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