2 * ============LICENSE_START=======================================================
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
11 * http://www.apache.org/licenses/LICENSE-2.0
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=========================================================
21 package org.openecomp.sdc.be.model.jsonjanusgraph.operations;
23 import fj.data.Either;
24 import java.util.ArrayList;
25 import java.util.Collection;
26 import java.util.EnumSet;
27 import java.util.HashMap;
28 import java.util.HashSet;
29 import java.util.LinkedHashMap;
30 import java.util.List;
33 import java.util.regex.Pattern;
34 import java.util.stream.Collectors;
35 import org.apache.tinkerpop.gremlin.structure.Direction;
36 import org.apache.tinkerpop.gremlin.structure.Edge;
37 import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus;
38 import org.openecomp.sdc.be.dao.jsongraph.GraphVertex;
39 import org.openecomp.sdc.be.dao.jsongraph.types.EdgeLabelEnum;
40 import org.openecomp.sdc.be.dao.jsongraph.types.JsonParseFlagEnum;
41 import org.openecomp.sdc.be.dao.jsongraph.types.VertexTypeEnum;
42 import org.openecomp.sdc.be.datatypes.elements.AdditionalInfoParameterDataDefinition;
43 import org.openecomp.sdc.be.datatypes.elements.AttributeDataDefinition;
44 import org.openecomp.sdc.be.datatypes.elements.InterfaceDataDefinition;
45 import org.openecomp.sdc.be.datatypes.elements.ListCapabilityDataDefinition;
46 import org.openecomp.sdc.be.datatypes.elements.ListRequirementDataDefinition;
47 import org.openecomp.sdc.be.datatypes.elements.MapPropertiesDataDefinition;
48 import org.openecomp.sdc.be.datatypes.elements.PropertyDataDefinition;
49 import org.openecomp.sdc.be.datatypes.enums.GraphPropertyEnum;
50 import org.openecomp.sdc.be.datatypes.enums.JsonPresentationFields;
51 import org.openecomp.sdc.be.datatypes.tosca.ToscaDataDefinition;
52 import org.openecomp.sdc.be.model.ComponentParametersView;
53 import org.openecomp.sdc.be.model.DerivedNodeTypeResolver;
54 import org.openecomp.sdc.be.model.LifecycleStateEnum;
55 import org.openecomp.sdc.be.model.jsonjanusgraph.datamodel.NodeType;
56 import org.openecomp.sdc.be.model.jsonjanusgraph.datamodel.ToscaElement;
57 import org.openecomp.sdc.be.model.jsonjanusgraph.datamodel.ToscaElementTypeEnum;
58 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
59 import org.openecomp.sdc.be.model.operations.impl.DaoStatusConverter;
60 import org.openecomp.sdc.be.model.operations.impl.UniqueIdBuilder;
61 import org.openecomp.sdc.common.jsongraph.util.CommonUtility;
62 import org.openecomp.sdc.common.jsongraph.util.CommonUtility.LogLevelEnum;
63 import org.openecomp.sdc.common.log.wrappers.Logger;
64 import org.springframework.beans.factory.annotation.Qualifier;
66 @org.springframework.stereotype.Component("node-type-operation")
67 public class NodeTypeOperation extends ToscaElementOperation {
68 public static final Pattern uuidNewVersion = Pattern.compile("^\\d+.1");
69 public static final Pattern uuidNormativeNewVersion = Pattern.compile("^\\d+.0");
70 private static final Logger log = Logger.getLogger(NodeTypeOperation.class);
71 private DerivedNodeTypeResolver derivedResourceResolver;
74 public NodeTypeOperation(@Qualifier("derived-resource-resolver") DerivedNodeTypeResolver derivedNodeTypeResolver) {
75 this.derivedResourceResolver = derivedNodeTypeResolver;
78 public Either<NodeType, StorageOperationStatus> createNodeType(NodeType nodeType) {
80 nodeType.generateUUID();
82 nodeType = getResourceMetaDataFromResource(nodeType);
83 String resourceUniqueId = nodeType.getUniqueId();
84 if (resourceUniqueId == null) {
85 resourceUniqueId = UniqueIdBuilder.buildResourceUniqueId();
86 nodeType.setUniqueId(resourceUniqueId);
89 // get derived from resources
90 List<GraphVertex> derivedResources = null;
91 Either<List<GraphVertex>, StorageOperationStatus> derivedResourcesResult = findDerivedResources(nodeType);
92 if (derivedResourcesResult.isRight()) {
93 return Either.right(derivedResourcesResult.right().value());
95 derivedResources = derivedResourcesResult.left().value();
98 GraphVertex nodeTypeVertex = new GraphVertex(VertexTypeEnum.NODE_TYPE);
99 fillToscaElementVertexData(nodeTypeVertex, nodeType, JsonParseFlagEnum.ParseAll);
101 Either<GraphVertex, JanusGraphOperationStatus> createdVertex = janusGraphDao.createVertex(nodeTypeVertex);
102 if (createdVertex.isRight()) {
103 JanusGraphOperationStatus status = createdVertex.right().value();
104 log.error("Error returned after creating resource data node {}. status returned is ", nodeTypeVertex, status);
105 return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status));
107 nodeTypeVertex = createdVertex.left().value();
109 StorageOperationStatus assosiateCommon = assosiateCommonForToscaElement(nodeTypeVertex, nodeType, derivedResources);
110 if (assosiateCommon != StorageOperationStatus.OK) {
111 return Either.right(assosiateCommon);
114 StorageOperationStatus associateDerived = assosiateToDerived(nodeTypeVertex, derivedResources);
115 if (associateDerived != StorageOperationStatus.OK) {
116 return Either.right(associateDerived);
118 StorageOperationStatus associateCategory = assosiateResourceMetadataToCategory(nodeTypeVertex, nodeType);
119 if (associateCategory != StorageOperationStatus.OK) {
120 return Either.right(associateCategory);
123 StorageOperationStatus associateAttributes = associateAttributesToResource(nodeTypeVertex, nodeType, derivedResources);
124 if (associateAttributes != StorageOperationStatus.OK) {
125 return Either.right(associateAttributes);
128 StorageOperationStatus associateRequirements = associateRequirementsToResource(nodeTypeVertex, nodeType, derivedResources);
129 if (associateRequirements != StorageOperationStatus.OK) {
130 return Either.right(associateRequirements);
133 StorageOperationStatus associateCapabilities = associateCapabilitiesToResource(nodeTypeVertex, nodeType, derivedResources);
134 if (associateCapabilities != StorageOperationStatus.OK) {
135 return Either.right(associateCapabilities);
137 StorageOperationStatus associateCapabilitiesProps = associateCapabilitiesPropertiesToResource(nodeTypeVertex, nodeType, derivedResources);
138 if (associateCapabilitiesProps != StorageOperationStatus.OK) {
139 return Either.right(associateCapabilitiesProps);
142 StorageOperationStatus associateInterfaces = associateInterfacesToResource(nodeTypeVertex, nodeType, derivedResources);
143 if (associateInterfaces != StorageOperationStatus.OK) {
144 return Either.right(associateInterfaces);
147 StorageOperationStatus addAdditionalInformation = addAdditionalInformationToResource(nodeTypeVertex, nodeType, derivedResources);
148 if (addAdditionalInformation != StorageOperationStatus.OK) {
149 return Either.right(addAdditionalInformation);
151 return Either.left(nodeType);
154 private StorageOperationStatus associateInterfacesToResource(GraphVertex nodeTypeVertex, NodeType nodeType, List<GraphVertex> derivedResources) {
155 // Note : currently only one derived supported!!!!
156 Either<Map<String, InterfaceDataDefinition>, StorageOperationStatus> dataFromDerived = getDataFromDerived(derivedResources, EdgeLabelEnum.INTERFACE_ARTIFACTS);
157 if (dataFromDerived.isRight()) {
158 return dataFromDerived.right().value();
160 Map<String, InterfaceDataDefinition> interfacArtsAll = dataFromDerived.left().value();
162 Map<String, InterfaceDataDefinition> interfacArts = nodeType.getInterfaceArtifacts();
163 if (interfacArts != null) {
164 interfacArtsAll.putAll(interfacArts);
166 if (!interfacArtsAll.isEmpty()) {
167 Either<GraphVertex, StorageOperationStatus> assosiateElementToData = associateElementToData(nodeTypeVertex, VertexTypeEnum.INTERFACE_ARTIFACTS, EdgeLabelEnum.INTERFACE_ARTIFACTS, interfacArtsAll);
168 if (assosiateElementToData.isRight()) {
169 return assosiateElementToData.right().value();
172 return StorageOperationStatus.OK;
176 public Either<ToscaElement, StorageOperationStatus> getToscaElement(String uniqueId, ComponentParametersView componentParametersView) {
178 Either<GraphVertex, StorageOperationStatus> componentByLabelAndId = getComponentByLabelAndId(uniqueId, ToscaElementTypeEnum.NODE_TYPE, JsonParseFlagEnum.ParseMetadata);
179 if (componentByLabelAndId.isRight()) {
180 return Either.right(componentByLabelAndId.right().value());
182 GraphVertex componentV = componentByLabelAndId.left().value();
184 return getToscaElement(componentV, componentParametersView);
188 // -------------------------------------------------------------
190 public Either<ToscaElement, StorageOperationStatus> getToscaElement(GraphVertex componentV, ComponentParametersView componentParametersView) {
191 NodeType toscaElement;
192 toscaElement = convertToComponent(componentV);
193 JanusGraphOperationStatus status = null;
194 if (!componentParametersView.isIgnoreUsers()) {
195 status = setCreatorFromGraph(componentV, toscaElement);
196 if (status != JanusGraphOperationStatus.OK) {
197 return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status));
200 status = setLastModifierFromGraph(componentV, toscaElement);
201 if (status != JanusGraphOperationStatus.OK) {
202 return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status));
206 if (!componentParametersView.isIgnoreProperties()) {
207 status = setResourcePropertiesFromGraph(componentV, toscaElement);
208 if (status != JanusGraphOperationStatus.OK && status != JanusGraphOperationStatus.NOT_FOUND) {
209 return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status));
213 if (!componentParametersView.isIgnoreAttributesFrom()) {
214 status = setResourceAttributesFromGraph(componentV, toscaElement);
215 if (status != JanusGraphOperationStatus.OK) {
216 return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status));
220 if (!componentParametersView.isIgnoreDerivedFrom()) {
221 status = setResourceDerivedFromGraph(componentV, toscaElement);
222 if (status != JanusGraphOperationStatus.OK) {
223 return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status));
227 if (!componentParametersView.isIgnoreCategories()) {
228 status = setResourceCategoryFromGraph(componentV, toscaElement);
229 if (status != JanusGraphOperationStatus.OK) {
230 return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status));
233 if (!componentParametersView.isIgnoreRequirements()) {
234 status = setResourceRequirementsFromGraph(componentV, toscaElement);
235 if (status != JanusGraphOperationStatus.OK) {
236 log.error("Failed to set requirement of resource {}. status is {}", componentV.getUniqueId(), status);
237 return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status));
240 if (!componentParametersView.isIgnoreCapabilities()) {
241 status = setResourceCapabilitiesFromGraph(componentV, toscaElement);
242 if (status != JanusGraphOperationStatus.OK) {
243 return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status));
247 if (!componentParametersView.isIgnoreArtifacts()) {
248 status = setArtifactsFromGraph(componentV, toscaElement);
249 if (status != JanusGraphOperationStatus.OK) {
250 return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status));
253 if (!componentParametersView.isIgnoreAdditionalInformation()) {
254 status = setAdditionalInformationFromGraph(componentV, toscaElement);
255 if (status != JanusGraphOperationStatus.OK) {
256 return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status));
259 if (!componentParametersView.isIgnoreInterfaces()) {
260 status = setInterfacesFromGraph(componentV, toscaElement);
261 if (status != JanusGraphOperationStatus.OK) {
262 return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status));
265 if (!componentParametersView.isIgnoreAllVersions()) {
266 status = setAllVersions(componentV, toscaElement);
267 if (status != JanusGraphOperationStatus.OK && status != JanusGraphOperationStatus.NOT_FOUND) {
268 return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status));
272 if (!componentParametersView.isIgnoreCapabiltyProperties()) {
273 status = setComponentCapPropertiesFromGraph(componentV, toscaElement);
274 if (status != JanusGraphOperationStatus.OK) {
275 return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status));
279 return Either.left(toscaElement);
282 private JanusGraphOperationStatus setComponentCapPropertiesFromGraph(GraphVertex componentV, NodeType toscaElement) {
283 Either<Map<String, MapPropertiesDataDefinition>, JanusGraphOperationStatus> result = getDataFromGraph(componentV, EdgeLabelEnum.CAPABILITIES_PROPERTIES);
284 if (result.isLeft()) {
285 toscaElement.setCapabilitiesProperties(result.left().value());
287 if (result.right().value() != JanusGraphOperationStatus.NOT_FOUND) {
288 return result.right().value();
291 return JanusGraphOperationStatus.OK;
294 private JanusGraphOperationStatus setInterfacesFromGraph(GraphVertex componentV, NodeType toscaElement) {
295 Either<Map<String, InterfaceDataDefinition>, JanusGraphOperationStatus> result = getDataFromGraph(componentV, EdgeLabelEnum.INTERFACE_ARTIFACTS);
296 if (result.isLeft()) {
297 toscaElement.setInterfaceArtifacts(result.left().value());
299 if (result.right().value() != JanusGraphOperationStatus.NOT_FOUND) {
300 return result.right().value();
303 return JanusGraphOperationStatus.OK;
306 protected <T extends ToscaElement> JanusGraphOperationStatus setCapabilitiesFromGraph(GraphVertex componentV, T toscaElement) {
307 return setResourceCapabilitiesFromGraph(componentV, (NodeType) toscaElement);
310 private JanusGraphOperationStatus setResourceCapabilitiesFromGraph(GraphVertex componentV, NodeType toscaElement) {
311 Either<Map<String, ListCapabilityDataDefinition>, JanusGraphOperationStatus> result = getDataFromGraph(componentV, EdgeLabelEnum.CAPABILITIES);
312 if (result.isLeft()) {
313 toscaElement.setCapabilities(result.left().value());
315 if (result.right().value() != JanusGraphOperationStatus.NOT_FOUND) {
316 return result.right().value();
319 return JanusGraphOperationStatus.OK;
322 private JanusGraphOperationStatus setResourceDerivedFromGraph(final GraphVertex componentV,
323 final NodeType toscaElement) {
324 final List<String> derivedFromList = new ArrayList<>();
325 final Map<String, String> derivedFromMapOfIdToName = new LinkedHashMap<>();
327 final JanusGraphOperationStatus listFromGraphStatus = findResourcesPathRecursively(componentV, derivedFromList,
328 derivedFromMapOfIdToName);
329 if (JanusGraphOperationStatus.OK != listFromGraphStatus) {
330 return listFromGraphStatus;
333 if (!derivedFromList.isEmpty()) {
334 if (derivedFromList.size() > 1) {
335 final List<String> lastDerivedFrom = new ArrayList<>();
336 lastDerivedFrom.add(derivedFromList.get(1));
337 toscaElement.setDerivedFrom(lastDerivedFrom);
339 toscaElement.setDerivedFrom(null);
341 toscaElement.setDerivedList(derivedFromList);
342 toscaElement.setDerivedFromMapOfIdToName(derivedFromMapOfIdToName);
344 return JanusGraphOperationStatus.OK;
347 private JanusGraphOperationStatus findResourcesPathRecursively(final GraphVertex nodeTypeV,
348 final List<String> resourcesPathList,
349 final Map<String, String> derivedFromMapOfIdToName) {
350 Either<GraphVertex, JanusGraphOperationStatus> parentResourceRes = janusGraphDao
351 .getChildVertex(nodeTypeV, EdgeLabelEnum.DERIVED_FROM, JsonParseFlagEnum.NoParse);
352 resourcesPathList.add((String) nodeTypeV.getMetadataProperty(GraphPropertyEnum.TOSCA_RESOURCE_NAME));
353 derivedFromMapOfIdToName.put(nodeTypeV.getUniqueId(),
354 (String) nodeTypeV.getMetadataProperty(GraphPropertyEnum.TOSCA_RESOURCE_NAME));
355 while (parentResourceRes.isLeft()) {
356 final GraphVertex parent = parentResourceRes.left().value();
357 resourcesPathList.add((String) parent.getMetadataProperty(GraphPropertyEnum.TOSCA_RESOURCE_NAME));
358 derivedFromMapOfIdToName
359 .put(parent.getUniqueId(), (String) parent.getMetadataProperty(GraphPropertyEnum.TOSCA_RESOURCE_NAME));
360 parentResourceRes = janusGraphDao
361 .getChildVertex(parent, EdgeLabelEnum.DERIVED_FROM, JsonParseFlagEnum.NoParse);
363 final JanusGraphOperationStatus operationStatus = parentResourceRes.right().value();
365 if (operationStatus != JanusGraphOperationStatus.NOT_FOUND) {
366 return operationStatus;
368 return JanusGraphOperationStatus.OK;
373 protected <T extends ToscaElement> JanusGraphOperationStatus setRequirementsFromGraph(GraphVertex componentV, T toscaElement) {
374 return setResourceRequirementsFromGraph(componentV, (NodeType) toscaElement);
377 private JanusGraphOperationStatus setResourceRequirementsFromGraph(GraphVertex componentV, NodeType toscaElement) {
378 Either<Map<String, ListRequirementDataDefinition>, JanusGraphOperationStatus> result = getDataFromGraph(componentV, EdgeLabelEnum.REQUIREMENTS);
379 if (result.isLeft()) {
380 toscaElement.setRequirements(result.left().value());
382 if (result.right().value() != JanusGraphOperationStatus.NOT_FOUND) {
383 return result.right().value();
386 return JanusGraphOperationStatus.OK;
389 private JanusGraphOperationStatus setResourceAttributesFromGraph(GraphVertex componentV, NodeType toscaElement) {
390 Either<Map<String, AttributeDataDefinition>, JanusGraphOperationStatus> result = getDataFromGraph(componentV, EdgeLabelEnum.ATTRIBUTES);
391 if (result.isLeft()) {
392 toscaElement.setAttributes(result.left().value());
394 if (result.right().value() != JanusGraphOperationStatus.NOT_FOUND) {
395 return result.right().value();
398 return JanusGraphOperationStatus.OK;
401 private JanusGraphOperationStatus setResourcePropertiesFromGraph(GraphVertex componentV, NodeType toscaElement) {
402 Either<Map<String, PropertyDataDefinition>, JanusGraphOperationStatus> result = getDataFromGraph(componentV, EdgeLabelEnum.PROPERTIES);
403 if (result.isLeft()) {
404 toscaElement.setProperties(result.left().value());
406 if (result.right().value() != JanusGraphOperationStatus.NOT_FOUND) {
407 return result.right().value();
410 return JanusGraphOperationStatus.OK;
413 private StorageOperationStatus assosiateToDerived(GraphVertex nodeTypeVertex, List<GraphVertex> derivedResources) {
414 for (GraphVertex derivedV : derivedResources) {
415 JanusGraphOperationStatus
416 createEdge = janusGraphDao
417 .createEdge(nodeTypeVertex, derivedV, EdgeLabelEnum.DERIVED_FROM, null);
418 if (createEdge != JanusGraphOperationStatus.OK) {
419 log.trace("Failed to associate resource {} to derived with id {}", nodeTypeVertex.getUniqueId(), derivedV.getUniqueId());
420 return DaoStatusConverter.convertJanusGraphStatusToStorageStatus(createEdge);
423 return StorageOperationStatus.OK;
426 private StorageOperationStatus addAdditionalInformationToResource(GraphVertex nodeTypeVertex, NodeType nodeType, List<GraphVertex> derivedResources) {
427 // Note : currently only one derived supported!!!!
428 Either<Map<String, AdditionalInfoParameterDataDefinition>, StorageOperationStatus> dataFromDerived = getDataFromDerived(derivedResources, EdgeLabelEnum.ADDITIONAL_INFORMATION);
429 if (dataFromDerived.isRight()) {
430 return dataFromDerived.right().value();
432 Map<String, AdditionalInfoParameterDataDefinition> addInformationAll = dataFromDerived.left().value();
434 Map<String, AdditionalInfoParameterDataDefinition> addInformation = nodeType.getAdditionalInformation();
435 if (addInformation != null) {
436 ToscaDataDefinition.mergeDataMaps(addInformationAll, addInformation);
438 if (!addInformationAll.isEmpty()) {
439 Either<GraphVertex, StorageOperationStatus> assosiateElementToData = associateElementToData(nodeTypeVertex, VertexTypeEnum.ADDITIONAL_INFORMATION, EdgeLabelEnum.ADDITIONAL_INFORMATION, addInformationAll);
440 if (assosiateElementToData.isRight()) {
441 return assosiateElementToData.right().value();
444 return StorageOperationStatus.OK;
447 private StorageOperationStatus associateCapabilitiesToResource(GraphVertex nodeTypeVertex, NodeType nodeType, List<GraphVertex> derivedResources) {
448 // Note : currently only one derived supported!!!!
449 Either<Map<String, ListCapabilityDataDefinition>, StorageOperationStatus> dataFromDerived = getDataFromDerived(derivedResources, EdgeLabelEnum.CAPABILITIES);
450 if (dataFromDerived.isRight()) {
451 return dataFromDerived.right().value();
453 Map<String, ListCapabilityDataDefinition> capabiltiesAll = dataFromDerived.left().value();
455 Map<String, ListCapabilityDataDefinition> capabilties = nodeType.getCapabilities();
456 if (capabilties != null) {
457 if (capabiltiesAll == null) {
458 capabiltiesAll = new HashMap<>();
460 capabilties.values().forEach(l -> {
461 l.getListToscaDataDefinition().stream().filter(p -> p.getUniqueId() == null).forEach(p -> {
462 String uid = UniqueIdBuilder.buildCapabilityUid(nodeTypeVertex.getUniqueId(), p.getName());
467 ToscaDataDefinition.mergeDataMaps(capabiltiesAll, capabilties);
468 capabiltiesAll.values().forEach(l -> {
469 l.getListToscaDataDefinition().forEach(c -> {
470 List<String> capabilitySources = c.getCapabilitySources();
471 if (capabilitySources == null) {
472 capabilitySources = new ArrayList<>();
474 capabilitySources.add((String) nodeType.getMetadataValue(JsonPresentationFields.TOSCA_RESOURCE_NAME));
475 c.setCapabilitySources(capabilitySources);
479 capabiltiesAll.values().forEach(l -> {
480 l.getListToscaDataDefinition().forEach(c -> {
481 List<String> capabilitySources = c.getCapabilitySources();
482 if (capabilitySources == null) {
483 capabilitySources = new ArrayList<>();
485 capabilitySources.add((String) nodeType.getMetadataValue(JsonPresentationFields.TOSCA_RESOURCE_NAME));
486 c.setCapabilitySources(capabilitySources);
489 if (!capabiltiesAll.isEmpty()) {
490 Either<GraphVertex, StorageOperationStatus> assosiateElementToData = associateElementToData(nodeTypeVertex, VertexTypeEnum.CAPABILITIES, EdgeLabelEnum.CAPABILITIES, capabiltiesAll);
491 if (assosiateElementToData.isRight()) {
492 return assosiateElementToData.right().value();
495 return StorageOperationStatus.OK;
498 private StorageOperationStatus associateRequirementsToResource(GraphVertex nodeTypeVertex, NodeType nodeType, List<GraphVertex> derivedResources) {
499 // Note : currently only one derived supported!!!!
500 Either<Map<String, ListRequirementDataDefinition>, StorageOperationStatus> dataFromDerived = getDataFromDerived(derivedResources, EdgeLabelEnum.REQUIREMENTS);
501 if (dataFromDerived.isRight()) {
502 return dataFromDerived.right().value();
504 Map<String, ListRequirementDataDefinition> requirementsAll = dataFromDerived.left().value();
506 Map<String, ListRequirementDataDefinition> requirements = nodeType.getRequirements();
507 if (requirements != null) {
508 if (requirementsAll == null) {
509 requirementsAll = new HashMap<>();
511 requirements.values().forEach(l -> {
512 l.getListToscaDataDefinition().stream().filter(p -> p.getUniqueId() == null).forEach(p -> {
513 String uid = UniqueIdBuilder.buildRequirementUid(nodeTypeVertex.getUniqueId(), p.getName());
518 ToscaDataDefinition.mergeDataMaps(requirementsAll, requirements);
521 if (!requirementsAll.isEmpty()) {
522 Either<GraphVertex, StorageOperationStatus> assosiateElementToData = associateElementToData(nodeTypeVertex, VertexTypeEnum.REQUIREMENTS, EdgeLabelEnum.REQUIREMENTS, requirementsAll);
523 if (assosiateElementToData.isRight()) {
524 return assosiateElementToData.right().value();
527 return StorageOperationStatus.OK;
530 private StorageOperationStatus associateAttributesToResource(GraphVertex nodeTypeVertex, NodeType nodeType, List<GraphVertex> derivedResources) {
531 // Note : currently only one derived supported!!!!
532 Either<Map<String, AttributeDataDefinition>, StorageOperationStatus> dataFromDerived = getDataFromDerived(derivedResources, EdgeLabelEnum.ATTRIBUTES);
533 if (dataFromDerived.isRight()) {
534 return dataFromDerived.right().value();
536 Map<String, AttributeDataDefinition> attributesAll = dataFromDerived.left().value();
538 Map<String, AttributeDataDefinition> attributes = nodeType.getAttributes();
539 if (attributes != null) {
540 attributes.values().stream().filter(p -> p.getUniqueId() == null).forEach(p -> {
541 String uid = UniqueIdBuilder.buildAttributeUid(nodeTypeVertex.getUniqueId(), p.getName());
544 ToscaDataDefinition.mergeDataMaps(attributesAll, attributes);
546 if (!attributesAll.isEmpty()) {
547 Either<GraphVertex, StorageOperationStatus> assosiateElementToData = associateElementToData(nodeTypeVertex, VertexTypeEnum.ATTRIBUTES, EdgeLabelEnum.ATTRIBUTES, attributesAll);
548 if (assosiateElementToData.isRight()) {
549 return assosiateElementToData.right().value();
552 return StorageOperationStatus.OK;
555 // TODO get from derived
556 private StorageOperationStatus associateCapabilitiesPropertiesToResource(GraphVertex nodeTypeVertex, NodeType nodeType, List<GraphVertex> derivedResources) {
557 // // Note : currently only one derived supported!!!!
558 Either<Map<String, MapPropertiesDataDefinition>, StorageOperationStatus> dataFromDerived = getDataFromDerived(derivedResources, EdgeLabelEnum.CAPABILITIES_PROPERTIES);
559 if (dataFromDerived.isRight()) {
560 return dataFromDerived.right().value();
562 Map<String, MapPropertiesDataDefinition> propertiesAll = dataFromDerived.left().value();
563 Map<String, MapPropertiesDataDefinition> capabiltiesProps = nodeType.getCapabilitiesProperties();
564 if (capabiltiesProps != null) {
565 capabiltiesProps.values().forEach(l -> {
566 if (l.getMapToscaDataDefinition() != null && l.getMapToscaDataDefinition().values() != null) {
567 Collection<PropertyDataDefinition> mapToscaDataDefinition = l.getMapToscaDataDefinition().values();
568 mapToscaDataDefinition.stream().filter(p -> p != null && p.getUniqueId() == null).forEach(p -> {
569 String uid = UniqueIdBuilder.buildRequirementUid(nodeTypeVertex.getUniqueId(), p.getName());
574 ToscaDataDefinition.mergeDataMaps(propertiesAll, capabiltiesProps);
576 if (!propertiesAll.isEmpty()) {
577 Either<GraphVertex, StorageOperationStatus> assosiateElementToData = associateElementToData(nodeTypeVertex, VertexTypeEnum.CAPABILITIES_PROPERTIES, EdgeLabelEnum.CAPABILITIES_PROPERTIES, propertiesAll);
578 if (assosiateElementToData.isRight()) {
579 return assosiateElementToData.right().value();
582 return StorageOperationStatus.OK;
585 public Either<List<GraphVertex>, StorageOperationStatus> findDerivedResources(NodeType nodeType) {
587 List<GraphVertex> derivedResources = new ArrayList<>();
588 List<String> derivedFromResources = nodeType.getDerivedFrom();
589 if (derivedFromResources != null && !derivedFromResources.isEmpty()) {
591 for (String parentResource : derivedFromResources) {
592 Either<List<GraphVertex>, JanusGraphOperationStatus> getParentResources = derivedResourceResolver.findDerivedResources(parentResource);
593 List<GraphVertex> resources = null;
594 if (getParentResources.isRight()) {
595 log.error("Cannot find parent resource by tosca resource name {} in the graph.", parentResource);
596 return Either.right(StorageOperationStatus.PARENT_RESOURCE_NOT_FOUND);
599 resources = getParentResources.left().value();
600 if (resources == null || resources.size() == 0) {
601 log.error("Cannot find parent resource by tosca name {} in the graph. resources size is empty", parentResource);
602 return Either.right(StorageOperationStatus.PARENT_RESOURCE_NOT_FOUND);
604 if (resources.size() > 1) {
605 return handleMultipleParent(parentResource, derivedResources, resources);
607 GraphVertex parentResourceData = resources.get(0);
608 derivedResources.add(parentResourceData);
616 return Either.left(derivedResources);
619 Either<List<GraphVertex>, StorageOperationStatus> handleMultipleParent(String parentResource, List<GraphVertex> derivedResource, List<GraphVertex> fetchedDerivedResources) {
621 Either<List<GraphVertex>, StorageOperationStatus> result = Either.left(derivedResource);
623 fetchedDerivedResources.sort((d1, d2) -> {
624 return new Double(Double.parseDouble((String) d1.getMetadataProperty(GraphPropertyEnum.VERSION))).compareTo(Double.parseDouble((String) d2.getMetadataProperty(GraphPropertyEnum.VERSION)));
627 int actualHighestIndex = fetchedDerivedResources.size() - 1;
628 derivedResource.add(fetchedDerivedResources.get(actualHighestIndex));
629 fetchedDerivedResources.remove(actualHighestIndex);
631 StorageOperationStatus status = fixMultipleParent(fetchedDerivedResources);
632 if (status != StorageOperationStatus.OK) {
633 result = Either.right(status);
635 } catch (Exception e) {
636 CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Exception occured during handle multiple parent {}. Exception is {}", parentResource, e.getMessage());
637 result = Either.right(StorageOperationStatus.GENERAL_ERROR);
642 private StorageOperationStatus fixMultipleParent(List<GraphVertex> fetchedDerivedResources) {
643 StorageOperationStatus result = StorageOperationStatus.OK;
644 for (GraphVertex fetchedDerivedResource : fetchedDerivedResources) {
645 fetchedDerivedResource.addMetadataProperty(GraphPropertyEnum.IS_HIGHEST_VERSION, false);
646 Either<GraphVertex, JanusGraphOperationStatus> updateVertexRes = janusGraphDao.updateVertex(fetchedDerivedResource);
647 if (updateVertexRes.isRight()) {
648 JanusGraphOperationStatus titatStatus = updateVertexRes.right().value();
649 CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to set highest version of node type {} to false. Status is {}", fetchedDerivedResource.getMetadataProperty(GraphPropertyEnum.TOSCA_RESOURCE_NAME), titatStatus);
650 result = DaoStatusConverter.convertJanusGraphStatusToStorageStatus(titatStatus);
657 private GraphVertex fillMetadata(GraphVertex nodeTypeVertex, NodeType nodeType) {
658 nodeTypeVertex.setLabel(VertexTypeEnum.NODE_TYPE);
660 fillCommonMetadata(nodeTypeVertex, nodeType);
661 nodeTypeVertex.setJsonMetadataField(JsonPresentationFields.ATTRIBUTES, nodeType.getAttributes());
663 return nodeTypeVertex;
667 public Either<ToscaElement, StorageOperationStatus> deleteToscaElement(GraphVertex toscaElementVertex) {
668 Either<ToscaElement, StorageOperationStatus> nodeType = getToscaElement(toscaElementVertex, new ComponentParametersView());
669 if (nodeType.isRight()) {
670 log.debug("Failed to fetch tosca element {} error {}", toscaElementVertex.getUniqueId(), nodeType.right().value());
673 JanusGraphOperationStatus status = disassociateAndDeleteCommonElements(toscaElementVertex);
674 if (status != JanusGraphOperationStatus.OK) {
675 Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status));
677 status = janusGraphDao
678 .disassociateAndDeleteLast(toscaElementVertex, Direction.OUT, EdgeLabelEnum.CAPABILITIES);
679 if (status != JanusGraphOperationStatus.OK) {
680 log.debug("Failed to disassociate capabilties for {} error {}", toscaElementVertex.getUniqueId(), status);
681 Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status));
683 status = janusGraphDao
684 .disassociateAndDeleteLast(toscaElementVertex, Direction.OUT, EdgeLabelEnum.CAPABILITIES_PROPERTIES);
685 if (status != JanusGraphOperationStatus.OK) {
686 log.debug("Failed to disassociate capabilties properties for {} error {}", toscaElementVertex.getUniqueId(), status);
687 Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status));
689 status = janusGraphDao
690 .disassociateAndDeleteLast(toscaElementVertex, Direction.OUT, EdgeLabelEnum.REQUIREMENTS);
691 if (status != JanusGraphOperationStatus.OK) {
692 log.debug("Failed to disassociate requirements for {} error {}", toscaElementVertex.getUniqueId(), status);
693 Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status));
695 status = janusGraphDao
696 .disassociateAndDeleteLast(toscaElementVertex, Direction.OUT, EdgeLabelEnum.ATTRIBUTES);
697 if (status != JanusGraphOperationStatus.OK) {
698 log.debug("Failed to disassociate attributes for {} error {}", toscaElementVertex.getUniqueId(), status);
699 Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status));
701 status = janusGraphDao
702 .disassociateAndDeleteLast(toscaElementVertex, Direction.OUT, EdgeLabelEnum.INTERFACE_ARTIFACTS);
703 if (status != JanusGraphOperationStatus.OK) {
704 log.debug("Failed to disassociate interface artifacts for {} error {}", toscaElementVertex.getUniqueId(), status);
705 Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status));
707 toscaElementVertex.getVertex().remove();
708 log.trace("Tosca element vertex for {} was removed", toscaElementVertex.getUniqueId());
713 @SuppressWarnings("unchecked")
715 public Either<NodeType, StorageOperationStatus> createToscaElement(ToscaElement toscaElement) {
716 return createNodeType((NodeType) toscaElement);
720 protected <T extends ToscaElement> JanusGraphOperationStatus setCategoriesFromGraph(GraphVertex vertexComponent, T toscaElement) {
721 return setResourceCategoryFromGraph(vertexComponent, toscaElement);
725 protected <T extends ToscaElement> StorageOperationStatus validateCategories(T toscaElementToUpdate, GraphVertex elementV) {
726 return validateResourceCategory(toscaElementToUpdate, elementV);
730 protected <T extends ToscaElement> StorageOperationStatus updateDerived(T toscaElementToUpdate, GraphVertex nodeTypeV) {
732 NodeType nodeType = (NodeType) toscaElementToUpdate;
734 List<String> derivedFromResources = nodeType.getDerivedFrom();
736 // now supported only single derived from
737 if (derivedFromResources != null && !derivedFromResources.isEmpty() && derivedFromResources.get(0) != null) {
738 String firstDerived = derivedFromResources.get(0);
739 boolean derivedFromGenericType = null != nodeType.getDerivedFromGenericType();
740 Either<GraphVertex, JanusGraphOperationStatus> childVertex = janusGraphDao
741 .getChildVertex(nodeTypeV, EdgeLabelEnum.DERIVED_FROM, JsonParseFlagEnum.NoParse);
742 if (childVertex.isRight()) {
743 JanusGraphOperationStatus getchieldError = childVertex.right().value();
744 log.debug("Failed to fetch derived resource for element {} error {}", nodeTypeV.getUniqueId(), getchieldError);
745 return DaoStatusConverter.convertJanusGraphStatusToStorageStatus(getchieldError);
747 GraphVertex firstDerivedInChain = childVertex.left().value();
749 String firstCurrentDerived = (String) firstDerivedInChain.getMetadataProperty(GraphPropertyEnum.TOSCA_RESOURCE_NAME);
750 if (!firstDerived.equals(firstCurrentDerived) || derivedFromGenericType) {
752 Map<GraphPropertyEnum, Object> propertiesToMatch = new HashMap<>();
753 propertiesToMatch.put(GraphPropertyEnum.STATE, LifecycleStateEnum.CERTIFIED.name());
755 propertiesToMatch.put(GraphPropertyEnum.TOSCA_RESOURCE_NAME, firstDerived);
756 propertiesToMatch.put(GraphPropertyEnum.IS_HIGHEST_VERSION, true);
758 Either<List<GraphVertex>, JanusGraphOperationStatus> getParentResources = janusGraphDao
759 .getByCriteria(VertexTypeEnum.NODE_TYPE, propertiesToMatch, JsonParseFlagEnum.NoParse);
761 if (getParentResources.isRight()) {
762 JanusGraphOperationStatus error = getParentResources.right().value();
763 CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to fetch derived by criteria {}. error {} ", propertiesToMatch, error);
764 return DaoStatusConverter.convertJanusGraphStatusToStorageStatus(error);
767 GraphVertex newDerivedV = getParentResources.left().value().get(0);
768 return updateDerived(toscaElementToUpdate, nodeTypeV, firstDerivedInChain, newDerivedV, false);
771 return StorageOperationStatus.OK;
776 * @param toscaElementToUpdate
783 protected <T extends ToscaElement> StorageOperationStatus updateDerived(T toscaElementToUpdate, GraphVertex nodeTypeV, GraphVertex preDerivedV, GraphVertex newDerivedV, boolean mergeValues) {
784 Set<String> preDerivedChainIdList = new HashSet();
785 preDerivedChainIdList.add(preDerivedV.getUniqueId());
786 Either<GraphVertex, JanusGraphOperationStatus> childVertex = janusGraphDao
787 .getChildVertex(preDerivedV, EdgeLabelEnum.DERIVED_FROM, JsonParseFlagEnum.NoParse);
788 while (childVertex.isLeft()) {
789 GraphVertex currentChield = childVertex.left().value();
790 preDerivedChainIdList.add(currentChield.getUniqueId());
791 childVertex = janusGraphDao
792 .getChildVertex(currentChield, EdgeLabelEnum.DERIVED_FROM, JsonParseFlagEnum.NoParse);
795 List<GraphVertex> derivedResources = new ArrayList<>();
796 derivedResources.add(newDerivedV);
797 StorageOperationStatus updateStatus = updateDataFromNewDerived(derivedResources, nodeTypeV, (NodeType) toscaElementToUpdate, mergeValues, preDerivedChainIdList);
798 if (updateStatus != StorageOperationStatus.OK) {
799 CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to update data for {} from new derived {} ", nodeTypeV.getUniqueId(), newDerivedV.getUniqueId(), updateStatus);
803 Either<Edge, JanusGraphOperationStatus> deleteEdge = janusGraphDao
804 .deleteEdge(nodeTypeV, preDerivedV, EdgeLabelEnum.DERIVED_FROM);
805 if (deleteEdge.isRight()) {
806 JanusGraphOperationStatus deleteError = deleteEdge.right().value();
807 log.debug("Failed to disassociate element {} from derived {} , error {}", nodeTypeV.getUniqueId(), preDerivedV.getUniqueId(), deleteError);
808 return DaoStatusConverter.convertJanusGraphStatusToStorageStatus(deleteError);
811 janusGraphDao.createEdge(nodeTypeV, newDerivedV, EdgeLabelEnum.DERIVED_FROM, new HashMap<>());
813 return StorageOperationStatus.OK;
816 private StorageOperationStatus associateDerivedDataByType(EdgeLabelEnum edgeLabel, GraphVertex nodeTypeV, NodeType nodeToUpdate, List<GraphVertex> newDerived) {
820 return associateCapabilitiesToResource(nodeTypeV, nodeToUpdate, newDerived);
822 return associateRequirementsToResource(nodeTypeV, nodeToUpdate, newDerived);
824 return associatePropertiesToResource(nodeTypeV, nodeToUpdate, newDerived);
826 return associateAttributesToResource(nodeTypeV, nodeToUpdate, newDerived);
827 case ADDITIONAL_INFORMATION:
828 return addAdditionalInformationToResource(nodeTypeV, nodeToUpdate, newDerived);
829 case CAPABILITIES_PROPERTIES:
830 return associateCapabilitiesPropertiesToResource(nodeTypeV, nodeToUpdate, newDerived);
832 return StorageOperationStatus.OK;
837 private StorageOperationStatus updateDataFromNewDerived(List<GraphVertex> newDerived, GraphVertex nodeTypeV, NodeType nodeToUpdate, boolean mergeValues, Set<String> preDerivedChainIdList) {
838 EnumSet<EdgeLabelEnum> edgeLabels = EnumSet.of(EdgeLabelEnum.CAPABILITIES, EdgeLabelEnum.REQUIREMENTS, EdgeLabelEnum.PROPERTIES, EdgeLabelEnum.ATTRIBUTES, EdgeLabelEnum.CAPABILITIES_PROPERTIES, EdgeLabelEnum.ADDITIONAL_INFORMATION);
839 StorageOperationStatus status = null;
840 for (EdgeLabelEnum edge : edgeLabels) {
841 status = updateDataByType(newDerived, nodeTypeV, edge, nodeToUpdate, mergeValues, preDerivedChainIdList);
842 if (status != StorageOperationStatus.OK) {
850 private <T extends ToscaDataDefinition> StorageOperationStatus updateDataByType(List<GraphVertex> newDerivedList, GraphVertex nodeTypeV, EdgeLabelEnum label, NodeType nodeElement, boolean mergeValues, Set<String> preDerivedChainIdList) {
851 log.debug("Update data from derived for element {} type {}", nodeTypeV.getUniqueId(), label);
852 Either<GraphVertex, JanusGraphOperationStatus> dataFromGraph = getDataVertex(nodeTypeV, label);
853 if (dataFromGraph.isRight()) {
854 if (JanusGraphOperationStatus.NOT_FOUND == dataFromGraph.right().value())
855 return associateDerivedDataByType(label, nodeTypeV, nodeElement, newDerivedList);
856 return DaoStatusConverter.convertJanusGraphStatusToStorageStatus(dataFromGraph.right().value());
858 GraphVertex dataV = dataFromGraph.left().value();
860 Map<String, T> mapFromGraph = (Map<String, T>) dataV.getJson();
861 Map<String, T> valuesFrmPrev = null;
862 if (isSimpleHierarchy(label)) {
864 valuesFrmPrev = mapFromGraph.entrySet().stream().filter(e -> e.getValue().getOwnerId() != null).collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
866 mapFromGraph.entrySet().removeIf(e -> preDerivedChainIdList.contains(e.getValue().getOwnerId()));
868 final Map<String, T> valuesFrmPrevFinal = new HashMap<>();
869 mapFromGraph.entrySet().stream().forEach(e -> {
870 T value = e.getValue();
871 value = ToscaDataDefinition.removeAndCollectByOwnerId(value, preDerivedChainIdList);
872 valuesFrmPrevFinal.put(e.getKey(), value);
874 valuesFrmPrev = valuesFrmPrevFinal;
875 mapFromGraph.entrySet().removeIf(e->e.getValue().isEmpty());
878 Either<Map<String, T>, StorageOperationStatus> dataFromDerived = getDataFromDerived(newDerivedList, label);
879 if (dataFromDerived.isRight()) {
880 return dataFromDerived.right().value();
882 Map<String, T> dataFromDerivedAll = dataFromDerived.left().value();
884 Either<Map<String, T>, String> merged = ToscaDataDefinition.mergeDataMaps(dataFromDerivedAll, mapFromGraph);
885 if (merged.isRight()) {
886 log.debug("property {} cannot be overriden", merged.right().value());
887 return StorageOperationStatus.INVALID_PROPERTY;
889 if (mergeValues && valuesFrmPrev != null) {
890 valuesFrmPrev.entrySet().forEach(e -> {
891 T newData = merged.left().value().get(e.getKey());
892 if (newData != null) {
893 if (isSimpleHierarchy(label)) {
894 e.getValue().mergeFunction(newData, true);
896 e.getValue().updateIfExist(newData, true);
901 dataV.setJson(dataFromDerivedAll);
902 Either<GraphVertex, JanusGraphOperationStatus> updateDataV = updateOrCopyOnUpdate(dataV, nodeTypeV, label);
903 if (updateDataV.isRight()) {
904 return DaoStatusConverter.convertJanusGraphStatusToStorageStatus(updateDataV.right().value());
906 return StorageOperationStatus.OK;
909 private boolean isSimpleHierarchy(EdgeLabelEnum label) {
913 case ADDITIONAL_INFORMATION:
924 public <T extends ToscaElement> void fillToscaElementVertexData(GraphVertex elementV, T toscaElementToUpdate, JsonParseFlagEnum flag) {
925 fillMetadata(elementV, (NodeType) toscaElementToUpdate);
928 public Either<ToscaElement, StorageOperationStatus> shouldUpdateDerivedVersion(ToscaElement toscaElementToUpdate, GraphVertex nodeTypeV) {
929 NodeType nodeType = (NodeType) toscaElementToUpdate;
931 Either<GraphVertex, JanusGraphOperationStatus> childVertex = janusGraphDao
932 .getChildVertex(nodeTypeV, EdgeLabelEnum.DERIVED_FROM, JsonParseFlagEnum.NoParse);
933 if (childVertex.isRight()) {
934 JanusGraphOperationStatus getchildError = childVertex.right().value();
935 if (getchildError == JanusGraphOperationStatus.NOT_FOUND) {
936 log.debug("derived resource for element {} not found", nodeTypeV.getUniqueId());
937 return Either.right(StorageOperationStatus.OK);
940 log.debug("Failed to fetch derived resource for element {} error {}", nodeTypeV.getUniqueId(), getchildError);
941 return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(getchildError));
943 GraphVertex firstDerivedInChain = childVertex.left().value();
945 String currentVersion = (String) firstDerivedInChain.getMetadataProperty(GraphPropertyEnum.VERSION);
947 Map<GraphPropertyEnum, Object> props = new HashMap<>();
948 props.put(GraphPropertyEnum.TOSCA_RESOURCE_NAME, nodeType.getDerivedFrom().get(0));
949 props.put(GraphPropertyEnum.STATE, LifecycleStateEnum.CERTIFIED.name());
950 props.put(GraphPropertyEnum.IS_HIGHEST_VERSION, true);
952 Map<GraphPropertyEnum, Object> propsHasNot = new HashMap<>();
953 propsHasNot.put(GraphPropertyEnum.IS_DELETED, true);
954 Either<List<GraphVertex>, JanusGraphOperationStatus> byCriteria = janusGraphDao
955 .getByCriteria(VertexTypeEnum.NODE_TYPE, props, propsHasNot, JsonParseFlagEnum.NoParse);
956 if (byCriteria.isRight()) {
957 log.debug("Failed to fetch derived by props {} error {}", props, byCriteria.right().value());
958 return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(byCriteria.right().value()));
960 List<GraphVertex> lastDerived = byCriteria.left().value();
961 // now supported only one derived!!! Change in future!(Evg)
962 GraphVertex derivedFromHighest = lastDerived.get(0);
963 String highestVersion = (String) derivedFromHighest.getMetadataProperty(GraphPropertyEnum.VERSION);
964 if (!highestVersion.equals(currentVersion)) {
966 // need to update to latest version of derived from
967 StorageOperationStatus updateDerived = updateDerived(toscaElementToUpdate, nodeTypeV, firstDerivedInChain, derivedFromHighest, true);
969 if (updateDerived != StorageOperationStatus.OK) {
970 log.debug("Failed to update {} to highest derived {} from error {}", nodeTypeV.getUniqueId(), derivedFromHighest.getUniqueId(), updateDerived);
971 return Either.right(updateDerived);
973 return getToscaElement(nodeTypeV.getUniqueId(), new ComponentParametersView());
975 // no version changes
976 return Either.right(StorageOperationStatus.OK);