1 package org.openecomp.sdc.be.model.jsontitan.operations;
3 import java.util.ArrayList;
4 import java.util.HashMap;
5 import java.util.HashSet;
6 import java.util.Iterator;
9 import java.util.Map.Entry;
10 import java.util.Optional;
12 import java.util.UUID;
13 import java.util.stream.Collectors;
15 import org.apache.commons.collections.CollectionUtils;
16 import org.apache.commons.collections.MapUtils;
17 import org.apache.commons.lang.StringUtils;
18 import org.apache.commons.lang3.tuple.ImmutablePair;
19 import org.apache.commons.lang3.tuple.Pair;
20 import org.apache.tinkerpop.gremlin.structure.Direction;
21 import org.apache.tinkerpop.gremlin.structure.Edge;
22 import org.openecomp.sdc.be.config.BeEcompErrorManager;
23 import org.openecomp.sdc.be.config.ConfigurationManager;
24 import org.openecomp.sdc.be.dao.jsongraph.GraphVertex;
25 import org.openecomp.sdc.be.dao.jsongraph.types.EdgeLabelEnum;
26 import org.openecomp.sdc.be.dao.jsongraph.types.JsonParseFlagEnum;
27 import org.openecomp.sdc.be.dao.jsongraph.types.VertexTypeEnum;
28 import org.openecomp.sdc.be.dao.titan.TitanOperationStatus;
29 import org.openecomp.sdc.be.datatypes.elements.ArtifactDataDefinition;
30 import org.openecomp.sdc.be.datatypes.elements.CapabilityDataDefinition;
31 import org.openecomp.sdc.be.datatypes.elements.ComponentInstanceDataDefinition;
32 import org.openecomp.sdc.be.datatypes.elements.CompositionDataDefinition;
33 import org.openecomp.sdc.be.datatypes.elements.GroupDataDefinition;
34 import org.openecomp.sdc.be.datatypes.elements.GroupInstanceDataDefinition;
35 import org.openecomp.sdc.be.datatypes.elements.ListCapabilityDataDefinition;
36 import org.openecomp.sdc.be.datatypes.elements.ListRequirementDataDefinition;
37 import org.openecomp.sdc.be.datatypes.elements.MapArtifactDataDefinition;
38 import org.openecomp.sdc.be.datatypes.elements.MapCapabiltyProperty;
39 import org.openecomp.sdc.be.datatypes.elements.MapDataDefinition;
40 import org.openecomp.sdc.be.datatypes.elements.MapGroupsDataDefinition;
41 import org.openecomp.sdc.be.datatypes.elements.MapListCapabiltyDataDefinition;
42 import org.openecomp.sdc.be.datatypes.elements.MapListRequirementDataDefinition;
43 import org.openecomp.sdc.be.datatypes.elements.MapPropertiesDataDefinition;
44 import org.openecomp.sdc.be.datatypes.elements.RelationshipInstDataDefinition;
45 import org.openecomp.sdc.be.datatypes.elements.RequirementDataDefinition;
46 import org.openecomp.sdc.be.datatypes.enums.JsonPresentationFields;
47 import org.openecomp.sdc.be.datatypes.enums.OriginTypeEnum;
48 import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum;
49 import org.openecomp.sdc.be.model.ArtifactDefinition;
50 import org.openecomp.sdc.be.model.CapabilityDefinition;
51 import org.openecomp.sdc.be.model.Component;
52 import org.openecomp.sdc.be.model.ComponentInstance;
53 import org.openecomp.sdc.be.model.ComponentInstanceInput;
54 import org.openecomp.sdc.be.model.ComponentInstanceProperty;
55 import org.openecomp.sdc.be.model.DistributionStatusEnum;
56 import org.openecomp.sdc.be.model.GroupDefinition;
57 import org.openecomp.sdc.be.model.GroupInstance;
58 import org.openecomp.sdc.be.model.RelationshipImpl;
59 import org.openecomp.sdc.be.model.RequirementAndRelationshipPair;
60 import org.openecomp.sdc.be.model.RequirementCapabilityRelDef;
61 import org.openecomp.sdc.be.model.Resource;
62 import org.openecomp.sdc.be.model.User;
63 import org.openecomp.sdc.be.model.jsontitan.datamodel.NodeType;
64 import org.openecomp.sdc.be.model.jsontitan.datamodel.TopologyTemplate;
65 import org.openecomp.sdc.be.model.jsontitan.datamodel.ToscaElement;
66 import org.openecomp.sdc.be.model.jsontitan.datamodel.ToscaElementTypeEnum;
67 import org.openecomp.sdc.be.model.jsontitan.enums.JsonConstantKeysEnum;
68 import org.openecomp.sdc.be.model.jsontitan.utils.ModelConverter;
69 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
70 import org.openecomp.sdc.be.model.operations.impl.DaoStatusConverter;
71 import org.openecomp.sdc.be.model.operations.impl.UniqueIdBuilder;
72 import org.openecomp.sdc.common.api.ArtifactGroupTypeEnum;
73 import org.openecomp.sdc.common.api.ArtifactTypeEnum;
74 import org.openecomp.sdc.common.jsongraph.util.CommonUtility;
75 import org.openecomp.sdc.common.jsongraph.util.CommonUtility.LogLevelEnum;
76 import org.openecomp.sdc.common.util.ValidationUtils;
77 import org.slf4j.Logger;
78 import org.slf4j.LoggerFactory;
80 import fj.data.Either;
82 @org.springframework.stereotype.Component("node-template-operation")
83 public class NodeTemplateOperation extends BaseOperation {
84 private static final String ARTIFACT_PLACEHOLDER_TYPE = "type";
85 private static final String ARTIFACT_PLACEHOLDER_DISPLAY_NAME = "displayName";
86 private static final Object ARTIFACT_PLACEHOLDER_DESCRIPTION = "description";
87 public static final String HEAT_ENV_NAME = "heatEnv";
88 public static final String HEAT_VF_ENV_NAME = "VfHeatEnv";
89 public static final String HEAT_ENV_SUFFIX = "env";
90 private static Integer defaultHeatTimeout;
91 public static final Integer NON_HEAT_TIMEOUT = 0;
93 private static Logger logger = LoggerFactory.getLogger(NodeTemplateOperation.class.getName());
95 public NodeTemplateOperation() {
96 defaultHeatTimeout = ConfigurationManager.getConfigurationManager().getConfiguration().getDefaultHeatArtifactTimeoutMinutes();
97 if ((defaultHeatTimeout == null) || (defaultHeatTimeout < 1)) {
98 defaultHeatTimeout = 60;
102 public static Integer getDefaultHeatTimeout() {
103 return defaultHeatTimeout;
106 public Either<ImmutablePair<TopologyTemplate, String>, StorageOperationStatus> addComponentInstanceToTopologyTemplate(TopologyTemplate container, ToscaElement originToscaElement, String instanceNumberSuffix, ComponentInstance componentInstance,
107 boolean allowDeleted, User user) {
109 Either<ImmutablePair<TopologyTemplate, String>, StorageOperationStatus> result = null;
110 Either<TopologyTemplate, StorageOperationStatus> addComponentInstanceRes = null;
111 CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "Going to create component instance {} in component {}", componentInstance, container.getUniqueId());
112 ComponentInstanceDataDefinition componentInstanceData = null;
113 Either<String, StorageOperationStatus> newInstanceNameRes = null;
115 Either<GraphVertex, TitanOperationStatus> metadataVertex = titanDao.getVertexById(container.getUniqueId(), JsonParseFlagEnum.ParseJson);
116 if (metadataVertex.isRight()) {
117 TitanOperationStatus status = metadataVertex.right().value();
118 if (status == TitanOperationStatus.NOT_FOUND) {
119 status = TitanOperationStatus.INVALID_ID;
121 result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status));
124 if (result == null) {
125 newInstanceNameRes = buildValidateInstanceName(container, originToscaElement, componentInstance, instanceNumberSuffix);
126 if (newInstanceNameRes.isRight()) {
127 result = Either.right(newInstanceNameRes.right().value());
130 if (result == null) {
131 componentInstanceData = buildComponentInstanceDataDefinition(componentInstance, container.getUniqueId(), newInstanceNameRes.left().value(), true, originToscaElement);
133 addComponentInstanceRes = addComponentInstanceToTopologyTemplate(container, originToscaElement, componentInstanceData, metadataVertex.left().value(), allowDeleted, user);
135 if (addComponentInstanceRes.isRight()) {
136 StorageOperationStatus status = addComponentInstanceRes.right().value();
137 if (status == StorageOperationStatus.NOT_FOUND) {
138 status = StorageOperationStatus.INVALID_ID;
140 result = Either.right(status);
143 if (result == null) {
144 result = Either.left(new ImmutablePair<>(addComponentInstanceRes.left().value(), componentInstanceData.getUniqueId()));
149 private Either<String, StorageOperationStatus> buildValidateInstanceName(TopologyTemplate container, ToscaElement originToscaElement, ComponentInstance componentInstance, String instanceNumberSuffix) {
151 Either<String, StorageOperationStatus> result = null;
152 String instanceName = componentInstance.getName();
153 if (StringUtils.isEmpty(instanceName) || instanceName.equalsIgnoreCase(originToscaElement.getName())) {
154 instanceName = buildComponentInstanceName(instanceNumberSuffix, instanceName);
155 } else if (!isUniqueInstanceName(container, componentInstance.getName())) {
156 CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "Failed to create component instance with name {} on component container {}. The instance with the same name already exists. ", componentInstance.getName(), container.getName());
157 result = Either.right(StorageOperationStatus.ENTITY_ALREADY_EXISTS);
159 if (result == null) {
160 result = Either.left(instanceName);
165 public Either<TopologyTemplate, StorageOperationStatus> addComponentInstanceToTopologyTemplate(TopologyTemplate container, ToscaElement originToscaElement, ComponentInstanceDataDefinition componentInstance, GraphVertex metadataVertex,
166 boolean allowDeleted, User user) {
168 Either<TopologyTemplate, StorageOperationStatus> result = null;
169 Either<ToscaElement, StorageOperationStatus> updateContainerComponentRes = null;
170 String containerComponentId = container.getUniqueId();
171 CommonUtility.addRecordToLog(logger, LogLevelEnum.TRACE, "Going to create component instance {} in component {}", componentInstance, containerComponentId);
172 String instOriginComponentId = componentInstance.getComponentUid();
173 Either<GraphVertex, TitanOperationStatus> updateElement = null;
175 Boolean isDeleted = (Boolean) originToscaElement.getMetadataValue(JsonPresentationFields.IS_DELETED);
177 if (!allowDeleted && (isDeleted != null) && isDeleted) {
178 CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "Component {} is already deleted. Cannot add component instance", instOriginComponentId);
179 result = Either.right(StorageOperationStatus.INVALID_ID);
181 if (result == null) {
182 container.addComponentInstance(componentInstance);
183 metadataVertex.setJsonMetadataField(JsonPresentationFields.LAST_UPDATE_DATE, System.currentTimeMillis());
184 topologyTemplateOperation.fillToscaElementVertexData(metadataVertex, container, JsonParseFlagEnum.ParseAll);
185 updateElement = titanDao.updateVertex(metadataVertex);
186 if (updateElement.isRight()) {
187 CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "Failed to update topology template {} with new component instance {}. ", container.getName(), componentInstance.getName());
188 result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(updateElement.right().value()));
191 if (result == null) {
192 Either<GraphVertex, StorageOperationStatus> addToscaDataRes = addComponentInstanceToscaDataToContainerComponent(originToscaElement, componentInstance, updateElement.left().value(), user);
193 if (addToscaDataRes.isRight()) {
194 result = Either.right(addToscaDataRes.right().value());
198 if (result == null) {
199 updateContainerComponentRes = topologyTemplateOperation.getToscaElement(containerComponentId);
200 if (updateContainerComponentRes.isRight()) {
201 CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "Failed to fetch updated topology template {} with new component instance {}. ", container.getName(), componentInstance.getName());
202 result = Either.right(updateContainerComponentRes.right().value());
205 if (result == null) {
206 result = Either.left((TopologyTemplate) updateContainerComponentRes.left().value());
211 public Either<ImmutablePair<TopologyTemplate, String>, StorageOperationStatus> updateComponentInstanceMetadataOfTopologyTemplate(TopologyTemplate container, ToscaElement originToscaElement, ComponentInstance componentInstance) {
213 Either<ImmutablePair<TopologyTemplate, String>, StorageOperationStatus> result = null;
214 Either<ToscaElement, StorageOperationStatus> updateContainerComponentRes = null;
216 String containerComponentId = container.getUniqueId();
217 CommonUtility.addRecordToLog(logger, LogLevelEnum.TRACE, "Going to update component instance metadata {} of container component {}", componentInstance, containerComponentId);
218 ComponentInstanceDataDefinition componentInstanceData = null;
220 Either<GraphVertex, TitanOperationStatus> metadataVertex = titanDao.getVertexById(container.getUniqueId(), JsonParseFlagEnum.ParseMetadata);
221 if (metadataVertex.isRight()) {
222 TitanOperationStatus status = metadataVertex.right().value();
223 if (status == TitanOperationStatus.NOT_FOUND) {
224 status = TitanOperationStatus.INVALID_ID;
226 result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status));
228 if (result == null) {
229 componentInstanceData = buildComponentInstanceDataDefinition(componentInstance, container.getUniqueId(), componentInstance.getName(), false, originToscaElement);
230 container.addComponentInstance(componentInstanceData);
231 metadataVertex.left().value().setJsonMetadataField(JsonPresentationFields.LAST_UPDATE_DATE, System.currentTimeMillis());
232 topologyTemplateOperation.fillToscaElementVertexData(metadataVertex.left().value(), container, JsonParseFlagEnum.ParseAll);
233 Either<GraphVertex, TitanOperationStatus> updateElement = titanDao.updateVertex(metadataVertex.left().value());
234 if (updateElement.isRight()) {
235 CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "Failed to update topology template {} with new component instance {}. ", container.getName(), componentInstance.getName());
236 result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(updateElement.right().value()));
239 if (result == null) {
240 updateContainerComponentRes = topologyTemplateOperation.getToscaElement(containerComponentId);
241 if (updateContainerComponentRes.isRight()) {
242 CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "Failed to fetch updated topology template {} with updated component instance {}. ", container.getName(), componentInstance.getName());
243 result = Either.right(updateContainerComponentRes.right().value());
246 if (result == null) {
247 result = Either.left(new ImmutablePair<>((TopologyTemplate) updateContainerComponentRes.left().value(), componentInstanceData.getUniqueId()));
252 public Either<TopologyTemplate, StorageOperationStatus> updateComponentInstanceMetadataOfTopologyTemplate(TopologyTemplate container) {
254 Either<TopologyTemplate, StorageOperationStatus> result = null;
255 Either<ToscaElement, StorageOperationStatus> updateContainerComponentRes = null;
257 String containerComponentId = container.getUniqueId();
258 CommonUtility.addRecordToLog(logger, LogLevelEnum.TRACE, "Going to update component instance metadata of container component {}", containerComponentId);
260 Either<GraphVertex, TitanOperationStatus> metadataVertex = titanDao.getVertexById(container.getUniqueId(), JsonParseFlagEnum.ParseMetadata);
261 if (metadataVertex.isRight()) {
262 TitanOperationStatus status = metadataVertex.right().value();
263 if (status == TitanOperationStatus.NOT_FOUND) {
264 status = TitanOperationStatus.INVALID_ID;
266 result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status));
268 if (result == null) {
269 metadataVertex.left().value().setJsonMetadataField(JsonPresentationFields.LAST_UPDATE_DATE, System.currentTimeMillis());
270 topologyTemplateOperation.fillToscaElementVertexData(metadataVertex.left().value(), container, JsonParseFlagEnum.ParseAll);
271 Either<GraphVertex, TitanOperationStatus> updateElement = titanDao.updateVertex(metadataVertex.left().value());
272 if (updateElement.isRight()) {
273 CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "Failed to update topology template {}. ", container.getName());
274 result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(updateElement.right().value()));
277 if (result == null) {
278 updateContainerComponentRes = topologyTemplateOperation.getToscaElement(containerComponentId);
279 if (updateContainerComponentRes.isRight()) {
280 CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "Failed to fetch updated topology template {}. ", container.getName());
281 result = Either.right(updateContainerComponentRes.right().value());
284 if (result == null) {
285 result = Either.left((TopologyTemplate) updateContainerComponentRes.left().value());
290 public Either<ImmutablePair<TopologyTemplate, String>, StorageOperationStatus> deleteComponentInstanceFromTopologyTemplate(TopologyTemplate container, String componentInstanceId) {
292 Either<ImmutablePair<TopologyTemplate, String>, StorageOperationStatus> result = null;
293 Either<ToscaElement, StorageOperationStatus> updateContainerComponentRes = null;
295 String containerComponentId = container.getUniqueId();
296 CommonUtility.addRecordToLog(logger, LogLevelEnum.TRACE, "Going to update component instance metadata {} of container component {}", componentInstanceId, containerComponentId);
298 Either<GraphVertex, TitanOperationStatus> metadataVertex = titanDao.getVertexById(container.getUniqueId(), JsonParseFlagEnum.ParseMetadata);
299 if (metadataVertex.isRight()) {
300 TitanOperationStatus status = metadataVertex.right().value();
301 if (status == TitanOperationStatus.NOT_FOUND) {
302 status = TitanOperationStatus.INVALID_ID;
304 result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status));
306 GraphVertex containerV = null;
307 if (result == null) {
308 container.getComponentInstances().remove(componentInstanceId);
309 containerV = metadataVertex.left().value();
310 StorageOperationStatus status = removeRelationsOfInstance(container, componentInstanceId, containerV);
311 if (status != StorageOperationStatus.OK) {
312 CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "Failed to delete relation for component instance {} in container. error {}", componentInstanceId, container.getUniqueId(), status);
313 result = Either.right(status);
316 containerV.setJsonMetadataField(JsonPresentationFields.LAST_UPDATE_DATE, System.currentTimeMillis());
317 topologyTemplateOperation.fillToscaElementVertexData(containerV, container, JsonParseFlagEnum.ParseAll);
318 Either<GraphVertex, TitanOperationStatus> updateElement = titanDao.updateVertex(containerV);
319 if (updateElement.isRight()) {
320 CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "Failed to update topology template {} with new component instance {}. ", container.getName(), componentInstanceId);
321 result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(updateElement.right().value()));
324 if (result == null) {
325 StorageOperationStatus status = deleteComponentInstanceToscaDataFromContainerComponent(containerV, componentInstanceId);
326 if (status != StorageOperationStatus.OK) {
327 CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "Failed to delete data for instance {} in container {}. error {] ", componentInstanceId, container.getUniqueId(), status);
328 return Either.right(status);
330 updateContainerComponentRes = topologyTemplateOperation.getToscaElement(containerComponentId);
331 if (updateContainerComponentRes.isRight()) {
332 CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "Failed to fetch updated topology template {} after deleting the component instance {}. ", container.getName(), componentInstanceId);
333 result = Either.right(updateContainerComponentRes.right().value());
336 if (result == null) {
337 result = Either.left(new ImmutablePair<>((TopologyTemplate) updateContainerComponentRes.left().value(), componentInstanceId));
342 private StorageOperationStatus removeRelationsOfInstance(TopologyTemplate container, String ciToRemove, GraphVertex containerV) {
343 CompositionDataDefinition composition = container.getCompositions().get(JsonConstantKeysEnum.COMPOSITION.getValue());
344 if (composition != null) {
345 Map<String, RelationshipInstDataDefinition> relations = composition.getRelations();
346 if (MapUtils.isNotEmpty(relations)) {
347 Either<Pair<GraphVertex, Map<String, MapListCapabiltyDataDefinition>>, StorageOperationStatus> capResult = fetchContainerCalculatedCapability(containerV, EdgeLabelEnum.CALCULATED_CAPABILITIES);
348 if (capResult.isRight()) {
349 return capResult.right().value();
352 Map<String, MapListCapabiltyDataDefinition> calculatedCapabilty = capResult.left().value().getRight();
354 Either<Pair<GraphVertex, Map<String, MapListCapabiltyDataDefinition>>, StorageOperationStatus> capFullResult = fetchContainerCalculatedCapability(containerV, EdgeLabelEnum.FULLFILLED_CAPABILITIES);
355 if (capResult.isRight()) {
356 return capResult.right().value();
359 Map<String, MapListCapabiltyDataDefinition> fullFilledCapabilty = capFullResult.left().value().getRight();
361 Either<Pair<GraphVertex, Map<String, MapListRequirementDataDefinition>>, StorageOperationStatus> reqResult = fetchContainerCalculatedRequirement(containerV, EdgeLabelEnum.CALCULATED_REQUIREMENTS);
362 if (reqResult.isRight()) {
363 return reqResult.right().value();
365 Map<String, MapListRequirementDataDefinition> calculatedRequirement = reqResult.left().value().getRight();
367 Either<Pair<GraphVertex, Map<String, MapListRequirementDataDefinition>>, StorageOperationStatus> reqFullResult = fetchContainerCalculatedRequirement(containerV, EdgeLabelEnum.FULLFILLED_REQUIREMENTS);
368 if (reqResult.isRight()) {
369 return reqResult.right().value();
371 Map<String, MapListRequirementDataDefinition> fullfilledRequirement = reqFullResult.left().value().getRight();
373 Iterator<Entry<String, RelationshipInstDataDefinition>> iterator = relations.entrySet().iterator();
374 while (iterator.hasNext()) {
375 Entry<String, RelationshipInstDataDefinition> relation = iterator.next();
376 RelationshipInstDataDefinition relationToDelete = relation.getValue();
377 if (relationToDelete.getFromId().equals(ciToRemove) || relationToDelete.getToId().equals(ciToRemove)) {
379 if (relationToDelete.getFromId().equals(ciToRemove)) {
380 updateCalculatedRequirementsAfterDeleteRelation(calculatedRequirement, fullfilledRequirement, ciToRemove, relationToDelete);
381 updateCalculatedCapabiltyAfterDeleteRelation(calculatedCapabilty, fullFilledCapabilty, relationToDelete.getToId(), relationToDelete);
383 if (relationToDelete.getToId().equals(ciToRemove)) {
384 updateCalculatedRequirementsAfterDeleteRelation(calculatedRequirement, fullfilledRequirement, relationToDelete.getFromId(), relationToDelete);
385 updateCalculatedCapabiltyAfterDeleteRelation(calculatedCapabilty, fullFilledCapabilty, ciToRemove, relationToDelete);
391 return StorageOperationStatus.OK;
394 private StorageOperationStatus deleteComponentInstanceToscaDataFromContainerComponent(GraphVertex containerV, String componentInstanceId) {
395 StorageOperationStatus status = deleteToscaDataDeepElementsBlockToToscaElement(containerV, EdgeLabelEnum.CALCULATED_CAPABILITIES, VertexTypeEnum.CALCULATED_CAPABILITIES, componentInstanceId);
396 if (status != StorageOperationStatus.OK && status != StorageOperationStatus.NOT_FOUND) {
397 CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "Failed to remove calculated capabilty for instance {} in container {}. error {] ", componentInstanceId, containerV.getUniqueId(), status);
400 status = deleteToscaDataDeepElementsBlockToToscaElement(containerV, EdgeLabelEnum.CALCULATED_CAP_PROPERTIES, VertexTypeEnum.CALCULATED_CAP_PROPERTIES, componentInstanceId);
401 if (status != StorageOperationStatus.OK && status != StorageOperationStatus.NOT_FOUND) {
402 CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "Failed to remove calculated capabilty properties for instance {} in container {}. error {] ", componentInstanceId, containerV.getUniqueId(), status);
405 status = deleteToscaDataDeepElementsBlockToToscaElement(containerV, EdgeLabelEnum.CALCULATED_REQUIREMENTS, VertexTypeEnum.CALCULATED_REQUIREMENTS, componentInstanceId);
406 if (status != StorageOperationStatus.OK && status != StorageOperationStatus.NOT_FOUND) {
407 CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "Failed to remove calculated requirement for instance {} in container {}. error {] ", componentInstanceId, containerV.getUniqueId(), status);
410 status = deleteToscaDataDeepElementsBlockToToscaElement(containerV, EdgeLabelEnum.FULLFILLED_CAPABILITIES, VertexTypeEnum.FULLFILLED_CAPABILITIES, componentInstanceId);
411 if (status != StorageOperationStatus.OK && status != StorageOperationStatus.NOT_FOUND) {
412 CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "Failed to remove fullfilled capabilities for instance {} in container {}. error {] ", componentInstanceId, containerV.getUniqueId(), status);
415 status = deleteToscaDataDeepElementsBlockToToscaElement(containerV, EdgeLabelEnum.FULLFILLED_REQUIREMENTS, VertexTypeEnum.FULLFILLED_REQUIREMENTS, componentInstanceId);
416 if (status != StorageOperationStatus.OK && status != StorageOperationStatus.NOT_FOUND) {
417 CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "Failed to remove fullfilled requirement for instance {} in container {}. error {] ", componentInstanceId, containerV.getUniqueId(), status);
420 status = deleteToscaDataDeepElementsBlockToToscaElement(containerV, EdgeLabelEnum.INST_ATTRIBUTES, VertexTypeEnum.INST_ATTRIBUTES, componentInstanceId);
421 if (status != StorageOperationStatus.OK && status != StorageOperationStatus.NOT_FOUND) {
422 CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "Failed to remove attributes for instance {} in container {}. error {] ", componentInstanceId, containerV.getUniqueId(), status);
425 status = deleteToscaDataDeepElementsBlockToToscaElement(containerV, EdgeLabelEnum.INST_PROPERTIES, VertexTypeEnum.INST_PROPERTIES, componentInstanceId);
426 if (status != StorageOperationStatus.OK && status != StorageOperationStatus.NOT_FOUND) {
427 CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "Failed to remove properties for instance {} in container {}. error {] ", componentInstanceId, containerV.getUniqueId(), status);
430 status = deleteToscaDataDeepElementsBlockToToscaElement(containerV, EdgeLabelEnum.INST_INPUTS, VertexTypeEnum.INST_INPUTS, componentInstanceId);
431 if (status != StorageOperationStatus.OK && status != StorageOperationStatus.NOT_FOUND) {
432 CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "Failed to remove instance inputs for instance {} in container {}. error {] ", componentInstanceId, containerV.getUniqueId(), status);
435 status = deleteToscaDataDeepElementsBlockToToscaElement(containerV, EdgeLabelEnum.INST_GROUPS, VertexTypeEnum.INST_GROUPS, componentInstanceId);
436 if (status != StorageOperationStatus.OK && status != StorageOperationStatus.NOT_FOUND) {
437 CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "Failed to remove fullfilled requirement for instance {} in container {}. error {] ", componentInstanceId, containerV.getUniqueId(), status);
440 status = deleteToscaDataDeepElementsBlockToToscaElement(containerV, EdgeLabelEnum.INST_DEPLOYMENT_ARTIFACTS, VertexTypeEnum.INST_DEPLOYMENT_ARTIFACTS, componentInstanceId);
441 if (status != StorageOperationStatus.OK && status != StorageOperationStatus.NOT_FOUND) {
442 CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "Failed to remove instance deployment artifacts for instance {} in container {}. error {] ", componentInstanceId, containerV.getUniqueId(), status);
445 status = deleteToscaDataDeepElementsBlockToToscaElement(containerV, EdgeLabelEnum.INSTANCE_ARTIFACTS, VertexTypeEnum.INSTANCE_ARTIFACTS, componentInstanceId);
446 if (status != StorageOperationStatus.OK && status != StorageOperationStatus.NOT_FOUND) {
447 CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "Failed to remove instance artifacts for instance {} in container {}. error {] ", componentInstanceId, containerV.getUniqueId(), status);
450 return StorageOperationStatus.OK;
453 protected Either<GraphVertex, StorageOperationStatus> addComponentInstanceToscaDataToContainerComponent(ToscaElement originToscaElement, ComponentInstanceDataDefinition componentInstance, GraphVertex updatedContainerVertex, User user) {
455 Either<GraphVertex, StorageOperationStatus> result;
456 StorageOperationStatus status;
457 if (originToscaElement.getToscaType() == ToscaElementTypeEnum.NodeType) {
458 status = addComponentInstanceToscaDataToNodeTypeContainer((NodeType) originToscaElement, componentInstance, updatedContainerVertex, user, HEAT_VF_ENV_NAME);
460 status = addComponentInstanceToscaDataToTopologyTemplateContainer((TopologyTemplate) originToscaElement, componentInstance, updatedContainerVertex);
462 if (status == StorageOperationStatus.OK) {
463 result = Either.left(updatedContainerVertex);
465 result = Either.right(status);
470 private StorageOperationStatus addComponentInstanceToscaDataToTopologyTemplateContainer(TopologyTemplate originTopologyTemplate, ComponentInstanceDataDefinition componentInstance, GraphVertex updatedContainerVertex) {
472 StorageOperationStatus status;
474 status = addCalculatedCapReqFromTopologyTemplate(originTopologyTemplate, componentInstance, updatedContainerVertex);
476 if (status != StorageOperationStatus.OK) {
481 MapPropertiesDataDefinition instProperties = new MapPropertiesDataDefinition(originTopologyTemplate.getInputs());
483 status = addToscaDataDeepElementsBlockToToscaElement(updatedContainerVertex, EdgeLabelEnum.INST_INPUTS, VertexTypeEnum.INST_INPUTS, instProperties, componentInstance.getUniqueId());
484 if (status != StorageOperationStatus.OK) {
491 private StorageOperationStatus addCalculatedCapReqFromTopologyTemplate(TopologyTemplate originTopologyTemplate, ComponentInstanceDataDefinition componentInstance, GraphVertex updatedContainerVertex) {
492 Map<String, MapListCapabiltyDataDefinition> calculatedCapabilities = originTopologyTemplate.getCalculatedCapabilities();
494 if (calculatedCapabilities != null) {
495 MapListCapabiltyDataDefinition allCalculatedCap = new MapListCapabiltyDataDefinition();
496 calculatedCapabilities.entrySet().forEach(enntryPerInstance -> {
497 Map<String, ListCapabilityDataDefinition> mapByType = enntryPerInstance.getValue().getMapToscaDataDefinition();
498 mapByType.entrySet().forEach(entryPerType -> {
499 entryPerType.getValue().getListToscaDataDefinition().forEach(cap -> {
500 cap.addToPath(componentInstance.getUniqueId());
501 allCalculatedCap.add(entryPerType.getKey(), cap);
506 StorageOperationStatus calculatedResult = addToscaDataDeepElementsBlockToToscaElement(updatedContainerVertex, EdgeLabelEnum.CALCULATED_CAPABILITIES, VertexTypeEnum.CALCULATED_CAPABILITIES, allCalculatedCap,
507 componentInstance.getUniqueId());
509 if (calculatedResult != StorageOperationStatus.OK) {
510 return calculatedResult;
512 MapListCapabiltyDataDefinition fullCalculatedCap = new MapListCapabiltyDataDefinition();
513 calculatedResult = addToscaDataDeepElementsBlockToToscaElement(updatedContainerVertex, EdgeLabelEnum.FULLFILLED_CAPABILITIES, VertexTypeEnum.FULLFILLED_CAPABILITIES, fullCalculatedCap, componentInstance.getUniqueId());
515 if (calculatedResult != StorageOperationStatus.OK) {
516 return calculatedResult;
519 Map<String, MapListRequirementDataDefinition> calculatedRequirements = originTopologyTemplate.getCalculatedRequirements();
520 if (calculatedRequirements != null) {
522 MapListRequirementDataDefinition allCalculatedReq = new MapListRequirementDataDefinition();
523 calculatedRequirements.entrySet().forEach(enntryPerInstance -> {
524 Map<String, ListRequirementDataDefinition> mapByType = enntryPerInstance.getValue().getMapToscaDataDefinition();
525 mapByType.entrySet().forEach(entryPerType -> {
526 entryPerType.getValue().getListToscaDataDefinition().forEach(req -> {
527 req.addToPath(componentInstance.getUniqueId());
528 allCalculatedReq.add(entryPerType.getKey(), req);
533 StorageOperationStatus calculatedResult = addToscaDataDeepElementsBlockToToscaElement(updatedContainerVertex, EdgeLabelEnum.CALCULATED_REQUIREMENTS, VertexTypeEnum.CALCULATED_REQUIREMENTS, allCalculatedReq,
534 componentInstance.getUniqueId());
535 if (calculatedResult != StorageOperationStatus.OK) {
536 return calculatedResult;
538 MapListRequirementDataDefinition fullCalculatedReq = new MapListRequirementDataDefinition();
539 calculatedResult = addToscaDataDeepElementsBlockToToscaElement(updatedContainerVertex, EdgeLabelEnum.FULLFILLED_REQUIREMENTS, VertexTypeEnum.FULLFILLED_REQUIREMENTS, fullCalculatedReq, componentInstance.getUniqueId());
540 if (calculatedResult != StorageOperationStatus.OK) {
541 return calculatedResult;
545 Map<String, MapCapabiltyProperty> calculatedCapabilitiesProperties = originTopologyTemplate.getCalculatedCapabilitiesProperties();
546 Map<String, MapPropertiesDataDefinition> updateKeyMap = new HashMap<>();
548 if (calculatedCapabilitiesProperties != null && !calculatedCapabilitiesProperties.isEmpty()) {
549 for (MapCapabiltyProperty map : calculatedCapabilitiesProperties.values()) {
550 for (Entry<String, MapPropertiesDataDefinition> entry : map.getMapToscaDataDefinition().entrySet()) {
551 String newKey = new String(componentInstance.getUniqueId() + ModelConverter.CAP_PROP_DELIM + entry.getKey());
552 updateKeyMap.put(newKey, entry.getValue());
555 MapCapabiltyProperty mapCapabiltyProperty = new MapCapabiltyProperty(updateKeyMap);
556 StorageOperationStatus calculatedResult = addToscaDataDeepElementsBlockToToscaElement(updatedContainerVertex, EdgeLabelEnum.CALCULATED_CAP_PROPERTIES, VertexTypeEnum.CALCULATED_CAP_PROPERTIES, mapCapabiltyProperty,
557 componentInstance.getUniqueId());
558 if (calculatedResult != StorageOperationStatus.OK) {
559 return calculatedResult;
562 return StorageOperationStatus.OK;
565 private StorageOperationStatus addComponentInstanceToscaDataToNodeTypeContainer(NodeType originNodeType, ComponentInstanceDataDefinition componentInstance, GraphVertex updatedContainerVertex, User user, String envType) {
567 MapPropertiesDataDefinition instProperties = new MapPropertiesDataDefinition(originNodeType.getProperties());
569 StorageOperationStatus status = addToscaDataDeepElementsBlockToToscaElement(updatedContainerVertex, EdgeLabelEnum.INST_PROPERTIES, VertexTypeEnum.INST_PROPERTIES, instProperties, componentInstance.getUniqueId());
570 if (status != StorageOperationStatus.OK) {
574 MapPropertiesDataDefinition instAttributes = new MapPropertiesDataDefinition(originNodeType.getAttributes());
576 status = addToscaDataDeepElementsBlockToToscaElement(updatedContainerVertex, EdgeLabelEnum.INST_ATTRIBUTES, VertexTypeEnum.INST_ATTRIBUTES, instAttributes, componentInstance.getUniqueId());
578 if (status != StorageOperationStatus.OK) {
581 status = addInstanceDeploymentArtifacts(originNodeType, componentInstance, updatedContainerVertex, user, envType);
582 if (status != StorageOperationStatus.OK) {
585 return addCalculatedCapReqFromNodeType(originNodeType, componentInstance, updatedContainerVertex);
589 private StorageOperationStatus addInstanceDeploymentArtifacts(ToscaElement originNodeType, ComponentInstanceDataDefinition componentInstance, GraphVertex updatedContainerVertex, User user, String envType) {
590 Map<String, ArtifactDataDefinition> deploymentArtifacts = originNodeType.getDeploymentArtifacts();
591 MapArtifactDataDefinition instArtifacts = prepareInstDeploymentArtifactPerInstance(deploymentArtifacts, componentInstance.getUniqueId(), user, envType);
592 if (instArtifacts != null) {
593 StorageOperationStatus calculatedResult = addToscaDataDeepElementsBlockToToscaElement(updatedContainerVertex, EdgeLabelEnum.INST_DEPLOYMENT_ARTIFACTS, VertexTypeEnum.INST_DEPLOYMENT_ARTIFACTS, instArtifacts,
594 componentInstance.getUniqueId());
596 if (calculatedResult != StorageOperationStatus.OK) {
597 return calculatedResult;
600 return StorageOperationStatus.OK;
603 public MapArtifactDataDefinition prepareInstDeploymentArtifactPerInstance(Map<String, ArtifactDataDefinition> deploymentArtifacts, String componentInstanceId, User user, String envType) {
604 if (deploymentArtifacts != null && envType.equals(HEAT_VF_ENV_NAME)) {
605 Map<String, ArtifactDataDefinition> instDeploymentArtifacts = new HashMap<>();
606 deploymentArtifacts.entrySet().forEach(e -> {
607 ArtifactDataDefinition artifact = e.getValue();
608 String type = artifact.getArtifactType();
609 if (!(type.equalsIgnoreCase(ArtifactTypeEnum.HEAT.getType()) || type.equalsIgnoreCase(ArtifactTypeEnum.HEAT_NET.getType()) || type.equalsIgnoreCase(ArtifactTypeEnum.HEAT_VOL.getType()))) {
610 instDeploymentArtifacts.put(e.getKey(), artifact);
611 ArtifactDataDefinition artifactEnv = createArtifactPlaceHolderInfo(artifact, componentInstanceId, user, envType);
612 instDeploymentArtifacts.put(artifactEnv.getArtifactLabel(), artifactEnv);
616 MapArtifactDataDefinition instArtifacts = new MapArtifactDataDefinition(instDeploymentArtifacts);
617 return instArtifacts;
622 @SuppressWarnings({ "unchecked" })
623 private ArtifactDataDefinition createArtifactPlaceHolderInfo(ArtifactDataDefinition artifactHeat, String componentId, User user, String heatEnvType) {
624 Map<String, Object> deploymentResourceArtifacts = ConfigurationManager.getConfigurationManager().getConfiguration().getDeploymentResourceInstanceArtifacts();
625 if (deploymentResourceArtifacts == null) {
626 logger.debug("no deployment artifacts are configured for generated artifacts");
629 Map<String, Object> placeHolderData = (Map<String, Object>) deploymentResourceArtifacts.get(heatEnvType);
630 if (placeHolderData == null) {
631 logger.debug("no env type {} are configured for generated artifacts", heatEnvType);
635 String envLabel = (artifactHeat.getArtifactLabel() + HEAT_ENV_SUFFIX).toLowerCase();
637 ArtifactDataDefinition artifactInfo = new ArtifactDataDefinition();
639 String artifactName = (String) placeHolderData.get(ARTIFACT_PLACEHOLDER_DISPLAY_NAME);
640 String artifactType = (String) placeHolderData.get(ARTIFACT_PLACEHOLDER_TYPE);
641 String artifactDescription = (String) placeHolderData.get(ARTIFACT_PLACEHOLDER_DESCRIPTION);
643 artifactInfo.setArtifactDisplayName(artifactName);
644 artifactInfo.setArtifactLabel(envLabel);
645 artifactInfo.setArtifactType(artifactType);
646 artifactInfo.setDescription(artifactDescription);
647 artifactInfo.setArtifactGroupType(artifactHeat.getArtifactGroupType());
648 setDefaultArtifactTimeout(artifactHeat.getArtifactGroupType(), artifactInfo);
649 artifactInfo.setGeneratedFromId(artifactHeat.getUniqueId());
650 // clone heat parameters in case of heat env only not VF heat env
651 if (heatEnvType.equals(HEAT_ENV_NAME)) {
652 artifactInfo.setHeatParameters(artifactHeat.getHeatParameters());
654 setArtifactPlaceholderCommonFields(componentId, user, artifactInfo);
659 public void setDefaultArtifactTimeout(ArtifactGroupTypeEnum groupType, ArtifactDataDefinition artifactInfo) {
660 if (groupType.equals(ArtifactGroupTypeEnum.DEPLOYMENT)) {
661 artifactInfo.setTimeout(defaultHeatTimeout);
663 artifactInfo.setTimeout(NON_HEAT_TIMEOUT);
667 private void setArtifactPlaceholderCommonFields(String resourceId, User user, ArtifactDataDefinition artifactInfo) {
668 String uniqueId = null;
670 if (resourceId != null) {
671 uniqueId = UniqueIdBuilder.buildPropertyUniqueId(resourceId.toLowerCase(), artifactInfo.getArtifactLabel().toLowerCase());
672 artifactInfo.setUniqueId(uniqueId);
674 artifactInfo.setUserIdCreator(user.getUserId());
675 String fullName = user.getFullName();
676 artifactInfo.setUpdaterFullName(fullName);
678 long time = System.currentTimeMillis();
680 artifactInfo.setCreatorFullName(fullName);
681 artifactInfo.setCreationDate(time);
683 artifactInfo.setLastUpdateDate(time);
684 artifactInfo.setUserIdLastUpdater(user.getUserId());
686 artifactInfo.setMandatory(true);
691 * @param originNodeType
692 * @param componentInstance
693 * @param updatedContainerVertex
696 private StorageOperationStatus addCalculatedCapReqFromNodeType(NodeType originNodeType, ComponentInstanceDataDefinition componentInstance, GraphVertex updatedContainerVertex) {
698 Map<String, ListCapabilityDataDefinition> capabilities = originNodeType.getCapabilties();
699 MapListCapabiltyDataDefinition allCalculatedCap = prepareCalculatedCapabiltyForNodeType(capabilities, componentInstance);
700 StorageOperationStatus calculatedResult;
701 if (allCalculatedCap != null) {
702 calculatedResult = addToscaDataDeepElementsBlockToToscaElement(updatedContainerVertex, EdgeLabelEnum.CALCULATED_CAPABILITIES, VertexTypeEnum.CALCULATED_CAPABILITIES, allCalculatedCap, componentInstance.getUniqueId());
704 if (calculatedResult != StorageOperationStatus.OK) {
705 return calculatedResult;
708 Map<String, MapPropertiesDataDefinition> capabiltiesProperties = originNodeType.getCapabiltiesProperties();
709 if (capabiltiesProperties != null) {
710 Map<String, MapPropertiesDataDefinition> updateKeyMap = capabiltiesProperties.entrySet().stream().collect(Collectors.toMap(e -> createCapPropertyKey(e.getKey(), componentInstance.getUniqueId()), e -> e.getValue()));
711 MapCapabiltyProperty mapCapabiltyProperty = new MapCapabiltyProperty(updateKeyMap);
712 calculatedResult = addToscaDataDeepElementsBlockToToscaElement(updatedContainerVertex, EdgeLabelEnum.CALCULATED_CAP_PROPERTIES, VertexTypeEnum.CALCULATED_CAP_PROPERTIES, mapCapabiltyProperty, componentInstance.getUniqueId());
713 if (calculatedResult != StorageOperationStatus.OK) {
714 return calculatedResult;
718 MapListCapabiltyDataDefinition fullCalculatedCap = new MapListCapabiltyDataDefinition();
719 calculatedResult = addToscaDataDeepElementsBlockToToscaElement(updatedContainerVertex, EdgeLabelEnum.FULLFILLED_CAPABILITIES, VertexTypeEnum.FULLFILLED_CAPABILITIES, fullCalculatedCap, componentInstance.getUniqueId());
721 if (calculatedResult != StorageOperationStatus.OK) {
722 return calculatedResult;
725 Map<String, ListRequirementDataDefinition> requirements = originNodeType.getRequirements();
727 MapListRequirementDataDefinition allCalculatedReq = prepareCalculatedRequirementForNodeType(requirements, componentInstance);
729 StorageOperationStatus status;
730 if (allCalculatedReq != null) {
731 status = addToscaDataDeepElementsBlockToToscaElement(updatedContainerVertex, EdgeLabelEnum.CALCULATED_REQUIREMENTS, VertexTypeEnum.CALCULATED_REQUIREMENTS, allCalculatedReq, componentInstance.getUniqueId());
732 if (status != StorageOperationStatus.OK) {
736 MapListRequirementDataDefinition fullCalculatedReq = new MapListRequirementDataDefinition();
737 status = addToscaDataDeepElementsBlockToToscaElement(updatedContainerVertex, EdgeLabelEnum.FULLFILLED_REQUIREMENTS, VertexTypeEnum.FULLFILLED_REQUIREMENTS, fullCalculatedReq, componentInstance.getUniqueId());
738 return StorageOperationStatus.OK;
742 public static String createCapPropertyKey(String key, String instanceId) {
743 StringBuffer sb = new StringBuffer(instanceId);
744 sb.append(ModelConverter.CAP_PROP_DELIM).append(instanceId).append(ModelConverter.CAP_PROP_DELIM).append(key);
745 return sb.toString();
748 public MapListCapabiltyDataDefinition prepareCalculatedCapabiltyForNodeType(Map<String, ListCapabilityDataDefinition> capabilities, ComponentInstanceDataDefinition componentInstance) {
749 if (capabilities != null) {
750 MapListCapabiltyDataDefinition allCalculatedCap = new MapListCapabiltyDataDefinition();
752 capabilities.entrySet().forEach(e -> {
753 List<CapabilityDataDefinition> listCapabilities = e.getValue().getListToscaDataDefinition();
754 listCapabilities.forEach(cap -> {
755 cap.setSource(componentInstance.getComponentUid());
756 cap.addToPath(componentInstance.getUniqueId());
757 cap.setOwnerId(componentInstance.getUniqueId());
758 cap.setOwnerName(componentInstance.getName());
759 cap.setLeftOccurrences(cap.getMaxOccurrences());
760 allCalculatedCap.add(e.getKey(), cap);
763 return allCalculatedCap;
768 public MapListRequirementDataDefinition prepareCalculatedRequirementForNodeType(Map<String, ListRequirementDataDefinition> requirements, ComponentInstanceDataDefinition componentInstance) {
769 if (requirements != null) {
770 MapListRequirementDataDefinition allCalculatedReq = new MapListRequirementDataDefinition();
772 requirements.entrySet().forEach(e -> {
773 List<RequirementDataDefinition> listCapabilities = e.getValue().getListToscaDataDefinition();
774 listCapabilities.forEach(req -> {
775 req.setSource(componentInstance.getComponentUid());
776 req.addToPath(componentInstance.getUniqueId());
777 req.setOwnerId(componentInstance.getUniqueId());
778 req.setOwnerName(componentInstance.getName());
779 req.setLeftOccurrences(req.getMaxOccurrences());
780 allCalculatedReq.add(e.getKey(), req);
783 return allCalculatedReq;
788 public StorageOperationStatus addGroupInstancesToComponentInstance(Component containerComponent, ComponentInstanceDataDefinition componentInstance, List<GroupDefinition> groups, Map<String, List<ArtifactDefinition>> groupInstancesArtifacts) {
790 StorageOperationStatus result = null;
791 Map<String, GroupInstanceDataDefinition> groupInstanceToCreate = new HashMap<>();
792 if (groupInstancesArtifacts != null && CollectionUtils.isNotEmpty(groups)) {
793 for (Map.Entry<String, List<ArtifactDefinition>> groupArtifacts : groupInstancesArtifacts.entrySet()) {
794 Optional<GroupDefinition> groupOptional = groups.stream().filter(g -> g.getUniqueId().equals(groupArtifacts.getKey())).findFirst();
795 if (groupOptional.isPresent()) {
796 GroupInstanceDataDefinition groupInstance = buildGroupInstanceDataDefinition((GroupDataDefinition)groupOptional.get(), (ComponentInstanceDataDefinition)componentInstance);
797 groupInstance.setGroupInstanceArtifacts(groupArtifacts.getValue().stream().map(a -> a.getUniqueId()).collect(Collectors.toList()));
798 groupInstance.setGroupInstanceArtifactsUuid(groupArtifacts.getValue().stream().map(a -> a.getArtifactUUID()).collect(Collectors.toList()));
799 groupInstanceToCreate.put(groupInstance.getName(), groupInstance);
803 if (MapUtils.isNotEmpty(groupInstanceToCreate)) {
804 result = addToscaDataDeepElementsBlockToToscaElement(containerComponent.getUniqueId(), EdgeLabelEnum.INST_GROUPS, VertexTypeEnum.INST_GROUPS, new MapDataDefinition<>(groupInstanceToCreate), componentInstance.getUniqueId());
806 if (result == null) {
807 result = StorageOperationStatus.OK;
814 private ComponentInstanceDataDefinition buildComponentInstanceDataDefinition(ComponentInstance resourceInstance, String containerComponentId, String instanceNewName, boolean generateUid, ToscaElement originToscaElement) {
815 String ciOriginComponentUid = resourceInstance.getComponentUid();
817 if (!ValidationUtils.validateStringNotEmpty(resourceInstance.getCustomizationUUID())) {
818 resourceInstance.setCustomizationUUID(generateCustomizationUUID());
820 ComponentInstanceDataDefinition dataDefinition = new ComponentInstanceDataDefinition(resourceInstance);
822 Long creationDate = resourceInstance.getCreationTime();
823 if (creationDate == null) {
824 creationDate = System.currentTimeMillis();
826 dataDefinition.setComponentUid(ciOriginComponentUid);
827 dataDefinition.setCreationTime(creationDate);
828 dataDefinition.setModificationTime(creationDate);
829 if (StringUtils.isNotEmpty(instanceNewName)) {
830 dataDefinition.setName(instanceNewName);
831 resourceInstance.setName(instanceNewName);
833 if (StringUtils.isNotEmpty(dataDefinition.getName()))
834 dataDefinition.setNormalizedName(ValidationUtils.normalizeComponentInstanceName(dataDefinition.getName()));
835 dataDefinition.setIcon(resourceInstance.getIcon());
837 dataDefinition.setUniqueId(UniqueIdBuilder.buildResourceInstanceUniuqeId(containerComponentId, ciOriginComponentUid, dataDefinition.getNormalizedName()));
838 resourceInstance.setUniqueId(dataDefinition.getUniqueId());
840 if (StringUtils.isEmpty(dataDefinition.getComponentVersion()) && originToscaElement != null)
841 dataDefinition.setComponentVersion((String) originToscaElement.getMetadataValue(JsonPresentationFields.VERSION));
842 if (StringUtils.isEmpty(dataDefinition.getComponentName()) && originToscaElement != null)
843 dataDefinition.setComponentName((String) originToscaElement.getMetadataValue(JsonPresentationFields.NAME));
844 if (StringUtils.isEmpty(dataDefinition.getToscaComponentName()) && originToscaElement != null)
845 dataDefinition.setToscaComponentName((String) originToscaElement.getMetadataValue(JsonPresentationFields.TOSCA_RESOURCE_NAME));
846 if (dataDefinition.getOriginType() == null && originToscaElement != null) {
847 ResourceTypeEnum resourceType = originToscaElement.getResourceType();
848 OriginTypeEnum originType = null;
849 switch (resourceType) {
851 originType = OriginTypeEnum.VF;
854 originType = OriginTypeEnum.VFC;
857 originType = OriginTypeEnum.VL;
860 originType = OriginTypeEnum.CP;
865 dataDefinition.setOriginType(originType);
867 return dataDefinition;
870 private Boolean isUniqueInstanceName(TopologyTemplate container, String instanceName) {
871 Boolean isUniqueName = true;
873 isUniqueName = !container.getComponentInstances().values().stream().filter(ci -> ci.getName() != null && ci.getName().equals(instanceName)).findAny().isPresent();
875 } catch (Exception e) {
876 CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "Exception occured during fetching component instance with name {} from component container {}. {} ", instanceName, container.getName(), e.getMessage());
885 private String buildComponentInstanceName(String instanceSuffixNumber, String instanceName) {
886 return instanceName + " " + (instanceSuffixNumber == null ? 0 : instanceSuffixNumber);
889 public Either<RequirementCapabilityRelDef, StorageOperationStatus> associateResourceInstances(String componentId, RequirementCapabilityRelDef relation) {
890 List<RequirementCapabilityRelDef> relations = new ArrayList<>();
891 relations.add(relation);
892 Either<List<RequirementCapabilityRelDef>, StorageOperationStatus> associateResourceInstances = associateResourceInstances(componentId, relations);
893 if (associateResourceInstances.isRight()) {
894 return Either.right(associateResourceInstances.right().value());
896 return Either.left(associateResourceInstances.left().value().get(0));
899 @SuppressWarnings({ "unchecked" })
900 public Either<List<RequirementCapabilityRelDef>, StorageOperationStatus> associateResourceInstances(String componentId, List<RequirementCapabilityRelDef> relations) {
902 Either<GraphVertex, TitanOperationStatus> containerVEither = titanDao.getVertexById(componentId, JsonParseFlagEnum.ParseAll);
903 if (containerVEither.isRight()) {
904 TitanOperationStatus error = containerVEither.right().value();
905 CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "Failed to fetch container vertex {} error {}", componentId, error);
906 return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(error));
908 GraphVertex containerV = containerVEither.left().value();
909 List<RequirementAndRelationshipPair> relationshipsResult = new ArrayList<RequirementAndRelationshipPair>();
910 Either<Pair<GraphVertex, Map<String, MapListCapabiltyDataDefinition>>, StorageOperationStatus> capResult = fetchContainerCalculatedCapability(containerV, EdgeLabelEnum.CALCULATED_CAPABILITIES);
911 if (capResult.isRight()) {
912 return Either.right(capResult.right().value());
915 Map<String, MapListCapabiltyDataDefinition> calculatedCapabilty = capResult.left().value().getRight();
917 Either<Pair<GraphVertex, Map<String, MapListCapabiltyDataDefinition>>, StorageOperationStatus> capFullResult = fetchContainerCalculatedCapability(containerV, EdgeLabelEnum.FULLFILLED_CAPABILITIES);
918 if (capResult.isRight()) {
919 return Either.right(capResult.right().value());
922 Map<String, MapListCapabiltyDataDefinition> fullFilledCapabilty = capFullResult.left().value().getRight();
924 Either<Pair<GraphVertex, Map<String, MapListRequirementDataDefinition>>, StorageOperationStatus> reqResult = fetchContainerCalculatedRequirement(containerV, EdgeLabelEnum.CALCULATED_REQUIREMENTS);
925 if (reqResult.isRight()) {
926 return Either.right(reqResult.right().value());
928 Map<String, MapListRequirementDataDefinition> calculatedRequirement = reqResult.left().value().getRight();
930 Either<Pair<GraphVertex, Map<String, MapListRequirementDataDefinition>>, StorageOperationStatus> reqFullResult = fetchContainerCalculatedRequirement(containerV, EdgeLabelEnum.FULLFILLED_REQUIREMENTS);
931 if (reqResult.isRight()) {
932 return Either.right(reqResult.right().value());
934 Map<String, MapListRequirementDataDefinition> fullfilledRequirement = reqFullResult.left().value().getRight();
936 Map<String, CompositionDataDefinition> jsonComposition = (Map<String, CompositionDataDefinition>) containerV.getJson();
937 CompositionDataDefinition compositionDataDefinition = jsonComposition.get(JsonConstantKeysEnum.COMPOSITION.getValue());
939 StorageOperationStatus status;
940 List<RequirementCapabilityRelDef> relationsList = new ArrayList<>();
941 for (RequirementCapabilityRelDef relation : relations) {
943 String fromNode = relation.getFromNode();
944 String toNode = relation.getToNode();
945 List<RequirementAndRelationshipPair> relationships = relation.getRelationships();
946 if (relationships == null || relationships.isEmpty()) {
947 BeEcompErrorManager.getInstance().logBeFailedAddingResourceInstanceError("AssociateResourceInstances - missing relationship", fromNode, componentId);
948 CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "No requirement definition sent in order to set the relation between {} to {}", fromNode, toNode);
949 return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(TitanOperationStatus.ILLEGAL_ARGUMENT));
952 for (RequirementAndRelationshipPair immutablePair : relationships) {
953 String requirement = immutablePair.getRequirement();
955 Either<RelationshipInstDataDefinition, StorageOperationStatus> associateRes = connectInstancesInContainer(fromNode, toNode, immutablePair, calculatedCapabilty, calculatedRequirement, fullFilledCapabilty, fullfilledRequirement,
956 compositionDataDefinition, containerV.getUniqueId());
958 if (associateRes.isRight()) {
959 status = associateRes.right().value();
960 BeEcompErrorManager.getInstance().logBeFailedAddingResourceInstanceError("AssociateResourceInstances - missing relationship", fromNode, componentId);
961 CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "Failed to associate resource instance {} to resource instance {}. status is {}", fromNode, toNode, status);
962 return Either.right(status);
965 RelationshipInstDataDefinition relationshipInstData = associateRes.left().value();
966 RelationshipImpl relationshipImplResult = new RelationshipImpl();
967 relationshipImplResult.setType(relationshipInstData.getType());
968 RequirementAndRelationshipPair requirementAndRelationshipPair = new RequirementAndRelationshipPair(requirement, relationshipImplResult);
969 requirementAndRelationshipPair.setCapability(immutablePair.getCapability());
970 requirementAndRelationshipPair.setCapabilityOwnerId(relationshipInstData.getCapabilityOwnerId());
971 requirementAndRelationshipPair.setRequirementOwnerId(relationshipInstData.getRequirementOwnerId());
972 requirementAndRelationshipPair.setCapabilityUid(immutablePair.getCapabilityUid());
973 requirementAndRelationshipPair.setRequirementUid(immutablePair.getRequirementUid());
974 relationshipsResult.add(requirementAndRelationshipPair);
975 CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "update customization UUID for from CI {} and to CI {}", relation.getFromNode(), relation.getToNode());
976 status = updateCustomizationUUID(relation.getFromNode(), compositionDataDefinition);
977 if (status != StorageOperationStatus.OK) {
978 return Either.right(status);
980 status = updateCustomizationUUID(relation.getToNode(), compositionDataDefinition);
981 if (status != StorageOperationStatus.OK) {
982 return Either.right(status);
985 RequirementCapabilityRelDef capabilityRelDef = new RequirementCapabilityRelDef();
986 capabilityRelDef.setFromNode(fromNode);
987 capabilityRelDef.setToNode(toNode);
988 capabilityRelDef.setRelationships(relationshipsResult);
989 relationsList.add(capabilityRelDef);
991 // update metadata of container and composition json
992 status = updateAllAndCalculatedCapReqOnGraph(componentId, containerV, capResult, capFullResult, reqResult, reqFullResult);
993 if (status != StorageOperationStatus.OK) {
994 return Either.right(status);
997 return Either.left(relationsList);
1000 private StorageOperationStatus updateAllAndCalculatedCapReqOnGraph(String componentId, GraphVertex containerV, Either<Pair<GraphVertex, Map<String, MapListCapabiltyDataDefinition>>, StorageOperationStatus> capResult,
1001 Either<Pair<GraphVertex, Map<String, MapListCapabiltyDataDefinition>>, StorageOperationStatus> capFullResult, Either<Pair<GraphVertex, Map<String, MapListRequirementDataDefinition>>, StorageOperationStatus> reqResult,
1002 Either<Pair<GraphVertex, Map<String, MapListRequirementDataDefinition>>, StorageOperationStatus> reqFullResult) {
1003 containerV.setJsonMetadataField(JsonPresentationFields.LAST_UPDATE_DATE, System.currentTimeMillis());
1004 Either<GraphVertex, TitanOperationStatus> updateElement = titanDao.updateVertex(containerV);
1005 if (updateElement.isRight()) {
1006 CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "Failed to update topology template {} with new relations error {}. ", componentId, updateElement.right().value());
1007 return DaoStatusConverter.convertTitanStatusToStorageStatus(updateElement.right().value());
1009 // update cap/req jsons, fullfilled cap/req jsons!!!!!
1010 Either<GraphVertex, TitanOperationStatus> status;
1011 CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "Update calculated capabilty for container {}", containerV.getUniqueId());
1012 status = updateOrCopyOnUpdate(capResult.left().value().getLeft(), containerV, EdgeLabelEnum.CALCULATED_CAPABILITIES);
1013 if (status.isRight()) {
1014 TitanOperationStatus error = status.right().value();
1015 CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "Failed to update calculated capabilty for container {} error {}", containerV.getUniqueId(), error);
1016 return DaoStatusConverter.convertTitanStatusToStorageStatus(error);
1019 CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "Update calculated requirement for container {}", containerV.getUniqueId());
1020 status = updateOrCopyOnUpdate(reqResult.left().value().getLeft(), containerV, EdgeLabelEnum.CALCULATED_REQUIREMENTS);
1021 if (status.isRight()) {
1022 TitanOperationStatus error = status.right().value();
1023 CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "Failed to update calculated requiremnt for container {} error {}", containerV.getUniqueId(), error);
1024 return DaoStatusConverter.convertTitanStatusToStorageStatus(error);
1027 CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "Update fullfilled capabilty for container {}", containerV.getUniqueId());
1028 status = updateOrCopyOnUpdate(capFullResult.left().value().getLeft(), containerV, EdgeLabelEnum.FULLFILLED_CAPABILITIES);
1029 if (status.isRight()) {
1030 TitanOperationStatus error = status.right().value();
1031 CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "Failed to update fullfilled capabilty for container {} error {}", containerV.getUniqueId(), error);
1032 return DaoStatusConverter.convertTitanStatusToStorageStatus(error);
1035 CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "Update fullfilled requirement for container {}", containerV.getUniqueId());
1036 status = updateOrCopyOnUpdate(reqFullResult.left().value().getLeft(), containerV, EdgeLabelEnum.FULLFILLED_REQUIREMENTS);
1037 if (status.isRight()) {
1038 TitanOperationStatus error = status.right().value();
1039 CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "Failed to update fullfilled requirement for container {} error {}", containerV.getUniqueId(), error);
1040 return DaoStatusConverter.convertTitanStatusToStorageStatus(error);
1042 return StorageOperationStatus.OK;
1045 @SuppressWarnings({ "unchecked" })
1046 public Either<RequirementCapabilityRelDef, StorageOperationStatus> dissociateResourceInstances(String componentId, RequirementCapabilityRelDef requirementDef) {
1047 if (requirementDef.getRelationships() == null) {
1048 CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "No relation pair in request [ {} ]", requirementDef);
1049 return Either.right(StorageOperationStatus.BAD_REQUEST);
1052 String fromResInstanceUid = requirementDef.getFromNode();
1053 String toResInstanceUid = requirementDef.getToNode();
1055 Either<GraphVertex, TitanOperationStatus> containerVEither = titanDao.getVertexById(componentId, JsonParseFlagEnum.ParseAll);
1056 if (containerVEither.isRight()) {
1057 TitanOperationStatus error = containerVEither.right().value();
1058 CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "Failed to fetch container vertex {} error {}", componentId, error);
1059 return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(error));
1061 GraphVertex containerV = containerVEither.left().value();
1063 // DE191707 - validatations
1064 Map<String, CompositionDataDefinition> jsonComposition = (Map<String, CompositionDataDefinition>) containerV.getJson();
1065 CompositionDataDefinition compositionDataDefinition = jsonComposition.get(JsonConstantKeysEnum.COMPOSITION.getValue());
1066 Map<String, ComponentInstanceDataDefinition> componentInstances = compositionDataDefinition.getComponentInstances();
1067 ComponentInstanceDataDefinition ciFrom = componentInstances.get(fromResInstanceUid);
1068 if (ciFrom == null) {
1069 CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "FROM instance {} isn't under container {}", fromResInstanceUid, componentId);
1070 return Either.right(StorageOperationStatus.NOT_FOUND);
1073 ComponentInstanceDataDefinition ciTo = componentInstances.get(toResInstanceUid);
1074 if (ciFrom == ciTo) {
1075 CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "TO instance {} isn't under container {}", toResInstanceUid, componentId);
1076 return Either.right(StorageOperationStatus.NOT_FOUND);
1079 Map<String, RelationshipInstDataDefinition> relations = compositionDataDefinition.getRelations();
1081 List<RequirementAndRelationshipPair> relationPairList = requirementDef.getRelationships();
1082 Either<Pair<GraphVertex, Map<String, MapListCapabiltyDataDefinition>>, StorageOperationStatus> capResult = fetchContainerCalculatedCapability(containerV, EdgeLabelEnum.CALCULATED_CAPABILITIES);
1083 if (capResult.isRight()) {
1084 return Either.right(capResult.right().value());
1087 Map<String, MapListCapabiltyDataDefinition> calculatedCapabilty = capResult.left().value().getRight();
1089 Either<Pair<GraphVertex, Map<String, MapListCapabiltyDataDefinition>>, StorageOperationStatus> capFullResult = fetchContainerCalculatedCapability(containerV, EdgeLabelEnum.FULLFILLED_CAPABILITIES);
1090 if (capResult.isRight()) {
1091 return Either.right(capResult.right().value());
1094 Map<String, MapListCapabiltyDataDefinition> fullFilledCapabilty = capFullResult.left().value().getRight();
1096 Either<Pair<GraphVertex, Map<String, MapListRequirementDataDefinition>>, StorageOperationStatus> reqResult = fetchContainerCalculatedRequirement(containerV, EdgeLabelEnum.CALCULATED_REQUIREMENTS);
1097 if (reqResult.isRight()) {
1098 return Either.right(reqResult.right().value());
1100 Map<String, MapListRequirementDataDefinition> calculatedRequirement = reqResult.left().value().getRight();
1102 Either<Pair<GraphVertex, Map<String, MapListRequirementDataDefinition>>, StorageOperationStatus> reqFullResult = fetchContainerCalculatedRequirement(containerV, EdgeLabelEnum.FULLFILLED_REQUIREMENTS);
1103 if (reqResult.isRight()) {
1104 return Either.right(reqResult.right().value());
1106 Map<String, MapListRequirementDataDefinition> fullfilledRequirement = reqFullResult.left().value().getRight();
1108 for (RequirementAndRelationshipPair relationPair : relationPairList) {
1109 Iterator<Entry<String, RelationshipInstDataDefinition>> iterator = relations.entrySet().iterator();
1110 boolean isDeleted = false;
1111 while (iterator.hasNext()) {
1112 Entry<String, RelationshipInstDataDefinition> entryInJson = iterator.next();
1113 RelationshipInstDataDefinition relationInJson = entryInJson.getValue();
1114 if (relationInJson.getFromId().equals(fromResInstanceUid) && relationInJson.getToId().equals(toResInstanceUid)) {
1115 if (relationPair.equalsTo(relationInJson)) {
1116 CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "Remove relation from {} to {} capabilty {} capOwnerId {} reqOwnerId {} ", toResInstanceUid, componentId, relationInJson.getType(),
1117 relationInJson.getCapabilityOwnerId(), relationInJson.getRequirementOwnerId());
1120 // update calculated cap/req
1121 StorageOperationStatus status = updateCalculatedCapabiltyAfterDeleteRelation(calculatedCapabilty, fullFilledCapabilty, toResInstanceUid, relationInJson);
1122 if (status != StorageOperationStatus.OK) {
1123 return Either.right(status);
1125 status = updateCalculatedRequirementsAfterDeleteRelation(calculatedRequirement, fullfilledRequirement, fromResInstanceUid, relationInJson);
1126 if (status != StorageOperationStatus.OK) {
1127 return Either.right(status);
1133 if (isDeleted == false) {
1134 CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "No relation to delete from {} to {} capabilty {} capOwnerId {} reqOwnerId {} ", toResInstanceUid, componentId, relationPair.getCapability(),
1135 relationPair.getCapabilityOwnerId(), relationPair.getRequirementOwnerId());
1136 return Either.right(StorageOperationStatus.NOT_FOUND);
1139 StorageOperationStatus status = updateCustomizationUUID(fromResInstanceUid, compositionDataDefinition);
1140 if (status != StorageOperationStatus.OK) {
1141 return Either.right(status);
1143 status = updateCustomizationUUID(toResInstanceUid, compositionDataDefinition);
1144 if (status != StorageOperationStatus.OK) {
1145 return Either.right(status);
1149 // update metadata of container and composition json
1150 status = updateAllAndCalculatedCapReqOnGraph(componentId, containerV, capResult, capFullResult, reqResult, reqFullResult);
1151 if (status != StorageOperationStatus.OK) {
1152 return Either.right(status);
1155 return Either.left(requirementDef);
1158 private StorageOperationStatus updateCalculatedRequirementsAfterDeleteRelation(Map<String, MapListRequirementDataDefinition> calculatedRequirement, Map<String, MapListRequirementDataDefinition> fullFilledRequirement, String fromResInstanceUid,
1159 RelationshipInstDataDefinition relation) {
1160 StorageOperationStatus status;
1161 MapListRequirementDataDefinition reqByInstance = calculatedRequirement.get(fromResInstanceUid);
1162 if (reqByInstance == null) {
1163 // move from fullfilled
1164 status = moveFromFullFilledRequirement(calculatedRequirement, fullFilledRequirement, fromResInstanceUid, relation);
1166 ListRequirementDataDefinition reqByType = reqByInstance.findByKey(relation.getType());
1167 if (reqByType == null) {
1168 // move from fullfilled
1169 status = moveFromFullFilledRequirement(calculatedRequirement, fullFilledRequirement, fromResInstanceUid, relation);
1171 Optional<RequirementDataDefinition> requirementOptional = reqByType.getListToscaDataDefinition().stream()
1172 .filter(cap -> cap.getOwnerId().equals(relation.getRequirementOwnerId()) && cap.getName().equals(relation.getRequirement()) && cap.getUniqueId().equals(relation.getRequirementId())).findFirst();
1174 if (requirementOptional.isPresent()) {
1176 RequirementDataDefinition requirement = requirementOptional.get();
1177 String leftOccurrences = requirement.getLeftOccurrences();
1178 if (leftOccurrences != null && !leftOccurrences.equals(RequirementDataDefinition.MAX_OCCURRENCES)) {
1179 Integer leftIntValue = Integer.parseInt(leftOccurrences);
1181 requirement.setLeftOccurrences(String.valueOf(leftIntValue));
1183 status = StorageOperationStatus.OK;
1185 // move from fullfilled
1186 status = moveFromFullFilledRequirement(calculatedRequirement, fullFilledRequirement, fromResInstanceUid, relation);
1193 private StorageOperationStatus updateCalculatedCapabiltyAfterDeleteRelation(Map<String, MapListCapabiltyDataDefinition> calculatedCapabilty, Map<String, MapListCapabiltyDataDefinition> fullFilledCapabilty, String toResInstanceUid,
1194 RelationshipInstDataDefinition relation) {
1195 StorageOperationStatus status;
1196 MapListCapabiltyDataDefinition capByInstance = calculatedCapabilty.get(toResInstanceUid);
1197 if (capByInstance == null) {
1198 // move from fullfilled
1199 status = moveFromFullFilledCapabilty(calculatedCapabilty, fullFilledCapabilty, toResInstanceUid, relation);
1201 ListCapabilityDataDefinition capByType = capByInstance.findByKey(relation.getType());
1202 if (capByType == null) {
1203 // move from fullfilled
1204 status = moveFromFullFilledCapabilty(calculatedCapabilty, fullFilledCapabilty, toResInstanceUid, relation);
1206 Optional<CapabilityDataDefinition> capabiltyOptional = capByType.getListToscaDataDefinition().stream()
1207 .filter(cap -> cap.getOwnerId().equals(relation.getCapabilityOwnerId()) && cap.getUniqueId().equals(relation.getCapabiltyId())).findFirst();
1209 if (capabiltyOptional.isPresent()) {
1211 CapabilityDataDefinition capability = capabiltyOptional.get();
1212 String leftOccurrences = capability.getLeftOccurrences();
1213 if (leftOccurrences != null && !leftOccurrences.equals(CapabilityDataDefinition.MAX_OCCURRENCES)) {
1214 Integer leftIntValue = Integer.parseInt(leftOccurrences);
1216 capability.setLeftOccurrences(String.valueOf(leftIntValue));
1218 status = StorageOperationStatus.OK;
1220 // move from fullfilled
1221 status = moveFromFullFilledCapabilty(calculatedCapabilty, fullFilledCapabilty, toResInstanceUid, relation);
1228 private StorageOperationStatus moveFromFullFilledCapabilty(Map<String, MapListCapabiltyDataDefinition> calculatedCapabilty, Map<String, MapListCapabiltyDataDefinition> fullFilledCapabilty, String toResInstanceUid,
1229 RelationshipInstDataDefinition relation) {
1230 MapListCapabiltyDataDefinition capByInstance = fullFilledCapabilty.get(toResInstanceUid);
1231 if (capByInstance == null) {
1232 CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "No capabilty in fullfilled list for instance {} ", toResInstanceUid);
1233 return StorageOperationStatus.GENERAL_ERROR;
1235 ListCapabilityDataDefinition capByType = capByInstance.findByKey(relation.getType());
1236 if (capByType == null) {
1237 CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "No capabilty type {} in fullfilled list for instance {} ", relation.getType(), toResInstanceUid);
1238 return StorageOperationStatus.GENERAL_ERROR;
1240 Iterator<CapabilityDataDefinition> iterator = capByType.getListToscaDataDefinition().iterator();
1241 boolean found = false;
1242 while (iterator.hasNext()) {
1243 CapabilityDataDefinition cap = iterator.next();
1244 if (cap.getOwnerId().equals(relation.getCapabilityOwnerId()) && cap.getName().equals(relation.getRequirement()) && cap.getUniqueId().equals(relation.getCapabiltyId())) {
1247 // return to calculated list
1248 String leftOccurrences = cap.getLeftOccurrences();
1249 Integer leftIntValue = Integer.parseInt(leftOccurrences);
1251 cap.setLeftOccurrences(String.valueOf(leftIntValue));
1253 MapListCapabiltyDataDefinition mapListCapaDataDef = calculatedCapabilty.get(toResInstanceUid);
1254 if (mapListCapaDataDef == null) {
1255 mapListCapaDataDef = new MapListCapabiltyDataDefinition();
1257 ListCapabilityDataDefinition findByKey = mapListCapaDataDef.findByKey(relation.getType());
1258 if (findByKey == null) {
1259 findByKey = new ListCapabilityDataDefinition();
1260 mapListCapaDataDef.put(relation.getType(), findByKey);
1266 if (found == false) {
1267 CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "No capabilty type {} with ownerId {} in fullfilled list for instance {} ", relation.getType(), relation.getCapabilityOwnerId(), toResInstanceUid);
1268 return StorageOperationStatus.GENERAL_ERROR;
1270 return StorageOperationStatus.OK;
1273 private StorageOperationStatus moveFromFullFilledRequirement(Map<String, MapListRequirementDataDefinition> calculatedRequirement, Map<String, MapListRequirementDataDefinition> fullFilledRequirement, String fromResInstanceUid,
1274 RelationshipInstDataDefinition relation) {
1275 MapListRequirementDataDefinition reqByInstance = fullFilledRequirement.get(fromResInstanceUid);
1276 if (reqByInstance == null) {
1277 CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "No requirement in fullfilled list for instance {} ", fromResInstanceUid);
1278 return StorageOperationStatus.GENERAL_ERROR;
1280 ListRequirementDataDefinition reqByType = reqByInstance.findByKey(relation.getType());
1281 if (reqByType == null) {
1282 CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "No requirement type {} in fullfilled list for instance {} ", relation.getType(), fromResInstanceUid);
1283 return StorageOperationStatus.GENERAL_ERROR;
1285 Iterator<RequirementDataDefinition> iterator = reqByType.getListToscaDataDefinition().iterator();
1286 boolean found = false;
1287 while (iterator.hasNext()) {
1288 RequirementDataDefinition req = iterator.next();
1289 if (req.getOwnerId().equals(relation.getRequirementOwnerId()) && req.getName().equals(relation.getRequirement()) && req.getUniqueId().equals(relation.getRequirementId())) {
1292 // return to calculated list
1293 String leftOccurrences = req.getLeftOccurrences();
1294 Integer leftIntValue = Integer.parseInt(leftOccurrences);
1296 req.setLeftOccurrences(String.valueOf(leftIntValue));
1298 MapListRequirementDataDefinition mapListReqDataDef = calculatedRequirement.get(fromResInstanceUid);
1299 if (mapListReqDataDef == null) {
1300 mapListReqDataDef = new MapListRequirementDataDefinition();
1302 ListRequirementDataDefinition findByKey = mapListReqDataDef.findByKey(relation.getType());
1303 if (findByKey == null) {
1304 findByKey = new ListRequirementDataDefinition();
1305 mapListReqDataDef.put(relation.getType(), findByKey);
1311 if (found == false) {
1312 CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "No requirement type {} with ownerId {} in fullfilled list for instance {} ", relation.getType(), relation.getCapabilityOwnerId(), fromResInstanceUid);
1313 return StorageOperationStatus.GENERAL_ERROR;
1315 return StorageOperationStatus.OK;
1319 public StorageOperationStatus updateCustomizationUUID(String componentInstanceId, CompositionDataDefinition compositionDataDefinition) {
1320 ComponentInstanceDataDefinition componentInstance = compositionDataDefinition.getComponentInstances().get(componentInstanceId);
1322 if (componentInstance == null) {
1323 CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "Failed to fetch component instance by id {} from map of instances ", componentInstanceId);
1324 return StorageOperationStatus.NOT_FOUND;
1326 UUID uuid = UUID.randomUUID();
1327 componentInstance.setCustomizationUUID(uuid.toString());
1329 return StorageOperationStatus.OK;
1332 public Either<RelationshipInstDataDefinition, StorageOperationStatus> connectInstancesInContainer(String fromResInstanceUid, String toResInstanceUid, RequirementAndRelationshipPair relationPair,
1333 Map<String, MapListCapabiltyDataDefinition> calculatedCapabilty, Map<String, MapListRequirementDataDefinition> calculatedRequirement, Map<String, MapListCapabiltyDataDefinition> fullfilledCapabilty,
1334 Map<String, MapListRequirementDataDefinition> fullfilledRequirement, CompositionDataDefinition compositionDataDefinition, String containerId) {
1335 String requirement = relationPair.getRequirement();
1336 Map<String, ComponentInstanceDataDefinition> componentInstances = compositionDataDefinition.getComponentInstances();
1338 CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "Going to associate resource instance {} to resource instance {} under component {}. Requirement is {}.", fromResInstanceUid, toResInstanceUid, containerId, requirement);
1340 ComponentInstanceDataDefinition fromResourceInstData = componentInstances.get(fromResInstanceUid);
1341 if (fromResourceInstData == null) {
1342 CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "Failed to find from resource instance {}.", fromResInstanceUid);
1343 return Either.right(StorageOperationStatus.NOT_FOUND);
1345 ComponentInstanceDataDefinition toResourceInstData = componentInstances.get(toResInstanceUid);
1346 if (toResourceInstData == null) {
1347 CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "Failed to find to resource instance {}.", toResInstanceUid);
1348 return Either.right(StorageOperationStatus.NOT_FOUND);
1351 Either<RelationshipInstDataDefinition, StorageOperationStatus> reqVsCap = connectRequirementVsCapability(fromResourceInstData, toResourceInstData, relationPair, calculatedCapabilty, calculatedRequirement, fullfilledCapabilty,
1352 fullfilledRequirement, containerId);
1353 if (reqVsCap.isRight()) {
1354 StorageOperationStatus status = reqVsCap.right().value();
1355 CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "Failed to connect requirement {} between resource instance {} to resource instance {}. status is {}", requirement, fromResInstanceUid, toResInstanceUid, status);
1356 return Either.right(status);
1358 RelationshipInstDataDefinition relation = reqVsCap.left().value();
1360 // add to json new relations
1361 compositionDataDefinition.addRelation(relation.getUniqueId(), relation);
1363 return Either.left(relation);
1366 private Either<Pair<GraphVertex, Map<String, MapListCapabiltyDataDefinition>>, StorageOperationStatus> fetchContainerCalculatedCapability(GraphVertex containerV, EdgeLabelEnum capLabel) {
1368 Either<Pair<GraphVertex, Map<String, MapListCapabiltyDataDefinition>>, TitanOperationStatus> calculatedCapabiltyEither = getDataAndVertexFromGraph(containerV, capLabel);
1369 if (calculatedCapabiltyEither.isRight()) {
1370 TitanOperationStatus error = calculatedCapabiltyEither.right().value();
1371 CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "Failed to fetch calculated capabilties for container {}.", containerV.getUniqueId(), error);
1372 return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(error));
1374 Pair<GraphVertex, Map<String, MapListCapabiltyDataDefinition>> calculatedCapabilty = calculatedCapabiltyEither.left().value();
1375 return Either.left(calculatedCapabilty);
1378 private Either<Pair<GraphVertex, Map<String, MapListRequirementDataDefinition>>, StorageOperationStatus> fetchContainerCalculatedRequirement(GraphVertex containerV, EdgeLabelEnum reqLabel) {
1379 Either<Pair<GraphVertex, Map<String, MapListRequirementDataDefinition>>, TitanOperationStatus> calculatedRequirementEither = getDataAndVertexFromGraph(containerV, reqLabel);
1380 if (calculatedRequirementEither.isRight()) {
1381 TitanOperationStatus error = calculatedRequirementEither.right().value();
1382 CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "Failed to fetch calculated requirements for container {}.", containerV.getUniqueId(), error);
1383 return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(error));
1385 Pair<GraphVertex, Map<String, MapListRequirementDataDefinition>> calculatedRequirement = calculatedRequirementEither.left().value();
1386 return Either.left(calculatedRequirement);
1389 private Either<RelationshipInstDataDefinition, StorageOperationStatus> connectRequirementVsCapability(ComponentInstanceDataDefinition fromResInstance, ComponentInstanceDataDefinition toResInstance, RequirementAndRelationshipPair relationPair,
1390 Map<String, MapListCapabiltyDataDefinition> calculatedCapabilty, Map<String, MapListRequirementDataDefinition> calculatedRequirement, Map<String, MapListCapabiltyDataDefinition> fullfilledCapabilty,
1391 Map<String, MapListRequirementDataDefinition> fullfilledRequirement, String containerId) {
1392 String type = relationPair.getRelationship().getType();
1395 String toInstId = toResInstance.getUniqueId();
1396 MapListCapabiltyDataDefinition mapListCapabiltyDataDefinition = calculatedCapabilty.get(toInstId);
1398 if (mapListCapabiltyDataDefinition == null) {
1399 CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "Failed to fetch calculated capabilities for instance {} in container {}.", toInstId, containerId);
1400 return Either.right(StorageOperationStatus.MATCH_NOT_FOUND);
1402 ListCapabilityDataDefinition listCapabilityDataDefinition = mapListCapabiltyDataDefinition.getMapToscaDataDefinition().get(type);
1403 if (listCapabilityDataDefinition == null) {
1404 CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "Failed to fetch calculated capabilities for type {} for instance {} in container {}.", type, toInstId, containerId);
1405 return Either.right(StorageOperationStatus.MATCH_NOT_FOUND);
1407 CapabilityDataDefinition capabiltyForRelation = null;
1408 Iterator<CapabilityDataDefinition> iteratorCap = listCapabilityDataDefinition.getListToscaDataDefinition().iterator();
1409 while (iteratorCap.hasNext()) {
1410 CapabilityDataDefinition cap = iteratorCap.next();
1411 if (cap.getUniqueId().equals(relationPair.getCapabilityUid()) && cap.getOwnerId().equals(relationPair.getCapabilityOwnerId())) {
1412 capabiltyForRelation = cap;
1413 String leftOccurrences = cap.getLeftOccurrences();
1414 if (leftOccurrences != null && !leftOccurrences.equals(CapabilityDataDefinition.MAX_OCCURRENCES)) {
1415 Integer leftIntValue = Integer.parseInt(leftOccurrences);
1416 if (leftIntValue > 0) {
1418 capabiltyForRelation.setLeftOccurrences(String.valueOf(leftIntValue));
1419 if (leftIntValue == 0) {
1420 // remove from calculated
1421 iteratorCap.remove();
1422 // move to fullfilled
1423 MapListCapabiltyDataDefinition mapListCapabiltyFullFilledInst = fullfilledCapabilty.get(toInstId);
1424 if (mapListCapabiltyFullFilledInst == null) {
1425 mapListCapabiltyFullFilledInst = new MapListCapabiltyDataDefinition();
1426 fullfilledCapabilty.put(toInstId, mapListCapabiltyFullFilledInst);
1429 ListCapabilityDataDefinition listCapabilityFull = mapListCapabiltyFullFilledInst.findByKey(type);
1430 if (listCapabilityFull == null) {
1431 listCapabilityFull = new ListCapabilityDataDefinition();
1432 mapListCapabiltyFullFilledInst.put(type, listCapabilityFull);
1434 listCapabilityFull.add(capabiltyForRelation);
1438 CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "No left occurrences capabilty {} to {} in container {}.", capabiltyForRelation.getType(), toInstId, containerId);
1439 return Either.right(StorageOperationStatus.MATCH_NOT_FOUND);
1444 if (capabiltyForRelation == null) {
1445 CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "Failed to fetch capabilty for type {} for instance {} in container {}.", type, toInstId, containerId);
1446 return Either.right(StorageOperationStatus.MATCH_NOT_FOUND);
1450 String fromInstId = fromResInstance.getUniqueId();
1451 MapListRequirementDataDefinition mapListRequirementDataDefinition = calculatedRequirement.get(fromInstId);
1452 if (mapListRequirementDataDefinition == null) {
1453 CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "Failed to fetch calculated requirements for instance {} in container {}.", fromInstId, containerId);
1454 return Either.right(StorageOperationStatus.MATCH_NOT_FOUND);
1456 ListRequirementDataDefinition listRequirementDataDefinition = mapListRequirementDataDefinition.getMapToscaDataDefinition().get(type);
1457 if (listRequirementDataDefinition == null) {
1458 CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "Failed to fetch calculated requirements for type {} for instance {} in container {}.", type, fromInstId, containerId);
1459 return Either.right(StorageOperationStatus.MATCH_NOT_FOUND);
1462 RequirementDataDefinition requirementForRelation = null;
1463 Iterator<RequirementDataDefinition> iteratorReq = listRequirementDataDefinition.getListToscaDataDefinition().iterator();
1464 while (iteratorReq.hasNext()) {
1465 RequirementDataDefinition req = iteratorReq.next();
1466 if (req.getUniqueId().equals(relationPair.getRequirementUid()) && req.getOwnerId().equals(relationPair.getRequirementOwnerId())) {
1467 requirementForRelation = req;
1469 String leftOccurrences = req.getLeftOccurrences();
1470 if (leftOccurrences != null && !leftOccurrences.equals(RequirementDataDefinition.MAX_OCCURRENCES)) {
1471 Integer leftIntValue = Integer.parseInt(leftOccurrences);
1472 if (leftIntValue > 0) {
1474 req.setLeftOccurrences(String.valueOf(leftIntValue));
1475 if (leftIntValue == 0) {
1476 // remove from calculated
1477 iteratorReq.remove();
1478 // move to fullfilled
1479 MapListRequirementDataDefinition mapListRequirementFullFilledInst = fullfilledRequirement.get(fromInstId);
1480 if (mapListRequirementFullFilledInst == null) {
1481 mapListRequirementFullFilledInst = new MapListRequirementDataDefinition();
1482 fullfilledRequirement.put(fromInstId, mapListRequirementFullFilledInst);
1485 ListRequirementDataDefinition listRequirementFull = mapListRequirementFullFilledInst.findByKey(type);
1486 if (listRequirementFull == null) {
1487 listRequirementFull = new ListRequirementDataDefinition();
1488 mapListRequirementFullFilledInst.put(type, listRequirementFull);
1490 listRequirementFull.add(requirementForRelation);
1494 CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "No left occurrences requirement {} from {} to {} in container {}.", requirementForRelation.getCapability(), fromInstId, toInstId, containerId);
1495 return Either.right(StorageOperationStatus.MATCH_NOT_FOUND);
1500 if (!capabiltyForRelation.getType().equals(requirementForRelation.getCapability())) {
1501 CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "No math for capabilty from type {} and requirement {} from {} to {} in container {}.", capabiltyForRelation.getType(), requirementForRelation.getCapability(), fromInstId, toInstId,
1503 return Either.right(StorageOperationStatus.MATCH_NOT_FOUND);
1506 RelationshipInstDataDefinition relationshipTypeData = buildRelationshipInstData(fromInstId, toInstId, relationPair);
1508 relationshipTypeData.setType(requirementForRelation.getRelationship());
1510 return Either.left(relationshipTypeData);
1513 private RelationshipInstDataDefinition buildRelationshipInstData(String fromResInstanceUid, String toInstId, RequirementAndRelationshipPair relationPair) {
1515 RelationshipInstDataDefinition relationshipInstData = new RelationshipInstDataDefinition();
1516 relationshipInstData.setUniqueId(UniqueIdBuilder.buildRelationsipInstInstanceUid(fromResInstanceUid, toInstId));
1518 relationshipInstData.setType(relationPair.getRelationship().getType());
1519 Long creationDate = System.currentTimeMillis();
1520 relationshipInstData.setCreationTime(creationDate);
1521 relationshipInstData.setModificationTime(creationDate);
1522 relationshipInstData.setCapabilityOwnerId(relationPair.getCapabilityOwnerId());
1523 relationshipInstData.setRequirementOwnerId(relationPair.getRequirementOwnerId());
1524 relationshipInstData.setCapabiltyId(relationPair.getCapabilityUid());
1525 relationshipInstData.setRequirementId(relationPair.getRequirementUid());
1526 relationshipInstData.setFromId(fromResInstanceUid);
1527 relationshipInstData.setToId(toInstId);
1528 relationshipInstData.setRequirement(relationPair.getRequirement());
1529 relationshipInstData.setCapability(relationPair.getCapability());
1531 return relationshipInstData;
1534 public StorageOperationStatus associateComponentInstancesToComponent(Component containerComponent, Map<ComponentInstance, Resource> resourcesInstancesMap, GraphVertex containerVertex, boolean allowDeleted) {
1536 StorageOperationStatus result = null;
1537 String containerId = containerComponent.getUniqueId();
1538 Map<String, ComponentInstanceDataDefinition> instancesJsonData = null;
1539 Either<GraphVertex, TitanOperationStatus> updateElement = null;
1540 if (!validateInstanceNames(resourcesInstancesMap)) {
1541 result = StorageOperationStatus.INCONSISTENCY;
1543 if (result == null) {
1544 if (!validateInstanceNames(resourcesInstancesMap)) {
1545 result = StorageOperationStatus.INCONSISTENCY;
1548 if (result == null && !allowDeleted) {
1549 if (!validateDeletedResources(resourcesInstancesMap)) {
1550 result = StorageOperationStatus.INCONSISTENCY;
1553 if (result == null) {
1554 instancesJsonData = convertToComponentInstanceDataDefinition(resourcesInstancesMap, containerId);
1556 if (result == null && MapUtils.isNotEmpty(instancesJsonData)) {
1557 containerVertex.setJsonMetadataField(JsonPresentationFields.LAST_UPDATE_DATE, System.currentTimeMillis());
1558 Map<String, CompositionDataDefinition> compositions = new HashMap<>();
1559 CompositionDataDefinition composition = new CompositionDataDefinition();
1560 composition.setComponentInstances(instancesJsonData);
1561 compositions.put(JsonConstantKeysEnum.COMPOSITION.getValue(), composition);
1562 containerVertex.setJson(compositions);
1563 updateElement = titanDao.updateVertex(containerVertex);
1564 if (updateElement.isRight()) {
1565 CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "Failed to update topology template {} with new component instances. ", containerComponent.getName());
1566 result = DaoStatusConverter.convertTitanStatusToStorageStatus(updateElement.right().value());
1569 if (result == null) {
1570 result = StorageOperationStatus.OK;
1575 private Map<String, ComponentInstanceDataDefinition> convertToComponentInstanceDataDefinition(Map<ComponentInstance, Resource> resourcesInstancesMap, String containerId) {
1577 Map<String, ComponentInstanceDataDefinition> instances = new HashMap<>();
1578 for (Entry<ComponentInstance, Resource> entry : resourcesInstancesMap.entrySet()) {
1579 ComponentInstanceDataDefinition instance = buildComponentInstanceDataDefinition(entry.getKey(), containerId, null, true, ModelConverter.convertToToscaElement(entry.getValue()));
1580 instances.put(instance.getUniqueId(), instance);
1585 private boolean validateDeletedResources(Map<ComponentInstance, Resource> resourcesInstancesMap) {
1586 boolean result = true;
1587 for (Resource resource : resourcesInstancesMap.values()) {
1588 if (resource.getIsDeleted() != null && resource.getIsDeleted()) {
1589 CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "Component {} is already deleted. Cannot add component instance. ", resource.getName());
1597 private boolean validateInstanceNames(Map<ComponentInstance, Resource> resourcesInstancesMap) {
1598 boolean result = true;
1599 Set<String> names = new HashSet<>();
1600 for (ComponentInstance instance : resourcesInstancesMap.keySet()) {
1601 if (StringUtils.isEmpty(instance.getName())) {
1602 CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "Component instance {} name is empty. Cannot add component instance. ", instance.getUniqueId());
1605 } else if (names.contains(instance.getName())) {
1606 CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "Component instance with the name {} already exsists. Cannot add component instance. ", instance.getName());
1610 names.add(instance.getName());
1616 public StorageOperationStatus addDeploymentArtifactsToInstance(String toscaElementId, String instanceId, Map<String, ArtifactDataDefinition> instDeplArtifacts) {
1617 Either<GraphVertex, TitanOperationStatus> metadataVertex = titanDao.getVertexById(toscaElementId, JsonParseFlagEnum.NoParse);
1618 if (metadataVertex.isRight()) {
1619 TitanOperationStatus status = metadataVertex.right().value();
1620 if (status == TitanOperationStatus.NOT_FOUND) {
1621 status = TitanOperationStatus.INVALID_ID;
1623 return DaoStatusConverter.convertTitanStatusToStorageStatus(status);
1625 MapArtifactDataDefinition instArtifacts = new MapArtifactDataDefinition(instDeplArtifacts);
1626 return addToscaDataDeepElementsBlockToToscaElement(metadataVertex.left().value(), EdgeLabelEnum.INST_DEPLOYMENT_ARTIFACTS, VertexTypeEnum.INST_DEPLOYMENT_ARTIFACTS, instArtifacts, instanceId);
1630 @SuppressWarnings({ "unchecked" })
1631 public StorageOperationStatus generateCustomizationUUIDOnInstance(String componentId, String instanceId) {
1632 Either<GraphVertex, TitanOperationStatus> metadataVertex = titanDao.getVertexById(componentId, JsonParseFlagEnum.ParseAll);
1633 if (metadataVertex.isRight()) {
1634 TitanOperationStatus status = metadataVertex.right().value();
1635 if (status == TitanOperationStatus.NOT_FOUND) {
1636 status = TitanOperationStatus.INVALID_ID;
1638 return DaoStatusConverter.convertTitanStatusToStorageStatus(status);
1640 GraphVertex metaVertex = metadataVertex.left().value();
1641 Map<String, CompositionDataDefinition> json = (Map<String, CompositionDataDefinition>) metaVertex.getJson();
1642 CompositionDataDefinition compositionDataDefinition = json.get(JsonConstantKeysEnum.COMPOSITION.getValue());
1643 StorageOperationStatus status = updateCustomizationUUID(instanceId, compositionDataDefinition);
1644 if (status != StorageOperationStatus.OK) {
1645 logger.debug("Failed to update customization UUID for instance {} in component {} error {}", instanceId, componentId, status);
1648 Either<GraphVertex, TitanOperationStatus> updateVertex = titanDao.updateVertex(metaVertex);
1649 if (updateVertex.isRight()) {
1650 logger.debug("Failed to update vertex of component {} error {}", componentId, updateVertex.right().value());
1651 return DaoStatusConverter.convertTitanStatusToStorageStatus(updateVertex.right().value());
1653 return StorageOperationStatus.OK;
1656 public StorageOperationStatus generateCustomizationUUIDOnInstanceGroup(String componentId, String instanceId, List<String> groupInstances) {
1657 if (groupInstances != null) {
1658 Either<Map<String, MapGroupsDataDefinition>, TitanOperationStatus> dataFromGraph = getDataFromGraph(componentId, EdgeLabelEnum.INST_GROUPS);
1659 if (dataFromGraph.isRight()) {
1660 return DaoStatusConverter.convertTitanStatusToStorageStatus(dataFromGraph.right().value());
1662 MapGroupsDataDefinition grInstPerInstance = dataFromGraph.left().value().get(instanceId);
1663 if (grInstPerInstance == null) {
1664 logger.debug("No instance groups for instance {} in component {}", instanceId, componentId);
1665 return StorageOperationStatus.NOT_FOUND;
1667 for (String instGroupForUpdate : groupInstances) {
1668 GroupInstanceDataDefinition groupInst = grInstPerInstance.findByKey(instGroupForUpdate);
1669 if (groupInst == null) {
1670 logger.debug("No group instance {} in group list for instance {} in component {}", instGroupForUpdate, instanceId, componentId);
1673 UUID uuid = UUID.randomUUID();
1674 groupInst.setCustomizationUUID(uuid.toString());
1678 return StorageOperationStatus.OK;
1681 public StorageOperationStatus addGroupInstancesToComponentInstance(Component containerComponent, ComponentInstance componentInstance, List<GroupInstance> groupInstances) {
1683 return addToscaDataDeepElementsBlockToToscaElement(containerComponent.getUniqueId(), EdgeLabelEnum.INST_GROUPS, VertexTypeEnum.INST_GROUPS,
1684 new MapDataDefinition<>(groupInstances.stream().collect(Collectors.toMap(gi -> gi.getName(), gi -> gi))), componentInstance.getUniqueId());
1687 public StorageOperationStatus addDeploymentArtifactsToComponentInstance(Component containerComponent, ComponentInstance componentInstance, Map<String, ArtifactDefinition> deploymentArtifacts) {
1689 return addToscaDataDeepElementsBlockToToscaElement(containerComponent.getUniqueId(), EdgeLabelEnum.INST_DEPLOYMENT_ARTIFACTS, VertexTypeEnum.INST_DEPLOYMENT_ARTIFACTS, new MapDataDefinition<>(deploymentArtifacts),
1690 componentInstance.getUniqueId());
1693 public StorageOperationStatus updateComponentInstanceProperty(Component containerComponent, String componentInstanceId, ComponentInstanceProperty property) {
1695 List<String> pathKeys = new ArrayList<>();
1696 pathKeys.add(componentInstanceId);
1697 return updateToscaDataDeepElementOfToscaElement(containerComponent.getUniqueId(), EdgeLabelEnum.INST_PROPERTIES, VertexTypeEnum.INST_PROPERTIES, property, pathKeys, JsonPresentationFields.NAME);
1701 public StorageOperationStatus addComponentInstanceProperty(Component containerComponent, String componentInstanceId, ComponentInstanceProperty property) {
1702 List<String> pathKeys = new ArrayList<>();
1703 pathKeys.add(componentInstanceId);
1704 return addToscaDataDeepElementToToscaElement(containerComponent.getUniqueId(), EdgeLabelEnum.INST_PROPERTIES, VertexTypeEnum.INST_PROPERTIES, property, pathKeys, JsonPresentationFields.NAME);
1707 public StorageOperationStatus updateComponentInstanceInput(Component containerComponent, String componentInstanceId, ComponentInstanceInput property) {
1709 List<String> pathKeys = new ArrayList<>();
1710 pathKeys.add(componentInstanceId);
1711 return updateToscaDataDeepElementOfToscaElement(containerComponent.getUniqueId(), EdgeLabelEnum.INST_INPUTS, VertexTypeEnum.INST_INPUTS, property, pathKeys, JsonPresentationFields.NAME);
1714 public StorageOperationStatus addComponentInstanceInput(Component containerComponent, String componentInstanceId, ComponentInstanceInput property) {
1715 List<String> pathKeys = new ArrayList<>();
1716 pathKeys.add(componentInstanceId);
1717 return addToscaDataDeepElementToToscaElement(containerComponent.getUniqueId(), EdgeLabelEnum.INST_INPUTS, VertexTypeEnum.INST_INPUTS, property, pathKeys, JsonPresentationFields.NAME);