catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/impl/InterfaceLifecycleOperation.java

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