2 * ============LICENSE_START=======================================================
4 * ================================================================================
5 * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
6 * ================================================================================
7 * Licensed under the Apache License, Version 2.0 (the "License");
8 * you may not use this file except in compliance with the License.
9 * You may obtain a copy of the License at
11 * http://www.apache.org/licenses/LICENSE-2.0
13 * Unless required by applicable law or agreed to in writing, software
14 * distributed under the License is distributed on an "AS IS" BASIS,
15 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 * See the License for the specific language governing permissions and
17 * limitations under the License.
18 * ============LICENSE_END=========================================================
20 package org.openecomp.sdc.be.components.impl;
22 import static org.openecomp.sdc.be.components.attribute.GetOutputUtils.isGetOutputValueForOutput;
23 import static org.openecomp.sdc.be.components.property.GetInputUtils.isGetInputValueForInput;
24 import static org.openecomp.sdc.be.components.utils.PropertiesUtils.getPropertyCapabilityOfChildInstance;
26 import com.google.common.collect.Sets;
27 import fj.data.Either;
28 import java.util.ArrayList;
29 import java.util.Arrays;
30 import java.util.Collection;
31 import java.util.Collections;
32 import java.util.HashMap;
33 import java.util.Iterator;
34 import java.util.List;
36 import java.util.Map.Entry;
37 import java.util.Objects;
38 import java.util.Optional;
40 import java.util.UUID;
41 import java.util.stream.Collectors;
42 import org.apache.commons.collections.CollectionUtils;
43 import org.apache.commons.collections.MapUtils;
44 import org.apache.commons.lang3.StringUtils;
45 import org.apache.commons.lang3.tuple.ImmutablePair;
46 import org.onap.sdc.tosca.datatypes.model.PropertyType;
47 import org.openecomp.sdc.be.components.impl.exceptions.BusinessLogicException;
48 import org.openecomp.sdc.be.components.impl.exceptions.ByActionStatusComponentException;
49 import org.openecomp.sdc.be.components.impl.exceptions.ByResponseFormatComponentException;
50 import org.openecomp.sdc.be.components.impl.exceptions.ComponentException;
51 import org.openecomp.sdc.be.components.impl.exceptions.ToscaGetFunctionExceptionSupplier;
52 import org.openecomp.sdc.be.components.impl.instance.ComponentInstanceChangeOperationOrchestrator;
53 import org.openecomp.sdc.be.components.impl.utils.DirectivesUtil;
54 import org.openecomp.sdc.be.components.merge.instance.ComponentInstanceMergeDataBusinessLogic;
55 import org.openecomp.sdc.be.components.merge.instance.DataForMergeHolder;
56 import org.openecomp.sdc.be.components.utils.PropertiesUtils;
57 import org.openecomp.sdc.be.components.validation.ComponentValidations;
58 import org.openecomp.sdc.be.config.BeEcompErrorManager;
59 import org.openecomp.sdc.be.config.BeEcompErrorManager.ErrorSeverity;
60 import org.openecomp.sdc.be.config.ConfigurationManager;
61 import org.openecomp.sdc.be.dao.api.ActionStatus;
62 import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus;
63 import org.openecomp.sdc.be.dao.jsongraph.types.JsonParseFlagEnum;
64 import org.openecomp.sdc.be.dao.neo4j.GraphPropertiesDictionary;
65 import org.openecomp.sdc.be.datatypes.elements.CINodeFilterDataDefinition;
66 import org.openecomp.sdc.be.datatypes.elements.CapabilityDataDefinition;
67 import org.openecomp.sdc.be.datatypes.elements.ForwardingPathDataDefinition;
68 import org.openecomp.sdc.be.datatypes.elements.GetInputValueDataDefinition;
69 import org.openecomp.sdc.be.datatypes.elements.GetOutputValueDataDefinition;
70 import org.openecomp.sdc.be.datatypes.elements.GetPolicyValueDataDefinition;
71 import org.openecomp.sdc.be.datatypes.elements.PropertyDataDefinition;
72 import org.openecomp.sdc.be.datatypes.elements.RequirementDataDefinition;
73 import org.openecomp.sdc.be.datatypes.elements.SchemaDefinition;
74 import org.openecomp.sdc.be.datatypes.elements.ToscaGetFunctionDataDefinition;
75 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
76 import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
77 import org.openecomp.sdc.be.datatypes.enums.OriginTypeEnum;
78 import org.openecomp.sdc.be.datatypes.enums.PropertySource;
79 import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum;
80 import org.openecomp.sdc.be.datatypes.tosca.ToscaGetFunctionType;
81 import org.openecomp.sdc.be.exception.BusinessException;
82 import org.openecomp.sdc.be.impl.ComponentsUtils;
83 import org.openecomp.sdc.be.impl.ForwardingPathUtils;
84 import org.openecomp.sdc.be.impl.ServiceFilterUtils;
85 import org.openecomp.sdc.be.info.CreateAndAssotiateInfo;
86 import org.openecomp.sdc.be.model.ArtifactDefinition;
87 import org.openecomp.sdc.be.model.AttributeDefinition;
88 import org.openecomp.sdc.be.model.CapabilityDefinition;
89 import org.openecomp.sdc.be.model.Component;
90 import org.openecomp.sdc.be.model.ComponentInstance;
91 import org.openecomp.sdc.be.model.ComponentInstanceAttribute;
92 import org.openecomp.sdc.be.model.ComponentInstanceInput;
93 import org.openecomp.sdc.be.model.ComponentInstanceOutput;
94 import org.openecomp.sdc.be.model.ComponentInstancePropInput;
95 import org.openecomp.sdc.be.model.ComponentInstanceProperty;
96 import org.openecomp.sdc.be.model.ComponentParametersView;
97 import org.openecomp.sdc.be.model.DataTypeDefinition;
98 import org.openecomp.sdc.be.model.GroupDefinition;
99 import org.openecomp.sdc.be.model.InputDefinition;
100 import org.openecomp.sdc.be.model.InterfaceDefinition;
101 import org.openecomp.sdc.be.model.LifecycleStateEnum;
102 import org.openecomp.sdc.be.model.OutputDefinition;
103 import org.openecomp.sdc.be.model.PolicyDefinition;
104 import org.openecomp.sdc.be.model.PropertyDefinition;
105 import org.openecomp.sdc.be.model.RelationshipInfo;
106 import org.openecomp.sdc.be.model.RequirementCapabilityRelDef;
107 import org.openecomp.sdc.be.model.RequirementDefinition;
108 import org.openecomp.sdc.be.model.Resource;
109 import org.openecomp.sdc.be.model.Service;
110 import org.openecomp.sdc.be.model.ToscaPropertyData;
111 import org.openecomp.sdc.be.model.User;
112 import org.openecomp.sdc.be.model.jsonjanusgraph.config.ContainerInstanceTypesData;
113 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.ArtifactsOperations;
114 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.ForwardingPathOperation;
115 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.InterfaceOperation;
116 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.NodeFilterOperation;
117 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.NodeTemplateOperation;
118 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.ToscaOperationFacade;
119 import org.openecomp.sdc.be.model.jsonjanusgraph.utils.ModelConverter;
120 import org.openecomp.sdc.be.model.operations.StorageException;
121 import org.openecomp.sdc.be.model.operations.api.IElementOperation;
122 import org.openecomp.sdc.be.model.operations.api.IGroupInstanceOperation;
123 import org.openecomp.sdc.be.model.operations.api.IGroupOperation;
124 import org.openecomp.sdc.be.model.operations.api.IGroupTypeOperation;
125 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
126 import org.openecomp.sdc.be.model.operations.impl.ComponentInstanceOperation;
127 import org.openecomp.sdc.be.model.operations.impl.DaoStatusConverter;
128 import org.openecomp.sdc.be.model.operations.impl.InterfaceLifecycleOperation;
129 import org.openecomp.sdc.be.model.operations.impl.UniqueIdBuilder;
130 import org.openecomp.sdc.be.model.operations.utils.ComponentValidationUtils;
131 import org.openecomp.sdc.be.model.tosca.ToscaPropertyType;
132 import org.openecomp.sdc.be.resources.data.ComponentInstanceData;
133 import org.openecomp.sdc.be.user.Role;
134 import org.openecomp.sdc.common.api.ArtifactGroupTypeEnum;
135 import org.openecomp.sdc.common.api.ArtifactTypeEnum;
136 import org.openecomp.sdc.common.api.Constants;
137 import org.openecomp.sdc.common.datastructure.Wrapper;
138 import org.openecomp.sdc.common.jsongraph.util.CommonUtility;
139 import org.openecomp.sdc.common.jsongraph.util.CommonUtility.LogLevelEnum;
140 import org.openecomp.sdc.common.log.elements.ErrorLogOptionalData;
141 import org.openecomp.sdc.common.log.enums.EcompLoggerErrorCode;
142 import org.openecomp.sdc.common.log.wrappers.Logger;
143 import org.openecomp.sdc.common.util.ValidationUtils;
144 import org.openecomp.sdc.exception.ResponseFormat;
145 import org.springframework.beans.factory.annotation.Autowired;
147 @org.springframework.stereotype.Component
148 public class ComponentInstanceBusinessLogic extends BaseBusinessLogic {
150 private static final Logger log = Logger.getLogger(ComponentInstanceBusinessLogic.class);
151 private static final String VF_MODULE = "org.openecomp.groups.VfModule";
152 private static final String TRY_TO_CREATE_ENTRY_ON_GRAPH = "Try to create entry on graph";
153 private static final String CLOUD_SPECIFIC_FIXED_KEY_WORD = "cloudtech";
154 private static final String[][] CLOUD_SPECIFIC_KEY_WORDS = {{"k8s", "azure", "aws"}, /* cloud specific technology */
155 {"charts", "day0", "configtemplate"} /*cloud specific sub type*/};
156 private static final String FAILED_TO_CREATE_ENTRY_ON_GRAPH_FOR_COMPONENT_INSTANCE = "Failed to create entry on graph for component instance {}";
157 private static final String ENTITY_ON_GRAPH_IS_CREATED = "Entity on graph is created.";
158 private static final String INVALID_COMPONENT_TYPE = "invalid component type";
159 private static final String FAILED_TO_RETRIEVE_COMPONENT_COMPONENT_ID = "Failed to retrieve component, component id {}";
160 private static final String FAILED_TO_LOCK_SERVICE = "Failed to lock service {}";
161 private static final String CREATE_OR_UPDATE_PROPERTY_VALUE = "CreateOrUpdatePropertyValue";
162 private static final String FAILED_TO_COPY_COMP_INSTANCE_TO_CANVAS = "Failed to copy the component instance to the canvas";
163 private static final String COPY_COMPONENT_INSTANCE_OK = "Copy component instance OK";
164 private static final String CANNOT_ATTACH_RESOURCE_INSTANCES_TO_CONTAINER_RESOURCE_OF_TYPE = "Cannot attach resource instances to container resource of type {}";
165 private static final String FAILED_TO_UPDATE_COMPONENT_INSTANCE_CAPABILITY = "Failed to update component instance capability on instance {} in "
167 private static final String SERVICE_PROXY = "serviceProxy";
168 private static final String ASSOCIATE_RI_TO_RI = "associateRIToRI";
169 private static final String COMPONENT_ARCHIVED = "Component is archived. Component id: {}";
170 private static final String RESTRICTED_OPERATION_ON_SERVIVE = "Restricted operation for user: {} on service {}";
171 private static final String FAILED_TO_LOCK_COMPONENT = "Failed to lock component {}";
172 private static final String RESTRICTED_OPERATION_ON_COMPONENT = "Restricted operation for user: {} on component {}";
173 private static final String RESOURCE_INSTANCE = "resource instance";
174 private static final String SERVICE = "service";
176 private final ComponentInstanceOperation componentInstanceOperation;
177 private final ArtifactsBusinessLogic artifactBusinessLogic;
178 private final ComponentInstanceMergeDataBusinessLogic compInstMergeDataBL;
179 private final ComponentInstanceChangeOperationOrchestrator onChangeInstanceOperationOrchestrator;
180 private final ForwardingPathOperation forwardingPathOperation;
181 private final NodeFilterOperation nodeFilterOperation;
183 private CompositionBusinessLogic compositionBusinessLogic;
185 private ContainerInstanceTypesData containerInstanceTypesData;
188 public ComponentInstanceBusinessLogic(IElementOperation elementDao, IGroupOperation groupOperation,
189 IGroupInstanceOperation groupInstanceOperation, IGroupTypeOperation groupTypeOperation,
190 InterfaceOperation interfaceOperation, InterfaceLifecycleOperation interfaceLifecycleTypeOperation,
191 ComponentInstanceOperation componentInstanceOperation, ArtifactsBusinessLogic artifactBusinessLogic,
192 ComponentInstanceMergeDataBusinessLogic compInstMergeDataBL,
193 ComponentInstanceChangeOperationOrchestrator onChangeInstanceOperationOrchestrator,
194 ForwardingPathOperation forwardingPathOperation, NodeFilterOperation nodeFilterOperation,
195 ArtifactsOperations artifactToscaOperation) {
196 super(elementDao, groupOperation, groupInstanceOperation, groupTypeOperation, interfaceOperation, interfaceLifecycleTypeOperation,
197 artifactToscaOperation);
198 this.componentInstanceOperation = componentInstanceOperation;
199 this.artifactBusinessLogic = artifactBusinessLogic;
200 this.compInstMergeDataBL = compInstMergeDataBL;
201 this.onChangeInstanceOperationOrchestrator = onChangeInstanceOperationOrchestrator;
202 this.forwardingPathOperation = forwardingPathOperation;
203 this.nodeFilterOperation = nodeFilterOperation;
206 public ComponentInstance createComponentInstance(String containerComponentParam, String containerComponentId, String userId,
207 ComponentInstance resourceInstance) {
208 return createComponentInstance(containerComponentParam, containerComponentId, userId, resourceInstance, true);
211 public List<ComponentInstanceProperty> getComponentInstancePropertiesByInputId(org.openecomp.sdc.be.model.Component component, String inputId) {
212 List<ComponentInstanceProperty> resList = new ArrayList<>();
213 Map<String, List<ComponentInstanceProperty>> ciPropertiesMap = component.getComponentInstancesProperties();
214 if (ciPropertiesMap != null && !ciPropertiesMap.isEmpty()) {
215 ciPropertiesMap.forEach((s, ciPropList) -> {
217 Optional<ComponentInstance> ciOp = component.getComponentInstances().stream().filter(ci -> ci.getUniqueId().equals(s)).findAny();
218 if (ciOp.isPresent()) {
219 ciName = ciOp.get().getName();
221 if (ciPropList != null && !ciPropList.isEmpty()) {
222 for (ComponentInstanceProperty prop : ciPropList) {
223 List<GetInputValueDataDefinition> inputsValues = prop.getGetInputValues();
224 addCompInstanceProperty(s, ciName, prop, inputsValues, inputId, resList);
232 public List<ComponentInstanceAttribute> getComponentInstanceAttributesByOutputId(final org.openecomp.sdc.be.model.Component component,
233 final String outputId) {
234 final List<ComponentInstanceAttribute> resList = new ArrayList<>();
235 final Map<String, List<ComponentInstanceAttribute>> componentInstancesAttributes = component.getComponentInstancesAttributes();
236 if (org.apache.commons.collections4.MapUtils.isNotEmpty(componentInstancesAttributes)) {
237 componentInstancesAttributes.forEach((s, componentInstanceAttributeList) -> {
239 final Optional<ComponentInstance> ciOp = component.getComponentInstances().stream().filter(ci -> ci.getUniqueId().equals(s))
241 if (ciOp.isPresent()) {
242 ciName = ciOp.get().getName();
244 if (componentInstanceAttributeList != null && !componentInstanceAttributeList.isEmpty()) {
245 for (final ComponentInstanceAttribute compInstanceAttribute : componentInstanceAttributeList) {
246 List<GetOutputValueDataDefinition> outputValues = compInstanceAttribute.getGetOutputValues();
247 addCompInstanceAttribute(s, ciName, compInstanceAttribute, outputValues, outputId, resList);
255 private void addCompInstanceProperty(String s, String ciName, ComponentInstanceProperty prop, List<GetInputValueDataDefinition> inputsValues,
256 String inputId, List<ComponentInstanceProperty> resList) {
257 if (inputsValues != null && !inputsValues.isEmpty()) {
258 for (GetInputValueDataDefinition inputData : inputsValues) {
259 if (isGetInputValueForInput(inputData, inputId)) {
260 prop.setComponentInstanceId(s);
261 prop.setComponentInstanceName(ciName);
269 private void addCompInstanceAttribute(final String s, final String ciName, final ComponentInstanceAttribute attribute,
270 final List<GetOutputValueDataDefinition> outputsValues, final String outputId,
271 final List<ComponentInstanceAttribute> resList) {
272 if (outputsValues != null && !outputsValues.isEmpty()) {
273 for (final GetOutputValueDataDefinition outputData : outputsValues) {
274 if (isGetOutputValueForOutput(outputData, outputId)) {
275 attribute.setComponentInstanceId(s);
276 attribute.setComponentInstanceName(ciName);
277 resList.add(attribute);
284 public Optional<ComponentInstanceProperty> getComponentInstancePropertyByPolicyId(Component component, PolicyDefinition policy) {
285 Optional<ComponentInstanceProperty> propertyCandidate = getComponentInstancePropertyByPolicy(component, policy);
286 if (propertyCandidate.isPresent()) {
287 ComponentInstanceProperty componentInstanceProperty = propertyCandidate.get();
288 Optional<GetPolicyValueDataDefinition> getPolicyCandidate = getGetPolicyValueDataDefinition(policy, componentInstanceProperty);
290 .ifPresent(getPolicyValue -> updateComponentInstancePropertyAfterUndeclaration(componentInstanceProperty, getPolicyValue, policy));
291 return Optional.of(componentInstanceProperty);
293 return Optional.empty();
296 private void updateComponentInstancePropertyAfterUndeclaration(ComponentInstanceProperty componentInstanceProperty,
297 GetPolicyValueDataDefinition getPolicyValue, PolicyDefinition policyDefinition) {
298 componentInstanceProperty.setValue(getPolicyValue.getOrigPropertyValue());
299 List<GetPolicyValueDataDefinition> getPolicyValues = componentInstanceProperty.getGetPolicyValues();
300 if (CollectionUtils.isNotEmpty(getPolicyValues)) {
301 getPolicyValues.remove(getPolicyValue);
302 componentInstanceProperty.setGetPolicyValues(getPolicyValues);
303 policyDefinition.setGetPolicyValues(getPolicyValues);
307 private Optional<GetPolicyValueDataDefinition> getGetPolicyValueDataDefinition(PolicyDefinition policy,
308 ComponentInstanceProperty componentInstanceProperty) {
309 List<GetPolicyValueDataDefinition> getPolicyValues = policy.getGetPolicyValues();
310 return getPolicyValues.stream().filter(getPolicyValue -> getPolicyValue.getPropertyName().equals(componentInstanceProperty.getName()))
314 private Optional<ComponentInstanceProperty> getComponentInstancePropertyByPolicy(Component component, PolicyDefinition policy) {
315 Map<String, List<ComponentInstanceProperty>> componentInstancesProperties = component.getComponentInstancesProperties();
316 if (MapUtils.isEmpty(componentInstancesProperties)) {
317 return Optional.empty();
319 String instanceUniqueId = policy.getInstanceUniqueId();
320 List<ComponentInstanceProperty> componentInstanceProperties =
321 componentInstancesProperties.containsKey(instanceUniqueId) ? componentInstancesProperties.get(instanceUniqueId) : new ArrayList<>();
322 return componentInstanceProperties.stream().filter(property -> property.getName().equals(policy.getName())).findAny();
325 public List<ComponentInstanceInput> getComponentInstanceInputsByInputId(org.openecomp.sdc.be.model.Component component, String inputId) {
326 List<ComponentInstanceInput> resList = new ArrayList<>();
327 Map<String, List<ComponentInstanceInput>> ciInputsMap = component.getComponentInstancesInputs();
328 if (ciInputsMap != null && !ciInputsMap.isEmpty()) {
329 ciInputsMap.forEach((s, ciPropList) -> {
331 Optional<ComponentInstance> ciOp = component.getComponentInstances().stream().filter(ci -> ci.getUniqueId().equals(s)).findAny();
332 if (ciOp.isPresent()) {
333 ciName = ciOp.get().getName();
335 if (ciPropList != null && !ciPropList.isEmpty()) {
336 for (ComponentInstanceInput prop : ciPropList) {
337 List<GetInputValueDataDefinition> inputsValues = prop.getGetInputValues();
338 addCompInstanceInput(s, ciName, prop, inputsValues, inputId, resList);
346 public List<ComponentInstanceOutput> getComponentInstanceOutputsByOutputId(final org.openecomp.sdc.be.model.Component component,
347 final String outputId) {
348 final List<ComponentInstanceOutput> resList = new ArrayList<>();
349 final Map<String, List<ComponentInstanceOutput>> ciInputsMap = component.getComponentInstancesOutputs();
350 if (ciInputsMap != null && !ciInputsMap.isEmpty()) {
351 ciInputsMap.forEach((s, ciPropList) -> {
353 final Optional<ComponentInstance> ciOp = component.getComponentInstances().stream().filter(ci -> ci.getUniqueId().equals(s))
355 if (ciOp.isPresent()) {
356 ciName = ciOp.get().getName();
358 if (ciPropList != null && !ciPropList.isEmpty()) {
359 for (final ComponentInstanceOutput prop : ciPropList) {
360 final List<GetOutputValueDataDefinition> outputValues = prop.getGetOutputValues();
361 addCompInstanceOutput(s, ciName, prop, outputValues, outputId, resList);
369 private void addCompInstanceInput(String s, String ciName, ComponentInstanceInput prop, List<GetInputValueDataDefinition> inputsValues,
370 String inputId, List<ComponentInstanceInput> resList) {
371 if (inputsValues != null && !inputsValues.isEmpty()) {
372 for (GetInputValueDataDefinition inputData : inputsValues) {
373 if (isGetInputValueForInput(inputData, inputId)) {
374 prop.setComponentInstanceId(s);
375 prop.setComponentInstanceName(ciName);
383 private void addCompInstanceOutput(final String s, final String ciName, final ComponentInstanceOutput prop,
384 final List<GetOutputValueDataDefinition> outputsValues, final String outputId,
385 final List<ComponentInstanceOutput> resList) {
386 if (outputsValues != null && !outputsValues.isEmpty()) {
387 for (final GetOutputValueDataDefinition outputData : outputsValues) {
388 if (isGetOutputValueForOutput(outputData, outputId)) {
389 prop.setComponentInstanceId(s);
390 prop.setComponentInstanceName(ciName);
398 public ComponentInstance createComponentInstance(final String containerComponentParam, final String containerComponentId, final String userId,
399 final ComponentInstance resourceInstance, final boolean needLock) {
400 final User user = validateUserExists(userId);
401 validateUserNotEmpty(user, "Create component instance");
402 validateJsonBody(resourceInstance, ComponentInstance.class);
403 final ComponentTypeEnum containerComponentType = validateComponentType(containerComponentParam);
404 final org.openecomp.sdc.be.model.Component containerComponent = validateComponentExists(containerComponentId, containerComponentType, null);
405 if (ModelConverter.isAtomicComponent(containerComponent)) {
406 if (log.isDebugEnabled()) {
407 log.debug(CANNOT_ATTACH_RESOURCE_INSTANCES_TO_CONTAINER_RESOURCE_OF_TYPE, containerComponent.assetType());
409 throw new ByActionStatusComponentException(ActionStatus.RESOURCE_CANNOT_CONTAIN_RESOURCE_INSTANCES, containerComponent.assetType());
411 validateCanWorkOnComponent(containerComponent, userId);
412 Component origComponent = null;
413 if (resourceInstance != null && containerComponentType != null) {
414 final OriginTypeEnum originType = resourceInstance.getOriginType();
415 validateInstanceName(resourceInstance);
416 if (originType == OriginTypeEnum.ServiceProxy) {
417 origComponent = getOrigComponentForServiceProxy(containerComponent, resourceInstance);
418 } else if (originType == OriginTypeEnum.ServiceSubstitution) {
419 origComponent = getOrigComponentForServiceSubstitution(resourceInstance);
421 origComponent = getAndValidateOriginComponentOfComponentInstance(containerComponent, resourceInstance);
422 validateOriginAndResourceInstanceTypes(containerComponent, origComponent, originType);
424 validateResourceInstanceState(containerComponent, origComponent);
425 overrideFields(origComponent, resourceInstance);
426 compositionBusinessLogic.validateAndSetDefaultCoordinates(resourceInstance);
428 return createComponent(needLock, containerComponent, origComponent, resourceInstance, user);
431 private Component getOrigComponentForServiceProxy(org.openecomp.sdc.be.model.Component containerComponent, ComponentInstance resourceInstance) {
432 Either<Component, StorageOperationStatus> serviceProxyOrigin = toscaOperationFacade.getLatestByName(SERVICE_PROXY, null);
433 if (isServiceProxyOrigin(serviceProxyOrigin)) {
434 throw new ByActionStatusComponentException(componentsUtils.convertFromStorageResponse(serviceProxyOrigin.right().value()));
436 Component origComponent = serviceProxyOrigin.left().value();
437 StorageOperationStatus fillProxyRes = fillInstanceData(resourceInstance, origComponent);
438 if (isFillProxyRes(fillProxyRes)) {
439 throw new ByActionStatusComponentException(componentsUtils.convertFromStorageResponse(fillProxyRes));
441 validateOriginAndResourceInstanceTypes(containerComponent, origComponent, OriginTypeEnum.ServiceProxy);
442 return origComponent;
445 private Component getOrigComponentForServiceSubstitution(ComponentInstance resourceInstance) {
446 final Either<Component, StorageOperationStatus> getServiceResult = toscaOperationFacade
447 .getToscaFullElement(resourceInstance.getComponentUid());
448 if (getServiceResult.isRight()) {
449 throw new ByActionStatusComponentException(componentsUtils.convertFromStorageResponse(getServiceResult.right().value()));
451 final Component service = getServiceResult.left().value();
452 final Either<Component, StorageOperationStatus> getServiceDerivedFromTypeResult = toscaOperationFacade
453 .getLatestByToscaResourceName(service.getDerivedFromGenericType(), service.getModel());
454 if (getServiceDerivedFromTypeResult.isRight()) {
455 throw new ByActionStatusComponentException(componentsUtils.convertFromStorageResponse(getServiceResult.right().value()));
457 Component origComponent = getServiceDerivedFromTypeResult.left().value();
458 final StorageOperationStatus fillProxyRes = fillInstanceData(resourceInstance, origComponent);
459 if (isFillProxyRes(fillProxyRes)) {
460 throw new ByActionStatusComponentException(componentsUtils.convertFromStorageResponse(fillProxyRes));
462 return origComponent;
465 private ComponentInstance createComponent(boolean needLock, Component containerComponent, Component origComponent,
466 ComponentInstance resourceInstance, User user) {
467 boolean failed = false;
469 lockIfNeed(needLock, containerComponent);
470 log.debug(TRY_TO_CREATE_ENTRY_ON_GRAPH);
471 return createComponentInstanceOnGraph(containerComponent, origComponent, resourceInstance, user);
472 } catch (ComponentException e) {
477 unlockComponent(failed, containerComponent);
483 * Try using either to make a judgment
485 * @param containerComponentParam
486 * @param containerComponentId
488 * @param resourceInstance
491 public Either<ComponentInstance, ResponseFormat> createRealComponentInstance(String containerComponentParam, String containerComponentId,
492 String userId, ComponentInstance resourceInstance) {
493 log.debug("enter createRealComponentInstance");
494 return createRealComponentInstance(containerComponentParam, containerComponentId, userId, resourceInstance, true);
498 * Try using either to make a judgment
501 * @param containerComponentParam
502 * @param containerComponentId
504 * @param resourceInstance
507 public Either<ComponentInstance, ResponseFormat> createRealComponentInstance(String containerComponentParam, String containerComponentId,
508 String userId, ComponentInstance resourceInstance,
510 log.debug("enter createRealComponentInstance");
511 Component origComponent = null;
513 org.openecomp.sdc.be.model.Component containerComponent = null;
514 ComponentTypeEnum containerComponentType;
516 user = validateUserExists(userId);
517 validateUserNotEmpty(user, "Create component instance");
518 validateJsonBody(resourceInstance, ComponentInstance.class);
519 containerComponentType = validateComponentType(containerComponentParam);
520 containerComponent = validateComponentExists(containerComponentId, containerComponentType, null);
521 log.debug("enter createRealComponentInstance,validate user json success");
522 if (ModelConverter.isAtomicComponent(containerComponent)) {
523 log.debug(CANNOT_ATTACH_RESOURCE_INSTANCES_TO_CONTAINER_RESOURCE_OF_TYPE, containerComponent.assetType());
524 throw new ByActionStatusComponentException(ActionStatus.RESOURCE_CANNOT_CONTAIN_RESOURCE_INSTANCES, containerComponent.assetType());
526 validateCanWorkOnComponent(containerComponent, userId);
527 log.debug("enter createRealComponentInstance,validateCanWorkOnComponent success");
528 if (resourceInstance != null && containerComponentType != null) {
529 log.debug("enter createRealComponentInstance,start create ComponentInstance");
530 OriginTypeEnum originType = resourceInstance.getOriginType();
531 validateInstanceName(resourceInstance);
532 if (originType == OriginTypeEnum.ServiceProxy) {
533 log.debug("enter createRealComponentInstance,originType equals ServiceProxy");
534 Either<Component, StorageOperationStatus> serviceProxyOrigin = toscaOperationFacade.getLatestByName(SERVICE_PROXY, null);
535 if (isServiceProxyOrigin(serviceProxyOrigin)) {
536 throw new ByActionStatusComponentException(componentsUtils.convertFromStorageResponse(serviceProxyOrigin.right().value()));
538 origComponent = serviceProxyOrigin.left().value();
539 StorageOperationStatus fillProxyRes = fillInstanceData(resourceInstance, origComponent);
540 if (isFillProxyRes(fillProxyRes)) {
541 throw new ByActionStatusComponentException(componentsUtils.convertFromStorageResponse(fillProxyRes));
544 log.debug("enter createRealComponentInstance,originType is not ServiceProxy");
545 origComponent = getAndValidateOriginComponentOfComponentInstance(containerComponent, resourceInstance);
547 validateOriginAndResourceInstanceTypes(containerComponent, origComponent, originType);
548 validateResourceInstanceState(containerComponent, origComponent);
549 overrideFields(origComponent, resourceInstance);
550 compositionBusinessLogic.validateAndSetDefaultCoordinates(resourceInstance);
551 log.debug("enter createRealComponentInstance,final validate success");
553 return createRealComponent(needLock, containerComponent, origComponent, resourceInstance, user);
554 } catch (ComponentException e) {
555 log.debug("create Real Component Instance failed");
560 private Either<ComponentInstance, ResponseFormat> createRealComponent(boolean needLock, Component containerComponent, Component origComponent,
561 ComponentInstance resourceInstance, User user) {
562 log.debug("enter createRealComponent");
563 boolean failed = false;
565 lockIfNeed(needLock, containerComponent);
566 log.debug(TRY_TO_CREATE_ENTRY_ON_GRAPH);
567 return createRealComponentInstanceOnGraph(containerComponent, origComponent, resourceInstance, user);
568 } catch (ComponentException e) {
573 unlockComponent(failed, containerComponent);
578 private Either<ComponentInstance, ResponseFormat> createRealComponentInstanceOnGraph(org.openecomp.sdc.be.model.Component containerComponent,
579 Component originComponent,
580 ComponentInstance componentInstance, User user) {
581 log.debug("enter createRealComponentInstanceOnGraph");
582 Either<ImmutablePair<Component, String>, StorageOperationStatus> result = toscaOperationFacade
583 .addComponentInstanceToTopologyTemplate(containerComponent, originComponent, componentInstance, false, user);
584 if (result.isRight()) {
585 log.debug("enter createRealComponentInstanceOnGraph,result is right");
586 ActionStatus status = componentsUtils.convertFromStorageResponse(result.right().value());
587 log.debug(FAILED_TO_CREATE_ENTRY_ON_GRAPH_FOR_COMPONENT_INSTANCE, componentInstance.getName());
588 return Either.right(componentsUtils.getResponseFormat(status));
590 log.debug(ENTITY_ON_GRAPH_IS_CREATED);
591 log.debug("enter createRealComponentInstanceOnGraph,Entity on graph is created.");
592 Component updatedComponent = result.left().value().getLeft();
593 Map<String, String> existingEnvVersions = new HashMap<>();
594 // TODO existingEnvVersions ??
595 addComponentInstanceArtifacts(updatedComponent, componentInstance, originComponent, user, existingEnvVersions);
596 Optional<ComponentInstance> updatedInstanceOptional = updatedComponent.getComponentInstances().stream()
597 .filter(ci -> ci.getUniqueId().equals(result.left().value().getRight())).findFirst();
598 if (!updatedInstanceOptional.isPresent()) {
599 log.debug("Failed to fetch new added component instance {} from component {}", componentInstance.getName(), containerComponent.getName());
600 throw new ByActionStatusComponentException(ActionStatus.COMPONENT_INSTANCE_NOT_FOUND_ON_CONTAINER, componentInstance.getName());
602 log.debug("enter createRealComponentInstanceOnGraph,and final success");
603 return Either.left(updatedInstanceOptional.get());
606 private void overrideFields(Component origComponent, ComponentInstance resourceInstance) {
607 resourceInstance.setComponentVersion(origComponent.getVersion());
608 resourceInstance.setIcon(origComponent.getIcon());
611 private void validateInstanceName(ComponentInstance resourceInstance) {
612 String resourceInstanceName = resourceInstance.getName();
613 if (StringUtils.isEmpty(resourceInstanceName)) {
614 log.debug("ComponentInstance name is empty");
615 throw new ByActionStatusComponentException(ActionStatus.INVALID_COMPONENT_NAME, resourceInstance.getName());
617 if (!ValidationUtils.validateComponentNameLength(resourceInstanceName)) {
618 log.debug("ComponentInstance name exceeds max length {} ", ValidationUtils.COMPONENT_NAME_MAX_LENGTH);
619 throw new ByActionStatusComponentException(ActionStatus.INVALID_COMPONENT_NAME, resourceInstance.getName());
621 if (!ValidationUtils.validateComponentNamePattern(resourceInstanceName)) {
622 log.debug("ComponentInstance name {} has invalid format", resourceInstanceName);
623 throw new ByActionStatusComponentException(ActionStatus.INVALID_COMPONENT_NAME, resourceInstance.getName());
627 private void validateResourceInstanceState(Component containerComponent, Component origComponent) {
628 if (origComponent.getLifecycleState() == LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT) {
629 throw new ByActionStatusComponentException(ActionStatus.CONTAINER_CANNOT_CONTAIN_INSTANCE,
630 containerComponent.getComponentType().getValue(), origComponent.getLifecycleState().toString());
634 private void validateOriginAndResourceInstanceTypes(final Component containerComponent, final Component origComponent,
635 final OriginTypeEnum originType) {
636 final ResourceTypeEnum resourceType = getResourceTypeEnumFromOriginComponent(origComponent);
637 validateOriginType(originType, resourceType);
638 validateOriginComponentIsValidForContainer(containerComponent, resourceType);
641 private void validateOriginComponentIsValidForContainer(Component containerComponent, ResourceTypeEnum resourceType) {
642 switch (containerComponent.getComponentType()) {
644 if (!containerInstanceTypesData.isAllowedForServiceComponent(resourceType, containerComponent.getModel())) {
645 throw new ByActionStatusComponentException(ActionStatus.CONTAINER_CANNOT_CONTAIN_INSTANCE,
646 containerComponent.getComponentType().toString(), resourceType.name());
650 final ResourceTypeEnum componentResourceType = ((Resource) containerComponent).getResourceType();
651 if (!containerInstanceTypesData.isAllowedForResourceComponent(componentResourceType, resourceType)) {
652 throw new ByActionStatusComponentException(ActionStatus.CONTAINER_CANNOT_CONTAIN_INSTANCE,
653 containerComponent.getComponentType().toString(), resourceType.name());
657 throw new ByActionStatusComponentException(ActionStatus.INVALID_CONTENT);
661 private void validateOriginType(OriginTypeEnum originType, ResourceTypeEnum resourceType) {
662 ResourceTypeEnum convertedOriginType;
664 convertedOriginType = ResourceTypeEnum.getTypeIgnoreCase(originType.name());
665 } catch (Exception e) {
666 throw new ByActionStatusComponentException(ActionStatus.INVALID_CONTENT);
668 if (resourceType != convertedOriginType) {
669 throw new ByActionStatusComponentException(ActionStatus.INVALID_CONTENT);
673 private ResourceTypeEnum getResourceTypeEnumFromOriginComponent(final Component origComponent) {
674 switch (origComponent.getComponentType()) {
676 return ResourceTypeEnum.ServiceProxy;
678 return ((Resource) origComponent).getResourceType();
680 throw new ByActionStatusComponentException(ActionStatus.INVALID_CONTENT);
684 private void lockIfNeed(boolean needLock, Component containerComponent) {
686 lockComponent(containerComponent, "createComponentInstance");
690 private boolean isServiceProxyOrigin(Either<Component, StorageOperationStatus> serviceProxyOrigin) {
691 if (serviceProxyOrigin.isRight()) {
692 log.debug("Failed to fetch normative service proxy resource by tosca name, error {}", serviceProxyOrigin.right().value());
698 private StorageOperationStatus fillInstanceData(ComponentInstance resourceInstance, Component origComponent) {
699 final ComponentParametersView filter = new ComponentParametersView(true);
700 filter.setIgnoreCapabilities(false);
701 filter.setIgnoreCapabiltyProperties(false);
702 filter.setIgnoreComponentInstances(false);
703 filter.setIgnoreRequirements(false);
704 filter.setIgnoreInterfaces(false);
705 filter.setIgnoreProperties(false);
706 filter.setIgnoreAttributes(false);
707 filter.setIgnoreInputs(false);
708 Either<Component, StorageOperationStatus> serviceRes = toscaOperationFacade.getToscaElement(resourceInstance.getComponentUid(), filter);
709 if (serviceRes.isRight()) {
710 return serviceRes.right().value();
712 final Component service = serviceRes.left().value();
713 final Map<String, List<CapabilityDefinition>> capabilities = service.getCapabilities();
714 resourceInstance.setCapabilities(capabilities);
715 final Map<String, List<RequirementDefinition>> req = service.getRequirements();
716 resourceInstance.setRequirements(req);
717 final Map<String, InterfaceDefinition> serviceInterfaces = service.getInterfaces();
718 if (MapUtils.isNotEmpty(serviceInterfaces)) {
719 serviceInterfaces.forEach(resourceInstance::addInterface);
721 resourceInstance.setProperties(PropertiesUtils.getProperties(service));
722 resourceInstance.setAttributes(service.getAttributes());
723 final List<InputDefinition> serviceInputs = service.getInputs();
724 resourceInstance.setInputs(serviceInputs);
725 resourceInstance.setSourceModelInvariant(service.getInvariantUUID());
726 resourceInstance.setSourceModelName(service.getName());
727 resourceInstance.setSourceModelUuid(service.getUUID());
728 resourceInstance.setSourceModelUid(service.getUniqueId());
729 resourceInstance.setComponentUid(origComponent.getUniqueId());
730 resourceInstance.setComponentVersion(service.getVersion());
731 switch (resourceInstance.getOriginType()) {
733 return fillProxyInstanceData(resourceInstance, origComponent, service);
734 case ServiceSubstitution:
735 return fillServiceSubstitutableNodeTypeData(resourceInstance, service);
737 return StorageOperationStatus.OK;
741 private StorageOperationStatus fillProxyInstanceData(final ComponentInstance resourceInstance, final Component origComponent,
742 final Component service) {
743 final String name = ValidationUtils.normalizeComponentInstanceName(service.getName()) + ToscaOperationFacade.PROXY_SUFFIX;
744 final String toscaResourceName = ((Resource) origComponent).getToscaResourceName();
745 final int lastIndexOf = toscaResourceName.lastIndexOf('.');
746 if (lastIndexOf != -1) {
747 final String proxyToscaName = toscaResourceName.substring(0, lastIndexOf + 1) + name;
748 resourceInstance.setToscaComponentName(proxyToscaName);
750 resourceInstance.setName(name);
751 resourceInstance.setIsProxy(true);
752 resourceInstance.setDescription("A Proxy for Service " + service.getName());
753 return StorageOperationStatus.OK;
756 private StorageOperationStatus fillServiceSubstitutableNodeTypeData(final ComponentInstance resourceInstance, final Component service) {
757 resourceInstance.setToscaComponentName("org.openecomp.service." + ValidationUtils.convertToSystemName(service.getName()));
758 resourceInstance.setName(ValidationUtils.normalizeComponentInstanceName(service.getName()));
759 resourceInstance.setIsProxy(false);
760 resourceInstance.setDescription("A substitutable node type for service " + service.getName());
761 return StorageOperationStatus.OK;
764 public Either<CreateAndAssotiateInfo, ResponseFormat> createAndAssociateRIToRI(String containerComponentParam, String containerComponentId,
765 String userId, CreateAndAssotiateInfo createAndAssotiateInfo) {
766 Either<CreateAndAssotiateInfo, ResponseFormat> resultOp = null;
767 ComponentInstance resourceInstance = createAndAssotiateInfo.getNode();
768 RequirementCapabilityRelDef associationInfo = createAndAssotiateInfo.getAssociate();
769 User user = validateUserExists(userId);
770 final ComponentTypeEnum containerComponentType = validateComponentType(containerComponentParam);
771 org.openecomp.sdc.be.model.Component containerComponent = validateComponentExists(containerComponentId, containerComponentType, null);
772 if (ModelConverter.isAtomicComponent(containerComponent)) {
773 log.debug(CANNOT_ATTACH_RESOURCE_INSTANCES_TO_CONTAINER_RESOURCE_OF_TYPE, containerComponent.assetType());
775 .right(componentsUtils.getResponseFormat(ActionStatus.RESOURCE_CANNOT_CONTAIN_RESOURCE_INSTANCES, containerComponent.assetType()));
777 validateCanWorkOnComponent(containerComponent, userId);
778 boolean failed = false;
780 lockComponent(containerComponent, "createAndAssociateRIToRI");
781 log.debug(TRY_TO_CREATE_ENTRY_ON_GRAPH);
782 Component origComponent = getOriginComponentFromComponentInstance(resourceInstance);
783 log.debug(ENTITY_ON_GRAPH_IS_CREATED);
784 ComponentInstance resResourceInfo = createComponentInstanceOnGraph(containerComponent, origComponent, resourceInstance, user);
785 if (associationInfo.getFromNode() == null || associationInfo.getFromNode().isEmpty()) {
786 associationInfo.setFromNode(resResourceInfo.getUniqueId());
788 associationInfo.setToNode(resResourceInfo.getUniqueId());
790 Either<RequirementCapabilityRelDef, StorageOperationStatus> resultReqCapDef = toscaOperationFacade
791 .associateResourceInstances(containerComponent, containerComponentId, associationInfo);
792 if (resultReqCapDef.isLeft()) {
793 log.debug(ENTITY_ON_GRAPH_IS_CREATED);
794 RequirementCapabilityRelDef resReqCapabilityRelDef = resultReqCapDef.left().value();
795 CreateAndAssotiateInfo resInfo = new CreateAndAssotiateInfo(resResourceInfo, resReqCapabilityRelDef);
796 resultOp = Either.left(resInfo);
799 log.info("Failed to associate node {} with node {}", associationInfo.getFromNode(), associationInfo.getToNode());
800 resultOp = Either.right(componentsUtils.getResponseFormatForResourceInstance(
801 componentsUtils.convertFromStorageResponseForResourceInstance(resultReqCapDef.right().value(), true), "", null));
804 } catch (ComponentException e) {
808 unlockComponent(failed, containerComponent);
812 private Component getOriginComponentFromComponentInstance(ComponentInstance componentInstance) {
813 return getOriginComponentFromComponentInstance(componentInstance.getName(), componentInstance.getComponentUid());
816 private Component getInstanceOriginNode(ComponentInstance componentInstance) {
817 return getOriginComponentFromComponentInstance(componentInstance.getName(), componentInstance.getActualComponentUid());
820 private Component getOriginComponentFromComponentInstance(String componentInstanceName, String origComponetId) {
821 Either<Component, StorageOperationStatus> eitherComponent = toscaOperationFacade.getToscaFullElement(origComponetId);
822 if (eitherComponent.isRight()) {
823 log.debug("Failed to get origin component with id {} for component instance {} ", origComponetId, componentInstanceName);
824 throw new ByActionStatusComponentException(
825 componentsUtils.convertFromStorageResponse(eitherComponent.right().value(), ComponentTypeEnum.RESOURCE), "", null);
827 return eitherComponent.left().value();
830 private ComponentInstance createComponentInstanceOnGraph(org.openecomp.sdc.be.model.Component containerComponent, Component originComponent,
831 ComponentInstance componentInstance, User user) {
832 Either<ImmutablePair<Component, String>, StorageOperationStatus> result = toscaOperationFacade
833 .addComponentInstanceToTopologyTemplate(containerComponent, originComponent, componentInstance, false, user);
834 if (result.isRight()) {
835 log.debug(FAILED_TO_CREATE_ENTRY_ON_GRAPH_FOR_COMPONENT_INSTANCE, componentInstance.getName());
836 throw new ByResponseFormatComponentException(componentsUtils
837 .getResponseFormatForResourceInstance(componentsUtils.convertFromStorageResponseForResourceInstance(result.right().value(), true), "",
840 log.debug(ENTITY_ON_GRAPH_IS_CREATED);
841 Component updatedComponent = result.left().value().getLeft();
842 Map<String, String> existingEnvVersions = new HashMap<>();
843 // TODO existingEnvVersions ??
844 addComponentInstanceArtifacts(updatedComponent, componentInstance, originComponent, user, existingEnvVersions);
845 Optional<ComponentInstance> updatedInstanceOptional = updatedComponent.getComponentInstances().stream()
846 .filter(ci -> ci.getUniqueId().equals(result.left().value().getRight())).findFirst();
847 if (!updatedInstanceOptional.isPresent()) {
848 log.debug("Failed to fetch new added component instance {} from component {}", componentInstance.getName(), containerComponent.getName());
849 throw new ByActionStatusComponentException(ActionStatus.COMPONENT_INSTANCE_NOT_FOUND_ON_CONTAINER, componentInstance.getName());
851 return updatedInstanceOptional.get();
854 public boolean isCloudSpecificArtifact(String artifact) {
855 if (artifact.contains(CLOUD_SPECIFIC_FIXED_KEY_WORD)) {
856 for (int i = 0; i < CLOUD_SPECIFIC_KEY_WORDS.length; i++) {
857 if (Arrays.stream(CLOUD_SPECIFIC_KEY_WORDS[i]).noneMatch(artifact::contains)) {
868 * addResourceInstanceArtifacts - add artifacts (HEAT_ENV) to resource instance The instance artifacts are generated from the resource's
871 * @param containerComponent
872 * @param componentInstance
873 * @param originComponent
875 * @param existingEnvVersions
878 protected ActionStatus addComponentInstanceArtifacts(org.openecomp.sdc.be.model.Component containerComponent, ComponentInstance componentInstance,
879 org.openecomp.sdc.be.model.Component originComponent, User user,
880 Map<String, String> existingEnvVersions) {
881 log.debug("add artifacts to resource instance");
882 List<GroupDefinition> filteredGroups = new ArrayList<>();
883 ActionStatus status = setResourceArtifactsOnResourceInstance(componentInstance);
884 if (ActionStatus.OK != status) {
885 throw new ByResponseFormatComponentException(componentsUtils.getResponseFormatForResourceInstance(status, "", null));
887 StorageOperationStatus artStatus;
888 // generate heat_env if necessary
889 Map<String, ArtifactDefinition> componentDeploymentArtifacts = componentInstance.getDeploymentArtifacts();
890 if (MapUtils.isNotEmpty(componentDeploymentArtifacts)) {
891 Map<String, ArtifactDefinition> finalDeploymentArtifacts = new HashMap<>();
892 Map<String, List<ArtifactDefinition>> groupInstancesArtifacts = new HashMap<>();
893 Integer defaultHeatTimeout = ConfigurationManager.getConfigurationManager().getConfiguration().getHeatArtifactDeploymentTimeout()
894 .getDefaultMinutes();
895 List<ArtifactDefinition> listOfCloudSpecificArts = new ArrayList<>();
896 for (ArtifactDefinition artifact : componentDeploymentArtifacts.values()) {
897 String type = artifact.getArtifactType();
898 if (!type.equalsIgnoreCase(ArtifactTypeEnum.HEAT_ENV.getType())) {
899 finalDeploymentArtifacts.put(artifact.getArtifactLabel(), artifact);
901 if (type.equalsIgnoreCase(ArtifactTypeEnum.HEAT.getType()) || type.equalsIgnoreCase(ArtifactTypeEnum.HELM.getType()) || type
902 .equalsIgnoreCase(ArtifactTypeEnum.HEAT_NET.getType()) || type.equalsIgnoreCase(ArtifactTypeEnum.HEAT_VOL.getType()) || type
903 .equalsIgnoreCase(ArtifactTypeEnum.CLOUD_TECHNOLOGY_SPECIFIC_ARTIFACT.getType())) {
904 artifact.setTimeout(defaultHeatTimeout);
908 if (artifact.checkEsIdExist()) {
909 ArtifactDefinition artifactDefinition = artifactBusinessLogic
910 .createHeatEnvPlaceHolder(new ArrayList<>(), artifact, ArtifactsBusinessLogic.HEAT_ENV_NAME, componentInstance.getUniqueId(),
911 NodeTypeEnum.ResourceInstance, componentInstance.getName(), user, containerComponent, existingEnvVersions);
913 finalDeploymentArtifacts.put(artifactDefinition.getArtifactLabel(), artifactDefinition);
914 if (CollectionUtils.isNotEmpty(originComponent.getGroups())) {
915 filteredGroups = originComponent.getGroups().stream().filter(g -> g.getType().equals(VF_MODULE)).collect(Collectors.toList());
917 if (isCloudSpecificArtifact(artifactDefinition.getArtifactName())) {
918 listOfCloudSpecificArts.add(artifact);
920 if (CollectionUtils.isNotEmpty(filteredGroups)) {
921 filteredGroups.stream()
922 .filter(g -> g.getArtifacts() != null && g.getArtifacts().stream().anyMatch(p -> p.equals(artifactDefinition.getGeneratedFromId()))).findFirst()
923 .ifPresent(g -> fillInstanceArtifactMap(groupInstancesArtifacts, artifactDefinition, g));
927 groupInstancesArtifacts.forEach((k, v) -> v.addAll(listOfCloudSpecificArts));
928 filteredGroups.forEach(g -> listOfCloudSpecificArts.forEach(e -> {
929 g.getArtifactsUuid().add(e.getArtifactUUID());
930 g.getArtifacts().add(e.getUniqueId());
932 artStatus = toscaOperationFacade
933 .addDeploymentArtifactsToInstance(containerComponent.getUniqueId(), componentInstance, finalDeploymentArtifacts);
934 if (artStatus != StorageOperationStatus.OK) {
935 log.debug("Failed to add instance deployment artifacts for instance {} in conatiner {} error {}", componentInstance.getUniqueId(),
936 containerComponent.getUniqueId(), artStatus);
937 throw new ByResponseFormatComponentException(
938 componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponseForResourceInstance(artStatus, false)));
940 StorageOperationStatus result = toscaOperationFacade
941 .addGroupInstancesToComponentInstance(containerComponent, componentInstance, filteredGroups, groupInstancesArtifacts);
942 if (result != StorageOperationStatus.OK) {
943 log.debug("failed to update group instance for component instance {}", componentInstance.getUniqueId());
944 throw new ByResponseFormatComponentException(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(result)));
946 componentInstance.setDeploymentArtifacts(finalDeploymentArtifacts);
948 artStatus = toscaOperationFacade
949 .addInformationalArtifactsToInstance(containerComponent.getUniqueId(), componentInstance, originComponent.getArtifacts());
950 if (artStatus != StorageOperationStatus.OK) {
951 log.debug("Failed to add informational artifacts to the instance {} belonging to the conatiner {}. Status is {}",
952 componentInstance.getUniqueId(), containerComponent.getUniqueId(), artStatus);
953 throw new ByResponseFormatComponentException(
954 componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponseForResourceInstance(artStatus, false)));
956 componentInstance.setArtifacts(originComponent.getArtifacts());
957 return ActionStatus.OK;
960 private void fillInstanceArtifactMap(Map<String, List<ArtifactDefinition>> groupInstancesArtifacts, ArtifactDefinition artifactDefinition,
961 GroupDefinition groupInstance) {
962 List<ArtifactDefinition> artifactsUid;
963 if (groupInstancesArtifacts.containsKey(groupInstance.getUniqueId())) {
964 artifactsUid = groupInstancesArtifacts.get(groupInstance.getUniqueId());
966 artifactsUid = new ArrayList<>();
968 artifactsUid.add(artifactDefinition);
969 groupInstancesArtifacts.put(groupInstance.getUniqueId(), artifactsUid);
972 private ActionStatus setResourceArtifactsOnResourceInstance(ComponentInstance resourceInstance) {
973 Either<Map<String, ArtifactDefinition>, StorageOperationStatus> getResourceDeploymentArtifacts = artifactBusinessLogic
974 .getArtifacts(resourceInstance.getComponentUid(), NodeTypeEnum.Resource, ArtifactGroupTypeEnum.DEPLOYMENT, null);
975 Map<String, ArtifactDefinition> deploymentArtifacts = new HashMap<>();
976 if (getResourceDeploymentArtifacts.isRight()) {
977 StorageOperationStatus status = getResourceDeploymentArtifacts.right().value();
978 if (status != StorageOperationStatus.NOT_FOUND) {
979 log.debug("Failed to fetch resource: {} artifacts. status is {}", resourceInstance.getComponentUid(), status);
980 return componentsUtils.convertFromStorageResponseForResourceInstance(status, true);
983 deploymentArtifacts = getResourceDeploymentArtifacts.left().value();
985 if (!deploymentArtifacts.isEmpty()) {
986 Map<String, ArtifactDefinition> tempDeploymentArtifacts = new HashMap<>(deploymentArtifacts);
987 for (Entry<String, ArtifactDefinition> artifact : deploymentArtifacts.entrySet()) {
988 if (!artifact.getValue().checkEsIdExist()) {
989 tempDeploymentArtifacts.remove(artifact.getKey());
992 resourceInstance.setDeploymentArtifacts(tempDeploymentArtifacts);
994 return ActionStatus.OK;
997 public Either<ComponentInstance, ResponseFormat> updateComponentInstanceMetadata(String containerComponentParam, String containerComponentId,
998 String componentInstanceId, String userId,
999 ComponentInstance componentInstance) {
1000 return updateComponentInstanceMetadata(containerComponentParam, containerComponentId, componentInstanceId, userId, componentInstance, true);
1003 public Either<ComponentInstance, ResponseFormat> updateComponentInstanceMetadata(final String containerComponentParam,
1004 final String containerComponentId,
1005 final String componentInstanceId, final String userId,
1006 ComponentInstance componentInstance, boolean needLock) {
1007 validateUserExists(userId);
1008 final ComponentTypeEnum containerComponentType = validateComponentType(containerComponentParam);
1009 final Component containerComponent = validateComponentExists(containerComponentId, containerComponentType, null);
1010 validateCanWorkOnComponent(containerComponent, userId);
1011 ComponentTypeEnum instanceType = getComponentType(containerComponentType);
1012 Either<Boolean, StorageOperationStatus> validateParentStatus = toscaOperationFacade
1013 .validateComponentExists(componentInstance.getComponentUid());
1014 if (validateParentStatus.isRight()) {
1015 log.debug("Failed to get component instance {} on service {}", componentInstanceId, containerComponentId);
1016 throw new ByActionStatusComponentException(ActionStatus.COMPONENT_INSTANCE_NOT_FOUND, componentInstance.getName(),
1017 instanceType.getValue().toLowerCase());
1019 if (!Boolean.TRUE.equals(validateParentStatus.left().value())) {
1020 throw new ByActionStatusComponentException(ActionStatus.COMPONENT_INSTANCE_NOT_FOUND_ON_CONTAINER, componentInstance.getName(),
1021 instanceType.getValue().toLowerCase(), containerComponentType.getValue().toLowerCase(), containerComponentId);
1024 lockComponent(containerComponent, "updateComponentInstance");
1026 Component origComponent;
1027 boolean failed = false;
1029 origComponent = getOriginComponentFromComponentInstance(componentInstance);
1030 componentInstance = updateComponentInstanceMetadata(containerComponent, containerComponentType, origComponent, componentInstanceId,
1032 } catch (ComponentException e) {
1037 unlockComponent(failed, containerComponent);
1040 return Either.left(componentInstance);
1043 // New Multiple Instance Update API
1044 public List<ComponentInstance> updateComponentInstance(String containerComponentParam, Component containerComponent, String containerComponentId,
1045 String userId, List<ComponentInstance> componentInstanceList, boolean needLock) {
1046 boolean failed = false;
1048 validateUserExists(userId);
1049 final ComponentTypeEnum containerComponentType = validateComponentType(containerComponentParam);
1050 ComponentParametersView componentFilter = new ComponentParametersView();
1051 componentFilter.disableAll();
1052 componentFilter.setIgnoreUsers(false);
1053 componentFilter.setIgnoreComponentInstances(false);
1054 if (containerComponent == null) {
1055 containerComponent = validateComponentExistsByFilter(containerComponentId, containerComponentType, componentFilter);
1057 validateCanWorkOnComponent(containerComponent, userId);
1058 ComponentTypeEnum instanceType = getComponentType(containerComponentType);
1059 for (ComponentInstance componentInstance : componentInstanceList) {
1060 boolean validateParent = validateParent(containerComponent, componentInstance.getUniqueId());
1061 if (!validateParent) {
1062 throw new ByActionStatusComponentException(ActionStatus.COMPONENT_INSTANCE_NOT_FOUND_ON_CONTAINER, componentInstance.getName(),
1063 instanceType.getValue().toLowerCase(), containerComponentType.getValue().toLowerCase(), containerComponentId);
1067 lockComponent(containerComponent, "updateComponentInstance");
1069 List<ComponentInstance> updatedList = new ArrayList<>();
1070 List<ComponentInstance> instancesFromContainerComponent = containerComponent.getComponentInstances();
1071 List<ComponentInstance> listForUpdate = new ArrayList<>();
1072 if (instancesFromContainerComponent == null || instancesFromContainerComponent.isEmpty()) {
1073 containerComponent.setComponentInstances(componentInstanceList);
1075 Iterator<ComponentInstance> iterator = instancesFromContainerComponent.iterator();
1076 while (iterator.hasNext()) {
1077 ComponentInstance origInst = iterator.next();
1078 Optional<ComponentInstance> op = componentInstanceList.stream().filter(ci -> ci.getUniqueId().equals(origInst.getUniqueId()))
1080 if (op.isPresent()) {
1081 ComponentInstance updatedCi = op.get();
1082 updatedCi = buildComponentInstance(updatedCi, origInst);
1083 Boolean isUniqueName = validateInstanceNameUniquenessUponUpdate(containerComponent, origInst, updatedCi.getName());
1084 if (!Boolean.TRUE.equals(isUniqueName)) {
1085 CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG,
1086 "Failed to update the name of the component instance {} to {}. A component instance with the same name already exists. ",
1087 origInst.getName(), updatedCi.getName());
1088 throw new ByResponseFormatComponentException(componentsUtils
1089 .getResponseFormat(ActionStatus.COMPONENT_NAME_ALREADY_EXIST, containerComponentType.getValue(), origInst.getName()));
1091 listForUpdate.add(updatedCi);
1093 listForUpdate.add(origInst);
1096 containerComponent.setComponentInstances(listForUpdate);
1097 Either<Component, StorageOperationStatus> updateStatus = toscaOperationFacade
1098 .updateComponentInstanceMetadataOfTopologyTemplate(containerComponent, componentFilter);
1099 if (updateStatus.isRight()) {
1101 .addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to update metadata belonging to container component {}. Status is {}. ",
1102 containerComponent.getName(), updateStatus.right().value());
1103 throw new ByResponseFormatComponentException(componentsUtils.getResponseFormatForResourceInstance(
1104 componentsUtils.convertFromStorageResponseForResourceInstance(updateStatus.right().value(), true), "", null));
1106 for (ComponentInstance updatedInstance : updateStatus.left().value().getComponentInstances()) {
1107 Optional<ComponentInstance> op = componentInstanceList.stream().filter(ci -> ci.getName().equals(updatedInstance.getName()))
1109 if (op.isPresent()) {
1110 updatedList.add(updatedInstance);
1115 } catch (ComponentException e) {
1120 unlockComponent(failed, containerComponent);
1125 private boolean validateParent(org.openecomp.sdc.be.model.Component containerComponent, String nodeTemplateId) {
1126 return containerComponent.getComponentInstances().stream().anyMatch(p -> p.getUniqueId().equals(nodeTemplateId));
1129 private ComponentTypeEnum getComponentType(ComponentTypeEnum containerComponentType) {
1130 if (ComponentTypeEnum.PRODUCT == containerComponentType) {
1131 return ComponentTypeEnum.SERVICE_INSTANCE;
1133 return ComponentTypeEnum.RESOURCE_INSTANCE;
1137 private ComponentInstance updateComponentInstanceMetadata(Component containerComponent, ComponentTypeEnum containerComponentType,
1138 org.openecomp.sdc.be.model.Component origComponent, String componentInstanceId,
1139 ComponentInstance componentInstance) {
1140 Optional<ComponentInstance> componentInstanceOptional;
1141 Either<ImmutablePair<Component, String>, StorageOperationStatus> updateRes = null;
1142 ComponentInstance oldComponentInstance = null;
1143 boolean isNameChanged = false;
1144 componentInstanceOptional = containerComponent.getComponentInstances().stream()
1145 .filter(ci -> ci.getUniqueId().equals(componentInstance.getUniqueId())).findFirst();
1146 if (!componentInstanceOptional.isPresent()) {
1147 CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to find the component instance {} in container component {}. ",
1148 componentInstance.getName(), containerComponent.getName());
1149 throw new ByActionStatusComponentException(ActionStatus.COMPONENT_INSTANCE_NOT_FOUND_ON_CONTAINER, componentInstance.getName());
1151 String oldComponentName;
1152 oldComponentInstance = componentInstanceOptional.get();
1153 oldComponentName = oldComponentInstance.getName();
1154 String newInstanceName = componentInstance.getName();
1155 if (oldComponentName != null && !oldComponentInstance.getName().equals(newInstanceName)) {
1156 isNameChanged = true;
1158 Boolean isUniqueName = validateInstanceNameUniquenessUponUpdate(containerComponent, oldComponentInstance, newInstanceName);
1159 if (!Boolean.TRUE.equals(isUniqueName)) {
1160 CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG,
1161 "Failed to update the name of the component instance {} to {}. A component instance with the same name already exists. ",
1162 oldComponentInstance.getName(), newInstanceName);
1163 throw new ByActionStatusComponentException(ActionStatus.COMPONENT_NAME_ALREADY_EXIST, containerComponentType.getValue(),
1164 componentInstance.getName());
1166 if (!DirectivesUtil.isValid(componentInstance.getDirectives())) {
1167 final String directivesStr = componentInstance.getDirectives().stream().collect(Collectors.joining(" , ", " [ ", " ] "));
1168 CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG,
1169 "Failed to update the directives of the component instance {} to {}. Directives data {} is invalid. ", oldComponentInstance.getName(),
1170 newInstanceName, directivesStr);
1171 throw new ByActionStatusComponentException(ActionStatus.DIRECTIVES_INVALID_VALUE, containerComponentType.getValue(),
1172 componentInstance.getName());
1174 updateRes = toscaOperationFacade.updateComponentInstanceMetadataOfTopologyTemplate(containerComponent, origComponent,
1175 updateComponentInstanceMetadata(oldComponentInstance, componentInstance));
1176 if (updateRes.isRight()) {
1177 CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG,
1178 "Failed to update metadata of component instance {} belonging to container component {}. Status is {}. ", componentInstance.getName(),
1179 containerComponent.getName(), updateRes.right().value());
1180 throw new ByResponseFormatComponentException(componentsUtils
1181 .getResponseFormatForResourceInstance(componentsUtils.convertFromStorageResponseForResourceInstance(updateRes.right().value(), true),
1184 // region - Update instance Groups
1185 if (isNameChanged) {
1186 Either<StorageOperationStatus, StorageOperationStatus> result = toscaOperationFacade
1187 .cleanAndAddGroupInstancesToComponentInstance(containerComponent, oldComponentInstance, componentInstanceId);
1188 if (result.isRight()) {
1190 .addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to rename group instances for container {}. error {} ", componentInstanceId,
1191 result.right().value());
1193 if (containerComponent instanceof Service) {
1194 Either<ComponentInstance, ResponseFormat> renameEither = renameServiceFilter((Service) containerComponent, newInstanceName,
1195 oldComponentInstance.getName());
1196 if (renameEither.isRight()) {
1197 throw new ByResponseFormatComponentException(renameEither.right().value());
1199 updateForwardingPathDefinition(containerComponent, componentInstance, oldComponentName);
1204 String newInstanceId = updateRes.left().value().getRight();
1205 Optional<ComponentInstance> updatedInstanceOptional = updateRes.left().value().getLeft().getComponentInstances().stream()
1206 .filter(ci -> ci.getUniqueId().equals(newInstanceId)).findFirst();
1207 if (!updatedInstanceOptional.isPresent()) {
1208 log.debug("Failed to update metadata of component instance {} of container component {}", componentInstance.getName(),
1209 containerComponent.getName());
1210 throw new ByResponseFormatComponentException(
1211 componentsUtils.getResponseFormat(ActionStatus.COMPONENT_INSTANCE_NOT_FOUND_ON_CONTAINER, componentInstance.getName()));
1213 return componentInstanceOptional.get();
1216 private void updateForwardingPathDefinition(Component containerComponent, ComponentInstance componentInstance, String oldComponentName) {
1217 Collection<ForwardingPathDataDefinition> forwardingPathDataDefinitions = getForwardingPathDataDefinitions(containerComponent.getUniqueId());
1218 Set<ForwardingPathDataDefinition> updated = new ForwardingPathUtils()
1219 .updateComponentInstanceName(forwardingPathDataDefinitions, oldComponentName, componentInstance.getName());
1220 updated.forEach(fp -> {
1221 Either<ForwardingPathDataDefinition, StorageOperationStatus> resultEither = forwardingPathOperation
1222 .updateForwardingPath(containerComponent.getUniqueId(), fp);
1223 if (resultEither.isRight()) {
1224 CommonUtility.addRecordToLog(log, LogLevelEnum.ERROR, "Failed to rename forwarding path for container {}. error {} ",
1225 containerComponent.getName(), resultEither.right().value());
1230 public Either<ComponentInstance, ResponseFormat> renameServiceFilter(final Service containerComponent, final String newInstanceName,
1231 final String oldInstanceName) {
1232 Map<String, CINodeFilterDataDefinition> renamedNodesFilter = ServiceFilterUtils
1233 .getRenamedNodesFilter(containerComponent, oldInstanceName, newInstanceName);
1234 for (Entry<String, CINodeFilterDataDefinition> entry : renamedNodesFilter.entrySet()) {
1235 Either<CINodeFilterDataDefinition, StorageOperationStatus> renameEither = nodeFilterOperation
1236 .updateNodeFilter(containerComponent.getUniqueId(), entry.getKey(), entry.getValue());
1237 if (renameEither.isRight()) {
1238 return Either.right(componentsUtils.getResponseFormatForResourceInstance(
1239 componentsUtils.convertFromStorageResponse(renameEither.right().value(), ComponentTypeEnum.SERVICE), containerComponent.getName(),
1243 return Either.left(null);
1247 * @param oldPrefix- The normalized old vf name
1248 * @param newNormailzedPrefix- The normalized new vf name
1249 * @param qualifiedGroupInstanceName- old Group Instance Name
1252 // modify group names
1253 private String getNewGroupName(String oldPrefix, String newNormailzedPrefix, String qualifiedGroupInstanceName) {
1254 if (qualifiedGroupInstanceName == null) {
1255 log.info("CANNOT change group name ");
1258 if (qualifiedGroupInstanceName.startsWith(oldPrefix) || qualifiedGroupInstanceName
1259 .startsWith(ValidationUtils.normalizeComponentInstanceName(oldPrefix))) {
1260 return qualifiedGroupInstanceName.replaceFirst(oldPrefix, newNormailzedPrefix);
1262 return qualifiedGroupInstanceName;
1265 private ComponentInstance updateComponentInstanceMetadata(ComponentInstance oldComponentInstance, ComponentInstance newComponentInstance) {
1266 oldComponentInstance.setName(newComponentInstance.getName());
1267 oldComponentInstance.setModificationTime(System.currentTimeMillis());
1268 oldComponentInstance.setCustomizationUUID(UUID.randomUUID().toString());
1269 oldComponentInstance.setDirectives(newComponentInstance.getDirectives());
1270 oldComponentInstance.setMaxOccurrences(newComponentInstance.getMaxOccurrences());
1271 oldComponentInstance.setMinOccurrences(newComponentInstance.getMinOccurrences());
1272 oldComponentInstance.setInstanceCount(newComponentInstance.getInstanceCount());
1273 if (oldComponentInstance.getGroupInstances() != null) {
1274 oldComponentInstance.getGroupInstances().forEach(group -> group.setName(getNewGroupName(oldComponentInstance.getNormalizedName(),
1275 ValidationUtils.normalizeComponentInstanceName(newComponentInstance.getName()), group.getName())));
1277 return oldComponentInstance;
1280 public ComponentInstance deleteComponentInstance(final String containerComponentParam, final String containerComponentId,
1281 final String componentInstanceId, String userId) throws BusinessLogicException {
1282 validateUserExists(userId);
1283 final ComponentTypeEnum containerComponentType = validateComponentType(containerComponentParam);
1284 final Component containerComponent = validateComponentExists(containerComponentId, containerComponentType, null);
1285 validateCanWorkOnComponent(containerComponent, userId);
1286 boolean failed = false;
1287 final Optional<ComponentInstance> componentInstanceOptional = containerComponent.getComponentInstanceById(componentInstanceId);
1288 if (!componentInstanceOptional.isPresent()) {
1289 throw new BusinessLogicException(componentsUtils.getResponseFormat(ActionStatus.COMPONENT_INSTANCE_NOT_FOUND));
1291 ComponentInstance componentInstance = componentInstanceOptional.get();
1293 if (containerComponent instanceof Service || containerComponent instanceof Resource) {
1294 final Either<String, StorageOperationStatus> deleteServiceFilterEither = nodeFilterOperation
1295 .deleteNodeFilter(containerComponent, componentInstanceId);
1296 if (deleteServiceFilterEither.isRight()) {
1297 final ActionStatus status = componentsUtils
1298 .convertFromStorageResponse(deleteServiceFilterEither.right().value(), containerComponentType);
1299 janusGraphDao.rollback();
1300 throw new ByResponseFormatComponentException(componentsUtils.getResponseFormat(status, componentInstanceId));
1302 final Either<ComponentInstance, ResponseFormat> resultOp = deleteNodeFiltersFromComponentInstance(containerComponent,
1303 componentInstance, containerComponentType, userId);
1304 if (resultOp.isRight()) {
1305 janusGraphDao.rollback();
1306 throw new ByResponseFormatComponentException(resultOp.right().value());
1309 lockComponent(containerComponent, "deleteComponentInstance");
1310 final ComponentInstance deletedCompInstance = deleteComponentInstance(containerComponent, componentInstanceId, containerComponentType);
1311 componentInstance = deleteForwardingPathsRelatedTobeDeletedComponentInstance(containerComponentId, containerComponentType,
1312 deletedCompInstance);
1313 final ActionStatus onDeleteOperationsStatus = onChangeInstanceOperationOrchestrator
1314 .doOnDeleteInstanceOperations(containerComponent, componentInstanceId);
1315 if (ActionStatus.OK != onDeleteOperationsStatus) {
1316 throw new ByActionStatusComponentException(onDeleteOperationsStatus);
1318 } catch (final ComponentException e) {
1322 unlockComponent(failed, containerComponent);
1324 return componentInstance;
1328 * Try to modify the delete and return two cases
1330 * @param containerComponentParam
1331 * @param containerComponentId
1332 * @param componentInstanceId
1336 public Either<ComponentInstance, ResponseFormat> deleteAbstractComponentInstance(String containerComponentParam, String containerComponentId,
1337 String componentInstanceId, String userId) {
1338 log.debug("enter deleteAbstractComponentInstance");
1339 validateUserExists(userId);
1340 final ComponentTypeEnum containerComponentType = validateComponentType(containerComponentParam);
1341 org.openecomp.sdc.be.model.Component containerComponent = validateComponentExists(containerComponentId, containerComponentType, null);
1342 validateCanWorkOnComponent(containerComponent, userId);
1343 boolean failed = false;
1344 ComponentInstance deletedRelatedInst;
1346 if (containerComponent instanceof Service) {
1347 final Optional<ComponentInstance> componentInstanceById = containerComponent.getComponentInstanceById(componentInstanceId);
1348 if (componentInstanceById.isPresent()) {
1349 ComponentInstance componentInstance = componentInstanceById.get();
1350 Either<String, StorageOperationStatus> deleteServiceFilterEither = nodeFilterOperation
1351 .deleteNodeFilter(containerComponent, componentInstanceId);
1352 if (deleteServiceFilterEither.isRight()) {
1353 log.debug("enter deleteAbstractComponentInstance:deleteServiceFilterEither is right, filed");
1354 ActionStatus status = componentsUtils
1355 .convertFromStorageResponse(deleteServiceFilterEither.right().value(), containerComponentType);
1356 janusGraphDao.rollback();
1357 return Either.right(componentsUtils.getResponseFormat(status, componentInstance.getName()));
1359 Either<ComponentInstance, ResponseFormat> resultOp = deleteNodeFiltersFromComponentInstance(containerComponent, componentInstance,
1360 ComponentTypeEnum.SERVICE, userId);
1361 if (resultOp.isRight()) {
1362 log.debug("enter deleteAbstractComponentInstance:resultOp is right, filed");
1363 janusGraphDao.rollback();
1368 log.debug("enter deleteAbstractComponentInstance:");
1369 lockComponent(containerComponent, "deleteComponentInstance");
1370 ComponentInstance deletedCompInstance = deleteComponentInstance(containerComponent, componentInstanceId, containerComponentType);
1371 deletedRelatedInst = deleteForwardingPathsRelatedTobeDeletedComponentInstance(containerComponentId, containerComponentType,
1372 deletedCompInstance);
1373 ActionStatus onDeleteOperationsStatus = onChangeInstanceOperationOrchestrator
1374 .doOnDeleteInstanceOperations(containerComponent, componentInstanceId);
1375 log.debug("enter deleteAbstractComponentInstance,get onDeleteOperationsStatus:{}", onDeleteOperationsStatus);
1376 if (ActionStatus.OK != onDeleteOperationsStatus) {
1377 throw new ByActionStatusComponentException(onDeleteOperationsStatus);
1379 } catch (ComponentException e) {
1383 unlockComponent(failed, containerComponent);
1385 log.debug("enter deleteAbstractComponentInstance,deleted RelatedInst success");
1386 return Either.left(deletedRelatedInst);
1389 public Either<ComponentInstance, ResponseFormat> deleteNodeFiltersFromComponentInstance(final Component component,
1390 final ComponentInstance componentInstance,
1391 final ComponentTypeEnum containerComponentType,
1392 final String userId) {
1393 final Set<String> componentFiltersIDsToBeDeleted = getComponentFiltersRelatedToComponentInstance(component.getUniqueId(), componentInstance);
1394 if (!componentFiltersIDsToBeDeleted.isEmpty()) {
1395 final Set<String> ids = component.getComponentInstances().stream().filter(ci -> componentFiltersIDsToBeDeleted.contains(ci.getName()))
1396 .map(ComponentInstance::getUniqueId).collect(Collectors.toSet());
1397 final Either<Set<String>, StorageOperationStatus> deleteComponentNodeFiltersEither = nodeFilterOperation
1398 .deleteNodeFilters(component, ids);
1399 if (deleteComponentNodeFiltersEither.isRight()) {
1400 final ActionStatus status = componentsUtils
1401 .convertFromStorageResponse(deleteComponentNodeFiltersEither.right().value(), containerComponentType);
1402 return Either.right(componentsUtils.getResponseFormat(status, componentInstance.getName()));
1404 for (final String id : ids) {
1405 final Optional<ComponentInstance> componentInstanceById = component.getComponentInstanceById(id);
1406 if (!componentInstanceById.isPresent()) {
1407 return Either.right(componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR));
1409 final ComponentInstance componentInstanceToBeUpdated = componentInstanceById.get();
1410 componentInstanceToBeUpdated.setDirectives(Collections.emptyList());
1411 final Either<ComponentInstance, ResponseFormat> componentInstanceResponseFormatEither = updateComponentInstanceMetadata(
1412 containerComponentType.getValue(), component.getUniqueId(), componentInstanceToBeUpdated.getUniqueId(), userId,
1413 componentInstanceToBeUpdated, false);
1414 if (componentInstanceResponseFormatEither.isRight()) {
1415 return componentInstanceResponseFormatEither;
1419 return Either.left(componentInstance);
1422 private Set<String> getComponentFiltersRelatedToComponentInstance(String containerComponentId, ComponentInstance componentInstance) {
1423 ComponentParametersView filter = new ComponentParametersView(true);
1424 filter.setIgnoreComponentInstances(false);
1425 Either<Component, StorageOperationStatus> componentFilterOrigin = toscaOperationFacade.getToscaElement(containerComponentId, filter);
1426 final Component component = componentFilterOrigin.left().value();
1427 return ComponentsUtils.getNodesFiltersToBeDeleted(component, componentInstance);
1430 ComponentInstance deleteForwardingPathsRelatedTobeDeletedComponentInstance(String containerComponentId, ComponentTypeEnum containerComponentType,
1431 ComponentInstance componentInstance) {
1432 if (containerComponentType == ComponentTypeEnum.SERVICE) {
1433 List<String> pathIDsToBeDeleted = getForwardingPathsRelatedToComponentInstance(containerComponentId, componentInstance.getName());
1434 if (!pathIDsToBeDeleted.isEmpty()) {
1435 deleteForwardingPaths(containerComponentId, pathIDsToBeDeleted);
1438 return componentInstance;
1441 private void deleteForwardingPaths(String serviceId, List<String> pathIdsToDelete) {
1442 Either<Service, StorageOperationStatus> storageStatus = toscaOperationFacade.getToscaElement(serviceId);
1443 if (storageStatus.isRight()) {
1444 throw new ByActionStatusComponentException(componentsUtils.convertFromStorageResponse(storageStatus.right().value()));
1446 Either<Set<String>, StorageOperationStatus> result = forwardingPathOperation
1447 .deleteForwardingPath(storageStatus.left().value(), Sets.newHashSet(pathIdsToDelete));
1448 if (result.isRight()) {
1449 throw new ByActionStatusComponentException(componentsUtils.convertFromStorageResponse(result.right().value()));
1453 private List<String> getForwardingPathsRelatedToComponentInstance(String containerComponentId, String componentInstanceId) {
1454 Collection<ForwardingPathDataDefinition> allPaths = getForwardingPathDataDefinitions(containerComponentId);
1455 List<String> pathIDsToBeDeleted = new ArrayList<>();
1456 allPaths.stream().filter(path -> isPathRelatedToComponent(path, componentInstanceId))
1457 .forEach(path -> pathIDsToBeDeleted.add(path.getUniqueId()));
1458 return pathIDsToBeDeleted;
1461 private Collection<ForwardingPathDataDefinition> getForwardingPathDataDefinitions(String containerComponentId) {
1462 ComponentParametersView filter = new ComponentParametersView(true);
1463 filter.setIgnoreServicePath(false);
1464 Either<Service, StorageOperationStatus> forwardingPathOrigin = toscaOperationFacade.getToscaElement(containerComponentId, filter);
1465 return forwardingPathOrigin.left().value().getForwardingPaths().values();
1468 private boolean isPathRelatedToComponent(ForwardingPathDataDefinition pathDataDefinition, String componentInstanceId) {
1469 return pathDataDefinition.getPathElements().getListToscaDataDefinition().stream().anyMatch(
1470 elementDataDefinition -> elementDataDefinition.getFromNode().equalsIgnoreCase(componentInstanceId) || elementDataDefinition.getToNode()
1471 .equalsIgnoreCase(componentInstanceId));
1474 private ComponentInstance deleteComponentInstance(Component containerComponent, String componentInstanceId,
1475 ComponentTypeEnum containerComponentType) {
1476 Either<ImmutablePair<Component, String>, StorageOperationStatus> deleteRes = toscaOperationFacade
1477 .deleteComponentInstanceFromTopologyTemplate(containerComponent, componentInstanceId);
1478 if (deleteRes.isRight()) {
1479 log.debug("Failed to delete entry on graph for resourceInstance {}", componentInstanceId);
1480 ActionStatus status = componentsUtils.convertFromStorageResponse(deleteRes.right().value(), containerComponentType);
1481 throw new ByActionStatusComponentException(status, componentInstanceId);
1483 log.debug("The component instance {} has been removed from container component {}. ", componentInstanceId, containerComponent);
1484 ComponentInstance deletedInstance = findAndRemoveComponentInstanceFromContainerComponent(componentInstanceId, containerComponent);
1485 if (CollectionUtils.isNotEmpty(containerComponent.getInputs())) {
1486 List<InputDefinition> inputsToDelete = containerComponent.getInputs().stream()
1487 .filter(i -> i.getInstanceUniqueId() != null && i.getInstanceUniqueId().equals(componentInstanceId)).collect(Collectors.toList());
1488 if (CollectionUtils.isNotEmpty(inputsToDelete)) {
1489 StorageOperationStatus deleteInputsRes = toscaOperationFacade
1490 .deleteComponentInstanceInputsFromTopologyTemplate(containerComponent, inputsToDelete);
1491 if (deleteInputsRes != StorageOperationStatus.OK) {
1492 log.debug("Failed to delete inputs of the component instance {} from container component. ", componentInstanceId);
1493 throw new ByActionStatusComponentException(componentsUtils.convertFromStorageResponse(deleteInputsRes, containerComponentType),
1494 componentInstanceId);
1498 if (CollectionUtils.isNotEmpty(containerComponent.getOutputs())) {
1499 final List<OutputDefinition> outputsToDelete = containerComponent.getOutputs().stream()
1500 .filter(i -> i.getInstanceUniqueId() != null && i.getInstanceUniqueId().equals(componentInstanceId)).collect(Collectors.toList());
1501 if (CollectionUtils.isNotEmpty(outputsToDelete)) {
1502 final StorageOperationStatus deleteOutputsRes = toscaOperationFacade
1503 .deleteComponentInstanceOutputsFromTopologyTemplate(containerComponent, outputsToDelete);
1504 if (deleteOutputsRes != StorageOperationStatus.OK) {
1505 log.debug("Failed to delete outputs of the component instance {} from container component. ", componentInstanceId);
1506 throw new ByActionStatusComponentException(componentsUtils.convertFromStorageResponse(deleteOutputsRes, containerComponentType),
1507 componentInstanceId);
1511 return deletedInstance;
1514 private ComponentInstance findAndRemoveComponentInstanceFromContainerComponent(String componentInstanceId, Component containerComponent) {
1515 ComponentInstance foundInstance = null;
1516 for (ComponentInstance instance : containerComponent.getComponentInstances()) {
1517 if (instance.getUniqueId().equals(componentInstanceId)) {
1518 foundInstance = instance;
1519 containerComponent.getComponentInstances().remove(instance);
1523 findAndRemoveComponentInstanceRelations(componentInstanceId, containerComponent);
1524 return foundInstance;
1527 private void findAndRemoveComponentInstanceRelations(String componentInstanceId, Component containerComponent) {
1528 if (CollectionUtils.isNotEmpty(containerComponent.getComponentInstancesRelations())) {
1529 containerComponent.setComponentInstancesRelations(
1530 containerComponent.getComponentInstancesRelations().stream().filter(r -> isNotBelongingRelation(componentInstanceId, r))
1531 .collect(Collectors.toList()));
1535 private boolean isNotBelongingRelation(String componentInstanceId, RequirementCapabilityRelDef relation) {
1536 return !relation.getToNode().equals(componentInstanceId) && !relation.getFromNode().equals(componentInstanceId);
1539 public RequirementCapabilityRelDef associateRIToRI(String componentId, String userId, RequirementCapabilityRelDef requirementDef,
1540 ComponentTypeEnum componentTypeEnum) {
1541 return associateRIToRI(componentId, userId, requirementDef, componentTypeEnum, true);
1544 public RequirementCapabilityRelDef associateRIToRI(String componentId, String userId, RequirementCapabilityRelDef requirementDef,
1545 ComponentTypeEnum componentTypeEnum, boolean needLock) {
1546 validateUserExists(userId);
1547 RequirementCapabilityRelDef requirementCapabilityRelDef;
1548 org.openecomp.sdc.be.model.Component containerComponent = validateComponentExists(componentId, componentTypeEnum, null);
1549 validateCanWorkOnComponent(containerComponent, userId);
1550 boolean failed = false;
1553 lockComponent(containerComponent, ASSOCIATE_RI_TO_RI);
1555 requirementCapabilityRelDef = associateRIToRIOnGraph(containerComponent, requirementDef);
1556 } catch (ComponentException e) {
1561 unlockComponent(failed, containerComponent);
1564 return requirementCapabilityRelDef;
1567 public RequirementCapabilityRelDef associateRIToRIOnGraph(Component containerComponent, RequirementCapabilityRelDef requirementDef) {
1568 log.debug(TRY_TO_CREATE_ENTRY_ON_GRAPH);
1569 Either<RequirementCapabilityRelDef, StorageOperationStatus> result = toscaOperationFacade
1570 .associateResourceInstances(null, containerComponent.getUniqueId(), requirementDef);
1571 if (result.isLeft()) {
1572 log.debug(ENTITY_ON_GRAPH_IS_CREATED);
1573 return result.left().value();
1575 log.debug("Failed to associate node: {} with node {}", requirementDef.getFromNode(), requirementDef.getToNode());
1576 String fromNameOrId = "";
1577 String toNameOrId = "";
1578 Either<ComponentInstance, StorageOperationStatus> fromResult = getResourceInstanceById(containerComponent, requirementDef.getFromNode());
1579 Either<ComponentInstance, StorageOperationStatus> toResult = getResourceInstanceById(containerComponent, requirementDef.getToNode());
1580 toNameOrId = requirementDef.getFromNode();
1581 fromNameOrId = requirementDef.getFromNode();
1582 if (fromResult.isLeft()) {
1583 fromNameOrId = fromResult.left().value().getName();
1585 if (toResult.isLeft()) {
1586 toNameOrId = toResult.left().value().getName();
1588 throw new ByActionStatusComponentException(componentsUtils.convertFromStorageResponseForResourceInstance(result.right().value(), true),
1589 fromNameOrId, toNameOrId, requirementDef.getRelationships().get(0).getRelation().getRequirement());
1594 * @param componentId
1596 * @param requirementDefList
1597 * @param componentTypeEnum
1600 public List<RequirementCapabilityRelDef> batchDissociateRIFromRI(String componentId, String userId,
1601 List<RequirementCapabilityRelDef> requirementDefList,
1602 ComponentTypeEnum componentTypeEnum) {
1603 validateUserExists(userId);
1604 org.openecomp.sdc.be.model.Component containerComponent = validateComponentExists(componentId, componentTypeEnum, null);
1605 validateCanWorkOnComponent(containerComponent, userId);
1606 boolean failed = false;
1607 List<RequirementCapabilityRelDef> delOkResult = new ArrayList<>();
1609 lockComponent(containerComponent, ASSOCIATE_RI_TO_RI);
1610 for (RequirementCapabilityRelDef requirementDef : requirementDefList) {
1611 RequirementCapabilityRelDef requirementCapabilityRelDef = dissociateRIFromRI(componentId, userId, requirementDef,
1612 containerComponent.getComponentType());
1613 delOkResult.add(requirementCapabilityRelDef);
1615 } catch (ComponentException e) {
1619 unlockComponent(failed, containerComponent);
1624 public RequirementCapabilityRelDef dissociateRIFromRI(String componentId, String userId, RequirementCapabilityRelDef requirementDef,
1625 ComponentTypeEnum componentTypeEnum) {
1626 validateUserExists(userId);
1627 org.openecomp.sdc.be.model.Component containerComponent = validateComponentExists(componentId, componentTypeEnum, null);
1628 validateCanWorkOnComponent(containerComponent, userId);
1629 boolean failed = false;
1631 lockComponent(containerComponent, ASSOCIATE_RI_TO_RI);
1632 log.debug(TRY_TO_CREATE_ENTRY_ON_GRAPH);
1633 Either<RequirementCapabilityRelDef, StorageOperationStatus> result = toscaOperationFacade
1634 .dissociateResourceInstances(componentId, requirementDef);
1635 if (result.isLeft()) {
1636 log.debug(ENTITY_ON_GRAPH_IS_CREATED);
1637 return result.left().value();
1639 log.debug("Failed to dissocaite node {} from node {}", requirementDef.getFromNode(), requirementDef.getToNode());
1640 String fromNameOrId = "";
1641 String toNameOrId = "";
1642 Either<ComponentInstance, StorageOperationStatus> fromResult = getResourceInstanceById(containerComponent,
1643 requirementDef.getFromNode());
1644 Either<ComponentInstance, StorageOperationStatus> toResult = getResourceInstanceById(containerComponent, requirementDef.getToNode());
1645 toNameOrId = requirementDef.getFromNode();
1646 fromNameOrId = requirementDef.getFromNode();
1647 if (fromResult.isLeft()) {
1648 fromNameOrId = fromResult.left().value().getName();
1650 if (toResult.isLeft()) {
1651 toNameOrId = toResult.left().value().getName();
1653 throw new ByActionStatusComponentException(
1654 componentsUtils.convertFromStorageResponseForResourceInstance(result.right().value(), true), fromNameOrId, toNameOrId,
1655 requirementDef.getRelationships().get(0).getRelation().getRequirement());
1657 } catch (ComponentException e) {
1661 unlockComponent(failed, containerComponent);
1666 * Allows to get relation contained in specified component according to received Id
1668 * @param componentId
1671 * @param componentTypeEnum
1674 public Either<RequirementCapabilityRelDef, ResponseFormat> getRelationById(String componentId, String relationId, String userId,
1675 ComponentTypeEnum componentTypeEnum) {
1676 Either<RequirementCapabilityRelDef, ResponseFormat> resultOp = null;
1678 org.openecomp.sdc.be.model.Component containerComponent = null;
1679 RequirementCapabilityRelDef foundRelation = null;
1680 validateUserExists(userId);
1681 containerComponent = validateComponentExists(componentId, componentTypeEnum, null);
1682 List<RequirementCapabilityRelDef> requirementCapabilityRelations = containerComponent.getComponentInstancesRelations();
1683 foundRelation = findRelation(relationId, requirementCapabilityRelations);
1684 if (foundRelation == null) {
1685 ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.RELATION_NOT_FOUND, relationId, componentId);
1686 log.debug("Relation with id {} was not found on the component", relationId, componentId);
1687 resultOp = Either.right(responseFormat);
1689 if (resultOp == null) {
1690 resultOp = setRelatedCapability(foundRelation, containerComponent);
1692 if (resultOp.isLeft()) {
1693 resultOp = setRelatedRequirement(foundRelation, containerComponent);
1695 } catch (Exception e) {
1696 log.error("The exception {} occured upon get relation {} of the component {} ", e, relationId, componentId);
1697 resultOp = Either.right(componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR));
1702 private RequirementCapabilityRelDef findRelation(String relationId, List<RequirementCapabilityRelDef> requirementCapabilityRelations) {
1703 for (RequirementCapabilityRelDef relationship : requirementCapabilityRelations) {
1704 if (relationship.getRelationships().stream().anyMatch(r -> r.getRelation().getId().equals(relationId))) {
1705 return relationship;
1711 private Either<RequirementCapabilityRelDef, ResponseFormat> setRelatedRequirement(RequirementCapabilityRelDef foundRelation,
1712 Component containerComponent) {
1713 Either<RequirementCapabilityRelDef, ResponseFormat> result = null;
1714 RelationshipInfo relationshipInfo = foundRelation.resolveSingleRelationship().getRelation();
1715 String instanceId = foundRelation.getFromNode();
1716 Optional<RequirementDefinition> foundRequirement;
1717 Optional<ComponentInstance> instance = containerComponent.getComponentInstances().stream().filter(i -> i.getUniqueId().equals(instanceId))
1719 if (!instance.isPresent()) {
1720 ResponseFormat responseFormat = componentsUtils
1721 .getResponseFormat(ActionStatus.COMPONENT_INSTANCE_NOT_FOUND_ON_CONTAINER, instanceId, "instance",
1722 containerComponent.getComponentType().getValue(), containerComponent.getName());
1723 log.debug("Component instance with id {} was not found on the component", instanceId, containerComponent.getUniqueId());
1724 result = Either.right(responseFormat);
1726 if (result == null && instance.isPresent()) {
1727 for (List<RequirementDefinition> requirements : instance.get().getRequirements().values()) {
1728 foundRequirement = requirements.stream()
1729 .filter(r -> isBelongingCalcRequirement(relationshipInfo, r, containerComponent.getLifecycleState())).findFirst();
1730 if (foundRequirement.isPresent()) {
1731 foundRelation.resolveSingleRelationship().setRequirement(foundRequirement.get());
1732 result = Either.left(foundRelation);
1736 if (result == null) {
1737 Either<RequirementDataDefinition, StorageOperationStatus> getfulfilledRequirementRes = toscaOperationFacade
1738 .getFulfilledRequirementByRelation(containerComponent.getUniqueId(), instanceId, foundRelation, this::isBelongingFullRequirement);
1739 if (getfulfilledRequirementRes.isRight()) {
1740 ResponseFormat responseFormat = componentsUtils
1741 .getResponseFormat(ActionStatus.REQUIREMENT_OF_INSTANCE_NOT_FOUND_ON_CONTAINER, relationshipInfo.getRequirement(), instanceId,
1742 containerComponent.getUniqueId());
1743 log.debug("Requirement {} of instance {} was not found on the container {}. ", relationshipInfo.getCapability(), instanceId,
1744 containerComponent.getUniqueId());
1745 result = Either.right(responseFormat);
1747 foundRelation.resolveSingleRelationship().setRequirement(getfulfilledRequirementRes.left().value());
1750 if (result == null) {
1751 result = Either.left(foundRelation);
1756 private boolean isBelongingFullRequirement(RelationshipInfo relationshipInfo, RequirementDataDefinition req) {
1757 return req.getName().equals(relationshipInfo.getRequirement()) && req.getUniqueId().equals(relationshipInfo.getRequirementUid()) && req
1758 .getOwnerId().equals(relationshipInfo.getRequirementOwnerId());
1761 private boolean isBelongingCalcRequirement(RelationshipInfo relationshipInfo, RequirementDataDefinition req, LifecycleStateEnum state) {
1762 return nameMatches(relationshipInfo.getRequirement(), req.getName(), req.getPreviousName(), state) && req.getUniqueId()
1763 .equals(relationshipInfo.getRequirementUid()) && req.getOwnerId().equals(relationshipInfo.getRequirementOwnerId());
1766 private Either<RequirementCapabilityRelDef, ResponseFormat> setRelatedCapability(RequirementCapabilityRelDef foundRelation,
1767 Component containerComponent) {
1768 Either<RequirementCapabilityRelDef, ResponseFormat> result = null;
1769 RelationshipInfo relationshipInfo = foundRelation.resolveSingleRelationship().getRelation();
1770 String instanceId = foundRelation.getToNode();
1771 Optional<CapabilityDefinition> foundCapability;
1772 Optional<ComponentInstance> instance = containerComponent.getComponentInstances().stream().filter(i -> i.getUniqueId().equals(instanceId))
1774 if (!instance.isPresent()) {
1775 ResponseFormat responseFormat = componentsUtils
1776 .getResponseFormat(ActionStatus.COMPONENT_INSTANCE_NOT_FOUND_ON_CONTAINER, instanceId, "instance",
1777 containerComponent.getComponentType().getValue(), containerComponent.getName());
1778 log.debug("Component instance with id {} was not found on the component", instanceId, containerComponent.getUniqueId());
1779 result = Either.right(responseFormat);
1781 if (result == null && instance.isPresent()) {
1782 for (List<CapabilityDefinition> capabilities : instance.get().getCapabilities().values()) {
1783 foundCapability = capabilities.stream()
1784 .filter(c -> isBelongingCalcCapability(relationshipInfo, c, containerComponent.getLifecycleState())).findFirst();
1785 if (foundCapability.isPresent()) {
1786 foundRelation.resolveSingleRelationship().setCapability(foundCapability.get());
1787 result = Either.left(foundRelation);
1791 if (result == null) {
1792 Either<CapabilityDataDefinition, StorageOperationStatus> getfulfilledRequirementRes = toscaOperationFacade
1793 .getFulfilledCapabilityByRelation(containerComponent.getUniqueId(), instanceId, foundRelation, this::isBelongingFullCapability);
1794 if (getfulfilledRequirementRes.isRight()) {
1795 ResponseFormat responseFormat = componentsUtils
1796 .getResponseFormat(ActionStatus.CAPABILITY_OF_INSTANCE_NOT_FOUND_ON_CONTAINER, relationshipInfo.getCapability(), instanceId,
1797 containerComponent.getUniqueId());
1798 log.debug("Capability {} of instance {} was not found on the container {}. ", relationshipInfo.getCapability(), instanceId,
1799 containerComponent.getUniqueId());
1800 result = Either.right(responseFormat);
1802 foundRelation.resolveSingleRelationship().setCapability(getfulfilledRequirementRes.left().value());
1805 if (result == null) {
1806 result = Either.left(foundRelation);
1811 private boolean isBelongingFullCapability(RelationshipInfo relationshipInfo, CapabilityDataDefinition cap) {
1812 return cap.getName().equals(relationshipInfo.getCapability()) && cap.getUniqueId().equals(relationshipInfo.getCapabilityUid()) && cap
1813 .getOwnerId().equals(relationshipInfo.getCapabilityOwnerId());
1816 private boolean isBelongingCalcCapability(RelationshipInfo relationshipInfo, CapabilityDataDefinition cap, LifecycleStateEnum state) {
1817 return nameMatches(relationshipInfo.getCapability(), cap.getName(), cap.getPreviousName(), state) && cap.getUniqueId()
1818 .equals(relationshipInfo.getCapabilityUid()) && cap.getOwnerId().equals(relationshipInfo.getCapabilityOwnerId());
1821 private boolean nameMatches(String nameFromRelationship, String currName, String previousName, LifecycleStateEnum state) {
1822 return state == LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT ? currName.equals(nameFromRelationship)
1823 : previousName != null && previousName.equals(nameFromRelationship);
1826 private Either<ComponentInstanceProperty, ResponseFormat> updateAttributeValue(ComponentInstanceProperty attribute, String resourceInstanceId) {
1827 Either<ComponentInstanceProperty, StorageOperationStatus> eitherAttribute = componentInstanceOperation
1828 .updateAttributeValueInResourceInstance(attribute, resourceInstanceId, true);
1829 Either<ComponentInstanceProperty, ResponseFormat> result;
1830 if (eitherAttribute.isLeft()) {
1831 log.debug("Attribute value {} was updated on graph.", attribute.getValueUniqueUid());
1832 ComponentInstanceProperty instanceAttribute = eitherAttribute.left().value();
1833 result = Either.left(instanceAttribute);
1835 log.debug("Failed to update attribute value {} in resource instance {}", attribute, resourceInstanceId);
1836 ActionStatus actionStatus = componentsUtils.convertFromStorageResponseForResourceInstanceProperty(eitherAttribute.right().value());
1837 result = Either.right(componentsUtils.getResponseFormat(actionStatus, ""));
1842 private Either<ComponentInstanceProperty, ResponseFormat> createAttributeValue(ComponentInstanceProperty attribute, String resourceInstanceId) {
1843 Either<ComponentInstanceProperty, ResponseFormat> result;
1844 Wrapper<Integer> indexCounterWrapper = new Wrapper<>();
1845 Wrapper<ResponseFormat> errorWrapper = new Wrapper<>();
1846 validateIncrementCounter(resourceInstanceId, GraphPropertiesDictionary.ATTRIBUTE_COUNTER, indexCounterWrapper, errorWrapper);
1847 if (!errorWrapper.isEmpty()) {
1848 result = Either.right(errorWrapper.getInnerElement());
1850 Either<ComponentInstanceProperty, StorageOperationStatus> eitherAttribute = componentInstanceOperation
1851 .addAttributeValueToResourceInstance(attribute, resourceInstanceId, indexCounterWrapper.getInnerElement(), true);
1852 if (eitherAttribute.isLeft()) {
1853 log.debug("Attribute value was added to resource instance {}", resourceInstanceId);
1854 ComponentInstanceProperty instanceAttribute = eitherAttribute.left().value();
1855 result = Either.left(instanceAttribute);
1857 log.debug("Failed to add attribute value {} to resource instance {}", attribute, resourceInstanceId);
1858 ActionStatus actionStatus = componentsUtils.convertFromStorageResponseForResourceInstanceProperty(eitherAttribute.right().value());
1859 result = Either.right(componentsUtils.getResponseFormatForResourceInstanceProperty(actionStatus, ""));
1866 * Create Or Updates Attribute Instance
1868 * @param componentTypeEnum
1869 * @param componentId
1870 * @param resourceInstanceId
1875 public Either<ComponentInstanceProperty, ResponseFormat> createOrUpdateAttributeValue(ComponentTypeEnum componentTypeEnum, String componentId,
1876 String resourceInstanceId,
1877 ComponentInstanceProperty attribute, String userId) {
1878 Either<ComponentInstanceProperty, ResponseFormat> result = null;
1879 Wrapper<ResponseFormat> errorWrapper = new Wrapper<>();
1880 validateUserExists(userId);
1881 if (errorWrapper.isEmpty()) {
1882 validateComponentTypeEnum(componentTypeEnum, "CreateOrUpdateAttributeValue", errorWrapper);
1884 if (errorWrapper.isEmpty()) {
1885 validateCanWorkOnComponent(componentId, componentTypeEnum, userId, errorWrapper);
1887 if (errorWrapper.isEmpty()) {
1888 validateComponentLock(componentId, componentTypeEnum, errorWrapper);
1891 if (errorWrapper.isEmpty()) {
1892 final boolean isCreate = Objects.isNull(attribute.getValueUniqueUid());
1894 result = createAttributeValue(attribute, resourceInstanceId);
1896 result = updateAttributeValue(attribute, resourceInstanceId);
1899 result = Either.right(errorWrapper.getInnerElement());
1903 if (result == null || result.isRight()) {
1904 janusGraphDao.rollback();
1906 janusGraphDao.commit();
1909 graphLockOperation.unlockComponent(componentId, componentTypeEnum.getNodeType());
1913 public Either<List<ComponentInstanceProperty>, ResponseFormat> createOrUpdatePropertiesValues(ComponentTypeEnum componentTypeEnum,
1914 String componentId, String resourceInstanceId,
1915 List<ComponentInstanceProperty> properties,
1917 Either<List<ComponentInstanceProperty>, ResponseFormat> resultOp = null;
1918 /*-------------------------------Validations---------------------------------*/
1919 validateUserExists(userId);
1921 if (componentTypeEnum == null) {
1922 BeEcompErrorManager.getInstance().logInvalidInputError("CreateOrUpdatePropertiesValues", INVALID_COMPONENT_TYPE, ErrorSeverity.INFO);
1923 resultOp = Either.right(componentsUtils.getResponseFormat(ActionStatus.NOT_ALLOWED));
1926 Either<Component, StorageOperationStatus> getResourceResult = toscaOperationFacade.getToscaElement(componentId, JsonParseFlagEnum.ParseAll);
1928 if (getResourceResult.isRight()) {
1929 log.debug(FAILED_TO_RETRIEVE_COMPONENT_COMPONENT_ID, componentId);
1930 ActionStatus actionStatus = componentsUtils.convertFromStorageResponse(getResourceResult.right().value(), componentTypeEnum);
1931 return Either.right(componentsUtils.getResponseFormat(actionStatus, componentId));
1933 Component containerComponent = getResourceResult.left().value();
1935 if (!ComponentValidationUtils.canWorkOnComponent(containerComponent, userId)) {
1936 if (Boolean.TRUE.equals(containerComponent.isArchived())) {
1937 log.info(COMPONENT_ARCHIVED, componentId);
1938 return Either.right(componentsUtils.getResponseFormat(ActionStatus.COMPONENT_IS_ARCHIVED, containerComponent.getName()));
1940 log.info(RESTRICTED_OPERATION_ON_SERVIVE, userId, componentId);
1941 return Either.right(componentsUtils.getResponseFormat(ActionStatus.RESTRICTED_OPERATION));
1944 Either<ComponentInstance, StorageOperationStatus> resourceInstanceStatus = getResourceInstanceById(containerComponent, resourceInstanceId);
1945 if (resourceInstanceStatus.isRight()) {
1946 return Either.right(componentsUtils.getResponseFormat(ActionStatus.COMPONENT_INSTANCE_NOT_FOUND_ON_CONTAINER,
1947 resourceInstanceId, RESOURCE_INSTANCE, SERVICE, componentId));
1949 ComponentInstance foundResourceInstance = resourceInstanceStatus.left().value();
1952 StorageOperationStatus lockStatus = graphLockOperation.lockComponent(componentId, componentTypeEnum.getNodeType());
1953 if (lockStatus != StorageOperationStatus.OK) {
1954 log.debug(FAILED_TO_LOCK_SERVICE, componentId);
1955 return Either.right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(lockStatus)));
1957 List<ComponentInstanceProperty> updatedProperties = new ArrayList<>();
1959 for (ComponentInstanceProperty property : properties) {
1960 validateMandatoryFields(property);
1961 validatePropertyExistsOnComponent(property, containerComponent, foundResourceInstance);
1962 String propertyParentUniqueId = property.getParentUniqueId();
1963 if (property.isGetFunction()) {
1964 validateToscaGetFunction(property, containerComponent);
1965 property.setValue(property.getToscaGetFunction().generatePropertyValue());
1967 Either<String, ResponseFormat> updatedPropertyValue = updatePropertyObjectValue(property, containerComponent.getModel());
1968 if (updatedPropertyValue.isRight()) {
1969 log.error("Failed to update property object value of property: {}",
1971 throw new ByResponseFormatComponentException(updatedPropertyValue.right().value());
1973 Optional<CapabilityDefinition>
1974 capPropDefinition = getPropertyCapabilityOfChildInstance(propertyParentUniqueId, foundResourceInstance.getCapabilities());
1975 if (capPropDefinition.isPresent()) {
1976 updatedPropertyValue
1977 .bimap(updatedValue -> updateCapabilityPropFromUpdateInstProp(property, updatedValue,
1978 containerComponent, foundResourceInstance, capPropDefinition.get().getType(),
1979 capPropDefinition.get().getName()), Either::right);
1981 updatedPropertyValue.bimap(
1982 updatedValue -> updatePropertyOnContainerComponent(property, updatedValue, containerComponent, foundResourceInstance),
1985 updatedProperties.add(property);
1989 Either<Component, StorageOperationStatus> updateContainerRes = toscaOperationFacade
1990 .updateComponentInstanceMetadataOfTopologyTemplate(containerComponent);
1991 if (updateContainerRes.isRight()) {
1992 ActionStatus actionStatus = componentsUtils.convertFromStorageResponseForResourceInstanceProperty(updateContainerRes.right().value());
1993 resultOp = Either.right(componentsUtils.getResponseFormatForResourceInstanceProperty(actionStatus, ""));
1996 resultOp = Either.left(updatedProperties);
1999 } catch (final ComponentException e) {
2000 return Either.right(e.getResponseFormat());
2002 if (resultOp == null || resultOp.isRight()) {
2003 janusGraphDao.rollback();
2005 janusGraphDao.commit();
2008 graphLockOperation.unlockComponent(componentId, componentTypeEnum.getNodeType());
2012 public Either<List<ComponentInstanceAttribute>, ResponseFormat> createOrUpdateAttributeValues(final ComponentTypeEnum componentTypeEnum,
2013 final String componentId,
2014 final String resourceInstanceId,
2015 final List<ComponentInstanceAttribute> attributes,
2016 final String userId) {
2017 Either<List<ComponentInstanceAttribute>, ResponseFormat> resultOp = null;
2018 /*-------------------------------Validations---------------------------------*/
2019 validateUserExists(userId);
2021 if (componentTypeEnum == null) {
2022 BeEcompErrorManager.getInstance().logInvalidInputError("CreateOrUpdatePropertiesValues", INVALID_COMPONENT_TYPE, ErrorSeverity.INFO);
2023 resultOp = Either.right(componentsUtils.getResponseFormat(ActionStatus.NOT_ALLOWED));
2026 final Either<Component, StorageOperationStatus> getResourceResult = toscaOperationFacade
2027 .getToscaElement(componentId, JsonParseFlagEnum.ParseAll);
2029 if (getResourceResult.isRight()) {
2030 log.debug(FAILED_TO_RETRIEVE_COMPONENT_COMPONENT_ID, componentId);
2031 final ActionStatus actionStatus = componentsUtils.convertFromStorageResponse(getResourceResult.right().value(), componentTypeEnum);
2032 return Either.right(componentsUtils.getResponseFormat(actionStatus, componentId));
2034 final Component containerComponent = getResourceResult.left().value();
2036 if (!ComponentValidationUtils.canWorkOnComponent(containerComponent, userId)) {
2037 if (Boolean.TRUE.equals(containerComponent.isArchived())) {
2038 log.info(COMPONENT_ARCHIVED, componentId);
2039 return Either.right(componentsUtils.getResponseFormat(ActionStatus.COMPONENT_IS_ARCHIVED, containerComponent.getName()));
2041 log.info(RESTRICTED_OPERATION_ON_SERVIVE, userId, componentId);
2042 return Either.right(componentsUtils.getResponseFormat(ActionStatus.RESTRICTED_OPERATION));
2045 final Either<ComponentInstance, StorageOperationStatus> resourceInstanceStatus = getResourceInstanceById(containerComponent,
2046 resourceInstanceId);
2047 if (resourceInstanceStatus.isRight()) {
2048 return Either.right(componentsUtils.getResponseFormat(ActionStatus.COMPONENT_INSTANCE_NOT_FOUND_ON_CONTAINER,
2049 resourceInstanceId, RESOURCE_INSTANCE, SERVICE, componentId));
2051 final ComponentInstance foundResourceInstance = resourceInstanceStatus.left().value();
2054 final StorageOperationStatus lockStatus = graphLockOperation.lockComponent(componentId, componentTypeEnum.getNodeType());
2055 if (lockStatus != StorageOperationStatus.OK) {
2056 log.debug(FAILED_TO_LOCK_SERVICE, componentId);
2057 return Either.right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(lockStatus)));
2059 final List<ComponentInstanceAttribute> updatedProperties = new ArrayList<>();
2061 for (final ComponentInstanceAttribute attribute : attributes) {
2062 final ComponentInstanceAttribute componentInstanceProperty = validateAttributeExistsOnComponent(attribute, containerComponent,
2063 foundResourceInstance);
2064 final Either<String, ResponseFormat> updatedPropertyValue = updateAttributeObjectValue(attribute);
2065 if (updatedPropertyValue.isRight()) {
2066 log.error("Failed to update attribute object value of attribute: {}", attribute);
2067 throw new ByResponseFormatComponentException(updatedPropertyValue.right().value());
2069 updatedPropertyValue.bimap(
2071 componentInstanceProperty.setValue(updatedValue);
2072 return updateAttributeOnContainerComponent(attribute, updatedValue,
2073 containerComponent, foundResourceInstance);
2075 updatedProperties.add(componentInstanceProperty);
2078 final Either<Component, StorageOperationStatus> updateContainerRes = toscaOperationFacade
2079 .updateComponentInstanceMetadataOfTopologyTemplate(containerComponent);
2080 if (updateContainerRes.isRight()) {
2081 final ActionStatus actionStatus = componentsUtils
2082 .convertFromStorageResponseForResourceInstanceProperty(updateContainerRes.right().value());
2083 resultOp = Either.right(componentsUtils.getResponseFormatForResourceInstanceProperty(actionStatus, ""));
2086 resultOp = Either.left(updatedProperties);
2089 } catch (final ComponentException e) {
2090 return Either.right(e.getResponseFormat());
2092 if (resultOp == null || resultOp.isRight()) {
2093 janusGraphDao.rollback();
2095 janusGraphDao.commit();
2098 graphLockOperation.unlockComponent(componentId, componentTypeEnum.getNodeType());
2102 private void validateMandatoryFields(PropertyDataDefinition property) {
2103 if (StringUtils.isEmpty(property.getName())) {
2104 throw new ByActionStatusComponentException(ActionStatus.MISSING_PROPERTY_NAME);
2108 private void validatePropertyExistsOnComponent(ComponentInstanceProperty property, Component containerComponent,
2109 ComponentInstance foundResourceInstance) {
2110 List<ComponentInstanceProperty> instanceProperties = containerComponent.getComponentInstancesProperties()
2111 .get(foundResourceInstance.getUniqueId());
2112 final boolean hasProperty = instanceProperties.stream().anyMatch(p -> p.getName().equals(property.getName()));
2114 throw new ByActionStatusComponentException(ActionStatus.PROPERTY_NOT_FOUND, property.getName());
2118 private ComponentInstanceAttribute validateAttributeExistsOnComponent(final ComponentInstanceAttribute attribute,
2119 final Component containerComponent,
2120 final ComponentInstance foundResourceInstance) {
2121 final List<ComponentInstanceAttribute> instanceProperties =
2122 containerComponent.getComponentInstancesAttributes().get(foundResourceInstance.getUniqueId());
2123 final Optional<ComponentInstanceAttribute> instanceAttribute =
2124 instanceProperties.stream().filter(p -> p.getName().equals(attribute.getName())).findAny();
2125 if (!instanceAttribute.isPresent()) {
2126 throw new ByActionStatusComponentException(ActionStatus.PROPERTY_NOT_FOUND, attribute.getName());
2128 return instanceAttribute.get();
2131 private ResponseFormat updateCapabilityPropertyOnContainerComponent(ComponentInstanceProperty property,
2132 String newValue, Component containerComponent,
2133 ComponentInstance foundResourceInstance,
2134 String capabilityType, String capabilityName) {
2135 String componentInstanceUniqueId = foundResourceInstance.getUniqueId();
2136 ResponseFormat actionStatus = updateCapPropOnContainerComponent(property, newValue, containerComponent,
2137 foundResourceInstance, capabilityType, capabilityName, componentInstanceUniqueId);
2138 if (actionStatus != null) {
2139 return actionStatus;
2142 return componentsUtils.getResponseFormat(ActionStatus.OK);
2145 private ResponseFormat updateCapabilityPropFromUpdateInstProp(ComponentInstanceProperty property,
2146 String newValue, Component containerComponent,
2147 ComponentInstance foundResourceInstance,
2148 String capabilityType, String capabilityName) {
2149 String componentInstanceUniqueId = foundResourceInstance.getUniqueId();
2150 Either<Component, StorageOperationStatus> getComponentRes =
2151 toscaOperationFacade.getToscaFullElement(foundResourceInstance.getComponentUid());
2152 if (getComponentRes.isRight()) {
2153 return componentsUtils.getResponseFormat(getComponentRes.right().value());
2156 ResponseFormat actionStatus = updateCapPropOnContainerComponent(property, newValue, containerComponent,
2157 foundResourceInstance, capabilityType, capabilityName, componentInstanceUniqueId);
2158 if (actionStatus != null) {
2159 return actionStatus;
2162 return componentsUtils.getResponseFormat(ActionStatus.OK);
2165 private ResponseFormat updateCapPropOnContainerComponent(ComponentInstanceProperty property, String newValue,
2166 Component containerComponent,
2167 ComponentInstance foundResourceInstance,
2168 String capabilityType, String capabilityName,
2169 String componentInstanceUniqueId) {
2170 Map<String, List<CapabilityDefinition>> capabilities =
2171 Optional.ofNullable(foundResourceInstance.getCapabilities()).orElse(Collections.emptyMap());
2172 List<CapabilityDefinition> capPerType =
2173 Optional.ofNullable(capabilities.get(capabilityType)).orElse(Collections.emptyList());
2174 Optional<CapabilityDefinition> cap =
2175 capPerType.stream().filter(c -> c.getName().equals(capabilityName)).findAny();
2176 if (cap.isPresent()) {
2177 List<ComponentInstanceProperty> capProperties = cap.get().getProperties();
2178 if (capProperties != null) {
2179 Optional<ComponentInstanceProperty> instanceProperty =
2180 capProperties.stream().filter(p -> p.getUniqueId().equals(property.getUniqueId())).findAny();
2181 StorageOperationStatus status;
2182 if (instanceProperty.isPresent()) {
2183 String capKey = ModelConverter
2184 .buildCapabilityPropertyKey(foundResourceInstance.getOriginType().isAtomicType(), capabilityType, capabilityName,
2185 componentInstanceUniqueId, cap.get());
2186 instanceProperty.get().setValue(newValue);
2187 List<String> path = new ArrayList<>();
2188 path.add(componentInstanceUniqueId);
2190 instanceProperty.get().setPath(path);
2191 status = toscaOperationFacade.updateComponentInstanceCapabiltyProperty(containerComponent,
2192 componentInstanceUniqueId, capKey, instanceProperty.get());
2193 if (status != StorageOperationStatus.OK) {
2194 ActionStatus actionStatus =
2195 componentsUtils.convertFromStorageResponseForResourceInstanceProperty(status);
2196 return componentsUtils.getResponseFormatForResourceInstanceProperty(actionStatus, "");
2199 foundResourceInstance.setCustomizationUUID(UUID.randomUUID().toString());
2206 private ResponseFormat updatePropertyOnContainerComponent(ComponentInstanceProperty instanceProperty, String newValue,
2207 Component containerComponent, ComponentInstance foundResourceInstance) {
2208 StorageOperationStatus status;
2209 instanceProperty.setValue(newValue);
2210 status = toscaOperationFacade.updateComponentInstanceProperty(containerComponent, foundResourceInstance.getUniqueId(), instanceProperty);
2211 if (status != StorageOperationStatus.OK) {
2212 ActionStatus actionStatus = componentsUtils.convertFromStorageResponseForResourceInstanceProperty(status);
2213 return componentsUtils.getResponseFormatForResourceInstanceProperty(actionStatus, "");
2215 foundResourceInstance.setCustomizationUUID(UUID.randomUUID().toString());
2216 return componentsUtils.getResponseFormat(ActionStatus.OK);
2219 private ResponseFormat updateAttributeOnContainerComponent(final ComponentInstanceAttribute instanceAttribute,
2220 final String newValue,
2221 final Component containerComponent,
2222 final ComponentInstance foundResourceInstance) {
2224 instanceAttribute.setValue(newValue);
2225 final StorageOperationStatus status =
2226 toscaOperationFacade.updateComponentInstanceAttribute(containerComponent, foundResourceInstance.getUniqueId(), instanceAttribute);
2227 if (status != StorageOperationStatus.OK) {
2228 final ActionStatus actionStatus = componentsUtils.convertFromStorageResponseForResourceInstanceProperty(status);
2229 return componentsUtils.getResponseFormatForResourceInstanceProperty(actionStatus, "");
2231 foundResourceInstance.setCustomizationUUID(UUID.randomUUID().toString());
2232 return componentsUtils.getResponseFormat(ActionStatus.OK);
2235 private <T extends PropertyDefinition> Either<String, ResponseFormat> validatePropertyObjectValue(T property, String newValue, boolean isInput) {
2236 final Map<String, DataTypeDefinition> allDataTypes = componentsUtils.getAllDataTypes(applicationDataTypeCache, property.getModel());
2237 String propertyType = property.getType();
2238 String innerType = getInnerType(property);
2240 // Specific Update Logic
2241 Either<Object, Boolean> isValid = propertyOperation
2242 .validateAndUpdatePropertyValue(property.getType(), newValue, true, innerType, allDataTypes);
2243 if (isValid.isRight()) {
2244 if (!Boolean.TRUE.equals(isValid.right().value())) {
2245 log.error("Invalid value {} of property {} ", newValue, property.getName());
2246 return Either.right(componentsUtils.getResponseFormat(ActionStatus.INVALID_CONTENT));
2249 Object object = isValid.left().value();
2250 if (object != null) {
2251 newValue = object.toString();
2254 if (validateAndUpdateRules(property, isInput, allDataTypes, innerType, propertyType)) {
2255 return Either.right(componentsUtils.getResponseFormat(componentsUtils
2256 .convertFromStorageResponse(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(JanusGraphOperationStatus.ILLEGAL_ARGUMENT))));
2258 return Either.left(newValue);
2261 private <T extends PropertyDefinition> boolean validateAndUpdateRules(T property, boolean isInput, Map<String, DataTypeDefinition> allDataTypes,
2262 String innerType, String propertyType) {
2264 ImmutablePair<String, Boolean> pair = propertyOperation
2265 .validateAndUpdateRules(propertyType, ((ComponentInstanceProperty) property).getRules(), innerType, allDataTypes, true);
2266 if (pair.getRight() != null && !pair.getRight()) {
2267 BeEcompErrorManager.getInstance().logBeInvalidValueError("Add property value", pair.getLeft(), property.getName(), propertyType);
2274 private <T extends PropertyDefinition> Either<String, ResponseFormat> updatePropertyObjectValue(T property, final String model) {
2275 final Map<String, DataTypeDefinition> allDataTypes = componentsUtils.getAllDataTypes(applicationDataTypeCache, model);
2276 String innerType = null;
2277 String propertyType = property.getType();
2278 ToscaPropertyType type = ToscaPropertyType.isValidType(propertyType);
2279 log.debug("The type of the property {} is {}", property.getUniqueId(), propertyType);
2281 if (type == ToscaPropertyType.LIST || type == ToscaPropertyType.MAP) {
2282 SchemaDefinition schema = property.getSchema();
2283 if (schema == null) {
2284 log.debug("Schema doesn't exists for property of type {}", type);
2286 .right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(StorageOperationStatus.INVALID_VALUE)));
2288 PropertyDataDefinition propDef = schema.getProperty();
2289 if (propDef == null) {
2290 log.debug("Property in Schema Definition inside property of type {} doesn't exist", type);
2292 .right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(StorageOperationStatus.INVALID_VALUE)));
2294 innerType = propDef.getType();
2297 // Specific Update Logic
2298 String newValue = property.getValue();
2300 if (property.hasGetFunction()) {
2301 return Either.left(newValue);
2304 Either<Object, Boolean> isValid = propertyOperation
2305 .validateAndUpdatePropertyValue(propertyType, property.getValue(), true, innerType, allDataTypes);
2306 if (isValid.isRight()) {
2307 if (!Boolean.TRUE.equals(isValid.right().value())) {
2308 log.debug("validate and update property value has failed with value: {}", property.getValue());
2309 throw new ByActionStatusComponentException(componentsUtils.convertFromStorageResponse(
2310 DaoStatusConverter.convertJanusGraphStatusToStorageStatus(JanusGraphOperationStatus.ILLEGAL_ARGUMENT)));
2313 Object object = isValid.left().value();
2314 if (object != null) {
2315 newValue = object.toString();
2318 ImmutablePair<String, Boolean> pair = propertyOperation
2319 .validateAndUpdateRules(propertyType, ((ComponentInstanceProperty) property).getRules(), innerType, allDataTypes, true);
2320 if (pair.getRight() != null && Boolean.FALSE.equals(pair.getRight())) {
2321 BeEcompErrorManager.getInstance().logBeInvalidValueError("Add property value", pair.getLeft(), property.getName(), propertyType);
2322 return Either.right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(
2323 DaoStatusConverter.convertJanusGraphStatusToStorageStatus(JanusGraphOperationStatus.ILLEGAL_ARGUMENT))));
2325 return Either.left(newValue);
2328 private <T extends AttributeDefinition> Either<String, ResponseFormat> updateAttributeObjectValue(final T attribute) {
2329 String innerType = null;
2330 final String attributeType = attribute.getType();
2331 final ToscaPropertyType type = ToscaPropertyType.isValidType(attributeType);
2332 log.debug("The type of the attribute {} is {}", attribute.getUniqueId(), attributeType);
2334 if (type == ToscaPropertyType.LIST || type == ToscaPropertyType.MAP) {
2335 final SchemaDefinition def = attribute.getSchema();
2337 log.debug("Schema doesn't exists for attribute of type {}", type);
2339 .right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(StorageOperationStatus.INVALID_VALUE)));
2341 PropertyDataDefinition propDef = def.getProperty();
2342 if (propDef == null) {
2343 log.debug("Property in Schema Definition inside attribute of type {} doesn't exist", type);
2345 .right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(StorageOperationStatus.INVALID_VALUE)));
2347 innerType = propDef.getType();
2350 // Specific Update Logic
2351 String newValue = attribute.getValue();
2353 final var isValid = attributeOperation.validateAndUpdateAttributeValue(attribute, innerType,
2354 componentsUtils.getAllDataTypes(applicationDataTypeCache, attribute.getModel()));
2355 if (isValid.isRight()) {
2356 final Boolean res = isValid.right().value();
2357 if (!Boolean.TRUE.equals(res)) {
2358 log.debug("validate and update attribute value has failed with value: {}", newValue);
2359 throw new ByActionStatusComponentException(componentsUtils.convertFromStorageResponse(
2360 DaoStatusConverter.convertJanusGraphStatusToStorageStatus(JanusGraphOperationStatus.ILLEGAL_ARGUMENT)));
2363 final Object object = isValid.left().value();
2364 if (object != null) {
2365 newValue = object.toString();
2368 return Either.left(newValue);
2371 private <T extends PropertyDefinition> void validateToscaGetFunction(T property, Component parentComponent) {
2372 final ToscaGetFunctionDataDefinition toscaGetFunction = property.getToscaGetFunction();
2373 validateGetToscaFunctionAttributes(toscaGetFunction);
2374 validateGetPropertySource(toscaGetFunction.getFunctionType(), toscaGetFunction.getPropertySource());
2375 if (toscaGetFunction.getFunctionType() == ToscaGetFunctionType.GET_INPUT) {
2376 validateGetFunction(property, parentComponent.getInputs(), parentComponent.getModel());
2379 if (toscaGetFunction.getFunctionType() == ToscaGetFunctionType.GET_PROPERTY) {
2380 if (toscaGetFunction.getPropertySource() == PropertySource.SELF) {
2381 validateGetFunction(property, parentComponent.getProperties(), parentComponent.getModel());
2382 } else if (toscaGetFunction.getPropertySource() == PropertySource.INSTANCE) {
2383 final ComponentInstance componentInstance =
2384 parentComponent.getComponentInstanceById(toscaGetFunction.getSourceUniqueId())
2385 .orElseThrow(ToscaGetFunctionExceptionSupplier.instanceNotFound(toscaGetFunction.getSourceName()));
2386 validateGetFunction(property, componentInstance.getProperties(), parentComponent.getModel());
2391 if (toscaGetFunction.getFunctionType() == ToscaGetFunctionType.GET_ATTRIBUTE) {
2392 if (toscaGetFunction.getPropertySource() == PropertySource.SELF) {
2393 validateGetFunction(property, parentComponent.getAttributes(), parentComponent.getModel());
2394 } else if (toscaGetFunction.getPropertySource() == PropertySource.INSTANCE) {
2395 final ComponentInstance componentInstance =
2396 parentComponent.getComponentInstanceById(toscaGetFunction.getSourceUniqueId())
2397 .orElseThrow(ToscaGetFunctionExceptionSupplier.instanceNotFound(toscaGetFunction.getSourceName()));
2398 validateGetFunction(property, componentInstance.getAttributes(), parentComponent.getModel());
2404 throw ToscaGetFunctionExceptionSupplier.functionNotSupported(toscaGetFunction.getFunctionType()).get();
2407 private <T extends PropertyDefinition> void validateGetFunction(final T property,
2408 final List<? extends ToscaPropertyData> parentProperties,
2409 final String model) {
2410 final ToscaGetFunctionDataDefinition toscaGetFunction = property.getToscaGetFunction();
2411 if (CollectionUtils.isEmpty(parentProperties)) {
2412 throw ToscaGetFunctionExceptionSupplier
2413 .propertyNotFoundOnTarget(toscaGetFunction.getPropertyName(), toscaGetFunction.getPropertySource(),
2414 toscaGetFunction.getFunctionType()
2417 final String getFunctionPropertyUniqueId = toscaGetFunction.getPropertyUniqueId();
2418 ToscaPropertyData referredProperty = parentProperties.stream()
2419 .filter(property1 -> getFunctionPropertyUniqueId.equals(property1.getUniqueId()))
2421 .orElseThrow(ToscaGetFunctionExceptionSupplier
2422 .propertyNotFoundOnTarget(toscaGetFunction.getPropertyName(), toscaGetFunction.getPropertySource()
2423 , toscaGetFunction.getFunctionType())
2425 if (toscaGetFunction.isSubProperty()) {
2426 referredProperty = findSubProperty(referredProperty, toscaGetFunction, model);
2429 if (!property.getType().equals(referredProperty.getType())) {
2430 throw ToscaGetFunctionExceptionSupplier
2431 .propertyTypeDiverge(toscaGetFunction.getFunctionType(), referredProperty.getType(), property.getType()).get();
2433 if (PropertyType.typeHasSchema(referredProperty.getType()) && !referredProperty.getSchemaType().equals(property.getSchemaType())) {
2434 throw ToscaGetFunctionExceptionSupplier
2435 .propertySchemaDiverge(toscaGetFunction.getFunctionType(), referredProperty.getSchemaType(), property.getSchemaType()).get();
2439 private ToscaPropertyData findSubProperty(final ToscaPropertyData referredProperty,
2440 final ToscaGetFunctionDataDefinition toscaGetFunction,
2441 final String model) {
2442 final Map<String, DataTypeDefinition> dataTypeMap = loadDataTypes(model);
2443 final List<String> propertyPathFromSource = toscaGetFunction.getPropertyPathFromSource();
2444 DataTypeDefinition dataType = dataTypeMap.get(referredProperty.getType());
2445 if (dataType == null) {
2446 throw ToscaGetFunctionExceptionSupplier
2447 .propertyDataTypeNotFound(propertyPathFromSource.get(0), referredProperty.getType(), toscaGetFunction.getFunctionType()).get();
2449 ToscaPropertyData foundProperty = referredProperty;
2450 for (int i = 1; i < propertyPathFromSource.size(); i++) {
2451 final String currentPropertyName = propertyPathFromSource.get(i);
2452 foundProperty = dataType.getProperties().stream()
2453 .filter(propertyDefinition -> currentPropertyName.equals(propertyDefinition.getName())).findFirst()
2455 ToscaGetFunctionExceptionSupplier
2456 .propertyNotFoundOnTarget(propertyPathFromSource.subList(0, i), toscaGetFunction.getPropertySource(),
2457 toscaGetFunction.getFunctionType())
2459 dataType = dataTypeMap.get(foundProperty.getType());
2460 if (dataType == null) {
2461 throw ToscaGetFunctionExceptionSupplier
2462 .propertyDataTypeNotFound(propertyPathFromSource.subList(0, i), foundProperty.getType(),
2463 toscaGetFunction.getFunctionType()).get();
2466 return foundProperty;
2469 private Map<String, DataTypeDefinition> loadDataTypes(String model) {
2470 final Either<Map<String, DataTypeDefinition>, JanusGraphOperationStatus> dataTypeEither =
2471 applicationDataTypeCache.getAll(model);
2472 if (dataTypeEither.isRight()) {
2473 throw ToscaGetFunctionExceptionSupplier.couldNotLoadDataTypes(model).get();
2475 return dataTypeEither.left().value();
2478 private void validateGetPropertySource(final ToscaGetFunctionType functionType, final PropertySource propertySource) {
2479 if (functionType == ToscaGetFunctionType.GET_INPUT && propertySource != PropertySource.SELF) {
2480 throw ToscaGetFunctionExceptionSupplier
2481 .targetSourceNotSupported(functionType, propertySource).get();
2483 if (functionType == ToscaGetFunctionType.GET_PROPERTY && !List.of(PropertySource.SELF, PropertySource.INSTANCE).contains(propertySource)) {
2484 throw ToscaGetFunctionExceptionSupplier
2485 .targetSourceNotSupported(functionType, propertySource).get();
2489 private void validateGetToscaFunctionAttributes(final ToscaGetFunctionDataDefinition toscaGetFunction) {
2490 if (toscaGetFunction.getFunctionType() == null) {
2491 throw ToscaGetFunctionExceptionSupplier.targetFunctionTypeNotFound().get();
2493 if (toscaGetFunction.getPropertySource() == null) {
2494 throw ToscaGetFunctionExceptionSupplier.targetPropertySourceNotFound(toscaGetFunction.getFunctionType()).get();
2496 if (CollectionUtils.isEmpty(toscaGetFunction.getPropertyPathFromSource())) {
2497 throw ToscaGetFunctionExceptionSupplier
2498 .targetSourcePathNotFound(toscaGetFunction.getFunctionType()).get();
2500 if (StringUtils.isEmpty(toscaGetFunction.getSourceName()) || StringUtils.isBlank(toscaGetFunction.getSourceName())) {
2501 throw ToscaGetFunctionExceptionSupplier.sourceNameNotFound(toscaGetFunction.getPropertySource()).get();
2503 if (StringUtils.isEmpty(toscaGetFunction.getSourceUniqueId()) || StringUtils.isBlank(toscaGetFunction.getSourceUniqueId())) {
2504 throw ToscaGetFunctionExceptionSupplier.sourceIdNotFound(toscaGetFunction.getPropertySource()).get();
2506 if (StringUtils.isEmpty(toscaGetFunction.getPropertyName()) || StringUtils.isBlank(toscaGetFunction.getPropertyName())) {
2507 throw ToscaGetFunctionExceptionSupplier.propertyNameNotFound(toscaGetFunction.getPropertySource()).get();
2509 if (StringUtils.isEmpty(toscaGetFunction.getPropertyUniqueId()) || StringUtils.isBlank(toscaGetFunction.getPropertyUniqueId())) {
2510 throw ToscaGetFunctionExceptionSupplier.propertyIdNotFound(toscaGetFunction.getPropertySource()).get();
2514 private ResponseFormat updateInputOnContainerComponent(ComponentInstanceInput input, String newValue, Component containerComponent,
2515 ComponentInstance foundResourceInstance) {
2516 StorageOperationStatus status;
2517 input.setValue(newValue);
2518 status = toscaOperationFacade.updateComponentInstanceInput(containerComponent, foundResourceInstance.getUniqueId(), input);
2519 if (status != StorageOperationStatus.OK) {
2520 ActionStatus actionStatus = componentsUtils.convertFromStorageResponseForResourceInstanceProperty(status);
2521 return componentsUtils.getResponseFormatForResourceInstanceProperty(actionStatus, "");
2523 foundResourceInstance.setCustomizationUUID(UUID.randomUUID().toString());
2524 return componentsUtils.getResponseFormat(ActionStatus.OK);
2527 public Either<List<ComponentInstanceInput>, ResponseFormat> createOrUpdateInstanceInputValues(ComponentTypeEnum componentTypeEnum,
2528 String componentId, String resourceInstanceId,
2529 List<ComponentInstanceInput> inputs,
2532 Either<List<ComponentInstanceInput>, ResponseFormat> resultOp = null;
2534 validateUserExists(userId);
2536 if (componentTypeEnum == null) {
2537 BeEcompErrorManager.getInstance().logInvalidInputError(CREATE_OR_UPDATE_PROPERTY_VALUE, INVALID_COMPONENT_TYPE, ErrorSeverity.INFO);
2538 resultOp = Either.right(componentsUtils.getResponseFormat(ActionStatus.NOT_ALLOWED));
2541 Either<Component, StorageOperationStatus> getResourceResult = toscaOperationFacade.getToscaElement(componentId, JsonParseFlagEnum.ParseAll);
2543 if (getResourceResult.isRight()) {
2544 log.debug(FAILED_TO_RETRIEVE_COMPONENT_COMPONENT_ID, componentId);
2545 ActionStatus actionStatus = componentsUtils.convertFromStorageResponse(getResourceResult.right().value(), componentTypeEnum);
2546 return Either.right(componentsUtils.getResponseFormat(actionStatus, componentId));
2548 Component containerComponent = getResourceResult.left().value();
2550 if (!ComponentValidationUtils.canWorkOnComponent(containerComponent, userId)) {
2551 if (Boolean.TRUE.equals(containerComponent.isArchived())) {
2552 log.info(COMPONENT_ARCHIVED, componentId);
2553 return Either.right(componentsUtils.getResponseFormat(ActionStatus.COMPONENT_IS_ARCHIVED, containerComponent.getName()));
2555 log.info(RESTRICTED_OPERATION_ON_SERVIVE, userId, componentId);
2556 resultOp = Either.right(componentsUtils.getResponseFormat(ActionStatus.RESTRICTED_OPERATION));
2559 Either<ComponentInstance, StorageOperationStatus> resourceInstanceStatus = getResourceInstanceById(containerComponent, resourceInstanceId);
2560 if (resourceInstanceStatus.isRight()) {
2561 return Either.right(componentsUtils.getResponseFormat(ActionStatus.COMPONENT_INSTANCE_NOT_FOUND_ON_CONTAINER,
2562 resourceInstanceId, RESOURCE_INSTANCE, SERVICE, componentId));
2565 ComponentInstance foundResourceInstance = resourceInstanceStatus.left().value();
2568 StorageOperationStatus lockStatus = graphLockOperation.lockComponent(componentId, componentTypeEnum.getNodeType());
2569 if (lockStatus != StorageOperationStatus.OK) {
2570 log.debug(FAILED_TO_LOCK_SERVICE, componentId);
2571 return Either.right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(lockStatus)));
2573 List<ComponentInstanceInput> updatedInputs = new ArrayList<>();
2575 for (ComponentInstanceInput input : inputs) {
2576 validateMandatoryFields(input);
2577 ComponentInstanceInput componentInstanceInput = validateInputExistsOnComponent(input, containerComponent, foundResourceInstance);
2578 Either<String, ResponseFormat> validatedInputValue = validatePropertyObjectValue(componentInstanceInput, input.getValue(), true);
2579 if (validatedInputValue.isRight()) {
2580 throw new ByActionStatusComponentException(ActionStatus.INVALID_CONTENT, input.getName());
2582 updateInputOnContainerComponent(componentInstanceInput, validatedInputValue.left().value(), containerComponent,
2583 foundResourceInstance);
2584 updatedInputs.add(componentInstanceInput);
2586 Either<Component, StorageOperationStatus> updateContainerRes = toscaOperationFacade
2587 .updateComponentInstanceMetadataOfTopologyTemplate(containerComponent);
2588 if (updateContainerRes.isRight()) {
2589 ActionStatus actionStatus = componentsUtils.convertFromStorageResponseForResourceInstanceProperty(updateContainerRes.right().value());
2590 resultOp = Either.right(componentsUtils.getResponseFormatForResourceInstanceProperty(actionStatus, ""));
2593 resultOp = Either.left(updatedInputs);
2597 if (resultOp == null || resultOp.isRight()) {
2598 janusGraphDao.rollback();
2600 janusGraphDao.commit();
2603 graphLockOperation.unlockComponent(componentId, componentTypeEnum.getNodeType());
2608 private ComponentInstanceInput validateInputExistsOnComponent(ComponentInstanceInput input, Component containerComponent,
2609 ComponentInstance foundResourceInstance) {
2610 List<ComponentInstanceInput> instanceProperties = containerComponent.getComponentInstancesInputs().get(foundResourceInstance.getUniqueId());
2611 Optional<ComponentInstanceInput> instanceInput = instanceProperties.stream().filter(p -> p.getName().equals(input.getName())).findAny();
2612 if (!instanceInput.isPresent()) {
2613 throw new ByActionStatusComponentException(ActionStatus.PROPERTY_NOT_FOUND, input.getName());
2615 return instanceInput.get();
2618 public Either<ComponentInstanceProperty, ResponseFormat> createOrUpdateGroupInstancePropertyValue(ComponentTypeEnum componentTypeEnum,
2619 String componentId, String resourceInstanceId,
2620 String groupInstanceId,
2621 ComponentInstanceProperty property,
2624 Either<ComponentInstanceProperty, ResponseFormat> resultOp = null;
2626 validateUserExists(userId);
2628 if (componentTypeEnum == null) {
2629 BeEcompErrorManager.getInstance().logInvalidInputError(CREATE_OR_UPDATE_PROPERTY_VALUE, INVALID_COMPONENT_TYPE, ErrorSeverity.INFO);
2630 resultOp = Either.right(componentsUtils.getResponseFormat(ActionStatus.NOT_ALLOWED));
2634 if (!ComponentValidationUtils.canWorkOnComponent(componentId, toscaOperationFacade, userId)) {
2635 log.info("Restricted operation for user: {} on service: {}", userId, componentId);
2636 resultOp = Either.right(componentsUtils.getResponseFormat(ActionStatus.RESTRICTED_OPERATION));
2640 StorageOperationStatus lockStatus = graphLockOperation.lockComponent(componentId, componentTypeEnum.getNodeType());
2641 if (lockStatus != StorageOperationStatus.OK) {
2642 log.debug(FAILED_TO_LOCK_SERVICE, componentId);
2643 resultOp = Either.right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(lockStatus)));
2647 String propertyValueUid = property.getValueUniqueUid();
2649 if (propertyValueUid == null) {
2651 Either<Integer, StorageOperationStatus> counterRes = groupInstanceOperation
2652 .increaseAndGetGroupInstancePropertyCounter(groupInstanceId);
2654 if (counterRes.isRight()) {
2655 log.debug("increaseAndGetResourcePropertyCounter failed resource instance: {} property: {}", resourceInstanceId, property);
2656 StorageOperationStatus status = counterRes.right().value();
2657 ActionStatus actionStatus = componentsUtils.convertFromStorageResponseForResourceInstanceProperty(status);
2658 resultOp = Either.right(componentsUtils.getResponseFormat(actionStatus));
2660 Integer index = counterRes.left().value();
2661 Either<ComponentInstanceProperty, StorageOperationStatus> result = groupInstanceOperation
2662 .addPropertyValueToGroupInstance(property, resourceInstanceId, index, true);
2664 if (result.isLeft()) {
2665 log.trace("Property value was added to resource instance {}", resourceInstanceId);
2666 ComponentInstanceProperty instanceProperty = result.left().value();
2668 resultOp = Either.left(instanceProperty);
2671 log.debug("Failed to add property value: {} to resource instance {}", property, resourceInstanceId);
2673 ActionStatus actionStatus = componentsUtils.convertFromStorageResponseForResourceInstanceProperty(result.right().value());
2675 resultOp = Either.right(componentsUtils.getResponseFormatForResourceInstanceProperty(actionStatus, ""));
2679 Either<ComponentInstanceProperty, StorageOperationStatus> result = groupInstanceOperation
2680 .updatePropertyValueInGroupInstance(property, resourceInstanceId, true);
2682 if (result.isLeft()) {
2683 log.debug("Property value {} was updated on graph.", property.getValueUniqueUid());
2684 ComponentInstanceProperty instanceProperty = result.left().value();
2686 resultOp = Either.left(instanceProperty);
2689 log.debug("Failed to update property value: {}, in resource instance {}", property, resourceInstanceId);
2691 ActionStatus actionStatus = componentsUtils.convertFromStorageResponseForResourceInstanceProperty(result.right().value());
2693 resultOp = Either.right(componentsUtils.getResponseFormatForResourceInstanceProperty(actionStatus, ""));
2696 if (resultOp.isLeft()) {
2697 StorageOperationStatus updateCustomizationUUID = componentInstanceOperation.updateCustomizationUUID(resourceInstanceId);
2698 if (updateCustomizationUUID != StorageOperationStatus.OK) {
2699 ActionStatus actionStatus = componentsUtils.convertFromStorageResponseForResourceInstanceProperty(updateCustomizationUUID);
2701 resultOp = Either.right(componentsUtils.getResponseFormatForResourceInstanceProperty(actionStatus, ""));
2708 if (resultOp == null || resultOp.isRight()) {
2709 janusGraphDao.rollback();
2711 janusGraphDao.commit();
2714 graphLockOperation.unlockComponent(componentId, componentTypeEnum.getNodeType());
2719 public Either<ComponentInstanceProperty, ResponseFormat> deletePropertyValue(ComponentTypeEnum componentTypeEnum, String serviceId,
2720 String resourceInstanceId, String propertyValueId, String userId) {
2722 validateUserExists(userId);
2724 Either<ComponentInstanceProperty, ResponseFormat> resultOp = null;
2726 if (componentTypeEnum == null) {
2727 BeEcompErrorManager.getInstance().logInvalidInputError(CREATE_OR_UPDATE_PROPERTY_VALUE, INVALID_COMPONENT_TYPE, ErrorSeverity.INFO);
2728 resultOp = Either.right(componentsUtils.getResponseFormat(ActionStatus.NOT_ALLOWED));
2732 if (!ComponentValidationUtils.canWorkOnComponent(serviceId, toscaOperationFacade, userId)) {
2733 log.info("Restricted operation for user {} on service {}", userId, serviceId);
2734 resultOp = Either.right(componentsUtils.getResponseFormat(ActionStatus.RESTRICTED_OPERATION));
2738 StorageOperationStatus lockStatus = graphLockOperation.lockComponent(serviceId, componentTypeEnum.getNodeType());
2739 if (lockStatus != StorageOperationStatus.OK) {
2740 log.debug(FAILED_TO_LOCK_SERVICE, serviceId);
2741 resultOp = Either.right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(lockStatus)));
2745 Either<ComponentInstanceProperty, StorageOperationStatus> result = propertyOperation
2746 .removePropertyValueFromResourceInstance(propertyValueId, resourceInstanceId, true);
2748 if (result.isLeft()) {
2749 log.debug("Property value {} was removed from graph.", propertyValueId);
2750 ComponentInstanceProperty instanceProperty = result.left().value();
2752 resultOp = Either.left(instanceProperty);
2756 log.debug("Failed to remove property value {} in resource instance {}", propertyValueId, resourceInstanceId);
2758 ActionStatus actionStatus = componentsUtils.convertFromStorageResponseForResourceInstanceProperty(result.right().value());
2760 resultOp = Either.right(componentsUtils.getResponseFormatForResourceInstanceProperty(actionStatus, ""));
2766 if (resultOp == null || resultOp.isRight()) {
2767 janusGraphDao.rollback();
2769 janusGraphDao.commit();
2772 graphLockOperation.unlockComponent(serviceId, componentTypeEnum.getNodeType());
2777 private Component getAndValidateOriginComponentOfComponentInstance(Component containerComponent, ComponentInstance componentInstance) {
2779 ComponentTypeEnum componentType = getComponentTypeByParentComponentType(containerComponent.getComponentType());
2780 Component component;
2781 Either<Component, StorageOperationStatus> getComponentRes = toscaOperationFacade.getToscaFullElement(componentInstance.getComponentUid());
2782 if (getComponentRes.isRight()) {
2783 log.debug("Failed to get the component with id {} for component instance {} creation. ", componentInstance.getComponentUid(),
2784 componentInstance.getName());
2785 ActionStatus actionStatus = componentsUtils.convertFromStorageResponse(getComponentRes.right().value(), componentType);
2786 throw new ByActionStatusComponentException(actionStatus, Constants.EMPTY_STRING);
2788 component = getComponentRes.left().value();
2789 LifecycleStateEnum resourceCurrState = component.getLifecycleState();
2790 if (resourceCurrState == LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT) {
2791 ActionStatus actionStatus = ActionStatus.CONTAINER_CANNOT_CONTAIN_COMPONENT_IN_STATE;
2792 throw new ByActionStatusComponentException(actionStatus, containerComponent.getComponentType().toString(), resourceCurrState.toString());
2794 if (Boolean.TRUE.equals(component.isArchived())) {
2795 ActionStatus actionStatus = ActionStatus.COMPONENT_IS_ARCHIVED;
2796 throw new ByActionStatusComponentException(actionStatus, component.getName());
2798 final Map<String, InterfaceDefinition> componentInterfaces = component.getInterfaces();
2799 if (MapUtils.isNotEmpty(componentInterfaces)) {
2800 componentInterfaces.forEach(componentInstance::addInterface);
2805 public Either<Set<String>, ResponseFormat> forwardingPathOnVersionChange(String containerComponentParam,
2806 String containerComponentId,
2807 String componentInstanceId,
2808 ComponentInstance newComponentInstance) {
2809 Either<Set<String>, ResponseFormat> resultOp;
2810 final ComponentTypeEnum containerComponentType = validateComponentType(containerComponentParam);
2811 ComponentParametersView componentParametersView = getComponentParametersViewForForwardingPath();
2814 Component containerComponent = validateComponentExists(containerComponentId, containerComponentType, componentParametersView);
2816 //Fetch current component instance
2817 Either<ComponentInstance, StorageOperationStatus> eitherResourceInstance =
2818 getResourceInstanceById(containerComponent, componentInstanceId);
2819 if (eitherResourceInstance.isRight()) {
2820 resultOp = Either.right(componentsUtils.getResponseFormat(
2821 ActionStatus.RESOURCE_INSTANCE_NOT_FOUND_ON_SERVICE, componentInstanceId, containerComponentId));
2824 ComponentInstance currentResourceInstance = eitherResourceInstance.left().value();
2826 //Check whether new componentInstance exists
2827 String resourceId = newComponentInstance.getComponentUid();
2828 Either<Boolean, StorageOperationStatus> componentExistsRes = toscaOperationFacade.validateComponentExists(resourceId);
2829 if (componentExistsRes.isRight()) {
2830 log.debug("Failed to find resource {}", resourceId);
2831 resultOp = Either.right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse
2832 (componentExistsRes.right().value()), resourceId));
2834 } else if (!Boolean.TRUE.equals(componentExistsRes.left().value())) {
2835 log.debug("The resource {} not found ", resourceId);
2836 resultOp = Either.right(componentsUtils.getResponseFormat(ActionStatus.RESOURCE_NOT_FOUND, resourceId));
2840 //Fetch component using new component instance uid
2841 Component updatedContainerComponent = getOriginComponentFromComponentInstance(newComponentInstance);
2842 Set<String> toDeleteForwardingPaths = getForwardingPaths(containerComponent,
2843 currentResourceInstance, updatedContainerComponent);
2844 resultOp = Either.left(toDeleteForwardingPaths);
2849 private Set<String> getForwardingPaths(Component containerComponent, ComponentInstance currentResourceInstance,
2850 Component updatedContainerComponent) {
2851 DataForMergeHolder dataForMergeHolder = new DataForMergeHolder();
2852 dataForMergeHolder.setOrigComponentInstId(currentResourceInstance.getName());
2854 Service service = (Service) containerComponent;
2855 ForwardingPathUtils forwardingPathUtils = new ForwardingPathUtils();
2857 return forwardingPathUtils.
2858 getForwardingPathsToBeDeletedOnVersionChange(service, dataForMergeHolder, updatedContainerComponent);
2861 private ComponentParametersView getComponentParametersViewForForwardingPath() {
2862 ComponentParametersView componentParametersView = new ComponentParametersView();
2863 componentParametersView.setIgnoreCapabiltyProperties(false);
2864 componentParametersView.setIgnoreServicePath(false);
2865 return componentParametersView;
2868 public ComponentInstance changeComponentInstanceVersion(String containerComponentParam, String containerComponentId, String componentInstanceId,
2869 String userId, ComponentInstance newComponentInstance) {
2871 User user = validateUserExists(userId);
2872 final ComponentTypeEnum containerComponentType = validateComponentType(containerComponentParam);
2873 ComponentParametersView componentParametersView = new ComponentParametersView();
2874 componentParametersView.setIgnoreCapabiltyProperties(false);
2876 org.openecomp.sdc.be.model.Component containerComponent = validateComponentExists(containerComponentId, containerComponentType,
2877 componentParametersView);
2879 validateCanWorkOnComponent(containerComponent, userId);
2881 Either<ComponentInstance, StorageOperationStatus> resourceInstanceStatus = getResourceInstanceById(containerComponent, componentInstanceId);
2882 if (resourceInstanceStatus.isRight()) {
2883 throw new ByActionStatusComponentException(ActionStatus.RESOURCE_INSTANCE_NOT_FOUND_ON_SERVICE, componentInstanceId,
2884 containerComponentId);
2887 ComponentInstance currentResourceInstance = resourceInstanceStatus.left().value();
2889 return changeInstanceVersion(containerComponent, currentResourceInstance, newComponentInstance, user, containerComponentType);
2892 public ComponentInstance changeInstanceVersion(org.openecomp.sdc.be.model.Component containerComponent,
2893 ComponentInstance currentResourceInstance,
2894 ComponentInstance newComponentInstance,
2896 final ComponentTypeEnum containerComponentType) {
2897 boolean failed = false;
2898 Either<ComponentInstance, StorageOperationStatus> resourceInstanceStatus;
2901 lockComponent(containerComponent, "changeComponentInstanceVersion");
2902 String containerComponentId = containerComponent.getUniqueId();
2903 String componentInstanceId = currentResourceInstance.getUniqueId();
2904 if (currentResourceInstance.getComponentUid().equals(newComponentInstance.getComponentUid())) {
2905 return currentResourceInstance;
2907 String resourceId = newComponentInstance.getComponentUid();
2909 Either<Boolean, StorageOperationStatus> componentExistsRes = toscaOperationFacade
2910 .validateComponentExists(resourceId);
2911 if (componentExistsRes.isRight()) {
2912 StorageOperationStatus errorStatus = componentExistsRes.right().value();
2914 log.debug("Failed to validate existing of the component {}. Status is {} ", resourceId, errorStatus);
2915 throw new ByActionStatusComponentException(
2916 componentsUtils.convertFromStorageResponse(errorStatus), resourceId);
2917 } else if (!Boolean.TRUE.equals(componentExistsRes.left().value())) {
2918 log.debug("The resource {} not found ", resourceId);
2919 throw new ByActionStatusComponentException(ActionStatus.RESOURCE_NOT_FOUND, resourceId);
2922 Component eitherOriginComponent = getInstanceOriginNode(currentResourceInstance);
2923 DataForMergeHolder dataHolder = compInstMergeDataBL
2924 .saveAllDataBeforeDeleting(containerComponent, currentResourceInstance, eitherOriginComponent);
2925 ComponentInstance resResourceInfo = deleteComponentInstance(containerComponent, componentInstanceId,
2926 containerComponentType);
2928 if (resResourceInfo == null) {
2929 log.error("Calling `deleteComponentInstance` for the resource {} returned a null", resourceId);
2930 throw new ByActionStatusComponentException(ActionStatus.RESOURCE_NOT_FOUND, resourceId);
2932 Component origComponent = null;
2933 OriginTypeEnum originType = currentResourceInstance.getOriginType();
2934 newComponentInstance.setOriginType(originType);
2935 if (originType == OriginTypeEnum.ServiceProxy) {
2936 Either<Component, StorageOperationStatus> serviceProxyOrigin = toscaOperationFacade
2937 .getLatestByName(SERVICE_PROXY, null);
2938 if (isServiceProxyOrigin(serviceProxyOrigin)) {
2939 throw new ByActionStatusComponentException(
2940 componentsUtils.convertFromStorageResponse(serviceProxyOrigin.right().value()));
2942 origComponent = serviceProxyOrigin.left().value();
2944 StorageOperationStatus fillProxyRes = fillInstanceData(newComponentInstance, origComponent);
2946 if (isFillProxyRes(fillProxyRes)) {
2947 throw new ByActionStatusComponentException(
2948 componentsUtils.convertFromStorageResponse(fillProxyRes));
2950 } else if (originType == OriginTypeEnum.ServiceSubstitution) {
2951 final Either<Component, StorageOperationStatus> getServiceResult = toscaOperationFacade
2952 .getToscaFullElement(newComponentInstance.getComponentUid());
2953 if (getServiceResult.isRight()) {
2954 throw new ByActionStatusComponentException(componentsUtils.convertFromStorageResponse(getServiceResult.right().value()));
2956 final Component service = getServiceResult.left().value();
2958 final Either<Component, StorageOperationStatus> getServiceDerivedFromTypeResult = toscaOperationFacade
2959 .getLatestByToscaResourceName(service.getDerivedFromGenericType(), service.getModel());
2960 if (getServiceDerivedFromTypeResult.isRight()) {
2961 throw new ByActionStatusComponentException(componentsUtils.convertFromStorageResponse(getServiceResult.right().value()));
2964 origComponent = getServiceDerivedFromTypeResult.left().value();
2966 final StorageOperationStatus fillProxyRes = fillInstanceData(newComponentInstance, origComponent);
2967 if (isFillProxyRes(fillProxyRes)) {
2968 throw new ByActionStatusComponentException(
2969 componentsUtils.convertFromStorageResponse(fillProxyRes));
2972 origComponent = getOriginComponentFromComponentInstance(newComponentInstance);
2973 newComponentInstance.setName(resResourceInfo.getName());
2974 final Map<String, InterfaceDefinition> componentInterfaces = origComponent.getInterfaces();
2975 if (MapUtils.isNotEmpty(componentInterfaces)) {
2976 componentInterfaces.forEach(newComponentInstance::addInterface);
2980 newComponentInstance.setInvariantName(resResourceInfo.getInvariantName());
2981 newComponentInstance.setPosX(resResourceInfo.getPosX());
2982 newComponentInstance.setPosY(resResourceInfo.getPosY());
2983 newComponentInstance.setDescription(resResourceInfo.getDescription());
2984 newComponentInstance.setInstanceCount(resResourceInfo.getInstanceCount());
2985 newComponentInstance.setMaxOccurrences(resResourceInfo.getMaxOccurrences());
2986 newComponentInstance.setMinOccurrences(resResourceInfo.getMinOccurrences());
2987 checkForExternalReqAndCapabilities(origComponent, resResourceInfo);
2989 ComponentInstance updatedComponentInstance =
2990 createComponentInstanceOnGraph(containerComponent, origComponent, newComponentInstance, user);
2991 dataHolder.setCurrInstanceNode(origComponent);
2993 .mergeComponentUserOrigData(user, dataHolder, containerComponent, containerComponentId, newComponentInstance.getUniqueId());
2995 ActionStatus postChangeVersionResult = onChangeInstanceOperationOrchestrator
2996 .doPostChangeVersionOperations(containerComponent, currentResourceInstance, newComponentInstance);
2997 if (postChangeVersionResult != ActionStatus.OK) {
2998 throw new ByActionStatusComponentException(postChangeVersionResult);
3001 ComponentParametersView filter = new ComponentParametersView(true);
3002 filter.setIgnoreComponentInstances(false);
3003 Either<Component, StorageOperationStatus> updatedComponentRes = toscaOperationFacade.getToscaElement(containerComponentId, filter);
3004 if (updatedComponentRes.isRight()) {
3005 StorageOperationStatus storageOperationStatus = updatedComponentRes.right().value();
3006 ActionStatus actionStatus = componentsUtils
3007 .convertFromStorageResponse(storageOperationStatus, containerComponent.getComponentType());
3008 log.debug("Component with id {} was not found", containerComponentId);
3009 throw new ByActionStatusComponentException(actionStatus, Constants.EMPTY_STRING);
3011 resourceInstanceStatus = getResourceInstanceById(updatedComponentRes.left().value(),
3012 updatedComponentInstance.getUniqueId());
3013 if (resourceInstanceStatus.isRight()) {
3014 throw new ByActionStatusComponentException(componentsUtils.convertFromStorageResponse
3015 (resourceInstanceStatus.right().value()), updatedComponentInstance.getUniqueId());
3017 return resourceInstanceStatus.left().value();
3019 } catch (ComponentException e) {
3023 unlockComponent(failed, containerComponent);
3027 private void checkForExternalReqAndCapabilities(Component component, ComponentInstance resResourceInfo) {
3028 Map<String, List<RequirementDefinition>> requirementsMap = resResourceInfo.getRequirements();
3029 Map<String, List<RequirementDefinition>> externalRequirementsMap = new HashMap<>();
3030 List<RequirementDefinition> externalRequirementList = new ArrayList<>();
3031 if (requirementsMap != null && !requirementsMap.isEmpty()) {
3032 requirementsMap.forEach((type, requirementDefinitions) -> {
3033 if (requirementDefinitions != null && !requirementDefinitions.isEmpty()) {
3034 for (final RequirementDefinition requirementDefinition : requirementDefinitions) {
3035 if (requirementDefinition.isExternal()) {
3036 externalRequirementList.add(requirementDefinition);
3037 externalRequirementsMap.put(type, externalRequirementList);
3044 Map<String, List<CapabilityDefinition>> capabilitiesMap = resResourceInfo.getCapabilities();
3045 Map<String, List<CapabilityDefinition>> externalCapabilitiesMap = new HashMap<>();
3046 List<CapabilityDefinition> externalCapabilitiesList = new ArrayList<>();
3047 if (capabilitiesMap != null && !capabilitiesMap.isEmpty()) {
3048 capabilitiesMap.forEach((type, capabilityDefinitions) -> {
3049 if (capabilityDefinitions != null && !capabilityDefinitions.isEmpty()) {
3050 for (final CapabilityDefinition capabilityDefinition : capabilityDefinitions) {
3051 if (capabilityDefinition.isExternal()) {
3052 externalCapabilitiesList.add(capabilityDefinition);
3053 externalCapabilitiesMap.put(type, externalCapabilitiesList);
3059 component.setCapabilities(externalCapabilitiesMap);
3060 component.setRequirements(externalRequirementsMap);
3063 private boolean isFillProxyRes(StorageOperationStatus fillProxyRes) {
3064 if (fillProxyRes != StorageOperationStatus.OK) {
3065 log.debug("Failed to fill service proxy resource data with data from service, error {}", fillProxyRes);
3072 public List<ComponentInstanceProperty> getComponentInstancePropertiesById(String containerComponentTypeParam, String containerComponentId,
3073 String componentInstanceUniqueId, String userId) {
3074 Component containerComponent = null;
3076 boolean failed = false;
3078 validateUserExists(userId);
3079 validateComponentType(containerComponentTypeParam);
3081 Either<Component, StorageOperationStatus> validateContainerComponentExists = toscaOperationFacade.getToscaElement(containerComponentId);
3082 if (validateContainerComponentExists.isRight()) {
3083 throw new ByActionStatusComponentException(
3084 componentsUtils.convertFromStorageResponse(validateContainerComponentExists.right().value()));
3086 containerComponent = validateContainerComponentExists.left().value();
3088 Either<ComponentInstance, StorageOperationStatus> resourceInstanceStatus = getResourceInstanceById(containerComponent,
3089 componentInstanceUniqueId);
3090 if (resourceInstanceStatus.isRight()) {
3091 throw new ByActionStatusComponentException(ActionStatus.RESOURCE_INSTANCE_NOT_FOUND_ON_SERVICE, componentInstanceUniqueId,
3092 containerComponentId);
3095 List<ComponentInstanceProperty> instanceProperties = containerComponent.getComponentInstancesProperties().get(componentInstanceUniqueId);
3096 if (CollectionUtils.isEmpty(instanceProperties)) {
3097 instanceProperties = new ArrayList<>();
3099 return instanceProperties;
3100 } catch (ComponentException e) {
3104 unlockComponent(failed, containerComponent);
3108 public List<ComponentInstanceAttribute> getComponentInstanceAttributesById(final String containerComponentTypeParam,
3109 final String containerComponentId,
3110 final String componentInstanceUniqueId,
3111 final String userId) {
3112 Component containerComponent = null;
3114 boolean failed = false;
3116 validateUserExists(userId);
3117 validateComponentType(containerComponentTypeParam);
3119 final Either<Component, StorageOperationStatus> validateContainerComponentExists =
3120 toscaOperationFacade.getToscaElement(containerComponentId);
3121 if (validateContainerComponentExists.isRight()) {
3122 throw new ByActionStatusComponentException(
3123 componentsUtils.convertFromStorageResponse(validateContainerComponentExists.right().value()));
3125 containerComponent = validateContainerComponentExists.left().value();
3127 if (getResourceInstanceById(containerComponent, componentInstanceUniqueId).isRight()) {
3128 throw new ByActionStatusComponentException(
3129 ActionStatus.RESOURCE_INSTANCE_NOT_FOUND_ON_SERVICE, componentInstanceUniqueId, containerComponentId);
3132 final Map<String, List<ComponentInstanceAttribute>> componentInstancesAttributes = containerComponent.getComponentInstancesAttributes();
3133 return componentInstancesAttributes == null ? new ArrayList<>()
3134 : componentInstancesAttributes.getOrDefault(componentInstanceUniqueId, new ArrayList<>());
3135 } catch (final ComponentException e) {
3139 unlockComponent(failed, containerComponent);
3143 protected void validateIncrementCounter(String resourceInstanceId, GraphPropertiesDictionary counterType,
3144 Wrapper<Integer> instaceCounterWrapper,
3145 Wrapper<ResponseFormat> errorWrapper) {
3146 Either<Integer, StorageOperationStatus> counterRes = componentInstanceOperation
3147 .increaseAndGetResourceInstanceSpecificCounter(resourceInstanceId, counterType, true);
3149 if (counterRes.isRight()) {
3150 log.debug("increase And Get {} failed resource instance {}", counterType, resourceInstanceId);
3151 StorageOperationStatus status = counterRes.right().value();
3152 ActionStatus actionStatus = componentsUtils.convertFromStorageResponseForResourceInstanceProperty(status);
3153 errorWrapper.setInnerElement(componentsUtils.getResponseFormat(actionStatus));
3155 instaceCounterWrapper.setInnerElement(counterRes.left().value());
3161 * updates componentInstance modificationTime
3163 * @param componentInstance
3164 * @param componentInstanceType
3165 * @param modificationTime
3166 * @param inTransaction
3169 public Either<ComponentInstanceData, ResponseFormat> updateComponentInstanceModificationTimeAndCustomizationUuid(
3170 ComponentInstance componentInstance, NodeTypeEnum componentInstanceType, Long modificationTime, boolean inTransaction) {
3171 Either<ComponentInstanceData, ResponseFormat> result;
3172 Either<ComponentInstanceData, StorageOperationStatus> updateComponentInstanceRes = componentInstanceOperation
3173 .updateComponentInstanceModificationTimeAndCustomizationUuidOnGraph(componentInstance, componentInstanceType, modificationTime,
3175 if (updateComponentInstanceRes.isRight()) {
3176 log.debug("Failed to update component instance {} with new last update date and mofifier. Status is {}. ", componentInstance.getName(),
3177 updateComponentInstanceRes.right().value());
3179 .right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(updateComponentInstanceRes.right().value())));
3181 result = Either.left(updateComponentInstanceRes.left().value());
3186 public Either<ComponentInstance, ResponseFormat> deleteServiceProxy() {
3187 // TODO Add implementation
3188 return Either.left(new ComponentInstance());
3191 public Either<ComponentInstance, ResponseFormat> createServiceProxy() {
3192 // TODO Add implementation
3193 return Either.left(new ComponentInstance());
3196 public Either<ComponentInstance, ResponseFormat> changeServiceProxyVersion() {
3197 // TODO Add implementation
3198 return Either.left(new ComponentInstance());
3201 private Boolean validateInstanceNameUniquenessUponUpdate(Component containerComponent, ComponentInstance oldComponentInstance,
3202 String newInstanceName) {
3203 return ComponentValidations.validateNameIsUniqueInComponent(oldComponentInstance.getName(), newInstanceName, containerComponent);
3206 private Either<ComponentInstance, StorageOperationStatus> getResourceInstanceById(final Component containerComponent, final String instanceId) {
3207 final List<ComponentInstance> instances = containerComponent.getComponentInstances();
3208 if (CollectionUtils.isEmpty(instances)) {
3209 return Either.right(StorageOperationStatus.NOT_FOUND);
3212 final Optional<ComponentInstance> foundInstance = instances.stream().filter(i -> i.getUniqueId().equals(instanceId)).findFirst();
3213 if (foundInstance.isEmpty()) {
3214 return Either.right(StorageOperationStatus.NOT_FOUND);
3217 return Either.left(foundInstance.get());
3220 private ComponentInstance buildComponentInstance(ComponentInstance resourceInstanceForUpdate, ComponentInstance origInstanceForUpdate) {
3221 Long creationDate = origInstanceForUpdate.getCreationTime();
3222 Long modificationTime = System.currentTimeMillis();
3223 resourceInstanceForUpdate.setCreationTime(creationDate);
3224 resourceInstanceForUpdate.setModificationTime(modificationTime);
3225 resourceInstanceForUpdate.setCustomizationUUID(origInstanceForUpdate.getCustomizationUUID());
3226 if (StringUtils.isEmpty(resourceInstanceForUpdate.getName()) && StringUtils.isNotEmpty(origInstanceForUpdate.getName())) {
3227 resourceInstanceForUpdate.setName(origInstanceForUpdate.getName());
3229 resourceInstanceForUpdate.setNormalizedName(ValidationUtils.normalizeComponentInstanceName(resourceInstanceForUpdate.getName()));
3230 if (StringUtils.isEmpty(resourceInstanceForUpdate.getIcon())) {
3231 resourceInstanceForUpdate.setIcon(origInstanceForUpdate.getIcon());
3233 if (StringUtils.isEmpty(resourceInstanceForUpdate.getComponentVersion())) {
3234 resourceInstanceForUpdate.setComponentVersion(origInstanceForUpdate.getComponentVersion());
3236 if (StringUtils.isEmpty(resourceInstanceForUpdate.getComponentName())) {
3237 resourceInstanceForUpdate.setComponentName(origInstanceForUpdate.getComponentName());
3239 if (StringUtils.isEmpty(resourceInstanceForUpdate.getToscaComponentName())) {
3240 resourceInstanceForUpdate.setToscaComponentName(origInstanceForUpdate.getToscaComponentName());
3242 if (resourceInstanceForUpdate.getOriginType() == null) {
3243 resourceInstanceForUpdate.setOriginType(origInstanceForUpdate.getOriginType());
3245 if (resourceInstanceForUpdate.getOriginType() == OriginTypeEnum.ServiceProxy) {
3246 resourceInstanceForUpdate.setIsProxy(true);
3248 if (resourceInstanceForUpdate.getSourceModelInvariant() == null) {
3249 resourceInstanceForUpdate.setSourceModelInvariant(origInstanceForUpdate.getSourceModelInvariant());
3251 if (resourceInstanceForUpdate.getSourceModelName() == null) {
3252 resourceInstanceForUpdate.setSourceModelName(origInstanceForUpdate.getSourceModelName());
3254 if (resourceInstanceForUpdate.getSourceModelUuid() == null) {
3255 resourceInstanceForUpdate.setSourceModelUuid(origInstanceForUpdate.getSourceModelUuid());
3257 if (resourceInstanceForUpdate.getSourceModelUid() == null) {
3258 resourceInstanceForUpdate.setSourceModelUid(origInstanceForUpdate.getSourceModelUid());
3260 if (resourceInstanceForUpdate.getCreatedFrom() == null) {
3261 resourceInstanceForUpdate.setCreatedFrom(origInstanceForUpdate.getCreatedFrom());
3263 return resourceInstanceForUpdate;
3267 * Returns list of ComponentInstanceProperty belonging to component instance capability specified by name, type and ownerId
3269 * @param containerComponentType
3270 * @param containerComponentId
3271 * @param componentInstanceUniqueId
3272 * @param capabilityType
3273 * @param capabilityName
3278 public List<ComponentInstanceProperty> getComponentInstanceCapabilityPropertiesById(String containerComponentType, String containerComponentId,
3279 String componentInstanceUniqueId, String capabilityType,
3280 String capabilityName, String ownerId, String userId) {
3281 Component containerComponent = null;
3282 List<ComponentInstanceProperty> resultOp = null;
3284 validateUserExists(userId);
3285 validateComponentType(containerComponentType);
3286 containerComponent = toscaOperationFacade.getToscaFullElement(containerComponentId).left().on(this::componentException);
3287 ComponentInstance resourceInstanceStatus = getResourceInstanceById(containerComponent, componentInstanceUniqueId).left()
3288 .on(this::componentInstanceException);
3289 resultOp = findCapabilityOfInstance(containerComponentId, componentInstanceUniqueId, capabilityType, capabilityName, ownerId,
3290 resourceInstanceStatus.getCapabilities());
3291 } catch (StorageException | ComponentException e) {
3292 unlockRollbackWithException(containerComponent, e);
3293 } catch (Exception e) {
3294 unlockRollbackWithException(containerComponent, new ByActionStatusComponentException(ActionStatus.GENERAL_ERROR));
3296 unlockWithCommit(containerComponent);
3300 private List<ComponentInstanceProperty> findCapabilityOfInstance(String componentId, String instanceId, String capabilityType,
3301 String capabilityName, String ownerId,
3302 Map<String, List<CapabilityDefinition>> instanceCapabilities) {
3303 CapabilityDefinition foundCapability;
3304 if (MapUtils.isNotEmpty(instanceCapabilities)) {
3305 List<CapabilityDefinition> capabilitiesPerType = instanceCapabilities.get(capabilityType);
3306 if (capabilitiesPerType != null) {
3307 Optional<CapabilityDefinition> capabilityOpt = capabilitiesPerType.stream()
3308 .filter(c -> c.getName().equals(capabilityName) && c.getOwnerId().equals(ownerId)).findFirst();
3309 if (capabilityOpt.isPresent()) {
3310 foundCapability = capabilityOpt.get();
3311 return foundCapability.getProperties() == null ? new ArrayList<>() : foundCapability.getProperties();
3315 return fetchComponentInstanceCapabilityProperties(componentId, instanceId, capabilityType, capabilityName, ownerId);
3318 private List<ComponentInstanceProperty> fetchComponentInstanceCapabilityProperties(String componentId, String instanceId, String capabilityType,
3319 String capabilityName, String ownerId) {
3321 return toscaOperationFacade.getComponentInstanceCapabilityProperties(componentId, instanceId, capabilityName, capabilityType, ownerId)
3322 .left().on(this::componentInstancePropertyListException);
3323 } catch (Exception e) {
3324 log.debug("The exception {} occurred upon the component {} instance {} capability {} properties retrieving. ", componentId, instanceId,
3326 throw new ByActionStatusComponentException(ActionStatus.GENERAL_ERROR);
3330 public Either<RequirementDefinition, ResponseFormat> updateInstanceRequirement(ComponentTypeEnum componentTypeEnum, String containerComponentId,
3331 String componentInstanceUniqueId,
3332 RequirementDefinition requirementDef, String userId) {
3333 Either<RequirementDefinition, ResponseFormat> resultOp = null;
3334 validateUserExists(userId);
3335 if (componentTypeEnum == null) {
3336 BeEcompErrorManager.getInstance().logInvalidInputError("updateInstanceRequirement", INVALID_COMPONENT_TYPE, ErrorSeverity.INFO);
3337 return Either.right(componentsUtils.getResponseFormat(ActionStatus.NOT_ALLOWED));
3339 Either<Component, StorageOperationStatus> getResourceResult = toscaOperationFacade.getToscaFullElement(containerComponentId);
3340 if (getResourceResult.isRight()) {
3341 log.debug(FAILED_TO_RETRIEVE_COMPONENT_COMPONENT_ID, containerComponentId);
3342 return Either.right(componentsUtils.getResponseFormat(ActionStatus.RESTRICTED_OPERATION));
3344 Component containerComponent = getResourceResult.left().value();
3345 if (!ComponentValidationUtils.canWorkOnComponent(containerComponent, userId)) {
3346 log.info(RESTRICTED_OPERATION_ON_COMPONENT, userId, containerComponentId);
3347 return Either.right(componentsUtils.getResponseFormat(ActionStatus.RESTRICTED_OPERATION));
3349 Either<ComponentInstance, StorageOperationStatus> resourceInstanceStatus = getResourceInstanceById(containerComponent,
3350 componentInstanceUniqueId);
3351 if (resourceInstanceStatus.isRight()) {
3352 return Either.right(componentsUtils
3353 .getResponseFormat(ActionStatus.RESOURCE_INSTANCE_NOT_FOUND_ON_SERVICE, componentInstanceUniqueId, containerComponentId));
3356 StorageOperationStatus lockStatus = graphLockOperation.lockComponent(containerComponentId, componentTypeEnum.getNodeType());
3357 if (lockStatus != StorageOperationStatus.OK) {
3358 log.debug(FAILED_TO_LOCK_COMPONENT, containerComponentId);
3359 return Either.right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(lockStatus)));
3362 StorageOperationStatus updateRequirementStatus = toscaOperationFacade
3363 .updateComponentInstanceRequirement(containerComponentId, componentInstanceUniqueId, requirementDef);
3364 if (updateRequirementStatus != StorageOperationStatus.OK) {
3365 log.debug("Failed to update component instance requirement on instance {} in container {}", componentInstanceUniqueId,
3366 containerComponentId);
3367 return Either.right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(updateRequirementStatus)));
3369 Either<Component, StorageOperationStatus> updateContainerRes = toscaOperationFacade
3370 .updateComponentInstanceMetadataOfTopologyTemplate(containerComponent);
3371 if (updateContainerRes.isRight()) {
3372 ActionStatus actionStatus = componentsUtils.convertFromStorageResponseForResourceInstanceProperty(updateContainerRes.right().value());
3373 resultOp = Either.right(componentsUtils.getResponseFormatForResourceInstanceProperty(actionStatus, ""));
3376 resultOp = Either.left(requirementDef);
3379 if (resultOp == null || resultOp.isRight()) {
3380 janusGraphDao.rollback();
3382 janusGraphDao.commit();
3385 graphLockOperation.unlockComponent(containerComponentId, componentTypeEnum.getNodeType());
3389 public Either<CapabilityDefinition, ResponseFormat> updateInstanceCapability(final ComponentTypeEnum containerComponentType,
3390 final String containerComponentId,
3391 final String componentInstanceUniqueId,
3392 final CapabilityDefinition capabilityDefinition,
3393 final String userId) {
3394 if (containerComponentType == null) {
3395 BeEcompErrorManager.getInstance().logInvalidInputError("updateInstanceCapability", INVALID_COMPONENT_TYPE, ErrorSeverity.INFO);
3396 return Either.right(componentsUtils.getResponseFormat(ActionStatus.NOT_ALLOWED));
3398 validateUserExists(userId);
3399 final Either<Component, StorageOperationStatus> getResourceResult = toscaOperationFacade.getToscaFullElement(containerComponentId);
3400 if (getResourceResult.isRight()) {
3401 log.debug(FAILED_TO_RETRIEVE_COMPONENT_COMPONENT_ID, containerComponentId);
3402 return Either.right(componentsUtils.getResponseFormat(ActionStatus.COMPONENT_NOT_FOUND, containerComponentId));
3404 final Component containerComponent = getResourceResult.left().value();
3405 if (!ComponentValidationUtils.canWorkOnComponent(containerComponent, userId)) {
3406 log.info(RESTRICTED_OPERATION_ON_COMPONENT, userId, containerComponentId);
3407 return Either.right(componentsUtils.getResponseFormat(ActionStatus.RESTRICTED_OPERATION));
3409 final Either<ComponentInstance, StorageOperationStatus> resourceInstanceStatus =
3410 getResourceInstanceById(containerComponent, componentInstanceUniqueId);
3411 if (resourceInstanceStatus.isRight()) {
3412 return Either.right(componentsUtils
3413 .getResponseFormat(ActionStatus.RESOURCE_INSTANCE_NOT_FOUND_ON_SERVICE, componentInstanceUniqueId, containerComponentId));
3416 final StorageOperationStatus lockStatus = graphLockOperation.lockComponent(containerComponentId, containerComponentType.getNodeType());
3417 if (lockStatus != StorageOperationStatus.OK) {
3418 log.debug(FAILED_TO_LOCK_COMPONENT, containerComponentId);
3419 return Either.right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(lockStatus)));
3421 var success = false;
3423 final CapabilityDataDefinition updatedCapabilityDefinition = toscaOperationFacade
3424 .updateComponentInstanceCapability(containerComponentId, componentInstanceUniqueId, capabilityDefinition);
3425 final Either<Component, StorageOperationStatus> updateContainerEither = toscaOperationFacade
3426 .updateComponentInstanceMetadataOfTopologyTemplate(containerComponent);
3427 if (updateContainerEither.isRight()) {
3428 var actionStatus = componentsUtils.convertFromStorageResponse(updateContainerEither.right().value(), containerComponentType);
3429 return Either.right(componentsUtils.getResponseFormat(actionStatus));
3432 return Either.left(new CapabilityDefinition(updatedCapabilityDefinition));
3433 } catch (final BusinessException e) {
3434 log.error(EcompLoggerErrorCode.BUSINESS_PROCESS_ERROR, NodeTemplateOperation.class.getName(), (ErrorLogOptionalData) null,
3435 FAILED_TO_UPDATE_COMPONENT_INSTANCE_CAPABILITY, componentInstanceUniqueId, containerComponentId);
3437 } catch (final Exception e) {
3438 log.error(EcompLoggerErrorCode.BUSINESS_PROCESS_ERROR, NodeTemplateOperation.class.getName(), (ErrorLogOptionalData) null,
3439 FAILED_TO_UPDATE_COMPONENT_INSTANCE_CAPABILITY, componentInstanceUniqueId, containerComponentId);
3440 throw new ByResponseFormatComponentException(componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR));
3443 janusGraphDao.commit();
3445 janusGraphDao.rollback();
3448 graphLockOperation.unlockComponent(containerComponentId, containerComponentType.getNodeType());
3452 public Either<List<ComponentInstanceProperty>, ResponseFormat> updateInstanceCapabilityProperties(ComponentTypeEnum componentTypeEnum,
3453 String containerComponentId,
3454 String componentInstanceUniqueId,
3455 String capabilityType, String capabilityName,
3456 List<ComponentInstanceProperty> properties,
3458 Either<List<ComponentInstanceProperty>, ResponseFormat> resultOp = null;
3459 validateUserExists(userId);
3460 if (componentTypeEnum == null) {
3461 BeEcompErrorManager.getInstance().logInvalidInputError("updateInstanceCapabilityProperty", INVALID_COMPONENT_TYPE, ErrorSeverity.INFO);
3462 return Either.right(componentsUtils.getResponseFormat(ActionStatus.NOT_ALLOWED));
3464 Either<Component, StorageOperationStatus> getResourceResult = toscaOperationFacade.getToscaFullElement(containerComponentId);
3465 if (getResourceResult.isRight()) {
3466 log.debug(FAILED_TO_RETRIEVE_COMPONENT_COMPONENT_ID, containerComponentId);
3467 return Either.right(componentsUtils.getResponseFormat(ActionStatus.RESTRICTED_OPERATION));
3469 Component containerComponent = getResourceResult.left().value();
3470 if (!ComponentValidationUtils.canWorkOnComponent(containerComponent, userId)) {
3471 log.info(RESTRICTED_OPERATION_ON_COMPONENT, userId, containerComponentId);
3472 return Either.right(componentsUtils.getResponseFormat(ActionStatus.RESTRICTED_OPERATION));
3474 Either<ComponentInstance, StorageOperationStatus> resourceInstanceStatus = getResourceInstanceById(containerComponent,
3475 componentInstanceUniqueId);
3476 if (resourceInstanceStatus.isRight()) {
3477 return Either.right(componentsUtils
3478 .getResponseFormat(ActionStatus.RESOURCE_INSTANCE_NOT_FOUND_ON_SERVICE, componentInstanceUniqueId, containerComponentId));
3480 ComponentInstance foundResourceInstance = resourceInstanceStatus.left().value();
3482 StorageOperationStatus lockStatus = graphLockOperation.lockComponent(containerComponentId, componentTypeEnum.getNodeType());
3483 if (lockStatus != StorageOperationStatus.OK) {
3484 log.debug(FAILED_TO_LOCK_COMPONENT, containerComponentId);
3485 return Either.right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(lockStatus)));
3488 for (ComponentInstanceProperty property : properties) {
3489 Either<String, ResponseFormat> newPropertyValueEither = validatePropertyObjectValue(property, property.getValue(), false);
3490 newPropertyValueEither.bimap(
3491 updatedValue -> updateCapabilityPropertyOnContainerComponent(property, updatedValue, containerComponent, foundResourceInstance,
3492 capabilityType, capabilityName), Either::right);
3494 Either<Component, StorageOperationStatus> updateContainerRes = toscaOperationFacade
3495 .updateComponentInstanceMetadataOfTopologyTemplate(containerComponent);
3496 if (updateContainerRes.isRight()) {
3497 ActionStatus actionStatus = componentsUtils.convertFromStorageResponseForResourceInstanceProperty(updateContainerRes.right().value());
3498 resultOp = Either.right(componentsUtils.getResponseFormatForResourceInstanceProperty(actionStatus, ""));
3501 resultOp = Either.left(properties);
3504 if (resultOp == null || resultOp.isRight()) {
3505 janusGraphDao.rollback();
3507 janusGraphDao.commit();
3510 graphLockOperation.unlockComponent(containerComponentId, componentTypeEnum.getNodeType());
3514 public Either<Map<String, ComponentInstance>, ResponseFormat> copyComponentInstance(ComponentInstance inputComponentInstance,
3515 String containerComponentId, String componentInstanceId,
3517 Map<String, ComponentInstance> resultMap = new HashMap<>();
3518 Either<Component, StorageOperationStatus> getOrigComponent = toscaOperationFacade.getToscaElement(containerComponentId);
3519 if (getOrigComponent.isRight()) {
3520 log.error("Failed to get the original component information");
3521 return Either.right(componentsUtils.getResponseFormat(ActionStatus.USER_DEFINED, FAILED_TO_COPY_COMP_INSTANCE_TO_CANVAS));
3523 Component origComponent = getOrigComponent.left().value();
3525 lockComponent(origComponent, "copyComponentInstance");
3526 } catch (ComponentException e) {
3527 log.error("destComponentInstance's data is {}", origComponent.toString());
3528 return Either.right(componentsUtils
3529 .getResponseFormat(ActionStatus.USER_DEFINED, "Failed to lock component destComponentInstance's data is {}",
3530 origComponent.toString()));
3532 boolean failed = false;
3533 ComponentInstance actionResponse = null;
3535 actionResponse = createComponentInstance("services", containerComponentId, userId, inputComponentInstance, false);
3536 } catch (ComponentException e) {
3538 // on failure of the create instance unlock the resource and rollback the transaction.
3539 return Either.right(componentsUtils.getResponseFormat(ActionStatus.USER_DEFINED, FAILED_TO_COPY_COMP_INSTANCE_TO_CANVAS));
3541 // on failure of the create instance unlock the resource and rollback the transaction.
3542 if (null == actionResponse) {
3543 log.error(FAILED_TO_COPY_COMP_INSTANCE_TO_CANVAS);
3544 unlockComponent(failed, origComponent);
3547 Either<String, ResponseFormat> resultOp = null;
3549 ComponentInstance destComponentInstance = actionResponse;
3550 log.debug("destComponentInstance's data is {}", destComponentInstance);
3551 resultOp = deepCopyComponentInstance(origComponent, containerComponentId, componentInstanceId, destComponentInstance, userId);
3552 resultMap.put("componentInstance", destComponentInstance);
3555 if (resultOp == null || resultOp.isRight()) {
3556 unlockComponent(true, origComponent);
3557 janusGraphDao.rollback();
3558 log.error("Failed to deep copy component instance");
3560 unlockComponent(false, origComponent);
3561 janusGraphDao.commit();
3562 log.debug("Success trasaction commit");
3565 if (resultOp == null || resultOp.isRight()) {
3567 .right(componentsUtils.getResponseFormat(ActionStatus.USER_DEFINED, "Failed to deep copy the component instance to the canvas"));
3569 return Either.left(resultMap);
3573 private Either<String, ResponseFormat> deepCopyComponentInstance(Component sourceComponent, String containerComponentId,
3574 String sourceComponentInstanceId, ComponentInstance destComponentInstance,
3576 Either<Component, StorageOperationStatus> getDestComponent = toscaOperationFacade.getToscaElement(containerComponentId);
3577 if (getDestComponent.isRight()) {
3578 log.error("Failed to get the dest component information");
3579 return Either.right(componentsUtils.getResponseFormat(ActionStatus.USER_DEFINED, FAILED_TO_COPY_COMP_INSTANCE_TO_CANVAS));
3581 Component destComponent = getDestComponent.left().value();
3582 Either<String, ResponseFormat> copyComponentInstanceWithPropertiesAndInputs = copyComponentInstanceWithPropertiesAndInputs(sourceComponent,
3583 destComponent, sourceComponentInstanceId, destComponentInstance);
3584 if (copyComponentInstanceWithPropertiesAndInputs.isRight()) {
3585 log.error("Failed to copy component instance with properties and inputs as part of deep copy");
3586 return Either.right(componentsUtils.getResponseFormat(ActionStatus.USER_DEFINED,
3587 "Failed to copy the component instance with properties and inputs as part of deep copy"));
3589 Either<String, ResponseFormat> copyComponentInstanceWithAttributes = copyComponentInstanceWithAttributes(sourceComponent, destComponent,
3590 sourceComponentInstanceId, destComponentInstance, userId);
3591 if (copyComponentInstanceWithAttributes.isRight()) {
3592 log.error("Failed to copy component instance with attributes as part of deep copy");
3593 return Either.right(componentsUtils
3594 .getResponseFormat(ActionStatus.USER_DEFINED, "Failed to copy the component instance with attributes as part of deep copy"));
3596 return Either.left(COPY_COMPONENT_INSTANCE_OK);
3599 private Either<String, ResponseFormat> copyComponentInstanceWithPropertiesAndInputs(Component sourceComponent, Component destComponent,
3600 String sourceComponentInstanceId,
3601 ComponentInstance destComponentInstance) {
3602 log.debug("start to copy ComponentInstance with properties and inputs");
3603 List<ComponentInstanceProperty> sourcePropList = null;
3604 if (sourceComponent.getComponentInstancesProperties() != null
3605 && sourceComponent.getComponentInstancesProperties().get(sourceComponentInstanceId) != null) {
3606 sourcePropList = sourceComponent.getComponentInstancesProperties().get(sourceComponentInstanceId);
3607 log.debug("sourcePropList");
3609 List<ComponentInstanceProperty> destPropList = null;
3610 String destComponentInstanceId = destComponentInstance.getUniqueId();
3611 log.debug("destComponentInstanceId: {}", destComponentInstance.getUniqueId());
3612 if (destComponent.getComponentInstancesProperties() != null
3613 && destComponent.getComponentInstancesProperties().get(destComponentInstanceId) != null) {
3614 destPropList = destComponent.getComponentInstancesProperties().get(destComponentInstanceId);
3615 log.debug("destPropList {}");
3617 List<ComponentInstancePropInput> componentInstancePropInputList = new ArrayList<>();
3618 if (null != destPropList && null != sourcePropList) {
3619 log.debug("start to set property and attribute");
3620 for (ComponentInstanceProperty destProp : destPropList) {
3621 String destPropertyName = destProp.getName();
3622 for (ComponentInstanceProperty sourceProp : sourcePropList) {
3623 if (!destPropertyName.equals(sourceProp.getName())) {
3626 log.debug("now set property");
3627 final List<GetInputValueDataDefinition> getInputValues = sourceProp.getGetInputValues();
3628 if (getInputValues == null && !StringUtils.isEmpty(sourceProp.getValue()) && (destProp.getValue() == null || !destProp.getValue()
3629 .equals(sourceProp.getValue()))) {
3630 log.debug("Now starting to copy the property {} in value {}", destPropertyName, sourceProp.getValue());
3631 destProp.setValue(sourceProp.getValue());
3632 Either<String, ResponseFormat> updatePropertyValueEither = updateComponentInstanceProperty(destComponent.getUniqueId(),
3633 destComponentInstanceId, destProp);
3634 if (updatePropertyValueEither.isRight()) {
3635 log.error("Failed to copy the property {}", destPropertyName);
3636 return Either.right(componentsUtils.getResponseFormat(ActionStatus.INVALID_CONTENT_PARAM,
3637 "Failed to paste component instance to the canvas, property copy"));
3641 log.debug("Now start to update inputs");
3642 if (getInputValues != null) {
3643 if (getInputValues.isEmpty()) {
3644 log.debug("property is return from input, set by man");
3647 log.debug("Now starting to copy the {} property", destPropertyName);
3648 Either<String, ResponseFormat> getSourceInputDefaultValue = getInputListDefaultValue(sourceComponent,
3649 getInputValues.get(0).getInputId());
3650 if (getSourceInputDefaultValue.isRight()) {
3651 return Either.right(getSourceInputDefaultValue.right().value());
3653 componentInstancePropInputList.add(new ComponentInstancePropInput(destProp));
3658 return Either.left(COPY_COMPONENT_INSTANCE_OK);
3661 private Either<String, ResponseFormat> copyComponentInstanceWithAttributes(Component sourceComponent, Component destComponent,
3662 String sourceComponentInstanceId,
3663 ComponentInstance destComponentInstance, String userId) {
3664 String destComponentInstanceId = destComponentInstance.getUniqueId();
3665 log.info("start to copy component instance with attributes");
3666 List<ComponentInstanceAttribute> sourceAttributeList = null;
3667 if (sourceComponent.getComponentInstancesAttributes() != null
3668 && sourceComponent.getComponentInstancesAttributes().get(sourceComponentInstanceId) != null) {
3669 sourceAttributeList = sourceComponent.getComponentInstancesAttributes().get(sourceComponentInstanceId);
3670 log.info("sourceAttributes {}");
3672 List<ComponentInstanceAttribute> destAttributeList = null;
3673 if (destComponent.getComponentInstancesAttributes() != null
3674 && destComponent.getComponentInstancesAttributes().get(destComponentInstanceId) != null) {
3675 destAttributeList = destComponent.getComponentInstancesAttributes().get(destComponentInstanceId);
3676 log.info("destAttributeList {}");
3678 if (null != sourceAttributeList && null != destAttributeList) {
3679 log.info("set attribute");
3680 for (ComponentInstanceAttribute sourceAttribute : sourceAttributeList) {
3681 String sourceAttributeName = sourceAttribute.getName();
3682 for (ComponentInstanceAttribute destAttribute : destAttributeList) {
3683 if (sourceAttributeName.equals(destAttribute.getName())) {
3684 log.debug("Start to copy the attribute exists {}", sourceAttributeName);
3685 sourceAttribute.setUniqueId(
3686 UniqueIdBuilder.buildResourceInstanceUniuqeId("attribute", destComponentInstanceId.split("\\.")[1], sourceAttributeName));
3687 Either<ComponentInstanceAttribute, ResponseFormat> updateAttributeValueEither = createOrUpdateAttributeValueForCopyPaste(
3688 ComponentTypeEnum.SERVICE, destComponent.getUniqueId(), destComponentInstanceId, sourceAttribute, userId);
3689 if (updateAttributeValueEither.isRight()) {
3690 log.error("Failed to copy the attribute");
3691 return Either.right(componentsUtils.getResponseFormat(ActionStatus.INVALID_CONTENT_PARAM,
3692 "Failed to paste component instance to the canvas, attribute copy"));
3699 return Either.left(COPY_COMPONENT_INSTANCE_OK);
3702 private Either<ComponentInstanceAttribute, ResponseFormat> createOrUpdateAttributeValueForCopyPaste(ComponentTypeEnum componentTypeEnum,
3703 String componentId, String resourceInstanceId,
3704 ComponentInstanceAttribute attribute,
3706 Either<ComponentInstanceAttribute, ResponseFormat> resultOp = null;
3707 validateUserExists(userId);
3708 if (componentTypeEnum == null) {
3709 BeEcompErrorManager.getInstance()
3710 .logInvalidInputError("createOrUpdateAttributeValueForCopyPaste", INVALID_COMPONENT_TYPE, ErrorSeverity.INFO);
3711 resultOp = Either.right(componentsUtils.getResponseFormat(ActionStatus.NOT_ALLOWED));
3714 Either<Component, StorageOperationStatus> getResourceResult = toscaOperationFacade.getToscaElement(componentId, JsonParseFlagEnum.ParseAll);
3715 if (getResourceResult.isRight()) {
3716 log.info("Failed to retrieve component id {}", componentId);
3717 resultOp = Either.right(componentsUtils.getResponseFormat(ActionStatus.RESTRICTED_OPERATION));
3720 Component containerComponent = getResourceResult.left().value();
3721 Either<ComponentInstance, StorageOperationStatus> resourceInstanceStatus = getResourceInstanceById(containerComponent, resourceInstanceId);
3722 if (resourceInstanceStatus.isRight()) {
3724 .right(componentsUtils.getResponseFormat(ActionStatus.RESOURCE_INSTANCE_NOT_FOUND_ON_SERVICE, resourceInstanceId, componentId));
3727 ComponentInstance foundResourceInstance = resourceInstanceStatus.left().value();
3728 String propertyType = attribute.getType();
3729 ToscaPropertyType type = ToscaPropertyType.isValidType(propertyType);
3730 log.info("The type of attribute id{},is {} ", attribute.getUniqueId(), propertyType);
3731 if (type == ToscaPropertyType.LIST || type == ToscaPropertyType.MAP) {
3732 SchemaDefinition def = attribute.getSchema();
3734 log.info("Schema doesn't exists for attribute of type {}", type);
3736 .right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(StorageOperationStatus.INVALID_VALUE)));
3738 PropertyDataDefinition propDef = def.getProperty();
3739 if (propDef == null) {
3740 log.info("Attribute in Schema Definition inside attribute of type {} doesn't exist", type);
3742 .right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(StorageOperationStatus.INVALID_VALUE)));
3745 List<ComponentInstanceAttribute> instanceAttributes = containerComponent.getComponentInstancesAttributes().get(resourceInstanceId);
3746 Optional<ComponentInstanceAttribute> instanceAttribute = instanceAttributes.stream()
3747 .filter(p -> p.getUniqueId().equals(attribute.getUniqueId())).findAny();
3748 StorageOperationStatus status;
3749 if (instanceAttribute.isPresent()) {
3750 log.info("updateComponentInstanceAttribute");
3751 status = toscaOperationFacade.updateComponentInstanceAttribute(containerComponent, foundResourceInstance.getUniqueId(), attribute);
3753 log.info("addComponentInstanceAttribute");
3754 status = toscaOperationFacade.addComponentInstanceAttribute(containerComponent, foundResourceInstance.getUniqueId(), attribute);
3756 if (status != StorageOperationStatus.OK) {
3757 ActionStatus actionStatus = componentsUtils.convertFromStorageResponseForResourceInstanceProperty(status);
3758 resultOp = Either.right(componentsUtils.getResponseFormatForResourceInstanceProperty(actionStatus, ""));
3761 List<String> path = new ArrayList<>();
3762 path.add(foundResourceInstance.getUniqueId());
3763 attribute.setPath(path);
3764 foundResourceInstance.setCustomizationUUID(UUID.randomUUID().toString());
3765 Either<Component, StorageOperationStatus> updateContainerRes = toscaOperationFacade
3766 .updateComponentInstanceMetadataOfTopologyTemplate(containerComponent);
3767 if (updateContainerRes.isRight()) {
3768 ActionStatus actionStatus = componentsUtils.convertFromStorageResponseForResourceInstanceProperty(updateContainerRes.right().value());
3769 resultOp = Either.right(componentsUtils.getResponseFormatForResourceInstanceProperty(actionStatus, ""));
3772 resultOp = Either.left(attribute);
3776 private Either<String, ResponseFormat> updateComponentInstanceProperty(String containerComponentId, String componentInstanceId,
3777 ComponentInstanceProperty property) {
3778 Either<String, ResponseFormat> resultOp;
3779 Either<Component, StorageOperationStatus> getComponent = toscaOperationFacade.getToscaElement(containerComponentId);
3780 if (getComponent.isRight()) {
3781 log.error("Failed to get the component information");
3782 return Either.right(componentsUtils
3783 .getResponseFormatForResourceInstanceProperty(ActionStatus.INVALID_CONTENT_PARAM, "Failed to get the component information"));
3785 Component containerComponent = getComponent.left().value();
3786 StorageOperationStatus status = toscaOperationFacade.updateComponentInstanceProperty(containerComponent, componentInstanceId, property);
3787 if (status != StorageOperationStatus.OK) {
3788 ActionStatus actionStatus = componentsUtils.convertFromStorageResponseForResourceInstanceProperty(status);
3789 resultOp = Either.right(componentsUtils.getResponseFormatForResourceInstanceProperty(actionStatus, ""));
3792 Either<Component, StorageOperationStatus> updateContainerRes = toscaOperationFacade
3793 .updateComponentInstanceMetadataOfTopologyTemplate(containerComponent);
3794 if (updateContainerRes.isRight()) {
3795 ActionStatus actionStatus = componentsUtils.convertFromStorageResponseForResourceInstanceProperty(updateContainerRes.right().value());
3796 resultOp = Either.right(componentsUtils.getResponseFormatForResourceInstanceProperty(actionStatus, ""));
3799 return Either.left("Update OK");
3802 private Either<String, ResponseFormat> getInputListDefaultValue(Component component, String inputId) {
3803 List<InputDefinition> inputList = component.getInputs();
3804 for (InputDefinition input : inputList) {
3805 if (input.getUniqueId().equals(inputId)) {
3806 if (input.getDefaultValue() == null) {
3807 log.debug("The input's default value is null");
3808 return Either.left(null);
3810 return Either.left(input.getDefaultValue());
3813 log.error("The input's default value with id {} is not found", inputId);
3814 return Either.right(componentsUtils.getResponseFormat(ActionStatus.USER_DEFINED, "Failed to paste component instance to the canvas"));
3818 * Method to delete selected nodes and edges on composition page
3820 * @param containerComponentType
3821 * @param componentId
3822 * @param componentInstanceIdList
3826 public Map<String, List<String>> batchDeleteComponentInstance(String containerComponentType, String componentId,
3827 List<String> componentInstanceIdList, String userId) {
3828 List<String> deleteErrorIds = new ArrayList<>();
3829 Map<String, List<String>> deleteErrorMap = new HashMap<>();
3830 validateUserExists(userId);
3831 org.openecomp.sdc.be.model.Component containerComponent = validateComponentExists(componentId,
3832 ComponentTypeEnum.findByParamName(containerComponentType), null);
3833 boolean failed = false;
3835 lockComponent(containerComponent, "batchDeleteComponentInstance");
3836 for (String eachInstanceId : componentInstanceIdList) {
3837 Either<ComponentInstance, ResponseFormat> actionResponse = batchDeleteComponentInstance(containerComponent, containerComponentType,
3839 log.debug("batchDeleteResourceInstances actionResponse is {}", actionResponse);
3840 if (actionResponse.isRight()) {
3841 log.error("Failed to delete ComponentInstance [{}]", eachInstanceId);
3842 deleteErrorIds.add(eachInstanceId);
3845 //sending the ids of the error nodes that were not deleted to UI
3846 deleteErrorMap.put("deleteFailedIds", deleteErrorIds);
3847 return deleteErrorMap;
3848 } catch (ComponentException e) {
3852 unlockComponent(failed, containerComponent);
3856 private Either<ComponentInstance, ResponseFormat> batchDeleteComponentInstance(Component containerComponent, String containerComponentType,
3857 String componentInstanceId) {
3858 ComponentInstance resultOp;
3859 final ComponentTypeEnum containerComponentTypeEnum = ComponentTypeEnum.findByParamName(containerComponentType);
3861 resultOp = deleteComponentInstance(containerComponent, componentInstanceId, containerComponentTypeEnum);
3862 log.info("Successfully deleted instance with id {}", componentInstanceId);
3863 return Either.left(resultOp);
3864 } catch (ComponentException e) {
3865 log.error("Failed to deleteComponentInstance with instanceId[{}]", componentInstanceId);
3866 return Either.right(new ResponseFormat());
3870 public void validateUser(final String userId) {
3871 final User user = userValidations.validateUserExists(userId);
3872 userValidations.validateUserRole(user, Arrays.asList(Role.DESIGNER, Role.ADMIN));
3875 public void setCompositionBusinessLogic(CompositionBusinessLogic compositionBusinessLogic) {
3876 this.compositionBusinessLogic = compositionBusinessLogic;
3879 public void setContainerInstanceTypesData(ContainerInstanceTypesData containerInstanceTypesData) {
3880 this.containerInstanceTypesData = containerInstanceTypesData;