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.json.JSONObject;
47 import org.onap.sdc.tosca.datatypes.model.PropertyType;
48 import org.openecomp.sdc.be.components.impl.exceptions.BusinessLogicException;
49 import org.openecomp.sdc.be.components.impl.exceptions.ByActionStatusComponentException;
50 import org.openecomp.sdc.be.components.impl.exceptions.ByResponseFormatComponentException;
51 import org.openecomp.sdc.be.components.impl.exceptions.ComponentException;
52 import org.openecomp.sdc.be.components.impl.exceptions.ToscaGetFunctionExceptionSupplier;
53 import org.openecomp.sdc.be.components.impl.instance.ComponentInstanceChangeOperationOrchestrator;
54 import org.openecomp.sdc.be.components.impl.utils.DirectivesUtil;
55 import org.openecomp.sdc.be.components.merge.instance.ComponentInstanceMergeDataBusinessLogic;
56 import org.openecomp.sdc.be.components.merge.instance.DataForMergeHolder;
57 import org.openecomp.sdc.be.components.utils.PropertiesUtils;
58 import org.openecomp.sdc.be.components.validation.ComponentValidations;
59 import org.openecomp.sdc.be.config.BeEcompErrorManager;
60 import org.openecomp.sdc.be.config.BeEcompErrorManager.ErrorSeverity;
61 import org.openecomp.sdc.be.config.ConfigurationManager;
62 import org.openecomp.sdc.be.dao.api.ActionStatus;
63 import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus;
64 import org.openecomp.sdc.be.dao.jsongraph.types.JsonParseFlagEnum;
65 import org.openecomp.sdc.be.dao.neo4j.GraphPropertiesDictionary;
66 import org.openecomp.sdc.be.datatypes.elements.CINodeFilterDataDefinition;
67 import org.openecomp.sdc.be.datatypes.elements.CapabilityDataDefinition;
68 import org.openecomp.sdc.be.datatypes.elements.ForwardingPathDataDefinition;
69 import org.openecomp.sdc.be.datatypes.elements.GetInputValueDataDefinition;
70 import org.openecomp.sdc.be.datatypes.elements.GetOutputValueDataDefinition;
71 import org.openecomp.sdc.be.datatypes.elements.GetPolicyValueDataDefinition;
72 import org.openecomp.sdc.be.datatypes.elements.PropertyDataDefinition;
73 import org.openecomp.sdc.be.datatypes.elements.RequirementDataDefinition;
74 import org.openecomp.sdc.be.datatypes.elements.SchemaDefinition;
75 import org.openecomp.sdc.be.datatypes.elements.ToscaGetFunctionDataDefinition;
76 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
77 import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
78 import org.openecomp.sdc.be.datatypes.enums.OriginTypeEnum;
79 import org.openecomp.sdc.be.datatypes.enums.PropertySource;
80 import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum;
81 import org.openecomp.sdc.be.datatypes.tosca.ToscaGetFunctionType;
82 import org.openecomp.sdc.be.exception.BusinessException;
83 import org.openecomp.sdc.be.impl.ComponentsUtils;
84 import org.openecomp.sdc.be.impl.ForwardingPathUtils;
85 import org.openecomp.sdc.be.impl.ServiceFilterUtils;
86 import org.openecomp.sdc.be.info.CreateAndAssotiateInfo;
87 import org.openecomp.sdc.be.model.ArtifactDefinition;
88 import org.openecomp.sdc.be.model.AttributeDefinition;
89 import org.openecomp.sdc.be.model.CapabilityDefinition;
90 import org.openecomp.sdc.be.model.Component;
91 import org.openecomp.sdc.be.model.ComponentInstance;
92 import org.openecomp.sdc.be.model.ComponentInstanceAttribute;
93 import org.openecomp.sdc.be.model.ComponentInstanceInput;
94 import org.openecomp.sdc.be.model.ComponentInstanceOutput;
95 import org.openecomp.sdc.be.model.ComponentInstancePropInput;
96 import org.openecomp.sdc.be.model.ComponentInstanceProperty;
97 import org.openecomp.sdc.be.model.ComponentParametersView;
98 import org.openecomp.sdc.be.model.DataTypeDefinition;
99 import org.openecomp.sdc.be.model.GroupDefinition;
100 import org.openecomp.sdc.be.model.InputDefinition;
101 import org.openecomp.sdc.be.model.InterfaceDefinition;
102 import org.openecomp.sdc.be.model.LifecycleStateEnum;
103 import org.openecomp.sdc.be.model.OutputDefinition;
104 import org.openecomp.sdc.be.model.PolicyDefinition;
105 import org.openecomp.sdc.be.model.PropertyDefinition;
106 import org.openecomp.sdc.be.model.RelationshipInfo;
107 import org.openecomp.sdc.be.model.RequirementCapabilityRelDef;
108 import org.openecomp.sdc.be.model.RequirementDefinition;
109 import org.openecomp.sdc.be.model.Resource;
110 import org.openecomp.sdc.be.model.Service;
111 import org.openecomp.sdc.be.model.ToscaPropertyData;
112 import org.openecomp.sdc.be.model.User;
113 import org.openecomp.sdc.be.model.jsonjanusgraph.config.ContainerInstanceTypesData;
114 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.ArtifactsOperations;
115 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.ForwardingPathOperation;
116 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.InterfaceOperation;
117 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.NodeFilterOperation;
118 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.NodeTemplateOperation;
119 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.ToscaOperationFacade;
120 import org.openecomp.sdc.be.model.jsonjanusgraph.utils.ModelConverter;
121 import org.openecomp.sdc.be.model.operations.StorageException;
122 import org.openecomp.sdc.be.model.operations.api.IElementOperation;
123 import org.openecomp.sdc.be.model.operations.api.IGroupInstanceOperation;
124 import org.openecomp.sdc.be.model.operations.api.IGroupOperation;
125 import org.openecomp.sdc.be.model.operations.api.IGroupTypeOperation;
126 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
127 import org.openecomp.sdc.be.model.operations.impl.ComponentInstanceOperation;
128 import org.openecomp.sdc.be.model.operations.impl.DaoStatusConverter;
129 import org.openecomp.sdc.be.model.operations.impl.InterfaceLifecycleOperation;
130 import org.openecomp.sdc.be.model.operations.impl.UniqueIdBuilder;
131 import org.openecomp.sdc.be.model.operations.utils.ComponentValidationUtils;
132 import org.openecomp.sdc.be.model.tosca.ToscaPropertyType;
133 import org.openecomp.sdc.be.model.validation.ToscaFunctionValidator;
134 import org.openecomp.sdc.be.resources.data.ComponentInstanceData;
135 import org.openecomp.sdc.be.user.Role;
136 import org.openecomp.sdc.common.api.ArtifactGroupTypeEnum;
137 import org.openecomp.sdc.common.api.ArtifactTypeEnum;
138 import org.openecomp.sdc.common.api.Constants;
139 import org.openecomp.sdc.common.datastructure.Wrapper;
140 import org.openecomp.sdc.common.jsongraph.util.CommonUtility;
141 import org.openecomp.sdc.common.jsongraph.util.CommonUtility.LogLevelEnum;
142 import org.openecomp.sdc.common.log.elements.ErrorLogOptionalData;
143 import org.openecomp.sdc.common.log.enums.EcompLoggerErrorCode;
144 import org.openecomp.sdc.common.log.wrappers.Logger;
145 import org.openecomp.sdc.common.util.ValidationUtils;
146 import org.openecomp.sdc.exception.ResponseFormat;
147 import org.springframework.beans.factory.annotation.Autowired;
148 import org.yaml.snakeyaml.Yaml;
150 @org.springframework.stereotype.Component
151 public class ComponentInstanceBusinessLogic extends BaseBusinessLogic {
153 private static final Logger log = Logger.getLogger(ComponentInstanceBusinessLogic.class);
154 private static final String VF_MODULE = "org.openecomp.groups.VfModule";
155 private static final String TRY_TO_CREATE_ENTRY_ON_GRAPH = "Try to create entry on graph";
156 private static final String CLOUD_SPECIFIC_FIXED_KEY_WORD = "cloudtech";
157 private static final String[][] CLOUD_SPECIFIC_KEY_WORDS = {{"k8s", "azure", "aws"}, /* cloud specific technology */
158 {"charts", "day0", "configtemplate"} /*cloud specific sub type*/};
159 private static final String FAILED_TO_CREATE_ENTRY_ON_GRAPH_FOR_COMPONENT_INSTANCE = "Failed to create entry on graph for component instance {}";
160 private static final String ENTITY_ON_GRAPH_IS_CREATED = "Entity on graph is created.";
161 private static final String INVALID_COMPONENT_TYPE = "invalid component type";
162 private static final String FAILED_TO_RETRIEVE_COMPONENT_COMPONENT_ID = "Failed to retrieve component, component id {}";
163 private static final String FAILED_TO_LOCK_SERVICE = "Failed to lock service {}";
164 private static final String CREATE_OR_UPDATE_PROPERTY_VALUE = "CreateOrUpdatePropertyValue";
165 private static final String FAILED_TO_COPY_COMP_INSTANCE_TO_CANVAS = "Failed to copy the component instance to the canvas";
166 private static final String COPY_COMPONENT_INSTANCE_OK = "Copy component instance OK";
167 private static final String CANNOT_ATTACH_RESOURCE_INSTANCES_TO_CONTAINER_RESOURCE_OF_TYPE = "Cannot attach resource instances to container resource of type {}";
168 private static final String FAILED_TO_UPDATE_COMPONENT_INSTANCE_CAPABILITY = "Failed to update component instance capability on instance {} in "
170 private static final String SERVICE_PROXY = "serviceProxy";
171 private static final String ASSOCIATE_RI_TO_RI = "associateRIToRI";
172 private static final String COMPONENT_ARCHIVED = "Component is archived. Component id: {}";
173 private static final String RESTRICTED_OPERATION_ON_SERVIVE = "Restricted operation for user: {} on service {}";
174 private static final String FAILED_TO_LOCK_COMPONENT = "Failed to lock component {}";
175 private static final String RESTRICTED_OPERATION_ON_COMPONENT = "Restricted operation for user: {} on component {}";
176 private static final String RESOURCE_INSTANCE = "resource instance";
177 private static final String SERVICE = "service";
179 private final ComponentInstanceOperation componentInstanceOperation;
180 private final ArtifactsBusinessLogic artifactBusinessLogic;
181 private final ComponentInstanceMergeDataBusinessLogic compInstMergeDataBL;
182 private final ComponentInstanceChangeOperationOrchestrator onChangeInstanceOperationOrchestrator;
183 private final ForwardingPathOperation forwardingPathOperation;
184 private final NodeFilterOperation nodeFilterOperation;
186 private CompositionBusinessLogic compositionBusinessLogic;
188 private ContainerInstanceTypesData containerInstanceTypesData;
189 private final ToscaFunctionValidator toscaFunctionValidator;
192 public ComponentInstanceBusinessLogic(IElementOperation elementDao, IGroupOperation groupOperation,
193 IGroupInstanceOperation groupInstanceOperation, IGroupTypeOperation groupTypeOperation,
194 InterfaceOperation interfaceOperation, InterfaceLifecycleOperation interfaceLifecycleTypeOperation,
195 ComponentInstanceOperation componentInstanceOperation, ArtifactsBusinessLogic artifactBusinessLogic,
196 ComponentInstanceMergeDataBusinessLogic compInstMergeDataBL,
197 ComponentInstanceChangeOperationOrchestrator onChangeInstanceOperationOrchestrator,
198 ForwardingPathOperation forwardingPathOperation, NodeFilterOperation nodeFilterOperation,
199 ArtifactsOperations artifactToscaOperation, final ToscaFunctionValidator toscaFunctionValidator) {
200 super(elementDao, groupOperation, groupInstanceOperation, groupTypeOperation, interfaceOperation, interfaceLifecycleTypeOperation,
201 artifactToscaOperation);
202 this.componentInstanceOperation = componentInstanceOperation;
203 this.artifactBusinessLogic = artifactBusinessLogic;
204 this.compInstMergeDataBL = compInstMergeDataBL;
205 this.onChangeInstanceOperationOrchestrator = onChangeInstanceOperationOrchestrator;
206 this.forwardingPathOperation = forwardingPathOperation;
207 this.nodeFilterOperation = nodeFilterOperation;
208 this.toscaFunctionValidator = toscaFunctionValidator;
211 public ComponentInstance createComponentInstance(String containerComponentParam, String containerComponentId, String userId,
212 ComponentInstance resourceInstance) {
213 return createComponentInstance(containerComponentParam, containerComponentId, userId, resourceInstance, true);
216 public List<ComponentInstanceProperty> getComponentInstancePropertiesByInputId(org.openecomp.sdc.be.model.Component component, String inputId) {
217 List<ComponentInstanceProperty> resList = new ArrayList<>();
218 Map<String, List<ComponentInstanceProperty>> ciPropertiesMap = component.getComponentInstancesProperties();
219 if (ciPropertiesMap != null && !ciPropertiesMap.isEmpty()) {
220 ciPropertiesMap.forEach((s, ciPropList) -> {
222 Optional<ComponentInstance> ciOp = component.getComponentInstances().stream().filter(ci -> ci.getUniqueId().equals(s)).findAny();
223 if (ciOp.isPresent()) {
224 ciName = ciOp.get().getName();
226 if (ciPropList != null && !ciPropList.isEmpty()) {
227 for (ComponentInstanceProperty prop : ciPropList) {
228 List<GetInputValueDataDefinition> inputsValues = prop.getGetInputValues();
229 addCompInstanceProperty(s, ciName, prop, inputsValues, inputId, resList);
237 public List<ComponentInstanceAttribute> getComponentInstanceAttributesByOutputId(final org.openecomp.sdc.be.model.Component component,
238 final String outputId) {
239 final List<ComponentInstanceAttribute> resList = new ArrayList<>();
240 final Map<String, List<ComponentInstanceAttribute>> componentInstancesAttributes = component.getComponentInstancesAttributes();
241 if (org.apache.commons.collections4.MapUtils.isNotEmpty(componentInstancesAttributes)) {
242 componentInstancesAttributes.forEach((s, componentInstanceAttributeList) -> {
244 final Optional<ComponentInstance> ciOp = component.getComponentInstances().stream().filter(ci -> ci.getUniqueId().equals(s))
246 if (ciOp.isPresent()) {
247 ciName = ciOp.get().getName();
249 if (componentInstanceAttributeList != null && !componentInstanceAttributeList.isEmpty()) {
250 for (final ComponentInstanceAttribute compInstanceAttribute : componentInstanceAttributeList) {
251 List<GetOutputValueDataDefinition> outputValues = compInstanceAttribute.getGetOutputValues();
252 addCompInstanceAttribute(s, ciName, compInstanceAttribute, outputValues, outputId, resList);
260 private void addCompInstanceProperty(String s, String ciName, ComponentInstanceProperty prop, List<GetInputValueDataDefinition> inputsValues,
261 String inputId, List<ComponentInstanceProperty> resList) {
262 if (inputsValues != null && !inputsValues.isEmpty()) {
263 for (GetInputValueDataDefinition inputData : inputsValues) {
264 if (isGetInputValueForInput(inputData, inputId)) {
265 prop.setComponentInstanceId(s);
266 prop.setComponentInstanceName(ciName);
274 private void addCompInstanceAttribute(final String s, final String ciName, final ComponentInstanceAttribute attribute,
275 final List<GetOutputValueDataDefinition> outputsValues, final String outputId,
276 final List<ComponentInstanceAttribute> resList) {
277 if (outputsValues != null && !outputsValues.isEmpty()) {
278 for (final GetOutputValueDataDefinition outputData : outputsValues) {
279 if (isGetOutputValueForOutput(outputData, outputId)) {
280 attribute.setComponentInstanceId(s);
281 attribute.setComponentInstanceName(ciName);
282 resList.add(attribute);
289 public Optional<ComponentInstanceProperty> getComponentInstancePropertyByPolicyId(Component component, PolicyDefinition policy) {
290 Optional<ComponentInstanceProperty> propertyCandidate = getComponentInstancePropertyByPolicy(component, policy);
291 if (propertyCandidate.isPresent()) {
292 ComponentInstanceProperty componentInstanceProperty = propertyCandidate.get();
293 Optional<GetPolicyValueDataDefinition> getPolicyCandidate = getGetPolicyValueDataDefinition(policy, componentInstanceProperty);
295 .ifPresent(getPolicyValue -> updateComponentInstancePropertyAfterUndeclaration(componentInstanceProperty, getPolicyValue, policy));
296 return Optional.of(componentInstanceProperty);
298 return Optional.empty();
301 private void updateComponentInstancePropertyAfterUndeclaration(ComponentInstanceProperty componentInstanceProperty,
302 GetPolicyValueDataDefinition getPolicyValue, PolicyDefinition policyDefinition) {
303 componentInstanceProperty.setValue(getPolicyValue.getOrigPropertyValue());
304 List<GetPolicyValueDataDefinition> getPolicyValues = componentInstanceProperty.getGetPolicyValues();
305 if (CollectionUtils.isNotEmpty(getPolicyValues)) {
306 getPolicyValues.remove(getPolicyValue);
307 componentInstanceProperty.setGetPolicyValues(getPolicyValues);
308 policyDefinition.setGetPolicyValues(getPolicyValues);
312 private Optional<GetPolicyValueDataDefinition> getGetPolicyValueDataDefinition(PolicyDefinition policy,
313 ComponentInstanceProperty componentInstanceProperty) {
314 List<GetPolicyValueDataDefinition> getPolicyValues = policy.getGetPolicyValues();
315 return getPolicyValues.stream().filter(getPolicyValue -> getPolicyValue.getPropertyName().equals(componentInstanceProperty.getName()))
319 private Optional<ComponentInstanceProperty> getComponentInstancePropertyByPolicy(Component component, PolicyDefinition policy) {
320 Map<String, List<ComponentInstanceProperty>> componentInstancesProperties = component.getComponentInstancesProperties();
321 if (MapUtils.isEmpty(componentInstancesProperties)) {
322 return Optional.empty();
324 String instanceUniqueId = policy.getInstanceUniqueId();
325 List<ComponentInstanceProperty> componentInstanceProperties =
326 componentInstancesProperties.containsKey(instanceUniqueId) ? componentInstancesProperties.get(instanceUniqueId) : new ArrayList<>();
327 return componentInstanceProperties.stream().filter(property -> property.getName().equals(policy.getName())).findAny();
330 public List<ComponentInstanceInput> getComponentInstanceInputsByInputId(org.openecomp.sdc.be.model.Component component, String inputId) {
331 List<ComponentInstanceInput> resList = new ArrayList<>();
332 Map<String, List<ComponentInstanceInput>> ciInputsMap = component.getComponentInstancesInputs();
333 if (ciInputsMap != null && !ciInputsMap.isEmpty()) {
334 ciInputsMap.forEach((s, ciPropList) -> {
336 Optional<ComponentInstance> ciOp = component.getComponentInstances().stream().filter(ci -> ci.getUniqueId().equals(s)).findAny();
337 if (ciOp.isPresent()) {
338 ciName = ciOp.get().getName();
340 if (ciPropList != null && !ciPropList.isEmpty()) {
341 for (ComponentInstanceInput prop : ciPropList) {
342 List<GetInputValueDataDefinition> inputsValues = prop.getGetInputValues();
343 addCompInstanceInput(s, ciName, prop, inputsValues, inputId, resList);
351 public List<ComponentInstanceOutput> getComponentInstanceOutputsByOutputId(final org.openecomp.sdc.be.model.Component component,
352 final String outputId) {
353 final List<ComponentInstanceOutput> resList = new ArrayList<>();
354 final Map<String, List<ComponentInstanceOutput>> ciInputsMap = component.getComponentInstancesOutputs();
355 if (ciInputsMap != null && !ciInputsMap.isEmpty()) {
356 ciInputsMap.forEach((s, ciPropList) -> {
358 final Optional<ComponentInstance> ciOp = component.getComponentInstances().stream().filter(ci -> ci.getUniqueId().equals(s))
360 if (ciOp.isPresent()) {
361 ciName = ciOp.get().getName();
363 if (ciPropList != null && !ciPropList.isEmpty()) {
364 for (final ComponentInstanceOutput prop : ciPropList) {
365 final List<GetOutputValueDataDefinition> outputValues = prop.getGetOutputValues();
366 addCompInstanceOutput(s, ciName, prop, outputValues, outputId, resList);
374 private void addCompInstanceInput(String s, String ciName, ComponentInstanceInput prop, List<GetInputValueDataDefinition> inputsValues,
375 String inputId, List<ComponentInstanceInput> resList) {
376 if (inputsValues != null && !inputsValues.isEmpty()) {
377 for (GetInputValueDataDefinition inputData : inputsValues) {
378 if (isGetInputValueForInput(inputData, inputId)) {
379 prop.setComponentInstanceId(s);
380 prop.setComponentInstanceName(ciName);
388 private void addCompInstanceOutput(final String s, final String ciName, final ComponentInstanceOutput prop,
389 final List<GetOutputValueDataDefinition> outputsValues, final String outputId,
390 final List<ComponentInstanceOutput> resList) {
391 if (outputsValues != null && !outputsValues.isEmpty()) {
392 for (final GetOutputValueDataDefinition outputData : outputsValues) {
393 if (isGetOutputValueForOutput(outputData, outputId)) {
394 prop.setComponentInstanceId(s);
395 prop.setComponentInstanceName(ciName);
403 public ComponentInstance createComponentInstance(final String containerComponentParam, final String containerComponentId, final String userId,
404 final ComponentInstance resourceInstance, final boolean needLock) {
405 final User user = validateUserExists(userId);
406 validateUserNotEmpty(user, "Create component instance");
407 validateJsonBody(resourceInstance, ComponentInstance.class);
408 final ComponentTypeEnum containerComponentType = validateComponentType(containerComponentParam);
409 final org.openecomp.sdc.be.model.Component containerComponent = validateComponentExists(containerComponentId, containerComponentType, null);
410 if (ModelConverter.isAtomicComponent(containerComponent)) {
411 if (log.isDebugEnabled()) {
412 log.debug(CANNOT_ATTACH_RESOURCE_INSTANCES_TO_CONTAINER_RESOURCE_OF_TYPE, containerComponent.assetType());
414 throw new ByActionStatusComponentException(ActionStatus.RESOURCE_CANNOT_CONTAIN_RESOURCE_INSTANCES, containerComponent.assetType());
416 validateCanWorkOnComponent(containerComponent, userId);
417 Component origComponent = null;
418 if (resourceInstance != null && containerComponentType != null) {
419 final OriginTypeEnum originType = resourceInstance.getOriginType();
420 validateInstanceName(resourceInstance);
421 if (originType == OriginTypeEnum.ServiceProxy) {
422 origComponent = getOrigComponentForServiceProxy(containerComponent, resourceInstance);
423 } else if (originType == OriginTypeEnum.ServiceSubstitution) {
424 origComponent = getOrigComponentForServiceSubstitution(resourceInstance);
426 origComponent = getAndValidateOriginComponentOfComponentInstance(containerComponent, resourceInstance);
427 validateOriginAndResourceInstanceTypes(containerComponent, origComponent, originType);
429 validateResourceInstanceState(containerComponent, origComponent);
430 overrideFields(origComponent, resourceInstance);
431 compositionBusinessLogic.validateAndSetDefaultCoordinates(resourceInstance);
433 return createComponent(needLock, containerComponent, origComponent, resourceInstance, user);
436 private Component getOrigComponentForServiceProxy(org.openecomp.sdc.be.model.Component containerComponent, ComponentInstance resourceInstance) {
437 Either<Component, StorageOperationStatus> serviceProxyOrigin = toscaOperationFacade.getLatestByName(SERVICE_PROXY, null);
438 if (isServiceProxyOrigin(serviceProxyOrigin)) {
439 throw new ByActionStatusComponentException(componentsUtils.convertFromStorageResponse(serviceProxyOrigin.right().value()));
441 Component origComponent = serviceProxyOrigin.left().value();
442 StorageOperationStatus fillProxyRes = fillInstanceData(resourceInstance, origComponent);
443 if (isFillProxyRes(fillProxyRes)) {
444 throw new ByActionStatusComponentException(componentsUtils.convertFromStorageResponse(fillProxyRes));
446 validateOriginAndResourceInstanceTypes(containerComponent, origComponent, OriginTypeEnum.ServiceProxy);
447 return origComponent;
450 private Component getOrigComponentForServiceSubstitution(ComponentInstance resourceInstance) {
451 final Either<Component, StorageOperationStatus> getServiceResult = toscaOperationFacade
452 .getToscaFullElement(resourceInstance.getComponentUid());
453 if (getServiceResult.isRight()) {
454 throw new ByActionStatusComponentException(componentsUtils.convertFromStorageResponse(getServiceResult.right().value()));
456 final Component service = getServiceResult.left().value();
457 final Either<Component, StorageOperationStatus> getServiceDerivedFromTypeResult = toscaOperationFacade
458 .getLatestByToscaResourceName(service.getDerivedFromGenericType(), service.getModel());
459 if (getServiceDerivedFromTypeResult.isRight()) {
460 throw new ByActionStatusComponentException(componentsUtils.convertFromStorageResponse(getServiceResult.right().value()));
462 Component origComponent = getServiceDerivedFromTypeResult.left().value();
463 final StorageOperationStatus fillProxyRes = fillInstanceData(resourceInstance, origComponent);
464 if (isFillProxyRes(fillProxyRes)) {
465 throw new ByActionStatusComponentException(componentsUtils.convertFromStorageResponse(fillProxyRes));
467 return origComponent;
470 private ComponentInstance createComponent(boolean needLock, Component containerComponent, Component origComponent,
471 ComponentInstance resourceInstance, User user) {
472 boolean failed = false;
474 lockIfNeed(needLock, containerComponent);
475 log.debug(TRY_TO_CREATE_ENTRY_ON_GRAPH);
476 return createComponentInstanceOnGraph(containerComponent, origComponent, resourceInstance, user);
477 } catch (ComponentException e) {
482 unlockComponent(failed, containerComponent);
488 * Try using either to make a judgment
490 * @param containerComponentParam
491 * @param containerComponentId
493 * @param resourceInstance
496 public Either<ComponentInstance, ResponseFormat> createRealComponentInstance(String containerComponentParam, String containerComponentId,
497 String userId, ComponentInstance resourceInstance) {
498 log.debug("enter createRealComponentInstance");
499 return createRealComponentInstance(containerComponentParam, containerComponentId, userId, resourceInstance, true);
503 * Try using either to make a judgment
506 * @param containerComponentParam
507 * @param containerComponentId
509 * @param resourceInstance
512 public Either<ComponentInstance, ResponseFormat> createRealComponentInstance(String containerComponentParam, String containerComponentId,
513 String userId, ComponentInstance resourceInstance,
515 log.debug("enter createRealComponentInstance");
516 Component origComponent = null;
518 org.openecomp.sdc.be.model.Component containerComponent = null;
519 ComponentTypeEnum containerComponentType;
521 user = validateUserExists(userId);
522 validateUserNotEmpty(user, "Create component instance");
523 validateJsonBody(resourceInstance, ComponentInstance.class);
524 containerComponentType = validateComponentType(containerComponentParam);
525 containerComponent = validateComponentExists(containerComponentId, containerComponentType, null);
526 log.debug("enter createRealComponentInstance,validate user json success");
527 if (ModelConverter.isAtomicComponent(containerComponent)) {
528 log.debug(CANNOT_ATTACH_RESOURCE_INSTANCES_TO_CONTAINER_RESOURCE_OF_TYPE, containerComponent.assetType());
529 throw new ByActionStatusComponentException(ActionStatus.RESOURCE_CANNOT_CONTAIN_RESOURCE_INSTANCES, containerComponent.assetType());
531 validateCanWorkOnComponent(containerComponent, userId);
532 log.debug("enter createRealComponentInstance,validateCanWorkOnComponent success");
533 if (resourceInstance != null && containerComponentType != null) {
534 log.debug("enter createRealComponentInstance,start create ComponentInstance");
535 OriginTypeEnum originType = resourceInstance.getOriginType();
536 validateInstanceName(resourceInstance);
537 if (originType == OriginTypeEnum.ServiceProxy) {
538 log.debug("enter createRealComponentInstance,originType equals ServiceProxy");
539 Either<Component, StorageOperationStatus> serviceProxyOrigin = toscaOperationFacade.getLatestByName(SERVICE_PROXY, null);
540 if (isServiceProxyOrigin(serviceProxyOrigin)) {
541 throw new ByActionStatusComponentException(componentsUtils.convertFromStorageResponse(serviceProxyOrigin.right().value()));
543 origComponent = serviceProxyOrigin.left().value();
544 StorageOperationStatus fillProxyRes = fillInstanceData(resourceInstance, origComponent);
545 if (isFillProxyRes(fillProxyRes)) {
546 throw new ByActionStatusComponentException(componentsUtils.convertFromStorageResponse(fillProxyRes));
549 log.debug("enter createRealComponentInstance,originType is not ServiceProxy");
550 origComponent = getAndValidateOriginComponentOfComponentInstance(containerComponent, resourceInstance);
552 validateOriginAndResourceInstanceTypes(containerComponent, origComponent, originType);
553 validateResourceInstanceState(containerComponent, origComponent);
554 overrideFields(origComponent, resourceInstance);
555 compositionBusinessLogic.validateAndSetDefaultCoordinates(resourceInstance);
556 log.debug("enter createRealComponentInstance,final validate success");
558 return createRealComponent(needLock, containerComponent, origComponent, resourceInstance, user);
559 } catch (ComponentException e) {
560 log.debug("create Real Component Instance failed");
565 private Either<ComponentInstance, ResponseFormat> createRealComponent(boolean needLock, Component containerComponent, Component origComponent,
566 ComponentInstance resourceInstance, User user) {
567 log.debug("enter createRealComponent");
568 boolean failed = false;
570 lockIfNeed(needLock, containerComponent);
571 log.debug(TRY_TO_CREATE_ENTRY_ON_GRAPH);
572 return createRealComponentInstanceOnGraph(containerComponent, origComponent, resourceInstance, user);
573 } catch (ComponentException e) {
578 unlockComponent(failed, containerComponent);
583 private Either<ComponentInstance, ResponseFormat> createRealComponentInstanceOnGraph(org.openecomp.sdc.be.model.Component containerComponent,
584 Component originComponent,
585 ComponentInstance componentInstance, User user) {
586 log.debug("enter createRealComponentInstanceOnGraph");
587 Either<ImmutablePair<Component, String>, StorageOperationStatus> result = toscaOperationFacade
588 .addComponentInstanceToTopologyTemplate(containerComponent, originComponent, componentInstance, false, user);
589 if (result.isRight()) {
590 log.debug("enter createRealComponentInstanceOnGraph,result is right");
591 ActionStatus status = componentsUtils.convertFromStorageResponse(result.right().value());
592 log.debug(FAILED_TO_CREATE_ENTRY_ON_GRAPH_FOR_COMPONENT_INSTANCE, componentInstance.getName());
593 return Either.right(componentsUtils.getResponseFormat(status));
595 log.debug(ENTITY_ON_GRAPH_IS_CREATED);
596 log.debug("enter createRealComponentInstanceOnGraph,Entity on graph is created.");
597 Component updatedComponent = result.left().value().getLeft();
598 Map<String, String> existingEnvVersions = new HashMap<>();
599 // TODO existingEnvVersions ??
600 addComponentInstanceArtifacts(updatedComponent, componentInstance, originComponent, user, existingEnvVersions);
601 Optional<ComponentInstance> updatedInstanceOptional = updatedComponent.getComponentInstances().stream()
602 .filter(ci -> ci.getUniqueId().equals(result.left().value().getRight())).findFirst();
603 if (!updatedInstanceOptional.isPresent()) {
604 log.debug("Failed to fetch new added component instance {} from component {}", componentInstance.getName(), containerComponent.getName());
605 throw new ByActionStatusComponentException(ActionStatus.COMPONENT_INSTANCE_NOT_FOUND_ON_CONTAINER, componentInstance.getName());
607 log.debug("enter createRealComponentInstanceOnGraph,and final success");
608 return Either.left(updatedInstanceOptional.get());
611 private void overrideFields(Component origComponent, ComponentInstance resourceInstance) {
612 resourceInstance.setComponentVersion(origComponent.getVersion());
613 resourceInstance.setIcon(origComponent.getIcon());
616 private void validateInstanceName(ComponentInstance resourceInstance) {
617 String resourceInstanceName = resourceInstance.getName();
618 if (StringUtils.isEmpty(resourceInstanceName)) {
619 log.debug("ComponentInstance name is empty");
620 throw new ByActionStatusComponentException(ActionStatus.INVALID_COMPONENT_NAME, resourceInstance.getName());
622 if (!ValidationUtils.validateComponentNameLength(resourceInstanceName)) {
623 log.debug("ComponentInstance name exceeds max length {} ", ValidationUtils.COMPONENT_NAME_MAX_LENGTH);
624 throw new ByActionStatusComponentException(ActionStatus.INVALID_COMPONENT_NAME, resourceInstance.getName());
626 if (!ValidationUtils.validateComponentNamePattern(resourceInstanceName)) {
627 log.debug("ComponentInstance name {} has invalid format", resourceInstanceName);
628 throw new ByActionStatusComponentException(ActionStatus.INVALID_COMPONENT_NAME, resourceInstance.getName());
632 private void validateResourceInstanceState(Component containerComponent, Component origComponent) {
633 if (origComponent.getLifecycleState() == LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT) {
634 throw new ByActionStatusComponentException(ActionStatus.CONTAINER_CANNOT_CONTAIN_INSTANCE,
635 containerComponent.getComponentType().getValue(), origComponent.getLifecycleState().toString());
639 private void validateOriginAndResourceInstanceTypes(final Component containerComponent, final Component origComponent,
640 final OriginTypeEnum originType) {
641 final ResourceTypeEnum resourceType = getResourceTypeEnumFromOriginComponent(origComponent);
642 validateOriginType(originType, resourceType);
643 validateOriginComponentIsValidForContainer(containerComponent, resourceType);
646 private void validateOriginComponentIsValidForContainer(Component containerComponent, ResourceTypeEnum resourceType) {
647 switch (containerComponent.getComponentType()) {
649 if (!containerInstanceTypesData.isAllowedForServiceComponent(resourceType, containerComponent.getModel())) {
650 throw new ByActionStatusComponentException(ActionStatus.CONTAINER_CANNOT_CONTAIN_INSTANCE,
651 containerComponent.getComponentType().toString(), resourceType.name());
655 final ResourceTypeEnum componentResourceType = ((Resource) containerComponent).getResourceType();
656 if (!containerInstanceTypesData.isAllowedForResourceComponent(componentResourceType, resourceType)) {
657 throw new ByActionStatusComponentException(ActionStatus.CONTAINER_CANNOT_CONTAIN_INSTANCE,
658 containerComponent.getComponentType().toString(), resourceType.name());
662 throw new ByActionStatusComponentException(ActionStatus.INVALID_CONTENT);
666 private void validateOriginType(OriginTypeEnum originType, ResourceTypeEnum resourceType) {
667 ResourceTypeEnum convertedOriginType;
669 convertedOriginType = ResourceTypeEnum.getTypeIgnoreCase(originType.name());
670 } catch (Exception e) {
671 throw new ByActionStatusComponentException(ActionStatus.INVALID_CONTENT);
673 if (resourceType != convertedOriginType) {
674 throw new ByActionStatusComponentException(ActionStatus.INVALID_CONTENT);
678 private ResourceTypeEnum getResourceTypeEnumFromOriginComponent(final Component origComponent) {
679 switch (origComponent.getComponentType()) {
681 return ResourceTypeEnum.ServiceProxy;
683 return ((Resource) origComponent).getResourceType();
685 throw new ByActionStatusComponentException(ActionStatus.INVALID_CONTENT);
689 private void lockIfNeed(boolean needLock, Component containerComponent) {
691 lockComponent(containerComponent, "createComponentInstance");
695 private boolean isServiceProxyOrigin(Either<Component, StorageOperationStatus> serviceProxyOrigin) {
696 if (serviceProxyOrigin.isRight()) {
697 log.debug("Failed to fetch normative service proxy resource by tosca name, error {}", serviceProxyOrigin.right().value());
703 private StorageOperationStatus fillInstanceData(ComponentInstance resourceInstance, Component origComponent) {
704 final ComponentParametersView filter = new ComponentParametersView(true);
705 filter.setIgnoreCapabilities(false);
706 filter.setIgnoreCapabiltyProperties(false);
707 filter.setIgnoreComponentInstances(false);
708 filter.setIgnoreRequirements(false);
709 filter.setIgnoreInterfaces(false);
710 filter.setIgnoreProperties(false);
711 filter.setIgnoreAttributes(false);
712 filter.setIgnoreInputs(false);
713 Either<Component, StorageOperationStatus> serviceRes = toscaOperationFacade.getToscaElement(resourceInstance.getComponentUid(), filter);
714 if (serviceRes.isRight()) {
715 return serviceRes.right().value();
717 final Component service = serviceRes.left().value();
718 final Map<String, List<CapabilityDefinition>> capabilities = service.getCapabilities();
719 resourceInstance.setCapabilities(capabilities);
720 final Map<String, List<RequirementDefinition>> req = service.getRequirements();
721 resourceInstance.setRequirements(req);
722 final Map<String, InterfaceDefinition> serviceInterfaces = service.getInterfaces();
723 if (MapUtils.isNotEmpty(serviceInterfaces)) {
724 serviceInterfaces.forEach(resourceInstance::addInterface);
726 resourceInstance.setProperties(PropertiesUtils.getProperties(service));
727 resourceInstance.setAttributes(service.getAttributes());
728 final List<InputDefinition> serviceInputs = service.getInputs();
729 resourceInstance.setInputs(serviceInputs);
730 resourceInstance.setSourceModelInvariant(service.getInvariantUUID());
731 resourceInstance.setSourceModelName(service.getName());
732 resourceInstance.setSourceModelUuid(service.getUUID());
733 resourceInstance.setSourceModelUid(service.getUniqueId());
734 resourceInstance.setComponentUid(origComponent.getUniqueId());
735 resourceInstance.setComponentVersion(service.getVersion());
736 switch (resourceInstance.getOriginType()) {
738 return fillProxyInstanceData(resourceInstance, origComponent, service);
739 case ServiceSubstitution:
740 return fillServiceSubstitutableNodeTypeData(resourceInstance, service);
742 return StorageOperationStatus.OK;
746 private StorageOperationStatus fillProxyInstanceData(final ComponentInstance resourceInstance, final Component origComponent,
747 final Component service) {
748 final String name = ValidationUtils.normalizeComponentInstanceName(service.getName()) + ToscaOperationFacade.PROXY_SUFFIX;
749 final String toscaResourceName = ((Resource) origComponent).getToscaResourceName();
750 final int lastIndexOf = toscaResourceName.lastIndexOf('.');
751 if (lastIndexOf != -1) {
752 final String proxyToscaName = toscaResourceName.substring(0, lastIndexOf + 1) + name;
753 resourceInstance.setToscaComponentName(proxyToscaName);
755 resourceInstance.setName(name);
756 resourceInstance.setIsProxy(true);
757 resourceInstance.setDescription("A Proxy for Service " + service.getName());
758 return StorageOperationStatus.OK;
761 private StorageOperationStatus fillServiceSubstitutableNodeTypeData(final ComponentInstance resourceInstance, final Component service) {
762 resourceInstance.setToscaComponentName("org.openecomp.service." + ValidationUtils.convertToSystemName(service.getName()));
763 resourceInstance.setName(ValidationUtils.normalizeComponentInstanceName(service.getName()));
764 resourceInstance.setIsProxy(false);
765 resourceInstance.setDescription("A substitutable node type for service " + service.getName());
766 return StorageOperationStatus.OK;
769 public Either<CreateAndAssotiateInfo, ResponseFormat> createAndAssociateRIToRI(String containerComponentParam, String containerComponentId,
770 String userId, CreateAndAssotiateInfo createAndAssotiateInfo) {
771 Either<CreateAndAssotiateInfo, ResponseFormat> resultOp = null;
772 ComponentInstance resourceInstance = createAndAssotiateInfo.getNode();
773 RequirementCapabilityRelDef associationInfo = createAndAssotiateInfo.getAssociate();
774 User user = validateUserExists(userId);
775 final ComponentTypeEnum containerComponentType = validateComponentType(containerComponentParam);
776 org.openecomp.sdc.be.model.Component containerComponent = validateComponentExists(containerComponentId, containerComponentType, null);
777 if (ModelConverter.isAtomicComponent(containerComponent)) {
778 log.debug(CANNOT_ATTACH_RESOURCE_INSTANCES_TO_CONTAINER_RESOURCE_OF_TYPE, containerComponent.assetType());
780 .right(componentsUtils.getResponseFormat(ActionStatus.RESOURCE_CANNOT_CONTAIN_RESOURCE_INSTANCES, containerComponent.assetType()));
782 validateCanWorkOnComponent(containerComponent, userId);
783 boolean failed = false;
785 lockComponent(containerComponent, "createAndAssociateRIToRI");
786 log.debug(TRY_TO_CREATE_ENTRY_ON_GRAPH);
787 Component origComponent = getOriginComponentFromComponentInstance(resourceInstance);
788 log.debug(ENTITY_ON_GRAPH_IS_CREATED);
789 ComponentInstance resResourceInfo = createComponentInstanceOnGraph(containerComponent, origComponent, resourceInstance, user);
790 if (associationInfo.getFromNode() == null || associationInfo.getFromNode().isEmpty()) {
791 associationInfo.setFromNode(resResourceInfo.getUniqueId());
793 associationInfo.setToNode(resResourceInfo.getUniqueId());
795 Either<RequirementCapabilityRelDef, StorageOperationStatus> resultReqCapDef = toscaOperationFacade
796 .associateResourceInstances(containerComponent, containerComponentId, associationInfo);
797 if (resultReqCapDef.isLeft()) {
798 log.debug(ENTITY_ON_GRAPH_IS_CREATED);
799 RequirementCapabilityRelDef resReqCapabilityRelDef = resultReqCapDef.left().value();
800 CreateAndAssotiateInfo resInfo = new CreateAndAssotiateInfo(resResourceInfo, resReqCapabilityRelDef);
801 resultOp = Either.left(resInfo);
804 log.info("Failed to associate node {} with node {}", associationInfo.getFromNode(), associationInfo.getToNode());
805 resultOp = Either.right(componentsUtils.getResponseFormatForResourceInstance(
806 componentsUtils.convertFromStorageResponseForResourceInstance(resultReqCapDef.right().value(), true), "", null));
809 } catch (ComponentException e) {
813 unlockComponent(failed, containerComponent);
817 private Component getOriginComponentFromComponentInstance(ComponentInstance componentInstance) {
818 return getOriginComponentFromComponentInstance(componentInstance.getName(), componentInstance.getComponentUid());
821 private Component getInstanceOriginNode(ComponentInstance componentInstance) {
822 return getOriginComponentFromComponentInstance(componentInstance.getName(), componentInstance.getActualComponentUid());
825 private Component getOriginComponentFromComponentInstance(String componentInstanceName, String origComponetId) {
826 Either<Component, StorageOperationStatus> eitherComponent = toscaOperationFacade.getToscaFullElement(origComponetId);
827 if (eitherComponent.isRight()) {
828 log.debug("Failed to get origin component with id {} for component instance {} ", origComponetId, componentInstanceName);
829 throw new ByActionStatusComponentException(
830 componentsUtils.convertFromStorageResponse(eitherComponent.right().value(), ComponentTypeEnum.RESOURCE), "", null);
832 return eitherComponent.left().value();
835 private ComponentInstance createComponentInstanceOnGraph(org.openecomp.sdc.be.model.Component containerComponent, Component originComponent,
836 ComponentInstance componentInstance, User user) {
837 Either<ImmutablePair<Component, String>, StorageOperationStatus> result = toscaOperationFacade
838 .addComponentInstanceToTopologyTemplate(containerComponent, originComponent, componentInstance, false, user);
839 if (result.isRight()) {
840 log.debug(FAILED_TO_CREATE_ENTRY_ON_GRAPH_FOR_COMPONENT_INSTANCE, componentInstance.getName());
841 throw new ByResponseFormatComponentException(componentsUtils
842 .getResponseFormatForResourceInstance(componentsUtils.convertFromStorageResponseForResourceInstance(result.right().value(), true), "",
845 log.debug(ENTITY_ON_GRAPH_IS_CREATED);
846 Component updatedComponent = result.left().value().getLeft();
847 Map<String, String> existingEnvVersions = new HashMap<>();
848 // TODO existingEnvVersions ??
849 addComponentInstanceArtifacts(updatedComponent, componentInstance, originComponent, user, existingEnvVersions);
850 Optional<ComponentInstance> updatedInstanceOptional = updatedComponent.getComponentInstances().stream()
851 .filter(ci -> ci.getUniqueId().equals(result.left().value().getRight())).findFirst();
852 if (!updatedInstanceOptional.isPresent()) {
853 log.debug("Failed to fetch new added component instance {} from component {}", componentInstance.getName(), containerComponent.getName());
854 throw new ByActionStatusComponentException(ActionStatus.COMPONENT_INSTANCE_NOT_FOUND_ON_CONTAINER, componentInstance.getName());
856 return updatedInstanceOptional.get();
859 public boolean isCloudSpecificArtifact(String artifact) {
860 if (artifact.contains(CLOUD_SPECIFIC_FIXED_KEY_WORD)) {
861 for (int i = 0; i < CLOUD_SPECIFIC_KEY_WORDS.length; i++) {
862 if (Arrays.stream(CLOUD_SPECIFIC_KEY_WORDS[i]).noneMatch(artifact::contains)) {
873 * addResourceInstanceArtifacts - add artifacts (HEAT_ENV) to resource instance The instance artifacts are generated from the resource's
876 * @param containerComponent
877 * @param componentInstance
878 * @param originComponent
880 * @param existingEnvVersions
883 protected ActionStatus addComponentInstanceArtifacts(org.openecomp.sdc.be.model.Component containerComponent, ComponentInstance componentInstance,
884 org.openecomp.sdc.be.model.Component originComponent, User user,
885 Map<String, String> existingEnvVersions) {
886 log.debug("add artifacts to resource instance");
887 List<GroupDefinition> filteredGroups = new ArrayList<>();
888 ActionStatus status = setResourceArtifactsOnResourceInstance(componentInstance);
889 if (ActionStatus.OK != status) {
890 throw new ByResponseFormatComponentException(componentsUtils.getResponseFormatForResourceInstance(status, "", null));
892 StorageOperationStatus artStatus;
893 // generate heat_env if necessary
894 Map<String, ArtifactDefinition> componentDeploymentArtifacts = componentInstance.getDeploymentArtifacts();
895 if (MapUtils.isNotEmpty(componentDeploymentArtifacts)) {
896 Map<String, ArtifactDefinition> finalDeploymentArtifacts = new HashMap<>();
897 Map<String, List<ArtifactDefinition>> groupInstancesArtifacts = new HashMap<>();
898 Integer defaultHeatTimeout = ConfigurationManager.getConfigurationManager().getConfiguration().getHeatArtifactDeploymentTimeout()
899 .getDefaultMinutes();
900 List<ArtifactDefinition> listOfCloudSpecificArts = new ArrayList<>();
901 for (ArtifactDefinition artifact : componentDeploymentArtifacts.values()) {
902 String type = artifact.getArtifactType();
903 if (!type.equalsIgnoreCase(ArtifactTypeEnum.HEAT_ENV.getType())) {
904 finalDeploymentArtifacts.put(artifact.getArtifactLabel(), artifact);
906 if (type.equalsIgnoreCase(ArtifactTypeEnum.HEAT.getType()) || type.equalsIgnoreCase(ArtifactTypeEnum.HELM.getType()) || type
907 .equalsIgnoreCase(ArtifactTypeEnum.HEAT_NET.getType()) || type.equalsIgnoreCase(ArtifactTypeEnum.HEAT_VOL.getType()) || type
908 .equalsIgnoreCase(ArtifactTypeEnum.CLOUD_TECHNOLOGY_SPECIFIC_ARTIFACT.getType())) {
909 artifact.setTimeout(defaultHeatTimeout);
913 if (artifact.checkEsIdExist()) {
914 ArtifactDefinition artifactDefinition = artifactBusinessLogic
915 .createHeatEnvPlaceHolder(new ArrayList<>(), artifact, ArtifactsBusinessLogic.HEAT_ENV_NAME, componentInstance.getUniqueId(),
916 NodeTypeEnum.ResourceInstance, componentInstance.getName(), user, containerComponent, existingEnvVersions);
918 finalDeploymentArtifacts.put(artifactDefinition.getArtifactLabel(), artifactDefinition);
919 if (CollectionUtils.isNotEmpty(originComponent.getGroups())) {
920 filteredGroups = originComponent.getGroups().stream().filter(g -> g.getType().equals(VF_MODULE)).collect(Collectors.toList());
922 if (isCloudSpecificArtifact(artifactDefinition.getArtifactName())) {
923 listOfCloudSpecificArts.add(artifact);
925 if (CollectionUtils.isNotEmpty(filteredGroups)) {
926 filteredGroups.stream()
927 .filter(g -> g.getArtifacts() != null && g.getArtifacts().stream().anyMatch(p -> p.equals(artifactDefinition.getGeneratedFromId()))).findFirst()
928 .ifPresent(g -> fillInstanceArtifactMap(groupInstancesArtifacts, artifactDefinition, g));
932 groupInstancesArtifacts.forEach((k, v) -> v.addAll(listOfCloudSpecificArts));
933 filteredGroups.forEach(g -> listOfCloudSpecificArts.forEach(e -> {
934 g.getArtifactsUuid().add(e.getArtifactUUID());
935 g.getArtifacts().add(e.getUniqueId());
937 artStatus = toscaOperationFacade
938 .addDeploymentArtifactsToInstance(containerComponent.getUniqueId(), componentInstance, finalDeploymentArtifacts);
939 if (artStatus != StorageOperationStatus.OK) {
940 log.debug("Failed to add instance deployment artifacts for instance {} in conatiner {} error {}", componentInstance.getUniqueId(),
941 containerComponent.getUniqueId(), artStatus);
942 throw new ByResponseFormatComponentException(
943 componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponseForResourceInstance(artStatus, false)));
945 StorageOperationStatus result = toscaOperationFacade
946 .addGroupInstancesToComponentInstance(containerComponent, componentInstance, filteredGroups, groupInstancesArtifacts);
947 if (result != StorageOperationStatus.OK) {
948 log.debug("failed to update group instance for component instance {}", componentInstance.getUniqueId());
949 throw new ByResponseFormatComponentException(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(result)));
951 componentInstance.setDeploymentArtifacts(finalDeploymentArtifacts);
953 artStatus = toscaOperationFacade
954 .addInformationalArtifactsToInstance(containerComponent.getUniqueId(), componentInstance, originComponent.getArtifacts());
955 if (artStatus != StorageOperationStatus.OK) {
956 log.debug("Failed to add informational artifacts to the instance {} belonging to the conatiner {}. Status is {}",
957 componentInstance.getUniqueId(), containerComponent.getUniqueId(), artStatus);
958 throw new ByResponseFormatComponentException(
959 componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponseForResourceInstance(artStatus, false)));
961 componentInstance.setArtifacts(originComponent.getArtifacts());
962 return ActionStatus.OK;
965 private void fillInstanceArtifactMap(Map<String, List<ArtifactDefinition>> groupInstancesArtifacts, ArtifactDefinition artifactDefinition,
966 GroupDefinition groupInstance) {
967 List<ArtifactDefinition> artifactsUid;
968 if (groupInstancesArtifacts.containsKey(groupInstance.getUniqueId())) {
969 artifactsUid = groupInstancesArtifacts.get(groupInstance.getUniqueId());
971 artifactsUid = new ArrayList<>();
973 artifactsUid.add(artifactDefinition);
974 groupInstancesArtifacts.put(groupInstance.getUniqueId(), artifactsUid);
977 private ActionStatus setResourceArtifactsOnResourceInstance(ComponentInstance resourceInstance) {
978 Either<Map<String, ArtifactDefinition>, StorageOperationStatus> getResourceDeploymentArtifacts = artifactBusinessLogic
979 .getArtifacts(resourceInstance.getComponentUid(), NodeTypeEnum.Resource, ArtifactGroupTypeEnum.DEPLOYMENT, null);
980 Map<String, ArtifactDefinition> deploymentArtifacts = new HashMap<>();
981 if (getResourceDeploymentArtifacts.isRight()) {
982 StorageOperationStatus status = getResourceDeploymentArtifacts.right().value();
983 if (status != StorageOperationStatus.NOT_FOUND) {
984 log.debug("Failed to fetch resource: {} artifacts. status is {}", resourceInstance.getComponentUid(), status);
985 return componentsUtils.convertFromStorageResponseForResourceInstance(status, true);
988 deploymentArtifacts = getResourceDeploymentArtifacts.left().value();
990 if (!deploymentArtifacts.isEmpty()) {
991 Map<String, ArtifactDefinition> tempDeploymentArtifacts = new HashMap<>(deploymentArtifacts);
992 for (Entry<String, ArtifactDefinition> artifact : deploymentArtifacts.entrySet()) {
993 if (!artifact.getValue().checkEsIdExist()) {
994 tempDeploymentArtifacts.remove(artifact.getKey());
997 resourceInstance.setDeploymentArtifacts(tempDeploymentArtifacts);
999 return ActionStatus.OK;
1002 public Either<ComponentInstance, ResponseFormat> updateComponentInstanceMetadata(String containerComponentParam, String containerComponentId,
1003 String componentInstanceId, String userId,
1004 ComponentInstance componentInstance) {
1005 return updateComponentInstanceMetadata(containerComponentParam, containerComponentId, componentInstanceId, userId, componentInstance, true);
1008 public Either<ComponentInstance, ResponseFormat> updateComponentInstanceMetadata(final String containerComponentParam,
1009 final String containerComponentId,
1010 final String componentInstanceId, final String userId,
1011 ComponentInstance componentInstance, boolean needLock) {
1012 validateUserExists(userId);
1013 final ComponentTypeEnum containerComponentType = validateComponentType(containerComponentParam);
1014 final Component containerComponent = validateComponentExists(containerComponentId, containerComponentType, null);
1015 validateCanWorkOnComponent(containerComponent, userId);
1016 ComponentTypeEnum instanceType = getComponentType(containerComponentType);
1017 Either<Boolean, StorageOperationStatus> validateParentStatus = toscaOperationFacade
1018 .validateComponentExists(componentInstance.getComponentUid());
1019 if (validateParentStatus.isRight()) {
1020 log.debug("Failed to get component instance {} on service {}", componentInstanceId, containerComponentId);
1021 throw new ByActionStatusComponentException(ActionStatus.COMPONENT_INSTANCE_NOT_FOUND, componentInstance.getName(),
1022 instanceType.getValue().toLowerCase());
1024 if (!Boolean.TRUE.equals(validateParentStatus.left().value())) {
1025 throw new ByActionStatusComponentException(ActionStatus.COMPONENT_INSTANCE_NOT_FOUND_ON_CONTAINER, componentInstance.getName(),
1026 instanceType.getValue().toLowerCase(), containerComponentType.getValue().toLowerCase(), containerComponentId);
1029 lockComponent(containerComponent, "updateComponentInstance");
1031 Component origComponent;
1032 boolean failed = false;
1034 origComponent = getOriginComponentFromComponentInstance(componentInstance);
1035 componentInstance = updateComponentInstanceMetadata(containerComponent, containerComponentType, origComponent, componentInstanceId,
1037 } catch (ComponentException e) {
1042 unlockComponent(failed, containerComponent);
1045 return Either.left(componentInstance);
1048 // New Multiple Instance Update API
1049 public List<ComponentInstance> updateComponentInstance(String containerComponentParam, Component containerComponent, String containerComponentId,
1050 String userId, List<ComponentInstance> componentInstanceList, boolean needLock) {
1051 boolean failed = false;
1053 validateUserExists(userId);
1054 final ComponentTypeEnum containerComponentType = validateComponentType(containerComponentParam);
1055 ComponentParametersView componentFilter = new ComponentParametersView();
1056 componentFilter.disableAll();
1057 componentFilter.setIgnoreUsers(false);
1058 componentFilter.setIgnoreComponentInstances(false);
1059 if (containerComponent == null) {
1060 containerComponent = validateComponentExistsByFilter(containerComponentId, containerComponentType, componentFilter);
1062 validateCanWorkOnComponent(containerComponent, userId);
1063 ComponentTypeEnum instanceType = getComponentType(containerComponentType);
1064 for (ComponentInstance componentInstance : componentInstanceList) {
1065 boolean validateParent = validateParent(containerComponent, componentInstance.getUniqueId());
1066 if (!validateParent) {
1067 throw new ByActionStatusComponentException(ActionStatus.COMPONENT_INSTANCE_NOT_FOUND_ON_CONTAINER, componentInstance.getName(),
1068 instanceType.getValue().toLowerCase(), containerComponentType.getValue().toLowerCase(), containerComponentId);
1072 lockComponent(containerComponent, "updateComponentInstance");
1074 List<ComponentInstance> updatedList = new ArrayList<>();
1075 List<ComponentInstance> instancesFromContainerComponent = containerComponent.getComponentInstances();
1076 List<ComponentInstance> listForUpdate = new ArrayList<>();
1077 if (instancesFromContainerComponent == null || instancesFromContainerComponent.isEmpty()) {
1078 containerComponent.setComponentInstances(componentInstanceList);
1080 Iterator<ComponentInstance> iterator = instancesFromContainerComponent.iterator();
1081 while (iterator.hasNext()) {
1082 ComponentInstance origInst = iterator.next();
1083 Optional<ComponentInstance> op = componentInstanceList.stream().filter(ci -> ci.getUniqueId().equals(origInst.getUniqueId()))
1085 if (op.isPresent()) {
1086 ComponentInstance updatedCi = op.get();
1087 updatedCi = buildComponentInstance(updatedCi, origInst);
1088 Boolean isUniqueName = validateInstanceNameUniquenessUponUpdate(containerComponent, origInst, updatedCi.getName());
1089 if (!Boolean.TRUE.equals(isUniqueName)) {
1090 CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG,
1091 "Failed to update the name of the component instance {} to {}. A component instance with the same name already exists. ",
1092 origInst.getName(), updatedCi.getName());
1093 throw new ByResponseFormatComponentException(componentsUtils
1094 .getResponseFormat(ActionStatus.COMPONENT_NAME_ALREADY_EXIST, containerComponentType.getValue(), origInst.getName()));
1096 listForUpdate.add(updatedCi);
1098 listForUpdate.add(origInst);
1101 containerComponent.setComponentInstances(listForUpdate);
1102 Either<Component, StorageOperationStatus> updateStatus = toscaOperationFacade
1103 .updateComponentInstanceMetadataOfTopologyTemplate(containerComponent, componentFilter);
1104 if (updateStatus.isRight()) {
1106 .addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to update metadata belonging to container component {}. Status is {}. ",
1107 containerComponent.getName(), updateStatus.right().value());
1108 throw new ByResponseFormatComponentException(componentsUtils.getResponseFormatForResourceInstance(
1109 componentsUtils.convertFromStorageResponseForResourceInstance(updateStatus.right().value(), true), "", null));
1111 for (ComponentInstance updatedInstance : updateStatus.left().value().getComponentInstances()) {
1112 Optional<ComponentInstance> op = componentInstanceList.stream().filter(ci -> ci.getName().equals(updatedInstance.getName()))
1114 if (op.isPresent()) {
1115 updatedList.add(updatedInstance);
1120 } catch (ComponentException e) {
1125 unlockComponent(failed, containerComponent);
1130 private boolean validateParent(org.openecomp.sdc.be.model.Component containerComponent, String nodeTemplateId) {
1131 return containerComponent.getComponentInstances().stream().anyMatch(p -> p.getUniqueId().equals(nodeTemplateId));
1134 private ComponentTypeEnum getComponentType(ComponentTypeEnum containerComponentType) {
1135 if (ComponentTypeEnum.PRODUCT == containerComponentType) {
1136 return ComponentTypeEnum.SERVICE_INSTANCE;
1138 return ComponentTypeEnum.RESOURCE_INSTANCE;
1142 private ComponentInstance updateComponentInstanceMetadata(Component containerComponent, ComponentTypeEnum containerComponentType,
1143 org.openecomp.sdc.be.model.Component origComponent, String componentInstanceId,
1144 ComponentInstance componentInstance) {
1145 Optional<ComponentInstance> componentInstanceOptional;
1146 Either<ImmutablePair<Component, String>, StorageOperationStatus> updateRes = null;
1147 ComponentInstance oldComponentInstance = null;
1148 boolean isNameChanged = false;
1149 componentInstanceOptional = containerComponent.getComponentInstances().stream()
1150 .filter(ci -> ci.getUniqueId().equals(componentInstance.getUniqueId())).findFirst();
1151 if (!componentInstanceOptional.isPresent()) {
1152 CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to find the component instance {} in container component {}. ",
1153 componentInstance.getName(), containerComponent.getName());
1154 throw new ByActionStatusComponentException(ActionStatus.COMPONENT_INSTANCE_NOT_FOUND_ON_CONTAINER, componentInstance.getName());
1156 String oldComponentName;
1157 oldComponentInstance = componentInstanceOptional.get();
1158 oldComponentName = oldComponentInstance.getName();
1159 String newInstanceName = componentInstance.getName();
1160 if (oldComponentName != null && !oldComponentInstance.getName().equals(newInstanceName)) {
1161 isNameChanged = true;
1163 Boolean isUniqueName = validateInstanceNameUniquenessUponUpdate(containerComponent, oldComponentInstance, newInstanceName);
1164 if (!Boolean.TRUE.equals(isUniqueName)) {
1165 CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG,
1166 "Failed to update the name of the component instance {} to {}. A component instance with the same name already exists. ",
1167 oldComponentInstance.getName(), newInstanceName);
1168 throw new ByActionStatusComponentException(ActionStatus.COMPONENT_NAME_ALREADY_EXIST, containerComponentType.getValue(),
1169 componentInstance.getName());
1171 if (!DirectivesUtil.isValid(componentInstance.getDirectives())) {
1172 final String directivesStr = componentInstance.getDirectives().stream().collect(Collectors.joining(" , ", " [ ", " ] "));
1173 CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG,
1174 "Failed to update the directives of the component instance {} to {}. Directives data {} is invalid. ", oldComponentInstance.getName(),
1175 newInstanceName, directivesStr);
1176 throw new ByActionStatusComponentException(ActionStatus.DIRECTIVES_INVALID_VALUE, containerComponentType.getValue(),
1177 componentInstance.getName());
1179 updateRes = toscaOperationFacade.updateComponentInstanceMetadataOfTopologyTemplate(containerComponent, origComponent,
1180 updateComponentInstanceMetadata(oldComponentInstance, componentInstance));
1181 if (updateRes.isRight()) {
1182 CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG,
1183 "Failed to update metadata of component instance {} belonging to container component {}. Status is {}. ", componentInstance.getName(),
1184 containerComponent.getName(), updateRes.right().value());
1185 throw new ByResponseFormatComponentException(componentsUtils
1186 .getResponseFormatForResourceInstance(componentsUtils.convertFromStorageResponseForResourceInstance(updateRes.right().value(), true),
1189 // region - Update instance Groups
1190 if (isNameChanged) {
1191 Either<StorageOperationStatus, StorageOperationStatus> result = toscaOperationFacade
1192 .cleanAndAddGroupInstancesToComponentInstance(containerComponent, oldComponentInstance, componentInstanceId);
1193 if (result.isRight()) {
1195 .addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to rename group instances for container {}. error {} ", componentInstanceId,
1196 result.right().value());
1198 if (containerComponent instanceof Service) {
1199 Either<ComponentInstance, ResponseFormat> renameEither = renameServiceFilter((Service) containerComponent, newInstanceName,
1200 oldComponentInstance.getName());
1201 if (renameEither.isRight()) {
1202 throw new ByResponseFormatComponentException(renameEither.right().value());
1204 updateForwardingPathDefinition(containerComponent, componentInstance, oldComponentName);
1209 String newInstanceId = updateRes.left().value().getRight();
1210 Optional<ComponentInstance> updatedInstanceOptional = updateRes.left().value().getLeft().getComponentInstances().stream()
1211 .filter(ci -> ci.getUniqueId().equals(newInstanceId)).findFirst();
1212 if (!updatedInstanceOptional.isPresent()) {
1213 log.debug("Failed to update metadata of component instance {} of container component {}", componentInstance.getName(),
1214 containerComponent.getName());
1215 throw new ByResponseFormatComponentException(
1216 componentsUtils.getResponseFormat(ActionStatus.COMPONENT_INSTANCE_NOT_FOUND_ON_CONTAINER, componentInstance.getName()));
1218 return componentInstanceOptional.get();
1221 private void updateForwardingPathDefinition(Component containerComponent, ComponentInstance componentInstance, String oldComponentName) {
1222 Collection<ForwardingPathDataDefinition> forwardingPathDataDefinitions = getForwardingPathDataDefinitions(containerComponent.getUniqueId());
1223 Set<ForwardingPathDataDefinition> updated = new ForwardingPathUtils()
1224 .updateComponentInstanceName(forwardingPathDataDefinitions, oldComponentName, componentInstance.getName());
1225 updated.forEach(fp -> {
1226 Either<ForwardingPathDataDefinition, StorageOperationStatus> resultEither = forwardingPathOperation
1227 .updateForwardingPath(containerComponent.getUniqueId(), fp);
1228 if (resultEither.isRight()) {
1229 CommonUtility.addRecordToLog(log, LogLevelEnum.ERROR, "Failed to rename forwarding path for container {}. error {} ",
1230 containerComponent.getName(), resultEither.right().value());
1235 public Either<ComponentInstance, ResponseFormat> renameServiceFilter(final Service containerComponent, final String newInstanceName,
1236 final String oldInstanceName) {
1237 Map<String, CINodeFilterDataDefinition> renamedNodesFilter = ServiceFilterUtils
1238 .getRenamedNodesFilter(containerComponent, oldInstanceName, newInstanceName);
1239 for (Entry<String, CINodeFilterDataDefinition> entry : renamedNodesFilter.entrySet()) {
1240 Either<CINodeFilterDataDefinition, StorageOperationStatus> renameEither = nodeFilterOperation
1241 .updateNodeFilter(containerComponent.getUniqueId(), entry.getKey(), entry.getValue());
1242 if (renameEither.isRight()) {
1243 return Either.right(componentsUtils.getResponseFormatForResourceInstance(
1244 componentsUtils.convertFromStorageResponse(renameEither.right().value(), ComponentTypeEnum.SERVICE), containerComponent.getName(),
1248 return Either.left(null);
1252 * @param oldPrefix- The normalized old vf name
1253 * @param newNormailzedPrefix- The normalized new vf name
1254 * @param qualifiedGroupInstanceName- old Group Instance Name
1257 // modify group names
1258 private String getNewGroupName(String oldPrefix, String newNormailzedPrefix, String qualifiedGroupInstanceName) {
1259 if (qualifiedGroupInstanceName == null) {
1260 log.info("CANNOT change group name ");
1263 if (qualifiedGroupInstanceName.startsWith(oldPrefix) || qualifiedGroupInstanceName
1264 .startsWith(ValidationUtils.normalizeComponentInstanceName(oldPrefix))) {
1265 return qualifiedGroupInstanceName.replaceFirst(oldPrefix, newNormailzedPrefix);
1267 return qualifiedGroupInstanceName;
1270 private ComponentInstance updateComponentInstanceMetadata(ComponentInstance oldComponentInstance, ComponentInstance newComponentInstance) {
1271 oldComponentInstance.setName(newComponentInstance.getName());
1272 oldComponentInstance.setModificationTime(System.currentTimeMillis());
1273 oldComponentInstance.setCustomizationUUID(UUID.randomUUID().toString());
1274 oldComponentInstance.setDirectives(newComponentInstance.getDirectives());
1275 oldComponentInstance.setMaxOccurrences(newComponentInstance.getMaxOccurrences());
1276 oldComponentInstance.setMinOccurrences(newComponentInstance.getMinOccurrences());
1277 oldComponentInstance.setInstanceCount(newComponentInstance.getInstanceCount());
1278 if (oldComponentInstance.getGroupInstances() != null) {
1279 oldComponentInstance.getGroupInstances().forEach(group -> group.setName(getNewGroupName(oldComponentInstance.getNormalizedName(),
1280 ValidationUtils.normalizeComponentInstanceName(newComponentInstance.getName()), group.getName())));
1282 return oldComponentInstance;
1285 public ComponentInstance deleteComponentInstance(final String containerComponentParam, final String containerComponentId,
1286 final String componentInstanceId, String userId) throws BusinessLogicException {
1287 validateUserExists(userId);
1288 final ComponentTypeEnum containerComponentType = validateComponentType(containerComponentParam);
1289 final Component containerComponent = validateComponentExists(containerComponentId, containerComponentType, null);
1290 validateCanWorkOnComponent(containerComponent, userId);
1291 boolean failed = false;
1292 final Optional<ComponentInstance> componentInstanceOptional = containerComponent.getComponentInstanceById(componentInstanceId);
1293 if (!componentInstanceOptional.isPresent()) {
1294 throw new BusinessLogicException(componentsUtils.getResponseFormat(ActionStatus.COMPONENT_INSTANCE_NOT_FOUND));
1296 ComponentInstance componentInstance = componentInstanceOptional.get();
1298 if (containerComponent instanceof Service || containerComponent instanceof Resource) {
1299 final Either<String, StorageOperationStatus> deleteServiceFilterEither = nodeFilterOperation
1300 .deleteNodeFilter(containerComponent, componentInstanceId);
1301 if (deleteServiceFilterEither.isRight()) {
1302 final ActionStatus status = componentsUtils
1303 .convertFromStorageResponse(deleteServiceFilterEither.right().value(), containerComponentType);
1304 janusGraphDao.rollback();
1305 throw new ByResponseFormatComponentException(componentsUtils.getResponseFormat(status, componentInstanceId));
1307 final Either<ComponentInstance, ResponseFormat> resultOp = deleteNodeFiltersFromComponentInstance(containerComponent,
1308 componentInstance, containerComponentType, userId);
1309 if (resultOp.isRight()) {
1310 janusGraphDao.rollback();
1311 throw new ByResponseFormatComponentException(resultOp.right().value());
1314 lockComponent(containerComponent, "deleteComponentInstance");
1315 final ComponentInstance deletedCompInstance = deleteComponentInstance(containerComponent, componentInstanceId, containerComponentType);
1316 componentInstance = deleteForwardingPathsRelatedTobeDeletedComponentInstance(containerComponentId, containerComponentType,
1317 deletedCompInstance);
1318 final ActionStatus onDeleteOperationsStatus = onChangeInstanceOperationOrchestrator
1319 .doOnDeleteInstanceOperations(containerComponent, componentInstanceId);
1320 if (ActionStatus.OK != onDeleteOperationsStatus) {
1321 throw new ByActionStatusComponentException(onDeleteOperationsStatus);
1323 } catch (final ComponentException e) {
1327 unlockComponent(failed, containerComponent);
1329 return componentInstance;
1333 * Try to modify the delete and return two cases
1335 * @param containerComponentParam
1336 * @param containerComponentId
1337 * @param componentInstanceId
1341 public Either<ComponentInstance, ResponseFormat> deleteAbstractComponentInstance(String containerComponentParam, String containerComponentId,
1342 String componentInstanceId, String userId) {
1343 log.debug("enter deleteAbstractComponentInstance");
1344 validateUserExists(userId);
1345 final ComponentTypeEnum containerComponentType = validateComponentType(containerComponentParam);
1346 org.openecomp.sdc.be.model.Component containerComponent = validateComponentExists(containerComponentId, containerComponentType, null);
1347 validateCanWorkOnComponent(containerComponent, userId);
1348 boolean failed = false;
1349 ComponentInstance deletedRelatedInst;
1351 if (containerComponent instanceof Service) {
1352 final Optional<ComponentInstance> componentInstanceById = containerComponent.getComponentInstanceById(componentInstanceId);
1353 if (componentInstanceById.isPresent()) {
1354 ComponentInstance componentInstance = componentInstanceById.get();
1355 Either<String, StorageOperationStatus> deleteServiceFilterEither = nodeFilterOperation
1356 .deleteNodeFilter(containerComponent, componentInstanceId);
1357 if (deleteServiceFilterEither.isRight()) {
1358 log.debug("enter deleteAbstractComponentInstance:deleteServiceFilterEither is right, filed");
1359 ActionStatus status = componentsUtils
1360 .convertFromStorageResponse(deleteServiceFilterEither.right().value(), containerComponentType);
1361 janusGraphDao.rollback();
1362 return Either.right(componentsUtils.getResponseFormat(status, componentInstance.getName()));
1364 Either<ComponentInstance, ResponseFormat> resultOp = deleteNodeFiltersFromComponentInstance(containerComponent, componentInstance,
1365 ComponentTypeEnum.SERVICE, userId);
1366 if (resultOp.isRight()) {
1367 log.debug("enter deleteAbstractComponentInstance:resultOp is right, filed");
1368 janusGraphDao.rollback();
1373 log.debug("enter deleteAbstractComponentInstance:");
1374 lockComponent(containerComponent, "deleteComponentInstance");
1375 ComponentInstance deletedCompInstance = deleteComponentInstance(containerComponent, componentInstanceId, containerComponentType);
1376 deletedRelatedInst = deleteForwardingPathsRelatedTobeDeletedComponentInstance(containerComponentId, containerComponentType,
1377 deletedCompInstance);
1378 ActionStatus onDeleteOperationsStatus = onChangeInstanceOperationOrchestrator
1379 .doOnDeleteInstanceOperations(containerComponent, componentInstanceId);
1380 log.debug("enter deleteAbstractComponentInstance,get onDeleteOperationsStatus:{}", onDeleteOperationsStatus);
1381 if (ActionStatus.OK != onDeleteOperationsStatus) {
1382 throw new ByActionStatusComponentException(onDeleteOperationsStatus);
1384 } catch (ComponentException e) {
1388 unlockComponent(failed, containerComponent);
1390 log.debug("enter deleteAbstractComponentInstance,deleted RelatedInst success");
1391 return Either.left(deletedRelatedInst);
1394 public Either<ComponentInstance, ResponseFormat> deleteNodeFiltersFromComponentInstance(final Component component,
1395 final ComponentInstance componentInstance,
1396 final ComponentTypeEnum containerComponentType,
1397 final String userId) {
1398 final Set<String> componentFiltersIDsToBeDeleted = getComponentFiltersRelatedToComponentInstance(component.getUniqueId(), componentInstance);
1399 if (!componentFiltersIDsToBeDeleted.isEmpty()) {
1400 final Set<String> ids = component.getComponentInstances().stream().filter(ci -> componentFiltersIDsToBeDeleted.contains(ci.getName()))
1401 .map(ComponentInstance::getUniqueId).collect(Collectors.toSet());
1402 final Either<Set<String>, StorageOperationStatus> deleteComponentNodeFiltersEither = nodeFilterOperation
1403 .deleteNodeFilters(component, ids);
1404 if (deleteComponentNodeFiltersEither.isRight()) {
1405 final ActionStatus status = componentsUtils
1406 .convertFromStorageResponse(deleteComponentNodeFiltersEither.right().value(), containerComponentType);
1407 return Either.right(componentsUtils.getResponseFormat(status, componentInstance.getName()));
1409 for (final String id : ids) {
1410 final Optional<ComponentInstance> componentInstanceById = component.getComponentInstanceById(id);
1411 if (!componentInstanceById.isPresent()) {
1412 return Either.right(componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR));
1414 final ComponentInstance componentInstanceToBeUpdated = componentInstanceById.get();
1415 componentInstanceToBeUpdated.setDirectives(Collections.emptyList());
1416 final Either<ComponentInstance, ResponseFormat> componentInstanceResponseFormatEither = updateComponentInstanceMetadata(
1417 containerComponentType.getValue(), component.getUniqueId(), componentInstanceToBeUpdated.getUniqueId(), userId,
1418 componentInstanceToBeUpdated, false);
1419 if (componentInstanceResponseFormatEither.isRight()) {
1420 return componentInstanceResponseFormatEither;
1424 return Either.left(componentInstance);
1427 private Set<String> getComponentFiltersRelatedToComponentInstance(String containerComponentId, ComponentInstance componentInstance) {
1428 ComponentParametersView filter = new ComponentParametersView(true);
1429 filter.setIgnoreComponentInstances(false);
1430 Either<Component, StorageOperationStatus> componentFilterOrigin = toscaOperationFacade.getToscaElement(containerComponentId, filter);
1431 final Component component = componentFilterOrigin.left().value();
1432 return ComponentsUtils.getNodesFiltersToBeDeleted(component, componentInstance);
1435 ComponentInstance deleteForwardingPathsRelatedTobeDeletedComponentInstance(String containerComponentId, ComponentTypeEnum containerComponentType,
1436 ComponentInstance componentInstance) {
1437 if (containerComponentType == ComponentTypeEnum.SERVICE) {
1438 List<String> pathIDsToBeDeleted = getForwardingPathsRelatedToComponentInstance(containerComponentId, componentInstance.getName());
1439 if (!pathIDsToBeDeleted.isEmpty()) {
1440 deleteForwardingPaths(containerComponentId, pathIDsToBeDeleted);
1443 return componentInstance;
1446 private void deleteForwardingPaths(String serviceId, List<String> pathIdsToDelete) {
1447 Either<Service, StorageOperationStatus> storageStatus = toscaOperationFacade.getToscaElement(serviceId);
1448 if (storageStatus.isRight()) {
1449 throw new ByActionStatusComponentException(componentsUtils.convertFromStorageResponse(storageStatus.right().value()));
1451 Either<Set<String>, StorageOperationStatus> result = forwardingPathOperation
1452 .deleteForwardingPath(storageStatus.left().value(), Sets.newHashSet(pathIdsToDelete));
1453 if (result.isRight()) {
1454 throw new ByActionStatusComponentException(componentsUtils.convertFromStorageResponse(result.right().value()));
1458 private List<String> getForwardingPathsRelatedToComponentInstance(String containerComponentId, String componentInstanceId) {
1459 Collection<ForwardingPathDataDefinition> allPaths = getForwardingPathDataDefinitions(containerComponentId);
1460 List<String> pathIDsToBeDeleted = new ArrayList<>();
1461 allPaths.stream().filter(path -> isPathRelatedToComponent(path, componentInstanceId))
1462 .forEach(path -> pathIDsToBeDeleted.add(path.getUniqueId()));
1463 return pathIDsToBeDeleted;
1466 private Collection<ForwardingPathDataDefinition> getForwardingPathDataDefinitions(String containerComponentId) {
1467 ComponentParametersView filter = new ComponentParametersView(true);
1468 filter.setIgnoreServicePath(false);
1469 Either<Service, StorageOperationStatus> forwardingPathOrigin = toscaOperationFacade.getToscaElement(containerComponentId, filter);
1470 return forwardingPathOrigin.left().value().getForwardingPaths().values();
1473 private boolean isPathRelatedToComponent(ForwardingPathDataDefinition pathDataDefinition, String componentInstanceId) {
1474 return pathDataDefinition.getPathElements().getListToscaDataDefinition().stream().anyMatch(
1475 elementDataDefinition -> elementDataDefinition.getFromNode().equalsIgnoreCase(componentInstanceId) || elementDataDefinition.getToNode()
1476 .equalsIgnoreCase(componentInstanceId));
1479 private ComponentInstance deleteComponentInstance(Component containerComponent, String componentInstanceId,
1480 ComponentTypeEnum containerComponentType) {
1481 Either<ImmutablePair<Component, String>, StorageOperationStatus> deleteRes = toscaOperationFacade
1482 .deleteComponentInstanceFromTopologyTemplate(containerComponent, componentInstanceId);
1483 if (deleteRes.isRight()) {
1484 log.debug("Failed to delete entry on graph for resourceInstance {}", componentInstanceId);
1485 ActionStatus status = componentsUtils.convertFromStorageResponse(deleteRes.right().value(), containerComponentType);
1486 throw new ByActionStatusComponentException(status, componentInstanceId);
1488 log.debug("The component instance {} has been removed from container component {}. ", componentInstanceId, containerComponent);
1489 ComponentInstance deletedInstance = findAndRemoveComponentInstanceFromContainerComponent(componentInstanceId, containerComponent);
1490 if (CollectionUtils.isNotEmpty(containerComponent.getInputs())) {
1491 List<InputDefinition> inputsToDelete = containerComponent.getInputs().stream()
1492 .filter(i -> i.getInstanceUniqueId() != null && i.getInstanceUniqueId().equals(componentInstanceId)).collect(Collectors.toList());
1493 if (CollectionUtils.isNotEmpty(inputsToDelete)) {
1494 StorageOperationStatus deleteInputsRes = toscaOperationFacade
1495 .deleteComponentInstanceInputsFromTopologyTemplate(containerComponent, inputsToDelete);
1496 if (deleteInputsRes != StorageOperationStatus.OK) {
1497 log.debug("Failed to delete inputs of the component instance {} from container component. ", componentInstanceId);
1498 throw new ByActionStatusComponentException(componentsUtils.convertFromStorageResponse(deleteInputsRes, containerComponentType),
1499 componentInstanceId);
1503 if (CollectionUtils.isNotEmpty(containerComponent.getOutputs())) {
1504 final List<OutputDefinition> outputsToDelete = containerComponent.getOutputs().stream()
1505 .filter(i -> i.getInstanceUniqueId() != null && i.getInstanceUniqueId().equals(componentInstanceId)).collect(Collectors.toList());
1506 if (CollectionUtils.isNotEmpty(outputsToDelete)) {
1507 final StorageOperationStatus deleteOutputsRes = toscaOperationFacade
1508 .deleteComponentInstanceOutputsFromTopologyTemplate(containerComponent, outputsToDelete);
1509 if (deleteOutputsRes != StorageOperationStatus.OK) {
1510 log.debug("Failed to delete outputs of the component instance {} from container component. ", componentInstanceId);
1511 throw new ByActionStatusComponentException(componentsUtils.convertFromStorageResponse(deleteOutputsRes, containerComponentType),
1512 componentInstanceId);
1516 return deletedInstance;
1519 private ComponentInstance findAndRemoveComponentInstanceFromContainerComponent(String componentInstanceId, Component containerComponent) {
1520 ComponentInstance foundInstance = null;
1521 for (ComponentInstance instance : containerComponent.getComponentInstances()) {
1522 if (instance.getUniqueId().equals(componentInstanceId)) {
1523 foundInstance = instance;
1524 containerComponent.getComponentInstances().remove(instance);
1528 findAndRemoveComponentInstanceRelations(componentInstanceId, containerComponent);
1529 return foundInstance;
1532 private void findAndRemoveComponentInstanceRelations(String componentInstanceId, Component containerComponent) {
1533 if (CollectionUtils.isNotEmpty(containerComponent.getComponentInstancesRelations())) {
1534 containerComponent.setComponentInstancesRelations(
1535 containerComponent.getComponentInstancesRelations().stream().filter(r -> isNotBelongingRelation(componentInstanceId, r))
1536 .collect(Collectors.toList()));
1540 private boolean isNotBelongingRelation(String componentInstanceId, RequirementCapabilityRelDef relation) {
1541 return !relation.getToNode().equals(componentInstanceId) && !relation.getFromNode().equals(componentInstanceId);
1544 public RequirementCapabilityRelDef associateRIToRI(String componentId, String userId, RequirementCapabilityRelDef requirementDef,
1545 ComponentTypeEnum componentTypeEnum) {
1546 return associateRIToRI(componentId, userId, requirementDef, componentTypeEnum, true);
1549 public RequirementCapabilityRelDef associateRIToRI(String componentId, String userId, RequirementCapabilityRelDef requirementDef,
1550 ComponentTypeEnum componentTypeEnum, boolean needLock) {
1551 validateUserExists(userId);
1552 RequirementCapabilityRelDef requirementCapabilityRelDef;
1553 org.openecomp.sdc.be.model.Component containerComponent = validateComponentExists(componentId, componentTypeEnum, null);
1554 validateCanWorkOnComponent(containerComponent, userId);
1555 boolean failed = false;
1558 lockComponent(containerComponent, ASSOCIATE_RI_TO_RI);
1560 requirementCapabilityRelDef = associateRIToRIOnGraph(containerComponent, requirementDef);
1561 } catch (ComponentException e) {
1566 unlockComponent(failed, containerComponent);
1569 return requirementCapabilityRelDef;
1572 public RequirementCapabilityRelDef associateRIToRIOnGraph(Component containerComponent, RequirementCapabilityRelDef requirementDef) {
1573 log.debug(TRY_TO_CREATE_ENTRY_ON_GRAPH);
1574 Either<RequirementCapabilityRelDef, StorageOperationStatus> result = toscaOperationFacade
1575 .associateResourceInstances(null, containerComponent.getUniqueId(), requirementDef);
1576 if (result.isLeft()) {
1577 log.debug(ENTITY_ON_GRAPH_IS_CREATED);
1578 return result.left().value();
1580 log.debug("Failed to associate node: {} with node {}", requirementDef.getFromNode(), requirementDef.getToNode());
1581 String fromNameOrId = "";
1582 String toNameOrId = "";
1583 Either<ComponentInstance, StorageOperationStatus> fromResult = getResourceInstanceById(containerComponent, requirementDef.getFromNode());
1584 Either<ComponentInstance, StorageOperationStatus> toResult = getResourceInstanceById(containerComponent, requirementDef.getToNode());
1585 toNameOrId = requirementDef.getFromNode();
1586 fromNameOrId = requirementDef.getFromNode();
1587 if (fromResult.isLeft()) {
1588 fromNameOrId = fromResult.left().value().getName();
1590 if (toResult.isLeft()) {
1591 toNameOrId = toResult.left().value().getName();
1593 throw new ByActionStatusComponentException(componentsUtils.convertFromStorageResponseForResourceInstance(result.right().value(), true),
1594 fromNameOrId, toNameOrId, requirementDef.getRelationships().get(0).getRelation().getRequirement());
1599 * @param componentId
1601 * @param requirementDefList
1602 * @param componentTypeEnum
1605 public List<RequirementCapabilityRelDef> batchDissociateRIFromRI(String componentId, String userId,
1606 List<RequirementCapabilityRelDef> requirementDefList,
1607 ComponentTypeEnum componentTypeEnum) {
1608 validateUserExists(userId);
1609 org.openecomp.sdc.be.model.Component containerComponent = validateComponentExists(componentId, componentTypeEnum, null);
1610 validateCanWorkOnComponent(containerComponent, userId);
1611 boolean failed = false;
1612 List<RequirementCapabilityRelDef> delOkResult = new ArrayList<>();
1614 lockComponent(containerComponent, ASSOCIATE_RI_TO_RI);
1615 for (RequirementCapabilityRelDef requirementDef : requirementDefList) {
1616 RequirementCapabilityRelDef requirementCapabilityRelDef = dissociateRIFromRI(componentId, userId, requirementDef,
1617 containerComponent.getComponentType());
1618 delOkResult.add(requirementCapabilityRelDef);
1620 } catch (ComponentException e) {
1624 unlockComponent(failed, containerComponent);
1629 public RequirementCapabilityRelDef dissociateRIFromRI(String componentId, String userId, RequirementCapabilityRelDef requirementDef,
1630 ComponentTypeEnum componentTypeEnum) {
1631 validateUserExists(userId);
1632 org.openecomp.sdc.be.model.Component containerComponent = validateComponentExists(componentId, componentTypeEnum, null);
1633 validateCanWorkOnComponent(containerComponent, userId);
1634 boolean failed = false;
1636 lockComponent(containerComponent, ASSOCIATE_RI_TO_RI);
1637 log.debug(TRY_TO_CREATE_ENTRY_ON_GRAPH);
1638 Either<RequirementCapabilityRelDef, StorageOperationStatus> result = toscaOperationFacade
1639 .dissociateResourceInstances(componentId, requirementDef);
1640 if (result.isLeft()) {
1641 log.debug(ENTITY_ON_GRAPH_IS_CREATED);
1642 return result.left().value();
1644 log.debug("Failed to dissocaite node {} from node {}", requirementDef.getFromNode(), requirementDef.getToNode());
1645 String fromNameOrId = "";
1646 String toNameOrId = "";
1647 Either<ComponentInstance, StorageOperationStatus> fromResult = getResourceInstanceById(containerComponent,
1648 requirementDef.getFromNode());
1649 Either<ComponentInstance, StorageOperationStatus> toResult = getResourceInstanceById(containerComponent, requirementDef.getToNode());
1650 toNameOrId = requirementDef.getFromNode();
1651 fromNameOrId = requirementDef.getFromNode();
1652 if (fromResult.isLeft()) {
1653 fromNameOrId = fromResult.left().value().getName();
1655 if (toResult.isLeft()) {
1656 toNameOrId = toResult.left().value().getName();
1658 throw new ByActionStatusComponentException(
1659 componentsUtils.convertFromStorageResponseForResourceInstance(result.right().value(), true), fromNameOrId, toNameOrId,
1660 requirementDef.getRelationships().get(0).getRelation().getRequirement());
1662 } catch (ComponentException e) {
1666 unlockComponent(failed, containerComponent);
1671 * Allows to get relation contained in specified component according to received Id
1673 * @param componentId
1676 * @param componentTypeEnum
1679 public Either<RequirementCapabilityRelDef, ResponseFormat> getRelationById(String componentId, String relationId, String userId,
1680 ComponentTypeEnum componentTypeEnum) {
1681 Either<RequirementCapabilityRelDef, ResponseFormat> resultOp = null;
1683 org.openecomp.sdc.be.model.Component containerComponent = null;
1684 RequirementCapabilityRelDef foundRelation = null;
1685 validateUserExists(userId);
1686 containerComponent = validateComponentExists(componentId, componentTypeEnum, null);
1687 List<RequirementCapabilityRelDef> requirementCapabilityRelations = containerComponent.getComponentInstancesRelations();
1688 foundRelation = findRelation(relationId, requirementCapabilityRelations);
1689 if (foundRelation == null) {
1690 ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.RELATION_NOT_FOUND, relationId, componentId);
1691 log.debug("Relation with id {} was not found on the component", relationId, componentId);
1692 resultOp = Either.right(responseFormat);
1694 if (resultOp == null) {
1695 resultOp = setRelatedCapability(foundRelation, containerComponent);
1697 if (resultOp.isLeft()) {
1698 resultOp = setRelatedRequirement(foundRelation, containerComponent);
1700 } catch (Exception e) {
1701 log.error("The exception {} occured upon get relation {} of the component {} ", e, relationId, componentId);
1702 resultOp = Either.right(componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR));
1707 private RequirementCapabilityRelDef findRelation(String relationId, List<RequirementCapabilityRelDef> requirementCapabilityRelations) {
1708 for (RequirementCapabilityRelDef relationship : requirementCapabilityRelations) {
1709 if (relationship.getRelationships().stream().anyMatch(r -> r.getRelation().getId().equals(relationId))) {
1710 return relationship;
1716 private Either<RequirementCapabilityRelDef, ResponseFormat> setRelatedRequirement(RequirementCapabilityRelDef foundRelation,
1717 Component containerComponent) {
1718 Either<RequirementCapabilityRelDef, ResponseFormat> result = null;
1719 RelationshipInfo relationshipInfo = foundRelation.resolveSingleRelationship().getRelation();
1720 String instanceId = foundRelation.getFromNode();
1721 Optional<RequirementDefinition> foundRequirement;
1722 Optional<ComponentInstance> instance = containerComponent.getComponentInstances().stream().filter(i -> i.getUniqueId().equals(instanceId))
1724 if (!instance.isPresent()) {
1725 ResponseFormat responseFormat = componentsUtils
1726 .getResponseFormat(ActionStatus.COMPONENT_INSTANCE_NOT_FOUND_ON_CONTAINER, instanceId, "instance",
1727 containerComponent.getComponentType().getValue(), containerComponent.getName());
1728 log.debug("Component instance with id {} was not found on the component", instanceId, containerComponent.getUniqueId());
1729 result = Either.right(responseFormat);
1731 if (result == null && instance.isPresent()) {
1732 for (List<RequirementDefinition> requirements : instance.get().getRequirements().values()) {
1733 foundRequirement = requirements.stream()
1734 .filter(r -> isBelongingCalcRequirement(relationshipInfo, r, containerComponent.getLifecycleState())).findFirst();
1735 if (foundRequirement.isPresent()) {
1736 foundRelation.resolveSingleRelationship().setRequirement(foundRequirement.get());
1737 result = Either.left(foundRelation);
1741 if (result == null) {
1742 Either<RequirementDataDefinition, StorageOperationStatus> getfulfilledRequirementRes = toscaOperationFacade
1743 .getFulfilledRequirementByRelation(containerComponent.getUniqueId(), instanceId, foundRelation, this::isBelongingFullRequirement);
1744 if (getfulfilledRequirementRes.isRight()) {
1745 ResponseFormat responseFormat = componentsUtils
1746 .getResponseFormat(ActionStatus.REQUIREMENT_OF_INSTANCE_NOT_FOUND_ON_CONTAINER, relationshipInfo.getRequirement(), instanceId,
1747 containerComponent.getUniqueId());
1748 log.debug("Requirement {} of instance {} was not found on the container {}. ", relationshipInfo.getCapability(), instanceId,
1749 containerComponent.getUniqueId());
1750 result = Either.right(responseFormat);
1752 foundRelation.resolveSingleRelationship().setRequirement(getfulfilledRequirementRes.left().value());
1755 if (result == null) {
1756 result = Either.left(foundRelation);
1761 private boolean isBelongingFullRequirement(RelationshipInfo relationshipInfo, RequirementDataDefinition req) {
1762 return req.getName().equals(relationshipInfo.getRequirement()) && req.getUniqueId().equals(relationshipInfo.getRequirementUid()) && req
1763 .getOwnerId().equals(relationshipInfo.getRequirementOwnerId());
1766 private boolean isBelongingCalcRequirement(RelationshipInfo relationshipInfo, RequirementDataDefinition req, LifecycleStateEnum state) {
1767 return nameMatches(relationshipInfo.getRequirement(), req.getName(), req.getPreviousName(), state) && req.getUniqueId()
1768 .equals(relationshipInfo.getRequirementUid()) && req.getOwnerId().equals(relationshipInfo.getRequirementOwnerId());
1771 private Either<RequirementCapabilityRelDef, ResponseFormat> setRelatedCapability(RequirementCapabilityRelDef foundRelation,
1772 Component containerComponent) {
1773 Either<RequirementCapabilityRelDef, ResponseFormat> result = null;
1774 RelationshipInfo relationshipInfo = foundRelation.resolveSingleRelationship().getRelation();
1775 String instanceId = foundRelation.getToNode();
1776 Optional<CapabilityDefinition> foundCapability;
1777 Optional<ComponentInstance> instance = containerComponent.getComponentInstances().stream().filter(i -> i.getUniqueId().equals(instanceId))
1779 if (!instance.isPresent()) {
1780 ResponseFormat responseFormat = componentsUtils
1781 .getResponseFormat(ActionStatus.COMPONENT_INSTANCE_NOT_FOUND_ON_CONTAINER, instanceId, "instance",
1782 containerComponent.getComponentType().getValue(), containerComponent.getName());
1783 log.debug("Component instance with id {} was not found on the component", instanceId, containerComponent.getUniqueId());
1784 result = Either.right(responseFormat);
1786 if (result == null && instance.isPresent()) {
1787 for (List<CapabilityDefinition> capabilities : instance.get().getCapabilities().values()) {
1788 foundCapability = capabilities.stream()
1789 .filter(c -> isBelongingCalcCapability(relationshipInfo, c, containerComponent.getLifecycleState())).findFirst();
1790 if (foundCapability.isPresent()) {
1791 foundRelation.resolveSingleRelationship().setCapability(foundCapability.get());
1792 result = Either.left(foundRelation);
1796 if (result == null) {
1797 Either<CapabilityDataDefinition, StorageOperationStatus> getfulfilledRequirementRes = toscaOperationFacade
1798 .getFulfilledCapabilityByRelation(containerComponent.getUniqueId(), instanceId, foundRelation, this::isBelongingFullCapability);
1799 if (getfulfilledRequirementRes.isRight()) {
1800 ResponseFormat responseFormat = componentsUtils
1801 .getResponseFormat(ActionStatus.CAPABILITY_OF_INSTANCE_NOT_FOUND_ON_CONTAINER, relationshipInfo.getCapability(), instanceId,
1802 containerComponent.getUniqueId());
1803 log.debug("Capability {} of instance {} was not found on the container {}. ", relationshipInfo.getCapability(), instanceId,
1804 containerComponent.getUniqueId());
1805 result = Either.right(responseFormat);
1807 foundRelation.resolveSingleRelationship().setCapability(getfulfilledRequirementRes.left().value());
1810 if (result == null) {
1811 result = Either.left(foundRelation);
1816 private boolean isBelongingFullCapability(RelationshipInfo relationshipInfo, CapabilityDataDefinition cap) {
1817 return cap.getName().equals(relationshipInfo.getCapability()) && cap.getUniqueId().equals(relationshipInfo.getCapabilityUid()) && cap
1818 .getOwnerId().equals(relationshipInfo.getCapabilityOwnerId());
1821 private boolean isBelongingCalcCapability(RelationshipInfo relationshipInfo, CapabilityDataDefinition cap, LifecycleStateEnum state) {
1822 return nameMatches(relationshipInfo.getCapability(), cap.getName(), cap.getPreviousName(), state) && cap.getUniqueId()
1823 .equals(relationshipInfo.getCapabilityUid()) && cap.getOwnerId().equals(relationshipInfo.getCapabilityOwnerId());
1826 private boolean nameMatches(String nameFromRelationship, String currName, String previousName, LifecycleStateEnum state) {
1827 return state == LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT ? currName.equals(nameFromRelationship)
1828 : previousName != null && previousName.equals(nameFromRelationship);
1831 private Either<ComponentInstanceProperty, ResponseFormat> updateAttributeValue(ComponentInstanceProperty attribute, String resourceInstanceId) {
1832 Either<ComponentInstanceProperty, StorageOperationStatus> eitherAttribute = componentInstanceOperation
1833 .updateAttributeValueInResourceInstance(attribute, resourceInstanceId, true);
1834 Either<ComponentInstanceProperty, ResponseFormat> result;
1835 if (eitherAttribute.isLeft()) {
1836 log.debug("Attribute value {} was updated on graph.", attribute.getValueUniqueUid());
1837 ComponentInstanceProperty instanceAttribute = eitherAttribute.left().value();
1838 result = Either.left(instanceAttribute);
1840 log.debug("Failed to update attribute value {} in resource instance {}", attribute, resourceInstanceId);
1841 ActionStatus actionStatus = componentsUtils.convertFromStorageResponseForResourceInstanceProperty(eitherAttribute.right().value());
1842 result = Either.right(componentsUtils.getResponseFormat(actionStatus, ""));
1847 private Either<ComponentInstanceProperty, ResponseFormat> createAttributeValue(ComponentInstanceProperty attribute, String resourceInstanceId) {
1848 Either<ComponentInstanceProperty, ResponseFormat> result;
1849 Wrapper<Integer> indexCounterWrapper = new Wrapper<>();
1850 Wrapper<ResponseFormat> errorWrapper = new Wrapper<>();
1851 validateIncrementCounter(resourceInstanceId, GraphPropertiesDictionary.ATTRIBUTE_COUNTER, indexCounterWrapper, errorWrapper);
1852 if (!errorWrapper.isEmpty()) {
1853 result = Either.right(errorWrapper.getInnerElement());
1855 Either<ComponentInstanceProperty, StorageOperationStatus> eitherAttribute = componentInstanceOperation
1856 .addAttributeValueToResourceInstance(attribute, resourceInstanceId, indexCounterWrapper.getInnerElement(), true);
1857 if (eitherAttribute.isLeft()) {
1858 log.debug("Attribute value was added to resource instance {}", resourceInstanceId);
1859 ComponentInstanceProperty instanceAttribute = eitherAttribute.left().value();
1860 result = Either.left(instanceAttribute);
1862 log.debug("Failed to add attribute value {} to resource instance {}", attribute, resourceInstanceId);
1863 ActionStatus actionStatus = componentsUtils.convertFromStorageResponseForResourceInstanceProperty(eitherAttribute.right().value());
1864 result = Either.right(componentsUtils.getResponseFormatForResourceInstanceProperty(actionStatus, ""));
1871 * Create Or Updates Attribute Instance
1873 * @param componentTypeEnum
1874 * @param componentId
1875 * @param resourceInstanceId
1880 public Either<ComponentInstanceProperty, ResponseFormat> createOrUpdateAttributeValue(ComponentTypeEnum componentTypeEnum, String componentId,
1881 String resourceInstanceId,
1882 ComponentInstanceProperty attribute, String userId) {
1883 Either<ComponentInstanceProperty, ResponseFormat> result = null;
1884 Wrapper<ResponseFormat> errorWrapper = new Wrapper<>();
1885 validateUserExists(userId);
1886 if (errorWrapper.isEmpty()) {
1887 validateComponentTypeEnum(componentTypeEnum, "CreateOrUpdateAttributeValue", errorWrapper);
1889 if (errorWrapper.isEmpty()) {
1890 validateCanWorkOnComponent(componentId, componentTypeEnum, userId, errorWrapper);
1892 if (errorWrapper.isEmpty()) {
1893 validateComponentLock(componentId, componentTypeEnum, errorWrapper);
1896 if (errorWrapper.isEmpty()) {
1897 final boolean isCreate = Objects.isNull(attribute.getValueUniqueUid());
1899 result = createAttributeValue(attribute, resourceInstanceId);
1901 result = updateAttributeValue(attribute, resourceInstanceId);
1904 result = Either.right(errorWrapper.getInnerElement());
1908 if (result == null || result.isRight()) {
1909 janusGraphDao.rollback();
1911 janusGraphDao.commit();
1914 graphLockOperation.unlockComponent(componentId, componentTypeEnum.getNodeType());
1918 public Either<List<ComponentInstanceProperty>, ResponseFormat> createOrUpdatePropertiesValues(ComponentTypeEnum componentTypeEnum,
1919 String componentId, String resourceInstanceId,
1920 List<ComponentInstanceProperty> properties,
1922 Either<List<ComponentInstanceProperty>, ResponseFormat> resultOp = null;
1923 /*-------------------------------Validations---------------------------------*/
1924 validateUserExists(userId);
1926 if (componentTypeEnum == null) {
1927 BeEcompErrorManager.getInstance().logInvalidInputError("CreateOrUpdatePropertiesValues", INVALID_COMPONENT_TYPE, ErrorSeverity.INFO);
1928 resultOp = Either.right(componentsUtils.getResponseFormat(ActionStatus.NOT_ALLOWED));
1931 Either<Component, StorageOperationStatus> getResourceResult = toscaOperationFacade.getToscaElement(componentId, JsonParseFlagEnum.ParseAll);
1933 if (getResourceResult.isRight()) {
1934 log.debug(FAILED_TO_RETRIEVE_COMPONENT_COMPONENT_ID, componentId);
1935 ActionStatus actionStatus = componentsUtils.convertFromStorageResponse(getResourceResult.right().value(), componentTypeEnum);
1936 return Either.right(componentsUtils.getResponseFormat(actionStatus, componentId));
1938 Component containerComponent = getResourceResult.left().value();
1940 if (!ComponentValidationUtils.canWorkOnComponent(containerComponent, userId)) {
1941 if (Boolean.TRUE.equals(containerComponent.isArchived())) {
1942 log.info(COMPONENT_ARCHIVED, componentId);
1943 return Either.right(componentsUtils.getResponseFormat(ActionStatus.COMPONENT_IS_ARCHIVED, containerComponent.getName()));
1945 log.info(RESTRICTED_OPERATION_ON_SERVIVE, userId, componentId);
1946 return Either.right(componentsUtils.getResponseFormat(ActionStatus.RESTRICTED_OPERATION));
1949 Either<ComponentInstance, StorageOperationStatus> resourceInstanceStatus = getResourceInstanceById(containerComponent, resourceInstanceId);
1950 if (resourceInstanceStatus.isRight()) {
1951 return Either.right(componentsUtils.getResponseFormat(ActionStatus.COMPONENT_INSTANCE_NOT_FOUND_ON_CONTAINER,
1952 resourceInstanceId, RESOURCE_INSTANCE, SERVICE, componentId));
1954 ComponentInstance foundResourceInstance = resourceInstanceStatus.left().value();
1957 StorageOperationStatus lockStatus = graphLockOperation.lockComponent(componentId, componentTypeEnum.getNodeType());
1958 if (lockStatus != StorageOperationStatus.OK) {
1959 log.debug(FAILED_TO_LOCK_SERVICE, componentId);
1960 return Either.right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(lockStatus)));
1962 List<ComponentInstanceProperty> updatedProperties = new ArrayList<>();
1964 for (ComponentInstanceProperty property : properties) {
1965 validateMandatoryFields(property);
1966 validatePropertyExistsOnComponent(property, containerComponent, foundResourceInstance);
1967 String propertyParentUniqueId = property.getParentUniqueId();
1968 if (property.isToscaFunction()) {
1969 toscaFunctionValidator.validate(property, containerComponent);
1970 property.setValue(property.getToscaFunction().getValue());
1973 if (CollectionUtils.isNotEmpty(property.getSubPropertyToscaFunctions())){
1974 final JSONObject jObject = property.getValue() == null ? new JSONObject() : new JSONObject(property.getValue());
1975 property.getSubPropertyToscaFunctions().stream().forEach(subToscaFunction -> {
1976 setJsonObjectForSubProperty(jObject, subToscaFunction.getSubPropertyPath(), subToscaFunction.getToscaFunction().getValue());
1978 property.setValue(jObject.toString());
1980 Either<String, ResponseFormat> updatedPropertyValue = updatePropertyObjectValue(property, containerComponent.getModel());
1981 if (updatedPropertyValue.isRight()) {
1982 log.error("Failed to update property object value of property: {}",
1984 throw new ByResponseFormatComponentException(updatedPropertyValue.right().value());
1986 Optional<CapabilityDefinition>
1987 capPropDefinition = getPropertyCapabilityOfChildInstance(propertyParentUniqueId, foundResourceInstance.getCapabilities());
1988 if (capPropDefinition.isPresent()) {
1989 updatedPropertyValue
1990 .bimap(updatedValue -> updateCapabilityPropFromUpdateInstProp(property, updatedValue,
1991 containerComponent, foundResourceInstance, capPropDefinition.get().getType(),
1992 capPropDefinition.get().getName()), Either::right);
1994 updatedPropertyValue.bimap(
1995 updatedValue -> updatePropertyOnContainerComponent(property, updatedValue, containerComponent, foundResourceInstance),
1998 updatedProperties.add(property);
2002 Either<Component, StorageOperationStatus> updateContainerRes = toscaOperationFacade
2003 .updateComponentInstanceMetadataOfTopologyTemplate(containerComponent);
2004 if (updateContainerRes.isRight()) {
2005 ActionStatus actionStatus = componentsUtils.convertFromStorageResponseForResourceInstanceProperty(updateContainerRes.right().value());
2006 resultOp = Either.right(componentsUtils.getResponseFormatForResourceInstanceProperty(actionStatus, ""));
2009 resultOp = Either.left(updatedProperties);
2012 } catch (final ComponentException e) {
2013 return Either.right(e.getResponseFormat());
2015 if (resultOp == null || resultOp.isRight()) {
2016 janusGraphDao.rollback();
2018 janusGraphDao.commit();
2021 graphLockOperation.unlockComponent(componentId, componentTypeEnum.getNodeType());
2025 private void setJsonObjectForSubProperty(final JSONObject jObject, final List<String> path, String value) {
2026 if (path.size() == 1) {
2027 Object valueAsObject = new Yaml().loadAs(value, Object.class);
2028 jObject.put(path.get(0), valueAsObject);
2030 if (!jObject.has(path.get(0))) {
2031 jObject.put(path.get(0), new JSONObject());
2033 final JSONObject jsonObject = jObject.getJSONObject(path.get(0));
2034 setJsonObjectForSubProperty(jsonObject, path.subList(1, path.size()), value);
2038 public Either<List<ComponentInstanceAttribute>, ResponseFormat> createOrUpdateAttributeValues(final ComponentTypeEnum componentTypeEnum,
2039 final String componentId,
2040 final String resourceInstanceId,
2041 final List<ComponentInstanceAttribute> attributes,
2042 final String userId) {
2043 Either<List<ComponentInstanceAttribute>, ResponseFormat> resultOp = null;
2044 /*-------------------------------Validations---------------------------------*/
2045 validateUserExists(userId);
2047 if (componentTypeEnum == null) {
2048 BeEcompErrorManager.getInstance().logInvalidInputError("CreateOrUpdatePropertiesValues", INVALID_COMPONENT_TYPE, ErrorSeverity.INFO);
2049 resultOp = Either.right(componentsUtils.getResponseFormat(ActionStatus.NOT_ALLOWED));
2052 final Either<Component, StorageOperationStatus> getResourceResult = toscaOperationFacade
2053 .getToscaElement(componentId, JsonParseFlagEnum.ParseAll);
2055 if (getResourceResult.isRight()) {
2056 log.debug(FAILED_TO_RETRIEVE_COMPONENT_COMPONENT_ID, componentId);
2057 final ActionStatus actionStatus = componentsUtils.convertFromStorageResponse(getResourceResult.right().value(), componentTypeEnum);
2058 return Either.right(componentsUtils.getResponseFormat(actionStatus, componentId));
2060 final Component containerComponent = getResourceResult.left().value();
2062 if (!ComponentValidationUtils.canWorkOnComponent(containerComponent, userId)) {
2063 if (Boolean.TRUE.equals(containerComponent.isArchived())) {
2064 log.info(COMPONENT_ARCHIVED, componentId);
2065 return Either.right(componentsUtils.getResponseFormat(ActionStatus.COMPONENT_IS_ARCHIVED, containerComponent.getName()));
2067 log.info(RESTRICTED_OPERATION_ON_SERVIVE, userId, componentId);
2068 return Either.right(componentsUtils.getResponseFormat(ActionStatus.RESTRICTED_OPERATION));
2071 final Either<ComponentInstance, StorageOperationStatus> resourceInstanceStatus = getResourceInstanceById(containerComponent,
2072 resourceInstanceId);
2073 if (resourceInstanceStatus.isRight()) {
2074 return Either.right(componentsUtils.getResponseFormat(ActionStatus.COMPONENT_INSTANCE_NOT_FOUND_ON_CONTAINER,
2075 resourceInstanceId, RESOURCE_INSTANCE, SERVICE, componentId));
2077 final ComponentInstance foundResourceInstance = resourceInstanceStatus.left().value();
2080 final StorageOperationStatus lockStatus = graphLockOperation.lockComponent(componentId, componentTypeEnum.getNodeType());
2081 if (lockStatus != StorageOperationStatus.OK) {
2082 log.debug(FAILED_TO_LOCK_SERVICE, componentId);
2083 return Either.right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(lockStatus)));
2085 final List<ComponentInstanceAttribute> updatedProperties = new ArrayList<>();
2087 for (final ComponentInstanceAttribute attribute : attributes) {
2088 final ComponentInstanceAttribute componentInstanceProperty = validateAttributeExistsOnComponent(attribute, containerComponent,
2089 foundResourceInstance);
2090 final Either<String, ResponseFormat> updatedPropertyValue = updateAttributeObjectValue(attribute);
2091 if (updatedPropertyValue.isRight()) {
2092 log.error("Failed to update attribute object value of attribute: {}", attribute);
2093 throw new ByResponseFormatComponentException(updatedPropertyValue.right().value());
2095 updatedPropertyValue.bimap(
2097 componentInstanceProperty.setValue(updatedValue);
2098 return updateAttributeOnContainerComponent(attribute, updatedValue,
2099 containerComponent, foundResourceInstance);
2101 updatedProperties.add(componentInstanceProperty);
2104 final Either<Component, StorageOperationStatus> updateContainerRes = toscaOperationFacade
2105 .updateComponentInstanceMetadataOfTopologyTemplate(containerComponent);
2106 if (updateContainerRes.isRight()) {
2107 final ActionStatus actionStatus = componentsUtils
2108 .convertFromStorageResponseForResourceInstanceProperty(updateContainerRes.right().value());
2109 resultOp = Either.right(componentsUtils.getResponseFormatForResourceInstanceProperty(actionStatus, ""));
2112 resultOp = Either.left(updatedProperties);
2115 } catch (final ComponentException e) {
2116 return Either.right(e.getResponseFormat());
2118 if (resultOp == null || resultOp.isRight()) {
2119 janusGraphDao.rollback();
2121 janusGraphDao.commit();
2124 graphLockOperation.unlockComponent(componentId, componentTypeEnum.getNodeType());
2128 private void validateMandatoryFields(PropertyDataDefinition property) {
2129 if (StringUtils.isEmpty(property.getName())) {
2130 throw new ByActionStatusComponentException(ActionStatus.MISSING_PROPERTY_NAME);
2134 private void validatePropertyExistsOnComponent(ComponentInstanceProperty property, Component containerComponent,
2135 ComponentInstance foundResourceInstance) {
2136 List<ComponentInstanceProperty> instanceProperties = containerComponent.getComponentInstancesProperties()
2137 .get(foundResourceInstance.getUniqueId());
2138 final boolean hasProperty = instanceProperties.stream().anyMatch(p -> p.getName().equals(property.getName()));
2140 throw new ByActionStatusComponentException(ActionStatus.PROPERTY_NOT_FOUND, property.getName());
2144 private ComponentInstanceAttribute validateAttributeExistsOnComponent(final ComponentInstanceAttribute attribute,
2145 final Component containerComponent,
2146 final ComponentInstance foundResourceInstance) {
2147 final List<ComponentInstanceAttribute> instanceProperties =
2148 containerComponent.getComponentInstancesAttributes().get(foundResourceInstance.getUniqueId());
2149 final Optional<ComponentInstanceAttribute> instanceAttribute =
2150 instanceProperties.stream().filter(p -> p.getName().equals(attribute.getName())).findAny();
2151 if (!instanceAttribute.isPresent()) {
2152 throw new ByActionStatusComponentException(ActionStatus.PROPERTY_NOT_FOUND, attribute.getName());
2154 return instanceAttribute.get();
2157 private ResponseFormat updateCapabilityPropertyOnContainerComponent(ComponentInstanceProperty property,
2158 String newValue, Component containerComponent,
2159 ComponentInstance foundResourceInstance,
2160 String capabilityType, String capabilityName) {
2161 String componentInstanceUniqueId = foundResourceInstance.getUniqueId();
2162 ResponseFormat actionStatus = updateCapPropOnContainerComponent(property, newValue, containerComponent,
2163 foundResourceInstance, capabilityType, capabilityName, componentInstanceUniqueId);
2164 if (actionStatus != null) {
2165 return actionStatus;
2168 return componentsUtils.getResponseFormat(ActionStatus.OK);
2171 private ResponseFormat updateCapabilityPropFromUpdateInstProp(ComponentInstanceProperty property,
2172 String newValue, Component containerComponent,
2173 ComponentInstance foundResourceInstance,
2174 String capabilityType, String capabilityName) {
2175 String componentInstanceUniqueId = foundResourceInstance.getUniqueId();
2176 Either<Component, StorageOperationStatus> getComponentRes =
2177 toscaOperationFacade.getToscaFullElement(foundResourceInstance.getComponentUid());
2178 if (getComponentRes.isRight()) {
2179 return componentsUtils.getResponseFormat(getComponentRes.right().value());
2182 ResponseFormat actionStatus = updateCapPropOnContainerComponent(property, newValue, containerComponent,
2183 foundResourceInstance, capabilityType, capabilityName, componentInstanceUniqueId);
2184 if (actionStatus != null) {
2185 return actionStatus;
2188 return componentsUtils.getResponseFormat(ActionStatus.OK);
2191 private ResponseFormat updateCapPropOnContainerComponent(ComponentInstanceProperty property, String newValue,
2192 Component containerComponent,
2193 ComponentInstance foundResourceInstance,
2194 String capabilityType, String capabilityName,
2195 String componentInstanceUniqueId) {
2196 Map<String, List<CapabilityDefinition>> capabilities =
2197 Optional.ofNullable(foundResourceInstance.getCapabilities()).orElse(Collections.emptyMap());
2198 List<CapabilityDefinition> capPerType =
2199 Optional.ofNullable(capabilities.get(capabilityType)).orElse(Collections.emptyList());
2200 Optional<CapabilityDefinition> cap =
2201 capPerType.stream().filter(c -> c.getName().equals(capabilityName)).findAny();
2202 if (cap.isPresent()) {
2203 List<ComponentInstanceProperty> capProperties = cap.get().getProperties();
2204 if (capProperties != null) {
2205 Optional<ComponentInstanceProperty> instanceProperty =
2206 capProperties.stream().filter(p -> p.getUniqueId().equals(property.getUniqueId())).findAny();
2207 StorageOperationStatus status;
2208 if (instanceProperty.isPresent()) {
2209 String capKey = ModelConverter
2210 .buildCapabilityPropertyKey(foundResourceInstance.getOriginType().isAtomicType(), capabilityType, capabilityName,
2211 componentInstanceUniqueId, cap.get());
2212 instanceProperty.get().setValue(newValue);
2213 List<String> path = new ArrayList<>();
2214 path.add(componentInstanceUniqueId);
2216 instanceProperty.get().setPath(path);
2217 status = toscaOperationFacade.updateComponentInstanceCapabiltyProperty(containerComponent,
2218 componentInstanceUniqueId, capKey, instanceProperty.get());
2219 if (status != StorageOperationStatus.OK) {
2220 ActionStatus actionStatus =
2221 componentsUtils.convertFromStorageResponseForResourceInstanceProperty(status);
2222 return componentsUtils.getResponseFormatForResourceInstanceProperty(actionStatus, "");
2225 foundResourceInstance.setCustomizationUUID(UUID.randomUUID().toString());
2232 private ResponseFormat updatePropertyOnContainerComponent(ComponentInstanceProperty instanceProperty, String newValue,
2233 Component containerComponent, ComponentInstance foundResourceInstance) {
2234 StorageOperationStatus status;
2235 instanceProperty.setValue(newValue);
2236 status = toscaOperationFacade.updateComponentInstanceProperty(containerComponent, foundResourceInstance.getUniqueId(), instanceProperty);
2237 if (status != StorageOperationStatus.OK) {
2238 ActionStatus actionStatus = componentsUtils.convertFromStorageResponseForResourceInstanceProperty(status);
2239 return componentsUtils.getResponseFormatForResourceInstanceProperty(actionStatus, "");
2241 foundResourceInstance.setCustomizationUUID(UUID.randomUUID().toString());
2242 return componentsUtils.getResponseFormat(ActionStatus.OK);
2245 private ResponseFormat updateAttributeOnContainerComponent(final ComponentInstanceAttribute instanceAttribute,
2246 final String newValue,
2247 final Component containerComponent,
2248 final ComponentInstance foundResourceInstance) {
2250 instanceAttribute.setValue(newValue);
2251 final StorageOperationStatus status =
2252 toscaOperationFacade.updateComponentInstanceAttribute(containerComponent, foundResourceInstance.getUniqueId(), instanceAttribute);
2253 if (status != StorageOperationStatus.OK) {
2254 final ActionStatus actionStatus = componentsUtils.convertFromStorageResponseForResourceInstanceProperty(status);
2255 return componentsUtils.getResponseFormatForResourceInstanceProperty(actionStatus, "");
2257 foundResourceInstance.setCustomizationUUID(UUID.randomUUID().toString());
2258 return componentsUtils.getResponseFormat(ActionStatus.OK);
2261 private <T extends PropertyDefinition> Either<String, ResponseFormat> validatePropertyObjectValue(T property, String newValue, boolean isInput) {
2262 final Map<String, DataTypeDefinition> allDataTypes = componentsUtils.getAllDataTypes(applicationDataTypeCache, property.getModel());
2263 String propertyType = property.getType();
2264 String innerType = getInnerType(property);
2266 // Specific Update Logic
2267 Either<Object, Boolean> isValid = propertyOperation
2268 .validateAndUpdatePropertyValue(property.getType(), newValue, true, innerType, allDataTypes);
2269 if (isValid.isRight()) {
2270 if (!Boolean.TRUE.equals(isValid.right().value())) {
2271 log.error("Invalid value {} of property {} ", newValue, property.getName());
2272 return Either.right(componentsUtils.getResponseFormat(ActionStatus.INVALID_CONTENT));
2275 Object object = isValid.left().value();
2276 if (object != null) {
2277 newValue = object.toString();
2280 if (validateAndUpdateRules(property, isInput, allDataTypes, innerType, propertyType)) {
2281 return Either.right(componentsUtils.getResponseFormat(componentsUtils
2282 .convertFromStorageResponse(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(JanusGraphOperationStatus.ILLEGAL_ARGUMENT))));
2284 return Either.left(newValue);
2287 private <T extends PropertyDefinition> boolean validateAndUpdateRules(T property, boolean isInput, Map<String, DataTypeDefinition> allDataTypes,
2288 String innerType, String propertyType) {
2290 ImmutablePair<String, Boolean> pair = propertyOperation
2291 .validateAndUpdateRules(propertyType, ((ComponentInstanceProperty) property).getRules(), innerType, allDataTypes, true);
2292 if (pair.getRight() != null && !pair.getRight()) {
2293 BeEcompErrorManager.getInstance().logBeInvalidValueError("Add property value", pair.getLeft(), property.getName(), propertyType);
2300 private <T extends PropertyDefinition> Either<String, ResponseFormat> updatePropertyObjectValue(T property, final String model) {
2301 final Map<String, DataTypeDefinition> allDataTypes = componentsUtils.getAllDataTypes(applicationDataTypeCache, model);
2302 String innerType = null;
2303 String propertyType = property.getType();
2304 ToscaPropertyType type = ToscaPropertyType.isValidType(propertyType);
2305 log.debug("The type of the property {} is {}", property.getUniqueId(), propertyType);
2307 if (type == ToscaPropertyType.LIST || type == ToscaPropertyType.MAP) {
2308 SchemaDefinition schema = property.getSchema();
2309 if (schema == null) {
2310 log.debug("Schema doesn't exists for property of type {}", type);
2312 .right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(StorageOperationStatus.INVALID_VALUE)));
2314 PropertyDataDefinition propDef = schema.getProperty();
2315 if (propDef == null) {
2316 log.debug("Property in Schema Definition inside property of type {} doesn't exist", type);
2318 .right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(StorageOperationStatus.INVALID_VALUE)));
2320 innerType = propDef.getType();
2323 // Specific Update Logic
2324 String newValue = property.getValue();
2326 if (property.hasToscaFunction() || CollectionUtils.isNotEmpty(property.getSubPropertyToscaFunctions())) {
2327 return Either.left(newValue);
2330 Either<Object, Boolean> isValid = propertyOperation
2331 .validateAndUpdatePropertyValue(propertyType, property.getValue(), true, innerType, allDataTypes);
2332 if (isValid.isRight()) {
2333 if (!Boolean.TRUE.equals(isValid.right().value())) {
2334 log.debug("validate and update property value has failed with value: {}", property.getValue());
2335 throw new ByActionStatusComponentException(componentsUtils.convertFromStorageResponse(
2336 DaoStatusConverter.convertJanusGraphStatusToStorageStatus(JanusGraphOperationStatus.ILLEGAL_ARGUMENT)));
2339 Object object = isValid.left().value();
2340 if (object != null) {
2341 newValue = object.toString();
2344 ImmutablePair<String, Boolean> pair = propertyOperation
2345 .validateAndUpdateRules(propertyType, ((ComponentInstanceProperty) property).getRules(), innerType, allDataTypes, true);
2346 if (pair.getRight() != null && Boolean.FALSE.equals(pair.getRight())) {
2347 BeEcompErrorManager.getInstance().logBeInvalidValueError("Add property value", pair.getLeft(), property.getName(), propertyType);
2348 return Either.right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(
2349 DaoStatusConverter.convertJanusGraphStatusToStorageStatus(JanusGraphOperationStatus.ILLEGAL_ARGUMENT))));
2351 return Either.left(newValue);
2354 private <T extends AttributeDefinition> Either<String, ResponseFormat> updateAttributeObjectValue(final T attribute) {
2355 String innerType = null;
2356 final String attributeType = attribute.getType();
2357 final ToscaPropertyType type = ToscaPropertyType.isValidType(attributeType);
2358 log.debug("The type of the attribute {} is {}", attribute.getUniqueId(), attributeType);
2360 if (type == ToscaPropertyType.LIST || type == ToscaPropertyType.MAP) {
2361 final SchemaDefinition def = attribute.getSchema();
2363 log.debug("Schema doesn't exists for attribute of type {}", type);
2365 .right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(StorageOperationStatus.INVALID_VALUE)));
2367 PropertyDataDefinition propDef = def.getProperty();
2368 if (propDef == null) {
2369 log.debug("Property in Schema Definition inside attribute of type {} doesn't exist", type);
2371 .right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(StorageOperationStatus.INVALID_VALUE)));
2373 innerType = propDef.getType();
2376 // Specific Update Logic
2377 String newValue = attribute.getValue();
2379 final var isValid = attributeOperation.validateAndUpdateAttributeValue(attribute, innerType,
2380 componentsUtils.getAllDataTypes(applicationDataTypeCache, attribute.getModel()));
2381 if (isValid.isRight()) {
2382 final Boolean res = isValid.right().value();
2383 if (!Boolean.TRUE.equals(res)) {
2384 log.debug("validate and update attribute value has failed with value: {}", newValue);
2385 throw new ByActionStatusComponentException(componentsUtils.convertFromStorageResponse(
2386 DaoStatusConverter.convertJanusGraphStatusToStorageStatus(JanusGraphOperationStatus.ILLEGAL_ARGUMENT)));
2389 final Object object = isValid.left().value();
2390 if (object != null) {
2391 newValue = object.toString();
2394 return Either.left(newValue);
2397 private <T extends PropertyDefinition> void validateToscaGetFunction(T property, Component parentComponent) {
2398 final ToscaGetFunctionDataDefinition toscaGetFunction = (ToscaGetFunctionDataDefinition) property.getToscaFunction();
2399 validateGetToscaFunctionAttributes(toscaGetFunction);
2400 validateGetPropertySource(toscaGetFunction.getFunctionType(), toscaGetFunction.getPropertySource());
2401 if (toscaGetFunction.getFunctionType() == ToscaGetFunctionType.GET_INPUT) {
2402 validateGetFunction(property, parentComponent.getInputs(), parentComponent.getModel());
2405 if (toscaGetFunction.getFunctionType() == ToscaGetFunctionType.GET_PROPERTY) {
2406 if (toscaGetFunction.getPropertySource() == PropertySource.SELF) {
2407 validateGetFunction(property, parentComponent.getProperties(), parentComponent.getModel());
2408 } else if (toscaGetFunction.getPropertySource() == PropertySource.INSTANCE) {
2409 final ComponentInstance componentInstance =
2410 parentComponent.getComponentInstanceById(toscaGetFunction.getSourceUniqueId())
2411 .orElseThrow(ToscaGetFunctionExceptionSupplier.instanceNotFound(toscaGetFunction.getSourceName()));
2412 validateGetFunction(property, componentInstance.getProperties(), parentComponent.getModel());
2417 if (toscaGetFunction.getFunctionType() == ToscaGetFunctionType.GET_ATTRIBUTE) {
2418 if (toscaGetFunction.getPropertySource() == PropertySource.SELF) {
2419 validateGetFunction(property, parentComponent.getAttributes(), parentComponent.getModel());
2420 } else if (toscaGetFunction.getPropertySource() == PropertySource.INSTANCE) {
2421 final ComponentInstance componentInstance =
2422 parentComponent.getComponentInstanceById(toscaGetFunction.getSourceUniqueId())
2423 .orElseThrow(ToscaGetFunctionExceptionSupplier.instanceNotFound(toscaGetFunction.getSourceName()));
2424 validateGetFunction(property, componentInstance.getAttributes(), parentComponent.getModel());
2430 throw ToscaGetFunctionExceptionSupplier.functionNotSupported(toscaGetFunction.getFunctionType()).get();
2433 private <T extends PropertyDefinition> void validateGetFunction(final T property,
2434 final List<? extends ToscaPropertyData> parentProperties,
2435 final String model) {
2436 final ToscaGetFunctionDataDefinition toscaGetFunction = (ToscaGetFunctionDataDefinition) property.getToscaFunction();
2437 if (CollectionUtils.isEmpty(parentProperties)) {
2438 throw ToscaGetFunctionExceptionSupplier
2439 .propertyNotFoundOnTarget(toscaGetFunction.getPropertyName(), toscaGetFunction.getPropertySource(),
2440 toscaGetFunction.getFunctionType()
2443 final String getFunctionPropertyUniqueId = toscaGetFunction.getPropertyUniqueId();
2444 ToscaPropertyData referredProperty = parentProperties.stream()
2445 .filter(property1 -> getFunctionPropertyUniqueId.equals(property1.getUniqueId()))
2447 .orElseThrow(ToscaGetFunctionExceptionSupplier
2448 .propertyNotFoundOnTarget(toscaGetFunction.getPropertyName(), toscaGetFunction.getPropertySource()
2449 , toscaGetFunction.getFunctionType())
2451 if (toscaGetFunction.isSubProperty()) {
2452 referredProperty = findSubProperty(referredProperty, toscaGetFunction, model);
2455 if (!property.getType().equals(referredProperty.getType())) {
2456 throw ToscaGetFunctionExceptionSupplier
2457 .propertyTypeDiverge(toscaGetFunction.getType(), referredProperty.getType(), property.getType()).get();
2459 if (PropertyType.typeHasSchema(referredProperty.getType()) && !referredProperty.getSchemaType().equals(property.getSchemaType())) {
2460 throw ToscaGetFunctionExceptionSupplier
2461 .propertySchemaDiverge(toscaGetFunction.getType(), referredProperty.getSchemaType(), property.getSchemaType()).get();
2465 private ToscaPropertyData findSubProperty(final ToscaPropertyData referredProperty,
2466 final ToscaGetFunctionDataDefinition toscaGetFunction,
2467 final String model) {
2468 final Map<String, DataTypeDefinition> dataTypeMap = loadDataTypes(model);
2469 final List<String> propertyPathFromSource = toscaGetFunction.getPropertyPathFromSource();
2470 DataTypeDefinition dataType = dataTypeMap.get(referredProperty.getType());
2471 if (dataType == null) {
2472 throw ToscaGetFunctionExceptionSupplier
2473 .propertyDataTypeNotFound(propertyPathFromSource.get(0), referredProperty.getType(), toscaGetFunction.getFunctionType()).get();
2475 ToscaPropertyData foundProperty = referredProperty;
2476 for (int i = 1; i < propertyPathFromSource.size(); i++) {
2477 final String currentPropertyName = propertyPathFromSource.get(i);
2478 foundProperty = dataType.getProperties().stream()
2479 .filter(propertyDefinition -> currentPropertyName.equals(propertyDefinition.getName())).findFirst()
2481 ToscaGetFunctionExceptionSupplier
2482 .propertyNotFoundOnTarget(propertyPathFromSource.subList(0, i), toscaGetFunction.getPropertySource(),
2483 toscaGetFunction.getFunctionType())
2485 dataType = dataTypeMap.get(foundProperty.getType());
2486 if (dataType == null) {
2487 throw ToscaGetFunctionExceptionSupplier
2488 .propertyDataTypeNotFound(propertyPathFromSource.subList(0, i), foundProperty.getType(),
2489 toscaGetFunction.getFunctionType()).get();
2492 return foundProperty;
2495 private Map<String, DataTypeDefinition> loadDataTypes(String model) {
2496 final Either<Map<String, DataTypeDefinition>, JanusGraphOperationStatus> dataTypeEither =
2497 applicationDataTypeCache.getAll(model);
2498 if (dataTypeEither.isRight()) {
2499 throw ToscaGetFunctionExceptionSupplier.couldNotLoadDataTypes(model).get();
2501 return dataTypeEither.left().value();
2504 private void validateGetPropertySource(final ToscaGetFunctionType functionType, final PropertySource propertySource) {
2505 if (functionType == ToscaGetFunctionType.GET_INPUT && propertySource != PropertySource.SELF) {
2506 throw ToscaGetFunctionExceptionSupplier
2507 .targetSourceNotSupported(functionType, propertySource).get();
2509 if (functionType == ToscaGetFunctionType.GET_PROPERTY && !List.of(PropertySource.SELF, PropertySource.INSTANCE).contains(propertySource)) {
2510 throw ToscaGetFunctionExceptionSupplier
2511 .targetSourceNotSupported(functionType, propertySource).get();
2515 private void validateGetToscaFunctionAttributes(final ToscaGetFunctionDataDefinition toscaGetFunction) {
2516 if (toscaGetFunction.getFunctionType() == null) {
2517 throw ToscaGetFunctionExceptionSupplier.targetFunctionTypeNotFound().get();
2519 if (toscaGetFunction.getPropertySource() == null) {
2520 throw ToscaGetFunctionExceptionSupplier.targetPropertySourceNotFound(toscaGetFunction.getFunctionType()).get();
2522 if (CollectionUtils.isEmpty(toscaGetFunction.getPropertyPathFromSource())) {
2523 throw ToscaGetFunctionExceptionSupplier
2524 .targetSourcePathNotFound(toscaGetFunction.getFunctionType()).get();
2526 if (StringUtils.isEmpty(toscaGetFunction.getSourceName()) || StringUtils.isBlank(toscaGetFunction.getSourceName())) {
2527 throw ToscaGetFunctionExceptionSupplier.sourceNameNotFound(toscaGetFunction.getPropertySource()).get();
2529 if (StringUtils.isEmpty(toscaGetFunction.getSourceUniqueId()) || StringUtils.isBlank(toscaGetFunction.getSourceUniqueId())) {
2530 throw ToscaGetFunctionExceptionSupplier.sourceIdNotFound(toscaGetFunction.getPropertySource()).get();
2532 if (StringUtils.isEmpty(toscaGetFunction.getPropertyName()) || StringUtils.isBlank(toscaGetFunction.getPropertyName())) {
2533 throw ToscaGetFunctionExceptionSupplier.propertyNameNotFound(toscaGetFunction.getPropertySource()).get();
2535 if (StringUtils.isEmpty(toscaGetFunction.getPropertyUniqueId()) || StringUtils.isBlank(toscaGetFunction.getPropertyUniqueId())) {
2536 throw ToscaGetFunctionExceptionSupplier.propertyIdNotFound(toscaGetFunction.getPropertySource()).get();
2540 private ResponseFormat updateInputOnContainerComponent(ComponentInstanceInput input, String newValue, Component containerComponent,
2541 ComponentInstance foundResourceInstance) {
2542 StorageOperationStatus status;
2543 input.setValue(newValue);
2544 status = toscaOperationFacade.updateComponentInstanceInput(containerComponent, foundResourceInstance.getUniqueId(), input);
2545 if (status != StorageOperationStatus.OK) {
2546 ActionStatus actionStatus = componentsUtils.convertFromStorageResponseForResourceInstanceProperty(status);
2547 return componentsUtils.getResponseFormatForResourceInstanceProperty(actionStatus, "");
2549 foundResourceInstance.setCustomizationUUID(UUID.randomUUID().toString());
2550 return componentsUtils.getResponseFormat(ActionStatus.OK);
2553 public Either<List<ComponentInstanceInput>, ResponseFormat> createOrUpdateInstanceInputValues(ComponentTypeEnum componentTypeEnum,
2554 String componentId, String resourceInstanceId,
2555 List<ComponentInstanceInput> inputs,
2558 Either<List<ComponentInstanceInput>, ResponseFormat> resultOp = null;
2560 validateUserExists(userId);
2562 if (componentTypeEnum == null) {
2563 BeEcompErrorManager.getInstance().logInvalidInputError(CREATE_OR_UPDATE_PROPERTY_VALUE, INVALID_COMPONENT_TYPE, ErrorSeverity.INFO);
2564 resultOp = Either.right(componentsUtils.getResponseFormat(ActionStatus.NOT_ALLOWED));
2567 Either<Component, StorageOperationStatus> getResourceResult = toscaOperationFacade.getToscaElement(componentId, JsonParseFlagEnum.ParseAll);
2569 if (getResourceResult.isRight()) {
2570 log.debug(FAILED_TO_RETRIEVE_COMPONENT_COMPONENT_ID, componentId);
2571 ActionStatus actionStatus = componentsUtils.convertFromStorageResponse(getResourceResult.right().value(), componentTypeEnum);
2572 return Either.right(componentsUtils.getResponseFormat(actionStatus, componentId));
2574 Component containerComponent = getResourceResult.left().value();
2576 if (!ComponentValidationUtils.canWorkOnComponent(containerComponent, userId)) {
2577 if (Boolean.TRUE.equals(containerComponent.isArchived())) {
2578 log.info(COMPONENT_ARCHIVED, componentId);
2579 return Either.right(componentsUtils.getResponseFormat(ActionStatus.COMPONENT_IS_ARCHIVED, containerComponent.getName()));
2581 log.info(RESTRICTED_OPERATION_ON_SERVIVE, userId, componentId);
2582 resultOp = Either.right(componentsUtils.getResponseFormat(ActionStatus.RESTRICTED_OPERATION));
2585 Either<ComponentInstance, StorageOperationStatus> resourceInstanceStatus = getResourceInstanceById(containerComponent, resourceInstanceId);
2586 if (resourceInstanceStatus.isRight()) {
2587 return Either.right(componentsUtils.getResponseFormat(ActionStatus.COMPONENT_INSTANCE_NOT_FOUND_ON_CONTAINER,
2588 resourceInstanceId, RESOURCE_INSTANCE, SERVICE, componentId));
2591 ComponentInstance foundResourceInstance = resourceInstanceStatus.left().value();
2594 StorageOperationStatus lockStatus = graphLockOperation.lockComponent(componentId, componentTypeEnum.getNodeType());
2595 if (lockStatus != StorageOperationStatus.OK) {
2596 log.debug(FAILED_TO_LOCK_SERVICE, componentId);
2597 return Either.right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(lockStatus)));
2599 List<ComponentInstanceInput> updatedInputs = new ArrayList<>();
2601 for (ComponentInstanceInput input : inputs) {
2602 validateMandatoryFields(input);
2603 ComponentInstanceInput componentInstanceInput = validateInputExistsOnComponent(input, containerComponent, foundResourceInstance);
2604 Either<String, ResponseFormat> validatedInputValue = validatePropertyObjectValue(componentInstanceInput, input.getValue(), true);
2605 if (validatedInputValue.isRight()) {
2606 throw new ByActionStatusComponentException(ActionStatus.INVALID_CONTENT, input.getName());
2608 updateInputOnContainerComponent(componentInstanceInput, validatedInputValue.left().value(), containerComponent,
2609 foundResourceInstance);
2610 updatedInputs.add(componentInstanceInput);
2612 Either<Component, StorageOperationStatus> updateContainerRes = toscaOperationFacade
2613 .updateComponentInstanceMetadataOfTopologyTemplate(containerComponent);
2614 if (updateContainerRes.isRight()) {
2615 ActionStatus actionStatus = componentsUtils.convertFromStorageResponseForResourceInstanceProperty(updateContainerRes.right().value());
2616 resultOp = Either.right(componentsUtils.getResponseFormatForResourceInstanceProperty(actionStatus, ""));
2619 resultOp = Either.left(updatedInputs);
2623 if (resultOp == null || resultOp.isRight()) {
2624 janusGraphDao.rollback();
2626 janusGraphDao.commit();
2629 graphLockOperation.unlockComponent(componentId, componentTypeEnum.getNodeType());
2634 private ComponentInstanceInput validateInputExistsOnComponent(ComponentInstanceInput input, Component containerComponent,
2635 ComponentInstance foundResourceInstance) {
2636 List<ComponentInstanceInput> instanceProperties = containerComponent.getComponentInstancesInputs().get(foundResourceInstance.getUniqueId());
2637 Optional<ComponentInstanceInput> instanceInput = instanceProperties.stream().filter(p -> p.getName().equals(input.getName())).findAny();
2638 if (!instanceInput.isPresent()) {
2639 throw new ByActionStatusComponentException(ActionStatus.PROPERTY_NOT_FOUND, input.getName());
2641 return instanceInput.get();
2644 public Either<ComponentInstanceProperty, ResponseFormat> createOrUpdateGroupInstancePropertyValue(ComponentTypeEnum componentTypeEnum,
2645 String componentId, String resourceInstanceId,
2646 String groupInstanceId,
2647 ComponentInstanceProperty property,
2650 Either<ComponentInstanceProperty, ResponseFormat> resultOp = null;
2652 validateUserExists(userId);
2654 if (componentTypeEnum == null) {
2655 BeEcompErrorManager.getInstance().logInvalidInputError(CREATE_OR_UPDATE_PROPERTY_VALUE, INVALID_COMPONENT_TYPE, ErrorSeverity.INFO);
2656 resultOp = Either.right(componentsUtils.getResponseFormat(ActionStatus.NOT_ALLOWED));
2660 if (!ComponentValidationUtils.canWorkOnComponent(componentId, toscaOperationFacade, userId)) {
2661 log.info("Restricted operation for user: {} on service: {}", userId, componentId);
2662 resultOp = Either.right(componentsUtils.getResponseFormat(ActionStatus.RESTRICTED_OPERATION));
2666 StorageOperationStatus lockStatus = graphLockOperation.lockComponent(componentId, componentTypeEnum.getNodeType());
2667 if (lockStatus != StorageOperationStatus.OK) {
2668 log.debug(FAILED_TO_LOCK_SERVICE, componentId);
2669 resultOp = Either.right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(lockStatus)));
2673 String propertyValueUid = property.getValueUniqueUid();
2675 if (propertyValueUid == null) {
2677 Either<Integer, StorageOperationStatus> counterRes = groupInstanceOperation
2678 .increaseAndGetGroupInstancePropertyCounter(groupInstanceId);
2680 if (counterRes.isRight()) {
2681 log.debug("increaseAndGetResourcePropertyCounter failed resource instance: {} property: {}", resourceInstanceId, property);
2682 StorageOperationStatus status = counterRes.right().value();
2683 ActionStatus actionStatus = componentsUtils.convertFromStorageResponseForResourceInstanceProperty(status);
2684 resultOp = Either.right(componentsUtils.getResponseFormat(actionStatus));
2686 Integer index = counterRes.left().value();
2687 Either<ComponentInstanceProperty, StorageOperationStatus> result = groupInstanceOperation
2688 .addPropertyValueToGroupInstance(property, resourceInstanceId, index, true);
2690 if (result.isLeft()) {
2691 log.trace("Property value was added to resource instance {}", resourceInstanceId);
2692 ComponentInstanceProperty instanceProperty = result.left().value();
2694 resultOp = Either.left(instanceProperty);
2697 log.debug("Failed to add property value: {} to resource instance {}", property, resourceInstanceId);
2699 ActionStatus actionStatus = componentsUtils.convertFromStorageResponseForResourceInstanceProperty(result.right().value());
2701 resultOp = Either.right(componentsUtils.getResponseFormatForResourceInstanceProperty(actionStatus, ""));
2705 Either<ComponentInstanceProperty, StorageOperationStatus> result = groupInstanceOperation
2706 .updatePropertyValueInGroupInstance(property, resourceInstanceId, true);
2708 if (result.isLeft()) {
2709 log.debug("Property value {} was updated on graph.", property.getValueUniqueUid());
2710 ComponentInstanceProperty instanceProperty = result.left().value();
2712 resultOp = Either.left(instanceProperty);
2715 log.debug("Failed to update property value: {}, in resource instance {}", property, resourceInstanceId);
2717 ActionStatus actionStatus = componentsUtils.convertFromStorageResponseForResourceInstanceProperty(result.right().value());
2719 resultOp = Either.right(componentsUtils.getResponseFormatForResourceInstanceProperty(actionStatus, ""));
2722 if (resultOp.isLeft()) {
2723 StorageOperationStatus updateCustomizationUUID = componentInstanceOperation.updateCustomizationUUID(resourceInstanceId);
2724 if (updateCustomizationUUID != StorageOperationStatus.OK) {
2725 ActionStatus actionStatus = componentsUtils.convertFromStorageResponseForResourceInstanceProperty(updateCustomizationUUID);
2727 resultOp = Either.right(componentsUtils.getResponseFormatForResourceInstanceProperty(actionStatus, ""));
2734 if (resultOp == null || resultOp.isRight()) {
2735 janusGraphDao.rollback();
2737 janusGraphDao.commit();
2740 graphLockOperation.unlockComponent(componentId, componentTypeEnum.getNodeType());
2745 public Either<ComponentInstanceProperty, ResponseFormat> deletePropertyValue(ComponentTypeEnum componentTypeEnum, String serviceId,
2746 String resourceInstanceId, String propertyValueId, String userId) {
2748 validateUserExists(userId);
2750 Either<ComponentInstanceProperty, ResponseFormat> resultOp = null;
2752 if (componentTypeEnum == null) {
2753 BeEcompErrorManager.getInstance().logInvalidInputError(CREATE_OR_UPDATE_PROPERTY_VALUE, INVALID_COMPONENT_TYPE, ErrorSeverity.INFO);
2754 resultOp = Either.right(componentsUtils.getResponseFormat(ActionStatus.NOT_ALLOWED));
2758 if (!ComponentValidationUtils.canWorkOnComponent(serviceId, toscaOperationFacade, userId)) {
2759 log.info("Restricted operation for user {} on service {}", userId, serviceId);
2760 resultOp = Either.right(componentsUtils.getResponseFormat(ActionStatus.RESTRICTED_OPERATION));
2764 StorageOperationStatus lockStatus = graphLockOperation.lockComponent(serviceId, componentTypeEnum.getNodeType());
2765 if (lockStatus != StorageOperationStatus.OK) {
2766 log.debug(FAILED_TO_LOCK_SERVICE, serviceId);
2767 resultOp = Either.right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(lockStatus)));
2771 Either<ComponentInstanceProperty, StorageOperationStatus> result = propertyOperation
2772 .removePropertyValueFromResourceInstance(propertyValueId, resourceInstanceId, true);
2774 if (result.isLeft()) {
2775 log.debug("Property value {} was removed from graph.", propertyValueId);
2776 ComponentInstanceProperty instanceProperty = result.left().value();
2778 resultOp = Either.left(instanceProperty);
2782 log.debug("Failed to remove property value {} in resource instance {}", propertyValueId, resourceInstanceId);
2784 ActionStatus actionStatus = componentsUtils.convertFromStorageResponseForResourceInstanceProperty(result.right().value());
2786 resultOp = Either.right(componentsUtils.getResponseFormatForResourceInstanceProperty(actionStatus, ""));
2792 if (resultOp == null || resultOp.isRight()) {
2793 janusGraphDao.rollback();
2795 janusGraphDao.commit();
2798 graphLockOperation.unlockComponent(serviceId, componentTypeEnum.getNodeType());
2803 private Component getAndValidateOriginComponentOfComponentInstance(Component containerComponent, ComponentInstance componentInstance) {
2805 ComponentTypeEnum componentType = getComponentTypeByParentComponentType(containerComponent.getComponentType());
2806 Component component;
2807 Either<Component, StorageOperationStatus> getComponentRes = toscaOperationFacade.getToscaFullElement(componentInstance.getComponentUid());
2808 if (getComponentRes.isRight()) {
2809 log.debug("Failed to get the component with id {} for component instance {} creation. ", componentInstance.getComponentUid(),
2810 componentInstance.getName());
2811 ActionStatus actionStatus = componentsUtils.convertFromStorageResponse(getComponentRes.right().value(), componentType);
2812 throw new ByActionStatusComponentException(actionStatus, Constants.EMPTY_STRING);
2814 component = getComponentRes.left().value();
2815 LifecycleStateEnum resourceCurrState = component.getLifecycleState();
2816 if (resourceCurrState == LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT) {
2817 ActionStatus actionStatus = ActionStatus.CONTAINER_CANNOT_CONTAIN_COMPONENT_IN_STATE;
2818 throw new ByActionStatusComponentException(actionStatus, containerComponent.getComponentType().toString(), resourceCurrState.toString());
2820 if (Boolean.TRUE.equals(component.isArchived())) {
2821 ActionStatus actionStatus = ActionStatus.COMPONENT_IS_ARCHIVED;
2822 throw new ByActionStatusComponentException(actionStatus, component.getName());
2824 final Map<String, InterfaceDefinition> componentInterfaces = component.getInterfaces();
2825 if (MapUtils.isNotEmpty(componentInterfaces)) {
2826 componentInterfaces.forEach(componentInstance::addInterface);
2831 public Either<Set<String>, ResponseFormat> forwardingPathOnVersionChange(String containerComponentParam,
2832 String containerComponentId,
2833 String componentInstanceId,
2834 ComponentInstance newComponentInstance) {
2835 Either<Set<String>, ResponseFormat> resultOp;
2836 final ComponentTypeEnum containerComponentType = validateComponentType(containerComponentParam);
2837 ComponentParametersView componentParametersView = getComponentParametersViewForForwardingPath();
2840 Component containerComponent = validateComponentExists(containerComponentId, containerComponentType, componentParametersView);
2842 //Fetch current component instance
2843 Either<ComponentInstance, StorageOperationStatus> eitherResourceInstance =
2844 getResourceInstanceById(containerComponent, componentInstanceId);
2845 if (eitherResourceInstance.isRight()) {
2846 resultOp = Either.right(componentsUtils.getResponseFormat(
2847 ActionStatus.RESOURCE_INSTANCE_NOT_FOUND_ON_SERVICE, componentInstanceId, containerComponentId));
2850 ComponentInstance currentResourceInstance = eitherResourceInstance.left().value();
2852 //Check whether new componentInstance exists
2853 String resourceId = newComponentInstance.getComponentUid();
2854 Either<Boolean, StorageOperationStatus> componentExistsRes = toscaOperationFacade.validateComponentExists(resourceId);
2855 if (componentExistsRes.isRight()) {
2856 log.debug("Failed to find resource {}", resourceId);
2857 resultOp = Either.right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse
2858 (componentExistsRes.right().value()), resourceId));
2860 } else if (!Boolean.TRUE.equals(componentExistsRes.left().value())) {
2861 log.debug("The resource {} not found ", resourceId);
2862 resultOp = Either.right(componentsUtils.getResponseFormat(ActionStatus.RESOURCE_NOT_FOUND, resourceId));
2866 //Fetch component using new component instance uid
2867 Component updatedContainerComponent = getOriginComponentFromComponentInstance(newComponentInstance);
2868 Set<String> toDeleteForwardingPaths = getForwardingPaths(containerComponent,
2869 currentResourceInstance, updatedContainerComponent);
2870 resultOp = Either.left(toDeleteForwardingPaths);
2875 private Set<String> getForwardingPaths(Component containerComponent, ComponentInstance currentResourceInstance,
2876 Component updatedContainerComponent) {
2877 DataForMergeHolder dataForMergeHolder = new DataForMergeHolder();
2878 dataForMergeHolder.setOrigComponentInstId(currentResourceInstance.getName());
2880 Service service = (Service) containerComponent;
2881 ForwardingPathUtils forwardingPathUtils = new ForwardingPathUtils();
2883 return forwardingPathUtils.
2884 getForwardingPathsToBeDeletedOnVersionChange(service, dataForMergeHolder, updatedContainerComponent);
2887 private ComponentParametersView getComponentParametersViewForForwardingPath() {
2888 ComponentParametersView componentParametersView = new ComponentParametersView();
2889 componentParametersView.setIgnoreCapabiltyProperties(false);
2890 componentParametersView.setIgnoreServicePath(false);
2891 return componentParametersView;
2894 public ComponentInstance changeComponentInstanceVersion(String containerComponentParam, String containerComponentId, String componentInstanceId,
2895 String userId, ComponentInstance newComponentInstance) {
2897 User user = validateUserExists(userId);
2898 final ComponentTypeEnum containerComponentType = validateComponentType(containerComponentParam);
2899 ComponentParametersView componentParametersView = new ComponentParametersView();
2900 componentParametersView.setIgnoreCapabiltyProperties(false);
2902 org.openecomp.sdc.be.model.Component containerComponent = validateComponentExists(containerComponentId, containerComponentType,
2903 componentParametersView);
2905 validateCanWorkOnComponent(containerComponent, userId);
2907 Either<ComponentInstance, StorageOperationStatus> resourceInstanceStatus = getResourceInstanceById(containerComponent, componentInstanceId);
2908 if (resourceInstanceStatus.isRight()) {
2909 throw new ByActionStatusComponentException(ActionStatus.RESOURCE_INSTANCE_NOT_FOUND_ON_SERVICE, componentInstanceId,
2910 containerComponentId);
2913 ComponentInstance currentResourceInstance = resourceInstanceStatus.left().value();
2915 return changeInstanceVersion(containerComponent, currentResourceInstance, newComponentInstance, user, containerComponentType);
2918 public ComponentInstance changeInstanceVersion(org.openecomp.sdc.be.model.Component containerComponent,
2919 ComponentInstance currentResourceInstance,
2920 ComponentInstance newComponentInstance,
2922 final ComponentTypeEnum containerComponentType) {
2923 boolean failed = false;
2924 Either<ComponentInstance, StorageOperationStatus> resourceInstanceStatus;
2927 lockComponent(containerComponent, "changeComponentInstanceVersion");
2928 String containerComponentId = containerComponent.getUniqueId();
2929 String componentInstanceId = currentResourceInstance.getUniqueId();
2930 if (currentResourceInstance.getComponentUid().equals(newComponentInstance.getComponentUid())) {
2931 return currentResourceInstance;
2933 String resourceId = newComponentInstance.getComponentUid();
2935 Either<Boolean, StorageOperationStatus> componentExistsRes = toscaOperationFacade
2936 .validateComponentExists(resourceId);
2937 if (componentExistsRes.isRight()) {
2938 StorageOperationStatus errorStatus = componentExistsRes.right().value();
2940 log.debug("Failed to validate existing of the component {}. Status is {} ", resourceId, errorStatus);
2941 throw new ByActionStatusComponentException(
2942 componentsUtils.convertFromStorageResponse(errorStatus), resourceId);
2943 } else if (!Boolean.TRUE.equals(componentExistsRes.left().value())) {
2944 log.debug("The resource {} not found ", resourceId);
2945 throw new ByActionStatusComponentException(ActionStatus.RESOURCE_NOT_FOUND, resourceId);
2948 Component eitherOriginComponent = getInstanceOriginNode(currentResourceInstance);
2949 DataForMergeHolder dataHolder = compInstMergeDataBL
2950 .saveAllDataBeforeDeleting(containerComponent, currentResourceInstance, eitherOriginComponent);
2951 ComponentInstance resResourceInfo = deleteComponentInstance(containerComponent, componentInstanceId,
2952 containerComponentType);
2954 if (resResourceInfo == null) {
2955 log.error("Calling `deleteComponentInstance` for the resource {} returned a null", resourceId);
2956 throw new ByActionStatusComponentException(ActionStatus.RESOURCE_NOT_FOUND, resourceId);
2958 Component origComponent = null;
2959 OriginTypeEnum originType = currentResourceInstance.getOriginType();
2960 newComponentInstance.setOriginType(originType);
2961 if (originType == OriginTypeEnum.ServiceProxy) {
2962 Either<Component, StorageOperationStatus> serviceProxyOrigin = toscaOperationFacade
2963 .getLatestByName(SERVICE_PROXY, null);
2964 if (isServiceProxyOrigin(serviceProxyOrigin)) {
2965 throw new ByActionStatusComponentException(
2966 componentsUtils.convertFromStorageResponse(serviceProxyOrigin.right().value()));
2968 origComponent = serviceProxyOrigin.left().value();
2970 StorageOperationStatus fillProxyRes = fillInstanceData(newComponentInstance, origComponent);
2972 if (isFillProxyRes(fillProxyRes)) {
2973 throw new ByActionStatusComponentException(
2974 componentsUtils.convertFromStorageResponse(fillProxyRes));
2976 } else if (originType == OriginTypeEnum.ServiceSubstitution) {
2977 final Either<Component, StorageOperationStatus> getServiceResult = toscaOperationFacade
2978 .getToscaFullElement(newComponentInstance.getComponentUid());
2979 if (getServiceResult.isRight()) {
2980 throw new ByActionStatusComponentException(componentsUtils.convertFromStorageResponse(getServiceResult.right().value()));
2982 final Component service = getServiceResult.left().value();
2984 final Either<Component, StorageOperationStatus> getServiceDerivedFromTypeResult = toscaOperationFacade
2985 .getLatestByToscaResourceName(service.getDerivedFromGenericType(), service.getModel());
2986 if (getServiceDerivedFromTypeResult.isRight()) {
2987 throw new ByActionStatusComponentException(componentsUtils.convertFromStorageResponse(getServiceResult.right().value()));
2990 origComponent = getServiceDerivedFromTypeResult.left().value();
2992 final StorageOperationStatus fillProxyRes = fillInstanceData(newComponentInstance, origComponent);
2993 if (isFillProxyRes(fillProxyRes)) {
2994 throw new ByActionStatusComponentException(
2995 componentsUtils.convertFromStorageResponse(fillProxyRes));
2998 origComponent = getOriginComponentFromComponentInstance(newComponentInstance);
2999 newComponentInstance.setName(resResourceInfo.getName());
3000 final Map<String, InterfaceDefinition> componentInterfaces = origComponent.getInterfaces();
3001 if (MapUtils.isNotEmpty(componentInterfaces)) {
3002 componentInterfaces.forEach(newComponentInstance::addInterface);
3006 newComponentInstance.setInvariantName(resResourceInfo.getInvariantName());
3007 newComponentInstance.setPosX(resResourceInfo.getPosX());
3008 newComponentInstance.setPosY(resResourceInfo.getPosY());
3009 newComponentInstance.setDescription(resResourceInfo.getDescription());
3010 newComponentInstance.setInstanceCount(resResourceInfo.getInstanceCount());
3011 newComponentInstance.setMaxOccurrences(resResourceInfo.getMaxOccurrences());
3012 newComponentInstance.setMinOccurrences(resResourceInfo.getMinOccurrences());
3013 newComponentInstance.setDirectives(resResourceInfo.getDirectives());
3014 checkForExternalReqAndCapabilities(origComponent, resResourceInfo);
3016 ComponentInstance updatedComponentInstance =
3017 createComponentInstanceOnGraph(containerComponent, origComponent, newComponentInstance, user);
3018 dataHolder.setCurrInstanceNode(origComponent);
3020 .mergeComponentUserOrigData(user, dataHolder, containerComponent, containerComponentId, newComponentInstance.getUniqueId());
3022 ActionStatus postChangeVersionResult = onChangeInstanceOperationOrchestrator
3023 .doPostChangeVersionOperations(containerComponent, currentResourceInstance, newComponentInstance);
3024 if (postChangeVersionResult != ActionStatus.OK) {
3025 throw new ByActionStatusComponentException(postChangeVersionResult);
3028 ComponentParametersView filter = new ComponentParametersView(true);
3029 filter.setIgnoreComponentInstances(false);
3030 Either<Component, StorageOperationStatus> updatedComponentRes = toscaOperationFacade.getToscaElement(containerComponentId, filter);
3031 if (updatedComponentRes.isRight()) {
3032 StorageOperationStatus storageOperationStatus = updatedComponentRes.right().value();
3033 ActionStatus actionStatus = componentsUtils
3034 .convertFromStorageResponse(storageOperationStatus, containerComponent.getComponentType());
3035 log.debug("Component with id {} was not found", containerComponentId);
3036 throw new ByActionStatusComponentException(actionStatus, Constants.EMPTY_STRING);
3039 maintainNodeFilters(currentResourceInstance, newComponentInstance, containerComponentId);
3041 resourceInstanceStatus = getResourceInstanceById(updatedComponentRes.left().value(),
3042 updatedComponentInstance.getUniqueId());
3043 if (resourceInstanceStatus.isRight()) {
3044 throw new ByActionStatusComponentException(componentsUtils.convertFromStorageResponse
3045 (resourceInstanceStatus.right().value()), updatedComponentInstance.getUniqueId());
3047 return resourceInstanceStatus.left().value();
3049 } catch (ComponentException e) {
3053 unlockComponent(failed, containerComponent);
3057 private void maintainNodeFilters(
3058 ComponentInstance currentResourceInstance,
3059 ComponentInstance newComponentInstance,
3060 String containerComponentId) {
3061 CINodeFilterDataDefinition filterToMaintain = currentResourceInstance.getNodeFilter();
3062 if (null != filterToMaintain) {
3063 nodeFilterOperation.addNodeFilterData(
3064 containerComponentId.toLowerCase(),
3065 newComponentInstance.getUniqueId(),
3070 private void checkForExternalReqAndCapabilities(Component component, ComponentInstance resResourceInfo) {
3071 Map<String, List<RequirementDefinition>> requirementsMap = resResourceInfo.getRequirements();
3072 Map<String, List<RequirementDefinition>> externalRequirementsMap = new HashMap<>();
3073 List<RequirementDefinition> externalRequirementList = new ArrayList<>();
3074 if (requirementsMap != null && !requirementsMap.isEmpty()) {
3075 requirementsMap.forEach((type, requirementDefinitions) -> {
3076 if (requirementDefinitions != null && !requirementDefinitions.isEmpty()) {
3077 for (final RequirementDefinition requirementDefinition : requirementDefinitions) {
3078 if (requirementDefinition.isExternal()) {
3079 externalRequirementList.add(requirementDefinition);
3080 externalRequirementsMap.put(type, externalRequirementList);
3087 Map<String, List<CapabilityDefinition>> capabilitiesMap = resResourceInfo.getCapabilities();
3088 Map<String, List<CapabilityDefinition>> externalCapabilitiesMap = new HashMap<>();
3089 List<CapabilityDefinition> externalCapabilitiesList = new ArrayList<>();
3090 if (capabilitiesMap != null && !capabilitiesMap.isEmpty()) {
3091 capabilitiesMap.forEach((type, capabilityDefinitions) -> {
3092 if (capabilityDefinitions != null && !capabilityDefinitions.isEmpty()) {
3093 for (final CapabilityDefinition capabilityDefinition : capabilityDefinitions) {
3094 if (capabilityDefinition.isExternal()) {
3095 externalCapabilitiesList.add(capabilityDefinition);
3096 externalCapabilitiesMap.put(type, externalCapabilitiesList);
3102 component.setCapabilities(externalCapabilitiesMap);
3103 component.setRequirements(externalRequirementsMap);
3106 private boolean isFillProxyRes(StorageOperationStatus fillProxyRes) {
3107 if (fillProxyRes != StorageOperationStatus.OK) {
3108 log.debug("Failed to fill service proxy resource data with data from service, error {}", fillProxyRes);
3115 public List<ComponentInstanceProperty> getComponentInstancePropertiesById(String containerComponentTypeParam, String containerComponentId,
3116 String componentInstanceUniqueId, String userId) {
3117 Component containerComponent = null;
3119 boolean failed = false;
3121 validateUserExists(userId);
3122 validateComponentType(containerComponentTypeParam);
3124 Either<Component, StorageOperationStatus> validateContainerComponentExists = toscaOperationFacade.getToscaElement(containerComponentId);
3125 if (validateContainerComponentExists.isRight()) {
3126 throw new ByActionStatusComponentException(
3127 componentsUtils.convertFromStorageResponse(validateContainerComponentExists.right().value()));
3129 containerComponent = validateContainerComponentExists.left().value();
3131 Either<ComponentInstance, StorageOperationStatus> resourceInstanceStatus = getResourceInstanceById(containerComponent,
3132 componentInstanceUniqueId);
3133 if (resourceInstanceStatus.isRight()) {
3134 throw new ByActionStatusComponentException(ActionStatus.RESOURCE_INSTANCE_NOT_FOUND_ON_SERVICE, componentInstanceUniqueId,
3135 containerComponentId);
3138 List<ComponentInstanceProperty> instanceProperties = new ArrayList<>();
3139 if (MapUtils.isNotEmpty(containerComponent.getComponentInstancesProperties())) {
3140 instanceProperties = containerComponent.getComponentInstancesProperties()
3141 .get(componentInstanceUniqueId);
3143 return instanceProperties;
3144 } catch (ComponentException e) {
3148 unlockComponent(failed, containerComponent);
3152 public List<ComponentInstanceAttribute> getComponentInstanceAttributesById(final String containerComponentTypeParam,
3153 final String containerComponentId,
3154 final String componentInstanceUniqueId,
3155 final String userId) {
3156 Component containerComponent = null;
3158 boolean failed = false;
3160 validateUserExists(userId);
3161 validateComponentType(containerComponentTypeParam);
3163 final Either<Component, StorageOperationStatus> validateContainerComponentExists =
3164 toscaOperationFacade.getToscaElement(containerComponentId);
3165 if (validateContainerComponentExists.isRight()) {
3166 throw new ByActionStatusComponentException(
3167 componentsUtils.convertFromStorageResponse(validateContainerComponentExists.right().value()));
3169 containerComponent = validateContainerComponentExists.left().value();
3171 if (getResourceInstanceById(containerComponent, componentInstanceUniqueId).isRight()) {
3172 throw new ByActionStatusComponentException(
3173 ActionStatus.RESOURCE_INSTANCE_NOT_FOUND_ON_SERVICE, componentInstanceUniqueId, containerComponentId);
3176 final Map<String, List<ComponentInstanceAttribute>> componentInstancesAttributes = containerComponent.getComponentInstancesAttributes();
3177 return componentInstancesAttributes == null ? new ArrayList<>()
3178 : componentInstancesAttributes.getOrDefault(componentInstanceUniqueId, new ArrayList<>());
3179 } catch (final ComponentException e) {
3183 unlockComponent(failed, containerComponent);
3187 protected void validateIncrementCounter(String resourceInstanceId, GraphPropertiesDictionary counterType,
3188 Wrapper<Integer> instaceCounterWrapper,
3189 Wrapper<ResponseFormat> errorWrapper) {
3190 Either<Integer, StorageOperationStatus> counterRes = componentInstanceOperation
3191 .increaseAndGetResourceInstanceSpecificCounter(resourceInstanceId, counterType, true);
3193 if (counterRes.isRight()) {
3194 log.debug("increase And Get {} failed resource instance {}", counterType, resourceInstanceId);
3195 StorageOperationStatus status = counterRes.right().value();
3196 ActionStatus actionStatus = componentsUtils.convertFromStorageResponseForResourceInstanceProperty(status);
3197 errorWrapper.setInnerElement(componentsUtils.getResponseFormat(actionStatus));
3199 instaceCounterWrapper.setInnerElement(counterRes.left().value());
3205 * updates componentInstance modificationTime
3207 * @param componentInstance
3208 * @param componentInstanceType
3209 * @param modificationTime
3210 * @param inTransaction
3213 public Either<ComponentInstanceData, ResponseFormat> updateComponentInstanceModificationTimeAndCustomizationUuid(
3214 ComponentInstance componentInstance, NodeTypeEnum componentInstanceType, Long modificationTime, boolean inTransaction) {
3215 Either<ComponentInstanceData, ResponseFormat> result;
3216 Either<ComponentInstanceData, StorageOperationStatus> updateComponentInstanceRes = componentInstanceOperation
3217 .updateComponentInstanceModificationTimeAndCustomizationUuidOnGraph(componentInstance, componentInstanceType, modificationTime,
3219 if (updateComponentInstanceRes.isRight()) {
3220 log.debug("Failed to update component instance {} with new last update date and mofifier. Status is {}. ", componentInstance.getName(),
3221 updateComponentInstanceRes.right().value());
3223 .right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(updateComponentInstanceRes.right().value())));
3225 result = Either.left(updateComponentInstanceRes.left().value());
3230 public Either<ComponentInstance, ResponseFormat> deleteServiceProxy() {
3231 // TODO Add implementation
3232 return Either.left(new ComponentInstance());
3235 public Either<ComponentInstance, ResponseFormat> createServiceProxy() {
3236 // TODO Add implementation
3237 return Either.left(new ComponentInstance());
3240 public Either<ComponentInstance, ResponseFormat> changeServiceProxyVersion() {
3241 // TODO Add implementation
3242 return Either.left(new ComponentInstance());
3245 private Boolean validateInstanceNameUniquenessUponUpdate(Component containerComponent, ComponentInstance oldComponentInstance,
3246 String newInstanceName) {
3247 return ComponentValidations.validateNameIsUniqueInComponent(oldComponentInstance.getName(), newInstanceName, containerComponent);
3250 private Either<ComponentInstance, StorageOperationStatus> getResourceInstanceById(final Component containerComponent, final String instanceId) {
3251 final List<ComponentInstance> instances = containerComponent.getComponentInstances();
3252 if (CollectionUtils.isEmpty(instances)) {
3253 return Either.right(StorageOperationStatus.NOT_FOUND);
3256 final Optional<ComponentInstance> foundInstance = instances.stream().filter(i -> i.getUniqueId().equals(instanceId)).findFirst();
3257 if (foundInstance.isEmpty()) {
3258 return Either.right(StorageOperationStatus.NOT_FOUND);
3261 return Either.left(foundInstance.get());
3264 private ComponentInstance buildComponentInstance(ComponentInstance resourceInstanceForUpdate, ComponentInstance origInstanceForUpdate) {
3265 Long creationDate = origInstanceForUpdate.getCreationTime();
3266 Long modificationTime = System.currentTimeMillis();
3267 resourceInstanceForUpdate.setCreationTime(creationDate);
3268 resourceInstanceForUpdate.setModificationTime(modificationTime);
3269 resourceInstanceForUpdate.setCustomizationUUID(origInstanceForUpdate.getCustomizationUUID());
3270 if (StringUtils.isEmpty(resourceInstanceForUpdate.getName()) && StringUtils.isNotEmpty(origInstanceForUpdate.getName())) {
3271 resourceInstanceForUpdate.setName(origInstanceForUpdate.getName());
3273 resourceInstanceForUpdate.setNormalizedName(ValidationUtils.normalizeComponentInstanceName(resourceInstanceForUpdate.getName()));
3274 if (StringUtils.isEmpty(resourceInstanceForUpdate.getIcon())) {
3275 resourceInstanceForUpdate.setIcon(origInstanceForUpdate.getIcon());
3277 if (StringUtils.isEmpty(resourceInstanceForUpdate.getComponentVersion())) {
3278 resourceInstanceForUpdate.setComponentVersion(origInstanceForUpdate.getComponentVersion());
3280 if (StringUtils.isEmpty(resourceInstanceForUpdate.getComponentName())) {
3281 resourceInstanceForUpdate.setComponentName(origInstanceForUpdate.getComponentName());
3283 if (StringUtils.isEmpty(resourceInstanceForUpdate.getToscaComponentName())) {
3284 resourceInstanceForUpdate.setToscaComponentName(origInstanceForUpdate.getToscaComponentName());
3286 if (resourceInstanceForUpdate.getOriginType() == null) {
3287 resourceInstanceForUpdate.setOriginType(origInstanceForUpdate.getOriginType());
3289 if (resourceInstanceForUpdate.getOriginType() == OriginTypeEnum.ServiceProxy) {
3290 resourceInstanceForUpdate.setIsProxy(true);
3292 if (resourceInstanceForUpdate.getSourceModelInvariant() == null) {
3293 resourceInstanceForUpdate.setSourceModelInvariant(origInstanceForUpdate.getSourceModelInvariant());
3295 if (resourceInstanceForUpdate.getSourceModelName() == null) {
3296 resourceInstanceForUpdate.setSourceModelName(origInstanceForUpdate.getSourceModelName());
3298 if (resourceInstanceForUpdate.getSourceModelUuid() == null) {
3299 resourceInstanceForUpdate.setSourceModelUuid(origInstanceForUpdate.getSourceModelUuid());
3301 if (resourceInstanceForUpdate.getSourceModelUid() == null) {
3302 resourceInstanceForUpdate.setSourceModelUid(origInstanceForUpdate.getSourceModelUid());
3304 if (resourceInstanceForUpdate.getCreatedFrom() == null) {
3305 resourceInstanceForUpdate.setCreatedFrom(origInstanceForUpdate.getCreatedFrom());
3307 return resourceInstanceForUpdate;
3311 * Returns list of ComponentInstanceProperty belonging to component instance capability specified by name, type and ownerId
3313 * @param containerComponentType
3314 * @param containerComponentId
3315 * @param componentInstanceUniqueId
3316 * @param capabilityType
3317 * @param capabilityName
3322 public List<ComponentInstanceProperty> getComponentInstanceCapabilityPropertiesById(String containerComponentType, String containerComponentId,
3323 String componentInstanceUniqueId, String capabilityType,
3324 String capabilityName, String ownerId, String userId) {
3325 Component containerComponent = null;
3326 List<ComponentInstanceProperty> resultOp = null;
3328 validateUserExists(userId);
3329 validateComponentType(containerComponentType);
3330 containerComponent = toscaOperationFacade.getToscaFullElement(containerComponentId).left().on(this::componentException);
3331 ComponentInstance resourceInstanceStatus = getResourceInstanceById(containerComponent, componentInstanceUniqueId).left()
3332 .on(this::componentInstanceException);
3333 resultOp = findCapabilityOfInstance(containerComponentId, componentInstanceUniqueId, capabilityType, capabilityName, ownerId,
3334 resourceInstanceStatus.getCapabilities());
3335 } catch (StorageException | ComponentException e) {
3336 unlockRollbackWithException(containerComponent, e);
3337 } catch (Exception e) {
3338 unlockRollbackWithException(containerComponent, new ByActionStatusComponentException(ActionStatus.GENERAL_ERROR));
3340 unlockWithCommit(containerComponent);
3344 private List<ComponentInstanceProperty> findCapabilityOfInstance(String componentId, String instanceId, String capabilityType,
3345 String capabilityName, String ownerId,
3346 Map<String, List<CapabilityDefinition>> instanceCapabilities) {
3347 CapabilityDefinition foundCapability;
3348 if (MapUtils.isNotEmpty(instanceCapabilities)) {
3349 List<CapabilityDefinition> capabilitiesPerType = instanceCapabilities.get(capabilityType);
3350 if (capabilitiesPerType != null) {
3351 Optional<CapabilityDefinition> capabilityOpt = capabilitiesPerType.stream()
3352 .filter(c -> c.getName().equals(capabilityName) && c.getOwnerId().equals(ownerId)).findFirst();
3353 if (capabilityOpt.isPresent()) {
3354 foundCapability = capabilityOpt.get();
3355 return foundCapability.getProperties() == null ? new ArrayList<>() : foundCapability.getProperties();
3359 return fetchComponentInstanceCapabilityProperties(componentId, instanceId, capabilityType, capabilityName, ownerId);
3362 private List<ComponentInstanceProperty> fetchComponentInstanceCapabilityProperties(String componentId, String instanceId, String capabilityType,
3363 String capabilityName, String ownerId) {
3365 return toscaOperationFacade.getComponentInstanceCapabilityProperties(componentId, instanceId, capabilityName, capabilityType, ownerId)
3366 .left().on(this::componentInstancePropertyListException);
3367 } catch (Exception e) {
3368 log.debug("The exception {} occurred upon the component {} instance {} capability {} properties retrieving. ", componentId, instanceId,
3370 throw new ByActionStatusComponentException(ActionStatus.GENERAL_ERROR);
3374 public Either<RequirementDefinition, ResponseFormat> updateInstanceRequirement(ComponentTypeEnum componentTypeEnum, String containerComponentId,
3375 String componentInstanceUniqueId,
3376 RequirementDefinition requirementDef, String userId) {
3377 Either<RequirementDefinition, ResponseFormat> resultOp = null;
3378 validateUserExists(userId);
3379 if (componentTypeEnum == null) {
3380 BeEcompErrorManager.getInstance().logInvalidInputError("updateInstanceRequirement", INVALID_COMPONENT_TYPE, ErrorSeverity.INFO);
3381 return Either.right(componentsUtils.getResponseFormat(ActionStatus.NOT_ALLOWED));
3383 Either<Component, StorageOperationStatus> getResourceResult = toscaOperationFacade.getToscaFullElement(containerComponentId);
3384 if (getResourceResult.isRight()) {
3385 log.debug(FAILED_TO_RETRIEVE_COMPONENT_COMPONENT_ID, containerComponentId);
3386 return Either.right(componentsUtils.getResponseFormat(ActionStatus.RESTRICTED_OPERATION));
3388 Component containerComponent = getResourceResult.left().value();
3389 if (!ComponentValidationUtils.canWorkOnComponent(containerComponent, userId)) {
3390 log.info(RESTRICTED_OPERATION_ON_COMPONENT, userId, containerComponentId);
3391 return Either.right(componentsUtils.getResponseFormat(ActionStatus.RESTRICTED_OPERATION));
3393 Either<ComponentInstance, StorageOperationStatus> resourceInstanceStatus = getResourceInstanceById(containerComponent,
3394 componentInstanceUniqueId);
3395 if (resourceInstanceStatus.isRight()) {
3396 return Either.right(componentsUtils
3397 .getResponseFormat(ActionStatus.RESOURCE_INSTANCE_NOT_FOUND_ON_SERVICE, componentInstanceUniqueId, containerComponentId));
3400 StorageOperationStatus lockStatus = graphLockOperation.lockComponent(containerComponentId, componentTypeEnum.getNodeType());
3401 if (lockStatus != StorageOperationStatus.OK) {
3402 log.debug(FAILED_TO_LOCK_COMPONENT, containerComponentId);
3403 return Either.right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(lockStatus)));
3406 StorageOperationStatus updateRequirementStatus = toscaOperationFacade
3407 .updateComponentInstanceRequirement(containerComponentId, componentInstanceUniqueId, requirementDef);
3408 if (updateRequirementStatus != StorageOperationStatus.OK) {
3409 log.debug("Failed to update component instance requirement on instance {} in container {}", componentInstanceUniqueId,
3410 containerComponentId);
3411 return Either.right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(updateRequirementStatus)));
3413 Either<Component, StorageOperationStatus> updateContainerRes = toscaOperationFacade
3414 .updateComponentInstanceMetadataOfTopologyTemplate(containerComponent);
3415 if (updateContainerRes.isRight()) {
3416 ActionStatus actionStatus = componentsUtils.convertFromStorageResponseForResourceInstanceProperty(updateContainerRes.right().value());
3417 resultOp = Either.right(componentsUtils.getResponseFormatForResourceInstanceProperty(actionStatus, ""));
3420 resultOp = Either.left(requirementDef);
3423 if (resultOp == null || resultOp.isRight()) {
3424 janusGraphDao.rollback();
3426 janusGraphDao.commit();
3429 graphLockOperation.unlockComponent(containerComponentId, componentTypeEnum.getNodeType());
3433 public Either<CapabilityDefinition, ResponseFormat> updateInstanceCapability(final ComponentTypeEnum containerComponentType,
3434 final String containerComponentId,
3435 final String componentInstanceUniqueId,
3436 final CapabilityDefinition capabilityDefinition,
3437 final String userId) {
3438 if (containerComponentType == null) {
3439 BeEcompErrorManager.getInstance().logInvalidInputError("updateInstanceCapability", INVALID_COMPONENT_TYPE, ErrorSeverity.INFO);
3440 return Either.right(componentsUtils.getResponseFormat(ActionStatus.NOT_ALLOWED));
3442 validateUserExists(userId);
3443 final Either<Component, StorageOperationStatus> getResourceResult = toscaOperationFacade.getToscaFullElement(containerComponentId);
3444 if (getResourceResult.isRight()) {
3445 log.debug(FAILED_TO_RETRIEVE_COMPONENT_COMPONENT_ID, containerComponentId);
3446 return Either.right(componentsUtils.getResponseFormat(ActionStatus.COMPONENT_NOT_FOUND, containerComponentId));
3448 final Component containerComponent = getResourceResult.left().value();
3449 if (!ComponentValidationUtils.canWorkOnComponent(containerComponent, userId)) {
3450 log.info(RESTRICTED_OPERATION_ON_COMPONENT, userId, containerComponentId);
3451 return Either.right(componentsUtils.getResponseFormat(ActionStatus.RESTRICTED_OPERATION));
3453 final Either<ComponentInstance, StorageOperationStatus> resourceInstanceStatus =
3454 getResourceInstanceById(containerComponent, componentInstanceUniqueId);
3455 if (resourceInstanceStatus.isRight()) {
3456 return Either.right(componentsUtils
3457 .getResponseFormat(ActionStatus.RESOURCE_INSTANCE_NOT_FOUND_ON_SERVICE, componentInstanceUniqueId, containerComponentId));
3460 final StorageOperationStatus lockStatus = graphLockOperation.lockComponent(containerComponentId, containerComponentType.getNodeType());
3461 if (lockStatus != StorageOperationStatus.OK) {
3462 log.debug(FAILED_TO_LOCK_COMPONENT, containerComponentId);
3463 return Either.right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(lockStatus)));
3465 var success = false;
3467 final CapabilityDataDefinition updatedCapabilityDefinition = toscaOperationFacade
3468 .updateComponentInstanceCapability(containerComponentId, componentInstanceUniqueId, capabilityDefinition);
3469 final Either<Component, StorageOperationStatus> updateContainerEither = toscaOperationFacade
3470 .updateComponentInstanceMetadataOfTopologyTemplate(containerComponent);
3471 if (updateContainerEither.isRight()) {
3472 var actionStatus = componentsUtils.convertFromStorageResponse(updateContainerEither.right().value(), containerComponentType);
3473 return Either.right(componentsUtils.getResponseFormat(actionStatus));
3476 return Either.left(new CapabilityDefinition(updatedCapabilityDefinition));
3477 } catch (final BusinessException e) {
3478 log.error(EcompLoggerErrorCode.BUSINESS_PROCESS_ERROR, NodeTemplateOperation.class.getName(), (ErrorLogOptionalData) null,
3479 FAILED_TO_UPDATE_COMPONENT_INSTANCE_CAPABILITY, componentInstanceUniqueId, containerComponentId);
3481 } catch (final Exception e) {
3482 log.error(EcompLoggerErrorCode.BUSINESS_PROCESS_ERROR, NodeTemplateOperation.class.getName(), (ErrorLogOptionalData) null,
3483 FAILED_TO_UPDATE_COMPONENT_INSTANCE_CAPABILITY, componentInstanceUniqueId, containerComponentId);
3484 throw new ByResponseFormatComponentException(componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR));
3487 janusGraphDao.commit();
3489 janusGraphDao.rollback();
3492 graphLockOperation.unlockComponent(containerComponentId, containerComponentType.getNodeType());
3496 public Either<List<ComponentInstanceProperty>, ResponseFormat> updateInstanceCapabilityProperties(ComponentTypeEnum componentTypeEnum,
3497 String containerComponentId,
3498 String componentInstanceUniqueId,
3499 String capabilityType, String capabilityName,
3500 List<ComponentInstanceProperty> properties,
3502 Either<List<ComponentInstanceProperty>, ResponseFormat> resultOp = null;
3503 validateUserExists(userId);
3504 if (componentTypeEnum == null) {
3505 BeEcompErrorManager.getInstance().logInvalidInputError("updateInstanceCapabilityProperty", INVALID_COMPONENT_TYPE, ErrorSeverity.INFO);
3506 return Either.right(componentsUtils.getResponseFormat(ActionStatus.NOT_ALLOWED));
3508 Either<Component, StorageOperationStatus> getResourceResult = toscaOperationFacade.getToscaFullElement(containerComponentId);
3509 if (getResourceResult.isRight()) {
3510 log.debug(FAILED_TO_RETRIEVE_COMPONENT_COMPONENT_ID, containerComponentId);
3511 return Either.right(componentsUtils.getResponseFormat(ActionStatus.RESTRICTED_OPERATION));
3513 Component containerComponent = getResourceResult.left().value();
3514 if (!ComponentValidationUtils.canWorkOnComponent(containerComponent, userId)) {
3515 log.info(RESTRICTED_OPERATION_ON_COMPONENT, userId, containerComponentId);
3516 return Either.right(componentsUtils.getResponseFormat(ActionStatus.RESTRICTED_OPERATION));
3518 Either<ComponentInstance, StorageOperationStatus> resourceInstanceStatus = getResourceInstanceById(containerComponent,
3519 componentInstanceUniqueId);
3520 if (resourceInstanceStatus.isRight()) {
3521 return Either.right(componentsUtils
3522 .getResponseFormat(ActionStatus.RESOURCE_INSTANCE_NOT_FOUND_ON_SERVICE, componentInstanceUniqueId, containerComponentId));
3524 ComponentInstance foundResourceInstance = resourceInstanceStatus.left().value();
3526 StorageOperationStatus lockStatus = graphLockOperation.lockComponent(containerComponentId, componentTypeEnum.getNodeType());
3527 if (lockStatus != StorageOperationStatus.OK) {
3528 log.debug(FAILED_TO_LOCK_COMPONENT, containerComponentId);
3529 return Either.right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(lockStatus)));
3532 for (ComponentInstanceProperty property : properties) {
3533 Either<String, ResponseFormat> newPropertyValueEither = validatePropertyObjectValue(property, property.getValue(), false);
3534 newPropertyValueEither.bimap(
3535 updatedValue -> updateCapabilityPropertyOnContainerComponent(property, updatedValue, containerComponent, foundResourceInstance,
3536 capabilityType, capabilityName), Either::right);
3538 Either<Component, StorageOperationStatus> updateContainerRes = toscaOperationFacade
3539 .updateComponentInstanceMetadataOfTopologyTemplate(containerComponent);
3540 if (updateContainerRes.isRight()) {
3541 ActionStatus actionStatus = componentsUtils.convertFromStorageResponseForResourceInstanceProperty(updateContainerRes.right().value());
3542 resultOp = Either.right(componentsUtils.getResponseFormatForResourceInstanceProperty(actionStatus, ""));
3545 resultOp = Either.left(properties);
3548 if (resultOp == null || resultOp.isRight()) {
3549 janusGraphDao.rollback();
3551 janusGraphDao.commit();
3554 graphLockOperation.unlockComponent(containerComponentId, componentTypeEnum.getNodeType());
3558 public Either<Map<String, ComponentInstance>, ResponseFormat> copyComponentInstance(ComponentInstance inputComponentInstance,
3559 String containerComponentId, String componentInstanceId,
3561 Map<String, ComponentInstance> resultMap = new HashMap<>();
3562 Either<Component, StorageOperationStatus> getOrigComponent = toscaOperationFacade.getToscaElement(containerComponentId);
3563 if (getOrigComponent.isRight()) {
3564 log.error("Failed to get the original component information");
3565 return Either.right(componentsUtils.getResponseFormat(ActionStatus.USER_DEFINED, FAILED_TO_COPY_COMP_INSTANCE_TO_CANVAS));
3567 Component origComponent = getOrigComponent.left().value();
3569 lockComponent(origComponent, "copyComponentInstance");
3570 } catch (ComponentException e) {
3571 log.error("destComponentInstance's data is {}", origComponent.toString());
3572 return Either.right(componentsUtils
3573 .getResponseFormat(ActionStatus.USER_DEFINED, "Failed to lock component destComponentInstance's data is {}",
3574 origComponent.toString()));
3576 boolean failed = false;
3577 ComponentInstance actionResponse = null;
3579 actionResponse = createComponentInstance("services", containerComponentId, userId, inputComponentInstance, false);
3580 } catch (ComponentException e) {
3582 // on failure of the create instance unlock the resource and rollback the transaction.
3583 return Either.right(componentsUtils.getResponseFormat(ActionStatus.USER_DEFINED, FAILED_TO_COPY_COMP_INSTANCE_TO_CANVAS));
3585 // on failure of the create instance unlock the resource and rollback the transaction.
3586 if (null == actionResponse) {
3587 log.error(FAILED_TO_COPY_COMP_INSTANCE_TO_CANVAS);
3588 unlockComponent(failed, origComponent);
3591 Either<String, ResponseFormat> resultOp = null;
3593 ComponentInstance destComponentInstance = actionResponse;
3594 log.debug("destComponentInstance's data is {}", destComponentInstance);
3595 resultOp = deepCopyComponentInstance(origComponent, containerComponentId, componentInstanceId, destComponentInstance, userId);
3596 resultMap.put("componentInstance", destComponentInstance);
3599 if (resultOp == null || resultOp.isRight()) {
3600 unlockComponent(true, origComponent);
3601 janusGraphDao.rollback();
3602 log.error("Failed to deep copy component instance");
3604 unlockComponent(false, origComponent);
3605 janusGraphDao.commit();
3606 log.debug("Success trasaction commit");
3609 if (resultOp == null || resultOp.isRight()) {
3611 .right(componentsUtils.getResponseFormat(ActionStatus.USER_DEFINED, "Failed to deep copy the component instance to the canvas"));
3613 return Either.left(resultMap);
3617 private Either<String, ResponseFormat> deepCopyComponentInstance(Component sourceComponent, String containerComponentId,
3618 String sourceComponentInstanceId, ComponentInstance destComponentInstance,
3620 Either<Component, StorageOperationStatus> getDestComponent = toscaOperationFacade.getToscaElement(containerComponentId);
3621 if (getDestComponent.isRight()) {
3622 log.error("Failed to get the dest component information");
3623 return Either.right(componentsUtils.getResponseFormat(ActionStatus.USER_DEFINED, FAILED_TO_COPY_COMP_INSTANCE_TO_CANVAS));
3625 Component destComponent = getDestComponent.left().value();
3626 Either<String, ResponseFormat> copyComponentInstanceWithPropertiesAndInputs = copyComponentInstanceWithPropertiesAndInputs(sourceComponent,
3627 destComponent, sourceComponentInstanceId, destComponentInstance);
3628 if (copyComponentInstanceWithPropertiesAndInputs.isRight()) {
3629 log.error("Failed to copy component instance with properties and inputs as part of deep copy");
3630 return Either.right(componentsUtils.getResponseFormat(ActionStatus.USER_DEFINED,
3631 "Failed to copy the component instance with properties and inputs as part of deep copy"));
3633 Either<String, ResponseFormat> copyComponentInstanceWithAttributes = copyComponentInstanceWithAttributes(sourceComponent, destComponent,
3634 sourceComponentInstanceId, destComponentInstance, userId);
3635 if (copyComponentInstanceWithAttributes.isRight()) {
3636 log.error("Failed to copy component instance with attributes as part of deep copy");
3637 return Either.right(componentsUtils
3638 .getResponseFormat(ActionStatus.USER_DEFINED, "Failed to copy the component instance with attributes as part of deep copy"));
3640 return Either.left(COPY_COMPONENT_INSTANCE_OK);
3643 private Either<String, ResponseFormat> copyComponentInstanceWithPropertiesAndInputs(Component sourceComponent, Component destComponent,
3644 String sourceComponentInstanceId,
3645 ComponentInstance destComponentInstance) {
3646 log.debug("start to copy ComponentInstance with properties and inputs");
3647 List<ComponentInstanceProperty> sourcePropList = null;
3648 if (sourceComponent.getComponentInstancesProperties() != null
3649 && sourceComponent.getComponentInstancesProperties().get(sourceComponentInstanceId) != null) {
3650 sourcePropList = sourceComponent.getComponentInstancesProperties().get(sourceComponentInstanceId);
3651 log.debug("sourcePropList");
3653 List<ComponentInstanceProperty> destPropList = null;
3654 String destComponentInstanceId = destComponentInstance.getUniqueId();
3655 log.debug("destComponentInstanceId: {}", destComponentInstance.getUniqueId());
3656 if (destComponent.getComponentInstancesProperties() != null
3657 && destComponent.getComponentInstancesProperties().get(destComponentInstanceId) != null) {
3658 destPropList = destComponent.getComponentInstancesProperties().get(destComponentInstanceId);
3659 log.debug("destPropList {}");
3661 List<ComponentInstancePropInput> componentInstancePropInputList = new ArrayList<>();
3662 if (null != destPropList && null != sourcePropList) {
3663 log.debug("start to set property and attribute");
3664 for (ComponentInstanceProperty destProp : destPropList) {
3665 String destPropertyName = destProp.getName();
3666 for (ComponentInstanceProperty sourceProp : sourcePropList) {
3667 if (!destPropertyName.equals(sourceProp.getName())) {
3670 log.debug("now set property");
3671 final List<GetInputValueDataDefinition> getInputValues = sourceProp.getGetInputValues();
3672 if (getInputValues == null && !StringUtils.isEmpty(sourceProp.getValue()) && (destProp.getValue() == null || !destProp.getValue()
3673 .equals(sourceProp.getValue()))) {
3674 log.debug("Now starting to copy the property {} in value {}", destPropertyName, sourceProp.getValue());
3675 destProp.setValue(sourceProp.getValue());
3676 Either<String, ResponseFormat> updatePropertyValueEither = updateComponentInstanceProperty(destComponent.getUniqueId(),
3677 destComponentInstanceId, destProp);
3678 if (updatePropertyValueEither.isRight()) {
3679 log.error("Failed to copy the property {}", destPropertyName);
3680 return Either.right(componentsUtils.getResponseFormat(ActionStatus.INVALID_CONTENT_PARAM,
3681 "Failed to paste component instance to the canvas, property copy"));
3685 log.debug("Now start to update inputs");
3686 if (getInputValues != null) {
3687 if (getInputValues.isEmpty()) {
3688 log.debug("property is return from input, set by man");
3691 log.debug("Now starting to copy the {} property", destPropertyName);
3692 Either<String, ResponseFormat> getSourceInputDefaultValue = getInputListDefaultValue(sourceComponent,
3693 getInputValues.get(0).getInputId());
3694 if (getSourceInputDefaultValue.isRight()) {
3695 return Either.right(getSourceInputDefaultValue.right().value());
3697 componentInstancePropInputList.add(new ComponentInstancePropInput(destProp));
3702 return Either.left(COPY_COMPONENT_INSTANCE_OK);
3705 private Either<String, ResponseFormat> copyComponentInstanceWithAttributes(Component sourceComponent, Component destComponent,
3706 String sourceComponentInstanceId,
3707 ComponentInstance destComponentInstance, String userId) {
3708 String destComponentInstanceId = destComponentInstance.getUniqueId();
3709 log.info("start to copy component instance with attributes");
3710 List<ComponentInstanceAttribute> sourceAttributeList = null;
3711 if (sourceComponent.getComponentInstancesAttributes() != null
3712 && sourceComponent.getComponentInstancesAttributes().get(sourceComponentInstanceId) != null) {
3713 sourceAttributeList = sourceComponent.getComponentInstancesAttributes().get(sourceComponentInstanceId);
3714 log.info("sourceAttributes {}");
3716 List<ComponentInstanceAttribute> destAttributeList = null;
3717 if (destComponent.getComponentInstancesAttributes() != null
3718 && destComponent.getComponentInstancesAttributes().get(destComponentInstanceId) != null) {
3719 destAttributeList = destComponent.getComponentInstancesAttributes().get(destComponentInstanceId);
3720 log.info("destAttributeList {}");
3722 if (null != sourceAttributeList && null != destAttributeList) {
3723 log.info("set attribute");
3724 for (ComponentInstanceAttribute sourceAttribute : sourceAttributeList) {
3725 String sourceAttributeName = sourceAttribute.getName();
3726 for (ComponentInstanceAttribute destAttribute : destAttributeList) {
3727 if (sourceAttributeName.equals(destAttribute.getName())) {
3728 log.debug("Start to copy the attribute exists {}", sourceAttributeName);
3729 sourceAttribute.setUniqueId(
3730 UniqueIdBuilder.buildResourceInstanceUniuqeId("attribute", destComponentInstanceId.split("\\.")[1], sourceAttributeName));
3731 Either<ComponentInstanceAttribute, ResponseFormat> updateAttributeValueEither = createOrUpdateAttributeValueForCopyPaste(
3732 ComponentTypeEnum.SERVICE, destComponent.getUniqueId(), destComponentInstanceId, sourceAttribute, userId);
3733 if (updateAttributeValueEither.isRight()) {
3734 log.error("Failed to copy the attribute");
3735 return Either.right(componentsUtils.getResponseFormat(ActionStatus.INVALID_CONTENT_PARAM,
3736 "Failed to paste component instance to the canvas, attribute copy"));
3743 return Either.left(COPY_COMPONENT_INSTANCE_OK);
3746 private Either<ComponentInstanceAttribute, ResponseFormat> createOrUpdateAttributeValueForCopyPaste(ComponentTypeEnum componentTypeEnum,
3747 String componentId, String resourceInstanceId,
3748 ComponentInstanceAttribute attribute,
3750 Either<ComponentInstanceAttribute, ResponseFormat> resultOp = null;
3751 validateUserExists(userId);
3752 if (componentTypeEnum == null) {
3753 BeEcompErrorManager.getInstance()
3754 .logInvalidInputError("createOrUpdateAttributeValueForCopyPaste", INVALID_COMPONENT_TYPE, ErrorSeverity.INFO);
3755 resultOp = Either.right(componentsUtils.getResponseFormat(ActionStatus.NOT_ALLOWED));
3758 Either<Component, StorageOperationStatus> getResourceResult = toscaOperationFacade.getToscaElement(componentId, JsonParseFlagEnum.ParseAll);
3759 if (getResourceResult.isRight()) {
3760 log.info("Failed to retrieve component id {}", componentId);
3761 resultOp = Either.right(componentsUtils.getResponseFormat(ActionStatus.RESTRICTED_OPERATION));
3764 Component containerComponent = getResourceResult.left().value();
3765 Either<ComponentInstance, StorageOperationStatus> resourceInstanceStatus = getResourceInstanceById(containerComponent, resourceInstanceId);
3766 if (resourceInstanceStatus.isRight()) {
3768 .right(componentsUtils.getResponseFormat(ActionStatus.RESOURCE_INSTANCE_NOT_FOUND_ON_SERVICE, resourceInstanceId, componentId));
3771 ComponentInstance foundResourceInstance = resourceInstanceStatus.left().value();
3772 String propertyType = attribute.getType();
3773 ToscaPropertyType type = ToscaPropertyType.isValidType(propertyType);
3774 log.info("The type of attribute id{},is {} ", attribute.getUniqueId(), propertyType);
3775 if (type == ToscaPropertyType.LIST || type == ToscaPropertyType.MAP) {
3776 SchemaDefinition def = attribute.getSchema();
3778 log.info("Schema doesn't exists for attribute of type {}", type);
3780 .right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(StorageOperationStatus.INVALID_VALUE)));
3782 PropertyDataDefinition propDef = def.getProperty();
3783 if (propDef == null) {
3784 log.info("Attribute in Schema Definition inside attribute of type {} doesn't exist", type);
3786 .right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(StorageOperationStatus.INVALID_VALUE)));
3789 List<ComponentInstanceAttribute> instanceAttributes = containerComponent.getComponentInstancesAttributes().get(resourceInstanceId);
3790 Optional<ComponentInstanceAttribute> instanceAttribute = instanceAttributes.stream()
3791 .filter(p -> p.getUniqueId().equals(attribute.getUniqueId())).findAny();
3792 StorageOperationStatus status;
3793 if (instanceAttribute.isPresent()) {
3794 log.info("updateComponentInstanceAttribute");
3795 status = toscaOperationFacade.updateComponentInstanceAttribute(containerComponent, foundResourceInstance.getUniqueId(), attribute);
3797 log.info("addComponentInstanceAttribute");
3798 status = toscaOperationFacade.addComponentInstanceAttribute(containerComponent, foundResourceInstance.getUniqueId(), attribute);
3800 if (status != StorageOperationStatus.OK) {
3801 ActionStatus actionStatus = componentsUtils.convertFromStorageResponseForResourceInstanceProperty(status);
3802 resultOp = Either.right(componentsUtils.getResponseFormatForResourceInstanceProperty(actionStatus, ""));
3805 List<String> path = new ArrayList<>();
3806 path.add(foundResourceInstance.getUniqueId());
3807 attribute.setPath(path);
3808 foundResourceInstance.setCustomizationUUID(UUID.randomUUID().toString());
3809 Either<Component, StorageOperationStatus> updateContainerRes = toscaOperationFacade
3810 .updateComponentInstanceMetadataOfTopologyTemplate(containerComponent);
3811 if (updateContainerRes.isRight()) {
3812 ActionStatus actionStatus = componentsUtils.convertFromStorageResponseForResourceInstanceProperty(updateContainerRes.right().value());
3813 resultOp = Either.right(componentsUtils.getResponseFormatForResourceInstanceProperty(actionStatus, ""));
3816 resultOp = Either.left(attribute);
3820 private Either<String, ResponseFormat> updateComponentInstanceProperty(String containerComponentId, String componentInstanceId,
3821 ComponentInstanceProperty property) {
3822 Either<String, ResponseFormat> resultOp;
3823 Either<Component, StorageOperationStatus> getComponent = toscaOperationFacade.getToscaElement(containerComponentId);
3824 if (getComponent.isRight()) {
3825 log.error("Failed to get the component information");
3826 return Either.right(componentsUtils
3827 .getResponseFormatForResourceInstanceProperty(ActionStatus.INVALID_CONTENT_PARAM, "Failed to get the component information"));
3829 Component containerComponent = getComponent.left().value();
3830 StorageOperationStatus status = toscaOperationFacade.updateComponentInstanceProperty(containerComponent, componentInstanceId, property);
3831 if (status != StorageOperationStatus.OK) {
3832 ActionStatus actionStatus = componentsUtils.convertFromStorageResponseForResourceInstanceProperty(status);
3833 resultOp = Either.right(componentsUtils.getResponseFormatForResourceInstanceProperty(actionStatus, ""));
3836 Either<Component, StorageOperationStatus> updateContainerRes = toscaOperationFacade
3837 .updateComponentInstanceMetadataOfTopologyTemplate(containerComponent);
3838 if (updateContainerRes.isRight()) {
3839 ActionStatus actionStatus = componentsUtils.convertFromStorageResponseForResourceInstanceProperty(updateContainerRes.right().value());
3840 resultOp = Either.right(componentsUtils.getResponseFormatForResourceInstanceProperty(actionStatus, ""));
3843 return Either.left("Update OK");
3846 private Either<String, ResponseFormat> getInputListDefaultValue(Component component, String inputId) {
3847 List<InputDefinition> inputList = component.getInputs();
3848 for (InputDefinition input : inputList) {
3849 if (input.getUniqueId().equals(inputId)) {
3850 if (input.getDefaultValue() == null) {
3851 log.debug("The input's default value is null");
3852 return Either.left(null);
3854 return Either.left(input.getDefaultValue());
3857 log.error("The input's default value with id {} is not found", inputId);
3858 return Either.right(componentsUtils.getResponseFormat(ActionStatus.USER_DEFINED, "Failed to paste component instance to the canvas"));
3862 * Method to delete selected nodes and edges on composition page
3864 * @param containerComponentType
3865 * @param componentId
3866 * @param componentInstanceIdList
3870 public Map<String, List<String>> batchDeleteComponentInstance(String containerComponentType, String componentId,
3871 List<String> componentInstanceIdList, String userId) {
3872 List<String> deleteErrorIds = new ArrayList<>();
3873 Map<String, List<String>> deleteErrorMap = new HashMap<>();
3874 validateUserExists(userId);
3875 org.openecomp.sdc.be.model.Component containerComponent = validateComponentExists(componentId,
3876 ComponentTypeEnum.findByParamName(containerComponentType), null);
3877 boolean failed = false;
3879 lockComponent(containerComponent, "batchDeleteComponentInstance");
3880 for (String eachInstanceId : componentInstanceIdList) {
3881 Either<ComponentInstance, ResponseFormat> actionResponse = batchDeleteComponentInstance(containerComponent, containerComponentType,
3883 log.debug("batchDeleteResourceInstances actionResponse is {}", actionResponse);
3884 if (actionResponse.isRight()) {
3885 log.error("Failed to delete ComponentInstance [{}]", eachInstanceId);
3886 deleteErrorIds.add(eachInstanceId);
3889 //sending the ids of the error nodes that were not deleted to UI
3890 deleteErrorMap.put("deleteFailedIds", deleteErrorIds);
3891 return deleteErrorMap;
3892 } catch (ComponentException e) {
3896 unlockComponent(failed, containerComponent);
3900 private Either<ComponentInstance, ResponseFormat> batchDeleteComponentInstance(Component containerComponent, String containerComponentType,
3901 String componentInstanceId) {
3902 ComponentInstance resultOp;
3903 final ComponentTypeEnum containerComponentTypeEnum = ComponentTypeEnum.findByParamName(containerComponentType);
3905 resultOp = deleteComponentInstance(containerComponent, componentInstanceId, containerComponentTypeEnum);
3906 log.info("Successfully deleted instance with id {}", componentInstanceId);
3907 return Either.left(resultOp);
3908 } catch (ComponentException e) {
3909 log.error("Failed to deleteComponentInstance with instanceId[{}]", componentInstanceId);
3910 return Either.right(new ResponseFormat());
3914 public void validateUser(final String userId) {
3915 final User user = userValidations.validateUserExists(userId);
3916 userValidations.validateUserRole(user, Arrays.asList(Role.DESIGNER, Role.ADMIN));
3919 public void setCompositionBusinessLogic(CompositionBusinessLogic compositionBusinessLogic) {
3920 this.compositionBusinessLogic = compositionBusinessLogic;
3923 public void setContainerInstanceTypesData(ContainerInstanceTypesData containerInstanceTypesData) {
3924 this.containerInstanceTypesData = containerInstanceTypesData;