gerrit.onap Code Review - sdc.git/blob

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