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