2 * ============LICENSE_START=======================================================
4 * ================================================================================
5 * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
6 * ================================================================================
7 * Licensed under the Apache License, Version 2.0 (the "License");
8 * you may not use this file except in compliance with the License.
9 * You may obtain a copy of the License at
11 * http://www.apache.org/licenses/LICENSE-2.0
13 * Unless required by applicable law or agreed to in writing, software
14 * distributed under the License is distributed on an "AS IS" BASIS,
15 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 * See the License for the specific language governing permissions and
17 * limitations under the License.
18 * ============LICENSE_END=========================================================
20 package org.openecomp.sdc.be.components.impl;
22 import static org.openecomp.sdc.be.components.attribute.GetOutputUtils.isGetOutputValueForOutput;
23 import static org.openecomp.sdc.be.components.property.GetInputUtils.isGetInputValueForInput;
24 import static org.openecomp.sdc.be.components.utils.PropertiesUtils.getPropertyCapabilityOfChildInstance;
26 import com.google.common.collect.Sets;
27 import fj.data.Either;
28 import java.util.ArrayList;
29 import java.util.Arrays;
30 import java.util.Collection;
31 import java.util.Collections;
32 import java.util.HashMap;
33 import java.util.Iterator;
34 import java.util.List;
36 import java.util.Map.Entry;
37 import java.util.Objects;
38 import java.util.Optional;
40 import java.util.UUID;
41 import java.util.stream.Collectors;
42 import org.apache.commons.collections.CollectionUtils;
43 import org.apache.commons.collections.MapUtils;
44 import org.apache.commons.lang3.StringUtils;
45 import org.apache.commons.lang3.tuple.ImmutablePair;
46 import org.onap.sdc.tosca.datatypes.model.PropertyType;
47 import org.openecomp.sdc.be.components.impl.exceptions.BusinessLogicException;
48 import org.openecomp.sdc.be.components.impl.exceptions.ByActionStatusComponentException;
49 import org.openecomp.sdc.be.components.impl.exceptions.ByResponseFormatComponentException;
50 import org.openecomp.sdc.be.components.impl.exceptions.ComponentException;
51 import org.openecomp.sdc.be.components.impl.exceptions.ToscaGetFunctionExceptionSupplier;
52 import org.openecomp.sdc.be.components.impl.instance.ComponentInstanceChangeOperationOrchestrator;
53 import org.openecomp.sdc.be.components.impl.utils.DirectivesUtil;
54 import org.openecomp.sdc.be.components.merge.instance.ComponentInstanceMergeDataBusinessLogic;
55 import org.openecomp.sdc.be.components.merge.instance.DataForMergeHolder;
56 import org.openecomp.sdc.be.components.utils.PropertiesUtils;
57 import org.openecomp.sdc.be.components.validation.ComponentValidations;
58 import org.openecomp.sdc.be.config.BeEcompErrorManager;
59 import org.openecomp.sdc.be.config.BeEcompErrorManager.ErrorSeverity;
60 import org.openecomp.sdc.be.config.ConfigurationManager;
61 import org.openecomp.sdc.be.dao.api.ActionStatus;
62 import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus;
63 import org.openecomp.sdc.be.dao.jsongraph.types.JsonParseFlagEnum;
64 import org.openecomp.sdc.be.dao.neo4j.GraphPropertiesDictionary;
65 import org.openecomp.sdc.be.datatypes.elements.CINodeFilterDataDefinition;
66 import org.openecomp.sdc.be.datatypes.elements.CapabilityDataDefinition;
67 import org.openecomp.sdc.be.datatypes.elements.ForwardingPathDataDefinition;
68 import org.openecomp.sdc.be.datatypes.elements.GetInputValueDataDefinition;
69 import org.openecomp.sdc.be.datatypes.elements.GetOutputValueDataDefinition;
70 import org.openecomp.sdc.be.datatypes.elements.GetPolicyValueDataDefinition;
71 import org.openecomp.sdc.be.datatypes.elements.PropertyDataDefinition;
72 import org.openecomp.sdc.be.datatypes.elements.RequirementDataDefinition;
73 import org.openecomp.sdc.be.datatypes.elements.SchemaDefinition;
74 import org.openecomp.sdc.be.datatypes.elements.ToscaGetFunctionDataDefinition;
75 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
76 import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
77 import org.openecomp.sdc.be.datatypes.enums.OriginTypeEnum;
78 import org.openecomp.sdc.be.datatypes.enums.PropertySource;
79 import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum;
80 import org.openecomp.sdc.be.datatypes.tosca.ToscaGetFunctionType;
81 import org.openecomp.sdc.be.exception.BusinessException;
82 import org.openecomp.sdc.be.impl.ComponentsUtils;
83 import org.openecomp.sdc.be.impl.ForwardingPathUtils;
84 import org.openecomp.sdc.be.impl.ServiceFilterUtils;
85 import org.openecomp.sdc.be.info.CreateAndAssotiateInfo;
86 import org.openecomp.sdc.be.model.ArtifactDefinition;
87 import org.openecomp.sdc.be.model.AttributeDefinition;
88 import org.openecomp.sdc.be.model.CapabilityDefinition;
89 import org.openecomp.sdc.be.model.Component;
90 import org.openecomp.sdc.be.model.ComponentInstance;
91 import org.openecomp.sdc.be.model.ComponentInstanceAttribute;
92 import org.openecomp.sdc.be.model.ComponentInstanceInput;
93 import org.openecomp.sdc.be.model.ComponentInstanceOutput;
94 import org.openecomp.sdc.be.model.ComponentInstancePropInput;
95 import org.openecomp.sdc.be.model.ComponentInstanceProperty;
96 import org.openecomp.sdc.be.model.ComponentParametersView;
97 import org.openecomp.sdc.be.model.DataTypeDefinition;
98 import org.openecomp.sdc.be.model.GroupDefinition;
99 import org.openecomp.sdc.be.model.InputDefinition;
100 import org.openecomp.sdc.be.model.InterfaceDefinition;
101 import org.openecomp.sdc.be.model.LifecycleStateEnum;
102 import org.openecomp.sdc.be.model.OutputDefinition;
103 import org.openecomp.sdc.be.model.PolicyDefinition;
104 import org.openecomp.sdc.be.model.PropertyDefinition;
105 import org.openecomp.sdc.be.model.RelationshipInfo;
106 import org.openecomp.sdc.be.model.RequirementCapabilityRelDef;
107 import org.openecomp.sdc.be.model.RequirementDefinition;
108 import org.openecomp.sdc.be.model.Resource;
109 import org.openecomp.sdc.be.model.Service;
110 import org.openecomp.sdc.be.model.ToscaPropertyData;
111 import org.openecomp.sdc.be.model.User;
112 import org.openecomp.sdc.be.model.jsonjanusgraph.config.ContainerInstanceTypesData;
113 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.ArtifactsOperations;
114 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.ForwardingPathOperation;
115 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.InterfaceOperation;
116 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.NodeFilterOperation;
117 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.NodeTemplateOperation;
118 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.ToscaOperationFacade;
119 import org.openecomp.sdc.be.model.jsonjanusgraph.utils.ModelConverter;
120 import org.openecomp.sdc.be.model.operations.StorageException;
121 import org.openecomp.sdc.be.model.operations.api.IElementOperation;
122 import org.openecomp.sdc.be.model.operations.api.IGroupInstanceOperation;
123 import org.openecomp.sdc.be.model.operations.api.IGroupOperation;
124 import org.openecomp.sdc.be.model.operations.api.IGroupTypeOperation;
125 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
126 import org.openecomp.sdc.be.model.operations.impl.ComponentInstanceOperation;
127 import org.openecomp.sdc.be.model.operations.impl.DaoStatusConverter;
128 import org.openecomp.sdc.be.model.operations.impl.InterfaceLifecycleOperation;
129 import org.openecomp.sdc.be.model.operations.impl.UniqueIdBuilder;
130 import org.openecomp.sdc.be.model.operations.utils.ComponentValidationUtils;
131 import org.openecomp.sdc.be.model.tosca.ToscaPropertyType;
132 import org.openecomp.sdc.be.model.validation.ToscaFunctionValidator;
133 import org.openecomp.sdc.be.resources.data.ComponentInstanceData;
134 import org.openecomp.sdc.be.user.Role;
135 import org.openecomp.sdc.common.api.ArtifactGroupTypeEnum;
136 import org.openecomp.sdc.common.api.ArtifactTypeEnum;
137 import org.openecomp.sdc.common.api.Constants;
138 import org.openecomp.sdc.common.datastructure.Wrapper;
139 import org.openecomp.sdc.common.jsongraph.util.CommonUtility;
140 import org.openecomp.sdc.common.jsongraph.util.CommonUtility.LogLevelEnum;
141 import org.openecomp.sdc.common.log.elements.ErrorLogOptionalData;
142 import org.openecomp.sdc.common.log.enums.EcompLoggerErrorCode;
143 import org.openecomp.sdc.common.log.wrappers.Logger;
144 import org.openecomp.sdc.common.util.ValidationUtils;
145 import org.openecomp.sdc.exception.ResponseFormat;
146 import org.springframework.beans.factory.annotation.Autowired;
148 @org.springframework.stereotype.Component
149 public class ComponentInstanceBusinessLogic extends BaseBusinessLogic {
151 private static final Logger log = Logger.getLogger(ComponentInstanceBusinessLogic.class);
152 private static final String VF_MODULE = "org.openecomp.groups.VfModule";
153 private static final String TRY_TO_CREATE_ENTRY_ON_GRAPH = "Try to create entry on graph";
154 private static final String CLOUD_SPECIFIC_FIXED_KEY_WORD = "cloudtech";
155 private static final String[][] CLOUD_SPECIFIC_KEY_WORDS = {{"k8s", "azure", "aws"}, /* cloud specific technology */
156 {"charts", "day0", "configtemplate"} /*cloud specific sub type*/};
157 private static final String FAILED_TO_CREATE_ENTRY_ON_GRAPH_FOR_COMPONENT_INSTANCE = "Failed to create entry on graph for component instance {}";
158 private static final String ENTITY_ON_GRAPH_IS_CREATED = "Entity on graph is created.";
159 private static final String INVALID_COMPONENT_TYPE = "invalid component type";
160 private static final String FAILED_TO_RETRIEVE_COMPONENT_COMPONENT_ID = "Failed to retrieve component, component id {}";
161 private static final String FAILED_TO_LOCK_SERVICE = "Failed to lock service {}";
162 private static final String CREATE_OR_UPDATE_PROPERTY_VALUE = "CreateOrUpdatePropertyValue";
163 private static final String FAILED_TO_COPY_COMP_INSTANCE_TO_CANVAS = "Failed to copy the component instance to the canvas";
164 private static final String COPY_COMPONENT_INSTANCE_OK = "Copy component instance OK";
165 private static final String CANNOT_ATTACH_RESOURCE_INSTANCES_TO_CONTAINER_RESOURCE_OF_TYPE = "Cannot attach resource instances to container resource of type {}";
166 private static final String FAILED_TO_UPDATE_COMPONENT_INSTANCE_CAPABILITY = "Failed to update component instance capability on instance {} in "
168 private static final String SERVICE_PROXY = "serviceProxy";
169 private static final String ASSOCIATE_RI_TO_RI = "associateRIToRI";
170 private static final String COMPONENT_ARCHIVED = "Component is archived. Component id: {}";
171 private static final String RESTRICTED_OPERATION_ON_SERVIVE = "Restricted operation for user: {} on service {}";
172 private static final String FAILED_TO_LOCK_COMPONENT = "Failed to lock component {}";
173 private static final String RESTRICTED_OPERATION_ON_COMPONENT = "Restricted operation for user: {} on component {}";
174 private static final String RESOURCE_INSTANCE = "resource instance";
175 private static final String SERVICE = "service";
177 private final ComponentInstanceOperation componentInstanceOperation;
178 private final ArtifactsBusinessLogic artifactBusinessLogic;
179 private final ComponentInstanceMergeDataBusinessLogic compInstMergeDataBL;
180 private final ComponentInstanceChangeOperationOrchestrator onChangeInstanceOperationOrchestrator;
181 private final ForwardingPathOperation forwardingPathOperation;
182 private final NodeFilterOperation nodeFilterOperation;
184 private CompositionBusinessLogic compositionBusinessLogic;
186 private ContainerInstanceTypesData containerInstanceTypesData;
187 private final ToscaFunctionValidator toscaFunctionValidator;
190 public ComponentInstanceBusinessLogic(IElementOperation elementDao, IGroupOperation groupOperation,
191 IGroupInstanceOperation groupInstanceOperation, IGroupTypeOperation groupTypeOperation,
192 InterfaceOperation interfaceOperation, InterfaceLifecycleOperation interfaceLifecycleTypeOperation,
193 ComponentInstanceOperation componentInstanceOperation, ArtifactsBusinessLogic artifactBusinessLogic,
194 ComponentInstanceMergeDataBusinessLogic compInstMergeDataBL,
195 ComponentInstanceChangeOperationOrchestrator onChangeInstanceOperationOrchestrator,
196 ForwardingPathOperation forwardingPathOperation, NodeFilterOperation nodeFilterOperation,
197 ArtifactsOperations artifactToscaOperation, final ToscaFunctionValidator toscaFunctionValidator) {
198 super(elementDao, groupOperation, groupInstanceOperation, groupTypeOperation, interfaceOperation, interfaceLifecycleTypeOperation,
199 artifactToscaOperation);
200 this.componentInstanceOperation = componentInstanceOperation;
201 this.artifactBusinessLogic = artifactBusinessLogic;
202 this.compInstMergeDataBL = compInstMergeDataBL;
203 this.onChangeInstanceOperationOrchestrator = onChangeInstanceOperationOrchestrator;
204 this.forwardingPathOperation = forwardingPathOperation;
205 this.nodeFilterOperation = nodeFilterOperation;
206 this.toscaFunctionValidator = toscaFunctionValidator;
209 public ComponentInstance createComponentInstance(String containerComponentParam, String containerComponentId, String userId,
210 ComponentInstance resourceInstance) {
211 return createComponentInstance(containerComponentParam, containerComponentId, userId, resourceInstance, true);
214 public List<ComponentInstanceProperty> getComponentInstancePropertiesByInputId(org.openecomp.sdc.be.model.Component component, String inputId) {
215 List<ComponentInstanceProperty> resList = new ArrayList<>();
216 Map<String, List<ComponentInstanceProperty>> ciPropertiesMap = component.getComponentInstancesProperties();
217 if (ciPropertiesMap != null && !ciPropertiesMap.isEmpty()) {
218 ciPropertiesMap.forEach((s, ciPropList) -> {
220 Optional<ComponentInstance> ciOp = component.getComponentInstances().stream().filter(ci -> ci.getUniqueId().equals(s)).findAny();
221 if (ciOp.isPresent()) {
222 ciName = ciOp.get().getName();
224 if (ciPropList != null && !ciPropList.isEmpty()) {
225 for (ComponentInstanceProperty prop : ciPropList) {
226 List<GetInputValueDataDefinition> inputsValues = prop.getGetInputValues();
227 addCompInstanceProperty(s, ciName, prop, inputsValues, inputId, resList);
235 public List<ComponentInstanceAttribute> getComponentInstanceAttributesByOutputId(final org.openecomp.sdc.be.model.Component component,
236 final String outputId) {
237 final List<ComponentInstanceAttribute> resList = new ArrayList<>();
238 final Map<String, List<ComponentInstanceAttribute>> componentInstancesAttributes = component.getComponentInstancesAttributes();
239 if (org.apache.commons.collections4.MapUtils.isNotEmpty(componentInstancesAttributes)) {
240 componentInstancesAttributes.forEach((s, componentInstanceAttributeList) -> {
242 final Optional<ComponentInstance> ciOp = component.getComponentInstances().stream().filter(ci -> ci.getUniqueId().equals(s))
244 if (ciOp.isPresent()) {
245 ciName = ciOp.get().getName();
247 if (componentInstanceAttributeList != null && !componentInstanceAttributeList.isEmpty()) {
248 for (final ComponentInstanceAttribute compInstanceAttribute : componentInstanceAttributeList) {
249 List<GetOutputValueDataDefinition> outputValues = compInstanceAttribute.getGetOutputValues();
250 addCompInstanceAttribute(s, ciName, compInstanceAttribute, outputValues, outputId, resList);
258 private void addCompInstanceProperty(String s, String ciName, ComponentInstanceProperty prop, List<GetInputValueDataDefinition> inputsValues,
259 String inputId, List<ComponentInstanceProperty> resList) {
260 if (inputsValues != null && !inputsValues.isEmpty()) {
261 for (GetInputValueDataDefinition inputData : inputsValues) {
262 if (isGetInputValueForInput(inputData, inputId)) {
263 prop.setComponentInstanceId(s);
264 prop.setComponentInstanceName(ciName);
272 private void addCompInstanceAttribute(final String s, final String ciName, final ComponentInstanceAttribute attribute,
273 final List<GetOutputValueDataDefinition> outputsValues, final String outputId,
274 final List<ComponentInstanceAttribute> resList) {
275 if (outputsValues != null && !outputsValues.isEmpty()) {
276 for (final GetOutputValueDataDefinition outputData : outputsValues) {
277 if (isGetOutputValueForOutput(outputData, outputId)) {
278 attribute.setComponentInstanceId(s);
279 attribute.setComponentInstanceName(ciName);
280 resList.add(attribute);
287 public Optional<ComponentInstanceProperty> getComponentInstancePropertyByPolicyId(Component component, PolicyDefinition policy) {
288 Optional<ComponentInstanceProperty> propertyCandidate = getComponentInstancePropertyByPolicy(component, policy);
289 if (propertyCandidate.isPresent()) {
290 ComponentInstanceProperty componentInstanceProperty = propertyCandidate.get();
291 Optional<GetPolicyValueDataDefinition> getPolicyCandidate = getGetPolicyValueDataDefinition(policy, componentInstanceProperty);
293 .ifPresent(getPolicyValue -> updateComponentInstancePropertyAfterUndeclaration(componentInstanceProperty, getPolicyValue, policy));
294 return Optional.of(componentInstanceProperty);
296 return Optional.empty();
299 private void updateComponentInstancePropertyAfterUndeclaration(ComponentInstanceProperty componentInstanceProperty,
300 GetPolicyValueDataDefinition getPolicyValue, PolicyDefinition policyDefinition) {
301 componentInstanceProperty.setValue(getPolicyValue.getOrigPropertyValue());
302 List<GetPolicyValueDataDefinition> getPolicyValues = componentInstanceProperty.getGetPolicyValues();
303 if (CollectionUtils.isNotEmpty(getPolicyValues)) {
304 getPolicyValues.remove(getPolicyValue);
305 componentInstanceProperty.setGetPolicyValues(getPolicyValues);
306 policyDefinition.setGetPolicyValues(getPolicyValues);
310 private Optional<GetPolicyValueDataDefinition> getGetPolicyValueDataDefinition(PolicyDefinition policy,
311 ComponentInstanceProperty componentInstanceProperty) {
312 List<GetPolicyValueDataDefinition> getPolicyValues = policy.getGetPolicyValues();
313 return getPolicyValues.stream().filter(getPolicyValue -> getPolicyValue.getPropertyName().equals(componentInstanceProperty.getName()))
317 private Optional<ComponentInstanceProperty> getComponentInstancePropertyByPolicy(Component component, PolicyDefinition policy) {
318 Map<String, List<ComponentInstanceProperty>> componentInstancesProperties = component.getComponentInstancesProperties();
319 if (MapUtils.isEmpty(componentInstancesProperties)) {
320 return Optional.empty();
322 String instanceUniqueId = policy.getInstanceUniqueId();
323 List<ComponentInstanceProperty> componentInstanceProperties =
324 componentInstancesProperties.containsKey(instanceUniqueId) ? componentInstancesProperties.get(instanceUniqueId) : new ArrayList<>();
325 return componentInstanceProperties.stream().filter(property -> property.getName().equals(policy.getName())).findAny();
328 public List<ComponentInstanceInput> getComponentInstanceInputsByInputId(org.openecomp.sdc.be.model.Component component, String inputId) {
329 List<ComponentInstanceInput> resList = new ArrayList<>();
330 Map<String, List<ComponentInstanceInput>> ciInputsMap = component.getComponentInstancesInputs();
331 if (ciInputsMap != null && !ciInputsMap.isEmpty()) {
332 ciInputsMap.forEach((s, ciPropList) -> {
334 Optional<ComponentInstance> ciOp = component.getComponentInstances().stream().filter(ci -> ci.getUniqueId().equals(s)).findAny();
335 if (ciOp.isPresent()) {
336 ciName = ciOp.get().getName();
338 if (ciPropList != null && !ciPropList.isEmpty()) {
339 for (ComponentInstanceInput prop : ciPropList) {
340 List<GetInputValueDataDefinition> inputsValues = prop.getGetInputValues();
341 addCompInstanceInput(s, ciName, prop, inputsValues, inputId, resList);
349 public List<ComponentInstanceOutput> getComponentInstanceOutputsByOutputId(final org.openecomp.sdc.be.model.Component component,
350 final String outputId) {
351 final List<ComponentInstanceOutput> resList = new ArrayList<>();
352 final Map<String, List<ComponentInstanceOutput>> ciInputsMap = component.getComponentInstancesOutputs();
353 if (ciInputsMap != null && !ciInputsMap.isEmpty()) {
354 ciInputsMap.forEach((s, ciPropList) -> {
356 final Optional<ComponentInstance> ciOp = component.getComponentInstances().stream().filter(ci -> ci.getUniqueId().equals(s))
358 if (ciOp.isPresent()) {
359 ciName = ciOp.get().getName();
361 if (ciPropList != null && !ciPropList.isEmpty()) {
362 for (final ComponentInstanceOutput prop : ciPropList) {
363 final List<GetOutputValueDataDefinition> outputValues = prop.getGetOutputValues();
364 addCompInstanceOutput(s, ciName, prop, outputValues, outputId, resList);
372 private void addCompInstanceInput(String s, String ciName, ComponentInstanceInput prop, List<GetInputValueDataDefinition> inputsValues,
373 String inputId, List<ComponentInstanceInput> resList) {
374 if (inputsValues != null && !inputsValues.isEmpty()) {
375 for (GetInputValueDataDefinition inputData : inputsValues) {
376 if (isGetInputValueForInput(inputData, inputId)) {
377 prop.setComponentInstanceId(s);
378 prop.setComponentInstanceName(ciName);
386 private void addCompInstanceOutput(final String s, final String ciName, final ComponentInstanceOutput prop,
387 final List<GetOutputValueDataDefinition> outputsValues, final String outputId,
388 final List<ComponentInstanceOutput> resList) {
389 if (outputsValues != null && !outputsValues.isEmpty()) {
390 for (final GetOutputValueDataDefinition outputData : outputsValues) {
391 if (isGetOutputValueForOutput(outputData, outputId)) {
392 prop.setComponentInstanceId(s);
393 prop.setComponentInstanceName(ciName);
401 public ComponentInstance createComponentInstance(final String containerComponentParam, final String containerComponentId, final String userId,
402 final ComponentInstance resourceInstance, final boolean needLock) {
403 final User user = validateUserExists(userId);
404 validateUserNotEmpty(user, "Create component instance");
405 validateJsonBody(resourceInstance, ComponentInstance.class);
406 final ComponentTypeEnum containerComponentType = validateComponentType(containerComponentParam);
407 final org.openecomp.sdc.be.model.Component containerComponent = validateComponentExists(containerComponentId, containerComponentType, null);
408 if (ModelConverter.isAtomicComponent(containerComponent)) {
409 if (log.isDebugEnabled()) {
410 log.debug(CANNOT_ATTACH_RESOURCE_INSTANCES_TO_CONTAINER_RESOURCE_OF_TYPE, containerComponent.assetType());
412 throw new ByActionStatusComponentException(ActionStatus.RESOURCE_CANNOT_CONTAIN_RESOURCE_INSTANCES, containerComponent.assetType());
414 validateCanWorkOnComponent(containerComponent, userId);
415 Component origComponent = null;
416 if (resourceInstance != null && containerComponentType != null) {
417 final OriginTypeEnum originType = resourceInstance.getOriginType();
418 validateInstanceName(resourceInstance);
419 if (originType == OriginTypeEnum.ServiceProxy) {
420 origComponent = getOrigComponentForServiceProxy(containerComponent, resourceInstance);
421 } else if (originType == OriginTypeEnum.ServiceSubstitution) {
422 origComponent = getOrigComponentForServiceSubstitution(resourceInstance);
424 origComponent = getAndValidateOriginComponentOfComponentInstance(containerComponent, resourceInstance);
425 validateOriginAndResourceInstanceTypes(containerComponent, origComponent, originType);
427 validateResourceInstanceState(containerComponent, origComponent);
428 overrideFields(origComponent, resourceInstance);
429 compositionBusinessLogic.validateAndSetDefaultCoordinates(resourceInstance);
431 return createComponent(needLock, containerComponent, origComponent, resourceInstance, user);
434 private Component getOrigComponentForServiceProxy(org.openecomp.sdc.be.model.Component containerComponent, ComponentInstance resourceInstance) {
435 Either<Component, StorageOperationStatus> serviceProxyOrigin = toscaOperationFacade.getLatestByName(SERVICE_PROXY, null);
436 if (isServiceProxyOrigin(serviceProxyOrigin)) {
437 throw new ByActionStatusComponentException(componentsUtils.convertFromStorageResponse(serviceProxyOrigin.right().value()));
439 Component origComponent = serviceProxyOrigin.left().value();
440 StorageOperationStatus fillProxyRes = fillInstanceData(resourceInstance, origComponent);
441 if (isFillProxyRes(fillProxyRes)) {
442 throw new ByActionStatusComponentException(componentsUtils.convertFromStorageResponse(fillProxyRes));
444 validateOriginAndResourceInstanceTypes(containerComponent, origComponent, OriginTypeEnum.ServiceProxy);
445 return origComponent;
448 private Component getOrigComponentForServiceSubstitution(ComponentInstance resourceInstance) {
449 final Either<Component, StorageOperationStatus> getServiceResult = toscaOperationFacade
450 .getToscaFullElement(resourceInstance.getComponentUid());
451 if (getServiceResult.isRight()) {
452 throw new ByActionStatusComponentException(componentsUtils.convertFromStorageResponse(getServiceResult.right().value()));
454 final Component service = getServiceResult.left().value();
455 final Either<Component, StorageOperationStatus> getServiceDerivedFromTypeResult = toscaOperationFacade
456 .getLatestByToscaResourceName(service.getDerivedFromGenericType(), service.getModel());
457 if (getServiceDerivedFromTypeResult.isRight()) {
458 throw new ByActionStatusComponentException(componentsUtils.convertFromStorageResponse(getServiceResult.right().value()));
460 Component origComponent = getServiceDerivedFromTypeResult.left().value();
461 final StorageOperationStatus fillProxyRes = fillInstanceData(resourceInstance, origComponent);
462 if (isFillProxyRes(fillProxyRes)) {
463 throw new ByActionStatusComponentException(componentsUtils.convertFromStorageResponse(fillProxyRes));
465 return origComponent;
468 private ComponentInstance createComponent(boolean needLock, Component containerComponent, Component origComponent,
469 ComponentInstance resourceInstance, User user) {
470 boolean failed = false;
472 lockIfNeed(needLock, containerComponent);
473 log.debug(TRY_TO_CREATE_ENTRY_ON_GRAPH);
474 return createComponentInstanceOnGraph(containerComponent, origComponent, resourceInstance, user);
475 } catch (ComponentException e) {
480 unlockComponent(failed, containerComponent);
486 * Try using either to make a judgment
488 * @param containerComponentParam
489 * @param containerComponentId
491 * @param resourceInstance
494 public Either<ComponentInstance, ResponseFormat> createRealComponentInstance(String containerComponentParam, String containerComponentId,
495 String userId, ComponentInstance resourceInstance) {
496 log.debug("enter createRealComponentInstance");
497 return createRealComponentInstance(containerComponentParam, containerComponentId, userId, resourceInstance, true);
501 * Try using either to make a judgment
504 * @param containerComponentParam
505 * @param containerComponentId
507 * @param resourceInstance
510 public Either<ComponentInstance, ResponseFormat> createRealComponentInstance(String containerComponentParam, String containerComponentId,
511 String userId, ComponentInstance resourceInstance,
513 log.debug("enter createRealComponentInstance");
514 Component origComponent = null;
516 org.openecomp.sdc.be.model.Component containerComponent = null;
517 ComponentTypeEnum containerComponentType;
519 user = validateUserExists(userId);
520 validateUserNotEmpty(user, "Create component instance");
521 validateJsonBody(resourceInstance, ComponentInstance.class);
522 containerComponentType = validateComponentType(containerComponentParam);
523 containerComponent = validateComponentExists(containerComponentId, containerComponentType, null);
524 log.debug("enter createRealComponentInstance,validate user json success");
525 if (ModelConverter.isAtomicComponent(containerComponent)) {
526 log.debug(CANNOT_ATTACH_RESOURCE_INSTANCES_TO_CONTAINER_RESOURCE_OF_TYPE, containerComponent.assetType());
527 throw new ByActionStatusComponentException(ActionStatus.RESOURCE_CANNOT_CONTAIN_RESOURCE_INSTANCES, containerComponent.assetType());
529 validateCanWorkOnComponent(containerComponent, userId);
530 log.debug("enter createRealComponentInstance,validateCanWorkOnComponent success");
531 if (resourceInstance != null && containerComponentType != null) {
532 log.debug("enter createRealComponentInstance,start create ComponentInstance");
533 OriginTypeEnum originType = resourceInstance.getOriginType();
534 validateInstanceName(resourceInstance);
535 if (originType == OriginTypeEnum.ServiceProxy) {
536 log.debug("enter createRealComponentInstance,originType equals ServiceProxy");
537 Either<Component, StorageOperationStatus> serviceProxyOrigin = toscaOperationFacade.getLatestByName(SERVICE_PROXY, null);
538 if (isServiceProxyOrigin(serviceProxyOrigin)) {
539 throw new ByActionStatusComponentException(componentsUtils.convertFromStorageResponse(serviceProxyOrigin.right().value()));
541 origComponent = serviceProxyOrigin.left().value();
542 StorageOperationStatus fillProxyRes = fillInstanceData(resourceInstance, origComponent);
543 if (isFillProxyRes(fillProxyRes)) {
544 throw new ByActionStatusComponentException(componentsUtils.convertFromStorageResponse(fillProxyRes));
547 log.debug("enter createRealComponentInstance,originType is not ServiceProxy");
548 origComponent = getAndValidateOriginComponentOfComponentInstance(containerComponent, resourceInstance);
550 validateOriginAndResourceInstanceTypes(containerComponent, origComponent, originType);
551 validateResourceInstanceState(containerComponent, origComponent);
552 overrideFields(origComponent, resourceInstance);
553 compositionBusinessLogic.validateAndSetDefaultCoordinates(resourceInstance);
554 log.debug("enter createRealComponentInstance,final validate success");
556 return createRealComponent(needLock, containerComponent, origComponent, resourceInstance, user);
557 } catch (ComponentException e) {
558 log.debug("create Real Component Instance failed");
563 private Either<ComponentInstance, ResponseFormat> createRealComponent(boolean needLock, Component containerComponent, Component origComponent,
564 ComponentInstance resourceInstance, User user) {
565 log.debug("enter createRealComponent");
566 boolean failed = false;
568 lockIfNeed(needLock, containerComponent);
569 log.debug(TRY_TO_CREATE_ENTRY_ON_GRAPH);
570 return createRealComponentInstanceOnGraph(containerComponent, origComponent, resourceInstance, user);
571 } catch (ComponentException e) {
576 unlockComponent(failed, containerComponent);
581 private Either<ComponentInstance, ResponseFormat> createRealComponentInstanceOnGraph(org.openecomp.sdc.be.model.Component containerComponent,
582 Component originComponent,
583 ComponentInstance componentInstance, User user) {
584 log.debug("enter createRealComponentInstanceOnGraph");
585 Either<ImmutablePair<Component, String>, StorageOperationStatus> result = toscaOperationFacade
586 .addComponentInstanceToTopologyTemplate(containerComponent, originComponent, componentInstance, false, user);
587 if (result.isRight()) {
588 log.debug("enter createRealComponentInstanceOnGraph,result is right");
589 ActionStatus status = componentsUtils.convertFromStorageResponse(result.right().value());
590 log.debug(FAILED_TO_CREATE_ENTRY_ON_GRAPH_FOR_COMPONENT_INSTANCE, componentInstance.getName());
591 return Either.right(componentsUtils.getResponseFormat(status));
593 log.debug(ENTITY_ON_GRAPH_IS_CREATED);
594 log.debug("enter createRealComponentInstanceOnGraph,Entity on graph is created.");
595 Component updatedComponent = result.left().value().getLeft();
596 Map<String, String> existingEnvVersions = new HashMap<>();
597 // TODO existingEnvVersions ??
598 addComponentInstanceArtifacts(updatedComponent, componentInstance, originComponent, user, existingEnvVersions);
599 Optional<ComponentInstance> updatedInstanceOptional = updatedComponent.getComponentInstances().stream()
600 .filter(ci -> ci.getUniqueId().equals(result.left().value().getRight())).findFirst();
601 if (!updatedInstanceOptional.isPresent()) {
602 log.debug("Failed to fetch new added component instance {} from component {}", componentInstance.getName(), containerComponent.getName());
603 throw new ByActionStatusComponentException(ActionStatus.COMPONENT_INSTANCE_NOT_FOUND_ON_CONTAINER, componentInstance.getName());
605 log.debug("enter createRealComponentInstanceOnGraph,and final success");
606 return Either.left(updatedInstanceOptional.get());
609 private void overrideFields(Component origComponent, ComponentInstance resourceInstance) {
610 resourceInstance.setComponentVersion(origComponent.getVersion());
611 resourceInstance.setIcon(origComponent.getIcon());
614 private void validateInstanceName(ComponentInstance resourceInstance) {
615 String resourceInstanceName = resourceInstance.getName();
616 if (StringUtils.isEmpty(resourceInstanceName)) {
617 log.debug("ComponentInstance name is empty");
618 throw new ByActionStatusComponentException(ActionStatus.INVALID_COMPONENT_NAME, resourceInstance.getName());
620 if (!ValidationUtils.validateComponentNameLength(resourceInstanceName)) {
621 log.debug("ComponentInstance name exceeds max length {} ", ValidationUtils.COMPONENT_NAME_MAX_LENGTH);
622 throw new ByActionStatusComponentException(ActionStatus.INVALID_COMPONENT_NAME, resourceInstance.getName());
624 if (!ValidationUtils.validateComponentNamePattern(resourceInstanceName)) {
625 log.debug("ComponentInstance name {} has invalid format", resourceInstanceName);
626 throw new ByActionStatusComponentException(ActionStatus.INVALID_COMPONENT_NAME, resourceInstance.getName());
630 private void validateResourceInstanceState(Component containerComponent, Component origComponent) {
631 if (origComponent.getLifecycleState() == LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT) {
632 throw new ByActionStatusComponentException(ActionStatus.CONTAINER_CANNOT_CONTAIN_INSTANCE,
633 containerComponent.getComponentType().getValue(), origComponent.getLifecycleState().toString());
637 private void validateOriginAndResourceInstanceTypes(final Component containerComponent, final Component origComponent,
638 final OriginTypeEnum originType) {
639 final ResourceTypeEnum resourceType = getResourceTypeEnumFromOriginComponent(origComponent);
640 validateOriginType(originType, resourceType);
641 validateOriginComponentIsValidForContainer(containerComponent, resourceType);
644 private void validateOriginComponentIsValidForContainer(Component containerComponent, ResourceTypeEnum resourceType) {
645 switch (containerComponent.getComponentType()) {
647 if (!containerInstanceTypesData.isAllowedForServiceComponent(resourceType, containerComponent.getModel())) {
648 throw new ByActionStatusComponentException(ActionStatus.CONTAINER_CANNOT_CONTAIN_INSTANCE,
649 containerComponent.getComponentType().toString(), resourceType.name());
653 final ResourceTypeEnum componentResourceType = ((Resource) containerComponent).getResourceType();
654 if (!containerInstanceTypesData.isAllowedForResourceComponent(componentResourceType, resourceType)) {
655 throw new ByActionStatusComponentException(ActionStatus.CONTAINER_CANNOT_CONTAIN_INSTANCE,
656 containerComponent.getComponentType().toString(), resourceType.name());
660 throw new ByActionStatusComponentException(ActionStatus.INVALID_CONTENT);
664 private void validateOriginType(OriginTypeEnum originType, ResourceTypeEnum resourceType) {
665 ResourceTypeEnum convertedOriginType;
667 convertedOriginType = ResourceTypeEnum.getTypeIgnoreCase(originType.name());
668 } catch (Exception e) {
669 throw new ByActionStatusComponentException(ActionStatus.INVALID_CONTENT);
671 if (resourceType != convertedOriginType) {
672 throw new ByActionStatusComponentException(ActionStatus.INVALID_CONTENT);
676 private ResourceTypeEnum getResourceTypeEnumFromOriginComponent(final Component origComponent) {
677 switch (origComponent.getComponentType()) {
679 return ResourceTypeEnum.ServiceProxy;
681 return ((Resource) origComponent).getResourceType();
683 throw new ByActionStatusComponentException(ActionStatus.INVALID_CONTENT);
687 private void lockIfNeed(boolean needLock, Component containerComponent) {
689 lockComponent(containerComponent, "createComponentInstance");
693 private boolean isServiceProxyOrigin(Either<Component, StorageOperationStatus> serviceProxyOrigin) {
694 if (serviceProxyOrigin.isRight()) {
695 log.debug("Failed to fetch normative service proxy resource by tosca name, error {}", serviceProxyOrigin.right().value());
701 private StorageOperationStatus fillInstanceData(ComponentInstance resourceInstance, Component origComponent) {
702 final ComponentParametersView filter = new ComponentParametersView(true);
703 filter.setIgnoreCapabilities(false);
704 filter.setIgnoreCapabiltyProperties(false);
705 filter.setIgnoreComponentInstances(false);
706 filter.setIgnoreRequirements(false);
707 filter.setIgnoreInterfaces(false);
708 filter.setIgnoreProperties(false);
709 filter.setIgnoreAttributes(false);
710 filter.setIgnoreInputs(false);
711 Either<Component, StorageOperationStatus> serviceRes = toscaOperationFacade.getToscaElement(resourceInstance.getComponentUid(), filter);
712 if (serviceRes.isRight()) {
713 return serviceRes.right().value();
715 final Component service = serviceRes.left().value();
716 final Map<String, List<CapabilityDefinition>> capabilities = service.getCapabilities();
717 resourceInstance.setCapabilities(capabilities);
718 final Map<String, List<RequirementDefinition>> req = service.getRequirements();
719 resourceInstance.setRequirements(req);
720 final Map<String, InterfaceDefinition> serviceInterfaces = service.getInterfaces();
721 if (MapUtils.isNotEmpty(serviceInterfaces)) {
722 serviceInterfaces.forEach(resourceInstance::addInterface);
724 resourceInstance.setProperties(PropertiesUtils.getProperties(service));
725 resourceInstance.setAttributes(service.getAttributes());
726 final List<InputDefinition> serviceInputs = service.getInputs();
727 resourceInstance.setInputs(serviceInputs);
728 resourceInstance.setSourceModelInvariant(service.getInvariantUUID());
729 resourceInstance.setSourceModelName(service.getName());
730 resourceInstance.setSourceModelUuid(service.getUUID());
731 resourceInstance.setSourceModelUid(service.getUniqueId());
732 resourceInstance.setComponentUid(origComponent.getUniqueId());
733 resourceInstance.setComponentVersion(service.getVersion());
734 switch (resourceInstance.getOriginType()) {
736 return fillProxyInstanceData(resourceInstance, origComponent, service);
737 case ServiceSubstitution:
738 return fillServiceSubstitutableNodeTypeData(resourceInstance, service);
740 return StorageOperationStatus.OK;
744 private StorageOperationStatus fillProxyInstanceData(final ComponentInstance resourceInstance, final Component origComponent,
745 final Component service) {
746 final String name = ValidationUtils.normalizeComponentInstanceName(service.getName()) + ToscaOperationFacade.PROXY_SUFFIX;
747 final String toscaResourceName = ((Resource) origComponent).getToscaResourceName();
748 final int lastIndexOf = toscaResourceName.lastIndexOf('.');
749 if (lastIndexOf != -1) {
750 final String proxyToscaName = toscaResourceName.substring(0, lastIndexOf + 1) + name;
751 resourceInstance.setToscaComponentName(proxyToscaName);
753 resourceInstance.setName(name);
754 resourceInstance.setIsProxy(true);
755 resourceInstance.setDescription("A Proxy for Service " + service.getName());
756 return StorageOperationStatus.OK;
759 private StorageOperationStatus fillServiceSubstitutableNodeTypeData(final ComponentInstance resourceInstance, final Component service) {
760 resourceInstance.setToscaComponentName("org.openecomp.service." + ValidationUtils.convertToSystemName(service.getName()));
761 resourceInstance.setName(ValidationUtils.normalizeComponentInstanceName(service.getName()));
762 resourceInstance.setIsProxy(false);
763 resourceInstance.setDescription("A substitutable node type for service " + service.getName());
764 return StorageOperationStatus.OK;
767 public Either<CreateAndAssotiateInfo, ResponseFormat> createAndAssociateRIToRI(String containerComponentParam, String containerComponentId,
768 String userId, CreateAndAssotiateInfo createAndAssotiateInfo) {
769 Either<CreateAndAssotiateInfo, ResponseFormat> resultOp = null;
770 ComponentInstance resourceInstance = createAndAssotiateInfo.getNode();
771 RequirementCapabilityRelDef associationInfo = createAndAssotiateInfo.getAssociate();
772 User user = validateUserExists(userId);
773 final ComponentTypeEnum containerComponentType = validateComponentType(containerComponentParam);
774 org.openecomp.sdc.be.model.Component containerComponent = validateComponentExists(containerComponentId, containerComponentType, null);
775 if (ModelConverter.isAtomicComponent(containerComponent)) {
776 log.debug(CANNOT_ATTACH_RESOURCE_INSTANCES_TO_CONTAINER_RESOURCE_OF_TYPE, containerComponent.assetType());
778 .right(componentsUtils.getResponseFormat(ActionStatus.RESOURCE_CANNOT_CONTAIN_RESOURCE_INSTANCES, containerComponent.assetType()));
780 validateCanWorkOnComponent(containerComponent, userId);
781 boolean failed = false;
783 lockComponent(containerComponent, "createAndAssociateRIToRI");
784 log.debug(TRY_TO_CREATE_ENTRY_ON_GRAPH);
785 Component origComponent = getOriginComponentFromComponentInstance(resourceInstance);
786 log.debug(ENTITY_ON_GRAPH_IS_CREATED);
787 ComponentInstance resResourceInfo = createComponentInstanceOnGraph(containerComponent, origComponent, resourceInstance, user);
788 if (associationInfo.getFromNode() == null || associationInfo.getFromNode().isEmpty()) {
789 associationInfo.setFromNode(resResourceInfo.getUniqueId());
791 associationInfo.setToNode(resResourceInfo.getUniqueId());
793 Either<RequirementCapabilityRelDef, StorageOperationStatus> resultReqCapDef = toscaOperationFacade
794 .associateResourceInstances(containerComponent, containerComponentId, associationInfo);
795 if (resultReqCapDef.isLeft()) {
796 log.debug(ENTITY_ON_GRAPH_IS_CREATED);
797 RequirementCapabilityRelDef resReqCapabilityRelDef = resultReqCapDef.left().value();
798 CreateAndAssotiateInfo resInfo = new CreateAndAssotiateInfo(resResourceInfo, resReqCapabilityRelDef);
799 resultOp = Either.left(resInfo);
802 log.info("Failed to associate node {} with node {}", associationInfo.getFromNode(), associationInfo.getToNode());
803 resultOp = Either.right(componentsUtils.getResponseFormatForResourceInstance(
804 componentsUtils.convertFromStorageResponseForResourceInstance(resultReqCapDef.right().value(), true), "", null));
807 } catch (ComponentException e) {
811 unlockComponent(failed, containerComponent);
815 private Component getOriginComponentFromComponentInstance(ComponentInstance componentInstance) {
816 return getOriginComponentFromComponentInstance(componentInstance.getName(), componentInstance.getComponentUid());
819 private Component getInstanceOriginNode(ComponentInstance componentInstance) {
820 return getOriginComponentFromComponentInstance(componentInstance.getName(), componentInstance.getActualComponentUid());
823 private Component getOriginComponentFromComponentInstance(String componentInstanceName, String origComponetId) {
824 Either<Component, StorageOperationStatus> eitherComponent = toscaOperationFacade.getToscaFullElement(origComponetId);
825 if (eitherComponent.isRight()) {
826 log.debug("Failed to get origin component with id {} for component instance {} ", origComponetId, componentInstanceName);
827 throw new ByActionStatusComponentException(
828 componentsUtils.convertFromStorageResponse(eitherComponent.right().value(), ComponentTypeEnum.RESOURCE), "", null);
830 return eitherComponent.left().value();
833 private ComponentInstance createComponentInstanceOnGraph(org.openecomp.sdc.be.model.Component containerComponent, Component originComponent,
834 ComponentInstance componentInstance, User user) {
835 Either<ImmutablePair<Component, String>, StorageOperationStatus> result = toscaOperationFacade
836 .addComponentInstanceToTopologyTemplate(containerComponent, originComponent, componentInstance, false, user);
837 if (result.isRight()) {
838 log.debug(FAILED_TO_CREATE_ENTRY_ON_GRAPH_FOR_COMPONENT_INSTANCE, componentInstance.getName());
839 throw new ByResponseFormatComponentException(componentsUtils
840 .getResponseFormatForResourceInstance(componentsUtils.convertFromStorageResponseForResourceInstance(result.right().value(), true), "",
843 log.debug(ENTITY_ON_GRAPH_IS_CREATED);
844 Component updatedComponent = result.left().value().getLeft();
845 Map<String, String> existingEnvVersions = new HashMap<>();
846 // TODO existingEnvVersions ??
847 addComponentInstanceArtifacts(updatedComponent, componentInstance, originComponent, user, existingEnvVersions);
848 Optional<ComponentInstance> updatedInstanceOptional = updatedComponent.getComponentInstances().stream()
849 .filter(ci -> ci.getUniqueId().equals(result.left().value().getRight())).findFirst();
850 if (!updatedInstanceOptional.isPresent()) {
851 log.debug("Failed to fetch new added component instance {} from component {}", componentInstance.getName(), containerComponent.getName());
852 throw new ByActionStatusComponentException(ActionStatus.COMPONENT_INSTANCE_NOT_FOUND_ON_CONTAINER, componentInstance.getName());
854 return updatedInstanceOptional.get();
857 public boolean isCloudSpecificArtifact(String artifact) {
858 if (artifact.contains(CLOUD_SPECIFIC_FIXED_KEY_WORD)) {
859 for (int i = 0; i < CLOUD_SPECIFIC_KEY_WORDS.length; i++) {
860 if (Arrays.stream(CLOUD_SPECIFIC_KEY_WORDS[i]).noneMatch(artifact::contains)) {
871 * addResourceInstanceArtifacts - add artifacts (HEAT_ENV) to resource instance The instance artifacts are generated from the resource's
874 * @param containerComponent
875 * @param componentInstance
876 * @param originComponent
878 * @param existingEnvVersions
881 protected ActionStatus addComponentInstanceArtifacts(org.openecomp.sdc.be.model.Component containerComponent, ComponentInstance componentInstance,
882 org.openecomp.sdc.be.model.Component originComponent, User user,
883 Map<String, String> existingEnvVersions) {
884 log.debug("add artifacts to resource instance");
885 List<GroupDefinition> filteredGroups = new ArrayList<>();
886 ActionStatus status = setResourceArtifactsOnResourceInstance(componentInstance);
887 if (ActionStatus.OK != status) {
888 throw new ByResponseFormatComponentException(componentsUtils.getResponseFormatForResourceInstance(status, "", null));
890 StorageOperationStatus artStatus;
891 // generate heat_env if necessary
892 Map<String, ArtifactDefinition> componentDeploymentArtifacts = componentInstance.getDeploymentArtifacts();
893 if (MapUtils.isNotEmpty(componentDeploymentArtifacts)) {
894 Map<String, ArtifactDefinition> finalDeploymentArtifacts = new HashMap<>();
895 Map<String, List<ArtifactDefinition>> groupInstancesArtifacts = new HashMap<>();
896 Integer defaultHeatTimeout = ConfigurationManager.getConfigurationManager().getConfiguration().getHeatArtifactDeploymentTimeout()
897 .getDefaultMinutes();
898 List<ArtifactDefinition> listOfCloudSpecificArts = new ArrayList<>();
899 for (ArtifactDefinition artifact : componentDeploymentArtifacts.values()) {
900 String type = artifact.getArtifactType();
901 if (!type.equalsIgnoreCase(ArtifactTypeEnum.HEAT_ENV.getType())) {
902 finalDeploymentArtifacts.put(artifact.getArtifactLabel(), artifact);
904 if (type.equalsIgnoreCase(ArtifactTypeEnum.HEAT.getType()) || type.equalsIgnoreCase(ArtifactTypeEnum.HELM.getType()) || type
905 .equalsIgnoreCase(ArtifactTypeEnum.HEAT_NET.getType()) || type.equalsIgnoreCase(ArtifactTypeEnum.HEAT_VOL.getType()) || type
906 .equalsIgnoreCase(ArtifactTypeEnum.CLOUD_TECHNOLOGY_SPECIFIC_ARTIFACT.getType())) {
907 artifact.setTimeout(defaultHeatTimeout);
911 if (artifact.checkEsIdExist()) {
912 ArtifactDefinition artifactDefinition = artifactBusinessLogic
913 .createHeatEnvPlaceHolder(new ArrayList<>(), artifact, ArtifactsBusinessLogic.HEAT_ENV_NAME, componentInstance.getUniqueId(),
914 NodeTypeEnum.ResourceInstance, componentInstance.getName(), user, containerComponent, existingEnvVersions);
916 finalDeploymentArtifacts.put(artifactDefinition.getArtifactLabel(), artifactDefinition);
917 if (CollectionUtils.isNotEmpty(originComponent.getGroups())) {
918 filteredGroups = originComponent.getGroups().stream().filter(g -> g.getType().equals(VF_MODULE)).collect(Collectors.toList());
920 if (isCloudSpecificArtifact(artifactDefinition.getArtifactName())) {
921 listOfCloudSpecificArts.add(artifact);
923 if (CollectionUtils.isNotEmpty(filteredGroups)) {
924 filteredGroups.stream()
925 .filter(g -> g.getArtifacts() != null && g.getArtifacts().stream().anyMatch(p -> p.equals(artifactDefinition.getGeneratedFromId()))).findFirst()
926 .ifPresent(g -> fillInstanceArtifactMap(groupInstancesArtifacts, artifactDefinition, g));
930 groupInstancesArtifacts.forEach((k, v) -> v.addAll(listOfCloudSpecificArts));
931 filteredGroups.forEach(g -> listOfCloudSpecificArts.forEach(e -> {
932 g.getArtifactsUuid().add(e.getArtifactUUID());
933 g.getArtifacts().add(e.getUniqueId());
935 artStatus = toscaOperationFacade
936 .addDeploymentArtifactsToInstance(containerComponent.getUniqueId(), componentInstance, finalDeploymentArtifacts);
937 if (artStatus != StorageOperationStatus.OK) {
938 log.debug("Failed to add instance deployment artifacts for instance {} in conatiner {} error {}", componentInstance.getUniqueId(),
939 containerComponent.getUniqueId(), artStatus);
940 throw new ByResponseFormatComponentException(
941 componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponseForResourceInstance(artStatus, false)));
943 StorageOperationStatus result = toscaOperationFacade
944 .addGroupInstancesToComponentInstance(containerComponent, componentInstance, filteredGroups, groupInstancesArtifacts);
945 if (result != StorageOperationStatus.OK) {
946 log.debug("failed to update group instance for component instance {}", componentInstance.getUniqueId());
947 throw new ByResponseFormatComponentException(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(result)));
949 componentInstance.setDeploymentArtifacts(finalDeploymentArtifacts);
951 artStatus = toscaOperationFacade
952 .addInformationalArtifactsToInstance(containerComponent.getUniqueId(), componentInstance, originComponent.getArtifacts());
953 if (artStatus != StorageOperationStatus.OK) {
954 log.debug("Failed to add informational artifacts to the instance {} belonging to the conatiner {}. Status is {}",
955 componentInstance.getUniqueId(), containerComponent.getUniqueId(), artStatus);
956 throw new ByResponseFormatComponentException(
957 componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponseForResourceInstance(artStatus, false)));
959 componentInstance.setArtifacts(originComponent.getArtifacts());
960 return ActionStatus.OK;
963 private void fillInstanceArtifactMap(Map<String, List<ArtifactDefinition>> groupInstancesArtifacts, ArtifactDefinition artifactDefinition,
964 GroupDefinition groupInstance) {
965 List<ArtifactDefinition> artifactsUid;
966 if (groupInstancesArtifacts.containsKey(groupInstance.getUniqueId())) {
967 artifactsUid = groupInstancesArtifacts.get(groupInstance.getUniqueId());
969 artifactsUid = new ArrayList<>();
971 artifactsUid.add(artifactDefinition);
972 groupInstancesArtifacts.put(groupInstance.getUniqueId(), artifactsUid);
975 private ActionStatus setResourceArtifactsOnResourceInstance(ComponentInstance resourceInstance) {
976 Either<Map<String, ArtifactDefinition>, StorageOperationStatus> getResourceDeploymentArtifacts = artifactBusinessLogic
977 .getArtifacts(resourceInstance.getComponentUid(), NodeTypeEnum.Resource, ArtifactGroupTypeEnum.DEPLOYMENT, null);
978 Map<String, ArtifactDefinition> deploymentArtifacts = new HashMap<>();
979 if (getResourceDeploymentArtifacts.isRight()) {
980 StorageOperationStatus status = getResourceDeploymentArtifacts.right().value();
981 if (status != StorageOperationStatus.NOT_FOUND) {
982 log.debug("Failed to fetch resource: {} artifacts. status is {}", resourceInstance.getComponentUid(), status);
983 return componentsUtils.convertFromStorageResponseForResourceInstance(status, true);
986 deploymentArtifacts = getResourceDeploymentArtifacts.left().value();
988 if (!deploymentArtifacts.isEmpty()) {
989 Map<String, ArtifactDefinition> tempDeploymentArtifacts = new HashMap<>(deploymentArtifacts);
990 for (Entry<String, ArtifactDefinition> artifact : deploymentArtifacts.entrySet()) {
991 if (!artifact.getValue().checkEsIdExist()) {
992 tempDeploymentArtifacts.remove(artifact.getKey());
995 resourceInstance.setDeploymentArtifacts(tempDeploymentArtifacts);
997 return ActionStatus.OK;
1000 public Either<ComponentInstance, ResponseFormat> updateComponentInstanceMetadata(String containerComponentParam, String containerComponentId,
1001 String componentInstanceId, String userId,
1002 ComponentInstance componentInstance) {
1003 return updateComponentInstanceMetadata(containerComponentParam, containerComponentId, componentInstanceId, userId, componentInstance, true);
1006 public Either<ComponentInstance, ResponseFormat> updateComponentInstanceMetadata(final String containerComponentParam,
1007 final String containerComponentId,
1008 final String componentInstanceId, final String userId,
1009 ComponentInstance componentInstance, boolean needLock) {
1010 validateUserExists(userId);
1011 final ComponentTypeEnum containerComponentType = validateComponentType(containerComponentParam);
1012 final Component containerComponent = validateComponentExists(containerComponentId, containerComponentType, null);
1013 validateCanWorkOnComponent(containerComponent, userId);
1014 ComponentTypeEnum instanceType = getComponentType(containerComponentType);
1015 Either<Boolean, StorageOperationStatus> validateParentStatus = toscaOperationFacade
1016 .validateComponentExists(componentInstance.getComponentUid());
1017 if (validateParentStatus.isRight()) {
1018 log.debug("Failed to get component instance {} on service {}", componentInstanceId, containerComponentId);
1019 throw new ByActionStatusComponentException(ActionStatus.COMPONENT_INSTANCE_NOT_FOUND, componentInstance.getName(),
1020 instanceType.getValue().toLowerCase());
1022 if (!Boolean.TRUE.equals(validateParentStatus.left().value())) {
1023 throw new ByActionStatusComponentException(ActionStatus.COMPONENT_INSTANCE_NOT_FOUND_ON_CONTAINER, componentInstance.getName(),
1024 instanceType.getValue().toLowerCase(), containerComponentType.getValue().toLowerCase(), containerComponentId);
1027 lockComponent(containerComponent, "updateComponentInstance");
1029 Component origComponent;
1030 boolean failed = false;
1032 origComponent = getOriginComponentFromComponentInstance(componentInstance);
1033 componentInstance = updateComponentInstanceMetadata(containerComponent, containerComponentType, origComponent, componentInstanceId,
1035 } catch (ComponentException e) {
1040 unlockComponent(failed, containerComponent);
1043 return Either.left(componentInstance);
1046 // New Multiple Instance Update API
1047 public List<ComponentInstance> updateComponentInstance(String containerComponentParam, Component containerComponent, String containerComponentId,
1048 String userId, List<ComponentInstance> componentInstanceList, boolean needLock) {
1049 boolean failed = false;
1051 validateUserExists(userId);
1052 final ComponentTypeEnum containerComponentType = validateComponentType(containerComponentParam);
1053 ComponentParametersView componentFilter = new ComponentParametersView();
1054 componentFilter.disableAll();
1055 componentFilter.setIgnoreUsers(false);
1056 componentFilter.setIgnoreComponentInstances(false);
1057 if (containerComponent == null) {
1058 containerComponent = validateComponentExistsByFilter(containerComponentId, containerComponentType, componentFilter);
1060 validateCanWorkOnComponent(containerComponent, userId);
1061 ComponentTypeEnum instanceType = getComponentType(containerComponentType);
1062 for (ComponentInstance componentInstance : componentInstanceList) {
1063 boolean validateParent = validateParent(containerComponent, componentInstance.getUniqueId());
1064 if (!validateParent) {
1065 throw new ByActionStatusComponentException(ActionStatus.COMPONENT_INSTANCE_NOT_FOUND_ON_CONTAINER, componentInstance.getName(),
1066 instanceType.getValue().toLowerCase(), containerComponentType.getValue().toLowerCase(), containerComponentId);
1070 lockComponent(containerComponent, "updateComponentInstance");
1072 List<ComponentInstance> updatedList = new ArrayList<>();
1073 List<ComponentInstance> instancesFromContainerComponent = containerComponent.getComponentInstances();
1074 List<ComponentInstance> listForUpdate = new ArrayList<>();
1075 if (instancesFromContainerComponent == null || instancesFromContainerComponent.isEmpty()) {
1076 containerComponent.setComponentInstances(componentInstanceList);
1078 Iterator<ComponentInstance> iterator = instancesFromContainerComponent.iterator();
1079 while (iterator.hasNext()) {
1080 ComponentInstance origInst = iterator.next();
1081 Optional<ComponentInstance> op = componentInstanceList.stream().filter(ci -> ci.getUniqueId().equals(origInst.getUniqueId()))
1083 if (op.isPresent()) {
1084 ComponentInstance updatedCi = op.get();
1085 updatedCi = buildComponentInstance(updatedCi, origInst);
1086 Boolean isUniqueName = validateInstanceNameUniquenessUponUpdate(containerComponent, origInst, updatedCi.getName());
1087 if (!Boolean.TRUE.equals(isUniqueName)) {
1088 CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG,
1089 "Failed to update the name of the component instance {} to {}. A component instance with the same name already exists. ",
1090 origInst.getName(), updatedCi.getName());
1091 throw new ByResponseFormatComponentException(componentsUtils
1092 .getResponseFormat(ActionStatus.COMPONENT_NAME_ALREADY_EXIST, containerComponentType.getValue(), origInst.getName()));
1094 listForUpdate.add(updatedCi);
1096 listForUpdate.add(origInst);
1099 containerComponent.setComponentInstances(listForUpdate);
1100 Either<Component, StorageOperationStatus> updateStatus = toscaOperationFacade
1101 .updateComponentInstanceMetadataOfTopologyTemplate(containerComponent, componentFilter);
1102 if (updateStatus.isRight()) {
1104 .addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to update metadata belonging to container component {}. Status is {}. ",
1105 containerComponent.getName(), updateStatus.right().value());
1106 throw new ByResponseFormatComponentException(componentsUtils.getResponseFormatForResourceInstance(
1107 componentsUtils.convertFromStorageResponseForResourceInstance(updateStatus.right().value(), true), "", null));
1109 for (ComponentInstance updatedInstance : updateStatus.left().value().getComponentInstances()) {
1110 Optional<ComponentInstance> op = componentInstanceList.stream().filter(ci -> ci.getName().equals(updatedInstance.getName()))
1112 if (op.isPresent()) {
1113 updatedList.add(updatedInstance);
1118 } catch (ComponentException e) {
1123 unlockComponent(failed, containerComponent);
1128 private boolean validateParent(org.openecomp.sdc.be.model.Component containerComponent, String nodeTemplateId) {
1129 return containerComponent.getComponentInstances().stream().anyMatch(p -> p.getUniqueId().equals(nodeTemplateId));
1132 private ComponentTypeEnum getComponentType(ComponentTypeEnum containerComponentType) {
1133 if (ComponentTypeEnum.PRODUCT == containerComponentType) {
1134 return ComponentTypeEnum.SERVICE_INSTANCE;
1136 return ComponentTypeEnum.RESOURCE_INSTANCE;
1140 private ComponentInstance updateComponentInstanceMetadata(Component containerComponent, ComponentTypeEnum containerComponentType,
1141 org.openecomp.sdc.be.model.Component origComponent, String componentInstanceId,
1142 ComponentInstance componentInstance) {
1143 Optional<ComponentInstance> componentInstanceOptional;
1144 Either<ImmutablePair<Component, String>, StorageOperationStatus> updateRes = null;
1145 ComponentInstance oldComponentInstance = null;
1146 boolean isNameChanged = false;
1147 componentInstanceOptional = containerComponent.getComponentInstances().stream()
1148 .filter(ci -> ci.getUniqueId().equals(componentInstance.getUniqueId())).findFirst();
1149 if (!componentInstanceOptional.isPresent()) {
1150 CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to find the component instance {} in container component {}. ",
1151 componentInstance.getName(), containerComponent.getName());
1152 throw new ByActionStatusComponentException(ActionStatus.COMPONENT_INSTANCE_NOT_FOUND_ON_CONTAINER, componentInstance.getName());
1154 String oldComponentName;
1155 oldComponentInstance = componentInstanceOptional.get();
1156 oldComponentName = oldComponentInstance.getName();
1157 String newInstanceName = componentInstance.getName();
1158 if (oldComponentName != null && !oldComponentInstance.getName().equals(newInstanceName)) {
1159 isNameChanged = true;
1161 Boolean isUniqueName = validateInstanceNameUniquenessUponUpdate(containerComponent, oldComponentInstance, newInstanceName);
1162 if (!Boolean.TRUE.equals(isUniqueName)) {
1163 CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG,
1164 "Failed to update the name of the component instance {} to {}. A component instance with the same name already exists. ",
1165 oldComponentInstance.getName(), newInstanceName);
1166 throw new ByActionStatusComponentException(ActionStatus.COMPONENT_NAME_ALREADY_EXIST, containerComponentType.getValue(),
1167 componentInstance.getName());
1169 if (!DirectivesUtil.isValid(componentInstance.getDirectives())) {
1170 final String directivesStr = componentInstance.getDirectives().stream().collect(Collectors.joining(" , ", " [ ", " ] "));
1171 CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG,
1172 "Failed to update the directives of the component instance {} to {}. Directives data {} is invalid. ", oldComponentInstance.getName(),
1173 newInstanceName, directivesStr);
1174 throw new ByActionStatusComponentException(ActionStatus.DIRECTIVES_INVALID_VALUE, containerComponentType.getValue(),
1175 componentInstance.getName());
1177 updateRes = toscaOperationFacade.updateComponentInstanceMetadataOfTopologyTemplate(containerComponent, origComponent,
1178 updateComponentInstanceMetadata(oldComponentInstance, componentInstance));
1179 if (updateRes.isRight()) {
1180 CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG,
1181 "Failed to update metadata of component instance {} belonging to container component {}. Status is {}. ", componentInstance.getName(),
1182 containerComponent.getName(), updateRes.right().value());
1183 throw new ByResponseFormatComponentException(componentsUtils
1184 .getResponseFormatForResourceInstance(componentsUtils.convertFromStorageResponseForResourceInstance(updateRes.right().value(), true),
1187 // region - Update instance Groups
1188 if (isNameChanged) {
1189 Either<StorageOperationStatus, StorageOperationStatus> result = toscaOperationFacade
1190 .cleanAndAddGroupInstancesToComponentInstance(containerComponent, oldComponentInstance, componentInstanceId);
1191 if (result.isRight()) {
1193 .addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to rename group instances for container {}. error {} ", componentInstanceId,
1194 result.right().value());
1196 if (containerComponent instanceof Service) {
1197 Either<ComponentInstance, ResponseFormat> renameEither = renameServiceFilter((Service) containerComponent, newInstanceName,
1198 oldComponentInstance.getName());
1199 if (renameEither.isRight()) {
1200 throw new ByResponseFormatComponentException(renameEither.right().value());
1202 updateForwardingPathDefinition(containerComponent, componentInstance, oldComponentName);
1207 String newInstanceId = updateRes.left().value().getRight();
1208 Optional<ComponentInstance> updatedInstanceOptional = updateRes.left().value().getLeft().getComponentInstances().stream()
1209 .filter(ci -> ci.getUniqueId().equals(newInstanceId)).findFirst();
1210 if (!updatedInstanceOptional.isPresent()) {
1211 log.debug("Failed to update metadata of component instance {} of container component {}", componentInstance.getName(),
1212 containerComponent.getName());
1213 throw new ByResponseFormatComponentException(
1214 componentsUtils.getResponseFormat(ActionStatus.COMPONENT_INSTANCE_NOT_FOUND_ON_CONTAINER, componentInstance.getName()));
1216 return componentInstanceOptional.get();
1219 private void updateForwardingPathDefinition(Component containerComponent, ComponentInstance componentInstance, String oldComponentName) {
1220 Collection<ForwardingPathDataDefinition> forwardingPathDataDefinitions = getForwardingPathDataDefinitions(containerComponent.getUniqueId());
1221 Set<ForwardingPathDataDefinition> updated = new ForwardingPathUtils()
1222 .updateComponentInstanceName(forwardingPathDataDefinitions, oldComponentName, componentInstance.getName());
1223 updated.forEach(fp -> {
1224 Either<ForwardingPathDataDefinition, StorageOperationStatus> resultEither = forwardingPathOperation
1225 .updateForwardingPath(containerComponent.getUniqueId(), fp);
1226 if (resultEither.isRight()) {
1227 CommonUtility.addRecordToLog(log, LogLevelEnum.ERROR, "Failed to rename forwarding path for container {}. error {} ",
1228 containerComponent.getName(), resultEither.right().value());
1233 public Either<ComponentInstance, ResponseFormat> renameServiceFilter(final Service containerComponent, final String newInstanceName,
1234 final String oldInstanceName) {
1235 Map<String, CINodeFilterDataDefinition> renamedNodesFilter = ServiceFilterUtils
1236 .getRenamedNodesFilter(containerComponent, oldInstanceName, newInstanceName);
1237 for (Entry<String, CINodeFilterDataDefinition> entry : renamedNodesFilter.entrySet()) {
1238 Either<CINodeFilterDataDefinition, StorageOperationStatus> renameEither = nodeFilterOperation
1239 .updateNodeFilter(containerComponent.getUniqueId(), entry.getKey(), entry.getValue());
1240 if (renameEither.isRight()) {
1241 return Either.right(componentsUtils.getResponseFormatForResourceInstance(
1242 componentsUtils.convertFromStorageResponse(renameEither.right().value(), ComponentTypeEnum.SERVICE), containerComponent.getName(),
1246 return Either.left(null);
1250 * @param oldPrefix- The normalized old vf name
1251 * @param newNormailzedPrefix- The normalized new vf name
1252 * @param qualifiedGroupInstanceName- old Group Instance Name
1255 // modify group names
1256 private String getNewGroupName(String oldPrefix, String newNormailzedPrefix, String qualifiedGroupInstanceName) {
1257 if (qualifiedGroupInstanceName == null) {
1258 log.info("CANNOT change group name ");
1261 if (qualifiedGroupInstanceName.startsWith(oldPrefix) || qualifiedGroupInstanceName
1262 .startsWith(ValidationUtils.normalizeComponentInstanceName(oldPrefix))) {
1263 return qualifiedGroupInstanceName.replaceFirst(oldPrefix, newNormailzedPrefix);
1265 return qualifiedGroupInstanceName;
1268 private ComponentInstance updateComponentInstanceMetadata(ComponentInstance oldComponentInstance, ComponentInstance newComponentInstance) {
1269 oldComponentInstance.setName(newComponentInstance.getName());
1270 oldComponentInstance.setModificationTime(System.currentTimeMillis());
1271 oldComponentInstance.setCustomizationUUID(UUID.randomUUID().toString());
1272 oldComponentInstance.setDirectives(newComponentInstance.getDirectives());
1273 oldComponentInstance.setMaxOccurrences(newComponentInstance.getMaxOccurrences());
1274 oldComponentInstance.setMinOccurrences(newComponentInstance.getMinOccurrences());
1275 oldComponentInstance.setInstanceCount(newComponentInstance.getInstanceCount());
1276 if (oldComponentInstance.getGroupInstances() != null) {
1277 oldComponentInstance.getGroupInstances().forEach(group -> group.setName(getNewGroupName(oldComponentInstance.getNormalizedName(),
1278 ValidationUtils.normalizeComponentInstanceName(newComponentInstance.getName()), group.getName())));
1280 return oldComponentInstance;
1283 public ComponentInstance deleteComponentInstance(final String containerComponentParam, final String containerComponentId,
1284 final String componentInstanceId, String userId) throws BusinessLogicException {
1285 validateUserExists(userId);
1286 final ComponentTypeEnum containerComponentType = validateComponentType(containerComponentParam);
1287 final Component containerComponent = validateComponentExists(containerComponentId, containerComponentType, null);
1288 validateCanWorkOnComponent(containerComponent, userId);
1289 boolean failed = false;
1290 final Optional<ComponentInstance> componentInstanceOptional = containerComponent.getComponentInstanceById(componentInstanceId);
1291 if (!componentInstanceOptional.isPresent()) {
1292 throw new BusinessLogicException(componentsUtils.getResponseFormat(ActionStatus.COMPONENT_INSTANCE_NOT_FOUND));
1294 ComponentInstance componentInstance = componentInstanceOptional.get();
1296 if (containerComponent instanceof Service || containerComponent instanceof Resource) {
1297 final Either<String, StorageOperationStatus> deleteServiceFilterEither = nodeFilterOperation
1298 .deleteNodeFilter(containerComponent, componentInstanceId);
1299 if (deleteServiceFilterEither.isRight()) {
1300 final ActionStatus status = componentsUtils
1301 .convertFromStorageResponse(deleteServiceFilterEither.right().value(), containerComponentType);
1302 janusGraphDao.rollback();
1303 throw new ByResponseFormatComponentException(componentsUtils.getResponseFormat(status, componentInstanceId));
1305 final Either<ComponentInstance, ResponseFormat> resultOp = deleteNodeFiltersFromComponentInstance(containerComponent,
1306 componentInstance, containerComponentType, userId);
1307 if (resultOp.isRight()) {
1308 janusGraphDao.rollback();
1309 throw new ByResponseFormatComponentException(resultOp.right().value());
1312 lockComponent(containerComponent, "deleteComponentInstance");
1313 final ComponentInstance deletedCompInstance = deleteComponentInstance(containerComponent, componentInstanceId, containerComponentType);
1314 componentInstance = deleteForwardingPathsRelatedTobeDeletedComponentInstance(containerComponentId, containerComponentType,
1315 deletedCompInstance);
1316 final ActionStatus onDeleteOperationsStatus = onChangeInstanceOperationOrchestrator
1317 .doOnDeleteInstanceOperations(containerComponent, componentInstanceId);
1318 if (ActionStatus.OK != onDeleteOperationsStatus) {
1319 throw new ByActionStatusComponentException(onDeleteOperationsStatus);
1321 } catch (final ComponentException e) {
1325 unlockComponent(failed, containerComponent);
1327 return componentInstance;
1331 * Try to modify the delete and return two cases
1333 * @param containerComponentParam
1334 * @param containerComponentId
1335 * @param componentInstanceId
1339 public Either<ComponentInstance, ResponseFormat> deleteAbstractComponentInstance(String containerComponentParam, String containerComponentId,
1340 String componentInstanceId, String userId) {
1341 log.debug("enter deleteAbstractComponentInstance");
1342 validateUserExists(userId);
1343 final ComponentTypeEnum containerComponentType = validateComponentType(containerComponentParam);
1344 org.openecomp.sdc.be.model.Component containerComponent = validateComponentExists(containerComponentId, containerComponentType, null);
1345 validateCanWorkOnComponent(containerComponent, userId);
1346 boolean failed = false;
1347 ComponentInstance deletedRelatedInst;
1349 if (containerComponent instanceof Service) {
1350 final Optional<ComponentInstance> componentInstanceById = containerComponent.getComponentInstanceById(componentInstanceId);
1351 if (componentInstanceById.isPresent()) {
1352 ComponentInstance componentInstance = componentInstanceById.get();
1353 Either<String, StorageOperationStatus> deleteServiceFilterEither = nodeFilterOperation
1354 .deleteNodeFilter(containerComponent, componentInstanceId);
1355 if (deleteServiceFilterEither.isRight()) {
1356 log.debug("enter deleteAbstractComponentInstance:deleteServiceFilterEither is right, filed");
1357 ActionStatus status = componentsUtils
1358 .convertFromStorageResponse(deleteServiceFilterEither.right().value(), containerComponentType);
1359 janusGraphDao.rollback();
1360 return Either.right(componentsUtils.getResponseFormat(status, componentInstance.getName()));
1362 Either<ComponentInstance, ResponseFormat> resultOp = deleteNodeFiltersFromComponentInstance(containerComponent, componentInstance,
1363 ComponentTypeEnum.SERVICE, userId);
1364 if (resultOp.isRight()) {
1365 log.debug("enter deleteAbstractComponentInstance:resultOp is right, filed");
1366 janusGraphDao.rollback();
1371 log.debug("enter deleteAbstractComponentInstance:");
1372 lockComponent(containerComponent, "deleteComponentInstance");
1373 ComponentInstance deletedCompInstance = deleteComponentInstance(containerComponent, componentInstanceId, containerComponentType);
1374 deletedRelatedInst = deleteForwardingPathsRelatedTobeDeletedComponentInstance(containerComponentId, containerComponentType,
1375 deletedCompInstance);
1376 ActionStatus onDeleteOperationsStatus = onChangeInstanceOperationOrchestrator
1377 .doOnDeleteInstanceOperations(containerComponent, componentInstanceId);
1378 log.debug("enter deleteAbstractComponentInstance,get onDeleteOperationsStatus:{}", onDeleteOperationsStatus);
1379 if (ActionStatus.OK != onDeleteOperationsStatus) {
1380 throw new ByActionStatusComponentException(onDeleteOperationsStatus);
1382 } catch (ComponentException e) {
1386 unlockComponent(failed, containerComponent);
1388 log.debug("enter deleteAbstractComponentInstance,deleted RelatedInst success");
1389 return Either.left(deletedRelatedInst);
1392 public Either<ComponentInstance, ResponseFormat> deleteNodeFiltersFromComponentInstance(final Component component,
1393 final ComponentInstance componentInstance,
1394 final ComponentTypeEnum containerComponentType,
1395 final String userId) {
1396 final Set<String> componentFiltersIDsToBeDeleted = getComponentFiltersRelatedToComponentInstance(component.getUniqueId(), componentInstance);
1397 if (!componentFiltersIDsToBeDeleted.isEmpty()) {
1398 final Set<String> ids = component.getComponentInstances().stream().filter(ci -> componentFiltersIDsToBeDeleted.contains(ci.getName()))
1399 .map(ComponentInstance::getUniqueId).collect(Collectors.toSet());
1400 final Either<Set<String>, StorageOperationStatus> deleteComponentNodeFiltersEither = nodeFilterOperation
1401 .deleteNodeFilters(component, ids);
1402 if (deleteComponentNodeFiltersEither.isRight()) {
1403 final ActionStatus status = componentsUtils
1404 .convertFromStorageResponse(deleteComponentNodeFiltersEither.right().value(), containerComponentType);
1405 return Either.right(componentsUtils.getResponseFormat(status, componentInstance.getName()));
1407 for (final String id : ids) {
1408 final Optional<ComponentInstance> componentInstanceById = component.getComponentInstanceById(id);
1409 if (!componentInstanceById.isPresent()) {
1410 return Either.right(componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR));
1412 final ComponentInstance componentInstanceToBeUpdated = componentInstanceById.get();
1413 componentInstanceToBeUpdated.setDirectives(Collections.emptyList());
1414 final Either<ComponentInstance, ResponseFormat> componentInstanceResponseFormatEither = updateComponentInstanceMetadata(
1415 containerComponentType.getValue(), component.getUniqueId(), componentInstanceToBeUpdated.getUniqueId(), userId,
1416 componentInstanceToBeUpdated, false);
1417 if (componentInstanceResponseFormatEither.isRight()) {
1418 return componentInstanceResponseFormatEither;
1422 return Either.left(componentInstance);
1425 private Set<String> getComponentFiltersRelatedToComponentInstance(String containerComponentId, ComponentInstance componentInstance) {
1426 ComponentParametersView filter = new ComponentParametersView(true);
1427 filter.setIgnoreComponentInstances(false);
1428 Either<Component, StorageOperationStatus> componentFilterOrigin = toscaOperationFacade.getToscaElement(containerComponentId, filter);
1429 final Component component = componentFilterOrigin.left().value();
1430 return ComponentsUtils.getNodesFiltersToBeDeleted(component, componentInstance);
1433 ComponentInstance deleteForwardingPathsRelatedTobeDeletedComponentInstance(String containerComponentId, ComponentTypeEnum containerComponentType,
1434 ComponentInstance componentInstance) {
1435 if (containerComponentType == ComponentTypeEnum.SERVICE) {
1436 List<String> pathIDsToBeDeleted = getForwardingPathsRelatedToComponentInstance(containerComponentId, componentInstance.getName());
1437 if (!pathIDsToBeDeleted.isEmpty()) {
1438 deleteForwardingPaths(containerComponentId, pathIDsToBeDeleted);
1441 return componentInstance;
1444 private void deleteForwardingPaths(String serviceId, List<String> pathIdsToDelete) {
1445 Either<Service, StorageOperationStatus> storageStatus = toscaOperationFacade.getToscaElement(serviceId);
1446 if (storageStatus.isRight()) {
1447 throw new ByActionStatusComponentException(componentsUtils.convertFromStorageResponse(storageStatus.right().value()));
1449 Either<Set<String>, StorageOperationStatus> result = forwardingPathOperation
1450 .deleteForwardingPath(storageStatus.left().value(), Sets.newHashSet(pathIdsToDelete));
1451 if (result.isRight()) {
1452 throw new ByActionStatusComponentException(componentsUtils.convertFromStorageResponse(result.right().value()));
1456 private List<String> getForwardingPathsRelatedToComponentInstance(String containerComponentId, String componentInstanceId) {
1457 Collection<ForwardingPathDataDefinition> allPaths = getForwardingPathDataDefinitions(containerComponentId);
1458 List<String> pathIDsToBeDeleted = new ArrayList<>();
1459 allPaths.stream().filter(path -> isPathRelatedToComponent(path, componentInstanceId))
1460 .forEach(path -> pathIDsToBeDeleted.add(path.getUniqueId()));
1461 return pathIDsToBeDeleted;
1464 private Collection<ForwardingPathDataDefinition> getForwardingPathDataDefinitions(String containerComponentId) {
1465 ComponentParametersView filter = new ComponentParametersView(true);
1466 filter.setIgnoreServicePath(false);
1467 Either<Service, StorageOperationStatus> forwardingPathOrigin = toscaOperationFacade.getToscaElement(containerComponentId, filter);
1468 return forwardingPathOrigin.left().value().getForwardingPaths().values();
1471 private boolean isPathRelatedToComponent(ForwardingPathDataDefinition pathDataDefinition, String componentInstanceId) {
1472 return pathDataDefinition.getPathElements().getListToscaDataDefinition().stream().anyMatch(
1473 elementDataDefinition -> elementDataDefinition.getFromNode().equalsIgnoreCase(componentInstanceId) || elementDataDefinition.getToNode()
1474 .equalsIgnoreCase(componentInstanceId));
1477 private ComponentInstance deleteComponentInstance(Component containerComponent, String componentInstanceId,
1478 ComponentTypeEnum containerComponentType) {
1479 Either<ImmutablePair<Component, String>, StorageOperationStatus> deleteRes = toscaOperationFacade
1480 .deleteComponentInstanceFromTopologyTemplate(containerComponent, componentInstanceId);
1481 if (deleteRes.isRight()) {
1482 log.debug("Failed to delete entry on graph for resourceInstance {}", componentInstanceId);
1483 ActionStatus status = componentsUtils.convertFromStorageResponse(deleteRes.right().value(), containerComponentType);
1484 throw new ByActionStatusComponentException(status, componentInstanceId);
1486 log.debug("The component instance {} has been removed from container component {}. ", componentInstanceId, containerComponent);
1487 ComponentInstance deletedInstance = findAndRemoveComponentInstanceFromContainerComponent(componentInstanceId, containerComponent);
1488 if (CollectionUtils.isNotEmpty(containerComponent.getInputs())) {
1489 List<InputDefinition> inputsToDelete = containerComponent.getInputs().stream()
1490 .filter(i -> i.getInstanceUniqueId() != null && i.getInstanceUniqueId().equals(componentInstanceId)).collect(Collectors.toList());
1491 if (CollectionUtils.isNotEmpty(inputsToDelete)) {
1492 StorageOperationStatus deleteInputsRes = toscaOperationFacade
1493 .deleteComponentInstanceInputsFromTopologyTemplate(containerComponent, inputsToDelete);
1494 if (deleteInputsRes != StorageOperationStatus.OK) {
1495 log.debug("Failed to delete inputs of the component instance {} from container component. ", componentInstanceId);
1496 throw new ByActionStatusComponentException(componentsUtils.convertFromStorageResponse(deleteInputsRes, containerComponentType),
1497 componentInstanceId);
1501 if (CollectionUtils.isNotEmpty(containerComponent.getOutputs())) {
1502 final List<OutputDefinition> outputsToDelete = containerComponent.getOutputs().stream()
1503 .filter(i -> i.getInstanceUniqueId() != null && i.getInstanceUniqueId().equals(componentInstanceId)).collect(Collectors.toList());
1504 if (CollectionUtils.isNotEmpty(outputsToDelete)) {
1505 final StorageOperationStatus deleteOutputsRes = toscaOperationFacade
1506 .deleteComponentInstanceOutputsFromTopologyTemplate(containerComponent, outputsToDelete);
1507 if (deleteOutputsRes != StorageOperationStatus.OK) {
1508 log.debug("Failed to delete outputs of the component instance {} from container component. ", componentInstanceId);
1509 throw new ByActionStatusComponentException(componentsUtils.convertFromStorageResponse(deleteOutputsRes, containerComponentType),
1510 componentInstanceId);
1514 return deletedInstance;
1517 private ComponentInstance findAndRemoveComponentInstanceFromContainerComponent(String componentInstanceId, Component containerComponent) {
1518 ComponentInstance foundInstance = null;
1519 for (ComponentInstance instance : containerComponent.getComponentInstances()) {
1520 if (instance.getUniqueId().equals(componentInstanceId)) {
1521 foundInstance = instance;
1522 containerComponent.getComponentInstances().remove(instance);
1526 findAndRemoveComponentInstanceRelations(componentInstanceId, containerComponent);
1527 return foundInstance;
1530 private void findAndRemoveComponentInstanceRelations(String componentInstanceId, Component containerComponent) {
1531 if (CollectionUtils.isNotEmpty(containerComponent.getComponentInstancesRelations())) {
1532 containerComponent.setComponentInstancesRelations(
1533 containerComponent.getComponentInstancesRelations().stream().filter(r -> isNotBelongingRelation(componentInstanceId, r))
1534 .collect(Collectors.toList()));
1538 private boolean isNotBelongingRelation(String componentInstanceId, RequirementCapabilityRelDef relation) {
1539 return !relation.getToNode().equals(componentInstanceId) && !relation.getFromNode().equals(componentInstanceId);
1542 public RequirementCapabilityRelDef associateRIToRI(String componentId, String userId, RequirementCapabilityRelDef requirementDef,
1543 ComponentTypeEnum componentTypeEnum) {
1544 return associateRIToRI(componentId, userId, requirementDef, componentTypeEnum, true);
1547 public RequirementCapabilityRelDef associateRIToRI(String componentId, String userId, RequirementCapabilityRelDef requirementDef,
1548 ComponentTypeEnum componentTypeEnum, boolean needLock) {
1549 validateUserExists(userId);
1550 RequirementCapabilityRelDef requirementCapabilityRelDef;
1551 org.openecomp.sdc.be.model.Component containerComponent = validateComponentExists(componentId, componentTypeEnum, null);
1552 validateCanWorkOnComponent(containerComponent, userId);
1553 boolean failed = false;
1556 lockComponent(containerComponent, ASSOCIATE_RI_TO_RI);
1558 requirementCapabilityRelDef = associateRIToRIOnGraph(containerComponent, requirementDef);
1559 } catch (ComponentException e) {
1564 unlockComponent(failed, containerComponent);
1567 return requirementCapabilityRelDef;
1570 public RequirementCapabilityRelDef associateRIToRIOnGraph(Component containerComponent, RequirementCapabilityRelDef requirementDef) {
1571 log.debug(TRY_TO_CREATE_ENTRY_ON_GRAPH);
1572 Either<RequirementCapabilityRelDef, StorageOperationStatus> result = toscaOperationFacade
1573 .associateResourceInstances(null, containerComponent.getUniqueId(), requirementDef);
1574 if (result.isLeft()) {
1575 log.debug(ENTITY_ON_GRAPH_IS_CREATED);
1576 return result.left().value();
1578 log.debug("Failed to associate node: {} with node {}", requirementDef.getFromNode(), requirementDef.getToNode());
1579 String fromNameOrId = "";
1580 String toNameOrId = "";
1581 Either<ComponentInstance, StorageOperationStatus> fromResult = getResourceInstanceById(containerComponent, requirementDef.getFromNode());
1582 Either<ComponentInstance, StorageOperationStatus> toResult = getResourceInstanceById(containerComponent, requirementDef.getToNode());
1583 toNameOrId = requirementDef.getFromNode();
1584 fromNameOrId = requirementDef.getFromNode();
1585 if (fromResult.isLeft()) {
1586 fromNameOrId = fromResult.left().value().getName();
1588 if (toResult.isLeft()) {
1589 toNameOrId = toResult.left().value().getName();
1591 throw new ByActionStatusComponentException(componentsUtils.convertFromStorageResponseForResourceInstance(result.right().value(), true),
1592 fromNameOrId, toNameOrId, requirementDef.getRelationships().get(0).getRelation().getRequirement());
1597 * @param componentId
1599 * @param requirementDefList
1600 * @param componentTypeEnum
1603 public List<RequirementCapabilityRelDef> batchDissociateRIFromRI(String componentId, String userId,
1604 List<RequirementCapabilityRelDef> requirementDefList,
1605 ComponentTypeEnum componentTypeEnum) {
1606 validateUserExists(userId);
1607 org.openecomp.sdc.be.model.Component containerComponent = validateComponentExists(componentId, componentTypeEnum, null);
1608 validateCanWorkOnComponent(containerComponent, userId);
1609 boolean failed = false;
1610 List<RequirementCapabilityRelDef> delOkResult = new ArrayList<>();
1612 lockComponent(containerComponent, ASSOCIATE_RI_TO_RI);
1613 for (RequirementCapabilityRelDef requirementDef : requirementDefList) {
1614 RequirementCapabilityRelDef requirementCapabilityRelDef = dissociateRIFromRI(componentId, userId, requirementDef,
1615 containerComponent.getComponentType());
1616 delOkResult.add(requirementCapabilityRelDef);
1618 } catch (ComponentException e) {
1622 unlockComponent(failed, containerComponent);
1627 public RequirementCapabilityRelDef dissociateRIFromRI(String componentId, String userId, RequirementCapabilityRelDef requirementDef,
1628 ComponentTypeEnum componentTypeEnum) {
1629 validateUserExists(userId);
1630 org.openecomp.sdc.be.model.Component containerComponent = validateComponentExists(componentId, componentTypeEnum, null);
1631 validateCanWorkOnComponent(containerComponent, userId);
1632 boolean failed = false;
1634 lockComponent(containerComponent, ASSOCIATE_RI_TO_RI);
1635 log.debug(TRY_TO_CREATE_ENTRY_ON_GRAPH);
1636 Either<RequirementCapabilityRelDef, StorageOperationStatus> result = toscaOperationFacade
1637 .dissociateResourceInstances(componentId, requirementDef);
1638 if (result.isLeft()) {
1639 log.debug(ENTITY_ON_GRAPH_IS_CREATED);
1640 return result.left().value();
1642 log.debug("Failed to dissocaite node {} from node {}", requirementDef.getFromNode(), requirementDef.getToNode());
1643 String fromNameOrId = "";
1644 String toNameOrId = "";
1645 Either<ComponentInstance, StorageOperationStatus> fromResult = getResourceInstanceById(containerComponent,
1646 requirementDef.getFromNode());
1647 Either<ComponentInstance, StorageOperationStatus> toResult = getResourceInstanceById(containerComponent, requirementDef.getToNode());
1648 toNameOrId = requirementDef.getFromNode();
1649 fromNameOrId = requirementDef.getFromNode();
1650 if (fromResult.isLeft()) {
1651 fromNameOrId = fromResult.left().value().getName();
1653 if (toResult.isLeft()) {
1654 toNameOrId = toResult.left().value().getName();
1656 throw new ByActionStatusComponentException(
1657 componentsUtils.convertFromStorageResponseForResourceInstance(result.right().value(), true), fromNameOrId, toNameOrId,
1658 requirementDef.getRelationships().get(0).getRelation().getRequirement());
1660 } catch (ComponentException e) {
1664 unlockComponent(failed, containerComponent);
1669 * Allows to get relation contained in specified component according to received Id
1671 * @param componentId
1674 * @param componentTypeEnum
1677 public Either<RequirementCapabilityRelDef, ResponseFormat> getRelationById(String componentId, String relationId, String userId,
1678 ComponentTypeEnum componentTypeEnum) {
1679 Either<RequirementCapabilityRelDef, ResponseFormat> resultOp = null;
1681 org.openecomp.sdc.be.model.Component containerComponent = null;
1682 RequirementCapabilityRelDef foundRelation = null;
1683 validateUserExists(userId);
1684 containerComponent = validateComponentExists(componentId, componentTypeEnum, null);
1685 List<RequirementCapabilityRelDef> requirementCapabilityRelations = containerComponent.getComponentInstancesRelations();
1686 foundRelation = findRelation(relationId, requirementCapabilityRelations);
1687 if (foundRelation == null) {
1688 ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.RELATION_NOT_FOUND, relationId, componentId);
1689 log.debug("Relation with id {} was not found on the component", relationId, componentId);
1690 resultOp = Either.right(responseFormat);
1692 if (resultOp == null) {
1693 resultOp = setRelatedCapability(foundRelation, containerComponent);
1695 if (resultOp.isLeft()) {
1696 resultOp = setRelatedRequirement(foundRelation, containerComponent);
1698 } catch (Exception e) {
1699 log.error("The exception {} occured upon get relation {} of the component {} ", e, relationId, componentId);
1700 resultOp = Either.right(componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR));
1705 private RequirementCapabilityRelDef findRelation(String relationId, List<RequirementCapabilityRelDef> requirementCapabilityRelations) {
1706 for (RequirementCapabilityRelDef relationship : requirementCapabilityRelations) {
1707 if (relationship.getRelationships().stream().anyMatch(r -> r.getRelation().getId().equals(relationId))) {
1708 return relationship;
1714 private Either<RequirementCapabilityRelDef, ResponseFormat> setRelatedRequirement(RequirementCapabilityRelDef foundRelation,
1715 Component containerComponent) {
1716 Either<RequirementCapabilityRelDef, ResponseFormat> result = null;
1717 RelationshipInfo relationshipInfo = foundRelation.resolveSingleRelationship().getRelation();
1718 String instanceId = foundRelation.getFromNode();
1719 Optional<RequirementDefinition> foundRequirement;
1720 Optional<ComponentInstance> instance = containerComponent.getComponentInstances().stream().filter(i -> i.getUniqueId().equals(instanceId))
1722 if (!instance.isPresent()) {
1723 ResponseFormat responseFormat = componentsUtils
1724 .getResponseFormat(ActionStatus.COMPONENT_INSTANCE_NOT_FOUND_ON_CONTAINER, instanceId, "instance",
1725 containerComponent.getComponentType().getValue(), containerComponent.getName());
1726 log.debug("Component instance with id {} was not found on the component", instanceId, containerComponent.getUniqueId());
1727 result = Either.right(responseFormat);
1729 if (result == null && instance.isPresent()) {
1730 for (List<RequirementDefinition> requirements : instance.get().getRequirements().values()) {
1731 foundRequirement = requirements.stream()
1732 .filter(r -> isBelongingCalcRequirement(relationshipInfo, r, containerComponent.getLifecycleState())).findFirst();
1733 if (foundRequirement.isPresent()) {
1734 foundRelation.resolveSingleRelationship().setRequirement(foundRequirement.get());
1735 result = Either.left(foundRelation);
1739 if (result == null) {
1740 Either<RequirementDataDefinition, StorageOperationStatus> getfulfilledRequirementRes = toscaOperationFacade
1741 .getFulfilledRequirementByRelation(containerComponent.getUniqueId(), instanceId, foundRelation, this::isBelongingFullRequirement);
1742 if (getfulfilledRequirementRes.isRight()) {
1743 ResponseFormat responseFormat = componentsUtils
1744 .getResponseFormat(ActionStatus.REQUIREMENT_OF_INSTANCE_NOT_FOUND_ON_CONTAINER, relationshipInfo.getRequirement(), instanceId,
1745 containerComponent.getUniqueId());
1746 log.debug("Requirement {} of instance {} was not found on the container {}. ", relationshipInfo.getCapability(), instanceId,
1747 containerComponent.getUniqueId());
1748 result = Either.right(responseFormat);
1750 foundRelation.resolveSingleRelationship().setRequirement(getfulfilledRequirementRes.left().value());
1753 if (result == null) {
1754 result = Either.left(foundRelation);
1759 private boolean isBelongingFullRequirement(RelationshipInfo relationshipInfo, RequirementDataDefinition req) {
1760 return req.getName().equals(relationshipInfo.getRequirement()) && req.getUniqueId().equals(relationshipInfo.getRequirementUid()) && req
1761 .getOwnerId().equals(relationshipInfo.getRequirementOwnerId());
1764 private boolean isBelongingCalcRequirement(RelationshipInfo relationshipInfo, RequirementDataDefinition req, LifecycleStateEnum state) {
1765 return nameMatches(relationshipInfo.getRequirement(), req.getName(), req.getPreviousName(), state) && req.getUniqueId()
1766 .equals(relationshipInfo.getRequirementUid()) && req.getOwnerId().equals(relationshipInfo.getRequirementOwnerId());
1769 private Either<RequirementCapabilityRelDef, ResponseFormat> setRelatedCapability(RequirementCapabilityRelDef foundRelation,
1770 Component containerComponent) {
1771 Either<RequirementCapabilityRelDef, ResponseFormat> result = null;
1772 RelationshipInfo relationshipInfo = foundRelation.resolveSingleRelationship().getRelation();
1773 String instanceId = foundRelation.getToNode();
1774 Optional<CapabilityDefinition> foundCapability;
1775 Optional<ComponentInstance> instance = containerComponent.getComponentInstances().stream().filter(i -> i.getUniqueId().equals(instanceId))
1777 if (!instance.isPresent()) {
1778 ResponseFormat responseFormat = componentsUtils
1779 .getResponseFormat(ActionStatus.COMPONENT_INSTANCE_NOT_FOUND_ON_CONTAINER, instanceId, "instance",
1780 containerComponent.getComponentType().getValue(), containerComponent.getName());
1781 log.debug("Component instance with id {} was not found on the component", instanceId, containerComponent.getUniqueId());
1782 result = Either.right(responseFormat);
1784 if (result == null && instance.isPresent()) {
1785 for (List<CapabilityDefinition> capabilities : instance.get().getCapabilities().values()) {
1786 foundCapability = capabilities.stream()
1787 .filter(c -> isBelongingCalcCapability(relationshipInfo, c, containerComponent.getLifecycleState())).findFirst();
1788 if (foundCapability.isPresent()) {
1789 foundRelation.resolveSingleRelationship().setCapability(foundCapability.get());
1790 result = Either.left(foundRelation);
1794 if (result == null) {
1795 Either<CapabilityDataDefinition, StorageOperationStatus> getfulfilledRequirementRes = toscaOperationFacade
1796 .getFulfilledCapabilityByRelation(containerComponent.getUniqueId(), instanceId, foundRelation, this::isBelongingFullCapability);
1797 if (getfulfilledRequirementRes.isRight()) {
1798 ResponseFormat responseFormat = componentsUtils
1799 .getResponseFormat(ActionStatus.CAPABILITY_OF_INSTANCE_NOT_FOUND_ON_CONTAINER, relationshipInfo.getCapability(), instanceId,
1800 containerComponent.getUniqueId());
1801 log.debug("Capability {} of instance {} was not found on the container {}. ", relationshipInfo.getCapability(), instanceId,
1802 containerComponent.getUniqueId());
1803 result = Either.right(responseFormat);
1805 foundRelation.resolveSingleRelationship().setCapability(getfulfilledRequirementRes.left().value());
1808 if (result == null) {
1809 result = Either.left(foundRelation);
1814 private boolean isBelongingFullCapability(RelationshipInfo relationshipInfo, CapabilityDataDefinition cap) {
1815 return cap.getName().equals(relationshipInfo.getCapability()) && cap.getUniqueId().equals(relationshipInfo.getCapabilityUid()) && cap
1816 .getOwnerId().equals(relationshipInfo.getCapabilityOwnerId());
1819 private boolean isBelongingCalcCapability(RelationshipInfo relationshipInfo, CapabilityDataDefinition cap, LifecycleStateEnum state) {
1820 return nameMatches(relationshipInfo.getCapability(), cap.getName(), cap.getPreviousName(), state) && cap.getUniqueId()
1821 .equals(relationshipInfo.getCapabilityUid()) && cap.getOwnerId().equals(relationshipInfo.getCapabilityOwnerId());
1824 private boolean nameMatches(String nameFromRelationship, String currName, String previousName, LifecycleStateEnum state) {
1825 return state == LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT ? currName.equals(nameFromRelationship)
1826 : previousName != null && previousName.equals(nameFromRelationship);
1829 private Either<ComponentInstanceProperty, ResponseFormat> updateAttributeValue(ComponentInstanceProperty attribute, String resourceInstanceId) {
1830 Either<ComponentInstanceProperty, StorageOperationStatus> eitherAttribute = componentInstanceOperation
1831 .updateAttributeValueInResourceInstance(attribute, resourceInstanceId, true);
1832 Either<ComponentInstanceProperty, ResponseFormat> result;
1833 if (eitherAttribute.isLeft()) {
1834 log.debug("Attribute value {} was updated on graph.", attribute.getValueUniqueUid());
1835 ComponentInstanceProperty instanceAttribute = eitherAttribute.left().value();
1836 result = Either.left(instanceAttribute);
1838 log.debug("Failed to update attribute value {} in resource instance {}", attribute, resourceInstanceId);
1839 ActionStatus actionStatus = componentsUtils.convertFromStorageResponseForResourceInstanceProperty(eitherAttribute.right().value());
1840 result = Either.right(componentsUtils.getResponseFormat(actionStatus, ""));
1845 private Either<ComponentInstanceProperty, ResponseFormat> createAttributeValue(ComponentInstanceProperty attribute, String resourceInstanceId) {
1846 Either<ComponentInstanceProperty, ResponseFormat> result;
1847 Wrapper<Integer> indexCounterWrapper = new Wrapper<>();
1848 Wrapper<ResponseFormat> errorWrapper = new Wrapper<>();
1849 validateIncrementCounter(resourceInstanceId, GraphPropertiesDictionary.ATTRIBUTE_COUNTER, indexCounterWrapper, errorWrapper);
1850 if (!errorWrapper.isEmpty()) {
1851 result = Either.right(errorWrapper.getInnerElement());
1853 Either<ComponentInstanceProperty, StorageOperationStatus> eitherAttribute = componentInstanceOperation
1854 .addAttributeValueToResourceInstance(attribute, resourceInstanceId, indexCounterWrapper.getInnerElement(), true);
1855 if (eitherAttribute.isLeft()) {
1856 log.debug("Attribute value was added to resource instance {}", resourceInstanceId);
1857 ComponentInstanceProperty instanceAttribute = eitherAttribute.left().value();
1858 result = Either.left(instanceAttribute);
1860 log.debug("Failed to add attribute value {} to resource instance {}", attribute, resourceInstanceId);
1861 ActionStatus actionStatus = componentsUtils.convertFromStorageResponseForResourceInstanceProperty(eitherAttribute.right().value());
1862 result = Either.right(componentsUtils.getResponseFormatForResourceInstanceProperty(actionStatus, ""));
1869 * Create Or Updates Attribute Instance
1871 * @param componentTypeEnum
1872 * @param componentId
1873 * @param resourceInstanceId
1878 public Either<ComponentInstanceProperty, ResponseFormat> createOrUpdateAttributeValue(ComponentTypeEnum componentTypeEnum, String componentId,
1879 String resourceInstanceId,
1880 ComponentInstanceProperty attribute, String userId) {
1881 Either<ComponentInstanceProperty, ResponseFormat> result = null;
1882 Wrapper<ResponseFormat> errorWrapper = new Wrapper<>();
1883 validateUserExists(userId);
1884 if (errorWrapper.isEmpty()) {
1885 validateComponentTypeEnum(componentTypeEnum, "CreateOrUpdateAttributeValue", errorWrapper);
1887 if (errorWrapper.isEmpty()) {
1888 validateCanWorkOnComponent(componentId, componentTypeEnum, userId, errorWrapper);
1890 if (errorWrapper.isEmpty()) {
1891 validateComponentLock(componentId, componentTypeEnum, errorWrapper);
1894 if (errorWrapper.isEmpty()) {
1895 final boolean isCreate = Objects.isNull(attribute.getValueUniqueUid());
1897 result = createAttributeValue(attribute, resourceInstanceId);
1899 result = updateAttributeValue(attribute, resourceInstanceId);
1902 result = Either.right(errorWrapper.getInnerElement());
1906 if (result == null || result.isRight()) {
1907 janusGraphDao.rollback();
1909 janusGraphDao.commit();
1912 graphLockOperation.unlockComponent(componentId, componentTypeEnum.getNodeType());
1916 public Either<List<ComponentInstanceProperty>, ResponseFormat> createOrUpdatePropertiesValues(ComponentTypeEnum componentTypeEnum,
1917 String componentId, String resourceInstanceId,
1918 List<ComponentInstanceProperty> properties,
1920 Either<List<ComponentInstanceProperty>, ResponseFormat> resultOp = null;
1921 /*-------------------------------Validations---------------------------------*/
1922 validateUserExists(userId);
1924 if (componentTypeEnum == null) {
1925 BeEcompErrorManager.getInstance().logInvalidInputError("CreateOrUpdatePropertiesValues", INVALID_COMPONENT_TYPE, ErrorSeverity.INFO);
1926 resultOp = Either.right(componentsUtils.getResponseFormat(ActionStatus.NOT_ALLOWED));
1929 Either<Component, StorageOperationStatus> getResourceResult = toscaOperationFacade.getToscaElement(componentId, JsonParseFlagEnum.ParseAll);
1931 if (getResourceResult.isRight()) {
1932 log.debug(FAILED_TO_RETRIEVE_COMPONENT_COMPONENT_ID, componentId);
1933 ActionStatus actionStatus = componentsUtils.convertFromStorageResponse(getResourceResult.right().value(), componentTypeEnum);
1934 return Either.right(componentsUtils.getResponseFormat(actionStatus, componentId));
1936 Component containerComponent = getResourceResult.left().value();
1938 if (!ComponentValidationUtils.canWorkOnComponent(containerComponent, userId)) {
1939 if (Boolean.TRUE.equals(containerComponent.isArchived())) {
1940 log.info(COMPONENT_ARCHIVED, componentId);
1941 return Either.right(componentsUtils.getResponseFormat(ActionStatus.COMPONENT_IS_ARCHIVED, containerComponent.getName()));
1943 log.info(RESTRICTED_OPERATION_ON_SERVIVE, userId, componentId);
1944 return Either.right(componentsUtils.getResponseFormat(ActionStatus.RESTRICTED_OPERATION));
1947 Either<ComponentInstance, StorageOperationStatus> resourceInstanceStatus = getResourceInstanceById(containerComponent, resourceInstanceId);
1948 if (resourceInstanceStatus.isRight()) {
1949 return Either.right(componentsUtils.getResponseFormat(ActionStatus.COMPONENT_INSTANCE_NOT_FOUND_ON_CONTAINER,
1950 resourceInstanceId, RESOURCE_INSTANCE, SERVICE, componentId));
1952 ComponentInstance foundResourceInstance = resourceInstanceStatus.left().value();
1955 StorageOperationStatus lockStatus = graphLockOperation.lockComponent(componentId, componentTypeEnum.getNodeType());
1956 if (lockStatus != StorageOperationStatus.OK) {
1957 log.debug(FAILED_TO_LOCK_SERVICE, componentId);
1958 return Either.right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(lockStatus)));
1960 List<ComponentInstanceProperty> updatedProperties = new ArrayList<>();
1962 for (ComponentInstanceProperty property : properties) {
1963 validateMandatoryFields(property);
1964 validatePropertyExistsOnComponent(property, containerComponent, foundResourceInstance);
1965 String propertyParentUniqueId = property.getParentUniqueId();
1966 if (property.isToscaFunction()) {
1967 toscaFunctionValidator.validate(property, containerComponent);
1968 property.setValue(property.getToscaFunction().getValue());
1970 Either<String, ResponseFormat> updatedPropertyValue = updatePropertyObjectValue(property, containerComponent.getModel());
1971 if (updatedPropertyValue.isRight()) {
1972 log.error("Failed to update property object value of property: {}",
1974 throw new ByResponseFormatComponentException(updatedPropertyValue.right().value());
1976 Optional<CapabilityDefinition>
1977 capPropDefinition = getPropertyCapabilityOfChildInstance(propertyParentUniqueId, foundResourceInstance.getCapabilities());
1978 if (capPropDefinition.isPresent()) {
1979 updatedPropertyValue
1980 .bimap(updatedValue -> updateCapabilityPropFromUpdateInstProp(property, updatedValue,
1981 containerComponent, foundResourceInstance, capPropDefinition.get().getType(),
1982 capPropDefinition.get().getName()), Either::right);
1984 updatedPropertyValue.bimap(
1985 updatedValue -> updatePropertyOnContainerComponent(property, updatedValue, containerComponent, foundResourceInstance),
1988 updatedProperties.add(property);
1992 Either<Component, StorageOperationStatus> updateContainerRes = toscaOperationFacade
1993 .updateComponentInstanceMetadataOfTopologyTemplate(containerComponent);
1994 if (updateContainerRes.isRight()) {
1995 ActionStatus actionStatus = componentsUtils.convertFromStorageResponseForResourceInstanceProperty(updateContainerRes.right().value());
1996 resultOp = Either.right(componentsUtils.getResponseFormatForResourceInstanceProperty(actionStatus, ""));
1999 resultOp = Either.left(updatedProperties);
2002 } catch (final ComponentException e) {
2003 return Either.right(e.getResponseFormat());
2005 if (resultOp == null || resultOp.isRight()) {
2006 janusGraphDao.rollback();
2008 janusGraphDao.commit();
2011 graphLockOperation.unlockComponent(componentId, componentTypeEnum.getNodeType());
2015 public Either<List<ComponentInstanceAttribute>, ResponseFormat> createOrUpdateAttributeValues(final ComponentTypeEnum componentTypeEnum,
2016 final String componentId,
2017 final String resourceInstanceId,
2018 final List<ComponentInstanceAttribute> attributes,
2019 final String userId) {
2020 Either<List<ComponentInstanceAttribute>, ResponseFormat> resultOp = null;
2021 /*-------------------------------Validations---------------------------------*/
2022 validateUserExists(userId);
2024 if (componentTypeEnum == null) {
2025 BeEcompErrorManager.getInstance().logInvalidInputError("CreateOrUpdatePropertiesValues", INVALID_COMPONENT_TYPE, ErrorSeverity.INFO);
2026 resultOp = Either.right(componentsUtils.getResponseFormat(ActionStatus.NOT_ALLOWED));
2029 final Either<Component, StorageOperationStatus> getResourceResult = toscaOperationFacade
2030 .getToscaElement(componentId, JsonParseFlagEnum.ParseAll);
2032 if (getResourceResult.isRight()) {
2033 log.debug(FAILED_TO_RETRIEVE_COMPONENT_COMPONENT_ID, componentId);
2034 final ActionStatus actionStatus = componentsUtils.convertFromStorageResponse(getResourceResult.right().value(), componentTypeEnum);
2035 return Either.right(componentsUtils.getResponseFormat(actionStatus, componentId));
2037 final Component containerComponent = getResourceResult.left().value();
2039 if (!ComponentValidationUtils.canWorkOnComponent(containerComponent, userId)) {
2040 if (Boolean.TRUE.equals(containerComponent.isArchived())) {
2041 log.info(COMPONENT_ARCHIVED, componentId);
2042 return Either.right(componentsUtils.getResponseFormat(ActionStatus.COMPONENT_IS_ARCHIVED, containerComponent.getName()));
2044 log.info(RESTRICTED_OPERATION_ON_SERVIVE, userId, componentId);
2045 return Either.right(componentsUtils.getResponseFormat(ActionStatus.RESTRICTED_OPERATION));
2048 final Either<ComponentInstance, StorageOperationStatus> resourceInstanceStatus = getResourceInstanceById(containerComponent,
2049 resourceInstanceId);
2050 if (resourceInstanceStatus.isRight()) {
2051 return Either.right(componentsUtils.getResponseFormat(ActionStatus.COMPONENT_INSTANCE_NOT_FOUND_ON_CONTAINER,
2052 resourceInstanceId, RESOURCE_INSTANCE, SERVICE, componentId));
2054 final ComponentInstance foundResourceInstance = resourceInstanceStatus.left().value();
2057 final StorageOperationStatus lockStatus = graphLockOperation.lockComponent(componentId, componentTypeEnum.getNodeType());
2058 if (lockStatus != StorageOperationStatus.OK) {
2059 log.debug(FAILED_TO_LOCK_SERVICE, componentId);
2060 return Either.right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(lockStatus)));
2062 final List<ComponentInstanceAttribute> updatedProperties = new ArrayList<>();
2064 for (final ComponentInstanceAttribute attribute : attributes) {
2065 final ComponentInstanceAttribute componentInstanceProperty = validateAttributeExistsOnComponent(attribute, containerComponent,
2066 foundResourceInstance);
2067 final Either<String, ResponseFormat> updatedPropertyValue = updateAttributeObjectValue(attribute);
2068 if (updatedPropertyValue.isRight()) {
2069 log.error("Failed to update attribute object value of attribute: {}", attribute);
2070 throw new ByResponseFormatComponentException(updatedPropertyValue.right().value());
2072 updatedPropertyValue.bimap(
2074 componentInstanceProperty.setValue(updatedValue);
2075 return updateAttributeOnContainerComponent(attribute, updatedValue,
2076 containerComponent, foundResourceInstance);
2078 updatedProperties.add(componentInstanceProperty);
2081 final Either<Component, StorageOperationStatus> updateContainerRes = toscaOperationFacade
2082 .updateComponentInstanceMetadataOfTopologyTemplate(containerComponent);
2083 if (updateContainerRes.isRight()) {
2084 final ActionStatus actionStatus = componentsUtils
2085 .convertFromStorageResponseForResourceInstanceProperty(updateContainerRes.right().value());
2086 resultOp = Either.right(componentsUtils.getResponseFormatForResourceInstanceProperty(actionStatus, ""));
2089 resultOp = Either.left(updatedProperties);
2092 } catch (final ComponentException e) {
2093 return Either.right(e.getResponseFormat());
2095 if (resultOp == null || resultOp.isRight()) {
2096 janusGraphDao.rollback();
2098 janusGraphDao.commit();
2101 graphLockOperation.unlockComponent(componentId, componentTypeEnum.getNodeType());
2105 private void validateMandatoryFields(PropertyDataDefinition property) {
2106 if (StringUtils.isEmpty(property.getName())) {
2107 throw new ByActionStatusComponentException(ActionStatus.MISSING_PROPERTY_NAME);
2111 private void validatePropertyExistsOnComponent(ComponentInstanceProperty property, Component containerComponent,
2112 ComponentInstance foundResourceInstance) {
2113 List<ComponentInstanceProperty> instanceProperties = containerComponent.getComponentInstancesProperties()
2114 .get(foundResourceInstance.getUniqueId());
2115 final boolean hasProperty = instanceProperties.stream().anyMatch(p -> p.getName().equals(property.getName()));
2117 throw new ByActionStatusComponentException(ActionStatus.PROPERTY_NOT_FOUND, property.getName());
2121 private ComponentInstanceAttribute validateAttributeExistsOnComponent(final ComponentInstanceAttribute attribute,
2122 final Component containerComponent,
2123 final ComponentInstance foundResourceInstance) {
2124 final List<ComponentInstanceAttribute> instanceProperties =
2125 containerComponent.getComponentInstancesAttributes().get(foundResourceInstance.getUniqueId());
2126 final Optional<ComponentInstanceAttribute> instanceAttribute =
2127 instanceProperties.stream().filter(p -> p.getName().equals(attribute.getName())).findAny();
2128 if (!instanceAttribute.isPresent()) {
2129 throw new ByActionStatusComponentException(ActionStatus.PROPERTY_NOT_FOUND, attribute.getName());
2131 return instanceAttribute.get();
2134 private ResponseFormat updateCapabilityPropertyOnContainerComponent(ComponentInstanceProperty property,
2135 String newValue, Component containerComponent,
2136 ComponentInstance foundResourceInstance,
2137 String capabilityType, String capabilityName) {
2138 String componentInstanceUniqueId = foundResourceInstance.getUniqueId();
2139 ResponseFormat actionStatus = updateCapPropOnContainerComponent(property, newValue, containerComponent,
2140 foundResourceInstance, capabilityType, capabilityName, componentInstanceUniqueId);
2141 if (actionStatus != null) {
2142 return actionStatus;
2145 return componentsUtils.getResponseFormat(ActionStatus.OK);
2148 private ResponseFormat updateCapabilityPropFromUpdateInstProp(ComponentInstanceProperty property,
2149 String newValue, Component containerComponent,
2150 ComponentInstance foundResourceInstance,
2151 String capabilityType, String capabilityName) {
2152 String componentInstanceUniqueId = foundResourceInstance.getUniqueId();
2153 Either<Component, StorageOperationStatus> getComponentRes =
2154 toscaOperationFacade.getToscaFullElement(foundResourceInstance.getComponentUid());
2155 if (getComponentRes.isRight()) {
2156 return componentsUtils.getResponseFormat(getComponentRes.right().value());
2159 ResponseFormat actionStatus = updateCapPropOnContainerComponent(property, newValue, containerComponent,
2160 foundResourceInstance, capabilityType, capabilityName, componentInstanceUniqueId);
2161 if (actionStatus != null) {
2162 return actionStatus;
2165 return componentsUtils.getResponseFormat(ActionStatus.OK);
2168 private ResponseFormat updateCapPropOnContainerComponent(ComponentInstanceProperty property, String newValue,
2169 Component containerComponent,
2170 ComponentInstance foundResourceInstance,
2171 String capabilityType, String capabilityName,
2172 String componentInstanceUniqueId) {
2173 Map<String, List<CapabilityDefinition>> capabilities =
2174 Optional.ofNullable(foundResourceInstance.getCapabilities()).orElse(Collections.emptyMap());
2175 List<CapabilityDefinition> capPerType =
2176 Optional.ofNullable(capabilities.get(capabilityType)).orElse(Collections.emptyList());
2177 Optional<CapabilityDefinition> cap =
2178 capPerType.stream().filter(c -> c.getName().equals(capabilityName)).findAny();
2179 if (cap.isPresent()) {
2180 List<ComponentInstanceProperty> capProperties = cap.get().getProperties();
2181 if (capProperties != null) {
2182 Optional<ComponentInstanceProperty> instanceProperty =
2183 capProperties.stream().filter(p -> p.getUniqueId().equals(property.getUniqueId())).findAny();
2184 StorageOperationStatus status;
2185 if (instanceProperty.isPresent()) {
2186 String capKey = ModelConverter
2187 .buildCapabilityPropertyKey(foundResourceInstance.getOriginType().isAtomicType(), capabilityType, capabilityName,
2188 componentInstanceUniqueId, cap.get());
2189 instanceProperty.get().setValue(newValue);
2190 List<String> path = new ArrayList<>();
2191 path.add(componentInstanceUniqueId);
2193 instanceProperty.get().setPath(path);
2194 status = toscaOperationFacade.updateComponentInstanceCapabiltyProperty(containerComponent,
2195 componentInstanceUniqueId, capKey, instanceProperty.get());
2196 if (status != StorageOperationStatus.OK) {
2197 ActionStatus actionStatus =
2198 componentsUtils.convertFromStorageResponseForResourceInstanceProperty(status);
2199 return componentsUtils.getResponseFormatForResourceInstanceProperty(actionStatus, "");
2202 foundResourceInstance.setCustomizationUUID(UUID.randomUUID().toString());
2209 private ResponseFormat updatePropertyOnContainerComponent(ComponentInstanceProperty instanceProperty, String newValue,
2210 Component containerComponent, ComponentInstance foundResourceInstance) {
2211 StorageOperationStatus status;
2212 instanceProperty.setValue(newValue);
2213 status = toscaOperationFacade.updateComponentInstanceProperty(containerComponent, foundResourceInstance.getUniqueId(), instanceProperty);
2214 if (status != StorageOperationStatus.OK) {
2215 ActionStatus actionStatus = componentsUtils.convertFromStorageResponseForResourceInstanceProperty(status);
2216 return componentsUtils.getResponseFormatForResourceInstanceProperty(actionStatus, "");
2218 foundResourceInstance.setCustomizationUUID(UUID.randomUUID().toString());
2219 return componentsUtils.getResponseFormat(ActionStatus.OK);
2222 private ResponseFormat updateAttributeOnContainerComponent(final ComponentInstanceAttribute instanceAttribute,
2223 final String newValue,
2224 final Component containerComponent,
2225 final ComponentInstance foundResourceInstance) {
2227 instanceAttribute.setValue(newValue);
2228 final StorageOperationStatus status =
2229 toscaOperationFacade.updateComponentInstanceAttribute(containerComponent, foundResourceInstance.getUniqueId(), instanceAttribute);
2230 if (status != StorageOperationStatus.OK) {
2231 final ActionStatus actionStatus = componentsUtils.convertFromStorageResponseForResourceInstanceProperty(status);
2232 return componentsUtils.getResponseFormatForResourceInstanceProperty(actionStatus, "");
2234 foundResourceInstance.setCustomizationUUID(UUID.randomUUID().toString());
2235 return componentsUtils.getResponseFormat(ActionStatus.OK);
2238 private <T extends PropertyDefinition> Either<String, ResponseFormat> validatePropertyObjectValue(T property, String newValue, boolean isInput) {
2239 final Map<String, DataTypeDefinition> allDataTypes = componentsUtils.getAllDataTypes(applicationDataTypeCache, property.getModel());
2240 String propertyType = property.getType();
2241 String innerType = getInnerType(property);
2243 // Specific Update Logic
2244 Either<Object, Boolean> isValid = propertyOperation
2245 .validateAndUpdatePropertyValue(property.getType(), newValue, true, innerType, allDataTypes);
2246 if (isValid.isRight()) {
2247 if (!Boolean.TRUE.equals(isValid.right().value())) {
2248 log.error("Invalid value {} of property {} ", newValue, property.getName());
2249 return Either.right(componentsUtils.getResponseFormat(ActionStatus.INVALID_CONTENT));
2252 Object object = isValid.left().value();
2253 if (object != null) {
2254 newValue = object.toString();
2257 if (validateAndUpdateRules(property, isInput, allDataTypes, innerType, propertyType)) {
2258 return Either.right(componentsUtils.getResponseFormat(componentsUtils
2259 .convertFromStorageResponse(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(JanusGraphOperationStatus.ILLEGAL_ARGUMENT))));
2261 return Either.left(newValue);
2264 private <T extends PropertyDefinition> boolean validateAndUpdateRules(T property, boolean isInput, Map<String, DataTypeDefinition> allDataTypes,
2265 String innerType, String propertyType) {
2267 ImmutablePair<String, Boolean> pair = propertyOperation
2268 .validateAndUpdateRules(propertyType, ((ComponentInstanceProperty) property).getRules(), innerType, allDataTypes, true);
2269 if (pair.getRight() != null && !pair.getRight()) {
2270 BeEcompErrorManager.getInstance().logBeInvalidValueError("Add property value", pair.getLeft(), property.getName(), propertyType);
2277 private <T extends PropertyDefinition> Either<String, ResponseFormat> updatePropertyObjectValue(T property, final String model) {
2278 final Map<String, DataTypeDefinition> allDataTypes = componentsUtils.getAllDataTypes(applicationDataTypeCache, model);
2279 String innerType = null;
2280 String propertyType = property.getType();
2281 ToscaPropertyType type = ToscaPropertyType.isValidType(propertyType);
2282 log.debug("The type of the property {} is {}", property.getUniqueId(), propertyType);
2284 if (type == ToscaPropertyType.LIST || type == ToscaPropertyType.MAP) {
2285 SchemaDefinition schema = property.getSchema();
2286 if (schema == null) {
2287 log.debug("Schema doesn't exists for property of type {}", type);
2289 .right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(StorageOperationStatus.INVALID_VALUE)));
2291 PropertyDataDefinition propDef = schema.getProperty();
2292 if (propDef == null) {
2293 log.debug("Property in Schema Definition inside property of type {} doesn't exist", type);
2295 .right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(StorageOperationStatus.INVALID_VALUE)));
2297 innerType = propDef.getType();
2300 // Specific Update Logic
2301 String newValue = property.getValue();
2303 if (property.hasToscaFunction()) {
2304 return Either.left(newValue);
2307 Either<Object, Boolean> isValid = propertyOperation
2308 .validateAndUpdatePropertyValue(propertyType, property.getValue(), true, innerType, allDataTypes);
2309 if (isValid.isRight()) {
2310 if (!Boolean.TRUE.equals(isValid.right().value())) {
2311 log.debug("validate and update property value has failed with value: {}", property.getValue());
2312 throw new ByActionStatusComponentException(componentsUtils.convertFromStorageResponse(
2313 DaoStatusConverter.convertJanusGraphStatusToStorageStatus(JanusGraphOperationStatus.ILLEGAL_ARGUMENT)));
2316 Object object = isValid.left().value();
2317 if (object != null) {
2318 newValue = object.toString();
2321 ImmutablePair<String, Boolean> pair = propertyOperation
2322 .validateAndUpdateRules(propertyType, ((ComponentInstanceProperty) property).getRules(), innerType, allDataTypes, true);
2323 if (pair.getRight() != null && Boolean.FALSE.equals(pair.getRight())) {
2324 BeEcompErrorManager.getInstance().logBeInvalidValueError("Add property value", pair.getLeft(), property.getName(), propertyType);
2325 return Either.right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(
2326 DaoStatusConverter.convertJanusGraphStatusToStorageStatus(JanusGraphOperationStatus.ILLEGAL_ARGUMENT))));
2328 return Either.left(newValue);
2331 private <T extends AttributeDefinition> Either<String, ResponseFormat> updateAttributeObjectValue(final T attribute) {
2332 String innerType = null;
2333 final String attributeType = attribute.getType();
2334 final ToscaPropertyType type = ToscaPropertyType.isValidType(attributeType);
2335 log.debug("The type of the attribute {} is {}", attribute.getUniqueId(), attributeType);
2337 if (type == ToscaPropertyType.LIST || type == ToscaPropertyType.MAP) {
2338 final SchemaDefinition def = attribute.getSchema();
2340 log.debug("Schema doesn't exists for attribute of type {}", type);
2342 .right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(StorageOperationStatus.INVALID_VALUE)));
2344 PropertyDataDefinition propDef = def.getProperty();
2345 if (propDef == null) {
2346 log.debug("Property in Schema Definition inside attribute of type {} doesn't exist", type);
2348 .right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(StorageOperationStatus.INVALID_VALUE)));
2350 innerType = propDef.getType();
2353 // Specific Update Logic
2354 String newValue = attribute.getValue();
2356 final var isValid = attributeOperation.validateAndUpdateAttributeValue(attribute, innerType,
2357 componentsUtils.getAllDataTypes(applicationDataTypeCache, attribute.getModel()));
2358 if (isValid.isRight()) {
2359 final Boolean res = isValid.right().value();
2360 if (!Boolean.TRUE.equals(res)) {
2361 log.debug("validate and update attribute value has failed with value: {}", newValue);
2362 throw new ByActionStatusComponentException(componentsUtils.convertFromStorageResponse(
2363 DaoStatusConverter.convertJanusGraphStatusToStorageStatus(JanusGraphOperationStatus.ILLEGAL_ARGUMENT)));
2366 final Object object = isValid.left().value();
2367 if (object != null) {
2368 newValue = object.toString();
2371 return Either.left(newValue);
2374 private <T extends PropertyDefinition> void validateToscaGetFunction(T property, Component parentComponent) {
2375 final ToscaGetFunctionDataDefinition toscaGetFunction = (ToscaGetFunctionDataDefinition) property.getToscaFunction();
2376 validateGetToscaFunctionAttributes(toscaGetFunction);
2377 validateGetPropertySource(toscaGetFunction.getFunctionType(), toscaGetFunction.getPropertySource());
2378 if (toscaGetFunction.getFunctionType() == ToscaGetFunctionType.GET_INPUT) {
2379 validateGetFunction(property, parentComponent.getInputs(), parentComponent.getModel());
2382 if (toscaGetFunction.getFunctionType() == ToscaGetFunctionType.GET_PROPERTY) {
2383 if (toscaGetFunction.getPropertySource() == PropertySource.SELF) {
2384 validateGetFunction(property, parentComponent.getProperties(), parentComponent.getModel());
2385 } else if (toscaGetFunction.getPropertySource() == PropertySource.INSTANCE) {
2386 final ComponentInstance componentInstance =
2387 parentComponent.getComponentInstanceById(toscaGetFunction.getSourceUniqueId())
2388 .orElseThrow(ToscaGetFunctionExceptionSupplier.instanceNotFound(toscaGetFunction.getSourceName()));
2389 validateGetFunction(property, componentInstance.getProperties(), parentComponent.getModel());
2394 if (toscaGetFunction.getFunctionType() == ToscaGetFunctionType.GET_ATTRIBUTE) {
2395 if (toscaGetFunction.getPropertySource() == PropertySource.SELF) {
2396 validateGetFunction(property, parentComponent.getAttributes(), parentComponent.getModel());
2397 } else if (toscaGetFunction.getPropertySource() == PropertySource.INSTANCE) {
2398 final ComponentInstance componentInstance =
2399 parentComponent.getComponentInstanceById(toscaGetFunction.getSourceUniqueId())
2400 .orElseThrow(ToscaGetFunctionExceptionSupplier.instanceNotFound(toscaGetFunction.getSourceName()));
2401 validateGetFunction(property, componentInstance.getAttributes(), parentComponent.getModel());
2407 throw ToscaGetFunctionExceptionSupplier.functionNotSupported(toscaGetFunction.getFunctionType()).get();
2410 private <T extends PropertyDefinition> void validateGetFunction(final T property,
2411 final List<? extends ToscaPropertyData> parentProperties,
2412 final String model) {
2413 final ToscaGetFunctionDataDefinition toscaGetFunction = (ToscaGetFunctionDataDefinition) property.getToscaFunction();
2414 if (CollectionUtils.isEmpty(parentProperties)) {
2415 throw ToscaGetFunctionExceptionSupplier
2416 .propertyNotFoundOnTarget(toscaGetFunction.getPropertyName(), toscaGetFunction.getPropertySource(),
2417 toscaGetFunction.getFunctionType()
2420 final String getFunctionPropertyUniqueId = toscaGetFunction.getPropertyUniqueId();
2421 ToscaPropertyData referredProperty = parentProperties.stream()
2422 .filter(property1 -> getFunctionPropertyUniqueId.equals(property1.getUniqueId()))
2424 .orElseThrow(ToscaGetFunctionExceptionSupplier
2425 .propertyNotFoundOnTarget(toscaGetFunction.getPropertyName(), toscaGetFunction.getPropertySource()
2426 , toscaGetFunction.getFunctionType())
2428 if (toscaGetFunction.isSubProperty()) {
2429 referredProperty = findSubProperty(referredProperty, toscaGetFunction, model);
2432 if (!property.getType().equals(referredProperty.getType())) {
2433 throw ToscaGetFunctionExceptionSupplier
2434 .propertyTypeDiverge(toscaGetFunction.getType(), referredProperty.getType(), property.getType()).get();
2436 if (PropertyType.typeHasSchema(referredProperty.getType()) && !referredProperty.getSchemaType().equals(property.getSchemaType())) {
2437 throw ToscaGetFunctionExceptionSupplier
2438 .propertySchemaDiverge(toscaGetFunction.getType(), referredProperty.getSchemaType(), property.getSchemaType()).get();
2442 private ToscaPropertyData findSubProperty(final ToscaPropertyData referredProperty,
2443 final ToscaGetFunctionDataDefinition toscaGetFunction,
2444 final String model) {
2445 final Map<String, DataTypeDefinition> dataTypeMap = loadDataTypes(model);
2446 final List<String> propertyPathFromSource = toscaGetFunction.getPropertyPathFromSource();
2447 DataTypeDefinition dataType = dataTypeMap.get(referredProperty.getType());
2448 if (dataType == null) {
2449 throw ToscaGetFunctionExceptionSupplier
2450 .propertyDataTypeNotFound(propertyPathFromSource.get(0), referredProperty.getType(), toscaGetFunction.getFunctionType()).get();
2452 ToscaPropertyData foundProperty = referredProperty;
2453 for (int i = 1; i < propertyPathFromSource.size(); i++) {
2454 final String currentPropertyName = propertyPathFromSource.get(i);
2455 foundProperty = dataType.getProperties().stream()
2456 .filter(propertyDefinition -> currentPropertyName.equals(propertyDefinition.getName())).findFirst()
2458 ToscaGetFunctionExceptionSupplier
2459 .propertyNotFoundOnTarget(propertyPathFromSource.subList(0, i), toscaGetFunction.getPropertySource(),
2460 toscaGetFunction.getFunctionType())
2462 dataType = dataTypeMap.get(foundProperty.getType());
2463 if (dataType == null) {
2464 throw ToscaGetFunctionExceptionSupplier
2465 .propertyDataTypeNotFound(propertyPathFromSource.subList(0, i), foundProperty.getType(),
2466 toscaGetFunction.getFunctionType()).get();
2469 return foundProperty;
2472 private Map<String, DataTypeDefinition> loadDataTypes(String model) {
2473 final Either<Map<String, DataTypeDefinition>, JanusGraphOperationStatus> dataTypeEither =
2474 applicationDataTypeCache.getAll(model);
2475 if (dataTypeEither.isRight()) {
2476 throw ToscaGetFunctionExceptionSupplier.couldNotLoadDataTypes(model).get();
2478 return dataTypeEither.left().value();
2481 private void validateGetPropertySource(final ToscaGetFunctionType functionType, final PropertySource propertySource) {
2482 if (functionType == ToscaGetFunctionType.GET_INPUT && propertySource != PropertySource.SELF) {
2483 throw ToscaGetFunctionExceptionSupplier
2484 .targetSourceNotSupported(functionType, propertySource).get();
2486 if (functionType == ToscaGetFunctionType.GET_PROPERTY && !List.of(PropertySource.SELF, PropertySource.INSTANCE).contains(propertySource)) {
2487 throw ToscaGetFunctionExceptionSupplier
2488 .targetSourceNotSupported(functionType, propertySource).get();
2492 private void validateGetToscaFunctionAttributes(final ToscaGetFunctionDataDefinition toscaGetFunction) {
2493 if (toscaGetFunction.getFunctionType() == null) {
2494 throw ToscaGetFunctionExceptionSupplier.targetFunctionTypeNotFound().get();
2496 if (toscaGetFunction.getPropertySource() == null) {
2497 throw ToscaGetFunctionExceptionSupplier.targetPropertySourceNotFound(toscaGetFunction.getFunctionType()).get();
2499 if (CollectionUtils.isEmpty(toscaGetFunction.getPropertyPathFromSource())) {
2500 throw ToscaGetFunctionExceptionSupplier
2501 .targetSourcePathNotFound(toscaGetFunction.getFunctionType()).get();
2503 if (StringUtils.isEmpty(toscaGetFunction.getSourceName()) || StringUtils.isBlank(toscaGetFunction.getSourceName())) {
2504 throw ToscaGetFunctionExceptionSupplier.sourceNameNotFound(toscaGetFunction.getPropertySource()).get();
2506 if (StringUtils.isEmpty(toscaGetFunction.getSourceUniqueId()) || StringUtils.isBlank(toscaGetFunction.getSourceUniqueId())) {
2507 throw ToscaGetFunctionExceptionSupplier.sourceIdNotFound(toscaGetFunction.getPropertySource()).get();
2509 if (StringUtils.isEmpty(toscaGetFunction.getPropertyName()) || StringUtils.isBlank(toscaGetFunction.getPropertyName())) {
2510 throw ToscaGetFunctionExceptionSupplier.propertyNameNotFound(toscaGetFunction.getPropertySource()).get();
2512 if (StringUtils.isEmpty(toscaGetFunction.getPropertyUniqueId()) || StringUtils.isBlank(toscaGetFunction.getPropertyUniqueId())) {
2513 throw ToscaGetFunctionExceptionSupplier.propertyIdNotFound(toscaGetFunction.getPropertySource()).get();
2517 private ResponseFormat updateInputOnContainerComponent(ComponentInstanceInput input, String newValue, Component containerComponent,
2518 ComponentInstance foundResourceInstance) {
2519 StorageOperationStatus status;
2520 input.setValue(newValue);
2521 status = toscaOperationFacade.updateComponentInstanceInput(containerComponent, foundResourceInstance.getUniqueId(), input);
2522 if (status != StorageOperationStatus.OK) {
2523 ActionStatus actionStatus = componentsUtils.convertFromStorageResponseForResourceInstanceProperty(status);
2524 return componentsUtils.getResponseFormatForResourceInstanceProperty(actionStatus, "");
2526 foundResourceInstance.setCustomizationUUID(UUID.randomUUID().toString());
2527 return componentsUtils.getResponseFormat(ActionStatus.OK);
2530 public Either<List<ComponentInstanceInput>, ResponseFormat> createOrUpdateInstanceInputValues(ComponentTypeEnum componentTypeEnum,
2531 String componentId, String resourceInstanceId,
2532 List<ComponentInstanceInput> inputs,
2535 Either<List<ComponentInstanceInput>, ResponseFormat> resultOp = null;
2537 validateUserExists(userId);
2539 if (componentTypeEnum == null) {
2540 BeEcompErrorManager.getInstance().logInvalidInputError(CREATE_OR_UPDATE_PROPERTY_VALUE, INVALID_COMPONENT_TYPE, ErrorSeverity.INFO);
2541 resultOp = Either.right(componentsUtils.getResponseFormat(ActionStatus.NOT_ALLOWED));
2544 Either<Component, StorageOperationStatus> getResourceResult = toscaOperationFacade.getToscaElement(componentId, JsonParseFlagEnum.ParseAll);
2546 if (getResourceResult.isRight()) {
2547 log.debug(FAILED_TO_RETRIEVE_COMPONENT_COMPONENT_ID, componentId);
2548 ActionStatus actionStatus = componentsUtils.convertFromStorageResponse(getResourceResult.right().value(), componentTypeEnum);
2549 return Either.right(componentsUtils.getResponseFormat(actionStatus, componentId));
2551 Component containerComponent = getResourceResult.left().value();
2553 if (!ComponentValidationUtils.canWorkOnComponent(containerComponent, userId)) {
2554 if (Boolean.TRUE.equals(containerComponent.isArchived())) {
2555 log.info(COMPONENT_ARCHIVED, componentId);
2556 return Either.right(componentsUtils.getResponseFormat(ActionStatus.COMPONENT_IS_ARCHIVED, containerComponent.getName()));
2558 log.info(RESTRICTED_OPERATION_ON_SERVIVE, userId, componentId);
2559 resultOp = Either.right(componentsUtils.getResponseFormat(ActionStatus.RESTRICTED_OPERATION));
2562 Either<ComponentInstance, StorageOperationStatus> resourceInstanceStatus = getResourceInstanceById(containerComponent, resourceInstanceId);
2563 if (resourceInstanceStatus.isRight()) {
2564 return Either.right(componentsUtils.getResponseFormat(ActionStatus.COMPONENT_INSTANCE_NOT_FOUND_ON_CONTAINER,
2565 resourceInstanceId, RESOURCE_INSTANCE, SERVICE, componentId));
2568 ComponentInstance foundResourceInstance = resourceInstanceStatus.left().value();
2571 StorageOperationStatus lockStatus = graphLockOperation.lockComponent(componentId, componentTypeEnum.getNodeType());
2572 if (lockStatus != StorageOperationStatus.OK) {
2573 log.debug(FAILED_TO_LOCK_SERVICE, componentId);
2574 return Either.right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(lockStatus)));
2576 List<ComponentInstanceInput> updatedInputs = new ArrayList<>();
2578 for (ComponentInstanceInput input : inputs) {
2579 validateMandatoryFields(input);
2580 ComponentInstanceInput componentInstanceInput = validateInputExistsOnComponent(input, containerComponent, foundResourceInstance);
2581 Either<String, ResponseFormat> validatedInputValue = validatePropertyObjectValue(componentInstanceInput, input.getValue(), true);
2582 if (validatedInputValue.isRight()) {
2583 throw new ByActionStatusComponentException(ActionStatus.INVALID_CONTENT, input.getName());
2585 updateInputOnContainerComponent(componentInstanceInput, validatedInputValue.left().value(), containerComponent,
2586 foundResourceInstance);
2587 updatedInputs.add(componentInstanceInput);
2589 Either<Component, StorageOperationStatus> updateContainerRes = toscaOperationFacade
2590 .updateComponentInstanceMetadataOfTopologyTemplate(containerComponent);
2591 if (updateContainerRes.isRight()) {
2592 ActionStatus actionStatus = componentsUtils.convertFromStorageResponseForResourceInstanceProperty(updateContainerRes.right().value());
2593 resultOp = Either.right(componentsUtils.getResponseFormatForResourceInstanceProperty(actionStatus, ""));
2596 resultOp = Either.left(updatedInputs);
2600 if (resultOp == null || resultOp.isRight()) {
2601 janusGraphDao.rollback();
2603 janusGraphDao.commit();
2606 graphLockOperation.unlockComponent(componentId, componentTypeEnum.getNodeType());
2611 private ComponentInstanceInput validateInputExistsOnComponent(ComponentInstanceInput input, Component containerComponent,
2612 ComponentInstance foundResourceInstance) {
2613 List<ComponentInstanceInput> instanceProperties = containerComponent.getComponentInstancesInputs().get(foundResourceInstance.getUniqueId());
2614 Optional<ComponentInstanceInput> instanceInput = instanceProperties.stream().filter(p -> p.getName().equals(input.getName())).findAny();
2615 if (!instanceInput.isPresent()) {
2616 throw new ByActionStatusComponentException(ActionStatus.PROPERTY_NOT_FOUND, input.getName());
2618 return instanceInput.get();
2621 public Either<ComponentInstanceProperty, ResponseFormat> createOrUpdateGroupInstancePropertyValue(ComponentTypeEnum componentTypeEnum,
2622 String componentId, String resourceInstanceId,
2623 String groupInstanceId,
2624 ComponentInstanceProperty property,
2627 Either<ComponentInstanceProperty, ResponseFormat> resultOp = null;
2629 validateUserExists(userId);
2631 if (componentTypeEnum == null) {
2632 BeEcompErrorManager.getInstance().logInvalidInputError(CREATE_OR_UPDATE_PROPERTY_VALUE, INVALID_COMPONENT_TYPE, ErrorSeverity.INFO);
2633 resultOp = Either.right(componentsUtils.getResponseFormat(ActionStatus.NOT_ALLOWED));
2637 if (!ComponentValidationUtils.canWorkOnComponent(componentId, toscaOperationFacade, userId)) {
2638 log.info("Restricted operation for user: {} on service: {}", userId, componentId);
2639 resultOp = Either.right(componentsUtils.getResponseFormat(ActionStatus.RESTRICTED_OPERATION));
2643 StorageOperationStatus lockStatus = graphLockOperation.lockComponent(componentId, componentTypeEnum.getNodeType());
2644 if (lockStatus != StorageOperationStatus.OK) {
2645 log.debug(FAILED_TO_LOCK_SERVICE, componentId);
2646 resultOp = Either.right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(lockStatus)));
2650 String propertyValueUid = property.getValueUniqueUid();
2652 if (propertyValueUid == null) {
2654 Either<Integer, StorageOperationStatus> counterRes = groupInstanceOperation
2655 .increaseAndGetGroupInstancePropertyCounter(groupInstanceId);
2657 if (counterRes.isRight()) {
2658 log.debug("increaseAndGetResourcePropertyCounter failed resource instance: {} property: {}", resourceInstanceId, property);
2659 StorageOperationStatus status = counterRes.right().value();
2660 ActionStatus actionStatus = componentsUtils.convertFromStorageResponseForResourceInstanceProperty(status);
2661 resultOp = Either.right(componentsUtils.getResponseFormat(actionStatus));
2663 Integer index = counterRes.left().value();
2664 Either<ComponentInstanceProperty, StorageOperationStatus> result = groupInstanceOperation
2665 .addPropertyValueToGroupInstance(property, resourceInstanceId, index, true);
2667 if (result.isLeft()) {
2668 log.trace("Property value was added to resource instance {}", resourceInstanceId);
2669 ComponentInstanceProperty instanceProperty = result.left().value();
2671 resultOp = Either.left(instanceProperty);
2674 log.debug("Failed to add property value: {} to resource instance {}", property, resourceInstanceId);
2676 ActionStatus actionStatus = componentsUtils.convertFromStorageResponseForResourceInstanceProperty(result.right().value());
2678 resultOp = Either.right(componentsUtils.getResponseFormatForResourceInstanceProperty(actionStatus, ""));
2682 Either<ComponentInstanceProperty, StorageOperationStatus> result = groupInstanceOperation
2683 .updatePropertyValueInGroupInstance(property, resourceInstanceId, true);
2685 if (result.isLeft()) {
2686 log.debug("Property value {} was updated on graph.", property.getValueUniqueUid());
2687 ComponentInstanceProperty instanceProperty = result.left().value();
2689 resultOp = Either.left(instanceProperty);
2692 log.debug("Failed to update property value: {}, in resource instance {}", property, resourceInstanceId);
2694 ActionStatus actionStatus = componentsUtils.convertFromStorageResponseForResourceInstanceProperty(result.right().value());
2696 resultOp = Either.right(componentsUtils.getResponseFormatForResourceInstanceProperty(actionStatus, ""));
2699 if (resultOp.isLeft()) {
2700 StorageOperationStatus updateCustomizationUUID = componentInstanceOperation.updateCustomizationUUID(resourceInstanceId);
2701 if (updateCustomizationUUID != StorageOperationStatus.OK) {
2702 ActionStatus actionStatus = componentsUtils.convertFromStorageResponseForResourceInstanceProperty(updateCustomizationUUID);
2704 resultOp = Either.right(componentsUtils.getResponseFormatForResourceInstanceProperty(actionStatus, ""));
2711 if (resultOp == null || resultOp.isRight()) {
2712 janusGraphDao.rollback();
2714 janusGraphDao.commit();
2717 graphLockOperation.unlockComponent(componentId, componentTypeEnum.getNodeType());
2722 public Either<ComponentInstanceProperty, ResponseFormat> deletePropertyValue(ComponentTypeEnum componentTypeEnum, String serviceId,
2723 String resourceInstanceId, String propertyValueId, String userId) {
2725 validateUserExists(userId);
2727 Either<ComponentInstanceProperty, ResponseFormat> resultOp = null;
2729 if (componentTypeEnum == null) {
2730 BeEcompErrorManager.getInstance().logInvalidInputError(CREATE_OR_UPDATE_PROPERTY_VALUE, INVALID_COMPONENT_TYPE, ErrorSeverity.INFO);
2731 resultOp = Either.right(componentsUtils.getResponseFormat(ActionStatus.NOT_ALLOWED));
2735 if (!ComponentValidationUtils.canWorkOnComponent(serviceId, toscaOperationFacade, userId)) {
2736 log.info("Restricted operation for user {} on service {}", userId, serviceId);
2737 resultOp = Either.right(componentsUtils.getResponseFormat(ActionStatus.RESTRICTED_OPERATION));
2741 StorageOperationStatus lockStatus = graphLockOperation.lockComponent(serviceId, componentTypeEnum.getNodeType());
2742 if (lockStatus != StorageOperationStatus.OK) {
2743 log.debug(FAILED_TO_LOCK_SERVICE, serviceId);
2744 resultOp = Either.right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(lockStatus)));
2748 Either<ComponentInstanceProperty, StorageOperationStatus> result = propertyOperation
2749 .removePropertyValueFromResourceInstance(propertyValueId, resourceInstanceId, true);
2751 if (result.isLeft()) {
2752 log.debug("Property value {} was removed from graph.", propertyValueId);
2753 ComponentInstanceProperty instanceProperty = result.left().value();
2755 resultOp = Either.left(instanceProperty);
2759 log.debug("Failed to remove property value {} in resource instance {}", propertyValueId, resourceInstanceId);
2761 ActionStatus actionStatus = componentsUtils.convertFromStorageResponseForResourceInstanceProperty(result.right().value());
2763 resultOp = Either.right(componentsUtils.getResponseFormatForResourceInstanceProperty(actionStatus, ""));
2769 if (resultOp == null || resultOp.isRight()) {
2770 janusGraphDao.rollback();
2772 janusGraphDao.commit();
2775 graphLockOperation.unlockComponent(serviceId, componentTypeEnum.getNodeType());
2780 private Component getAndValidateOriginComponentOfComponentInstance(Component containerComponent, ComponentInstance componentInstance) {
2782 ComponentTypeEnum componentType = getComponentTypeByParentComponentType(containerComponent.getComponentType());
2783 Component component;
2784 Either<Component, StorageOperationStatus> getComponentRes = toscaOperationFacade.getToscaFullElement(componentInstance.getComponentUid());
2785 if (getComponentRes.isRight()) {
2786 log.debug("Failed to get the component with id {} for component instance {} creation. ", componentInstance.getComponentUid(),
2787 componentInstance.getName());
2788 ActionStatus actionStatus = componentsUtils.convertFromStorageResponse(getComponentRes.right().value(), componentType);
2789 throw new ByActionStatusComponentException(actionStatus, Constants.EMPTY_STRING);
2791 component = getComponentRes.left().value();
2792 LifecycleStateEnum resourceCurrState = component.getLifecycleState();
2793 if (resourceCurrState == LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT) {
2794 ActionStatus actionStatus = ActionStatus.CONTAINER_CANNOT_CONTAIN_COMPONENT_IN_STATE;
2795 throw new ByActionStatusComponentException(actionStatus, containerComponent.getComponentType().toString(), resourceCurrState.toString());
2797 if (Boolean.TRUE.equals(component.isArchived())) {
2798 ActionStatus actionStatus = ActionStatus.COMPONENT_IS_ARCHIVED;
2799 throw new ByActionStatusComponentException(actionStatus, component.getName());
2801 final Map<String, InterfaceDefinition> componentInterfaces = component.getInterfaces();
2802 if (MapUtils.isNotEmpty(componentInterfaces)) {
2803 componentInterfaces.forEach(componentInstance::addInterface);
2808 public Either<Set<String>, ResponseFormat> forwardingPathOnVersionChange(String containerComponentParam,
2809 String containerComponentId,
2810 String componentInstanceId,
2811 ComponentInstance newComponentInstance) {
2812 Either<Set<String>, ResponseFormat> resultOp;
2813 final ComponentTypeEnum containerComponentType = validateComponentType(containerComponentParam);
2814 ComponentParametersView componentParametersView = getComponentParametersViewForForwardingPath();
2817 Component containerComponent = validateComponentExists(containerComponentId, containerComponentType, componentParametersView);
2819 //Fetch current component instance
2820 Either<ComponentInstance, StorageOperationStatus> eitherResourceInstance =
2821 getResourceInstanceById(containerComponent, componentInstanceId);
2822 if (eitherResourceInstance.isRight()) {
2823 resultOp = Either.right(componentsUtils.getResponseFormat(
2824 ActionStatus.RESOURCE_INSTANCE_NOT_FOUND_ON_SERVICE, componentInstanceId, containerComponentId));
2827 ComponentInstance currentResourceInstance = eitherResourceInstance.left().value();
2829 //Check whether new componentInstance exists
2830 String resourceId = newComponentInstance.getComponentUid();
2831 Either<Boolean, StorageOperationStatus> componentExistsRes = toscaOperationFacade.validateComponentExists(resourceId);
2832 if (componentExistsRes.isRight()) {
2833 log.debug("Failed to find resource {}", resourceId);
2834 resultOp = Either.right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse
2835 (componentExistsRes.right().value()), resourceId));
2837 } else if (!Boolean.TRUE.equals(componentExistsRes.left().value())) {
2838 log.debug("The resource {} not found ", resourceId);
2839 resultOp = Either.right(componentsUtils.getResponseFormat(ActionStatus.RESOURCE_NOT_FOUND, resourceId));
2843 //Fetch component using new component instance uid
2844 Component updatedContainerComponent = getOriginComponentFromComponentInstance(newComponentInstance);
2845 Set<String> toDeleteForwardingPaths = getForwardingPaths(containerComponent,
2846 currentResourceInstance, updatedContainerComponent);
2847 resultOp = Either.left(toDeleteForwardingPaths);
2852 private Set<String> getForwardingPaths(Component containerComponent, ComponentInstance currentResourceInstance,
2853 Component updatedContainerComponent) {
2854 DataForMergeHolder dataForMergeHolder = new DataForMergeHolder();
2855 dataForMergeHolder.setOrigComponentInstId(currentResourceInstance.getName());
2857 Service service = (Service) containerComponent;
2858 ForwardingPathUtils forwardingPathUtils = new ForwardingPathUtils();
2860 return forwardingPathUtils.
2861 getForwardingPathsToBeDeletedOnVersionChange(service, dataForMergeHolder, updatedContainerComponent);
2864 private ComponentParametersView getComponentParametersViewForForwardingPath() {
2865 ComponentParametersView componentParametersView = new ComponentParametersView();
2866 componentParametersView.setIgnoreCapabiltyProperties(false);
2867 componentParametersView.setIgnoreServicePath(false);
2868 return componentParametersView;
2871 public ComponentInstance changeComponentInstanceVersion(String containerComponentParam, String containerComponentId, String componentInstanceId,
2872 String userId, ComponentInstance newComponentInstance) {
2874 User user = validateUserExists(userId);
2875 final ComponentTypeEnum containerComponentType = validateComponentType(containerComponentParam);
2876 ComponentParametersView componentParametersView = new ComponentParametersView();
2877 componentParametersView.setIgnoreCapabiltyProperties(false);
2879 org.openecomp.sdc.be.model.Component containerComponent = validateComponentExists(containerComponentId, containerComponentType,
2880 componentParametersView);
2882 validateCanWorkOnComponent(containerComponent, userId);
2884 Either<ComponentInstance, StorageOperationStatus> resourceInstanceStatus = getResourceInstanceById(containerComponent, componentInstanceId);
2885 if (resourceInstanceStatus.isRight()) {
2886 throw new ByActionStatusComponentException(ActionStatus.RESOURCE_INSTANCE_NOT_FOUND_ON_SERVICE, componentInstanceId,
2887 containerComponentId);
2890 ComponentInstance currentResourceInstance = resourceInstanceStatus.left().value();
2892 return changeInstanceVersion(containerComponent, currentResourceInstance, newComponentInstance, user, containerComponentType);
2895 public ComponentInstance changeInstanceVersion(org.openecomp.sdc.be.model.Component containerComponent,
2896 ComponentInstance currentResourceInstance,
2897 ComponentInstance newComponentInstance,
2899 final ComponentTypeEnum containerComponentType) {
2900 boolean failed = false;
2901 Either<ComponentInstance, StorageOperationStatus> resourceInstanceStatus;
2904 lockComponent(containerComponent, "changeComponentInstanceVersion");
2905 String containerComponentId = containerComponent.getUniqueId();
2906 String componentInstanceId = currentResourceInstance.getUniqueId();
2907 if (currentResourceInstance.getComponentUid().equals(newComponentInstance.getComponentUid())) {
2908 return currentResourceInstance;
2910 String resourceId = newComponentInstance.getComponentUid();
2912 Either<Boolean, StorageOperationStatus> componentExistsRes = toscaOperationFacade
2913 .validateComponentExists(resourceId);
2914 if (componentExistsRes.isRight()) {
2915 StorageOperationStatus errorStatus = componentExistsRes.right().value();
2917 log.debug("Failed to validate existing of the component {}. Status is {} ", resourceId, errorStatus);
2918 throw new ByActionStatusComponentException(
2919 componentsUtils.convertFromStorageResponse(errorStatus), resourceId);
2920 } else if (!Boolean.TRUE.equals(componentExistsRes.left().value())) {
2921 log.debug("The resource {} not found ", resourceId);
2922 throw new ByActionStatusComponentException(ActionStatus.RESOURCE_NOT_FOUND, resourceId);
2925 Component eitherOriginComponent = getInstanceOriginNode(currentResourceInstance);
2926 DataForMergeHolder dataHolder = compInstMergeDataBL
2927 .saveAllDataBeforeDeleting(containerComponent, currentResourceInstance, eitherOriginComponent);
2928 ComponentInstance resResourceInfo = deleteComponentInstance(containerComponent, componentInstanceId,
2929 containerComponentType);
2931 if (resResourceInfo == null) {
2932 log.error("Calling `deleteComponentInstance` for the resource {} returned a null", resourceId);
2933 throw new ByActionStatusComponentException(ActionStatus.RESOURCE_NOT_FOUND, resourceId);
2935 Component origComponent = null;
2936 OriginTypeEnum originType = currentResourceInstance.getOriginType();
2937 newComponentInstance.setOriginType(originType);
2938 if (originType == OriginTypeEnum.ServiceProxy) {
2939 Either<Component, StorageOperationStatus> serviceProxyOrigin = toscaOperationFacade
2940 .getLatestByName(SERVICE_PROXY, null);
2941 if (isServiceProxyOrigin(serviceProxyOrigin)) {
2942 throw new ByActionStatusComponentException(
2943 componentsUtils.convertFromStorageResponse(serviceProxyOrigin.right().value()));
2945 origComponent = serviceProxyOrigin.left().value();
2947 StorageOperationStatus fillProxyRes = fillInstanceData(newComponentInstance, origComponent);
2949 if (isFillProxyRes(fillProxyRes)) {
2950 throw new ByActionStatusComponentException(
2951 componentsUtils.convertFromStorageResponse(fillProxyRes));
2953 } else if (originType == OriginTypeEnum.ServiceSubstitution) {
2954 final Either<Component, StorageOperationStatus> getServiceResult = toscaOperationFacade
2955 .getToscaFullElement(newComponentInstance.getComponentUid());
2956 if (getServiceResult.isRight()) {
2957 throw new ByActionStatusComponentException(componentsUtils.convertFromStorageResponse(getServiceResult.right().value()));
2959 final Component service = getServiceResult.left().value();
2961 final Either<Component, StorageOperationStatus> getServiceDerivedFromTypeResult = toscaOperationFacade
2962 .getLatestByToscaResourceName(service.getDerivedFromGenericType(), service.getModel());
2963 if (getServiceDerivedFromTypeResult.isRight()) {
2964 throw new ByActionStatusComponentException(componentsUtils.convertFromStorageResponse(getServiceResult.right().value()));
2967 origComponent = getServiceDerivedFromTypeResult.left().value();
2969 final StorageOperationStatus fillProxyRes = fillInstanceData(newComponentInstance, origComponent);
2970 if (isFillProxyRes(fillProxyRes)) {
2971 throw new ByActionStatusComponentException(
2972 componentsUtils.convertFromStorageResponse(fillProxyRes));
2975 origComponent = getOriginComponentFromComponentInstance(newComponentInstance);
2976 newComponentInstance.setName(resResourceInfo.getName());
2977 final Map<String, InterfaceDefinition> componentInterfaces = origComponent.getInterfaces();
2978 if (MapUtils.isNotEmpty(componentInterfaces)) {
2979 componentInterfaces.forEach(newComponentInstance::addInterface);
2983 newComponentInstance.setInvariantName(resResourceInfo.getInvariantName());
2984 newComponentInstance.setPosX(resResourceInfo.getPosX());
2985 newComponentInstance.setPosY(resResourceInfo.getPosY());
2986 newComponentInstance.setDescription(resResourceInfo.getDescription());
2987 newComponentInstance.setInstanceCount(resResourceInfo.getInstanceCount());
2988 newComponentInstance.setMaxOccurrences(resResourceInfo.getMaxOccurrences());
2989 newComponentInstance.setMinOccurrences(resResourceInfo.getMinOccurrences());
2990 newComponentInstance.setDirectives(resResourceInfo.getDirectives());
2991 checkForExternalReqAndCapabilities(origComponent, resResourceInfo);
2993 ComponentInstance updatedComponentInstance =
2994 createComponentInstanceOnGraph(containerComponent, origComponent, newComponentInstance, user);
2995 dataHolder.setCurrInstanceNode(origComponent);
2997 .mergeComponentUserOrigData(user, dataHolder, containerComponent, containerComponentId, newComponentInstance.getUniqueId());
2999 ActionStatus postChangeVersionResult = onChangeInstanceOperationOrchestrator
3000 .doPostChangeVersionOperations(containerComponent, currentResourceInstance, newComponentInstance);
3001 if (postChangeVersionResult != ActionStatus.OK) {
3002 throw new ByActionStatusComponentException(postChangeVersionResult);
3005 ComponentParametersView filter = new ComponentParametersView(true);
3006 filter.setIgnoreComponentInstances(false);
3007 Either<Component, StorageOperationStatus> updatedComponentRes = toscaOperationFacade.getToscaElement(containerComponentId, filter);
3008 if (updatedComponentRes.isRight()) {
3009 StorageOperationStatus storageOperationStatus = updatedComponentRes.right().value();
3010 ActionStatus actionStatus = componentsUtils
3011 .convertFromStorageResponse(storageOperationStatus, containerComponent.getComponentType());
3012 log.debug("Component with id {} was not found", containerComponentId);
3013 throw new ByActionStatusComponentException(actionStatus, Constants.EMPTY_STRING);
3016 maintainNodeFilters(currentResourceInstance, newComponentInstance, containerComponentId);
3018 resourceInstanceStatus = getResourceInstanceById(updatedComponentRes.left().value(),
3019 updatedComponentInstance.getUniqueId());
3020 if (resourceInstanceStatus.isRight()) {
3021 throw new ByActionStatusComponentException(componentsUtils.convertFromStorageResponse
3022 (resourceInstanceStatus.right().value()), updatedComponentInstance.getUniqueId());
3024 return resourceInstanceStatus.left().value();
3026 } catch (ComponentException e) {
3030 unlockComponent(failed, containerComponent);
3034 private void maintainNodeFilters(
3035 ComponentInstance currentResourceInstance,
3036 ComponentInstance newComponentInstance,
3037 String containerComponentId) {
3038 CINodeFilterDataDefinition filterToMaintain = currentResourceInstance.getNodeFilter();
3039 if (null != filterToMaintain) {
3040 nodeFilterOperation.addNodeFilterData(
3041 containerComponentId.toLowerCase(),
3042 newComponentInstance.getUniqueId(),
3047 private void checkForExternalReqAndCapabilities(Component component, ComponentInstance resResourceInfo) {
3048 Map<String, List<RequirementDefinition>> requirementsMap = resResourceInfo.getRequirements();
3049 Map<String, List<RequirementDefinition>> externalRequirementsMap = new HashMap<>();
3050 List<RequirementDefinition> externalRequirementList = new ArrayList<>();
3051 if (requirementsMap != null && !requirementsMap.isEmpty()) {
3052 requirementsMap.forEach((type, requirementDefinitions) -> {
3053 if (requirementDefinitions != null && !requirementDefinitions.isEmpty()) {
3054 for (final RequirementDefinition requirementDefinition : requirementDefinitions) {
3055 if (requirementDefinition.isExternal()) {
3056 externalRequirementList.add(requirementDefinition);
3057 externalRequirementsMap.put(type, externalRequirementList);
3064 Map<String, List<CapabilityDefinition>> capabilitiesMap = resResourceInfo.getCapabilities();
3065 Map<String, List<CapabilityDefinition>> externalCapabilitiesMap = new HashMap<>();
3066 List<CapabilityDefinition> externalCapabilitiesList = new ArrayList<>();
3067 if (capabilitiesMap != null && !capabilitiesMap.isEmpty()) {
3068 capabilitiesMap.forEach((type, capabilityDefinitions) -> {
3069 if (capabilityDefinitions != null && !capabilityDefinitions.isEmpty()) {
3070 for (final CapabilityDefinition capabilityDefinition : capabilityDefinitions) {
3071 if (capabilityDefinition.isExternal()) {
3072 externalCapabilitiesList.add(capabilityDefinition);
3073 externalCapabilitiesMap.put(type, externalCapabilitiesList);
3079 component.setCapabilities(externalCapabilitiesMap);
3080 component.setRequirements(externalRequirementsMap);
3083 private boolean isFillProxyRes(StorageOperationStatus fillProxyRes) {
3084 if (fillProxyRes != StorageOperationStatus.OK) {
3085 log.debug("Failed to fill service proxy resource data with data from service, error {}", fillProxyRes);
3092 public List<ComponentInstanceProperty> getComponentInstancePropertiesById(String containerComponentTypeParam, String containerComponentId,
3093 String componentInstanceUniqueId, String userId) {
3094 Component containerComponent = null;
3096 boolean failed = false;
3098 validateUserExists(userId);
3099 validateComponentType(containerComponentTypeParam);
3101 Either<Component, StorageOperationStatus> validateContainerComponentExists = toscaOperationFacade.getToscaElement(containerComponentId);
3102 if (validateContainerComponentExists.isRight()) {
3103 throw new ByActionStatusComponentException(
3104 componentsUtils.convertFromStorageResponse(validateContainerComponentExists.right().value()));
3106 containerComponent = validateContainerComponentExists.left().value();
3108 Either<ComponentInstance, StorageOperationStatus> resourceInstanceStatus = getResourceInstanceById(containerComponent,
3109 componentInstanceUniqueId);
3110 if (resourceInstanceStatus.isRight()) {
3111 throw new ByActionStatusComponentException(ActionStatus.RESOURCE_INSTANCE_NOT_FOUND_ON_SERVICE, componentInstanceUniqueId,
3112 containerComponentId);
3115 List<ComponentInstanceProperty> instanceProperties = containerComponent.getComponentInstancesProperties().get(componentInstanceUniqueId);
3116 if (CollectionUtils.isEmpty(instanceProperties)) {
3117 instanceProperties = new ArrayList<>();
3119 return instanceProperties;
3120 } catch (ComponentException e) {
3124 unlockComponent(failed, containerComponent);
3128 public List<ComponentInstanceAttribute> getComponentInstanceAttributesById(final String containerComponentTypeParam,
3129 final String containerComponentId,
3130 final String componentInstanceUniqueId,
3131 final String userId) {
3132 Component containerComponent = null;
3134 boolean failed = false;
3136 validateUserExists(userId);
3137 validateComponentType(containerComponentTypeParam);
3139 final Either<Component, StorageOperationStatus> validateContainerComponentExists =
3140 toscaOperationFacade.getToscaElement(containerComponentId);
3141 if (validateContainerComponentExists.isRight()) {
3142 throw new ByActionStatusComponentException(
3143 componentsUtils.convertFromStorageResponse(validateContainerComponentExists.right().value()));
3145 containerComponent = validateContainerComponentExists.left().value();
3147 if (getResourceInstanceById(containerComponent, componentInstanceUniqueId).isRight()) {
3148 throw new ByActionStatusComponentException(
3149 ActionStatus.RESOURCE_INSTANCE_NOT_FOUND_ON_SERVICE, componentInstanceUniqueId, containerComponentId);
3152 final Map<String, List<ComponentInstanceAttribute>> componentInstancesAttributes = containerComponent.getComponentInstancesAttributes();
3153 return componentInstancesAttributes == null ? new ArrayList<>()
3154 : componentInstancesAttributes.getOrDefault(componentInstanceUniqueId, new ArrayList<>());
3155 } catch (final ComponentException e) {
3159 unlockComponent(failed, containerComponent);
3163 protected void validateIncrementCounter(String resourceInstanceId, GraphPropertiesDictionary counterType,
3164 Wrapper<Integer> instaceCounterWrapper,
3165 Wrapper<ResponseFormat> errorWrapper) {
3166 Either<Integer, StorageOperationStatus> counterRes = componentInstanceOperation
3167 .increaseAndGetResourceInstanceSpecificCounter(resourceInstanceId, counterType, true);
3169 if (counterRes.isRight()) {
3170 log.debug("increase And Get {} failed resource instance {}", counterType, resourceInstanceId);
3171 StorageOperationStatus status = counterRes.right().value();
3172 ActionStatus actionStatus = componentsUtils.convertFromStorageResponseForResourceInstanceProperty(status);
3173 errorWrapper.setInnerElement(componentsUtils.getResponseFormat(actionStatus));
3175 instaceCounterWrapper.setInnerElement(counterRes.left().value());
3181 * updates componentInstance modificationTime
3183 * @param componentInstance
3184 * @param componentInstanceType
3185 * @param modificationTime
3186 * @param inTransaction
3189 public Either<ComponentInstanceData, ResponseFormat> updateComponentInstanceModificationTimeAndCustomizationUuid(
3190 ComponentInstance componentInstance, NodeTypeEnum componentInstanceType, Long modificationTime, boolean inTransaction) {
3191 Either<ComponentInstanceData, ResponseFormat> result;
3192 Either<ComponentInstanceData, StorageOperationStatus> updateComponentInstanceRes = componentInstanceOperation
3193 .updateComponentInstanceModificationTimeAndCustomizationUuidOnGraph(componentInstance, componentInstanceType, modificationTime,
3195 if (updateComponentInstanceRes.isRight()) {
3196 log.debug("Failed to update component instance {} with new last update date and mofifier. Status is {}. ", componentInstance.getName(),
3197 updateComponentInstanceRes.right().value());
3199 .right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(updateComponentInstanceRes.right().value())));
3201 result = Either.left(updateComponentInstanceRes.left().value());
3206 public Either<ComponentInstance, ResponseFormat> deleteServiceProxy() {
3207 // TODO Add implementation
3208 return Either.left(new ComponentInstance());
3211 public Either<ComponentInstance, ResponseFormat> createServiceProxy() {
3212 // TODO Add implementation
3213 return Either.left(new ComponentInstance());
3216 public Either<ComponentInstance, ResponseFormat> changeServiceProxyVersion() {
3217 // TODO Add implementation
3218 return Either.left(new ComponentInstance());
3221 private Boolean validateInstanceNameUniquenessUponUpdate(Component containerComponent, ComponentInstance oldComponentInstance,
3222 String newInstanceName) {
3223 return ComponentValidations.validateNameIsUniqueInComponent(oldComponentInstance.getName(), newInstanceName, containerComponent);
3226 private Either<ComponentInstance, StorageOperationStatus> getResourceInstanceById(final Component containerComponent, final String instanceId) {
3227 final List<ComponentInstance> instances = containerComponent.getComponentInstances();
3228 if (CollectionUtils.isEmpty(instances)) {
3229 return Either.right(StorageOperationStatus.NOT_FOUND);
3232 final Optional<ComponentInstance> foundInstance = instances.stream().filter(i -> i.getUniqueId().equals(instanceId)).findFirst();
3233 if (foundInstance.isEmpty()) {
3234 return Either.right(StorageOperationStatus.NOT_FOUND);
3237 return Either.left(foundInstance.get());
3240 private ComponentInstance buildComponentInstance(ComponentInstance resourceInstanceForUpdate, ComponentInstance origInstanceForUpdate) {
3241 Long creationDate = origInstanceForUpdate.getCreationTime();
3242 Long modificationTime = System.currentTimeMillis();
3243 resourceInstanceForUpdate.setCreationTime(creationDate);
3244 resourceInstanceForUpdate.setModificationTime(modificationTime);
3245 resourceInstanceForUpdate.setCustomizationUUID(origInstanceForUpdate.getCustomizationUUID());
3246 if (StringUtils.isEmpty(resourceInstanceForUpdate.getName()) && StringUtils.isNotEmpty(origInstanceForUpdate.getName())) {
3247 resourceInstanceForUpdate.setName(origInstanceForUpdate.getName());
3249 resourceInstanceForUpdate.setNormalizedName(ValidationUtils.normalizeComponentInstanceName(resourceInstanceForUpdate.getName()));
3250 if (StringUtils.isEmpty(resourceInstanceForUpdate.getIcon())) {
3251 resourceInstanceForUpdate.setIcon(origInstanceForUpdate.getIcon());
3253 if (StringUtils.isEmpty(resourceInstanceForUpdate.getComponentVersion())) {
3254 resourceInstanceForUpdate.setComponentVersion(origInstanceForUpdate.getComponentVersion());
3256 if (StringUtils.isEmpty(resourceInstanceForUpdate.getComponentName())) {
3257 resourceInstanceForUpdate.setComponentName(origInstanceForUpdate.getComponentName());
3259 if (StringUtils.isEmpty(resourceInstanceForUpdate.getToscaComponentName())) {
3260 resourceInstanceForUpdate.setToscaComponentName(origInstanceForUpdate.getToscaComponentName());
3262 if (resourceInstanceForUpdate.getOriginType() == null) {
3263 resourceInstanceForUpdate.setOriginType(origInstanceForUpdate.getOriginType());
3265 if (resourceInstanceForUpdate.getOriginType() == OriginTypeEnum.ServiceProxy) {
3266 resourceInstanceForUpdate.setIsProxy(true);
3268 if (resourceInstanceForUpdate.getSourceModelInvariant() == null) {
3269 resourceInstanceForUpdate.setSourceModelInvariant(origInstanceForUpdate.getSourceModelInvariant());
3271 if (resourceInstanceForUpdate.getSourceModelName() == null) {
3272 resourceInstanceForUpdate.setSourceModelName(origInstanceForUpdate.getSourceModelName());
3274 if (resourceInstanceForUpdate.getSourceModelUuid() == null) {
3275 resourceInstanceForUpdate.setSourceModelUuid(origInstanceForUpdate.getSourceModelUuid());
3277 if (resourceInstanceForUpdate.getSourceModelUid() == null) {
3278 resourceInstanceForUpdate.setSourceModelUid(origInstanceForUpdate.getSourceModelUid());
3280 if (resourceInstanceForUpdate.getCreatedFrom() == null) {
3281 resourceInstanceForUpdate.setCreatedFrom(origInstanceForUpdate.getCreatedFrom());
3283 return resourceInstanceForUpdate;
3287 * Returns list of ComponentInstanceProperty belonging to component instance capability specified by name, type and ownerId
3289 * @param containerComponentType
3290 * @param containerComponentId
3291 * @param componentInstanceUniqueId
3292 * @param capabilityType
3293 * @param capabilityName
3298 public List<ComponentInstanceProperty> getComponentInstanceCapabilityPropertiesById(String containerComponentType, String containerComponentId,
3299 String componentInstanceUniqueId, String capabilityType,
3300 String capabilityName, String ownerId, String userId) {
3301 Component containerComponent = null;
3302 List<ComponentInstanceProperty> resultOp = null;
3304 validateUserExists(userId);
3305 validateComponentType(containerComponentType);
3306 containerComponent = toscaOperationFacade.getToscaFullElement(containerComponentId).left().on(this::componentException);
3307 ComponentInstance resourceInstanceStatus = getResourceInstanceById(containerComponent, componentInstanceUniqueId).left()
3308 .on(this::componentInstanceException);
3309 resultOp = findCapabilityOfInstance(containerComponentId, componentInstanceUniqueId, capabilityType, capabilityName, ownerId,
3310 resourceInstanceStatus.getCapabilities());
3311 } catch (StorageException | ComponentException e) {
3312 unlockRollbackWithException(containerComponent, e);
3313 } catch (Exception e) {
3314 unlockRollbackWithException(containerComponent, new ByActionStatusComponentException(ActionStatus.GENERAL_ERROR));
3316 unlockWithCommit(containerComponent);
3320 private List<ComponentInstanceProperty> findCapabilityOfInstance(String componentId, String instanceId, String capabilityType,
3321 String capabilityName, String ownerId,
3322 Map<String, List<CapabilityDefinition>> instanceCapabilities) {
3323 CapabilityDefinition foundCapability;
3324 if (MapUtils.isNotEmpty(instanceCapabilities)) {
3325 List<CapabilityDefinition> capabilitiesPerType = instanceCapabilities.get(capabilityType);
3326 if (capabilitiesPerType != null) {
3327 Optional<CapabilityDefinition> capabilityOpt = capabilitiesPerType.stream()
3328 .filter(c -> c.getName().equals(capabilityName) && c.getOwnerId().equals(ownerId)).findFirst();
3329 if (capabilityOpt.isPresent()) {
3330 foundCapability = capabilityOpt.get();
3331 return foundCapability.getProperties() == null ? new ArrayList<>() : foundCapability.getProperties();
3335 return fetchComponentInstanceCapabilityProperties(componentId, instanceId, capabilityType, capabilityName, ownerId);
3338 private List<ComponentInstanceProperty> fetchComponentInstanceCapabilityProperties(String componentId, String instanceId, String capabilityType,
3339 String capabilityName, String ownerId) {
3341 return toscaOperationFacade.getComponentInstanceCapabilityProperties(componentId, instanceId, capabilityName, capabilityType, ownerId)
3342 .left().on(this::componentInstancePropertyListException);
3343 } catch (Exception e) {
3344 log.debug("The exception {} occurred upon the component {} instance {} capability {} properties retrieving. ", componentId, instanceId,
3346 throw new ByActionStatusComponentException(ActionStatus.GENERAL_ERROR);
3350 public Either<RequirementDefinition, ResponseFormat> updateInstanceRequirement(ComponentTypeEnum componentTypeEnum, String containerComponentId,
3351 String componentInstanceUniqueId,
3352 RequirementDefinition requirementDef, String userId) {
3353 Either<RequirementDefinition, ResponseFormat> resultOp = null;
3354 validateUserExists(userId);
3355 if (componentTypeEnum == null) {
3356 BeEcompErrorManager.getInstance().logInvalidInputError("updateInstanceRequirement", INVALID_COMPONENT_TYPE, ErrorSeverity.INFO);
3357 return Either.right(componentsUtils.getResponseFormat(ActionStatus.NOT_ALLOWED));
3359 Either<Component, StorageOperationStatus> getResourceResult = toscaOperationFacade.getToscaFullElement(containerComponentId);
3360 if (getResourceResult.isRight()) {
3361 log.debug(FAILED_TO_RETRIEVE_COMPONENT_COMPONENT_ID, containerComponentId);
3362 return Either.right(componentsUtils.getResponseFormat(ActionStatus.RESTRICTED_OPERATION));
3364 Component containerComponent = getResourceResult.left().value();
3365 if (!ComponentValidationUtils.canWorkOnComponent(containerComponent, userId)) {
3366 log.info(RESTRICTED_OPERATION_ON_COMPONENT, userId, containerComponentId);
3367 return Either.right(componentsUtils.getResponseFormat(ActionStatus.RESTRICTED_OPERATION));
3369 Either<ComponentInstance, StorageOperationStatus> resourceInstanceStatus = getResourceInstanceById(containerComponent,
3370 componentInstanceUniqueId);
3371 if (resourceInstanceStatus.isRight()) {
3372 return Either.right(componentsUtils
3373 .getResponseFormat(ActionStatus.RESOURCE_INSTANCE_NOT_FOUND_ON_SERVICE, componentInstanceUniqueId, containerComponentId));
3376 StorageOperationStatus lockStatus = graphLockOperation.lockComponent(containerComponentId, componentTypeEnum.getNodeType());
3377 if (lockStatus != StorageOperationStatus.OK) {
3378 log.debug(FAILED_TO_LOCK_COMPONENT, containerComponentId);
3379 return Either.right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(lockStatus)));
3382 StorageOperationStatus updateRequirementStatus = toscaOperationFacade
3383 .updateComponentInstanceRequirement(containerComponentId, componentInstanceUniqueId, requirementDef);
3384 if (updateRequirementStatus != StorageOperationStatus.OK) {
3385 log.debug("Failed to update component instance requirement on instance {} in container {}", componentInstanceUniqueId,
3386 containerComponentId);
3387 return Either.right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(updateRequirementStatus)));
3389 Either<Component, StorageOperationStatus> updateContainerRes = toscaOperationFacade
3390 .updateComponentInstanceMetadataOfTopologyTemplate(containerComponent);
3391 if (updateContainerRes.isRight()) {
3392 ActionStatus actionStatus = componentsUtils.convertFromStorageResponseForResourceInstanceProperty(updateContainerRes.right().value());
3393 resultOp = Either.right(componentsUtils.getResponseFormatForResourceInstanceProperty(actionStatus, ""));
3396 resultOp = Either.left(requirementDef);
3399 if (resultOp == null || resultOp.isRight()) {
3400 janusGraphDao.rollback();
3402 janusGraphDao.commit();
3405 graphLockOperation.unlockComponent(containerComponentId, componentTypeEnum.getNodeType());
3409 public Either<CapabilityDefinition, ResponseFormat> updateInstanceCapability(final ComponentTypeEnum containerComponentType,
3410 final String containerComponentId,
3411 final String componentInstanceUniqueId,
3412 final CapabilityDefinition capabilityDefinition,
3413 final String userId) {
3414 if (containerComponentType == null) {
3415 BeEcompErrorManager.getInstance().logInvalidInputError("updateInstanceCapability", INVALID_COMPONENT_TYPE, ErrorSeverity.INFO);
3416 return Either.right(componentsUtils.getResponseFormat(ActionStatus.NOT_ALLOWED));
3418 validateUserExists(userId);
3419 final Either<Component, StorageOperationStatus> getResourceResult = toscaOperationFacade.getToscaFullElement(containerComponentId);
3420 if (getResourceResult.isRight()) {
3421 log.debug(FAILED_TO_RETRIEVE_COMPONENT_COMPONENT_ID, containerComponentId);
3422 return Either.right(componentsUtils.getResponseFormat(ActionStatus.COMPONENT_NOT_FOUND, containerComponentId));
3424 final Component containerComponent = getResourceResult.left().value();
3425 if (!ComponentValidationUtils.canWorkOnComponent(containerComponent, userId)) {
3426 log.info(RESTRICTED_OPERATION_ON_COMPONENT, userId, containerComponentId);
3427 return Either.right(componentsUtils.getResponseFormat(ActionStatus.RESTRICTED_OPERATION));
3429 final Either<ComponentInstance, StorageOperationStatus> resourceInstanceStatus =
3430 getResourceInstanceById(containerComponent, componentInstanceUniqueId);
3431 if (resourceInstanceStatus.isRight()) {
3432 return Either.right(componentsUtils
3433 .getResponseFormat(ActionStatus.RESOURCE_INSTANCE_NOT_FOUND_ON_SERVICE, componentInstanceUniqueId, containerComponentId));
3436 final StorageOperationStatus lockStatus = graphLockOperation.lockComponent(containerComponentId, containerComponentType.getNodeType());
3437 if (lockStatus != StorageOperationStatus.OK) {
3438 log.debug(FAILED_TO_LOCK_COMPONENT, containerComponentId);
3439 return Either.right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(lockStatus)));
3441 var success = false;
3443 final CapabilityDataDefinition updatedCapabilityDefinition = toscaOperationFacade
3444 .updateComponentInstanceCapability(containerComponentId, componentInstanceUniqueId, capabilityDefinition);
3445 final Either<Component, StorageOperationStatus> updateContainerEither = toscaOperationFacade
3446 .updateComponentInstanceMetadataOfTopologyTemplate(containerComponent);
3447 if (updateContainerEither.isRight()) {
3448 var actionStatus = componentsUtils.convertFromStorageResponse(updateContainerEither.right().value(), containerComponentType);
3449 return Either.right(componentsUtils.getResponseFormat(actionStatus));
3452 return Either.left(new CapabilityDefinition(updatedCapabilityDefinition));
3453 } catch (final BusinessException e) {
3454 log.error(EcompLoggerErrorCode.BUSINESS_PROCESS_ERROR, NodeTemplateOperation.class.getName(), (ErrorLogOptionalData) null,
3455 FAILED_TO_UPDATE_COMPONENT_INSTANCE_CAPABILITY, componentInstanceUniqueId, containerComponentId);
3457 } catch (final Exception e) {
3458 log.error(EcompLoggerErrorCode.BUSINESS_PROCESS_ERROR, NodeTemplateOperation.class.getName(), (ErrorLogOptionalData) null,
3459 FAILED_TO_UPDATE_COMPONENT_INSTANCE_CAPABILITY, componentInstanceUniqueId, containerComponentId);
3460 throw new ByResponseFormatComponentException(componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR));
3463 janusGraphDao.commit();
3465 janusGraphDao.rollback();
3468 graphLockOperation.unlockComponent(containerComponentId, containerComponentType.getNodeType());
3472 public Either<List<ComponentInstanceProperty>, ResponseFormat> updateInstanceCapabilityProperties(ComponentTypeEnum componentTypeEnum,
3473 String containerComponentId,
3474 String componentInstanceUniqueId,
3475 String capabilityType, String capabilityName,
3476 List<ComponentInstanceProperty> properties,
3478 Either<List<ComponentInstanceProperty>, ResponseFormat> resultOp = null;
3479 validateUserExists(userId);
3480 if (componentTypeEnum == null) {
3481 BeEcompErrorManager.getInstance().logInvalidInputError("updateInstanceCapabilityProperty", INVALID_COMPONENT_TYPE, ErrorSeverity.INFO);
3482 return Either.right(componentsUtils.getResponseFormat(ActionStatus.NOT_ALLOWED));
3484 Either<Component, StorageOperationStatus> getResourceResult = toscaOperationFacade.getToscaFullElement(containerComponentId);
3485 if (getResourceResult.isRight()) {
3486 log.debug(FAILED_TO_RETRIEVE_COMPONENT_COMPONENT_ID, containerComponentId);
3487 return Either.right(componentsUtils.getResponseFormat(ActionStatus.RESTRICTED_OPERATION));
3489 Component containerComponent = getResourceResult.left().value();
3490 if (!ComponentValidationUtils.canWorkOnComponent(containerComponent, userId)) {
3491 log.info(RESTRICTED_OPERATION_ON_COMPONENT, userId, containerComponentId);
3492 return Either.right(componentsUtils.getResponseFormat(ActionStatus.RESTRICTED_OPERATION));
3494 Either<ComponentInstance, StorageOperationStatus> resourceInstanceStatus = getResourceInstanceById(containerComponent,
3495 componentInstanceUniqueId);
3496 if (resourceInstanceStatus.isRight()) {
3497 return Either.right(componentsUtils
3498 .getResponseFormat(ActionStatus.RESOURCE_INSTANCE_NOT_FOUND_ON_SERVICE, componentInstanceUniqueId, containerComponentId));
3500 ComponentInstance foundResourceInstance = resourceInstanceStatus.left().value();
3502 StorageOperationStatus lockStatus = graphLockOperation.lockComponent(containerComponentId, componentTypeEnum.getNodeType());
3503 if (lockStatus != StorageOperationStatus.OK) {
3504 log.debug(FAILED_TO_LOCK_COMPONENT, containerComponentId);
3505 return Either.right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(lockStatus)));
3508 for (ComponentInstanceProperty property : properties) {
3509 Either<String, ResponseFormat> newPropertyValueEither = validatePropertyObjectValue(property, property.getValue(), false);
3510 newPropertyValueEither.bimap(
3511 updatedValue -> updateCapabilityPropertyOnContainerComponent(property, updatedValue, containerComponent, foundResourceInstance,
3512 capabilityType, capabilityName), Either::right);
3514 Either<Component, StorageOperationStatus> updateContainerRes = toscaOperationFacade
3515 .updateComponentInstanceMetadataOfTopologyTemplate(containerComponent);
3516 if (updateContainerRes.isRight()) {
3517 ActionStatus actionStatus = componentsUtils.convertFromStorageResponseForResourceInstanceProperty(updateContainerRes.right().value());
3518 resultOp = Either.right(componentsUtils.getResponseFormatForResourceInstanceProperty(actionStatus, ""));
3521 resultOp = Either.left(properties);
3524 if (resultOp == null || resultOp.isRight()) {
3525 janusGraphDao.rollback();
3527 janusGraphDao.commit();
3530 graphLockOperation.unlockComponent(containerComponentId, componentTypeEnum.getNodeType());
3534 public Either<Map<String, ComponentInstance>, ResponseFormat> copyComponentInstance(ComponentInstance inputComponentInstance,
3535 String containerComponentId, String componentInstanceId,
3537 Map<String, ComponentInstance> resultMap = new HashMap<>();
3538 Either<Component, StorageOperationStatus> getOrigComponent = toscaOperationFacade.getToscaElement(containerComponentId);
3539 if (getOrigComponent.isRight()) {
3540 log.error("Failed to get the original component information");
3541 return Either.right(componentsUtils.getResponseFormat(ActionStatus.USER_DEFINED, FAILED_TO_COPY_COMP_INSTANCE_TO_CANVAS));
3543 Component origComponent = getOrigComponent.left().value();
3545 lockComponent(origComponent, "copyComponentInstance");
3546 } catch (ComponentException e) {
3547 log.error("destComponentInstance's data is {}", origComponent.toString());
3548 return Either.right(componentsUtils
3549 .getResponseFormat(ActionStatus.USER_DEFINED, "Failed to lock component destComponentInstance's data is {}",
3550 origComponent.toString()));
3552 boolean failed = false;
3553 ComponentInstance actionResponse = null;
3555 actionResponse = createComponentInstance("services", containerComponentId, userId, inputComponentInstance, false);
3556 } catch (ComponentException e) {
3558 // on failure of the create instance unlock the resource and rollback the transaction.
3559 return Either.right(componentsUtils.getResponseFormat(ActionStatus.USER_DEFINED, FAILED_TO_COPY_COMP_INSTANCE_TO_CANVAS));
3561 // on failure of the create instance unlock the resource and rollback the transaction.
3562 if (null == actionResponse) {
3563 log.error(FAILED_TO_COPY_COMP_INSTANCE_TO_CANVAS);
3564 unlockComponent(failed, origComponent);
3567 Either<String, ResponseFormat> resultOp = null;
3569 ComponentInstance destComponentInstance = actionResponse;
3570 log.debug("destComponentInstance's data is {}", destComponentInstance);
3571 resultOp = deepCopyComponentInstance(origComponent, containerComponentId, componentInstanceId, destComponentInstance, userId);
3572 resultMap.put("componentInstance", destComponentInstance);
3575 if (resultOp == null || resultOp.isRight()) {
3576 unlockComponent(true, origComponent);
3577 janusGraphDao.rollback();
3578 log.error("Failed to deep copy component instance");
3580 unlockComponent(false, origComponent);
3581 janusGraphDao.commit();
3582 log.debug("Success trasaction commit");
3585 if (resultOp == null || resultOp.isRight()) {
3587 .right(componentsUtils.getResponseFormat(ActionStatus.USER_DEFINED, "Failed to deep copy the component instance to the canvas"));
3589 return Either.left(resultMap);
3593 private Either<String, ResponseFormat> deepCopyComponentInstance(Component sourceComponent, String containerComponentId,
3594 String sourceComponentInstanceId, ComponentInstance destComponentInstance,
3596 Either<Component, StorageOperationStatus> getDestComponent = toscaOperationFacade.getToscaElement(containerComponentId);
3597 if (getDestComponent.isRight()) {
3598 log.error("Failed to get the dest component information");
3599 return Either.right(componentsUtils.getResponseFormat(ActionStatus.USER_DEFINED, FAILED_TO_COPY_COMP_INSTANCE_TO_CANVAS));
3601 Component destComponent = getDestComponent.left().value();
3602 Either<String, ResponseFormat> copyComponentInstanceWithPropertiesAndInputs = copyComponentInstanceWithPropertiesAndInputs(sourceComponent,
3603 destComponent, sourceComponentInstanceId, destComponentInstance);
3604 if (copyComponentInstanceWithPropertiesAndInputs.isRight()) {
3605 log.error("Failed to copy component instance with properties and inputs as part of deep copy");
3606 return Either.right(componentsUtils.getResponseFormat(ActionStatus.USER_DEFINED,
3607 "Failed to copy the component instance with properties and inputs as part of deep copy"));
3609 Either<String, ResponseFormat> copyComponentInstanceWithAttributes = copyComponentInstanceWithAttributes(sourceComponent, destComponent,
3610 sourceComponentInstanceId, destComponentInstance, userId);
3611 if (copyComponentInstanceWithAttributes.isRight()) {
3612 log.error("Failed to copy component instance with attributes as part of deep copy");
3613 return Either.right(componentsUtils
3614 .getResponseFormat(ActionStatus.USER_DEFINED, "Failed to copy the component instance with attributes as part of deep copy"));
3616 return Either.left(COPY_COMPONENT_INSTANCE_OK);
3619 private Either<String, ResponseFormat> copyComponentInstanceWithPropertiesAndInputs(Component sourceComponent, Component destComponent,
3620 String sourceComponentInstanceId,
3621 ComponentInstance destComponentInstance) {
3622 log.debug("start to copy ComponentInstance with properties and inputs");
3623 List<ComponentInstanceProperty> sourcePropList = null;
3624 if (sourceComponent.getComponentInstancesProperties() != null
3625 && sourceComponent.getComponentInstancesProperties().get(sourceComponentInstanceId) != null) {
3626 sourcePropList = sourceComponent.getComponentInstancesProperties().get(sourceComponentInstanceId);
3627 log.debug("sourcePropList");
3629 List<ComponentInstanceProperty> destPropList = null;
3630 String destComponentInstanceId = destComponentInstance.getUniqueId();
3631 log.debug("destComponentInstanceId: {}", destComponentInstance.getUniqueId());
3632 if (destComponent.getComponentInstancesProperties() != null
3633 && destComponent.getComponentInstancesProperties().get(destComponentInstanceId) != null) {
3634 destPropList = destComponent.getComponentInstancesProperties().get(destComponentInstanceId);
3635 log.debug("destPropList {}");
3637 List<ComponentInstancePropInput> componentInstancePropInputList = new ArrayList<>();
3638 if (null != destPropList && null != sourcePropList) {
3639 log.debug("start to set property and attribute");
3640 for (ComponentInstanceProperty destProp : destPropList) {
3641 String destPropertyName = destProp.getName();
3642 for (ComponentInstanceProperty sourceProp : sourcePropList) {
3643 if (!destPropertyName.equals(sourceProp.getName())) {
3646 log.debug("now set property");
3647 final List<GetInputValueDataDefinition> getInputValues = sourceProp.getGetInputValues();
3648 if (getInputValues == null && !StringUtils.isEmpty(sourceProp.getValue()) && (destProp.getValue() == null || !destProp.getValue()
3649 .equals(sourceProp.getValue()))) {
3650 log.debug("Now starting to copy the property {} in value {}", destPropertyName, sourceProp.getValue());
3651 destProp.setValue(sourceProp.getValue());
3652 Either<String, ResponseFormat> updatePropertyValueEither = updateComponentInstanceProperty(destComponent.getUniqueId(),
3653 destComponentInstanceId, destProp);
3654 if (updatePropertyValueEither.isRight()) {
3655 log.error("Failed to copy the property {}", destPropertyName);
3656 return Either.right(componentsUtils.getResponseFormat(ActionStatus.INVALID_CONTENT_PARAM,
3657 "Failed to paste component instance to the canvas, property copy"));
3661 log.debug("Now start to update inputs");
3662 if (getInputValues != null) {
3663 if (getInputValues.isEmpty()) {
3664 log.debug("property is return from input, set by man");
3667 log.debug("Now starting to copy the {} property", destPropertyName);
3668 Either<String, ResponseFormat> getSourceInputDefaultValue = getInputListDefaultValue(sourceComponent,
3669 getInputValues.get(0).getInputId());
3670 if (getSourceInputDefaultValue.isRight()) {
3671 return Either.right(getSourceInputDefaultValue.right().value());
3673 componentInstancePropInputList.add(new ComponentInstancePropInput(destProp));
3678 return Either.left(COPY_COMPONENT_INSTANCE_OK);
3681 private Either<String, ResponseFormat> copyComponentInstanceWithAttributes(Component sourceComponent, Component destComponent,
3682 String sourceComponentInstanceId,
3683 ComponentInstance destComponentInstance, String userId) {
3684 String destComponentInstanceId = destComponentInstance.getUniqueId();
3685 log.info("start to copy component instance with attributes");
3686 List<ComponentInstanceAttribute> sourceAttributeList = null;
3687 if (sourceComponent.getComponentInstancesAttributes() != null
3688 && sourceComponent.getComponentInstancesAttributes().get(sourceComponentInstanceId) != null) {
3689 sourceAttributeList = sourceComponent.getComponentInstancesAttributes().get(sourceComponentInstanceId);
3690 log.info("sourceAttributes {}");
3692 List<ComponentInstanceAttribute> destAttributeList = null;
3693 if (destComponent.getComponentInstancesAttributes() != null
3694 && destComponent.getComponentInstancesAttributes().get(destComponentInstanceId) != null) {
3695 destAttributeList = destComponent.getComponentInstancesAttributes().get(destComponentInstanceId);
3696 log.info("destAttributeList {}");
3698 if (null != sourceAttributeList && null != destAttributeList) {
3699 log.info("set attribute");
3700 for (ComponentInstanceAttribute sourceAttribute : sourceAttributeList) {
3701 String sourceAttributeName = sourceAttribute.getName();
3702 for (ComponentInstanceAttribute destAttribute : destAttributeList) {
3703 if (sourceAttributeName.equals(destAttribute.getName())) {
3704 log.debug("Start to copy the attribute exists {}", sourceAttributeName);
3705 sourceAttribute.setUniqueId(
3706 UniqueIdBuilder.buildResourceInstanceUniuqeId("attribute", destComponentInstanceId.split("\\.")[1], sourceAttributeName));
3707 Either<ComponentInstanceAttribute, ResponseFormat> updateAttributeValueEither = createOrUpdateAttributeValueForCopyPaste(
3708 ComponentTypeEnum.SERVICE, destComponent.getUniqueId(), destComponentInstanceId, sourceAttribute, userId);
3709 if (updateAttributeValueEither.isRight()) {
3710 log.error("Failed to copy the attribute");
3711 return Either.right(componentsUtils.getResponseFormat(ActionStatus.INVALID_CONTENT_PARAM,
3712 "Failed to paste component instance to the canvas, attribute copy"));
3719 return Either.left(COPY_COMPONENT_INSTANCE_OK);
3722 private Either<ComponentInstanceAttribute, ResponseFormat> createOrUpdateAttributeValueForCopyPaste(ComponentTypeEnum componentTypeEnum,
3723 String componentId, String resourceInstanceId,
3724 ComponentInstanceAttribute attribute,
3726 Either<ComponentInstanceAttribute, ResponseFormat> resultOp = null;
3727 validateUserExists(userId);
3728 if (componentTypeEnum == null) {
3729 BeEcompErrorManager.getInstance()
3730 .logInvalidInputError("createOrUpdateAttributeValueForCopyPaste", INVALID_COMPONENT_TYPE, ErrorSeverity.INFO);
3731 resultOp = Either.right(componentsUtils.getResponseFormat(ActionStatus.NOT_ALLOWED));
3734 Either<Component, StorageOperationStatus> getResourceResult = toscaOperationFacade.getToscaElement(componentId, JsonParseFlagEnum.ParseAll);
3735 if (getResourceResult.isRight()) {
3736 log.info("Failed to retrieve component id {}", componentId);
3737 resultOp = Either.right(componentsUtils.getResponseFormat(ActionStatus.RESTRICTED_OPERATION));
3740 Component containerComponent = getResourceResult.left().value();
3741 Either<ComponentInstance, StorageOperationStatus> resourceInstanceStatus = getResourceInstanceById(containerComponent, resourceInstanceId);
3742 if (resourceInstanceStatus.isRight()) {
3744 .right(componentsUtils.getResponseFormat(ActionStatus.RESOURCE_INSTANCE_NOT_FOUND_ON_SERVICE, resourceInstanceId, componentId));
3747 ComponentInstance foundResourceInstance = resourceInstanceStatus.left().value();
3748 String propertyType = attribute.getType();
3749 ToscaPropertyType type = ToscaPropertyType.isValidType(propertyType);
3750 log.info("The type of attribute id{},is {} ", attribute.getUniqueId(), propertyType);
3751 if (type == ToscaPropertyType.LIST || type == ToscaPropertyType.MAP) {
3752 SchemaDefinition def = attribute.getSchema();
3754 log.info("Schema doesn't exists for attribute of type {}", type);
3756 .right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(StorageOperationStatus.INVALID_VALUE)));
3758 PropertyDataDefinition propDef = def.getProperty();
3759 if (propDef == null) {
3760 log.info("Attribute in Schema Definition inside attribute of type {} doesn't exist", type);
3762 .right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(StorageOperationStatus.INVALID_VALUE)));
3765 List<ComponentInstanceAttribute> instanceAttributes = containerComponent.getComponentInstancesAttributes().get(resourceInstanceId);
3766 Optional<ComponentInstanceAttribute> instanceAttribute = instanceAttributes.stream()
3767 .filter(p -> p.getUniqueId().equals(attribute.getUniqueId())).findAny();
3768 StorageOperationStatus status;
3769 if (instanceAttribute.isPresent()) {
3770 log.info("updateComponentInstanceAttribute");
3771 status = toscaOperationFacade.updateComponentInstanceAttribute(containerComponent, foundResourceInstance.getUniqueId(), attribute);
3773 log.info("addComponentInstanceAttribute");
3774 status = toscaOperationFacade.addComponentInstanceAttribute(containerComponent, foundResourceInstance.getUniqueId(), attribute);
3776 if (status != StorageOperationStatus.OK) {
3777 ActionStatus actionStatus = componentsUtils.convertFromStorageResponseForResourceInstanceProperty(status);
3778 resultOp = Either.right(componentsUtils.getResponseFormatForResourceInstanceProperty(actionStatus, ""));
3781 List<String> path = new ArrayList<>();
3782 path.add(foundResourceInstance.getUniqueId());
3783 attribute.setPath(path);
3784 foundResourceInstance.setCustomizationUUID(UUID.randomUUID().toString());
3785 Either<Component, StorageOperationStatus> updateContainerRes = toscaOperationFacade
3786 .updateComponentInstanceMetadataOfTopologyTemplate(containerComponent);
3787 if (updateContainerRes.isRight()) {
3788 ActionStatus actionStatus = componentsUtils.convertFromStorageResponseForResourceInstanceProperty(updateContainerRes.right().value());
3789 resultOp = Either.right(componentsUtils.getResponseFormatForResourceInstanceProperty(actionStatus, ""));
3792 resultOp = Either.left(attribute);
3796 private Either<String, ResponseFormat> updateComponentInstanceProperty(String containerComponentId, String componentInstanceId,
3797 ComponentInstanceProperty property) {
3798 Either<String, ResponseFormat> resultOp;
3799 Either<Component, StorageOperationStatus> getComponent = toscaOperationFacade.getToscaElement(containerComponentId);
3800 if (getComponent.isRight()) {
3801 log.error("Failed to get the component information");
3802 return Either.right(componentsUtils
3803 .getResponseFormatForResourceInstanceProperty(ActionStatus.INVALID_CONTENT_PARAM, "Failed to get the component information"));
3805 Component containerComponent = getComponent.left().value();
3806 StorageOperationStatus status = toscaOperationFacade.updateComponentInstanceProperty(containerComponent, componentInstanceId, property);
3807 if (status != StorageOperationStatus.OK) {
3808 ActionStatus actionStatus = componentsUtils.convertFromStorageResponseForResourceInstanceProperty(status);
3809 resultOp = Either.right(componentsUtils.getResponseFormatForResourceInstanceProperty(actionStatus, ""));
3812 Either<Component, StorageOperationStatus> updateContainerRes = toscaOperationFacade
3813 .updateComponentInstanceMetadataOfTopologyTemplate(containerComponent);
3814 if (updateContainerRes.isRight()) {
3815 ActionStatus actionStatus = componentsUtils.convertFromStorageResponseForResourceInstanceProperty(updateContainerRes.right().value());
3816 resultOp = Either.right(componentsUtils.getResponseFormatForResourceInstanceProperty(actionStatus, ""));
3819 return Either.left("Update OK");
3822 private Either<String, ResponseFormat> getInputListDefaultValue(Component component, String inputId) {
3823 List<InputDefinition> inputList = component.getInputs();
3824 for (InputDefinition input : inputList) {
3825 if (input.getUniqueId().equals(inputId)) {
3826 if (input.getDefaultValue() == null) {
3827 log.debug("The input's default value is null");
3828 return Either.left(null);
3830 return Either.left(input.getDefaultValue());
3833 log.error("The input's default value with id {} is not found", inputId);
3834 return Either.right(componentsUtils.getResponseFormat(ActionStatus.USER_DEFINED, "Failed to paste component instance to the canvas"));
3838 * Method to delete selected nodes and edges on composition page
3840 * @param containerComponentType
3841 * @param componentId
3842 * @param componentInstanceIdList
3846 public Map<String, List<String>> batchDeleteComponentInstance(String containerComponentType, String componentId,
3847 List<String> componentInstanceIdList, String userId) {
3848 List<String> deleteErrorIds = new ArrayList<>();
3849 Map<String, List<String>> deleteErrorMap = new HashMap<>();
3850 validateUserExists(userId);
3851 org.openecomp.sdc.be.model.Component containerComponent = validateComponentExists(componentId,
3852 ComponentTypeEnum.findByParamName(containerComponentType), null);
3853 boolean failed = false;
3855 lockComponent(containerComponent, "batchDeleteComponentInstance");
3856 for (String eachInstanceId : componentInstanceIdList) {
3857 Either<ComponentInstance, ResponseFormat> actionResponse = batchDeleteComponentInstance(containerComponent, containerComponentType,
3859 log.debug("batchDeleteResourceInstances actionResponse is {}", actionResponse);
3860 if (actionResponse.isRight()) {
3861 log.error("Failed to delete ComponentInstance [{}]", eachInstanceId);
3862 deleteErrorIds.add(eachInstanceId);
3865 //sending the ids of the error nodes that were not deleted to UI
3866 deleteErrorMap.put("deleteFailedIds", deleteErrorIds);
3867 return deleteErrorMap;
3868 } catch (ComponentException e) {
3872 unlockComponent(failed, containerComponent);
3876 private Either<ComponentInstance, ResponseFormat> batchDeleteComponentInstance(Component containerComponent, String containerComponentType,
3877 String componentInstanceId) {
3878 ComponentInstance resultOp;
3879 final ComponentTypeEnum containerComponentTypeEnum = ComponentTypeEnum.findByParamName(containerComponentType);
3881 resultOp = deleteComponentInstance(containerComponent, componentInstanceId, containerComponentTypeEnum);
3882 log.info("Successfully deleted instance with id {}", componentInstanceId);
3883 return Either.left(resultOp);
3884 } catch (ComponentException e) {
3885 log.error("Failed to deleteComponentInstance with instanceId[{}]", componentInstanceId);
3886 return Either.right(new ResponseFormat());
3890 public void validateUser(final String userId) {
3891 final User user = userValidations.validateUserExists(userId);
3892 userValidations.validateUserRole(user, Arrays.asList(Role.DESIGNER, Role.ADMIN));
3895 public void setCompositionBusinessLogic(CompositionBusinessLogic compositionBusinessLogic) {
3896 this.compositionBusinessLogic = compositionBusinessLogic;
3899 public void setContainerInstanceTypesData(ContainerInstanceTypesData containerInstanceTypesData) {
3900 this.containerInstanceTypesData = containerInstanceTypesData;