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