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.ArrayList;
  24 import java.util.HashMap;
  25 import java.util.List;
  26 import java.util.Map;
  27 import java.util.function.Function;
  28 import java.util.stream.Collectors;
  29
  30 import org.apache.commons.lang3.tuple.ImmutablePair;
  31 import org.apache.tinkerpop.gremlin.structure.Edge;
  32 import org.openecomp.sdc.be.dao.graph.datatype.GraphEdge;
  33 import org.openecomp.sdc.be.dao.graph.datatype.GraphRelation;
  34 import org.openecomp.sdc.be.dao.neo4j.GraphEdgeLabels;
  35 import org.openecomp.sdc.be.dao.neo4j.GraphPropertiesDictionary;
  36 import org.openecomp.sdc.be.dao.titan.TitanOperationStatus;
  37 import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
  38 import org.openecomp.sdc.be.model.CapabilityDefinition;
  39 import org.openecomp.sdc.be.model.ComponentInstanceProperty;
  40 import org.openecomp.sdc.be.model.DataTypeDefinition;
  41 import org.openecomp.sdc.be.model.PropertyDefinition;
  42 import org.openecomp.sdc.be.model.operations.api.ICapabilityInstanceOperation;
  43 import org.openecomp.sdc.be.resources.data.CapabilityData;
  44 import org.openecomp.sdc.be.resources.data.CapabilityInstData;
  45 import org.openecomp.sdc.be.resources.data.ComponentInstanceData;
  46 import org.openecomp.sdc.be.resources.data.PropertyData;
  47 import org.openecomp.sdc.be.resources.data.PropertyValueData;
  48 import org.openecomp.sdc.be.resources.data.UniqueIdData;
  49 import org.openecomp.sdc.common.datastructure.Wrapper;
  50 import org.slf4j.Logger;
  51 import org.slf4j.LoggerFactory;
  52 import org.springframework.beans.factory.annotation.Autowired;
  53 import org.springframework.stereotype.Component;
  54
  55 import com.thinkaurelius.titan.core.TitanVertex;
  56
  57 import fj.data.Either;
  58
  59 /**
  60  * public class CapabilityInstanceOperation provides methods for CRUD operations for CapabilityInstance on component instance level
  61  *
  62  * @author ns019t
  63  *
  64  */
  65 @Component("capability-instance-operation")
  66 public class CapabilityInstanceOperation extends AbstractOperation implements ICapabilityInstanceOperation {
  67
  68         private static Logger log = LoggerFactory.getLogger(CapabilityOperation.class.getName());
  69
  70         @Autowired
  71         private PropertyOperation propertyOperation;
  72
  73         @Autowired
  74         private CapabilityOperation capabilityOperation;
  75
  76         /**
  77          * String constants for logger
  78          */
  79         private String statusIs = ". status is ";
  80         private String dot = ".";
  81         private String onGraph = " on graph ";
  82         private String ofRI = " of resource instance ";
  83         private String toCapability = " to capability ";
  84         private String toCI = " to capability instance ";
  85         private String toProperty = " to property ";
  86         private String forRI = " for resource instance ";
  87         private String failedCreateCI = "Failed to create capability instance of capability ";
  88         private String failedAddProperties = "Failed to add properties to capability instance ";
  89         private String ofCI = " of component instance ";
  90         private String failedDeletePropertyValues = "Failed to delete property values of capability instance ";
  91         private String toValue = " to property value ";
  92         private String fromRI = " from resource instance ";
  93
  94         /**
  95          * create capability instance of capability with property values for resource instance
  96          *
  97          * @param resourceInstanceId
  98          * @param capabilityId
  99          * @param propertyValues
 100          * @param validateCapabilityInstExistence
 101          * @param capabilityName
 102          * @return
 103          */
 104         @Override
 105         public Either<Map<CapabilityInstData, List<PropertyValueData>>, TitanOperationStatus> createCapabilityInstanceOfCapabilityWithPropertyValuesForResourceInstance(String resourceInstanceId, String capabilityId, String capabilityName,
 106                         List<ComponentInstanceProperty> propertyValues, boolean validateCapabilityInstExistence) {
 107                 Wrapper<TitanOperationStatus> errorWrapper = new Wrapper<>();
 108                 Wrapper<CapabilityData> overrideCapabilityDataWrapper = new Wrapper<>();
 109                 Wrapper<CapabilityDefinition> overrideCapabilityDefinitionWrapper = new Wrapper<>();
 110                 Either<CapabilityInstData, TitanOperationStatus> createCapabilityRes = null;
 111                 CapabilityInstData createdCapabilityInstance = null;
 112
 113                 Wrapper<Map<String, PropertyDefinition>> defaultPropertiesWrapper = new Wrapper<>();
 114                 Either<ImmutablePair<CapabilityData, GraphEdge>, TitanOperationStatus> getCapabilityRes = null;
 115                 Either<CapabilityDefinition, TitanOperationStatus> getCapabilityDefinitionRes = null;
 116                 Either<List<PropertyValueData>, TitanOperationStatus> addPropertyValuesRes = null;
 117                 Wrapper<String> createdCapabilityInstanceIdWrapper = new Wrapper<>();
 118                 if (validateCapabilityInstExistence) {
 119                         validateCapabilityInstanceExistence(resourceInstanceId, capabilityId, errorWrapper);
 120                 }
 121                 if (errorWrapper.isEmpty()) {
 122                         getCapabilityRes = getCapabilitiesOfResourceInstance(resourceInstanceId, capabilityId, capabilityName, errorWrapper);
 123                 }
 124                 if (errorWrapper.isEmpty()) {
 125                         getCapabilityDefinitionRes = getCapabiityDefinition(resourceInstanceId, capabilityId, errorWrapper, overrideCapabilityDataWrapper, getCapabilityRes);
 126                 }
 127                 if (errorWrapper.isEmpty()) {
 128                         createCapabilityRes = createCapabilityInstanceOnGraph(resourceInstanceId, capabilityId, errorWrapper, overrideCapabilityDataWrapper, overrideCapabilityDefinitionWrapper, getCapabilityDefinitionRes);
 129                 }
 130                 if (errorWrapper.isEmpty() && overrideCapabilityDefinitionWrapper.getInnerElement().getProperties() != null) {
 131                         createdCapabilityInstance = validateCapabilityInstanceProperties(resourceInstanceId, propertyValues, errorWrapper, overrideCapabilityDefinitionWrapper, createCapabilityRes, defaultPropertiesWrapper, createdCapabilityInstanceIdWrapper);
 132                 }
 133                 if (errorWrapper.isEmpty()) {
 134                         addPropertyValuesRes = addPropertyValueToCapabilityInstance(resourceInstanceId, propertyValues, errorWrapper, createCapabilityRes, defaultPropertiesWrapper, createdCapabilityInstanceIdWrapper);
 135                 }
 136                 Either<Map<CapabilityInstData, List<PropertyValueData>>, TitanOperationStatus> result;
 137                 if (errorWrapper.isEmpty()) {
 138                         Map<CapabilityInstData, List<PropertyValueData>> resultMap = new HashMap<>();
 139                         resultMap.put(createdCapabilityInstance, addPropertyValuesRes.left().value());
 140                         result = Either.left(resultMap);
 141                 } else {
 142                         result = Either.right(errorWrapper.getInnerElement());
 143                 }
 144                 return result;
 145         }
 146
 147         @Override
 148         public TitanOperationStatus createCapabilityInstanceOfCapabilityWithPropertyValuesForResourceInstance(TitanVertex resourceInstanceVertex, String resourceInstanceId, String capabilityId, String capabilityName,
 149                         List<ComponentInstanceProperty> propertyValues, boolean validateCapabilityInstExistence) {
 150                 Wrapper<TitanOperationStatus> errorWrapper = new Wrapper<>();
 151                 Wrapper<TitanVertex> overrideCapabilityDataWrapper = new Wrapper<>();
 152                 Wrapper<CapabilityDefinition> overrideCapabilityDefinitionWrapper = new Wrapper<>();
 153                 Either<TitanVertex, TitanOperationStatus> createCapabilityRes = null;
 154                 TitanVertex createdCapabilityInstance = null;
 155
 156                 Wrapper<Map<String, PropertyDefinition>> defaultPropertiesWrapper = new Wrapper<>();
 157                 Either<ImmutablePair<TitanVertex, Edge>, TitanOperationStatus> getCapabilityRes = null;
 158                 Either<CapabilityDefinition, TitanOperationStatus> getCapabilityDefinitionRes = null;
 159                 TitanOperationStatus addPropertyValuesRes = null;
 160                 Wrapper<String> createdCapabilityInstanceIdWrapper = new Wrapper<>();
 161                 if (validateCapabilityInstExistence) {
 162                         validateCapabilityInstanceExistence(resourceInstanceVertex, resourceInstanceId, capabilityId, errorWrapper);
 163                 }
 164                 if (errorWrapper.isEmpty()) {
 165                         getCapabilityRes = getCapabilitiesOfResourceInstance(resourceInstanceVertex, resourceInstanceId, capabilityId, capabilityName, errorWrapper);
 166                 }
 167                 if (errorWrapper.isEmpty()) {
 168                         getCapabilityDefinitionRes = getCapabiityDefinitionByVertex(resourceInstanceId, capabilityId, errorWrapper, overrideCapabilityDataWrapper, getCapabilityRes);
 169                 }
 170                 if (errorWrapper.isEmpty()) {
 171                         createCapabilityRes = createCapabilityInstanceOnGraphByVertex(resourceInstanceVertex, resourceInstanceId, capabilityId, errorWrapper, overrideCapabilityDataWrapper, overrideCapabilityDefinitionWrapper, getCapabilityDefinitionRes);
 172                 }
 173                 if (errorWrapper.isEmpty() && overrideCapabilityDefinitionWrapper.getInnerElement().getProperties() != null) {
 174                         createdCapabilityInstance = validateCapabilityInstancePropertiesByVertex(resourceInstanceId, propertyValues, errorWrapper, overrideCapabilityDefinitionWrapper, createCapabilityRes.left().value(), defaultPropertiesWrapper,
 175                                         createdCapabilityInstanceIdWrapper);
 176                 }
 177                 if (errorWrapper.isEmpty()) {
 178                         addPropertyValuesRes = addPropertyValueToCapabilityInstanceByVertex(resourceInstanceId, propertyValues, errorWrapper, createCapabilityRes, defaultPropertiesWrapper, createdCapabilityInstanceIdWrapper);
 179                 }
 180
 181                 return addPropertyValuesRes;
 182         }
 183
 184         private Either<List<PropertyValueData>, TitanOperationStatus> addPropertyValueToCapabilityInstance(String resourceInstanceId, List<ComponentInstanceProperty> propertyValues, Wrapper<TitanOperationStatus> errorWrapper,
 185                         Either<CapabilityInstData, TitanOperationStatus> createCapabilityRes, Wrapper<Map<String, PropertyDefinition>> defaultPropertiesWrapper, Wrapper<String> createdCapabilityInstanceIdWrapper) {
 186                 Either<List<PropertyValueData>, TitanOperationStatus> addPropertyValuesRes;
 187                 log.debug("Before adding property values to capability instance {} dot", createdCapabilityInstanceIdWrapper.getInnerElement());
 188                 addPropertyValuesRes = addPropertyValuesToCapabilityInstance(createCapabilityRes.left().value(), propertyValues, defaultPropertiesWrapper.getInnerElement());
 189                 if (addPropertyValuesRes.isRight()) {
 190                         errorWrapper.setInnerElement(addPropertyValuesRes.right().value());
 191                         log.debug("failedAddProperties {} ofRI {} statusIs {} dot", createdCapabilityInstanceIdWrapper.getInnerElement(), resourceInstanceId, errorWrapper.getInnerElement());
 192                 }
 193                 log.debug("After adding property values to capability instance {} status is {}.", createdCapabilityInstanceIdWrapper.getInnerElement(), errorWrapper.getInnerElement());
 194                 return addPropertyValuesRes;
 195         }
 196
 197         private TitanOperationStatus addPropertyValueToCapabilityInstanceByVertex(String resourceInstanceId, List<ComponentInstanceProperty> propertyValues, Wrapper<TitanOperationStatus> errorWrapper,
 198                         Either<TitanVertex, TitanOperationStatus> createCapabilityRes, Wrapper<Map<String, PropertyDefinition>> defaultPropertiesWrapper, Wrapper<String> createdCapabilityInstanceIdWrapper) {
 199                 log.trace("Before adding property values to capability instance {}", createdCapabilityInstanceIdWrapper.getInnerElement());
 200                 TitanOperationStatus addPropertyValuesRes = addPropertyValuesToCapabilityInstance(createCapabilityRes.left().value(), propertyValues, defaultPropertiesWrapper.getInnerElement());
 201                 if (!addPropertyValuesRes.equals(TitanOperationStatus.OK)) {
 202                         errorWrapper.setInnerElement(addPropertyValuesRes);
 203                         log.debug("Failed to add properties to capability instance {} {} {} {} {}", createdCapabilityInstanceIdWrapper.getInnerElement(), ofRI, resourceInstanceId, statusIs, errorWrapper.getInnerElement());
 204                 }
 205                 log.trace("After adding property values to capability instance {} {} {}", createdCapabilityInstanceIdWrapper.getInnerElement(), statusIs, errorWrapper.getInnerElement());
 206                 return addPropertyValuesRes;
 207         }
 208
 209         private CapabilityInstData validateCapabilityInstanceProperties(String resourceInstanceId, List<ComponentInstanceProperty> propertyValues, Wrapper<TitanOperationStatus> errorWrapper,
 210                         Wrapper<CapabilityDefinition> overrideCapabilityDefinitionWrapper, Either<CapabilityInstData, TitanOperationStatus> createCapabilityRes, Wrapper<Map<String, PropertyDefinition>> defaultPropertiesWrapper,
 211                         Wrapper<String> createdCapabilityInstanceIdWrapper) {
 212                 CapabilityInstData createdCapabilityInstance;
 213                 createdCapabilityInstance = createCapabilityRes.left().value();
 214                 createdCapabilityInstanceIdWrapper.setInnerElement(createdCapabilityInstance.getUniqueId());
 215                 Map<String, PropertyDefinition> defaultProperties = overrideCapabilityDefinitionWrapper.getInnerElement().getProperties().stream().collect(Collectors.toMap(PropertyDefinition::getName, Function.identity()));
 216                 defaultPropertiesWrapper.setInnerElement(defaultProperties);
 217                 log.debug("Before validating property values of capability instance {}.", createdCapabilityInstanceIdWrapper.getInnerElement());
 218                 Either<Boolean, TitanOperationStatus> result = validateCapabilityInstanceProperties(defaultProperties, propertyValues);
 219                 if (result.isRight()) {
 220                         errorWrapper.setInnerElement(result.right().value());
 221                         log.debug("failedAddProperties {} ofRI {} statusIs {}.", createdCapabilityInstanceIdWrapper.getInnerElement(), resourceInstanceId, errorWrapper.getInnerElement());
 222                 }
 223                 log.debug("After validating property values of capability instance {} status is {}.", createdCapabilityInstanceIdWrapper.getInnerElement(), errorWrapper.getInnerElement());
 224                 return createdCapabilityInstance;
 225         }
 226
 227         private TitanVertex validateCapabilityInstancePropertiesByVertex(String resourceInstanceId, List<ComponentInstanceProperty> propertyValues, Wrapper<TitanOperationStatus> errorWrapper,
 228                         Wrapper<CapabilityDefinition> overrideCapabilityDefinitionWrapper, TitanVertex createCapabilityRes, Wrapper<Map<String, PropertyDefinition>> defaultPropertiesWrapper, Wrapper<String> createdCapabilityInstanceIdWrapper) {
 229                 String id = (String) titanGenericDao.getProperty(createCapabilityRes, GraphPropertiesDictionary.UNIQUE_ID.getProperty());
 230                 createdCapabilityInstanceIdWrapper.setInnerElement(id);
 231                 Map<String, PropertyDefinition> defaultProperties = overrideCapabilityDefinitionWrapper.getInnerElement().getProperties().stream().collect(Collectors.toMap(PropertyDefinition::getName, Function.identity()));
 232                 defaultPropertiesWrapper.setInnerElement(defaultProperties);
 233                 log.trace("Before validating property values of capability instance {}", createdCapabilityInstanceIdWrapper.getInnerElement());
 234                 Either<Boolean, TitanOperationStatus> result = validateCapabilityInstanceProperties(defaultProperties, propertyValues);
 235                 if (result.isRight()) {
 236                         errorWrapper.setInnerElement(result.right().value());
 237                         log.debug("Failed to add properties to capability instance {} {} {} {} {}", createdCapabilityInstanceIdWrapper.getInnerElement(), ofRI, resourceInstanceId, statusIs, errorWrapper.getInnerElement());
 238                 }
 239                 log.trace("After validating property values of capability instance {} {} {}", createdCapabilityInstanceIdWrapper.getInnerElement(), statusIs, errorWrapper.getInnerElement());
 240                 return createCapabilityRes;
 241         }
 242
 243         private Either<CapabilityInstData, TitanOperationStatus> createCapabilityInstanceOnGraph(String resourceInstanceId, String capabilityId, Wrapper<TitanOperationStatus> errorWrapper, Wrapper<CapabilityData> overrideCapabilityDataWrapper,
 244                         Wrapper<CapabilityDefinition> overrideCapabilityDefinitionWrapper, Either<CapabilityDefinition, TitanOperationStatus> getCapabilityDefinitionRes) {
 245                 Either<CapabilityInstData, TitanOperationStatus> createCapabilityRes;
 246                 log.debug("Before creating capability instance of capability {} on graph.", capabilityId);
 247                 overrideCapabilityDefinitionWrapper.setInnerElement(getCapabilityDefinitionRes.left().value());
 248                 CapabilityInstData capabilityInstance = buildCapabilityInstanceData(resourceInstanceId, overrideCapabilityDefinitionWrapper.getInnerElement());
 249                 createCapabilityRes = createCapabilityInstanceOnGraph(resourceInstanceId, overrideCapabilityDataWrapper.getInnerElement(), capabilityInstance);
 250                 if (createCapabilityRes.isRight()) {
 251                         errorWrapper.setInnerElement(createCapabilityRes.right().value());
 252                         log.debug("failedCreateCI {} ofRI {} statusIs {}.", capabilityId, resourceInstanceId, errorWrapper.getInnerElement());
 253                 }
 254                 log.debug("After creating capability instance of capability {} on graph. Status is {}", capabilityId, errorWrapper.getInnerElement());
 255                 return createCapabilityRes;
 256         }
 257
 258         private Either<TitanVertex, TitanOperationStatus> createCapabilityInstanceOnGraphByVertex(TitanVertex riVertex, String resourceInstanceId, String capabilityId, Wrapper<TitanOperationStatus> errorWrapper,
 259                         Wrapper<TitanVertex> overrideCapabilityDataWrapper, Wrapper<CapabilityDefinition> overrideCapabilityDefinitionWrapper, Either<CapabilityDefinition, TitanOperationStatus> getCapabilityDefinitionRes) {
 260                 Either<TitanVertex, TitanOperationStatus> createCapabilityRes;
 261                 log.trace("Before creating capability instance of capability {} {}", capabilityId, onGraph);
 262                 overrideCapabilityDefinitionWrapper.setInnerElement(getCapabilityDefinitionRes.left().value());
 263                 CapabilityInstData capabilityInstance = buildCapabilityInstanceData(resourceInstanceId, overrideCapabilityDefinitionWrapper.getInnerElement());
 264                 createCapabilityRes = createCapabilityInstanceOnGraph(riVertex, resourceInstanceId, overrideCapabilityDataWrapper.getInnerElement(), capabilityInstance);
 265                 if (createCapabilityRes.isRight()) {
 266                         errorWrapper.setInnerElement(createCapabilityRes.right().value());
 267                         log.debug("Failed to create capability instance of capability {} {} {} {} {} ", capabilityId, ofRI, resourceInstanceId, statusIs, errorWrapper.getInnerElement());
 268                 }
 269                 log.debug("After creating capability instance of capability {} {} {} {} {}", capabilityId, onGraph, statusIs, errorWrapper.getInnerElement());
 270                 return createCapabilityRes;
 271         }
 272
 273         private Either<CapabilityDefinition, TitanOperationStatus> getCapabiityDefinition(String resourceInstanceId, String capabilityId, Wrapper<TitanOperationStatus> errorWrapper, Wrapper<CapabilityData> overrideCapabilityDataWrapper,
 274                         Either<ImmutablePair<CapabilityData, GraphEdge>, TitanOperationStatus> getCapabilityRes) {
 275                 Either<CapabilityDefinition, TitanOperationStatus> getCapabilityDefinitionRes;
 276                 log.debug("Before getting capability definition {} forRI {}.", capabilityId, resourceInstanceId);
 277                 CapabilityData overrideCapabilityData = getCapabilityRes.left().value().getLeft();
 278                 overrideCapabilityDataWrapper.setInnerElement(overrideCapabilityData);
 279                 getCapabilityDefinitionRes = capabilityOperation.getCapabilityByCapabilityData(overrideCapabilityData);
 280                 if (getCapabilityDefinitionRes.isRight()) {
 281                         errorWrapper.setInnerElement(getCapabilityDefinitionRes.right().value());
 282                         log.debug("Failed to retrieve capability {} ofRI {} statusIs {}.", capabilityId, resourceInstanceId, errorWrapper.getInnerElement());
 283                 }
 284                 log.debug("After getting capability definition for {} forRI {} statusIs {}.", capabilityId, resourceInstanceId, errorWrapper.getInnerElement());
 285                 return getCapabilityDefinitionRes;
 286         }
 287
 288         private Either<CapabilityDefinition, TitanOperationStatus> getCapabiityDefinitionByVertex(String resourceInstanceId, String capabilityId, Wrapper<TitanOperationStatus> errorWrapper, Wrapper<TitanVertex> overrideCapabilityDataWrapper,
 289                         Either<ImmutablePair<TitanVertex, Edge>, TitanOperationStatus> getCapabilityRes) {
 290                 Either<CapabilityDefinition, TitanOperationStatus> getCapabilityDefinitionRes;
 291                 log.trace("Before getting capability definition {} {} {}", capabilityId, forRI, resourceInstanceId);
 292
 293                 TitanVertex overrideCapabilityData = getCapabilityRes.left().value().getLeft();
 294
 295                 overrideCapabilityDataWrapper.setInnerElement(overrideCapabilityData);
 296                 getCapabilityDefinitionRes = capabilityOperation.getCapabilityByCapabilityData(overrideCapabilityData);
 297                 if (getCapabilityDefinitionRes.isRight()) {
 298                         errorWrapper.setInnerElement(getCapabilityDefinitionRes.right().value());
 299                         log.debug("Failed to retrieve capability {} ofRI {} statusIs {}", capabilityId, resourceInstanceId, errorWrapper.getInnerElement());
 300                 }
 301                 log.debug("After getting capability definition for {} forRI {} statusIs {}.", capabilityId, resourceInstanceId, errorWrapper.getInnerElement());
 302                 return getCapabilityDefinitionRes;
 303         }
 304
 305         private Either<ImmutablePair<CapabilityData, GraphEdge>, TitanOperationStatus> getCapabilitiesOfResourceInstance(String resourceInstanceId, String capabilityId, String capabilityName, Wrapper<TitanOperationStatus> errorWrapper) {
 306                 Either<ImmutablePair<CapabilityData, GraphEdge>, TitanOperationStatus> getCapabilityRes;
 307                 log.debug("Before getting capability {} forRI {}.", capabilityId, resourceInstanceId);
 308                 Map<String, Object> props = new HashMap<>();
 309                 props.put(GraphPropertiesDictionary.NAME.getProperty(), capabilityName);
 310                 getCapabilityRes = titanGenericDao.getChildByEdgeCriteria(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.ResourceInstance), resourceInstanceId, GraphEdgeLabels.CALCULATED_CAPABILITY, NodeTypeEnum.Capability, CapabilityData.class, props);
 311                 if (getCapabilityRes.isRight()) {
 312                         errorWrapper.setInnerElement(getCapabilityRes.right().value());
 313                         log.debug("Failed to get capability {} ofRI {} statusIs {}.", capabilityId, resourceInstanceId, errorWrapper.getInnerElement());
 314                 }
 315                 log.debug("After getting capability for {} forRI {} statusIs {}.", capabilityId, resourceInstanceId, errorWrapper.getInnerElement());
 316                 return getCapabilityRes;
 317         }
 318
 319         private Either<ImmutablePair<TitanVertex, Edge>, TitanOperationStatus> getCapabilitiesOfResourceInstance(TitanVertex instanceVertex, String resourceInstanceId, String capabilityId, String capabilityName,
 320                         Wrapper<TitanOperationStatus> errorWrapper) {
 321                 Either<ImmutablePair<TitanVertex, Edge>, TitanOperationStatus> getCapabilityRes;
 322                 log.trace("Before getting capability {} {} {}", capabilityId, forRI, resourceInstanceId);
 323                 Map<String, Object> props = new HashMap<>();
 324                 props.put(GraphPropertiesDictionary.NAME.getProperty(), capabilityName);
 325                 getCapabilityRes = titanGenericDao.getChildByEdgeCriteria(instanceVertex, GraphEdgeLabels.CALCULATED_CAPABILITY, props);
 326                 if (getCapabilityRes.isRight()) {
 327                         errorWrapper.setInnerElement(getCapabilityRes.right().value());
 328                         log.debug("Failed to get capability {} {} {} {} {}", capabilityId, ofRI, resourceInstanceId, statusIs, errorWrapper.getInnerElement());
 329                 }
 330                 log.trace("After getting capability for {} {} {} {} {}", capabilityId, forRI, resourceInstanceId, statusIs, errorWrapper.getInnerElement());
 331                 return getCapabilityRes;
 332         }
 333
 334         private void validateCapabilityInstanceExistence(String resourceInstanceId, String capabilityId, Wrapper<TitanOperationStatus> errorWrapper) {
 335                 log.debug("Before validation of existence of capability instance of capability {} forRI {}.", capabilityId, resourceInstanceId);
 336                 boolean capabilityInstOfCapabilityAlreadyExists;
 337                 Either<Boolean, TitanOperationStatus> validateCapabilityInstExistenceRes = validateCapabilityInstExistence(resourceInstanceId, capabilityId);
 338                 if (validateCapabilityInstExistenceRes.isRight()) {
 339                         errorWrapper.setInnerElement(validateCapabilityInstExistenceRes.right().value());
 340                         log.debug("Failed to validate uniqueness of capability instance of capability {} ofRI {} statusIs {}.", capabilityId, resourceInstanceId, errorWrapper.getInnerElement());
 341                 } else {
 342                         capabilityInstOfCapabilityAlreadyExists = validateCapabilityInstExistenceRes.left().value();
 343                         if (capabilityInstOfCapabilityAlreadyExists) {
 344                                 errorWrapper.setInnerElement(TitanOperationStatus.ALREADY_EXIST);
 345                                 log.debug("failedCreateCI {} ofRI {} statusIs {}.", capabilityId, resourceInstanceId, errorWrapper.getInnerElement());
 346                         }
 347                 }
 348                 log.debug("After validation of existence of capability instance of capability {} forRI {} statusIs {}.", capabilityId, resourceInstanceId, errorWrapper.getInnerElement());
 349         }
 350
 351         private void validateCapabilityInstanceExistence(TitanVertex resourceInstanceVertex, String resourceInstanceId, String capabilityId, Wrapper<TitanOperationStatus> errorWrapper) {
 352                 log.trace("Before validation of existence of capability instance of capability {} {} {}", capabilityId, forRI, resourceInstanceId);
 353                 boolean capabilityInstOfCapabilityAlreadyExists;
 354                 Either<Boolean, TitanOperationStatus> validateCapabilityInstExistenceRes = validateCapabilityInstExistence(resourceInstanceId, capabilityId);
 355                 if (validateCapabilityInstExistenceRes.isRight()) {
 356                         errorWrapper.setInnerElement(validateCapabilityInstExistenceRes.right().value());
 357                         log.debug("Failed to validate uniqueness of capability instance of capability {} ofRI {} statusIs {}.", capabilityId, resourceInstanceId, errorWrapper.getInnerElement());
 358                 } else {
 359                         capabilityInstOfCapabilityAlreadyExists = validateCapabilityInstExistenceRes.left().value();
 360                         if (capabilityInstOfCapabilityAlreadyExists) {
 361                                 errorWrapper.setInnerElement(TitanOperationStatus.ALREADY_EXIST);
 362                                 log.debug("failedCreateCI {} ofRI {} statusIs {}.", capabilityId, resourceInstanceId, errorWrapper.getInnerElement());
 363                         }
 364                 }
 365                 log.debug("After validation of existence of capability instance of capability {} forRI {} statusIs {}.", capabilityId, resourceInstanceId, errorWrapper.getInnerElement());
 366         }
 367
 368         private Either<List<PropertyValueData>, TitanOperationStatus> addPropertyValuesToCapabilityInstance(CapabilityInstData createdCapabilityInstance, List<ComponentInstanceProperty> propertyValues, Map<String, PropertyDefinition> defaultProperties) {
 369                 TitanOperationStatus error = null;
 370                 List<PropertyValueData> createdPropertyValues = new ArrayList<>();
 371                 for (ComponentInstanceProperty property : propertyValues) {
 372                         log.debug("Before adding property value {} toCI {}.", property.getName(), createdCapabilityInstance.getUniqueId());
 373                         PropertyValueData propertyData = buildPropertyValueData(property.getName(), property.getType(), property.getValue(), createdCapabilityInstance.getUniqueId());
 374                         Either<PropertyValueData, TitanOperationStatus> addPropertyValueRes = addPropertyValueToCapabilityInstance(createdCapabilityInstance, propertyData, defaultProperties.get(property.getName()));
 375                         if (addPropertyValueRes.isRight()) {
 376                                 error = addPropertyValueRes.right().value();
 377                                 log.debug("Failed to add property to capability instance {} ofRI. StatusIs {}.", createdCapabilityInstance.getUniqueId(), error);
 378                                 break;
 379                         } else {
 380                                 createdPropertyValues.add(addPropertyValueRes.left().value());
 381                         }
 382                         log.debug("After adding property value {} toCI {} statusIs {}", property.getName(), createdCapabilityInstance.getUniqueId(), error);
 383                 }
 384                 if (error == null) {
 385                         return Either.left(createdPropertyValues);
 386                 }
 387                 return Either.right(error);
 388         }
 389
 390         private TitanOperationStatus addPropertyValuesToCapabilityInstance(TitanVertex createdCapabilityInstancevertex, List<ComponentInstanceProperty> propertyValues, Map<String, PropertyDefinition> defaultProperties) {
 391                 TitanOperationStatus error = null;
 392                 String id = (String) titanGenericDao.getProperty(createdCapabilityInstancevertex, GraphPropertiesDictionary.UNIQUE_ID.getProperty());
 393                 for (ComponentInstanceProperty property : propertyValues) {
 394                         log.trace("Before adding property value {} {} {}", property.getName(), toCI, id);
 395                         PropertyValueData propertyData = buildPropertyValueData(property.getName(), property.getType(), property.getValue(), id);
 396                         TitanOperationStatus addPropertyValueRes = addPropertyValueToCapabilityInstance(createdCapabilityInstancevertex, propertyData, defaultProperties.get(property.getName()), id);
 397                         if (!addPropertyValueRes.equals(TitanOperationStatus.OK)) {
 398                                 error = addPropertyValueRes;
 399                                 log.debug("Failed to add property to capability instance {} {} {} {}", id, ofRI, statusIs, error);
 400                                 break;
 401                         }
 402                         log.debug("After adding property value {} {} {} {} {}", property.getName(), toCI, id, statusIs, error);
 403                 }
 404                 if (error == null) {
 405                         return TitanOperationStatus.OK;
 406                 }
 407                 return error;
 408         }
 409
 410         private PropertyValueData buildPropertyValueData(String propertyName, String propertyType, String propertyValue, String capabilityInstanceId) {
 411                 PropertyValueData propertyData = new PropertyValueData();
 412                 String uniqueId = UniqueIdBuilder.buildPropertyValueUniqueId(capabilityInstanceId, propertyName);
 413                 Long creationTime = System.currentTimeMillis();
 414                 propertyData.setUniqueId(uniqueId);
 415                 propertyData.setValue(propertyValue);
 416                 propertyData.setType(propertyType);
 417                 propertyData.setCreationTime(creationTime);
 418                 propertyData.setModificationTime(creationTime);
 419                 return propertyData;
 420         }
 421
 422         private Either<PropertyValueData, TitanOperationStatus> addPropertyValueToCapabilityInstance(CapabilityInstData createdCapabilityInstance, PropertyValueData propertyValue, PropertyDefinition propertyDefinition) {
 423                 TitanOperationStatus error = null;
 424                 Map<String, Object> props = null;
 425                 Either<GraphRelation, TitanOperationStatus> createRelationRes;
 426                 PropertyValueData createdValue = null;
 427                 log.debug("Before creating property value node {} onGraph.", propertyValue.getUniqueId());
 428                 Either<PropertyValueData, TitanOperationStatus> createValueRes = titanGenericDao.createNode(propertyValue, PropertyValueData.class);
 429                 if (createValueRes.isRight()) {
 430                         error = createValueRes.right().value();
 431                         log.debug("Failed to create property value for capability instance {} ofRI statusIs {}.", createdCapabilityInstance.getUniqueId(), error);
 432                 }
 433                 log.debug("After creating property value node {} onGraph statusIs {}.", propertyValue.getUniqueId(), error);
 434                 if (error == null) {
 435                         log.debug("Before creating relation from property value node {} toCI {}.", propertyValue.getUniqueId(), createdCapabilityInstance.getUniqueId());
 436                         createdValue = createValueRes.left().value();
 437                         props = new HashMap<>();
 438                         props.put(GraphPropertiesDictionary.PROPERTY_NAME.name(), propertyDefinition.getName());
 439                         props.put(GraphPropertiesDictionary.PROPERTY_ID.name(), propertyDefinition.getUniqueId());
 440                         createRelationRes = titanGenericDao.createRelation(createdCapabilityInstance, createdValue, GraphEdgeLabels.PROPERTY_VALUE, props);
 441                         if (createRelationRes.isRight()) {
 442                                 error = createRelationRes.right().value();
 443                                 log.debug("Failed to create relation from capability instance {} toValue {} statusIs {}.", createdCapabilityInstance.getUniqueId(), createdValue.getUniqueId(), error);
 444                         }
 445                         log.debug("After creating relation from property value node {} toCI {}  statusIs {}.", propertyValue.getUniqueId(), createdCapabilityInstance.getUniqueId(), error);
 446                 }
 447                 if (error == null) {
 448                         log.debug("Before creating relation from property value node {} toProperty {}.", propertyValue.getUniqueId(), propertyDefinition.getUniqueId());
 449                         createRelationRes = titanGenericDao.createRelation(propertyValue, new PropertyData(propertyDefinition, null), GraphEdgeLabels.PROPERTY_IMPL, props);
 450                         if (createRelationRes.isRight()) {
 451                                 error = createRelationRes.right().value();
 452                                 log.debug("Failed to create relation from property value {} toProperty {} statusIs {}.", createdValue.getUniqueId(), propertyDefinition.getUniqueId(), error);
 453                         }
 454                         log.debug("After creating relation from property value node {} toProperty statusIs {}.", propertyValue.getUniqueId(), propertyDefinition.getUniqueId(), error);
 455                 }
 456                 if (error == null) {
 457                         return Either.left(createdValue);
 458                 }
 459                 return Either.right(error);
 460         }
 461
 462         private TitanOperationStatus addPropertyValueToCapabilityInstance(TitanVertex createdCapabilityInstanceVertex, PropertyValueData propertyValue, PropertyDefinition propertyDefinition, String id) {
 463                 TitanOperationStatus error = null;
 464                 Map<String, Object> props = null;
 465                 TitanOperationStatus createRelationRes;
 466                 log.trace("Before creating property value node {}  on graph.", propertyValue.getUniqueId());
 467                 Either<TitanVertex, TitanOperationStatus> createValueRes = titanGenericDao.createNode(propertyValue);
 468                 if (createValueRes.isRight()) {
 469                         error = createValueRes.right().value();
 470                         if (log.isDebugEnabled()){
 471                                 log.debug("Failed to create property value for capability instance {} {} {} {}", id, ofRI, statusIs, error);
 472                         }
 473                 }
 474                 log.trace("After creating property value node {}  on graph status is {}", propertyValue.getUniqueId(), error);
 475                 TitanVertex createdPropVertex = null;
 476                 String createdId = null;
 477                 if (error == null) {
 478                         log.trace("Before creating relation from property value node {} {} {} ", propertyValue.getUniqueId(), toCI, id);
 479                         props = new HashMap<>();
 480                         props.put(GraphPropertiesDictionary.PROPERTY_NAME.name(), propertyDefinition.getName());
 481                         props.put(GraphPropertiesDictionary.PROPERTY_ID.name(), propertyDefinition.getUniqueId());
 482                         createdPropVertex = createValueRes.left().value();
 483                         createRelationRes = titanGenericDao.createEdge(createdCapabilityInstanceVertex, createdPropVertex, GraphEdgeLabels.PROPERTY_VALUE, props);
 484                         if (!createRelationRes.equals(TitanOperationStatus.OK)) {
 485                                 error = createRelationRes;
 486                                 createdId = (String) titanGenericDao.getProperty(createdPropVertex, GraphPropertiesDictionary.UNIQUE_ID.getProperty());
 487                                 if (log.isDebugEnabled()) {
 488                                         log.debug("Failed to create relation from capability instance {} {} {} {} {}", id, toValue, createdId, statusIs, error);
 489                                 }
 490                         }
 491                         if (log.isTraceEnabled()){
 492                                 log.trace("After creating relation from property value node {} {} {} {} {}", propertyValue.getUniqueId(), toCI, id, statusIs, error);
 493                         }
 494                 }
 495                 if (error == null) {
 496                         log.trace("Before creating relation from property value node {} {} {}", propertyValue.getUniqueId(), toProperty, propertyDefinition.getUniqueId());
 497                         createRelationRes = titanGenericDao.createEdge(createdPropVertex, new PropertyData(propertyDefinition, null), GraphEdgeLabels.PROPERTY_IMPL, props);
 498                         if (!createRelationRes.equals(TitanOperationStatus.OK)) {
 499                                 error = createRelationRes;
 500                                 log.debug("Failed to create relation from property value {} {} {} {} {}", createdId, toProperty, propertyDefinition.getUniqueId(), statusIs, error);
 501                         }
 502                         log.debug("After creating relation from property value node {} {} {} {} {}", propertyValue.getUniqueId(), toProperty, propertyDefinition.getUniqueId(), statusIs, error);
 503                 }
 504                 if (error == null) {
 505                         return TitanOperationStatus.OK;
 506                 }
 507                 return error;
 508         }
 509
 510         private Either<Boolean, TitanOperationStatus> validateCapabilityInstanceProperties(Map<String, PropertyDefinition> defaultProperties, List<ComponentInstanceProperty> propertyValues) {
 511                 Either<Boolean, TitanOperationStatus> result = Either.left(true);
 512                 for (ComponentInstanceProperty property : propertyValues) {
 513                         result = validateUpdateCapabilityInstancePropertyValue(property, defaultProperties);
 514                         if (result.isRight()) {
 515                                 break;
 516                         }
 517                 }
 518                 return result;
 519         }
 520
 521         private Either<Boolean, TitanOperationStatus> validateUpdateCapabilityInstancePropertyValue(ComponentInstanceProperty property, Map<String, PropertyDefinition> defaultProperties) {
 522                 PropertyDefinition defaultProperty;
 523                 String propertyName = property.getName();
 524                 Either<Boolean, TitanOperationStatus> result = null;
 525                 if (defaultProperties.containsKey(propertyName)) {
 526                         defaultProperty = defaultProperties.get(propertyName);
 527                         String propertyType = property.getType() == null || property.getType().isEmpty() ? defaultProperty.getType() : property.getType();
 528
 529                         String innerType = null;
 530                         if (property.getSchema() != null && property.getSchema().getProperty() != null)
 531                                 innerType = property.getSchema().getProperty().getType();
 532                         if (innerType == null && defaultProperty.getSchema() != null && defaultProperty.getSchema().getProperty() != null)
 533                                 innerType = defaultProperty.getSchema().getProperty().getType();
 534
 535                         if (defaultProperty.getType().equals(propertyType)) {
 536                                 String propertyValue = property.getValue();
 537                                 Either<Map<String, DataTypeDefinition>, TitanOperationStatus> allDataTypes = applicationDataTypeCache.getAll();
 538                                 if (allDataTypes.isRight()) {
 539                                         TitanOperationStatus status = allDataTypes.right().value();
 540                                         log.debug("Failed to update property value statusIs {}.", status);
 541                                         result = Either.right(status);
 542                                 }
 543                                 if (result == null) {
 544                                         Either<Object, Boolean> updatedPropertyValueRes = propertyOperation.validateAndUpdatePropertyValue(propertyType, propertyValue, innerType, allDataTypes.left().value());
 545                                         if (updatedPropertyValueRes.isLeft()) {
 546                                                 if (updatedPropertyValueRes.left().value() != null)
 547                                                         property.setDefaultValue(updatedPropertyValueRes.left().value().toString());
 548                                                 result = Either.left(true);
 549                                         } else {
 550                                                 result = Either.right(TitanOperationStatus.INVALID_PROPERTY);
 551                                         }
 552                                 }
 553                                 log.debug("The property with name {} has invalid type {} or invalid value {}.", propertyName, propertyType, propertyValue);
 554
 555                         } else {
 556                                 result = Either.right(TitanOperationStatus.PROPERTY_NAME_ALREADY_EXISTS);
 557                                 log.debug("The property with name {} and different type already exists.", propertyName);
 558                         }
 559                 } else {
 560                         result = Either.right(TitanOperationStatus.NOT_FOUND);
 561                         log.debug("Failed to find property with name {}.", propertyName);
 562                 }
 563                 return result;
 564         }
 565
 566         /**
 567          * validate capability instance uniqueness
 568          *
 569          * @param resourceInstanceId
 570          * @param capabilityId
 571          * @return
 572          */
 573         @Override
 574         public Either<Boolean, TitanOperationStatus> validateCapabilityInstExistence(String resourceInstanceId, String capabilityId) {
 575                 Either<Boolean, TitanOperationStatus> result = null;
 576                 TitanOperationStatus error;
 577                 Map<String, Object> props = new HashMap<>();
 578                 props.put(GraphPropertiesDictionary.CAPABILITY_ID.getProperty(), capabilityId);
 579                 Either<Edge, TitanOperationStatus> getCapabilityInstanceEdgeRes = titanGenericDao.getOutgoingEdgeByCriteria(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.ResourceInstance), resourceInstanceId, GraphEdgeLabels.CAPABILITY_INST, props);
 580                 if (getCapabilityInstanceEdgeRes.isRight()) {
 581                         error = getCapabilityInstanceEdgeRes.right().value();
 582                         if (error.equals(TitanOperationStatus.NOT_FOUND)) {
 583                                 result = Either.left(false);
 584                         } else {
 585                                 log.debug("Failed to get outgoing edge for resource instance {} statusIs {}.", resourceInstanceId, error);
 586                                 result = Either.right(error);
 587                         }
 588                 }
 589                 if (result == null) {
 590                         result = Either.left(true);
 591                 }
 592                 return result;
 593         }
 594
 595         @Override
 596         public Either<Boolean, TitanOperationStatus> validateCapabilityInstExistence(TitanVertex instanceVertex, String resourceInstanceId, String capabilityId) {
 597                 Either<Boolean, TitanOperationStatus> result = null;
 598                 TitanOperationStatus error;
 599                 Map<String, Object> props = new HashMap<>();
 600                 props.put(GraphPropertiesDictionary.CAPABILITY_ID.getProperty(), capabilityId);
 601                 Either<Edge, TitanOperationStatus> getCapabilityInstanceEdgeRes = titanGenericDao.getOutgoingEdgeByCriteria(instanceVertex, GraphEdgeLabels.CAPABILITY_INST, props);
 602                 if (getCapabilityInstanceEdgeRes.isRight()) {
 603                         error = getCapabilityInstanceEdgeRes.right().value();
 604                         if (error.equals(TitanOperationStatus.NOT_FOUND)) {
 605                                 result = Either.left(false);
 606                         } else {
 607                                 log.debug("Failed to get outgoing edge for resource instance {} {} {}", resourceInstanceId, statusIs, error);
 608                                 result = Either.right(error);
 609                         }
 610                 }
 611                 if (result == null) {
 612                         result = Either.left(true);
 613                 }
 614                 return result;
 615         }
 616
 617         private Either<CapabilityInstData, TitanOperationStatus> createCapabilityInstanceOnGraph(String resourceInstanceId, CapabilityData overrideCapabilityData, CapabilityInstData capabilityInstance) {
 618                 log.debug("Before creation of capability instance of capability {} forRI {}.", overrideCapabilityData.getUniqueId(), resourceInstanceId);
 619
 620                 Either<GraphRelation, TitanOperationStatus> createRelationRes;
 621                 CapabilityInstData createdCapabilityInstance = null;
 622                 String capabilityInstanceId = null;
 623                 TitanOperationStatus error = null;
 624                 Either<CapabilityInstData, TitanOperationStatus> createCapabilityInstanceRes = titanGenericDao.createNode(capabilityInstance, CapabilityInstData.class);
 625                 if (createCapabilityInstanceRes.isRight()) {
 626                         error = createCapabilityInstanceRes.right().value();
 627                         log.debug("failedCreateCI {} forRI {} statusIs {}.", overrideCapabilityData.getUniqueId(), resourceInstanceId, error);
 628                 }
 629                 log.debug("After creation of capability instance of capability {} forRI {} statusIs {}.", overrideCapabilityData.getUniqueId(), resourceInstanceId, error);
 630                 if (error == null) {
 631                         createdCapabilityInstance = createCapabilityInstanceRes.left().value();
 632                         capabilityInstanceId = createdCapabilityInstance.getUniqueId();
 633                         Map<String, Object> props = new HashMap<>();
 634                         props.put(GraphPropertiesDictionary.CAPABILITY_ID.getProperty(), overrideCapabilityData.getUniqueId());
 635                         UniqueIdData resourceInstanceIdData = new UniqueIdData(NodeTypeEnum.ResourceInstance, resourceInstanceId);
 636                         log.debug("Before associating resource instance {} to capability instance.", resourceInstanceId);
 637                         createRelationRes = titanGenericDao.createRelation(resourceInstanceIdData, capabilityInstance, GraphEdgeLabels.CAPABILITY_INST, props);
 638                         if (createRelationRes.isRight()) {
 639                                 error = createRelationRes.right().value();
 640                                 log.debug("Failed to assotiate resource instance {} toCI {} statusIs {}.", resourceInstanceId, capabilityInstanceId, error);
 641                         }
 642                         log.debug("After associating resource instance {} to CI {} statusIs {}.", resourceInstanceId, capabilityInstanceId, error);
 643                 }
 644                 if (error == null) {
 645                         log.debug("Before associating capability instance {} toCapability {}.", capabilityInstanceId, overrideCapabilityData.getUniqueId());
 646                         Map<String, Object> props = new HashMap<>();
 647                         props.put(GraphPropertiesDictionary.CAPABILITY_ID.getProperty(), overrideCapabilityData.getUniqueId());
 648                         createRelationRes = titanGenericDao.createRelation(createdCapabilityInstance, overrideCapabilityData, GraphEdgeLabels.INSTANCE_OF, props);
 649                         if (createRelationRes.isRight()) {
 650                                 error = createRelationRes.right().value();
 651                                 log.debug("Failed to associate capability instance {} toCapability statusIs {}.", capabilityInstanceId, overrideCapabilityData.getUniqueId(), error);
 652                         }
 653                         log.debug("After associating capability instance {} toCapability statusIs {}.", capabilityInstanceId, overrideCapabilityData.getUniqueId(), error);
 654                 }
 655                 if (error == null) {
 656                         return createCapabilityInstanceRes;
 657                 }
 658                 return Either.right(error);
 659         }
 660
 661         private Either<TitanVertex, TitanOperationStatus> createCapabilityInstanceOnGraph(TitanVertex riVertex, String resourceInstanceId, TitanVertex overrideCapabilityDataVertex, CapabilityInstData capabilityInstance) {
 662                 String overrideCapabilityDataId = (String) titanGenericDao.getProperty(overrideCapabilityDataVertex, GraphPropertiesDictionary.UNIQUE_ID.getProperty());
 663                 log.trace("Before creation of capability instance of capability {} {} {}", overrideCapabilityDataVertex, forRI, resourceInstanceId);
 664
 665                 TitanOperationStatus createRelationRes;
 666                 TitanVertex createdCapabilityInstance = null;
 667                 String capabilityInstanceId = null;
 668                 TitanOperationStatus error = null;
 669                 Either<TitanVertex, TitanOperationStatus> createCapabilityInstanceRes = titanGenericDao.createNode(capabilityInstance);
 670                 if (createCapabilityInstanceRes.isRight()) {
 671                         error = createCapabilityInstanceRes.right().value();
 672                         log.debug("Failed to create capability instance of capability {} {} {} {} {}", overrideCapabilityDataId, forRI, resourceInstanceId, statusIs, error);
 673                 }
 674                 log.trace("After creation of capability instance of capability {} {} {} {} {}", overrideCapabilityDataId, forRI, resourceInstanceId, statusIs, error);
 675                 if (error == null) {
 676                         createdCapabilityInstance = createCapabilityInstanceRes.left().value();
 677                         capabilityInstanceId = (String) titanGenericDao.getProperty(createdCapabilityInstance, GraphPropertiesDictionary.UNIQUE_ID.getProperty());
 678                         Map<String, Object> props = new HashMap<>();
 679                         props.put(GraphPropertiesDictionary.CAPABILITY_ID.getProperty(), overrideCapabilityDataId);
 680                         log.debug("Before associating resource instance {} to capability instance.", resourceInstanceId);
 681
 682                         createRelationRes = titanGenericDao.createEdge(riVertex, capabilityInstance, GraphEdgeLabels.CAPABILITY_INST, props);
 683                         if (!createRelationRes.equals(TitanOperationStatus.OK)) {
 684                                 error = createRelationRes;
 685                                 log.debug("Failed to assotiate resource instance {} {} {} {} {}", resourceInstanceId, toCI, capabilityInstanceId, statusIs, error);
 686                         }
 687                         if (log.isTraceEnabled()) {
 688                                 log.trace("After associating resource instance {} {} {} {} {}", resourceInstanceId, toCI, capabilityInstanceId, statusIs, error);
 689                         }
 690                 }
 691                 if (error == null) {
 692                         log.trace("Before associating capability instance {} {} {}", capabilityInstanceId, toCapability, overrideCapabilityDataId);
 693                         Map<String, Object> props = new HashMap<>();
 694                         props.put(GraphPropertiesDictionary.CAPABILITY_ID.getProperty(), overrideCapabilityDataId);
 695                         createRelationRes = titanGenericDao.createEdge(createdCapabilityInstance, overrideCapabilityDataVertex, GraphEdgeLabels.INSTANCE_OF, props);
 696                         if (!createRelationRes.equals(TitanOperationStatus.OK)) {
 697                                 error = createRelationRes;
 698                                 log.debug("Failed to associate capability instance {} {} {} {} {}", capabilityInstanceId, toCapability, overrideCapabilityDataId, statusIs, error);
 699                         }
 700                         log.debug("After associating capability instance {} {} {} {} {}", capabilityInstanceId, toCapability, overrideCapabilityDataId, statusIs, error);
 701                 }
 702                 if (error == null) {
 703                         return createCapabilityInstanceRes;
 704                 }
 705                 return Either.right(error);
 706         }
 707
 708         private CapabilityInstData buildCapabilityInstanceData(String resourceInstanceId, CapabilityDefinition capability) {
 709                 CapabilityInstData capabilityInstance = new CapabilityInstData();
 710                 Long creationTime = System.currentTimeMillis();
 711                 String uniqueId = UniqueIdBuilder.buildCapabilityInstanceUid(resourceInstanceId, capability.getName());
 712
 713                 capabilityInstance.setCreationTime(creationTime);
 714                 capabilityInstance.setModificationTime(creationTime);
 715                 capabilityInstance.setUniqueId(uniqueId);
 716
 717                 return capabilityInstance;
 718         }
 719
 720         /**
 721          * delete capability instance from resource instance
 722          *
 723          * @param resourceInstanceId
 724          * @param capabilityInstanceId
 725          * @return
 726          */
 727         @Override
 728         public Either<CapabilityInstData, TitanOperationStatus> deleteCapabilityInstanceFromResourceInstance(String resourceInstanceId, String capabilityInstanceId) {
 729                 log.debug("Before deleting of capability instance {} fromRI {}.", capabilityInstanceId, resourceInstanceId);
 730
 731                 Either<CapabilityInstData, TitanOperationStatus> deleteCapabilityInstRes = null;
 732                 TitanOperationStatus error = null;
 733                 Either<Boolean, TitanOperationStatus> deleteProperyValuesRes = deleteAllPropertyValuesOfCapabilityInstance(resourceInstanceId, capabilityInstanceId);
 734                 if (deleteProperyValuesRes.isRight()) {
 735                         error = deleteProperyValuesRes.right().value();
 736                         log.debug("failedDeletePropertyValues {} for RI {} statusIs {}.", capabilityInstanceId, resourceInstanceId, error);
 737                 }
 738                 if (error == null) {
 739                         deleteCapabilityInstRes = titanGenericDao.deleteNode(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.CapabilityInst), capabilityInstanceId, CapabilityInstData.class);
 740                         if (deleteCapabilityInstRes.isRight()) {
 741                                 error = deleteCapabilityInstRes.right().value();
 742                                 log.debug("Failed to delete capability instance {} forRI {} statusIs {}", capabilityInstanceId, resourceInstanceId, error);
 743                         }
 744                 }
 745                 log.debug("After deleting of capability instance {} fromRI {} statusIs {}.", capabilityInstanceId, resourceInstanceId, error);
 746                 if (error == null) {
 747                         return Either.left(deleteCapabilityInstRes.left().value());
 748                 }
 749                 return Either.right(error);
 750         }
 751
 752         private Either<Boolean, TitanOperationStatus> deleteAllPropertyValuesOfCapabilityInstance(String resourceInstanceId, String capabilityInstanceId) {
 753                 log.debug("Before deleting all property values of capability instance {} fromRI {}.", capabilityInstanceId, resourceInstanceId);
 754                 TitanOperationStatus error = null;
 755                 List<ImmutablePair<PropertyValueData, GraphEdge>> deletePropertiesPairs;
 756                 Either<List<ImmutablePair<PropertyValueData, GraphEdge>>, TitanOperationStatus> getPropertyValuesRes = titanGenericDao.getChildrenNodes(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.CapabilityInst), capabilityInstanceId,
 757                                 GraphEdgeLabels.PROPERTY_VALUE, NodeTypeEnum.PropertyValue, PropertyValueData.class);
 758                 if (getPropertyValuesRes.isRight()) {
 759                         error = getPropertyValuesRes.right().value();
 760                         log.debug("Failed to retrieve property values of capability instance {} forRI {} status {}.", capabilityInstanceId, resourceInstanceId, error);
 761                 }
 762                 if (error == null) {
 763                         deletePropertiesPairs = getPropertyValuesRes.left().value();
 764                         for (ImmutablePair<PropertyValueData, GraphEdge> propertyPair : deletePropertiesPairs) {
 765                                 Either<PropertyValueData, TitanOperationStatus> deletePropertyRes = titanGenericDao.deleteNode(propertyPair.getLeft(), PropertyValueData.class);
 766                                 if (deletePropertyRes.isRight()) {
 767                                         error = deletePropertyRes.right().value();
 768                                         log.debug("failedDeletePropertyValues {} forRI {} statusIs {}.", capabilityInstanceId, resourceInstanceId, error);
 769                                         break;
 770                                 }
 771                         }
 772                 }
 773                 log.debug("After deleting all property values of capability instance {} fromRI {} statusIs {}.", capabilityInstanceId, resourceInstanceId, error);
 774                 if (error == null) {
 775                         return Either.left(true);
 776                 }
 777                 return Either.right(error);
 778         }
 779
 780         /**
 781          * get all capability instances for resource instance returns all Capability Instances related to Resource Instance as List<CapabilityInstData> or TitanOperationStatus if error occurs or if Resource Instance have no any related Capability
 782          * Instance
 783          *
 784          * @param resourceInstanceId
 785          * @return Either<List<CapabilityInstData>, TitanOperationStatus>
 786          */
 787         @Override
 788         public Either<List<ImmutablePair<CapabilityInstData, GraphEdge>>, TitanOperationStatus> getAllCapabilityInstancesOfResourceInstance(String resourceInstanceId) {
 789                 log.debug("Before deleting all capability instances of resource instance {}.", resourceInstanceId);
 790                 TitanOperationStatus error = null;
 791                 Either<List<ImmutablePair<CapabilityInstData, GraphEdge>>, TitanOperationStatus> getCapabilityInstancesRes = titanGenericDao.getChildrenNodes(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.ResourceInstance), resourceInstanceId,
 792                                 GraphEdgeLabels.CAPABILITY_INST, NodeTypeEnum.CapabilityInst, CapabilityInstData.class);
 793                 if (getCapabilityInstancesRes.isRight()) {
 794                         error = getCapabilityInstancesRes.right().value();
 795                         log.debug("Failed to retrieve capability Instances of resource instance {} statusIs {}.", resourceInstanceId, error);
 796                 }
 797                 log.debug("After deleting all capability instances of resource instance {} statusIs {}", resourceInstanceId, error);
 798                 if (error == null) {
 799                         return getCapabilityInstancesRes;
 800                 }
 801                 return Either.right(error);
 802         }
 803
 804         /**
 805          * get capability instance of capability for resource instance
 806          *
 807          * @param resourceInstanceId
 808          * @param capabilityId
 809          * @return
 810          */
 811         @Override
 812         public Either<CapabilityInstData, TitanOperationStatus> getCapabilityInstanceOfCapabilityOfResourceInstance(String resourceInstanceId, String capabilityId) {
 813                 TitanOperationStatus error = null;
 814                 Map<String, Object> props = new HashMap<>();
 815                 props.put(GraphPropertiesDictionary.CAPABILITY_ID.getProperty(), capabilityId);
 816                 Either<ImmutablePair<CapabilityInstData, GraphEdge>, TitanOperationStatus> getCapabilityInstanceRes = titanGenericDao.getChildByEdgeCriteria(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.ResourceInstance), resourceInstanceId,
 817                                 GraphEdgeLabels.CAPABILITY_INST, NodeTypeEnum.CapabilityInst, CapabilityInstData.class, props);
 818                 if (getCapabilityInstanceRes.isRight()) {
 819                         error = getCapabilityInstanceRes.right().value();
 820                         log.debug("Failed to retrieve capability Instance of capability {} ofRI {} statusIs {}.", capabilityId, resourceInstanceId, error);
 821                 }
 822                 if (error == null) {
 823                         return Either.left(getCapabilityInstanceRes.left().value().getLeft());
 824                 }
 825                 return Either.right(error);
 826         }
 827
 828         /**
 829          * update capability property values
 830          *
 831          * @param resourceInstanceId
 832          * @param propertyValues
 833          * @param capabilityId
 834          * @return
 835          */
 836         @Override
 837         public Either<List<PropertyValueData>, TitanOperationStatus> updateCapabilityPropertyValues(String resourceInstanceId, String capabilityId, List<ComponentInstanceProperty> propertyValues) {
 838                 log.debug("Before updating property values of capability {} ofRI {}.", capabilityId, resourceInstanceId);
 839                 TitanOperationStatus error = null;
 840                 Map<String, Object> props = new HashMap<>();
 841                 CapabilityInstData capabilityInstance = null;
 842                 String capabilityInstanceId = null;
 843                 Either<Boolean, TitanOperationStatus> deleteProperyValuesRes;
 844
 845                 CapabilityData overrideCapabilityData;
 846                 CapabilityDefinition overrideCapabilityDefinition;
 847                 Map<String, PropertyDefinition> defaultProperties = null;
 848                 Either<ImmutablePair<CapabilityData, GraphEdge>, TitanOperationStatus> getCapabilityDataRes = null;
 849                 Either<List<PropertyValueData>, TitanOperationStatus> addPropertyValuesRes = null;
 850                 Either<CapabilityDefinition, TitanOperationStatus> getCapabilityDefinitionRes = null;
 851
 852                 log.debug("Before getting all capability instances of RI {}.", resourceInstanceId);
 853                 props.put(GraphPropertiesDictionary.CAPABILITY_ID.getProperty(), capabilityId);
 854                 Either<ImmutablePair<CapabilityInstData, GraphEdge>, TitanOperationStatus> getCapabilityInstancesRes = titanGenericDao.getChildByEdgeCriteria(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.ResourceInstance), resourceInstanceId,
 855                                 GraphEdgeLabels.CAPABILITY_INST, NodeTypeEnum.CapabilityInst, CapabilityInstData.class, props);
 856                 if (getCapabilityInstancesRes.isRight()) {
 857                         error = getCapabilityInstancesRes.right().value();
 858                         log.debug("Failed to retrieve capability Instances of capability {} ofRI {} statusIs {}.", capabilityId, resourceInstanceId, error);
 859                 }
 860                 log.debug("After getting all capability instances ofRI {} statusIs {}.", resourceInstanceId, error);
 861                 if (error == null) {
 862                         log.debug("Before deleting all capability instances ofRI {}.", resourceInstanceId);
 863                         capabilityInstance = getCapabilityInstancesRes.left().value().getLeft();
 864                         capabilityInstanceId = capabilityInstance.getUniqueId();
 865                         deleteProperyValuesRes = deleteAllPropertyValuesOfCapabilityInstance(resourceInstanceId, capabilityInstanceId);
 866                         if (deleteProperyValuesRes.isRight()) {
 867                                 error = deleteProperyValuesRes.right().value();
 868                                 log.debug("failedDeletePropertyValues {} forRI {} statusIs {}", capabilityInstanceId, resourceInstanceId, statusIs, error);
 869                         }
 870                         log.debug("After deleting all capability instances ofRI {} statusIs {}.", resourceInstanceId, error);
 871                 }
 872                 if (error == null) {
 873                         log.debug("Before getting capability {} ofRI {}.", capabilityId, resourceInstanceId);
 874                         getCapabilityDataRes = titanGenericDao.getChild(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.ResourceInstance), resourceInstanceId, GraphEdgeLabels.CALCULATED_CAPABILITY, NodeTypeEnum.Capability, CapabilityData.class);
 875                         if (getCapabilityDataRes.isRight()) {
 876                                 error = getCapabilityDataRes.right().value();
 877                                 log.debug("Failed to get capability {} ofRI {} statusIs {}.", capabilityId, resourceInstanceId, error);
 878                         }
 879                         log.debug("After getting capability {} ofRI {} statusIs {}.", capabilityId, resourceInstanceId, error);
 880                 }
 881                 if (error == null) {
 882                         log.debug("Before getting capability definition for capability {} ofRI {}.", capabilityId, resourceInstanceId);
 883                         overrideCapabilityData = getCapabilityDataRes.left().value().getLeft();
 884                         getCapabilityDefinitionRes = capabilityOperation.getCapabilityByCapabilityData(overrideCapabilityData);
 885                         if (getCapabilityDefinitionRes.isRight()) {
 886                                 error = getCapabilityDefinitionRes.right().value();
 887                                 log.debug("Failed to retrieve capability {} ofRI {} statusIs {}", capabilityId, resourceInstanceId, error);
 888                         }
 889                         log.debug("After getting capability definition for capability {} ofRI {} statusIs {}.", capabilityId, resourceInstanceId, error);
 890                 }
 891                 if (error == null) {
 892                         log.debug("Before validating capability properties of capability instance {} ofRI {}.", capabilityInstanceId, resourceInstanceId);
 893                         overrideCapabilityDefinition = getCapabilityDefinitionRes.left().value();
 894                         if (overrideCapabilityDefinition.getProperties() != null) {
 895                                 defaultProperties = overrideCapabilityDefinition.getProperties().stream().collect(Collectors.toMap(PropertyDefinition::getName, Function.identity()));
 896                         }
 897                         Either<Boolean, TitanOperationStatus> result = validateCapabilityInstanceProperties(defaultProperties, propertyValues);
 898                         if (result.isRight()) {
 899                                 error = result.right().value();
 900                                 log.debug("failedAddProperties {} ofRI {} statusIs {}.", capabilityInstance.getUniqueId(), resourceInstanceId, error);
 901                         }
 902                         log.debug("After validating capability properties of capability instance {} of RI {} statusIs {}.", capabilityInstanceId, resourceInstanceId, error);
 903                 }
 904                 if (error == null) {
 905                         log.debug("Before adding property values toCI {} ofRI {}.", capabilityInstanceId, resourceInstanceId);
 906                         addPropertyValuesRes = addPropertyValuesToCapabilityInstance(capabilityInstance, propertyValues, defaultProperties);
 907                         if (addPropertyValuesRes.isRight()) {
 908                                 error = addPropertyValuesRes.right().value();
 909                                 log.debug("failedAddProperties {} ofRI {} statusIs {}.", capabilityInstance.getUniqueId(), resourceInstanceId, error);
 910                         }
 911                         log.debug("Before adding property values toCI {} ofRI {}.", capabilityInstanceId, resourceInstanceId);
 912                 }
 913                 log.debug("After updating property values of capability {} ofRI {} statusIs {}.", capabilityId, resourceInstanceId, error);
 914                 if (error == null) {
 915                         return addPropertyValuesRes;
 916                 }
 917                 return Either.right(error);
 918         }
 919
 920         /**
 921          * clone and associate capability instance with property values
 922          *
 923          * @param createdComponentInstance
 924          * @param capability
 925          * @param capabilityInstPair
 926          * @return
 927          */
 928         @Override
 929         public Either<ImmutablePair<CapabilityInstData, List<PropertyValueData>>, TitanOperationStatus> cloneAssociateCapabilityInstanceWithPropertyValues(ComponentInstanceData createdComponentInstance, CapabilityDefinition capability,
 930                         ImmutablePair<CapabilityInstData, GraphEdge> capabilityInstPair) {
 931
 932                 TitanOperationStatus error = null;
 933                 String componentInstanceId = createdComponentInstance.getUniqueId();
 934                 String capabilityInstanceId = capabilityInstPair.getLeft().getUniqueId();
 935
 936                 log.debug("Before cloning capability instance with property values of capability instance {} ofRI {}.", capabilityInstanceId, componentInstanceId);
 937                 List<ImmutablePair<PropertyValueData, GraphEdge>> propertyValuePairs;
 938                 List<PropertyValueData> newPropertyValues = new ArrayList<>();
 939                 CapabilityInstData cloneCapabilityInstance = null;
 940                 Either<CapabilityInstData, TitanOperationStatus> cloneCapabilityInstanceNodeRes = null;
 941
 942                 log.debug("Before getting all property values ofCI {} ofRI {}.", capabilityInstanceId, componentInstanceId);
 943                 Either<List<ImmutablePair<PropertyValueData, GraphEdge>>, TitanOperationStatus> getPropertyValuesRes = titanGenericDao.getChildrenNodes(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.CapabilityInst), capabilityInstPair.getLeft().getUniqueId(),
 944                                 GraphEdgeLabels.PROPERTY_VALUE, NodeTypeEnum.PropertyValue, PropertyValueData.class);
 945                 if (getPropertyValuesRes.isRight()) {
 946                         error = getPropertyValuesRes.right().value();
 947                         log.debug("Failed to retrieve property values of capability instance {} ofCI {} statusIs {}.", capabilityInstPair.getLeft().getUniqueId(), componentInstanceId ,error);
 948                 }
 949                 log.debug("After getting all property values ofCI {} ofRI {} statusIs {}.", capabilityInstanceId, componentInstanceId, error);
 950                 if (error == null) {
 951                         CapabilityInstData cloneCapabilityInst = buildCapabilityInstanceData(componentInstanceId, capability);
 952                         log.debug("Before creating capability instance node {} onGraph.", cloneCapabilityInst.getUniqueId());
 953                         cloneCapabilityInstanceNodeRes = titanGenericDao.createNode(cloneCapabilityInst, CapabilityInstData.class);
 954                         if (cloneCapabilityInstanceNodeRes.isRight()) {
 955                                 error = cloneCapabilityInstanceNodeRes.right().value();
 956                                 log.debug("Failed to create capability instance of capability {} ofCI {} statusIs {}.", capability.getUniqueId(), componentInstanceId, error);
 957                         }
 958                         log.debug("After creating capability instance node {} onGraph. statusIs {}", cloneCapabilityInst.getUniqueId(), error);
 959                 }
 960
 961                 if (error == null) {
 962                         log.debug("Before creating relation from capability instance {} toCapability {} onGraph.", cloneCapabilityInstanceNodeRes.left().value().getUniqueId(), capability.getUniqueId());
 963                         cloneCapabilityInstance = cloneCapabilityInstanceNodeRes.left().value();
 964                         CapabilityData capabilityData = buildCapabilityData(capability);
 965                         Map<String, Object> props = new HashMap<>();
 966                         props.put(GraphPropertiesDictionary.CAPABILITY_ID.getProperty(), capabilityData.getUniqueId());
 967                         Either<GraphRelation, TitanOperationStatus> createRelationRes = titanGenericDao.createRelation(cloneCapabilityInstance, capabilityData, GraphEdgeLabels.INSTANCE_OF, props);
 968                         if (createRelationRes.isRight()) {
 969                                 error = createRelationRes.right().value();
 970                                 log.debug("Failed to associate capability instance {} toCapability {} statusIs {}.", cloneCapabilityInstance.getUniqueId(), capability.getUniqueId(), error);
 971                         }
 972                         log.debug("After creating relation from capability instance {} toCapability {} onGraph. statusIs {}.", cloneCapabilityInstanceNodeRes.left().value().getUniqueId(), capability.getUniqueId(), error);
 973                 }
 974
 975                 if (error == null) {
 976                         log.debug("Before cloning property values ofCI {}.", capabilityInstanceId);
 977                         propertyValuePairs = getPropertyValuesRes.left().value();
 978                         for (ImmutablePair<PropertyValueData, GraphEdge> propertyValuePair : propertyValuePairs) {
 979                                 Either<PropertyValueData, TitanOperationStatus> clonePropertyValueRes = cloneAssociatePropertyValue(cloneCapabilityInstance, propertyValuePair);
 980                                 if (clonePropertyValueRes.isRight()) {
 981                                         error = clonePropertyValueRes.right().value();
 982                                         if (log.isDebugEnabled()) {
 983                                                 log.debug("Failed to clone property value {} ofCapability {} ofCI {}. statusIs {}.", propertyValuePair.getLeft().getUniqueId(), capability.getUniqueId(), componentInstanceId, error);
 984                                         }
 985                                         break;
 986                                 } else {
 987                                         newPropertyValues.add(clonePropertyValueRes.left().value());
 988                                 }
 989                         }
 990                         log.debug("After cloning property values of CI {} statusIs {}.", capabilityInstanceId, error);
 991                 }
 992                 log.debug("After cloning capability instance with property values of capability instance {} ofRI {} statusIs {}.", capabilityInstanceId, componentInstanceId, error);
 993                 if (error == null) {
 994                         return Either.left(new ImmutablePair<CapabilityInstData, List<PropertyValueData>>(cloneCapabilityInstance, newPropertyValues));
 995                 }
 996                 return Either.right(error);
 997         }
 998
 999         public Either<TitanVertex, TitanOperationStatus> cloneAssociateCapabilityInstanceWithPropertyValues(TitanVertex componentInstanceVertex, CapabilityDefinition capability, ImmutablePair<CapabilityInstData, GraphEdge> capabilityInstPair) {
1000
1001                 TitanOperationStatus error = null;
1002                 String componentInstanceId = (String) titanGenericDao.getProperty(componentInstanceVertex, GraphPropertiesDictionary.UNIQUE_ID.getProperty());
1003                 String capabilityInstanceId = capabilityInstPair.getLeft().getUniqueId();
1004
1005                 if (log.isTraceEnabled()) {
1006                         log.trace("Before cloning capability instance with property values of capability instance {} {} {}", capabilityInstanceId, ofRI, componentInstanceId);
1007                 }
1008                 List<ImmutablePair<TitanVertex, Edge>> propertyValuePairs;
1009                 Either<TitanVertex, TitanOperationStatus> cloneCapabilityInstanceNodeRes = null;
1010
1011                 if (log.isTraceEnabled()) {
1012                         log.trace("Before getting all property values {} {} {} {}", ofCI, capabilityInstanceId, ofRI, componentInstanceId);
1013                 }
1014                 Either<List<ImmutablePair<TitanVertex, Edge>>, TitanOperationStatus> getPropertyValuesRes = titanGenericDao.getChildrenVertecies(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.CapabilityInst), capabilityInstPair.getLeft().getUniqueId(),
1015                                 GraphEdgeLabels.PROPERTY_VALUE);
1016                 if (getPropertyValuesRes.isRight()) {
1017                         error = getPropertyValuesRes.right().value();
1018                         if (log.isDebugEnabled()) {
1019                                 log.debug("Failed to retrieve property values of capability instance {} {} {} {} {}", capabilityInstPair.getLeft().getUniqueId(), ofCI, componentInstanceId, statusIs, error);
1020                         }
1021                 }
1022                 if (log.isTraceEnabled()) {
1023                         log.trace("After getting all property values {} {} {} {} {} {}", ofCI, capabilityInstanceId, ofRI, componentInstanceId, statusIs, error);
1024                 }
1025                 if (error == null) {
1026                         CapabilityInstData cloneCapabilityInst = buildCapabilityInstanceData(componentInstanceId, capability);
1027                         log.trace("Before creating capability instance node {} {} ", cloneCapabilityInst.getUniqueId(), onGraph);
1028                         cloneCapabilityInstanceNodeRes = titanGenericDao.createNode(cloneCapabilityInst);
1029                         if (cloneCapabilityInstanceNodeRes.isRight()) {
1030                                 error = cloneCapabilityInstanceNodeRes.right().value();
1031                                 if (log.isDebugEnabled()) {
1032                                         log.debug("Failed to create capability instance of capability {} {} {} {} {}", capability.getUniqueId(), ofCI, componentInstanceId, statusIs, error);
1033                                 }
1034                         }
1035                         if (log.isTraceEnabled()) {
1036                                 log.trace("After creating capability instance node {} {} {} {}", cloneCapabilityInst.getUniqueId(), onGraph, statusIs, error);
1037                         }
1038                 }
1039                 CapabilityData capabilityData;
1040                 TitanVertex cloneCapabilityInstance = null;
1041                 if (error == null) {
1042                         if (log.isTraceEnabled()) {
1043                                 log.trace("Before creating relation from capability instance {} {} {} {}", capability.getUniqueId(), toCapability, capability.getUniqueId(), onGraph);
1044                         }
1045                         capabilityData = buildCapabilityData(capability);
1046                         Map<String, Object> props = new HashMap<>();
1047                         props.put(GraphPropertiesDictionary.CAPABILITY_ID.getProperty(), capabilityData.getUniqueId());
1048                         cloneCapabilityInstance = cloneCapabilityInstanceNodeRes.left().value();
1049                         TitanOperationStatus createRelationRes = titanGenericDao.createEdge(cloneCapabilityInstance, capabilityData, GraphEdgeLabels.INSTANCE_OF, props);
1050                         if (!createRelationRes.equals(TitanOperationStatus.OK)) {
1051                                 error = createRelationRes;
1052                                 if (log.isDebugEnabled()) {
1053                                         log.debug("Failed to associate capability instance {} {} {} {} {}", capabilityData.getUniqueId(), toCapability, capability.getUniqueId(), statusIs, createRelationRes);
1054                                 }
1055                         }
1056                         if (log.isTraceEnabled()) {
1057                                 log.trace("After creating relation from capability instance {} {} {} {} {} {}", capabilityData.getUniqueId(), toCapability, capability.getUniqueId(), onGraph, statusIs, error);
1058                         }
1059                 }
1060
1061                 if (error == null) {
1062                         log.trace("Before cloning property values {} {} ", ofCI, capabilityInstanceId);
1063                         propertyValuePairs = getPropertyValuesRes.left().value();
1064                         for (ImmutablePair<TitanVertex, Edge> propertyValuePair : propertyValuePairs) {
1065                                 TitanOperationStatus clonePropertyValueRes = cloneAssociatePropertyValue(cloneCapabilityInstance, propertyValuePair);
1066                                 if (!clonePropertyValueRes.equals(TitanOperationStatus.OK)) {
1067                                         error = clonePropertyValueRes;
1068                                         if (log.isDebugEnabled()) {
1069                                                 log.debug("Failed to clone property value  of capability {} {} {} {} {}", capability.getUniqueId(), ofCI, componentInstanceId, statusIs, error);
1070                                         }
1071                                         break;
1072                                 }
1073                         }
1074                         if (log.isDebugEnabled()) {
1075                                 log.debug("After cloning property values {} {} {} {}", ofCI, capabilityInstanceId, statusIs, error);
1076                         }
1077                 }
1078                 log.debug("After cloning capability instance with property values of capability instance {} ofRI {} statusIs {}.", capabilityInstanceId, componentInstanceId, error);
1079                 if (error == null) {
1080                         return Either.left(cloneCapabilityInstance);
1081                 }
1082                 return Either.right(error);
1083         }
1084
1085         private CapabilityData buildCapabilityData(CapabilityDefinition capability) {
1086                 CapabilityData capabilityData = new CapabilityData();
1087                 capabilityData.setUniqueId(capability.getUniqueId());
1088                 capabilityData.setDescription(capability.getDescription());
1089                 capabilityData.setType(capability.getType());
1090                 capabilityData.setMaxOccurrences(capability.getMaxOccurrences());
1091                 capabilityData.setMinOccurrences(capability.getMinOccurrences());
1092                 List<String> validSourceTypes = capability.getValidSourceTypes();
1093                 if (validSourceTypes != null) {
1094                         capabilityData.setValidSourceTypes(validSourceTypes);
1095                 }
1096                 return capabilityData;
1097         }
1098
1099         private Either<PropertyValueData, TitanOperationStatus> cloneAssociatePropertyValue(CapabilityInstData cloneCapabilityInstance, ImmutablePair<PropertyValueData, GraphEdge> propertyValuePair) {
1100                 TitanOperationStatus error = null;
1101                 String propertyValueID = propertyValuePair.getLeft().getUniqueId();
1102                 String capabilityInstanceId = cloneCapabilityInstance.getUniqueId();
1103                 log.debug("Before cloning property values {} ofCI {}.", propertyValueID, capabilityInstanceId);
1104
1105                 Map<String, Object> props = propertyValuePair.getRight().getProperties();
1106                 PropertyData propertyData = new PropertyData();
1107                 String propertyId = (String) props.get(GraphPropertiesDictionary.PROPERTY_ID.name());
1108                 propertyData.getPropertyDataDefinition().setUniqueId(propertyId);
1109
1110                 PropertyValueData propertyValue = buildPropertyValueData((String) props.get(GraphPropertiesDictionary.PROPERTY_NAME.name()), propertyValuePair.getLeft().getType(), propertyValuePair.getLeft().getValue(), capabilityInstanceId);
1111                 PropertyValueData createdValue = null;
1112                 Either<GraphRelation, TitanOperationStatus> createRelationRes;
1113
1114                 log.debug("Before creating property values node {} onGraph.", propertyValue.getUniqueId());
1115                 Either<PropertyValueData, TitanOperationStatus> createValueRes = titanGenericDao.createNode(propertyValue, PropertyValueData.class);
1116                 if (createValueRes.isRight()) {
1117                         error = createValueRes.right().value();
1118                         log.debug("Failed to create property value for capability instance {} ofRI. statusIs {}.", cloneCapabilityInstance.getUniqueId(), error);
1119                 }
1120                 log.debug("After creating property values node {} onGraph. statusIs {}.", propertyValue.getUniqueId(), error);
1121                 if (error == null) {
1122                         createdValue = createValueRes.left().value();
1123                         log.debug("Before creating relation from capability instance {} toValue {}.", capabilityInstanceId, createdValue.getUniqueId());
1124                         createRelationRes = titanGenericDao.createRelation(cloneCapabilityInstance, createdValue, GraphEdgeLabels.PROPERTY_VALUE, props);
1125                         if (createRelationRes.isRight()) {
1126                                 error = createRelationRes.right().value();
1127                                 log.debug("Failed to create relation from capability instance {} toValue {} statusIs {}.", cloneCapabilityInstance.getUniqueId(), createdValue.getUniqueId(), error);
1128                         }
1129                         log.debug("After creating relation from capability instance {} toValue {} statusIs {}", capabilityInstanceId, createdValue.getUniqueId(), error);
1130                 }
1131                 if (error == null) {
1132                         log.debug("Before creating relation from property value {} toProperty {}.", createdValue, propertyData.getUniqueId());
1133                         createRelationRes = titanGenericDao.createRelation(createdValue, propertyData, GraphEdgeLabels.PROPERTY_IMPL, props);
1134                         if (createRelationRes.isRight()) {
1135                                 error = createRelationRes.right().value();
1136                                 log.debug("Failed to create relation from property value {} toProperty {} statusIs {}.", createdValue.getUniqueId(), propertyId, error);
1137                         }
1138                         log.debug("Before creating relation from property value {} toProperty {} statusIs {}.", createdValue, propertyData.getUniqueId(), error);
1139                 }
1140                 log.debug("After cloning property values {} ofCI {} statusIs {}.", propertyValueID, capabilityInstanceId, error);
1141                 if (error == null) {
1142                         return Either.left(createdValue);
1143                 }
1144                 return Either.right(error);
1145         }
1146
1147         private TitanOperationStatus cloneAssociatePropertyValue(TitanVertex capabilityInstanceVertex, ImmutablePair<TitanVertex, Edge> propertyValuePair) {
1148                 TitanOperationStatus error = null;
1149                 TitanVertex propertyVertex = propertyValuePair.getLeft();
1150                 String propertyValueID = (String) titanGenericDao.getProperty(propertyVertex, GraphPropertiesDictionary.UNIQUE_ID.getProperty());
1151                 String capabilityInstanceId = (String) titanGenericDao.getProperty(capabilityInstanceVertex, GraphPropertiesDictionary.UNIQUE_ID.getProperty());
1152                 if (log.isTraceEnabled()) {
1153                         log.trace("Before cloning property values {} {} {}", propertyValueID, ofCI, capabilityInstanceId);
1154                 }
1155
1156                 Map<String, Object> props = titanGenericDao.getProperties(propertyValuePair.getRight());
1157                 PropertyData propertyData = new PropertyData();
1158                 String propertyId = (String) props.get(GraphPropertiesDictionary.PROPERTY_ID.name());
1159                 propertyData.getPropertyDataDefinition().setUniqueId(propertyId);
1160
1161                 String propertyType = (String) titanGenericDao.getProperty(propertyVertex, GraphPropertiesDictionary.TYPE.getProperty());
1162                 String propertyValueStr = (String) titanGenericDao.getProperty(propertyVertex, GraphPropertiesDictionary.VALUE.getProperty());
1163
1164                 PropertyValueData propertyValue = buildPropertyValueData((String) props.get(GraphPropertiesDictionary.PROPERTY_NAME.name()), propertyType, propertyValueStr, capabilityInstanceId);
1165                 TitanVertex createdValue = null;
1166                 TitanOperationStatus createRelationRes;
1167
1168                 log.trace("Before creating property values node {} {} ", propertyValue.getUniqueId(), onGraph);
1169                 Either<TitanVertex, TitanOperationStatus> createValueRes = titanGenericDao.createNode(propertyValue);
1170                 String capabiltyInstId = (String) titanGenericDao.getProperty(capabilityInstanceVertex, GraphPropertiesDictionary.UNIQUE_ID.getProperty());
1171                 if (createValueRes.isRight()) {
1172                         error = createValueRes.right().value();
1173                         if (log.isDebugEnabled()) {
1174                                 log.debug("Failed to create property value for capability instance {} {} {} {}", capabiltyInstId, ofRI, statusIs, error);
1175                         }
1176                 }
1177                 if (log.isTraceEnabled()) {
1178                         log.trace("After creating property values node {} {} {} {} ", propertyValue.getUniqueId(), onGraph, statusIs, error);
1179                 }
1180                 if (error == null) {
1181                         createdValue = createValueRes.left().value();
1182                         log.trace("Before creating relation from capability instance {} {} {}", capabilityInstanceId, toValue, propertyValue.getUniqueId());
1183                         createRelationRes = titanGenericDao.createEdge(capabilityInstanceVertex, createdValue, GraphEdgeLabels.PROPERTY_VALUE, props);
1184                         if (!createRelationRes.equals(TitanOperationStatus.OK)) {
1185                                 error = createRelationRes;
1186                                 if (log.isDebugEnabled()) {
1187                                         log.debug("Failed to create relation from capability instance {} {} {} {} {}", capabiltyInstId, toValue, propertyValue.getUniqueId(), statusIs, error);
1188                                 }
1189                         }
1190                         if (log.isTraceEnabled()) {
1191                                 log.trace("After creating relation from capability instance {} {} {} {} {} ", capabilityInstanceId, toValue, propertyValue.getUniqueId(), statusIs, error);
1192                         }
1193                 }
1194                 if (error == null) {
1195                         log.trace("Before creating relation from property value {} {} {} ", createdValue, toProperty, propertyData.getUniqueId());
1196                         createRelationRes = titanGenericDao.createEdge(createdValue, propertyData, GraphEdgeLabels.PROPERTY_IMPL, props);
1197                         if (!createRelationRes.equals(TitanOperationStatus.OK)) {
1198                                 error = createRelationRes;
1199                                 if (log.isDebugEnabled()) {
1200                                         log.debug("Failed to create relation from property value {} {} {} {} {}", propertyValue.getUniqueId(), toProperty, propertyId, statusIs, error);
1201                                 }
1202                         }
1203                         if (log.isTraceEnabled()) {
1204                                 log.trace("Before creating relation from property value c", createdValue, toProperty, propertyData.getUniqueId(), statusIs, error);
1205                         }
1206                 }
1207                 if (log.isTraceEnabled()) {
1208                         log.trace("After cloning property values {} {} {} {} {}", propertyValueID, ofCI, capabilityInstanceId, statusIs, error);
1209                 }
1210                 if (error == null) {
1211                         return TitanOperationStatus.OK;
1212                 }
1213                 return error;
1214         }
1215 }