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