gerrit.onap Code Review - sdc.git/blob

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * SDC
   4  * ================================================================================
   5  * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
   6  * ================================================================================
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  * ============LICENSE_END=========================================================
  19  */
  20
  21 package org.openecomp.sdc.be.model.operations.impl;
  22
  23 import fj.data.Either;
  24 import org.apache.commons.lang3.tuple.ImmutablePair;
  25 import org.openecomp.sdc.be.dao.graph.datatype.GraphEdge;
  26 import org.openecomp.sdc.be.dao.graph.datatype.GraphRelation;
  27 import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus;
  28 import org.openecomp.sdc.be.dao.neo4j.GraphEdgeLabels;
  29 import org.openecomp.sdc.be.dao.neo4j.GraphPropertiesDictionary;
  30 import org.openecomp.sdc.be.dao.janusgraph.JanusGraphGenericDao;
  31 import org.openecomp.sdc.be.datatypes.elements.InterfaceDataDefinition;
  32 import org.openecomp.sdc.be.datatypes.elements.OperationDataDefinition;
  33 import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
  34 import org.openecomp.sdc.be.model.ArtifactDefinition;
  35 import org.openecomp.sdc.be.model.InterfaceDefinition;
  36 import org.openecomp.sdc.be.model.Operation;
  37 import org.openecomp.sdc.be.model.operations.api.IInterfaceLifecycleOperation;
  38 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
  39 import org.openecomp.sdc.be.resources.data.ArtifactData;
  40 import org.openecomp.sdc.be.resources.data.InterfaceData;
  41 import org.openecomp.sdc.be.resources.data.OperationData;
  42 import org.openecomp.sdc.be.resources.data.ResourceMetadataData;
  43 import org.openecomp.sdc.common.log.wrappers.Logger;
  44 import org.springframework.stereotype.Component;
  45
  46 import java.util.*;
  47 import java.util.Map.Entry;
  48 import java.util.List;
  49 import java.util.Map;
  50 import java.util.Set;
  51 import java.util.stream.Collectors;
  52
  53 @Component("interface-operation")
  54 public class InterfaceLifecycleOperation implements IInterfaceLifecycleOperation {
  55
  56     private static final Logger log = Logger.getLogger(InterfaceLifecycleOperation.class.getName());
  57     private static final String FAILED_TO_FIND_OPERATION = "Failed to find operation  {} on interface {}";
  58     private static final String FAILED_TO_FIND_ARTIFACT = "Failed to add artifact {} to interface {}";
  59
  60     public InterfaceLifecycleOperation() {
  61         super();
  62     }
  63
  64     @javax.annotation.Resource
  65     private ArtifactOperation artifactOperation;
  66
  67     @javax.annotation.Resource
  68     private JanusGraphGenericDao janusGraphGenericDao;
  69
  70     @Override
  71     public Either<InterfaceDefinition, StorageOperationStatus> addInterfaceToResource(InterfaceDefinition interf, String resourceId, String interfaceName, boolean inTransaction) {
  72
  73         return createInterfaceOnResource(interf, resourceId, interfaceName, true, inTransaction);
  74
  75     }
  76
  77     private Either<OperationData, JanusGraphOperationStatus> addOperationToGraph(InterfaceDefinition interf, String opName, Operation op, InterfaceData interfaceData) {
  78
  79         op.setUniqueId(UniqueIdBuilder.buildPropertyUniqueId((String) interfaceData.getUniqueId(), opName));
  80         OperationData operationData = new OperationData(op);
  81
  82         log.debug("Before adding operation to graph {}", operationData);
  83         Either<OperationData, JanusGraphOperationStatus> createOpNodeResult = janusGraphGenericDao
  84             .createNode(operationData, OperationData.class);
  85         log.debug("After adding operation to graph {}", operationData);
  86
  87         if (createOpNodeResult.isRight()) {
  88             JanusGraphOperationStatus opStatus = createOpNodeResult.right().value();
  89             log.error("Failed to add operation {} to graph. status is {}", opName, opStatus);
  90             return Either.right(opStatus);
  91         }
  92
  93         Map<String, Object> props = new HashMap<>();
  94         props.put(GraphPropertiesDictionary.NAME.getProperty(), opName);
  95         Either<GraphRelation, JanusGraphOperationStatus> createRelResult = janusGraphGenericDao
  96             .createRelation(interfaceData, operationData, GraphEdgeLabels.INTERFACE_OPERATION, props);
  97
  98         if (createRelResult.isRight()) {
  99             JanusGraphOperationStatus operationStatus = createOpNodeResult.right().value();
 100             log.error("Failed to associate operation {} to property {} in graph. status is {}", interfaceData.getUniqueId(), opName, operationStatus);
 101
 102             return Either.right(operationStatus);
 103         }
 104
 105         return Either.left(createOpNodeResult.left().value());
 106
 107     }
 108
 109     private InterfaceDefinition convertInterfaceDataToInterfaceDefinition(InterfaceData interfaceData) {
 110
 111         log.debug("The object returned after create interface is {}", interfaceData);
 112
 113         return new InterfaceDefinition(interfaceData.getInterfaceDataDefinition());
 114
 115     }
 116
 117     private Operation convertOperationDataToOperation(OperationData operationData) {
 118
 119         log.debug("The object returned after create operation is {}", operationData);
 120
 121         return new Operation(operationData.getOperationDataDefinition());
 122
 123     }
 124
 125     private Either<InterfaceData, JanusGraphOperationStatus> addInterfaceToGraph(InterfaceDefinition interfaceInfo, String interfaceName, String resourceId) {
 126         InterfaceData interfaceData = new InterfaceData(interfaceInfo);
 127         ResourceMetadataData resourceData = new ResourceMetadataData();
 128         resourceData.getMetadataDataDefinition().setUniqueId(resourceId);
 129
 130         String interfaceNameSplitted = getShortInterfaceName(interfaceInfo);
 131         interfaceInfo.setUniqueId(UniqueIdBuilder.buildPropertyUniqueId(resourceId, interfaceNameSplitted));
 132
 133         Either<InterfaceData, JanusGraphOperationStatus> existInterface = janusGraphGenericDao
 134             .getNode(interfaceData.getUniqueIdKey(), interfaceData.getUniqueId(), InterfaceData.class);
 135         if (existInterface.isRight()) {
 136             return createInterfaceNodeAndRelation(interfaceNameSplitted, resourceId, interfaceData, resourceData);
 137         } else {
 138             log.debug("Interface {} already exist", interfaceData.getUniqueId());
 139             return Either.right(JanusGraphOperationStatus.ALREADY_EXIST);
 140         }
 141     }
 142
 143     private Either<InterfaceData, JanusGraphOperationStatus> createInterfaceNodeAndRelation(String interfaceName, String resourceId, InterfaceData interfaceData, ResourceMetadataData resourceData) {
 144         log.debug("Before adding interface to graph {}", interfaceData);
 145         Either<InterfaceData, JanusGraphOperationStatus> createNodeResult = janusGraphGenericDao
 146             .createNode(interfaceData, InterfaceData.class);
 147         log.debug("After adding property to graph {}", interfaceData);
 148
 149         if (createNodeResult.isRight()) {
 150             JanusGraphOperationStatus operationStatus = createNodeResult.right().value();
 151             log.error("Failed to add interface {} to graph. status is {}", interfaceName, operationStatus);
 152             return Either.right(operationStatus);
 153         }
 154
 155         Map<String, Object> props = new HashMap<>();
 156         props.put(GraphPropertiesDictionary.NAME.getProperty(), interfaceName);
 157         Either<GraphRelation, JanusGraphOperationStatus> createRelResult = janusGraphGenericDao
 158             .createRelation(resourceData, interfaceData, GraphEdgeLabels.INTERFACE, props);
 159         if (createRelResult.isRight()) {
 160             JanusGraphOperationStatus operationStatus = createNodeResult.right().value();
 161             log.error("Failed to associate resource {} to property {} in graph. status is {}", resourceId, interfaceName, operationStatus);
 162
 163             return Either.right(operationStatus);
 164         }
 165
 166         return Either.left(createNodeResult.left().value());
 167     }
 168
 169     private Either<OperationData, JanusGraphOperationStatus> createOperationNodeAndRelation(String operationName, OperationData operationData, InterfaceData interfaceData) {
 170         log.debug("Before adding operation to graph {}", operationData);
 171         Either<OperationData, JanusGraphOperationStatus> createNodeResult = janusGraphGenericDao
 172             .createNode(operationData, OperationData.class);
 173         log.debug("After adding operation to graph {}", interfaceData);
 174
 175         if (createNodeResult.isRight()) {
 176             JanusGraphOperationStatus operationStatus = createNodeResult.right().value();
 177             log.error("Failed to add interfoperationce {} to graph. status is {}", operationName, operationStatus);
 178             return Either.right(operationStatus);
 179         }
 180
 181         Map<String, Object> props = new HashMap<>();
 182         props.put(GraphPropertiesDictionary.NAME.getProperty(), operationName);
 183         Either<GraphRelation, JanusGraphOperationStatus> createRelResult = janusGraphGenericDao
 184             .createRelation(interfaceData, operationData, GraphEdgeLabels.INTERFACE_OPERATION, props);
 185         if (createRelResult.isRight()) {
 186             JanusGraphOperationStatus operationStatus = createNodeResult.right().value();
 187             log.error("Failed to associate operation {} to interface {} in graph. status is {}", operationName, interfaceData.getUniqueId(), operationStatus);
 188
 189             return Either.right(operationStatus);
 190         }
 191
 192         return Either.left(createNodeResult.left().value());
 193     }
 194
 195
 196     @Override
 197     public Either<Map<String, InterfaceDefinition>, StorageOperationStatus> getAllInterfacesOfResource(String resourceIdn, boolean recursively) {
 198         return getAllInterfacesOfResource(resourceIdn, recursively, false);
 199     }
 200
 201     @Override
 202     public Either<Map<String, InterfaceDefinition>, StorageOperationStatus> getAllInterfacesOfResource(String resourceId, boolean recursively, boolean inTransaction) {
 203         Either<Map<String, InterfaceDefinition>, StorageOperationStatus> result = null;
 204         Map<String, InterfaceDefinition> interfaces = new HashMap<>();
 205         try {
 206             if ((resourceId == null) || resourceId.isEmpty()) {
 207                 log.error("resourceId is empty");
 208                 result = Either.right(StorageOperationStatus.INVALID_ID);
 209                 return result;
 210             }
 211
 212             JanusGraphOperationStatus findInterfacesRes = JanusGraphOperationStatus.GENERAL_ERROR;
 213             if (recursively) {
 214                 findInterfacesRes = findAllInterfacesRecursively(resourceId, interfaces);
 215             } else {
 216                 findInterfacesRes = findAllInterfacesNotRecursively(resourceId, interfaces);
 217             }
 218             if (!findInterfacesRes.equals(JanusGraphOperationStatus.OK)) {
 219                 log.error("Failed to get all interfaces of resource {}. status is {}", resourceId, findInterfacesRes);
 220                 result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(findInterfacesRes));
 221                 return result;
 222             }
 223             result = Either.left(interfaces);
 224             return result;
 225         } finally {
 226             if (!inTransaction) {
 227                 if (result == null || result.isRight()) {
 228                     log.error("Going to execute rollback on graph.");
 229                     janusGraphGenericDao.rollback();
 230                 } else {
 231                     log.debug("Going to execute commit on graph.");
 232                     janusGraphGenericDao.commit();
 233                 }
 234             }
 235         }
 236     }
 237
 238     private JanusGraphOperationStatus findAllInterfacesNotRecursively(String resourceId, Map<String, InterfaceDefinition> interfaces) {
 239         Either<List<ImmutablePair<InterfaceData, GraphEdge>>, JanusGraphOperationStatus> interfaceNodes = janusGraphGenericDao
 240             .getChildrenNodes(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.Resource), resourceId, GraphEdgeLabels.INTERFACE,
 241                 NodeTypeEnum.Interface, InterfaceData.class);
 242
 243         if (interfaceNodes.isRight()) {
 244             JanusGraphOperationStatus status = interfaceNodes.right().value();
 245             if (status != JanusGraphOperationStatus.NOT_FOUND) {
 246                 return status;
 247             }
 248         } else {
 249             List<ImmutablePair<InterfaceData, GraphEdge>> interfaceList = interfaceNodes.left().value();
 250             if (interfaceList != null) {
 251                 for (ImmutablePair<InterfaceData, GraphEdge> interfacePair : interfaceList) {
 252                     String interfaceUniqueId = (String) interfacePair.getKey().getUniqueId();
 253                     Either<String, JanusGraphOperationStatus> interfaceNameRes = getPropertyValueFromEdge(interfacePair.getValue(), GraphPropertiesDictionary.NAME);
 254                     if (interfaceNameRes.isRight()) {
 255                         log.error("The requirement name is missing on the edge of requirement {}", interfaceUniqueId);
 256                         return interfaceNameRes.right().value();
 257                     }
 258                     String interfaceName = interfaceNameRes.left().value();
 259                     Either<InterfaceDefinition, JanusGraphOperationStatus> interfaceDefRes = getNonRecursiveInterface(interfacePair.getKey());
 260                     if (interfaceDefRes.isRight()) {
 261                         JanusGraphOperationStatus status = interfaceDefRes.right().value();
 262                         log.error("Failed to get interface actions of interface {}", interfaceUniqueId);
 263                         return status;
 264                     }
 265
 266                     InterfaceDefinition interfaceDefinition = interfaceDefRes.left().value();
 267                     if (interfaces.containsKey(interfaceName)) {
 268                         log.debug("The interface {} was already defined in dervied resource. add not overriden operations", interfaceName);
 269                         InterfaceDefinition existInterface = interfaces.get(interfaceName);
 270                         addMissingOperationsToInterface(interfaceDefinition, existInterface);
 271                     } else {
 272                         interfaces.put(interfaceName, interfaceDefinition);
 273                     }
 274
 275                 }
 276             }
 277         }
 278         return JanusGraphOperationStatus.OK;
 279     }
 280
 281     public JanusGraphOperationStatus findAllInterfacesRecursively(String resourceId, Map<String, InterfaceDefinition> interfaces) {
 282         JanusGraphOperationStatus
 283             findAllInterfacesNotRecursively = findAllInterfacesNotRecursively(resourceId, interfaces);
 284         if (!findAllInterfacesNotRecursively.equals(JanusGraphOperationStatus.OK)) {
 285             log.error("failed to get interfaces for resource {}. status is {}", resourceId, findAllInterfacesNotRecursively);
 286         }
 287
 288         Either<ImmutablePair<ResourceMetadataData, GraphEdge>, JanusGraphOperationStatus> parentNodes = janusGraphGenericDao
 289             .getChild(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.Resource), resourceId, GraphEdgeLabels.DERIVED_FROM, NodeTypeEnum.Resource,
 290                 ResourceMetadataData.class);
 291
 292         if (parentNodes.isRight()) {
 293             JanusGraphOperationStatus parentNodesStatus = parentNodes.right().value();
 294             if (parentNodesStatus == JanusGraphOperationStatus.NOT_FOUND) {
 295                 log.debug("Finish to lookup for parnet interfaces");
 296                 return JanusGraphOperationStatus.OK;
 297             } else {
 298                 log.error("Failed to find parent interfaces of resource {}. status is {}", resourceId, parentNodesStatus);
 299                 return parentNodesStatus;
 300             }
 301         }
 302         ImmutablePair<ResourceMetadataData, GraphEdge> parentNodePair = parentNodes.left().value();
 303         String parentUniqueId = parentNodePair.getKey().getMetadataDataDefinition().getUniqueId();
 304         JanusGraphOperationStatus addParentIntStatus = findAllInterfacesRecursively(parentUniqueId, interfaces);
 305
 306         if (addParentIntStatus != JanusGraphOperationStatus.OK) {
 307             log.error("Failed to fetch all interfaces of resource {}", parentUniqueId);
 308             return addParentIntStatus;
 309         }
 310
 311         return JanusGraphOperationStatus.OK;
 312     }
 313
 314     private Either<String, JanusGraphOperationStatus> getPropertyValueFromEdge(GraphEdge edge, GraphPropertiesDictionary property) {
 315         Map<String, Object> edgeProps = edge.getProperties();
 316         String interfaceName = null;
 317         if (edgeProps != null) {
 318             interfaceName = (String) edgeProps.get(property.getProperty());
 319             if (interfaceName == null) {
 320                 return Either.right(JanusGraphOperationStatus.INVALID_ELEMENT);
 321             }
 322         } else {
 323             return Either.right(JanusGraphOperationStatus.INVALID_ELEMENT);
 324         }
 325         return Either.left(interfaceName);
 326     }
 327
 328     private Either<InterfaceDefinition, JanusGraphOperationStatus> getNonRecursiveInterface(InterfaceData interfaceData) {
 329
 330         log.debug("Going to fetch the operations associate to interface {}", interfaceData.getUniqueId());
 331         InterfaceDefinition interfaceDefinition = new InterfaceDefinition(interfaceData.getInterfaceDataDefinition());
 332
 333         String interfaceId = interfaceData.getUniqueId();
 334         Either<List<ImmutablePair<OperationData, GraphEdge>>, JanusGraphOperationStatus> operationsRes = janusGraphGenericDao
 335             .getChildrenNodes(GraphPropertiesDictionary.UNIQUE_ID.getProperty(), interfaceId, GraphEdgeLabels.INTERFACE_OPERATION,
 336                 NodeTypeEnum.InterfaceOperation, OperationData.class);
 337
 338         if (operationsRes.isRight()) {
 339             JanusGraphOperationStatus status = operationsRes.right().value();
 340             if (status != JanusGraphOperationStatus.NOT_FOUND) {
 341                 return Either.right(status);
 342             } else {
 343                 return Either.left(interfaceDefinition);
 344             }
 345         }
 346
 347         List<ImmutablePair<OperationData, GraphEdge>> operationList = operationsRes.left().value();
 348         if (operationList != null && !operationList.isEmpty()) {
 349             for (ImmutablePair<OperationData, GraphEdge> operationPair : operationList) {
 350                 Operation operation = new Operation(operationPair.getKey().getOperationDataDefinition());
 351                 Either<String, JanusGraphOperationStatus> operationNameRes = getPropertyValueFromEdge(operationPair.getValue(), GraphPropertiesDictionary.NAME);
 352                 if (operationNameRes.isRight()) {
 353                     log.error("The operation name is missing on the edge of operation {}", operationPair.getKey().getUniqueId());
 354                     return Either.right(operationNameRes.right().value());
 355                 }
 356                 String operationName = operationNameRes.left().value();
 357                 findOperationImplementation(operation);
 358                 interfaceDefinition.getOperations().put(operationName, operation);
 359             }
 360         }
 361
 362         return Either.left(interfaceDefinition);
 363     }
 364
 365     private StorageOperationStatus findOperationImplementation(Operation operation) {
 366
 367         String operationId = operation.getUniqueId();
 368         Either<Map<String, ArtifactDefinition>, StorageOperationStatus> artifactsRes = artifactOperation.getArtifacts(operationId, NodeTypeEnum.InterfaceOperation, true);
 369         if (artifactsRes.isRight() || artifactsRes.left().value() == null) {
 370             log.error("failed to get artifact from graph for operation id {}. status is {}", operationId, artifactsRes.right().value());
 371             return artifactsRes.right().value();
 372         } else {
 373             Map<String, ArtifactDefinition> artifacts = artifactsRes.left().value();
 374             Iterator<String> iter = artifacts.keySet().iterator();
 375
 376             if (iter.hasNext()) {
 377                 operation.setImplementation(artifacts.get(iter.next()));
 378             }
 379         }
 380         return StorageOperationStatus.OK;
 381     }
 382
 383     private StorageOperationStatus addMissingOperationsToInterface(InterfaceDefinition interfaceDefinition, InterfaceDefinition existInterface) {
 384         Map<String, Operation> existOperations = existInterface.getOperationsMap();
 385         Map<String, Operation> operations = interfaceDefinition.getOperationsMap();
 386         if (operations != null && !operations.isEmpty()) {
 387             Set<Entry<String, Operation>> operationsSet = operations.entrySet();
 388             for (Entry<String, Operation> operation : operationsSet) {
 389                 if (!existOperations.containsKey(operation.getKey())) {
 390                     existOperations.put(operation.getKey(), operation.getValue());
 391                 }
 392             }
 393         }
 394         return StorageOperationStatus.OK;
 395     }
 396
 397     @Override
 398     public Either<Operation, StorageOperationStatus> updateInterfaceOperation(String resourceId, String interfaceName, String operationName, Operation interf) {
 399
 400         return updateInterfaceOperation(resourceId, interfaceName, operationName, interf, false);
 401     }
 402
 403     @Override
 404     public Either<Operation, StorageOperationStatus> updateInterfaceOperation(String resourceId, String interfaceName, String operationName, Operation operation, boolean inTransaction) {
 405
 406         return updateOperationOnGraph(operation, resourceId, interfaceName, operationName);
 407     }
 408
 409     private Either<Operation, StorageOperationStatus> updateOperationOnGraph(Operation operation, String resourceId, String interfaceName, String operationName) {
 410
 411         Either<List<ImmutablePair<InterfaceData, GraphEdge>>, JanusGraphOperationStatus> childrenNodes = janusGraphGenericDao
 412             .getChildrenNodes(GraphPropertiesDictionary.UNIQUE_ID.getProperty(), resourceId, GraphEdgeLabels.INTERFACE, NodeTypeEnum.Interface,
 413                 InterfaceData.class);
 414
 415         if (childrenNodes.isRight()) {
 416             return updateOperationFromParentNode(operation, resourceId, interfaceName, operationName);
 417
 418         } else {
 419             return updateExistingOperation(resourceId, operation, interfaceName, operationName, childrenNodes);
 420
 421         }
 422
 423     }
 424
 425     private Either<Operation, StorageOperationStatus> updateExistingOperation(String resourceId, Operation operation, String interfaceName, String operationName,
 426             Either<List<ImmutablePair<InterfaceData, GraphEdge>>, JanusGraphOperationStatus> childrenNodes) {
 427         Operation newOperation = null;
 428         StorageOperationStatus storageOperationStatus = StorageOperationStatus.GENERAL_ERROR;
 429
 430         for (ImmutablePair<InterfaceData, GraphEdge> interfaceDataNode : childrenNodes.left().value()) {
 431
 432             GraphEdge interfaceEdge = interfaceDataNode.getRight();
 433             Map<String, Object> interfaceEdgeProp = interfaceEdge.getProperties();
 434             InterfaceData interfaceData = interfaceDataNode.getKey();
 435
 436             if (interfaceEdgeProp.get(GraphPropertiesDictionary.NAME.getProperty()).equals(interfaceName)) {
 437                 Either<List<ImmutablePair<OperationData, GraphEdge>>, JanusGraphOperationStatus> operationRes = janusGraphGenericDao
 438                     .getChildrenNodes(GraphPropertiesDictionary.UNIQUE_ID.getProperty(), (String) interfaceDataNode.getLeft().getUniqueId(),
 439                         GraphEdgeLabels.INTERFACE_OPERATION, NodeTypeEnum.InterfaceOperation, OperationData.class);
 440                 if (operationRes.isRight()) {
 441                     log.error(FAILED_TO_FIND_OPERATION, operationName, interfaceName);
 442                     return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(operationRes.right().value()));
 443                 } else {
 444                     List<ImmutablePair<OperationData, GraphEdge>> operations = operationRes.left().value();
 445                     for (ImmutablePair<OperationData, GraphEdge> operationPairEdge : operations) {
 446                         GraphEdge opEdge = operationPairEdge.getRight();
 447                         OperationData opData = operationPairEdge.getLeft();
 448                         Map<String, Object> opEdgeProp = opEdge.getProperties();
 449                         if (opEdgeProp.get(GraphPropertiesDictionary.NAME.getProperty()).equals(operationName)) {
 450                             ArtifactDefinition artifact = operation.getImplementationArtifact();
 451                             Either<ImmutablePair<ArtifactData, GraphEdge>, JanusGraphOperationStatus> artifactRes = janusGraphGenericDao
 452                                 .getChild(GraphPropertiesDictionary.UNIQUE_ID.getProperty(), (String) opData.getUniqueId(), GraphEdgeLabels.ARTIFACT_REF,
 453                                     NodeTypeEnum.ArtifactRef, ArtifactData.class);
 454                             Either<ArtifactDefinition, StorageOperationStatus> artStatus;
 455                             if (artifactRes.isRight()) {
 456                                 artStatus = artifactOperation.addArifactToComponent(artifact, (String) operationPairEdge.getLeft().getUniqueId(), NodeTypeEnum.InterfaceOperation, true, true);
 457                             } else {
 458                                 artStatus = artifactOperation.updateArifactOnResource(artifact, (String) operationPairEdge.getLeft().getUniqueId(), (String) artifactRes.left().value().getLeft().getUniqueId(), NodeTypeEnum.InterfaceOperation, true);
 459                             }
 460                             if (artStatus.isRight()) {
 461                                 janusGraphGenericDao.rollback();
 462                                 log.error(FAILED_TO_FIND_ARTIFACT, operationName, interfaceName);
 463                                 return Either.right(artStatus.right().value());
 464                             } else {
 465                                 newOperation = this.convertOperationDataToOperation(opData);
 466                                 newOperation.setImplementation(artStatus.left().value());
 467
 468                             }
 469
 470                         }
 471
 472                     }
 473                     if (newOperation == null) {
 474                         Either<InterfaceData, JanusGraphOperationStatus> parentInterfaceStatus = findInterfaceOnParentNode(resourceId, interfaceName);
 475                         if (parentInterfaceStatus.isRight()) {
 476                             log.debug("Interface {} not exist", interfaceName);
 477                             return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(parentInterfaceStatus.right().value()));
 478                         }
 479
 480                         InterfaceData parentInterfaceData = parentInterfaceStatus.left().value();
 481                         Either<List<ImmutablePair<OperationData, GraphEdge>>, JanusGraphOperationStatus> opRes = janusGraphGenericDao
 482                             .getChildrenNodes(GraphPropertiesDictionary.UNIQUE_ID.getProperty(), (String) parentInterfaceData.getUniqueId(),
 483                                 GraphEdgeLabels.INTERFACE_OPERATION, NodeTypeEnum.InterfaceOperation, OperationData.class);
 484                         if (opRes.isRight()) {
 485                             log.error(FAILED_TO_FIND_OPERATION, operationName, interfaceName);
 486                             return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(operationRes.right().value()));
 487
 488                         } else {
 489                             List<ImmutablePair<OperationData, GraphEdge>> parentOperations = opRes.left().value();
 490                             for (ImmutablePair<OperationData, GraphEdge> operationPairEdge : parentOperations) {
 491                                 GraphEdge opEdge = operationPairEdge.getRight();
 492                                 OperationData opData = operationPairEdge.getLeft();
 493                                 Map<String, Object> opEdgeProp = opEdge.getProperties();
 494                                 if (opEdgeProp.get(GraphPropertiesDictionary.NAME.getProperty()).equals(operationName)) {
 495                                     return copyAndCreateNewOperation(operation, interfaceName, operationName, null, interfaceData, operationRes, opData);
 496                                 }
 497                             }
 498                         }
 499
 500                     }
 501
 502                 }
 503
 504             } else {
 505                 // not found
 506                 storageOperationStatus = StorageOperationStatus.ARTIFACT_NOT_FOUND;
 507             }
 508
 509         }
 510         if (newOperation == null)
 511             return Either.right(storageOperationStatus);
 512         else
 513             return Either.left(newOperation);
 514     }
 515
 516     private Either<Operation, StorageOperationStatus> copyAndCreateNewOperation(Operation operation, String interfaceName, String operationName, Operation newOperation, InterfaceData interfaceData,
 517                                                                                 Either<List<ImmutablePair<OperationData, GraphEdge>>, JanusGraphOperationStatus> operationRes, OperationData opData) {
 518         OperationDataDefinition opDataInfo = opData.getOperationDataDefinition();
 519         OperationDataDefinition newOperationInfo = new OperationDataDefinition(opDataInfo);
 520         newOperationInfo.setUniqueId(UniqueIdBuilder.buildPropertyUniqueId(interfaceData.getUniqueId(), operationName.toLowerCase()));
 521         OperationData newopData = new OperationData(newOperationInfo);
 522         Either<OperationData, JanusGraphOperationStatus> operationStatus = createOperationNodeAndRelation(operationName, newopData, interfaceData);
 523         if (operationStatus.isRight()) {
 524             log.error("Failed to create operation  {} on interface {}", operationName, interfaceName);
 525             return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(operationRes.right().value()));
 526         }
 527         ArtifactDefinition artifact = operation.getImplementationArtifact();
 528         if (artifact != null) {
 529             Either<ArtifactDefinition, StorageOperationStatus> artStatus = artifactOperation.addArifactToComponent(artifact, (String) operationStatus.left().value().getUniqueId(), NodeTypeEnum.InterfaceOperation, true, true);
 530             if (artStatus.isRight()) {
 531                 janusGraphGenericDao.rollback();
 532                 log.error(FAILED_TO_FIND_ARTIFACT, operationName, interfaceName);
 533             } else {
 534                 newOperation = this.convertOperationDataToOperation(opData);
 535                 newOperation.setImplementation(artStatus.left().value());
 536
 537             }
 538         }
 539         return Either.left(newOperation);
 540     }
 541
 542     private Either<Operation, StorageOperationStatus> updateOperationFromParentNode(Operation operation, String resourceId, String interfaceName, String operationName) {
 543         // Operation newOperation = null;
 544         ResourceMetadataData resourceData = new ResourceMetadataData();
 545         resourceData.getMetadataDataDefinition().setUniqueId(resourceId);
 546         Either<InterfaceData, JanusGraphOperationStatus> parentInterfaceStatus = findInterfaceOnParentNode(resourceId, interfaceName);
 547         if (parentInterfaceStatus.isRight()) {
 548             log.debug("Interface {} not exist", interfaceName);
 549             return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(parentInterfaceStatus.right().value()));
 550         }
 551
 552         InterfaceData interfaceData = parentInterfaceStatus.left().value();
 553         InterfaceDataDefinition intDataDefinition = interfaceData.getInterfaceDataDefinition();
 554         InterfaceDataDefinition newInterfaceInfo = new InterfaceDataDefinition(intDataDefinition);
 555
 556         String interfaceNameSplitted = getShortInterfaceName(intDataDefinition);
 557
 558         newInterfaceInfo.setUniqueId(UniqueIdBuilder.buildPropertyUniqueId(resourceId, interfaceNameSplitted));
 559         InterfaceData updatedInterfaceData = new InterfaceData(newInterfaceInfo);
 560         Either<InterfaceData, JanusGraphOperationStatus> createStatus = createInterfaceNodeAndRelation(interfaceName, resourceId, updatedInterfaceData, resourceData);
 561         if (createStatus.isRight()) {
 562             log.debug("failed to create interface node  {} on resource  {}", interfaceName,  resourceId);
 563             return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(createStatus.right().value()));
 564         }
 565
 566         InterfaceData newInterfaceNode = createStatus.left().value();
 567         Either<GraphRelation, JanusGraphOperationStatus> createRelResult = janusGraphGenericDao
 568             .createRelation(newInterfaceNode, interfaceData, GraphEdgeLabels.DERIVED_FROM, null);
 569         if (createRelResult.isRight()) {
 570             JanusGraphOperationStatus operationStatus = createRelResult.right().value();
 571             log.error("Failed to associate interface {} to interface {} in graph. status is {}", interfaceData.getUniqueId(), newInterfaceNode.getUniqueId(),  operationStatus);
 572
 573             return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(operationStatus));
 574         }
 575         Either<List<ImmutablePair<OperationData, GraphEdge>>, JanusGraphOperationStatus> operationRes = janusGraphGenericDao
 576             .getChildrenNodes(GraphPropertiesDictionary.UNIQUE_ID.getProperty(), (String) interfaceData.getUniqueId(),
 577                 GraphEdgeLabels.INTERFACE_OPERATION, NodeTypeEnum.InterfaceOperation, OperationData.class);
 578         if (operationRes.isRight()) {
 579             log.error(FAILED_TO_FIND_OPERATION, operationName, interfaceName);
 580             return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(operationRes.right().value()));
 581
 582         } else {
 583             List<ImmutablePair<OperationData, GraphEdge>> operations = operationRes.left().value();
 584             for (ImmutablePair<OperationData, GraphEdge> operationPairEdge : operations) {
 585                 GraphEdge opEdge = operationPairEdge.getRight();
 586                 OperationData opData = operationPairEdge.getLeft();
 587                 Map<String, Object> opEdgeProp = opEdge.getProperties();
 588                 if (opEdgeProp.get(GraphPropertiesDictionary.NAME.getProperty()).equals(operationName)) {
 589
 590                     return copyAndCreateNewOperation(operation, interfaceName, operationName, null, // changed
 591                                                                                                     // from
 592                                                                                                     // newOperation
 593                             newInterfaceNode, operationRes, opData);
 594
 595                 }
 596             }
 597         }
 598         return Either.right(StorageOperationStatus.GENERAL_ERROR);
 599     }
 600
 601     private Either<InterfaceData, JanusGraphOperationStatus> findInterfaceOnParentNode(String resourceId, String interfaceName) {
 602
 603         Either<ImmutablePair<ResourceMetadataData, GraphEdge>, JanusGraphOperationStatus> parentRes = janusGraphGenericDao
 604             .getChild(GraphPropertiesDictionary.UNIQUE_ID.getProperty(), resourceId, GraphEdgeLabels.DERIVED_FROM, NodeTypeEnum.Resource,
 605                 ResourceMetadataData.class);
 606         if (parentRes.isRight()) {
 607             log.debug("interface {} not found ", interfaceName);
 608             return Either.right(parentRes.right().value());
 609         }
 610         ImmutablePair<ResourceMetadataData, GraphEdge> parenNode = parentRes.left().value();
 611
 612         Either<List<ImmutablePair<InterfaceData, GraphEdge>>, JanusGraphOperationStatus> childrenNodes = janusGraphGenericDao
 613             .getChildrenNodes(GraphPropertiesDictionary.UNIQUE_ID.getProperty(), parenNode.getKey().getMetadataDataDefinition().getUniqueId(),
 614                 GraphEdgeLabels.INTERFACE, NodeTypeEnum.Interface, InterfaceData.class);
 615         if (childrenNodes.isRight()) {
 616             return findInterfaceOnParentNode(parenNode.getKey().getMetadataDataDefinition().getUniqueId(), interfaceName);
 617
 618         } else {
 619             for (ImmutablePair<InterfaceData, GraphEdge> interfaceDataNode : childrenNodes.left().value()) {
 620
 621                 GraphEdge interfaceEdge = interfaceDataNode.getRight();
 622                 Map<String, Object> interfaceEdgeProp = interfaceEdge.getProperties();
 623
 624                 if (interfaceEdgeProp.get(GraphPropertiesDictionary.NAME.getProperty()).equals(interfaceName)) {
 625                     return Either.left(interfaceDataNode.getKey());
 626                 }
 627
 628             }
 629             return findInterfaceOnParentNode(parenNode.getKey().getMetadataDataDefinition().getUniqueId(), interfaceName);
 630         }
 631
 632     }
 633
 634     @Override
 635     public Either<InterfaceDefinition, StorageOperationStatus> createInterfaceOnResource(InterfaceDefinition interf, String resourceId, String interfaceName, boolean failIfExist, boolean inTransaction) {
 636         Either<InterfaceData, JanusGraphOperationStatus> status = addInterfaceToGraph(interf, interfaceName, resourceId);
 637         if (status.isRight()) {
 638             janusGraphGenericDao.rollback();
 639             log.error("Failed to add interface {} to resource {}", interfaceName, resourceId);
 640             return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status.right().value()));
 641         } else {
 642
 643             if (!inTransaction) {
 644                 janusGraphGenericDao.commit();
 645             }
 646             InterfaceData interfaceData = status.left().value();
 647
 648             InterfaceDefinition interfaceDefResult = convertInterfaceDataToInterfaceDefinition(interfaceData);
 649             Map<String, Operation> operations = interf.getOperationsMap();
 650             if (operations != null && !operations.isEmpty()) {
 651                 Set<String> opNames = operations.keySet();
 652                 Map<String, Operation> newOperations = new HashMap<>();
 653                 for (String operationName : opNames) {
 654
 655                     Operation op = operations.get(operationName);
 656                     Either<OperationData, JanusGraphOperationStatus> opStatus = addOperationToGraph(interf, operationName, op, interfaceData);
 657                     if (status.isRight()) {
 658                         janusGraphGenericDao.rollback();
 659                         log.error("Failed to add operation {} to interface {}", operationName, interfaceName);
 660                     } else if (status.isLeft()) {
 661                         if (!inTransaction) {
 662                             janusGraphGenericDao.commit();
 663                         }
 664                         OperationData opData = opStatus.left().value();
 665                         Operation newOperation = this.convertOperationDataToOperation(opData);
 666
 667                         ArtifactDefinition art = op.getImplementationArtifact();
 668                         if (art != null) {
 669                             Either<ArtifactDefinition, StorageOperationStatus> artRes = artifactOperation.addArifactToComponent(art, (String) opData.getUniqueId(), NodeTypeEnum.InterfaceOperation, failIfExist, true);
 670                             if (artRes.isRight()) {
 671                                 janusGraphGenericDao.rollback();
 672                                 log.error(FAILED_TO_FIND_ARTIFACT, operationName, interfaceName);
 673                             } else {
 674                                 newOperation.setImplementation(artRes.left().value());
 675                             }
 676                             newOperations.put(operationName, newOperation);
 677                         }
 678                     }
 679                 }
 680                 interfaceDefResult.setOperationsMap(newOperations);
 681             }
 682             log.debug("The returned InterfaceDefintion is {}", interfaceDefResult);
 683             return Either.left(interfaceDefResult);
 684         }
 685
 686     }
 687
 688     @Override
 689     public Either<Operation, StorageOperationStatus> deleteInterfaceOperation(String resourceId, String interfaceName, String operationId, boolean inTransaction) {
 690
 691         Either<Operation, JanusGraphOperationStatus> status = removeOperationOnGraph(resourceId, interfaceName, operationId);
 692         if (status.isRight()) {
 693             if (!inTransaction) {
 694                 janusGraphGenericDao.rollback();
 695             }
 696             log.error("Failed to delete operation {} of interface {} resource {}", operationId, interfaceName, resourceId);
 697             return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status.right().value()));
 698         } else {
 699             if (!inTransaction) {
 700                 janusGraphGenericDao.commit();
 701             }
 702
 703             Operation opDefResult = status.left().value();
 704             log.debug("The returned Operation is {}", opDefResult);
 705             return Either.left(opDefResult);
 706         }
 707
 708     }
 709
 710     private Either<Operation, JanusGraphOperationStatus> removeOperationOnGraph(String resourceId, String interfaceName, String operationId) {
 711         log.debug("Before deleting operation from graph {}", operationId);
 712
 713         Either<List<ImmutablePair<InterfaceData, GraphEdge>>, JanusGraphOperationStatus> childrenNodes = janusGraphGenericDao
 714             .getChildrenNodes(GraphPropertiesDictionary.UNIQUE_ID.getProperty(), resourceId, GraphEdgeLabels.INTERFACE, NodeTypeEnum.Interface,
 715                 InterfaceData.class);
 716
 717         if (childrenNodes.isRight()) {
 718             log.debug("Not found interface {}", interfaceName);
 719             return Either.right(childrenNodes.right().value());
 720         }
 721         OperationData opData = null;
 722         for (ImmutablePair<InterfaceData, GraphEdge> interfaceDataNode : childrenNodes.left().value()) {
 723
 724             GraphEdge interfaceEdge = interfaceDataNode.getRight();
 725             Map<String, Object> interfaceEdgeProp = interfaceEdge.getProperties();
 726
 727             String interfaceSplitedName = splitType(interfaceName);
 728
 729             if (interfaceEdgeProp.get(GraphPropertiesDictionary.NAME.getProperty()).equals(interfaceSplitedName)) {
 730                 Either<List<ImmutablePair<OperationData, GraphEdge>>, JanusGraphOperationStatus> operationRes = janusGraphGenericDao
 731                     .getChildrenNodes(GraphPropertiesDictionary.UNIQUE_ID.getProperty(), (String) interfaceDataNode.getLeft().getUniqueId(),
 732                         GraphEdgeLabels.INTERFACE_OPERATION, NodeTypeEnum.InterfaceOperation, OperationData.class);
 733                 if (operationRes.isRight()) {
 734                     log.error("Failed to find operation {} on interface {}", operationId, interfaceName);
 735                     return Either.right(operationRes.right().value());
 736                 }
 737                 List<ImmutablePair<OperationData, GraphEdge>> operations = operationRes.left().value();
 738
 739                 for (ImmutablePair<OperationData, GraphEdge> operationPairEdge : operations) {
 740
 741                     opData = operationPairEdge.getLeft();
 742                     if (opData.getUniqueId().equals(operationId)) {
 743
 744                         Either<ImmutablePair<ArtifactData, GraphEdge>, JanusGraphOperationStatus> artifactRes = janusGraphGenericDao
 745                             .getChild(GraphPropertiesDictionary.UNIQUE_ID.getProperty(), (String) operationPairEdge.getLeft().getUniqueId(),
 746                                 GraphEdgeLabels.ARTIFACT_REF, NodeTypeEnum.ArtifactRef, ArtifactData.class);
 747                         Either<ArtifactDefinition, StorageOperationStatus> arStatus = null;
 748                         if (artifactRes.isLeft()) {
 749                             ArtifactData arData = artifactRes.left().value().getKey();
 750                             arStatus = artifactOperation.removeArifactFromResource((String) operationPairEdge.getLeft().getUniqueId(), (String) arData.getUniqueId(), NodeTypeEnum.InterfaceOperation, true, true);
 751                             if (arStatus.isRight()) {
 752                                 log.debug("failed to delete artifact {}", arData.getUniqueId());
 753                                 return Either.right(JanusGraphOperationStatus.INVALID_ID);
 754                             }
 755                         }
 756                         Either<OperationData, JanusGraphOperationStatus> deleteOpStatus = janusGraphGenericDao
 757                             .deleteNode(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.InterfaceOperation), opData.getUniqueId(), OperationData.class);
 758                         if (deleteOpStatus.isRight()) {
 759                             log.debug("failed to delete operation {}", opData.getUniqueId());
 760                             return Either.right(JanusGraphOperationStatus.INVALID_ID);
 761                         }
 762                         opData = deleteOpStatus.left().value();
 763                         Operation operation = new Operation(opData.getOperationDataDefinition());
 764                         if (arStatus != null) {
 765                             operation.setImplementation(arStatus.left().value());
 766                         }
 767                         if (operations.size() <= 1) {
 768                             Either<InterfaceData, JanusGraphOperationStatus> deleteInterfaceStatus = janusGraphGenericDao
 769                                 .deleteNode(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.Interface), interfaceDataNode.left.getUniqueId(), InterfaceData.class);
 770                             if (deleteInterfaceStatus.isRight()) {
 771                                 log.debug("failed to delete interface {}", interfaceDataNode.left.getUniqueId());
 772                                 return Either.right(JanusGraphOperationStatus.INVALID_ID);
 773                             }
 774
 775                         }
 776
 777                         return Either.left(operation);
 778
 779                     }
 780                 }
 781             }
 782         }
 783
 784         log.debug("Not found operation {}", interfaceName);
 785         return Either.right(JanusGraphOperationStatus.INVALID_ID);
 786     }
 787
 788     private String splitType(String interfaceName) {
 789         String interfaceSplittedName;
 790         String[] packageName = interfaceName.split("\\.");
 791
 792         if (packageName.length == 0) {
 793             interfaceSplittedName = interfaceName;
 794         } else {
 795             interfaceSplittedName = packageName[packageName.length - 1];
 796         }
 797
 798         return interfaceSplittedName.toLowerCase();
 799     }
 800
 801     /**
 802      * FOR TEST ONLY
 803      *
 804      * @param janusGraphGenericDao
 805      */
 806     public void setJanusGraphGenericDao(JanusGraphGenericDao janusGraphGenericDao) {
 807         this.janusGraphGenericDao = janusGraphGenericDao;
 808     }
 809
 810     public void setArtifactOperation(ArtifactOperation artifactOperation) {
 811         this.artifactOperation = artifactOperation;
 812     }
 813
 814     @Override
 815     public Either<InterfaceDefinition, StorageOperationStatus> createInterfaceType(InterfaceDefinition interf, boolean inTransaction) {
 816         Either<InterfaceDefinition, StorageOperationStatus> result = null;
 817         try {
 818
 819             InterfaceData interfaceData = new InterfaceData(interf);
 820             interf.setUniqueId(interf.getType().toLowerCase());
 821
 822             Either<InterfaceData, JanusGraphOperationStatus> existInterface = janusGraphGenericDao
 823                 .getNode(interfaceData.getUniqueIdKey(), interfaceData.getUniqueId(), InterfaceData.class);
 824
 825             if (existInterface.isLeft()) {
 826                 // already exist
 827                 log.debug("Interface type already exist {}", interfaceData);
 828                 result = Either.right(StorageOperationStatus.ENTITY_ALREADY_EXISTS);
 829                 return result;
 830             }
 831
 832             log.debug("Before adding interface type to graph {}", interfaceData);
 833             Either<InterfaceData, JanusGraphOperationStatus> createNodeResult = janusGraphGenericDao
 834                 .createNode(interfaceData, InterfaceData.class);
 835             log.debug("After adding property type to graph {}", interfaceData);
 836
 837             if (createNodeResult.isRight()) {
 838                 JanusGraphOperationStatus operationStatus = createNodeResult.right().value();
 839                 log.error("Failed to add interface {} to graph. status is {}", interf.getType(), operationStatus);
 840                 result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(operationStatus));
 841                 return result;
 842             }
 843
 844             InterfaceDefinition interfaceDefResult = convertInterfaceDataToInterfaceDefinition(interfaceData);
 845             Map<String, Operation> operations = interf.getOperationsMap();
 846
 847             if (operations != null && !operations.isEmpty()) {
 848                 Map<String, Operation> newOperations = new HashMap<>();
 849
 850                 for (Map.Entry<String, Operation> operation : operations.entrySet()) {
 851                     Either<OperationData, JanusGraphOperationStatus> opStatus = addOperationToGraph(interf, operation.getKey(), operation.getValue(), interfaceData);
 852                     if (opStatus.isRight()) {
 853                         janusGraphGenericDao.rollback();
 854                         log.error("Failed to add operation {} to interface {}", operation.getKey(), interf.getType());
 855
 856                         result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(opStatus.right().value()));
 857                         return result;
 858                     } else {
 859                         OperationData opData = opStatus.left().value();
 860                         Operation newOperation = this.convertOperationDataToOperation(opData);
 861                         newOperations.put(operation.getKey(), newOperation);
 862                     }
 863                 }
 864                 interfaceDefResult.setOperationsMap(newOperations);
 865             }
 866             result = Either.left(interfaceDefResult);
 867             return result;
 868         } finally {
 869             if (!inTransaction) {
 870                 if (result == null || result.isRight()) {
 871                     log.error("Going to execute rollback on graph.");
 872                     janusGraphGenericDao.rollback();
 873                 } else {
 874                     log.debug("Going to execute commit on graph.");
 875                     janusGraphGenericDao.commit();
 876                 }
 877             }
 878         }
 879
 880     }
 881
 882     @Override
 883     public Either<InterfaceDefinition, StorageOperationStatus> getInterface(String interfaceId) {
 884         Either<InterfaceData, JanusGraphOperationStatus> getResult = janusGraphGenericDao
 885             .getNode(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.Interface), interfaceId, InterfaceData.class);
 886         if (getResult.isLeft()) {
 887             InterfaceData interfaceData = getResult.left().value();
 888             return Either.left(convertInterfaceDataToInterfaceDefinition(interfaceData));
 889         } else {
 890             JanusGraphOperationStatus janusGraphStatus = getResult.right().value();
 891             log.debug("Node with id {} was not found in the graph. status: {}", interfaceId, janusGraphStatus);
 892             StorageOperationStatus storageOperationStatus = DaoStatusConverter.convertJanusGraphStatusToStorageStatus(janusGraphStatus);
 893             return Either.right(storageOperationStatus);
 894         }
 895     }
 896
 897     public String getShortInterfaceName(InterfaceDataDefinition interfaceDefinition) {
 898         String[] packageName = interfaceDefinition.getType().split("\\.");
 899         String interfaceName;
 900         if (packageName.length == 0) {
 901             interfaceName = interfaceDefinition.getType();
 902         } else {
 903             interfaceName = packageName[packageName.length - 1];
 904         }
 905         return interfaceName.toLowerCase();
 906     }
 907
 908     public Either<InterfaceDefinition, StorageOperationStatus> createInterfaceType(InterfaceDefinition interf) {
 909         return createInterfaceType(interf, false);
 910     }
 911
 912     @Override
 913     public Either<Map<String, InterfaceDefinition>, StorageOperationStatus> getAllInterfaceLifecycleTypes() {
 914
 915         Either<List<InterfaceData>, JanusGraphOperationStatus> allInterfaceLifecycleTypes =
 916             janusGraphGenericDao
 917                 .getByCriteria(NodeTypeEnum.Interface, Collections.emptyMap(), InterfaceData.class);
 918         if (allInterfaceLifecycleTypes.isRight()) {
 919             return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus
 920                 (allInterfaceLifecycleTypes.right().value()));
 921         }
 922
 923         Map<String, InterfaceDefinition> interfaceTypes = new HashMap<>();
 924         List<InterfaceData> interfaceDataList = allInterfaceLifecycleTypes.left().value();
 925         List<InterfaceDefinition> interfaceDefinitions = interfaceDataList.stream()
 926             .map(this::convertInterfaceDataToInterfaceDefinition)
 927             .filter(interfaceDefinition -> interfaceDefinition.getUniqueId().equalsIgnoreCase((interfaceDefinition.getType())))
 928             .collect(Collectors.toList());
 929
 930         for (InterfaceDefinition interfaceDefinition : interfaceDefinitions) {
 931             Either<List<ImmutablePair<OperationData, GraphEdge>>, JanusGraphOperationStatus>
 932                     childrenNodes = janusGraphGenericDao.getChildrenNodes(GraphPropertiesDictionary.UNIQUE_ID.getProperty(),
 933                     interfaceDefinition.getUniqueId(), GraphEdgeLabels.INTERFACE_OPERATION, NodeTypeEnum.InterfaceOperation, OperationData.class);
 934             if (childrenNodes.isLeft()) {
 935                 Map<String, OperationDataDefinition> operationsDataDefinitionMap = new HashMap<>();
 936                 for(ImmutablePair<OperationData, GraphEdge> operation : childrenNodes.left().value()) {
 937                     OperationData operationData = operation.getLeft();
 938                     operationsDataDefinitionMap.put(operationData.getUniqueId(), operationData.getOperationDataDefinition());
 939                 }
 940                 interfaceDefinition.setOperations(operationsDataDefinitionMap);
 941             }
 942             interfaceTypes.put(interfaceDefinition.getUniqueId(), interfaceDefinition);
 943         }
 944         return Either.left(interfaceTypes);
 945     }
 946 }