catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/impl/ComponentInstanceOperation.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * SDC
   4  * ================================================================================
   5  * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
   6  * ================================================================================
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  * ============LICENSE_END=========================================================
  19  */
  20
  21 package org.openecomp.sdc.be.model.operations.impl;
  22
  23 import fj.F;
  24 import org.janusgraph.core.JanusGraph;
  25 import org.janusgraph.core.JanusGraphVertex;
  26 import fj.data.Either;
  27 import java.util.HashMap;
  28 import java.util.Map;
  29 import java.util.UUID;
  30 import java.util.function.Supplier;
  31 import org.apache.commons.lang3.tuple.ImmutablePair;
  32 import org.apache.tinkerpop.gremlin.structure.Vertex;
  33 import org.apache.tinkerpop.gremlin.structure.VertexProperty;
  34 import org.openecomp.sdc.be.config.BeEcompErrorManager;
  35 import org.openecomp.sdc.be.config.BeEcompErrorManager.ErrorSeverity;
  36 import org.openecomp.sdc.be.dao.graph.datatype.GraphEdge;
  37 import org.openecomp.sdc.be.dao.graph.datatype.GraphNode;
  38 import org.openecomp.sdc.be.dao.graph.datatype.GraphRelation;
  39 import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus;
  40 import org.openecomp.sdc.be.dao.neo4j.GraphEdgeLabels;
  41 import org.openecomp.sdc.be.dao.neo4j.GraphEdgePropertiesDictionary;
  42 import org.openecomp.sdc.be.dao.neo4j.GraphPropertiesDictionary;
  43 import org.openecomp.sdc.be.dao.janusgraph.HealingJanusGraphGenericDao;
  44 import org.openecomp.sdc.be.datatypes.elements.PropertyDataDefinition;
  45 import org.openecomp.sdc.be.datatypes.elements.SchemaDefinition;
  46 import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
  47 import org.openecomp.sdc.be.model.ComponentInstance;
  48 import org.openecomp.sdc.be.model.ComponentInstanceInput;
  49 import org.openecomp.sdc.be.model.ComponentInstanceProperty;
  50 import org.openecomp.sdc.be.model.DataTypeDefinition;
  51 import org.openecomp.sdc.be.model.IComponentInstanceConnectedElement;
  52 import org.openecomp.sdc.be.model.cache.ApplicationDataTypeCache;
  53 import org.openecomp.sdc.be.model.operations.api.IInputsOperation;
  54 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
  55 import org.openecomp.sdc.be.model.tosca.ToscaPropertyType;
  56 import org.openecomp.sdc.be.resources.data.AttributeData;
  57 import org.openecomp.sdc.be.resources.data.AttributeValueData;
  58 import org.openecomp.sdc.be.resources.data.ComponentInstanceData;
  59 import org.openecomp.sdc.be.resources.data.InputValueData;
  60 import org.openecomp.sdc.be.resources.data.InputsData;
  61 import org.openecomp.sdc.common.datastructure.Wrapper;
  62 import org.openecomp.sdc.common.log.wrappers.Logger;
  63 import org.springframework.beans.factory.annotation.Autowired;
  64
  65 @org.springframework.stereotype.Component("component-instance-operation")
  66 public class ComponentInstanceOperation extends AbstractOperation {
  67
  68     public ComponentInstanceOperation() {
  69         super();
  70     }
  71
  72     private static final Logger log = Logger.getLogger(ComponentInstanceOperation.class.getName());
  73
  74     @Autowired
  75     PropertyOperation propertyOperation;
  76
  77     @Autowired
  78     private IInputsOperation inputOperation;
  79
  80     @Autowired
  81     private ApplicationDataTypeCache dataTypeCache;
  82
  83     /**
  84      * FOR TEST ONLY
  85      *
  86      * @param janusGraphGenericDao
  87      */
  88     public void setJanusGraphGenericDao(HealingJanusGraphGenericDao janusGraphGenericDao) {
  89         this.janusGraphGenericDao = janusGraphGenericDao;
  90     }
  91
  92     public Either<Integer, StorageOperationStatus> increaseAndGetResourceInstanceSpecificCounter(String resourceInstanceId, GraphPropertiesDictionary counterType, boolean inTransaction) {
  93
  94         Either<Integer, StorageOperationStatus> result = null;
  95         try {
  96
  97             Either<JanusGraph, JanusGraphOperationStatus> graphResult = janusGraphGenericDao.getGraph();
  98             if (graphResult.isRight()) {
  99                 result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(graphResult.right().value()));
 100                 return result;
 101             }
 102             Either<JanusGraphVertex, JanusGraphOperationStatus> vertexService = janusGraphGenericDao
 103                 .getVertexByProperty(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.ResourceInstance), resourceInstanceId);
 104             if (vertexService.isRight()) {
 105                 log.debug("failed to fetch vertex of resource instance for id = {}", resourceInstanceId);
 106                 return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(vertexService.right().value()));
 107             }
 108             Vertex vertex = vertexService.left().value();
 109
 110             VertexProperty<Object> vertexProperty = vertex.property(counterType.getProperty());
 111             Integer counter = 0;
 112             if (vertexProperty.isPresent()) {
 113                 if (vertexProperty.value() != null) {
 114                     counter = (Integer) vertexProperty.value();
 115                 }
 116             }
 117
 118             counter++;
 119             vertex.property(counterType.getProperty(), counter);
 120
 121             result = Either.left(counter);
 122             return result;
 123
 124         } finally {
 125             if (!inTransaction) {
 126                 if (result == null || result.isRight()) {
 127                     log.error("increaseAndGetResourceInstanceSpecificCounter operation : Going to execute rollback on graph.");
 128                     janusGraphGenericDao.rollback();
 129                 } else {
 130                     log.debug("increaseAndGetResourceInstanceSpecificCounter operation : Going to execute commit on graph.");
 131                     janusGraphGenericDao.commit();
 132                 }
 133             }
 134         }
 135
 136     }
 137
 138     private void connectAttValueDataToComponentInstanceData(Wrapper<JanusGraphOperationStatus> errorWrapper, ComponentInstanceData compIns, AttributeValueData attValueData) {
 139
 140         Either<GraphRelation, JanusGraphOperationStatus> createRelResult = janusGraphGenericDao
 141             .createRelation(compIns, attValueData, GraphEdgeLabels.ATTRIBUTE_VALUE, null);
 142
 143         if (createRelResult.isRight()) {
 144             JanusGraphOperationStatus operationStatus = createRelResult.right().value();
 145             errorWrapper.setInnerElement(operationStatus);
 146             BeEcompErrorManager.getInstance().logInternalFlowError("connectAttValueDataToComponentInstanceData",
 147                     "Failed to associate resource instance " + compIns.getUniqueId() + " attribute value " + attValueData.getUniqueId() + " in graph. status is " + operationStatus, ErrorSeverity.ERROR);
 148         }
 149     }
 150
 151     private void connectAttValueDataToAttData(Wrapper<JanusGraphOperationStatus> errorWrapper, AttributeData attData, AttributeValueData attValueData) {
 152
 153         Either<GraphRelation, JanusGraphOperationStatus> createRelResult = janusGraphGenericDao
 154             .createRelation(attValueData, attData, GraphEdgeLabels.ATTRIBUTE_IMPL, null);
 155
 156         if (createRelResult.isRight()) {
 157             JanusGraphOperationStatus operationStatus = createRelResult.right().value();
 158             BeEcompErrorManager.getInstance().logInternalFlowError("connectAttValueDataToAttData",
 159                     "Failed to associate attribute value " + attValueData.getUniqueId() + " to attribute " + attData.getUniqueId() + " in graph. status is " + operationStatus, ErrorSeverity.ERROR);
 160
 161             errorWrapper.setInnerElement(operationStatus);
 162         }
 163     }
 164
 165     private void createAttributeValueDataNode(ComponentInstanceProperty attributeInstanceProperty, Integer index, Wrapper<JanusGraphOperationStatus> errorWrapper, ComponentInstanceData resourceInstanceData,
 166                                               Wrapper<AttributeValueData> attValueDataWrapper) {
 167         String valueUniqueUid = attributeInstanceProperty.getValueUniqueUid();
 168         if (valueUniqueUid == null) {
 169
 170             String attValueDatauniqueId = UniqueIdBuilder.buildResourceInstanceAttributeValueUid(resourceInstanceData.getUniqueId(), index);
 171             AttributeValueData attributeValueData = buildAttributeValueDataFromComponentInstanceAttribute(attributeInstanceProperty, attValueDatauniqueId);
 172
 173             log.debug("Before adding attribute value to graph {}", attributeValueData);
 174             Either<AttributeValueData, JanusGraphOperationStatus> createNodeResult = janusGraphGenericDao
 175                 .createNode(attributeValueData, AttributeValueData.class);
 176             log.debug("After adding attribute value to graph {}", attributeValueData);
 177
 178             if (createNodeResult.isRight()) {
 179                 JanusGraphOperationStatus operationStatus = createNodeResult.right().value();
 180                 errorWrapper.setInnerElement(operationStatus);
 181             } else {
 182                 attValueDataWrapper.setInnerElement(createNodeResult.left().value());
 183             }
 184
 185         } else {
 186             BeEcompErrorManager.getInstance().logInternalFlowError("CreateAttributeValueDataNode", "attribute value already exists.", ErrorSeverity.ERROR);
 187             errorWrapper.setInnerElement(JanusGraphOperationStatus.ALREADY_EXIST);
 188         }
 189     }
 190
 191     private AttributeValueData buildAttributeValueDataFromComponentInstanceAttribute(ComponentInstanceProperty resourceInstanceAttribute, String uniqueId) {
 192         AttributeValueData attributeValueData = new AttributeValueData();
 193         attributeValueData.setUniqueId(uniqueId);
 194         attributeValueData.setHidden(resourceInstanceAttribute.isHidden());
 195         attributeValueData.setValue(resourceInstanceAttribute.getValue());
 196         attributeValueData.setType(resourceInstanceAttribute.getType());
 197         long currentTimeMillis = System.currentTimeMillis();
 198         attributeValueData.setCreationTime(currentTimeMillis);
 199         attributeValueData.setModificationTime(currentTimeMillis);
 200         return attributeValueData;
 201     }
 202
 203     private static final class UpdateDataContainer<SomeData, SomeValueData> {
 204         final Wrapper<SomeValueData> valueDataWrapper;
 205         final Wrapper<SomeData> dataWrapper;
 206         final GraphEdgeLabels graphEdge;
 207         final Supplier<Class<SomeData>> someDataClassGen;
 208         final Supplier<Class<SomeValueData>> someValueDataClassGen;
 209         final NodeTypeEnum nodeType;
 210         final NodeTypeEnum nodeTypeValue;
 211
 212         private UpdateDataContainer(GraphEdgeLabels graphEdge, Supplier<Class<SomeData>> someDataClassGen, Supplier<Class<SomeValueData>> someValueDataClassGen, NodeTypeEnum nodeType, NodeTypeEnum nodeTypeValue) {
 213             super();
 214             this.valueDataWrapper = new Wrapper<>();
 215             this.dataWrapper = new Wrapper<>();
 216             this.graphEdge = graphEdge;
 217             this.someDataClassGen = someDataClassGen;
 218             this.someValueDataClassGen = someValueDataClassGen;
 219             this.nodeType = nodeType;
 220             this.nodeTypeValue = nodeTypeValue;
 221         }
 222
 223         public Wrapper<SomeValueData> getValueDataWrapper() {
 224             return valueDataWrapper;
 225         }
 226
 227         public Wrapper<SomeData> getDataWrapper() {
 228             return dataWrapper;
 229         }
 230
 231         public GraphEdgeLabels getGraphEdge() {
 232             return graphEdge;
 233         }
 234
 235         public Supplier<Class<SomeData>> getSomeDataClassGen() {
 236             return someDataClassGen;
 237         }
 238
 239         public Supplier<Class<SomeValueData>> getSomeValueDataClassGen() {
 240             return someValueDataClassGen;
 241         }
 242
 243         public NodeTypeEnum getNodeType() {
 244             return nodeType;
 245         }
 246
 247         public NodeTypeEnum getNodeTypeValue() {
 248             return nodeTypeValue;
 249         }
 250     }
 251
 252     /**
 253      * update value of attribute on resource instance
 254      *
 255      * @param resourceInstanceAttribute
 256      * @param resourceInstanceId
 257      * @return
 258      */
 259     private Either<AttributeValueData, JanusGraphOperationStatus> updateAttributeOfResourceInstance(ComponentInstanceProperty resourceInstanceAttribute, String resourceInstanceId) {
 260         Wrapper<JanusGraphOperationStatus> errorWrapper = new Wrapper<>();
 261         UpdateDataContainer<AttributeData, AttributeValueData> updateDataContainer = new UpdateDataContainer<>(GraphEdgeLabels.ATTRIBUTE_IMPL, (() -> AttributeData.class), (() -> AttributeValueData.class), NodeTypeEnum.Attribute,
 262                 NodeTypeEnum.AttributeValue);
 263         preUpdateElementOfResourceInstanceValidations(updateDataContainer, resourceInstanceAttribute, resourceInstanceId, errorWrapper);
 264         if (errorWrapper.isEmpty()) {
 265             AttributeValueData attributeValueData = updateDataContainer.getValueDataWrapper().getInnerElement();
 266             attributeValueData.setHidden(resourceInstanceAttribute.isHidden());
 267             attributeValueData.setValue(resourceInstanceAttribute.getValue());
 268
 269             return janusGraphGenericDao.updateNode(
 270                 attributeValueData, AttributeValueData.class
 271             );
 272         } else {
 273             return Either.right(errorWrapper.getInnerElement());
 274         }
 275     }
 276
 277     private Either<AttributeValueData, JanusGraphOperationStatus> addAttributeToResourceInstance(ComponentInstanceProperty attributeInstanceProperty, String resourceInstanceId, Integer index) {
 278         Wrapper<JanusGraphOperationStatus> errorWrapper = new Wrapper<>();
 279         Wrapper<ComponentInstanceData> compInsWrapper = new Wrapper<>();
 280         Wrapper<AttributeData> attDataWrapper = new Wrapper<>();
 281         Wrapper<AttributeValueData> attValueDataWrapper = new Wrapper<>();
 282
 283         // Verify RI Exist
 284         validateRIExist(resourceInstanceId, compInsWrapper, errorWrapper);
 285
 286         if (errorWrapper.isEmpty()) {
 287             // Verify Attribute Exist
 288             validateElementExistInGraph(attributeInstanceProperty.getUniqueId(), NodeTypeEnum.Attribute, () -> AttributeData.class, attDataWrapper, errorWrapper);
 289         }
 290         if (errorWrapper.isEmpty()) {
 291             // Create AttributeValueData that is connected to RI
 292             createAttributeValueDataNode(attributeInstanceProperty, index, errorWrapper, compInsWrapper.getInnerElement(), attValueDataWrapper);
 293         }
 294         if (errorWrapper.isEmpty()) {
 295             // Connect AttributeValueData (Att on RI) to AttData (Att on
 296             // Resource)
 297             connectAttValueDataToAttData(errorWrapper, attDataWrapper.getInnerElement(), attValueDataWrapper.getInnerElement());
 298         }
 299         if (errorWrapper.isEmpty()) {
 300             // Connect AttributeValueData to RI
 301             connectAttValueDataToComponentInstanceData(errorWrapper, compInsWrapper.getInnerElement(), attValueDataWrapper.getInnerElement());
 302         }
 303
 304         if (errorWrapper.isEmpty()) {
 305             return Either.left(attValueDataWrapper.getInnerElement());
 306         } else {
 307             return Either.right(errorWrapper.getInnerElement());
 308         }
 309
 310     }
 311
 312     private <SomeData extends GraphNode, SomeValueData extends GraphNode> void preUpdateElementOfResourceInstanceValidations(UpdateDataContainer<SomeData, SomeValueData> updateDataContainer, IComponentInstanceConnectedElement resourceInstanceProerty,
 313             String resourceInstanceId, Wrapper<JanusGraphOperationStatus> errorWrapper) {
 314
 315         if (errorWrapper.isEmpty()) {
 316             // Verify VFC instance Exist
 317             validateRIExist(resourceInstanceId, errorWrapper);
 318         }
 319
 320         if (errorWrapper.isEmpty()) {
 321             // Example: Verify Property connected to VFC exist
 322             validateElementConnectedToComponentExist(updateDataContainer, resourceInstanceProerty, errorWrapper);
 323         }
 324
 325         if (errorWrapper.isEmpty()) {
 326             // Example: Verify PropertyValue connected to VFC Instance exist
 327             validateElementConnectedToComponentInstanceExist(updateDataContainer, resourceInstanceProerty, errorWrapper);
 328         }
 329
 330         if (errorWrapper.isEmpty()) {
 331             // Example: Verify PropertyValue connected Property
 332             validateElementConnectedToInstance(updateDataContainer, resourceInstanceProerty, errorWrapper);
 333         }
 334     }
 335
 336     private <SomeData extends GraphNode, SomeValueData extends GraphNode> void validateElementConnectedToInstance(UpdateDataContainer<SomeData, SomeValueData> updateDataContainer, IComponentInstanceConnectedElement resourceInstanceProerty,
 337             Wrapper<JanusGraphOperationStatus> errorWrapper) {
 338         Either<ImmutablePair<SomeData, GraphEdge>, JanusGraphOperationStatus> child = janusGraphGenericDao
 339             .getChild(UniqueIdBuilder.getKeyByNodeType(updateDataContainer.getNodeTypeValue()), resourceInstanceProerty.getValueUniqueUid(),
 340                 updateDataContainer.getGraphEdge(), updateDataContainer.getNodeType(), updateDataContainer.getSomeDataClassGen().get());
 341
 342         if (child.isRight()) {
 343             JanusGraphOperationStatus status = child.right().value();
 344             if (status == JanusGraphOperationStatus.NOT_FOUND) {
 345                 status = JanusGraphOperationStatus.INVALID_ID;
 346             }
 347             errorWrapper.setInnerElement(status);
 348
 349         } else {
 350             updateDataContainer.getDataWrapper().setInnerElement(child.left().value().left);
 351         }
 352     }
 353
 354     private <SomeValueData extends GraphNode, SomeData extends GraphNode> void validateElementConnectedToComponentInstanceExist(UpdateDataContainer<SomeData, SomeValueData> updateDataContainer,
 355             IComponentInstanceConnectedElement resourceInstanceProerty, Wrapper<JanusGraphOperationStatus> errorWrapper) {
 356         String valueUniqueUid = resourceInstanceProerty.getValueUniqueUid();
 357         if (valueUniqueUid == null) {
 358             errorWrapper.setInnerElement(JanusGraphOperationStatus.INVALID_ID);
 359         } else {
 360             Either<SomeValueData, JanusGraphOperationStatus> findPropertyValueRes = janusGraphGenericDao
 361                 .getNode(UniqueIdBuilder.getKeyByNodeType(updateDataContainer.getNodeTypeValue()), valueUniqueUid, updateDataContainer.getSomeValueDataClassGen().get());
 362             if (findPropertyValueRes.isRight()) {
 363                 JanusGraphOperationStatus status = findPropertyValueRes.right().value();
 364                 if (status == JanusGraphOperationStatus.NOT_FOUND) {
 365                     status = JanusGraphOperationStatus.INVALID_ID;
 366                 }
 367                 errorWrapper.setInnerElement(status);
 368             } else {
 369                 updateDataContainer.getValueDataWrapper().setInnerElement(findPropertyValueRes.left().value());
 370             }
 371         }
 372     }
 373
 374     private <SomeData extends GraphNode, SomeValueData extends GraphNode> void validateElementConnectedToComponentExist(UpdateDataContainer<SomeData, SomeValueData> updateDataContainer,
 375             IComponentInstanceConnectedElement resourceInstanceElementConnected, Wrapper<JanusGraphOperationStatus> errorWrapper) {
 376         String uniqueId = resourceInstanceElementConnected.getUniqueId();
 377         Either<SomeData, JanusGraphOperationStatus> findPropertyDefRes = janusGraphGenericDao
 378             .getNode(UniqueIdBuilder.getKeyByNodeType(updateDataContainer.getNodeType()), uniqueId, updateDataContainer.getSomeDataClassGen().get());
 379
 380         if (findPropertyDefRes.isRight()) {
 381             JanusGraphOperationStatus status = findPropertyDefRes.right().value();
 382             errorWrapper.setInnerElement(status);
 383         }
 384     }
 385
 386     private void validateRIExist(String resourceInstanceId, Wrapper<JanusGraphOperationStatus> errorWrapper) {
 387         validateRIExist(resourceInstanceId, null, errorWrapper);
 388     }
 389
 390     private void validateRIExist(String resourceInstanceId, Wrapper<ComponentInstanceData> compInsDataWrapper, Wrapper<JanusGraphOperationStatus> errorWrapper) {
 391         validateElementExistInGraph(resourceInstanceId, NodeTypeEnum.ResourceInstance, () -> ComponentInstanceData.class, compInsDataWrapper, errorWrapper);
 392     }
 393
 394     public <ElementData extends GraphNode> void validateElementExistInGraph(String elementUniqueId, NodeTypeEnum elementNodeType, Supplier<Class<ElementData>> elementClassGen, Wrapper<ElementData> elementDataWrapper,
 395             Wrapper<JanusGraphOperationStatus> errorWrapper) {
 396         Either<ElementData, JanusGraphOperationStatus> findResInstanceRes = janusGraphGenericDao
 397             .getNode(UniqueIdBuilder.getKeyByNodeType(elementNodeType), elementUniqueId, elementClassGen.get());
 398         if (findResInstanceRes.isRight()) {
 399             JanusGraphOperationStatus status = findResInstanceRes.right().value();
 400             if (status == JanusGraphOperationStatus.NOT_FOUND) {
 401                 status = JanusGraphOperationStatus.INVALID_ID;
 402             }
 403             errorWrapper.setInnerElement(status);
 404         } else {
 405             if (elementDataWrapper != null) {
 406                 elementDataWrapper.setInnerElement(findResInstanceRes.left().value());
 407             }
 408         }
 409     }
 410
 411     /**
 412      * add property to resource instance
 413      *
 414      * @param resourceInstanceId
 415      * @param index
 416      * @return
 417      */
 418     private Either<InputValueData, JanusGraphOperationStatus> addInputToResourceInstance(ComponentInstanceInput resourceInstanceInput, String resourceInstanceId, Integer index) {
 419
 420         Either<ComponentInstanceData, JanusGraphOperationStatus> findResInstanceRes = janusGraphGenericDao
 421             .getNode(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.ResourceInstance), resourceInstanceId, ComponentInstanceData.class);
 422
 423         if (findResInstanceRes.isRight()) {
 424             JanusGraphOperationStatus status = findResInstanceRes.right().value();
 425             if (status == JanusGraphOperationStatus.NOT_FOUND) {
 426                 status = JanusGraphOperationStatus.INVALID_ID;
 427             }
 428             return Either.right(status);
 429         }
 430
 431         String propertyId = resourceInstanceInput.getUniqueId();
 432         Either<InputsData, JanusGraphOperationStatus> findPropertyDefRes = janusGraphGenericDao
 433             .getNode(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.Input), propertyId, InputsData.class);
 434
 435         if (findPropertyDefRes.isRight()) {
 436             JanusGraphOperationStatus status = findPropertyDefRes.right().value();
 437             if (status == JanusGraphOperationStatus.NOT_FOUND) {
 438                 status = JanusGraphOperationStatus.INVALID_ID;
 439             }
 440             return Either.right(status);
 441         }
 442
 443         String valueUniqueUid = resourceInstanceInput.getValueUniqueUid();
 444         if (valueUniqueUid == null) {
 445
 446             InputsData propertyData = findPropertyDefRes.left().value();
 447
 448             ComponentInstanceData resourceInstanceData = findResInstanceRes.left().value();
 449
 450             ImmutablePair<JanusGraphOperationStatus, String> isInputValueExists = inputOperation.findInputValue(resourceInstanceId, propertyId);
 451             if (isInputValueExists.getLeft() == JanusGraphOperationStatus.ALREADY_EXIST) {
 452                 log.debug("The property {} already added to the resource instance {}", propertyId, resourceInstanceId);
 453                 resourceInstanceInput.setValueUniqueUid(isInputValueExists.getRight());
 454             }
 455
 456             if (isInputValueExists.getLeft() != JanusGraphOperationStatus.NOT_FOUND) {
 457                 log.debug("After finding input value of {} on componenet instance {}", propertyId, resourceInstanceId);
 458                 return Either.right(isInputValueExists.getLeft());
 459             }
 460
 461             String innerType = null;
 462
 463             PropertyDataDefinition propDataDef = propertyData.getPropertyDataDefinition();
 464             String propertyType = propDataDef.getType();
 465             String value = resourceInstanceInput.getValue();
 466             ToscaPropertyType type = ToscaPropertyType.isValidType(propertyType);
 467
 468             if (type == ToscaPropertyType.LIST || type == ToscaPropertyType.MAP) {
 469                 SchemaDefinition def = propDataDef.getSchema();
 470                 if (def == null) {
 471                     log.debug("Schema doesn't exists for property of type {}", type);
 472                     return Either.right(JanusGraphOperationStatus.ILLEGAL_ARGUMENT);
 473                 }
 474                 PropertyDataDefinition propDef = def.getProperty();
 475                 if (propDef == null) {
 476                     log.debug("Property in Schema Definition inside property of type {} doesn't exist", type);
 477                     return Either.right(JanusGraphOperationStatus.ILLEGAL_ARGUMENT);
 478                 }
 479                 innerType = propDef.getType();
 480             }
 481
 482             log.debug("Before validateAndUpdatePropertyValue");
 483             Either<Map<String, DataTypeDefinition>, JanusGraphOperationStatus> allDataTypes = dataTypeCache.getAll();
 484             if (allDataTypes.isRight()) {
 485                 JanusGraphOperationStatus status = allDataTypes.right().value();
 486                 BeEcompErrorManager.getInstance().logInternalFlowError("UpdatePropertyValueOnComponentInstance", "Failed to update property value on instance. Status is " + status, ErrorSeverity.ERROR);
 487                 return Either.right(status);
 488             }
 489
 490             String uniqueId = UniqueIdBuilder.buildResourceInstanceInputValueUid(resourceInstanceData.getUniqueId(), index);
 491             InputValueData propertyValueData = new InputValueData();
 492             propertyValueData.setUniqueId(uniqueId);
 493             propertyValueData.setValue(value);
 494
 495             log.debug("Before validateAndUpdateRules");
 496             ImmutablePair<String, Boolean> pair = propertyOperation.validateAndUpdateRules(propertyType, resourceInstanceInput.getRules(), innerType, allDataTypes.left().value(), true);
 497             log.debug("After validateAndUpdateRules. pair = {} ", pair);
 498             if (pair.getRight() != null && !pair.getRight()) {
 499                 BeEcompErrorManager.getInstance().logBeInvalidValueError("Add property value", pair.getLeft(), resourceInstanceInput.getName(), propertyType);
 500                 return Either.right(JanusGraphOperationStatus.ILLEGAL_ARGUMENT);
 501             }
 502             log.debug("Before adding property value to graph {}", propertyValueData);
 503             Either<InputValueData, JanusGraphOperationStatus> createNodeResult = janusGraphGenericDao
 504                 .createNode(propertyValueData, InputValueData.class);
 505             log.debug("After adding property value to graph {}", propertyValueData);
 506
 507             if (createNodeResult.isRight()) {
 508                 JanusGraphOperationStatus operationStatus = createNodeResult.right().value();
 509                 return Either.right(operationStatus);
 510             }
 511
 512             Either<GraphRelation, JanusGraphOperationStatus> createRelResult = janusGraphGenericDao
 513                 .createRelation(propertyValueData, propertyData, GraphEdgeLabels.INPUT_IMPL, null);
 514
 515             if (createRelResult.isRight()) {
 516                 JanusGraphOperationStatus operationStatus = createRelResult.right().value();
 517                 log.error("Failed to associate property value {} to property {} in graph. status is {}", uniqueId, propertyId, operationStatus);
 518                 return Either.right(operationStatus);
 519             }
 520
 521             Map<String, Object> properties1 = new HashMap<>();
 522
 523             properties1.put(GraphEdgePropertiesDictionary.NAME.getProperty(), resourceInstanceData.getComponentInstDataDefinition().getName());
 524             properties1.put(GraphEdgePropertiesDictionary.OWNER_ID.getProperty(), resourceInstanceData.getComponentInstDataDefinition().getUniqueId());
 525
 526             createRelResult = janusGraphGenericDao
 527                 .createRelation(resourceInstanceData, propertyValueData, GraphEdgeLabels.INPUT_VALUE, properties1);
 528
 529             if (createRelResult.isRight()) {
 530                 JanusGraphOperationStatus operationStatus = createNodeResult.right().value();
 531                 log.error("Failed to associate resource instance {} property value {} in graph. status is {}", resourceInstanceId, uniqueId, operationStatus);
 532                 return Either.right(operationStatus);
 533
 534             }
 535
 536             return Either.left(createNodeResult.left().value());
 537         } else {
 538             log.error("property value already exists.");
 539             return Either.right(JanusGraphOperationStatus.ALREADY_EXIST);
 540         }
 541
 542     }
 543
 544     public Either<ComponentInstanceProperty, StorageOperationStatus> addAttributeValueToResourceInstance(ComponentInstanceProperty resourceInstanceAttribute, String resourceInstanceId, Integer index, boolean inTransaction) {
 545         Either<ComponentInstanceProperty, StorageOperationStatus> result = null;
 546
 547         try {
 548
 549             Either<AttributeValueData, JanusGraphOperationStatus> eitherStatus = this.addAttributeToResourceInstance(resourceInstanceAttribute, resourceInstanceId, index);
 550
 551             if (eitherStatus.isRight()) {
 552                 log.error("Failed to add attribute value {} to resource instance {} in Graph. status is {}", resourceInstanceAttribute, resourceInstanceId, eitherStatus.right().value().name());
 553                 result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(eitherStatus.right().value()));
 554                 return result;
 555             } else {
 556                 AttributeValueData attributeValueData = eitherStatus.left().value();
 557
 558                 ComponentInstanceProperty attributeValueResult = buildResourceInstanceAttribute(attributeValueData, resourceInstanceAttribute);
 559                 log.debug("The returned ResourceInstanceAttribute is {}", attributeValueResult);
 560
 561                 result = Either.left(attributeValueResult);
 562                 return result;
 563             }
 564         }
 565
 566         finally {
 567             handleTransactionCommitRollback(inTransaction, result);
 568         }
 569     }
 570
 571     private ComponentInstanceProperty buildResourceInstanceAttribute(AttributeValueData attributeValueData, ComponentInstanceProperty resourceInstanceAttribute) {
 572         Boolean hidden = attributeValueData.isHidden();
 573         String uid = attributeValueData.getUniqueId();
 574         return new ComponentInstanceProperty(hidden, resourceInstanceAttribute, uid);
 575     }
 576
 577     public Either<ComponentInstanceProperty, StorageOperationStatus> updateAttributeValueInResourceInstance(
 578         ComponentInstanceProperty resourceInstanceAttribute,
 579         String resourceInstanceId,
 580         boolean inTransaction
 581     ) {
 582         //TODO This null could bubble up. Shouldn't we set a default value (such as Either.left(StorageOperationStatus.GENERAL_ERROR)) ?
 583         Either<ComponentInstanceProperty, StorageOperationStatus> result = null;
 584         try {
 585             result = updateAttributeOfResourceInstance(resourceInstanceAttribute, resourceInstanceId)
 586                 .bimap(
 587                     buildResourceInstanceAttribute(resourceInstanceAttribute),
 588                     handleFailedAttributeAdditionError(resourceInstanceAttribute, resourceInstanceId));
 589         } finally {
 590             handleTransactionCommitRollback(inTransaction, result);
 591         }
 592         return result;
 593     }
 594
 595     private F<JanusGraphOperationStatus, StorageOperationStatus> handleFailedAttributeAdditionError(
 596         ComponentInstanceProperty resourceInstanceAttribute, String resourceInstanceId) {
 597         return status -> {
 598             log.error("Failed to add attribute value {} to resource instance {} in Graph. status is {}",
 599                 resourceInstanceAttribute, resourceInstanceId, status.name());
 600             return DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status);
 601         };
 602     }
 603
 604     private F<AttributeValueData, ComponentInstanceProperty> buildResourceInstanceAttribute(
 605         ComponentInstanceProperty resourceInstanceAttribute) {
 606         return attributeValueData -> {
 607             ComponentInstanceProperty attributeValueResult =
 608                 buildResourceInstanceAttribute(attributeValueData, resourceInstanceAttribute);
 609             log.debug("The returned ResourceInstanceAttribute is {}", attributeValueResult);
 610             return attributeValueResult;
 611         };
 612     }
 613
 614     public Either<ComponentInstanceInput, StorageOperationStatus> addInputValueToResourceInstance(ComponentInstanceInput resourceInstanceInput, String resourceInstanceId, Integer index, boolean inTransaction) {
 615
 616         /// #RULES SUPPORT
 617         /// Ignore rules received from client till support
 618         resourceInstanceInput.setRules(null);
 619         ///
 620         ///
 621
 622         Either<ComponentInstanceInput, StorageOperationStatus> result = null;
 623
 624         try {
 625
 626             Either<InputValueData, JanusGraphOperationStatus> eitherStatus = addInputToResourceInstance(resourceInstanceInput, resourceInstanceId, index);
 627
 628             if (eitherStatus.isRight()) {
 629                 log.error("Failed to add input value {} to resource instance {} in Graph. status is {}", resourceInstanceInput, resourceInstanceId, eitherStatus.right().value().name());
 630                 result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(eitherStatus.right().value()));
 631                 return result;
 632             } else {
 633                 InputValueData propertyValueData = eitherStatus.left().value();
 634
 635                 ComponentInstanceInput propertyValueResult = inputOperation.buildResourceInstanceInput(propertyValueData, resourceInstanceInput);
 636                 log.debug("The returned ResourceInstanceProperty is {}", propertyValueResult);
 637
 638                 Either<String, JanusGraphOperationStatus> findDefaultValue = propertyOperation.findDefaultValueFromSecondPosition(resourceInstanceInput.getPath(), resourceInstanceInput.getUniqueId(), resourceInstanceInput.getDefaultValue());
 639                 if (findDefaultValue.isRight()) {
 640                     result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(findDefaultValue.right().value()));
 641                     return result;
 642                 }
 643                 String defaultValue = findDefaultValue.left().value();
 644                 propertyValueResult.setDefaultValue(defaultValue);
 645                 log.debug("The returned default value in ResourceInstanceProperty is {}", defaultValue);
 646
 647                 result = Either.left(propertyValueResult);
 648                 return result;
 649             }
 650         }
 651
 652         finally {
 653             if (!inTransaction) {
 654                 if (result == null || result.isRight()) {
 655                     log.error("Going to execute rollback on graph.");
 656                     janusGraphGenericDao.rollback();
 657                 } else {
 658                     log.debug("Going to execute commit on graph.");
 659                     janusGraphGenericDao.commit();
 660                 }
 661             }
 662         }
 663
 664     }
 665
 666     public Either<ComponentInstanceInput, StorageOperationStatus> updateInputValueInResourceInstance(ComponentInstanceInput input, String resourceInstanceId, boolean b) {
 667         return null;
 668     }
 669
 670     public StorageOperationStatus updateCustomizationUUID(String componentInstanceId) {
 671         Either<JanusGraphVertex, JanusGraphOperationStatus> vertexByProperty = janusGraphGenericDao.getVertexByProperty(GraphPropertiesDictionary.UNIQUE_ID.getProperty(), componentInstanceId);
 672         if (vertexByProperty.isRight()) {
 673             log.debug("Failed to fetch component instance by id {} error {}", componentInstanceId, vertexByProperty.right().value());
 674             return DaoStatusConverter.convertJanusGraphStatusToStorageStatus(vertexByProperty.right().value());
 675         }
 676         UUID uuid = UUID.randomUUID();
 677         JanusGraphVertex ciVertex = vertexByProperty.left().value();
 678         ciVertex.property(GraphPropertiesDictionary.CUSTOMIZATION_UUID.getProperty(), uuid.toString());
 679
 680         return StorageOperationStatus.OK;
 681     }
 682
 683     public Either<ComponentInstanceData, StorageOperationStatus> updateComponentInstanceModificationTimeAndCustomizationUuidOnGraph(ComponentInstance componentInstance, NodeTypeEnum componentInstanceType, Long modificationTime, boolean inTransaction) {
 684
 685         log.debug("Going to update modification time of component instance {}. ", componentInstance.getName());
 686         Either<ComponentInstanceData, StorageOperationStatus> result = null;
 687         try{
 688             ComponentInstanceData componentData = new ComponentInstanceData(componentInstance, componentInstance.getGroupInstances().size());
 689             componentData.getComponentInstDataDefinition().setModificationTime(modificationTime);
 690             componentData.getComponentInstDataDefinition().setCustomizationUUID(UUID.randomUUID().toString());
 691             Either<ComponentInstanceData, JanusGraphOperationStatus> updateNode = janusGraphGenericDao
 692                 .updateNode(componentData, ComponentInstanceData.class);
 693             if (updateNode.isRight()) {
 694                 log.error("Failed to update resource {}. status is {}", componentInstance.getUniqueId(), updateNode.right().value());
 695                 result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(updateNode.right().value()));
 696             }else{
 697                 result = Either.left(updateNode.left().value());
 698             }
 699         }catch(Exception e){
 700             log.error("Exception occured during  update modification date of compomemt instance{}. The message is {}. ", componentInstance.getName(), e.getMessage(), e);
 701             result = Either.right(StorageOperationStatus.GENERAL_ERROR);
 702         }finally {
 703             if(!inTransaction){
 704                 if (result == null || result.isRight()) {
 705                     log.error("Going to execute rollback on graph.");
 706                     janusGraphGenericDao.rollback();
 707                 } else {
 708                     log.debug("Going to execute commit on graph.");
 709                     janusGraphGenericDao.commit();
 710                 }
 711             }
 712         }
 713         return result;
 714     }
 715 }