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.openecomp.sdc.be.components.impl.exceptions.BusinessLogicException;
47 import org.openecomp.sdc.be.components.impl.exceptions.ByActionStatusComponentException;
48 import org.openecomp.sdc.be.components.impl.exceptions.ByResponseFormatComponentException;
49 import org.openecomp.sdc.be.components.impl.exceptions.ComponentException;
50 import org.openecomp.sdc.be.components.impl.instance.ComponentInstanceChangeOperationOrchestrator;
51 import org.openecomp.sdc.be.components.impl.utils.DirectivesUtil;
52 import org.openecomp.sdc.be.components.merge.instance.ComponentInstanceMergeDataBusinessLogic;
53 import org.openecomp.sdc.be.components.merge.instance.DataForMergeHolder;
54 import org.openecomp.sdc.be.components.utils.PropertiesUtils;
55 import org.openecomp.sdc.be.components.validation.ComponentValidations;
56 import org.openecomp.sdc.be.config.BeEcompErrorManager;
57 import org.openecomp.sdc.be.config.BeEcompErrorManager.ErrorSeverity;
58 import org.openecomp.sdc.be.config.ConfigurationManager;
59 import org.openecomp.sdc.be.dao.api.ActionStatus;
60 import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus;
61 import org.openecomp.sdc.be.dao.jsongraph.types.JsonParseFlagEnum;
62 import org.openecomp.sdc.be.dao.neo4j.GraphPropertiesDictionary;
63 import org.openecomp.sdc.be.datatypes.elements.CINodeFilterDataDefinition;
64 import org.openecomp.sdc.be.datatypes.elements.CapabilityDataDefinition;
65 import org.openecomp.sdc.be.datatypes.elements.ForwardingPathDataDefinition;
66 import org.openecomp.sdc.be.datatypes.elements.GetInputValueDataDefinition;
67 import org.openecomp.sdc.be.datatypes.elements.GetOutputValueDataDefinition;
68 import org.openecomp.sdc.be.datatypes.elements.GetPolicyValueDataDefinition;
69 import org.openecomp.sdc.be.datatypes.elements.PropertyDataDefinition;
70 import org.openecomp.sdc.be.datatypes.elements.RequirementDataDefinition;
71 import org.openecomp.sdc.be.datatypes.elements.SchemaDefinition;
72 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
73 import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
74 import org.openecomp.sdc.be.datatypes.enums.OriginTypeEnum;
75 import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum;
76 import org.openecomp.sdc.be.datatypes.tosca.ToscaGetFunctionType;
77 import org.openecomp.sdc.be.exception.BusinessException;
78 import org.openecomp.sdc.be.impl.ComponentsUtils;
79 import org.openecomp.sdc.be.impl.ForwardingPathUtils;
80 import org.openecomp.sdc.be.impl.ServiceFilterUtils;
81 import org.openecomp.sdc.be.info.CreateAndAssotiateInfo;
82 import org.openecomp.sdc.be.model.ArtifactDefinition;
83 import org.openecomp.sdc.be.model.AttributeDefinition;
84 import org.openecomp.sdc.be.model.CapabilityDefinition;
85 import org.openecomp.sdc.be.model.Component;
86 import org.openecomp.sdc.be.model.ComponentInstance;
87 import org.openecomp.sdc.be.model.ComponentInstanceAttribute;
88 import org.openecomp.sdc.be.model.ComponentInstanceInput;
89 import org.openecomp.sdc.be.model.ComponentInstanceOutput;
90 import org.openecomp.sdc.be.model.ComponentInstancePropInput;
91 import org.openecomp.sdc.be.model.ComponentInstanceProperty;
92 import org.openecomp.sdc.be.model.ComponentParametersView;
93 import org.openecomp.sdc.be.model.DataTypeDefinition;
94 import org.openecomp.sdc.be.model.GroupDefinition;
95 import org.openecomp.sdc.be.model.InputDefinition;
96 import org.openecomp.sdc.be.model.InterfaceDefinition;
97 import org.openecomp.sdc.be.model.LifecycleStateEnum;
98 import org.openecomp.sdc.be.model.OutputDefinition;
99 import org.openecomp.sdc.be.model.PolicyDefinition;
100 import org.openecomp.sdc.be.model.PropertyDefinition;
101 import org.openecomp.sdc.be.model.RelationshipInfo;
102 import org.openecomp.sdc.be.model.RequirementCapabilityRelDef;
103 import org.openecomp.sdc.be.model.RequirementDefinition;
104 import org.openecomp.sdc.be.model.Resource;
105 import org.openecomp.sdc.be.model.Service;
106 import org.openecomp.sdc.be.model.User;
107 import org.openecomp.sdc.be.model.jsonjanusgraph.config.ContainerInstanceTypesData;
108 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.ArtifactsOperations;
109 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.ForwardingPathOperation;
110 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.InterfaceOperation;
111 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.NodeFilterOperation;
112 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.NodeTemplateOperation;
113 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.ToscaOperationFacade;
114 import org.openecomp.sdc.be.model.jsonjanusgraph.utils.ModelConverter;
115 import org.openecomp.sdc.be.model.operations.StorageException;
116 import org.openecomp.sdc.be.model.operations.api.IElementOperation;
117 import org.openecomp.sdc.be.model.operations.api.IGroupInstanceOperation;
118 import org.openecomp.sdc.be.model.operations.api.IGroupOperation;
119 import org.openecomp.sdc.be.model.operations.api.IGroupTypeOperation;
120 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
121 import org.openecomp.sdc.be.model.operations.impl.ComponentInstanceOperation;
122 import org.openecomp.sdc.be.model.operations.impl.DaoStatusConverter;
123 import org.openecomp.sdc.be.model.operations.impl.InterfaceLifecycleOperation;
124 import org.openecomp.sdc.be.model.operations.impl.UniqueIdBuilder;
125 import org.openecomp.sdc.be.model.operations.utils.ComponentValidationUtils;
126 import org.openecomp.sdc.be.model.tosca.ToscaPropertyType;
127 import org.openecomp.sdc.be.resources.data.ComponentInstanceData;
128 import org.openecomp.sdc.be.user.Role;
129 import org.openecomp.sdc.common.api.ArtifactGroupTypeEnum;
130 import org.openecomp.sdc.common.api.ArtifactTypeEnum;
131 import org.openecomp.sdc.common.api.Constants;
132 import org.openecomp.sdc.common.datastructure.Wrapper;
133 import org.openecomp.sdc.common.jsongraph.util.CommonUtility;
134 import org.openecomp.sdc.common.jsongraph.util.CommonUtility.LogLevelEnum;
135 import org.openecomp.sdc.common.log.elements.ErrorLogOptionalData;
136 import org.openecomp.sdc.common.log.enums.EcompLoggerErrorCode;
137 import org.openecomp.sdc.common.log.wrappers.Logger;
138 import org.openecomp.sdc.common.util.ValidationUtils;
139 import org.openecomp.sdc.exception.ResponseFormat;
140 import org.springframework.beans.factory.annotation.Autowired;
142 @org.springframework.stereotype.Component
143 public class ComponentInstanceBusinessLogic extends BaseBusinessLogic {
145 private static final Logger log = Logger.getLogger(ComponentInstanceBusinessLogic.class);
146 private static final String VF_MODULE = "org.openecomp.groups.VfModule";
147 private static final String TRY_TO_CREATE_ENTRY_ON_GRAPH = "Try to create entry on graph";
148 private static final String CLOUD_SPECIFIC_FIXED_KEY_WORD = "cloudtech";
149 private static final String[][] CLOUD_SPECIFIC_KEY_WORDS = {{"k8s", "azure", "aws"}, /* cloud specific technology */
150 {"charts", "day0", "configtemplate"} /*cloud specific sub type*/};
151 private static final String FAILED_TO_CREATE_ENTRY_ON_GRAPH_FOR_COMPONENT_INSTANCE = "Failed to create entry on graph for component instance {}";
152 private static final String ENTITY_ON_GRAPH_IS_CREATED = "Entity on graph is created.";
153 private static final String INVALID_COMPONENT_TYPE = "invalid component type";
154 private static final String FAILED_TO_RETRIEVE_COMPONENT_COMPONENT_ID = "Failed to retrieve component, component id {}";
155 private static final String FAILED_TO_LOCK_SERVICE = "Failed to lock service {}";
156 private static final String CREATE_OR_UPDATE_PROPERTY_VALUE = "CreateOrUpdatePropertyValue";
157 private static final String FAILED_TO_COPY_COMP_INSTANCE_TO_CANVAS = "Failed to copy the component instance to the canvas";
158 private static final String COPY_COMPONENT_INSTANCE_OK = "Copy component instance OK";
159 private static final String CANNOT_ATTACH_RESOURCE_INSTANCES_TO_CONTAINER_RESOURCE_OF_TYPE = "Cannot attach resource instances to container resource of type {}";
160 private static final String FAILED_TO_UPDATE_COMPONENT_INSTANCE_CAPABILITY = "Failed to update component instance capability on instance {} in "
162 private static final String SERVICE_PROXY = "serviceProxy";
163 private static final String ASSOCIATE_RI_TO_RI = "associateRIToRI";
164 private static final String COMPONENT_ARCHIVED = "Component is archived. Component id: {}";
165 private static final String RESTRICTED_OPERATION_ON_SERVIVE = "Restricted operation for user: {} on service {}";
166 private static final String FAILED_TO_LOCK_COMPONENT = "Failed to lock component {}";
167 private static final String RESTRICTED_OPERATION_ON_COMPONENT = "Restricted operation for user: {} on component {}";
168 private static final String RESOURCE_INSTANCE = "resource instance";
169 private static final String SERVICE = "service";
170 private static final String UPDATE_PROPERTY_CONTEXT = "UpdatePropertyValueOnComponentInstance";
172 private ComponentInstanceOperation componentInstanceOperation;
173 private ArtifactsBusinessLogic artifactBusinessLogic;
174 private ComponentInstanceMergeDataBusinessLogic compInstMergeDataBL;
175 private ComponentInstanceChangeOperationOrchestrator onChangeInstanceOperationOrchestrator;
176 private ForwardingPathOperation forwardingPathOperation;
177 private NodeFilterOperation nodeFilterOperation;
179 private CompositionBusinessLogic compositionBusinessLogic;
181 private ContainerInstanceTypesData containerInstanceTypesData;
184 public ComponentInstanceBusinessLogic(IElementOperation elementDao, IGroupOperation groupOperation,
185 IGroupInstanceOperation groupInstanceOperation, IGroupTypeOperation groupTypeOperation,
186 InterfaceOperation interfaceOperation, InterfaceLifecycleOperation interfaceLifecycleTypeOperation,
187 ComponentInstanceOperation componentInstanceOperation, ArtifactsBusinessLogic artifactBusinessLogic,
188 ComponentInstanceMergeDataBusinessLogic compInstMergeDataBL,
189 ComponentInstanceChangeOperationOrchestrator onChangeInstanceOperationOrchestrator,
190 ForwardingPathOperation forwardingPathOperation, NodeFilterOperation nodeFilterOperation,
191 ArtifactsOperations artifactToscaOperation) {
192 super(elementDao, groupOperation, groupInstanceOperation, groupTypeOperation, interfaceOperation, interfaceLifecycleTypeOperation,
193 artifactToscaOperation);
194 this.componentInstanceOperation = componentInstanceOperation;
195 this.artifactBusinessLogic = artifactBusinessLogic;
196 this.compInstMergeDataBL = compInstMergeDataBL;
197 this.onChangeInstanceOperationOrchestrator = onChangeInstanceOperationOrchestrator;
198 this.forwardingPathOperation = forwardingPathOperation;
199 this.nodeFilterOperation = nodeFilterOperation;
202 public ComponentInstance createComponentInstance(String containerComponentParam, String containerComponentId, String userId,
203 ComponentInstance resourceInstance) {
204 return createComponentInstance(containerComponentParam, containerComponentId, userId, resourceInstance, true);
207 public List<ComponentInstanceProperty> getComponentInstancePropertiesByInputId(org.openecomp.sdc.be.model.Component component, String inputId) {
208 List<ComponentInstanceProperty> resList = new ArrayList<>();
209 Map<String, List<ComponentInstanceProperty>> ciPropertiesMap = component.getComponentInstancesProperties();
210 if (ciPropertiesMap != null && !ciPropertiesMap.isEmpty()) {
211 ciPropertiesMap.forEach((s, ciPropList) -> {
213 Optional<ComponentInstance> ciOp = component.getComponentInstances().stream().filter(ci -> ci.getUniqueId().equals(s)).findAny();
214 if (ciOp.isPresent()) {
215 ciName = ciOp.get().getName();
217 if (ciPropList != null && !ciPropList.isEmpty()) {
218 for (ComponentInstanceProperty prop : ciPropList) {
219 List<GetInputValueDataDefinition> inputsValues = prop.getGetInputValues();
220 addCompInstanceProperty(s, ciName, prop, inputsValues, inputId, resList);
228 public List<ComponentInstanceAttribute> getComponentInstanceAttributesByOutputId(final org.openecomp.sdc.be.model.Component component,
229 final String outputId) {
230 final List<ComponentInstanceAttribute> resList = new ArrayList<>();
231 final Map<String, List<ComponentInstanceAttribute>> componentInstancesAttributes = component.getComponentInstancesAttributes();
232 if (org.apache.commons.collections4.MapUtils.isNotEmpty(componentInstancesAttributes)) {
233 componentInstancesAttributes.forEach((s, componentInstanceAttributeList) -> {
235 final Optional<ComponentInstance> ciOp = component.getComponentInstances().stream().filter(ci -> ci.getUniqueId().equals(s))
237 if (ciOp.isPresent()) {
238 ciName = ciOp.get().getName();
240 if (componentInstanceAttributeList != null && !componentInstanceAttributeList.isEmpty()) {
241 for (final ComponentInstanceAttribute compInstanceAttribute : componentInstanceAttributeList) {
242 List<GetOutputValueDataDefinition> outputValues = compInstanceAttribute.getGetOutputValues();
243 addCompInstanceAttribute(s, ciName, compInstanceAttribute, outputValues, outputId, resList);
251 private void addCompInstanceProperty(String s, String ciName, ComponentInstanceProperty prop, List<GetInputValueDataDefinition> inputsValues,
252 String inputId, List<ComponentInstanceProperty> resList) {
253 if (inputsValues != null && !inputsValues.isEmpty()) {
254 for (GetInputValueDataDefinition inputData : inputsValues) {
255 if (isGetInputValueForInput(inputData, inputId)) {
256 prop.setComponentInstanceId(s);
257 prop.setComponentInstanceName(ciName);
265 private void addCompInstanceAttribute(final String s, final String ciName, final ComponentInstanceAttribute attribute,
266 final List<GetOutputValueDataDefinition> outputsValues, final String outputId,
267 final List<ComponentInstanceAttribute> resList) {
268 if (outputsValues != null && !outputsValues.isEmpty()) {
269 for (final GetOutputValueDataDefinition outputData : outputsValues) {
270 if (isGetOutputValueForOutput(outputData, outputId)) {
271 attribute.setComponentInstanceId(s);
272 attribute.setComponentInstanceName(ciName);
273 resList.add(attribute);
280 public Optional<ComponentInstanceProperty> getComponentInstancePropertyByPolicyId(Component component, PolicyDefinition policy) {
281 Optional<ComponentInstanceProperty> propertyCandidate = getComponentInstancePropertyByPolicy(component, policy);
282 if (propertyCandidate.isPresent()) {
283 ComponentInstanceProperty componentInstanceProperty = propertyCandidate.get();
284 Optional<GetPolicyValueDataDefinition> getPolicyCandidate = getGetPolicyValueDataDefinition(policy, componentInstanceProperty);
286 .ifPresent(getPolicyValue -> updateComponentInstancePropertyAfterUndeclaration(componentInstanceProperty, getPolicyValue, policy));
287 return Optional.of(componentInstanceProperty);
289 return Optional.empty();
292 private void updateComponentInstancePropertyAfterUndeclaration(ComponentInstanceProperty componentInstanceProperty,
293 GetPolicyValueDataDefinition getPolicyValue, PolicyDefinition policyDefinition) {
294 componentInstanceProperty.setValue(getPolicyValue.getOrigPropertyValue());
295 List<GetPolicyValueDataDefinition> getPolicyValues = componentInstanceProperty.getGetPolicyValues();
296 if (CollectionUtils.isNotEmpty(getPolicyValues)) {
297 getPolicyValues.remove(getPolicyValue);
298 componentInstanceProperty.setGetPolicyValues(getPolicyValues);
299 policyDefinition.setGetPolicyValues(getPolicyValues);
303 private Optional<GetPolicyValueDataDefinition> getGetPolicyValueDataDefinition(PolicyDefinition policy,
304 ComponentInstanceProperty componentInstanceProperty) {
305 List<GetPolicyValueDataDefinition> getPolicyValues = policy.getGetPolicyValues();
306 return getPolicyValues.stream().filter(getPolicyValue -> getPolicyValue.getPropertyName().equals(componentInstanceProperty.getName()))
310 private Optional<ComponentInstanceProperty> getComponentInstancePropertyByPolicy(Component component, PolicyDefinition policy) {
311 Map<String, List<ComponentInstanceProperty>> componentInstancesProperties = component.getComponentInstancesProperties();
312 if (MapUtils.isEmpty(componentInstancesProperties)) {
313 return Optional.empty();
315 String instanceUniqueId = policy.getInstanceUniqueId();
316 List<ComponentInstanceProperty> componentInstanceProperties =
317 componentInstancesProperties.containsKey(instanceUniqueId) ? componentInstancesProperties.get(instanceUniqueId) : new ArrayList<>();
318 return componentInstanceProperties.stream().filter(property -> property.getName().equals(policy.getName())).findAny();
321 public List<ComponentInstanceInput> getComponentInstanceInputsByInputId(org.openecomp.sdc.be.model.Component component, String inputId) {
322 List<ComponentInstanceInput> resList = new ArrayList<>();
323 Map<String, List<ComponentInstanceInput>> ciInputsMap = component.getComponentInstancesInputs();
324 if (ciInputsMap != null && !ciInputsMap.isEmpty()) {
325 ciInputsMap.forEach((s, ciPropList) -> {
327 Optional<ComponentInstance> ciOp = component.getComponentInstances().stream().filter(ci -> ci.getUniqueId().equals(s)).findAny();
328 if (ciOp.isPresent()) {
329 ciName = ciOp.get().getName();
331 if (ciPropList != null && !ciPropList.isEmpty()) {
332 for (ComponentInstanceInput prop : ciPropList) {
333 List<GetInputValueDataDefinition> inputsValues = prop.getGetInputValues();
334 addCompInstanceInput(s, ciName, prop, inputsValues, inputId, resList);
342 public List<ComponentInstanceOutput> getComponentInstanceOutputsByOutputId(final org.openecomp.sdc.be.model.Component component,
343 final String outputId) {
344 final List<ComponentInstanceOutput> resList = new ArrayList<>();
345 final Map<String, List<ComponentInstanceOutput>> ciInputsMap = component.getComponentInstancesOutputs();
346 if (ciInputsMap != null && !ciInputsMap.isEmpty()) {
347 ciInputsMap.forEach((s, ciPropList) -> {
349 final Optional<ComponentInstance> ciOp = component.getComponentInstances().stream().filter(ci -> ci.getUniqueId().equals(s))
351 if (ciOp.isPresent()) {
352 ciName = ciOp.get().getName();
354 if (ciPropList != null && !ciPropList.isEmpty()) {
355 for (final ComponentInstanceOutput prop : ciPropList) {
356 final List<GetOutputValueDataDefinition> outputValues = prop.getGetOutputValues();
357 addCompInstanceOutput(s, ciName, prop, outputValues, outputId, resList);
365 private void addCompInstanceInput(String s, String ciName, ComponentInstanceInput prop, List<GetInputValueDataDefinition> inputsValues,
366 String inputId, List<ComponentInstanceInput> resList) {
367 if (inputsValues != null && !inputsValues.isEmpty()) {
368 for (GetInputValueDataDefinition inputData : inputsValues) {
369 if (isGetInputValueForInput(inputData, inputId)) {
370 prop.setComponentInstanceId(s);
371 prop.setComponentInstanceName(ciName);
379 private void addCompInstanceOutput(final String s, final String ciName, final ComponentInstanceOutput prop,
380 final List<GetOutputValueDataDefinition> outputsValues, final String outputId,
381 final List<ComponentInstanceOutput> resList) {
382 if (outputsValues != null && !outputsValues.isEmpty()) {
383 for (final GetOutputValueDataDefinition outputData : outputsValues) {
384 if (isGetOutputValueForOutput(outputData, outputId)) {
385 prop.setComponentInstanceId(s);
386 prop.setComponentInstanceName(ciName);
394 public ComponentInstance createComponentInstance(final String containerComponentParam, final String containerComponentId, final String userId,
395 final ComponentInstance resourceInstance, final boolean needLock) {
396 final User user = validateUserExists(userId);
397 validateUserNotEmpty(user, "Create component instance");
398 validateJsonBody(resourceInstance, ComponentInstance.class);
399 final ComponentTypeEnum containerComponentType = validateComponentType(containerComponentParam);
400 final org.openecomp.sdc.be.model.Component containerComponent = validateComponentExists(containerComponentId, containerComponentType, null);
401 if (ModelConverter.isAtomicComponent(containerComponent)) {
402 if (log.isDebugEnabled()) {
403 log.debug(CANNOT_ATTACH_RESOURCE_INSTANCES_TO_CONTAINER_RESOURCE_OF_TYPE, containerComponent.assetType());
405 throw new ByActionStatusComponentException(ActionStatus.RESOURCE_CANNOT_CONTAIN_RESOURCE_INSTANCES, containerComponent.assetType());
407 validateCanWorkOnComponent(containerComponent, userId);
408 Component origComponent = null;
409 if (resourceInstance != null && containerComponentType != null) {
410 final OriginTypeEnum originType = resourceInstance.getOriginType();
411 validateInstanceName(resourceInstance);
412 if (originType == OriginTypeEnum.ServiceProxy) {
413 origComponent = getOrigComponentForServiceProxy(containerComponent, resourceInstance);
414 } else if (originType == OriginTypeEnum.ServiceSubstitution) {
415 origComponent = getOrigComponentForServiceSubstitution(resourceInstance);
417 origComponent = getAndValidateOriginComponentOfComponentInstance(containerComponent, resourceInstance);
418 validateOriginAndResourceInstanceTypes(containerComponent, origComponent, originType);
420 validateResourceInstanceState(containerComponent, origComponent);
421 overrideFields(origComponent, resourceInstance);
422 compositionBusinessLogic.validateAndSetDefaultCoordinates(resourceInstance);
424 return createComponent(needLock, containerComponent, origComponent, resourceInstance, user);
427 private Component getOrigComponentForServiceProxy(org.openecomp.sdc.be.model.Component containerComponent, ComponentInstance resourceInstance) {
428 Either<Component, StorageOperationStatus> serviceProxyOrigin = toscaOperationFacade.getLatestByName(SERVICE_PROXY, null);
429 if (isServiceProxyOrigin(serviceProxyOrigin)) {
430 throw new ByActionStatusComponentException(componentsUtils.convertFromStorageResponse(serviceProxyOrigin.right().value()));
432 Component origComponent = serviceProxyOrigin.left().value();
433 StorageOperationStatus fillProxyRes = fillInstanceData(resourceInstance, origComponent);
434 if (isFillProxyRes(fillProxyRes)) {
435 throw new ByActionStatusComponentException(componentsUtils.convertFromStorageResponse(fillProxyRes));
437 validateOriginAndResourceInstanceTypes(containerComponent, origComponent, OriginTypeEnum.ServiceProxy);
438 return origComponent;
441 private Component getOrigComponentForServiceSubstitution(ComponentInstance resourceInstance) {
442 final Either<Component, StorageOperationStatus> getServiceResult = toscaOperationFacade
443 .getToscaFullElement(resourceInstance.getComponentUid());
444 if (getServiceResult.isRight()) {
445 throw new ByActionStatusComponentException(componentsUtils.convertFromStorageResponse(getServiceResult.right().value()));
447 final Component service = getServiceResult.left().value();
448 final Either<Component, StorageOperationStatus> getServiceDerivedFromTypeResult = toscaOperationFacade
449 .getLatestByToscaResourceName(service.getDerivedFromGenericType(), service.getModel());
450 if (getServiceDerivedFromTypeResult.isRight()) {
451 throw new ByActionStatusComponentException(componentsUtils.convertFromStorageResponse(getServiceResult.right().value()));
453 Component origComponent = getServiceDerivedFromTypeResult.left().value();
454 final StorageOperationStatus fillProxyRes = fillInstanceData(resourceInstance, origComponent);
455 if (isFillProxyRes(fillProxyRes)) {
456 throw new ByActionStatusComponentException(componentsUtils.convertFromStorageResponse(fillProxyRes));
458 return origComponent;
461 private ComponentInstance createComponent(boolean needLock, Component containerComponent, Component origComponent,
462 ComponentInstance resourceInstance, User user) {
463 boolean failed = false;
465 lockIfNeed(needLock, containerComponent);
466 log.debug(TRY_TO_CREATE_ENTRY_ON_GRAPH);
467 return createComponentInstanceOnGraph(containerComponent, origComponent, resourceInstance, user);
468 } catch (ComponentException e) {
473 unlockComponent(failed, containerComponent);
479 * Try using either to make a judgment
481 * @param containerComponentParam
482 * @param containerComponentId
484 * @param resourceInstance
487 public Either<ComponentInstance, ResponseFormat> createRealComponentInstance(String containerComponentParam, String containerComponentId,
488 String userId, ComponentInstance resourceInstance) {
489 log.debug("enter createRealComponentInstance");
490 return createRealComponentInstance(containerComponentParam, containerComponentId, userId, resourceInstance, true);
494 * Try using either to make a judgment
497 * @param containerComponentParam
498 * @param containerComponentId
500 * @param resourceInstance
503 public Either<ComponentInstance, ResponseFormat> createRealComponentInstance(String containerComponentParam, String containerComponentId,
504 String userId, ComponentInstance resourceInstance,
506 log.debug("enter createRealComponentInstance");
507 Component origComponent = null;
509 org.openecomp.sdc.be.model.Component containerComponent = null;
510 ComponentTypeEnum containerComponentType;
512 user = validateUserExists(userId);
513 validateUserNotEmpty(user, "Create component instance");
514 validateJsonBody(resourceInstance, ComponentInstance.class);
515 containerComponentType = validateComponentType(containerComponentParam);
516 containerComponent = validateComponentExists(containerComponentId, containerComponentType, null);
517 log.debug("enter createRealComponentInstance,validate user json success");
518 if (ModelConverter.isAtomicComponent(containerComponent)) {
519 log.debug(CANNOT_ATTACH_RESOURCE_INSTANCES_TO_CONTAINER_RESOURCE_OF_TYPE, containerComponent.assetType());
520 throw new ByActionStatusComponentException(ActionStatus.RESOURCE_CANNOT_CONTAIN_RESOURCE_INSTANCES, containerComponent.assetType());
522 validateCanWorkOnComponent(containerComponent, userId);
523 log.debug("enter createRealComponentInstance,validateCanWorkOnComponent success");
524 if (resourceInstance != null && containerComponentType != null) {
525 log.debug("enter createRealComponentInstance,start create ComponentInstance");
526 OriginTypeEnum originType = resourceInstance.getOriginType();
527 validateInstanceName(resourceInstance);
528 if (originType == OriginTypeEnum.ServiceProxy) {
529 log.debug("enter createRealComponentInstance,originType equals ServiceProxy");
530 Either<Component, StorageOperationStatus> serviceProxyOrigin = toscaOperationFacade.getLatestByName(SERVICE_PROXY, null);
531 if (isServiceProxyOrigin(serviceProxyOrigin)) {
532 throw new ByActionStatusComponentException(componentsUtils.convertFromStorageResponse(serviceProxyOrigin.right().value()));
534 origComponent = serviceProxyOrigin.left().value();
535 StorageOperationStatus fillProxyRes = fillInstanceData(resourceInstance, origComponent);
536 if (isFillProxyRes(fillProxyRes)) {
537 throw new ByActionStatusComponentException(componentsUtils.convertFromStorageResponse(fillProxyRes));
540 log.debug("enter createRealComponentInstance,originType is not ServiceProxy");
541 origComponent = getAndValidateOriginComponentOfComponentInstance(containerComponent, resourceInstance);
543 validateOriginAndResourceInstanceTypes(containerComponent, origComponent, originType);
544 validateResourceInstanceState(containerComponent, origComponent);
545 overrideFields(origComponent, resourceInstance);
546 compositionBusinessLogic.validateAndSetDefaultCoordinates(resourceInstance);
547 log.debug("enter createRealComponentInstance,final validate success");
549 return createRealComponent(needLock, containerComponent, origComponent, resourceInstance, user);
550 } catch (ComponentException e) {
551 log.debug("create Real Component Instance failed");
556 private Either<ComponentInstance, ResponseFormat> createRealComponent(boolean needLock, Component containerComponent, Component origComponent,
557 ComponentInstance resourceInstance, User user) {
558 log.debug("enter createRealComponent");
559 boolean failed = false;
561 lockIfNeed(needLock, containerComponent);
562 log.debug(TRY_TO_CREATE_ENTRY_ON_GRAPH);
563 return createRealComponentInstanceOnGraph(containerComponent, origComponent, resourceInstance, user);
564 } catch (ComponentException e) {
569 unlockComponent(failed, containerComponent);
574 private Either<ComponentInstance, ResponseFormat> createRealComponentInstanceOnGraph(org.openecomp.sdc.be.model.Component containerComponent,
575 Component originComponent,
576 ComponentInstance componentInstance, User user) {
577 log.debug("enter createRealComponentInstanceOnGraph");
578 Either<ImmutablePair<Component, String>, StorageOperationStatus> result = toscaOperationFacade
579 .addComponentInstanceToTopologyTemplate(containerComponent, originComponent, componentInstance, false, user);
580 if (result.isRight()) {
581 log.debug("enter createRealComponentInstanceOnGraph,result is right");
582 ActionStatus status = componentsUtils.convertFromStorageResponse(result.right().value());
583 log.debug(FAILED_TO_CREATE_ENTRY_ON_GRAPH_FOR_COMPONENT_INSTANCE, componentInstance.getName());
584 return Either.right(componentsUtils.getResponseFormat(status));
586 log.debug(ENTITY_ON_GRAPH_IS_CREATED);
587 log.debug("enter createRealComponentInstanceOnGraph,Entity on graph is created.");
588 Component updatedComponent = result.left().value().getLeft();
589 Map<String, String> existingEnvVersions = new HashMap<>();
590 // TODO existingEnvVersions ??
591 addComponentInstanceArtifacts(updatedComponent, componentInstance, originComponent, user, existingEnvVersions);
592 Optional<ComponentInstance> updatedInstanceOptional = updatedComponent.getComponentInstances().stream()
593 .filter(ci -> ci.getUniqueId().equals(result.left().value().getRight())).findFirst();
594 if (!updatedInstanceOptional.isPresent()) {
595 log.debug("Failed to fetch new added component instance {} from component {}", componentInstance.getName(), containerComponent.getName());
596 throw new ByActionStatusComponentException(ActionStatus.COMPONENT_INSTANCE_NOT_FOUND_ON_CONTAINER, componentInstance.getName());
598 log.debug("enter createRealComponentInstanceOnGraph,and final success");
599 return Either.left(updatedInstanceOptional.get());
602 private void overrideFields(Component origComponent, ComponentInstance resourceInstance) {
603 resourceInstance.setComponentVersion(origComponent.getVersion());
604 resourceInstance.setIcon(origComponent.getIcon());
607 private void validateInstanceName(ComponentInstance resourceInstance) {
608 String resourceInstanceName = resourceInstance.getName();
609 if (StringUtils.isEmpty(resourceInstanceName)) {
610 log.debug("ComponentInstance name is empty");
611 throw new ByActionStatusComponentException(ActionStatus.INVALID_COMPONENT_NAME, resourceInstance.getName());
613 if (!ValidationUtils.validateComponentNameLength(resourceInstanceName)) {
614 log.debug("ComponentInstance name exceeds max length {} ", ValidationUtils.COMPONENT_NAME_MAX_LENGTH);
615 throw new ByActionStatusComponentException(ActionStatus.INVALID_COMPONENT_NAME, resourceInstance.getName());
617 if (!ValidationUtils.validateComponentNamePattern(resourceInstanceName)) {
618 log.debug("ComponentInstance name {} has invalid format", resourceInstanceName);
619 throw new ByActionStatusComponentException(ActionStatus.INVALID_COMPONENT_NAME, resourceInstance.getName());
623 private void validateResourceInstanceState(Component containerComponent, Component origComponent) {
624 if (origComponent.getLifecycleState() == LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT) {
625 throw new ByActionStatusComponentException(ActionStatus.CONTAINER_CANNOT_CONTAIN_INSTANCE,
626 containerComponent.getComponentType().getValue(), origComponent.getLifecycleState().toString());
630 private void validateOriginAndResourceInstanceTypes(final Component containerComponent, final Component origComponent,
631 final OriginTypeEnum originType) {
632 final ResourceTypeEnum resourceType = getResourceTypeEnumFromOriginComponent(origComponent);
633 validateOriginType(originType, resourceType);
634 validateOriginComponentIsValidForContainer(containerComponent, resourceType);
637 private void validateOriginComponentIsValidForContainer(Component containerComponent, ResourceTypeEnum resourceType) {
638 switch (containerComponent.getComponentType()) {
640 if (!containerInstanceTypesData.isAllowedForServiceComponent(resourceType)) {
641 throw new ByActionStatusComponentException(ActionStatus.CONTAINER_CANNOT_CONTAIN_INSTANCE,
642 containerComponent.getComponentType().toString(), resourceType.name());
646 final ResourceTypeEnum componentResourceType = ((Resource) containerComponent).getResourceType();
647 if (!containerInstanceTypesData.isAllowedForResourceComponent(componentResourceType, resourceType)) {
648 throw new ByActionStatusComponentException(ActionStatus.CONTAINER_CANNOT_CONTAIN_INSTANCE,
649 containerComponent.getComponentType().toString(), resourceType.name());
653 throw new ByActionStatusComponentException(ActionStatus.INVALID_CONTENT);
657 private void validateOriginType(OriginTypeEnum originType, ResourceTypeEnum resourceType) {
658 ResourceTypeEnum convertedOriginType;
660 convertedOriginType = ResourceTypeEnum.getTypeIgnoreCase(originType.name());
661 } catch (Exception e) {
662 throw new ByActionStatusComponentException(ActionStatus.INVALID_CONTENT);
664 if (resourceType != convertedOriginType) {
665 throw new ByActionStatusComponentException(ActionStatus.INVALID_CONTENT);
669 private ResourceTypeEnum getResourceTypeEnumFromOriginComponent(final Component origComponent) {
670 switch (origComponent.getComponentType()) {
672 return ResourceTypeEnum.ServiceProxy;
674 return ((Resource) origComponent).getResourceType();
676 throw new ByActionStatusComponentException(ActionStatus.INVALID_CONTENT);
680 private void lockIfNeed(boolean needLock, Component containerComponent) {
682 lockComponent(containerComponent, "createComponentInstance");
686 private boolean isServiceProxyOrigin(Either<Component, StorageOperationStatus> serviceProxyOrigin) {
687 if (serviceProxyOrigin.isRight()) {
688 log.debug("Failed to fetch normative service proxy resource by tosca name, error {}", serviceProxyOrigin.right().value());
694 private StorageOperationStatus fillInstanceData(ComponentInstance resourceInstance, Component origComponent) {
695 final ComponentParametersView filter = new ComponentParametersView(true);
696 filter.setIgnoreCapabilities(false);
697 filter.setIgnoreCapabiltyProperties(false);
698 filter.setIgnoreComponentInstances(false);
699 filter.setIgnoreRequirements(false);
700 filter.setIgnoreInterfaces(false);
701 filter.setIgnoreProperties(false);
702 filter.setIgnoreAttributes(false);
703 filter.setIgnoreInputs(false);
704 Either<Component, StorageOperationStatus> serviceRes = toscaOperationFacade.getToscaElement(resourceInstance.getComponentUid(), filter);
705 if (serviceRes.isRight()) {
706 return serviceRes.right().value();
708 final Component service = serviceRes.left().value();
709 final Map<String, List<CapabilityDefinition>> capabilities = service.getCapabilities();
710 resourceInstance.setCapabilities(capabilities);
711 final Map<String, List<RequirementDefinition>> req = service.getRequirements();
712 resourceInstance.setRequirements(req);
713 final Map<String, InterfaceDefinition> serviceInterfaces = service.getInterfaces();
714 if (MapUtils.isNotEmpty(serviceInterfaces)) {
715 serviceInterfaces.forEach(resourceInstance::addInterface);
717 resourceInstance.setProperties(PropertiesUtils.getProperties(service));
718 resourceInstance.setAttributes(service.getAttributes());
719 final List<InputDefinition> serviceInputs = service.getInputs();
720 resourceInstance.setInputs(serviceInputs);
721 resourceInstance.setSourceModelInvariant(service.getInvariantUUID());
722 resourceInstance.setSourceModelName(service.getName());
723 resourceInstance.setSourceModelUuid(service.getUUID());
724 resourceInstance.setSourceModelUid(service.getUniqueId());
725 resourceInstance.setComponentUid(origComponent.getUniqueId());
726 resourceInstance.setComponentVersion(service.getVersion());
727 switch (resourceInstance.getOriginType()) {
729 return fillProxyInstanceData(resourceInstance, origComponent, service);
730 case ServiceSubstitution:
731 return fillServiceSubstitutableNodeTypeData(resourceInstance, service);
733 return StorageOperationStatus.OK;
737 private StorageOperationStatus fillProxyInstanceData(final ComponentInstance resourceInstance, final Component origComponent,
738 final Component service) {
739 final String name = ValidationUtils.normalizeComponentInstanceName(service.getName()) + ToscaOperationFacade.PROXY_SUFFIX;
740 final String toscaResourceName = ((Resource) origComponent).getToscaResourceName();
741 final int lastIndexOf = toscaResourceName.lastIndexOf('.');
742 if (lastIndexOf != -1) {
743 final String proxyToscaName = toscaResourceName.substring(0, lastIndexOf + 1) + name;
744 resourceInstance.setToscaComponentName(proxyToscaName);
746 resourceInstance.setName(name);
747 resourceInstance.setIsProxy(true);
748 resourceInstance.setDescription("A Proxy for Service " + service.getName());
749 return StorageOperationStatus.OK;
752 private StorageOperationStatus fillServiceSubstitutableNodeTypeData(final ComponentInstance resourceInstance, final Component service) {
753 resourceInstance.setToscaComponentName("org.openecomp.service." + ValidationUtils.convertToSystemName(service.getName()));
754 resourceInstance.setName(ValidationUtils.normalizeComponentInstanceName(service.getName()));
755 resourceInstance.setIsProxy(false);
756 resourceInstance.setDescription("A substitutable node type for service " + service.getName());
757 return StorageOperationStatus.OK;
760 public Either<CreateAndAssotiateInfo, ResponseFormat> createAndAssociateRIToRI(String containerComponentParam, String containerComponentId,
761 String userId, CreateAndAssotiateInfo createAndAssotiateInfo) {
762 Either<CreateAndAssotiateInfo, ResponseFormat> resultOp = null;
763 ComponentInstance resourceInstance = createAndAssotiateInfo.getNode();
764 RequirementCapabilityRelDef associationInfo = createAndAssotiateInfo.getAssociate();
765 User user = validateUserExists(userId);
766 final ComponentTypeEnum containerComponentType = validateComponentType(containerComponentParam);
767 org.openecomp.sdc.be.model.Component containerComponent = validateComponentExists(containerComponentId, containerComponentType, null);
768 if (ModelConverter.isAtomicComponent(containerComponent)) {
769 log.debug(CANNOT_ATTACH_RESOURCE_INSTANCES_TO_CONTAINER_RESOURCE_OF_TYPE, containerComponent.assetType());
771 .right(componentsUtils.getResponseFormat(ActionStatus.RESOURCE_CANNOT_CONTAIN_RESOURCE_INSTANCES, containerComponent.assetType()));
773 validateCanWorkOnComponent(containerComponent, userId);
774 boolean failed = false;
776 lockComponent(containerComponent, "createAndAssociateRIToRI");
777 log.debug(TRY_TO_CREATE_ENTRY_ON_GRAPH);
778 Component origComponent = getOriginComponentFromComponentInstance(resourceInstance);
779 log.debug(ENTITY_ON_GRAPH_IS_CREATED);
780 ComponentInstance resResourceInfo = createComponentInstanceOnGraph(containerComponent, origComponent, resourceInstance, user);
781 if (associationInfo.getFromNode() == null || associationInfo.getFromNode().isEmpty()) {
782 associationInfo.setFromNode(resResourceInfo.getUniqueId());
784 associationInfo.setToNode(resResourceInfo.getUniqueId());
786 Either<RequirementCapabilityRelDef, StorageOperationStatus> resultReqCapDef = toscaOperationFacade
787 .associateResourceInstances(containerComponent, containerComponentId, associationInfo);
788 if (resultReqCapDef.isLeft()) {
789 log.debug(ENTITY_ON_GRAPH_IS_CREATED);
790 RequirementCapabilityRelDef resReqCapabilityRelDef = resultReqCapDef.left().value();
791 CreateAndAssotiateInfo resInfo = new CreateAndAssotiateInfo(resResourceInfo, resReqCapabilityRelDef);
792 resultOp = Either.left(resInfo);
795 log.info("Failed to associate node {} with node {}", associationInfo.getFromNode(), associationInfo.getToNode());
796 resultOp = Either.right(componentsUtils.getResponseFormatForResourceInstance(
797 componentsUtils.convertFromStorageResponseForResourceInstance(resultReqCapDef.right().value(), true), "", null));
800 } catch (ComponentException e) {
804 unlockComponent(failed, containerComponent);
808 private Component getOriginComponentFromComponentInstance(ComponentInstance componentInstance) {
809 return getOriginComponentFromComponentInstance(componentInstance.getName(), componentInstance.getComponentUid());
812 private Component getInstanceOriginNode(ComponentInstance componentInstance) {
813 return getOriginComponentFromComponentInstance(componentInstance.getName(), componentInstance.getActualComponentUid());
816 private Component getOriginComponentFromComponentInstance(String componentInstanceName, String origComponetId) {
817 Either<Component, StorageOperationStatus> eitherComponent = toscaOperationFacade.getToscaFullElement(origComponetId);
818 if (eitherComponent.isRight()) {
819 log.debug("Failed to get origin component with id {} for component instance {} ", origComponetId, componentInstanceName);
820 throw new ByActionStatusComponentException(
821 componentsUtils.convertFromStorageResponse(eitherComponent.right().value(), ComponentTypeEnum.RESOURCE), "", null);
823 return eitherComponent.left().value();
826 private ComponentInstance createComponentInstanceOnGraph(org.openecomp.sdc.be.model.Component containerComponent, Component originComponent,
827 ComponentInstance componentInstance, User user) {
828 Either<ImmutablePair<Component, String>, StorageOperationStatus> result = toscaOperationFacade
829 .addComponentInstanceToTopologyTemplate(containerComponent, originComponent, componentInstance, false, user);
830 if (result.isRight()) {
831 log.debug(FAILED_TO_CREATE_ENTRY_ON_GRAPH_FOR_COMPONENT_INSTANCE, componentInstance.getName());
832 throw new ByResponseFormatComponentException(componentsUtils
833 .getResponseFormatForResourceInstance(componentsUtils.convertFromStorageResponseForResourceInstance(result.right().value(), true), "",
836 log.debug(ENTITY_ON_GRAPH_IS_CREATED);
837 Component updatedComponent = result.left().value().getLeft();
838 Map<String, String> existingEnvVersions = new HashMap<>();
839 // TODO existingEnvVersions ??
840 addComponentInstanceArtifacts(updatedComponent, componentInstance, originComponent, user, existingEnvVersions);
841 Optional<ComponentInstance> updatedInstanceOptional = updatedComponent.getComponentInstances().stream()
842 .filter(ci -> ci.getUniqueId().equals(result.left().value().getRight())).findFirst();
843 if (!updatedInstanceOptional.isPresent()) {
844 log.debug("Failed to fetch new added component instance {} from component {}", componentInstance.getName(), containerComponent.getName());
845 throw new ByActionStatusComponentException(ActionStatus.COMPONENT_INSTANCE_NOT_FOUND_ON_CONTAINER, componentInstance.getName());
847 return updatedInstanceOptional.get();
850 public boolean isCloudSpecificArtifact(String artifact) {
851 if (artifact.contains(CLOUD_SPECIFIC_FIXED_KEY_WORD)) {
852 for (int i = 0; i < CLOUD_SPECIFIC_KEY_WORDS.length; i++) {
853 if (Arrays.stream(CLOUD_SPECIFIC_KEY_WORDS[i]).noneMatch(artifact::contains)) {
864 * addResourceInstanceArtifacts - add artifacts (HEAT_ENV) to resource instance The instance artifacts are generated from the resource's
867 * @param containerComponent
868 * @param componentInstance
869 * @param originComponent
871 * @param existingEnvVersions
874 protected ActionStatus addComponentInstanceArtifacts(org.openecomp.sdc.be.model.Component containerComponent, ComponentInstance componentInstance,
875 org.openecomp.sdc.be.model.Component originComponent, User user,
876 Map<String, String> existingEnvVersions) {
877 log.debug("add artifacts to resource instance");
878 List<GroupDefinition> filteredGroups = new ArrayList<>();
879 ActionStatus status = setResourceArtifactsOnResourceInstance(componentInstance);
880 if (ActionStatus.OK != status) {
881 throw new ByResponseFormatComponentException(componentsUtils.getResponseFormatForResourceInstance(status, "", null));
883 StorageOperationStatus artStatus;
884 // generate heat_env if necessary
885 Map<String, ArtifactDefinition> componentDeploymentArtifacts = componentInstance.getDeploymentArtifacts();
886 if (MapUtils.isNotEmpty(componentDeploymentArtifacts)) {
887 Map<String, ArtifactDefinition> finalDeploymentArtifacts = new HashMap<>();
888 Map<String, List<ArtifactDefinition>> groupInstancesArtifacts = new HashMap<>();
889 Integer defaultHeatTimeout = ConfigurationManager.getConfigurationManager().getConfiguration().getHeatArtifactDeploymentTimeout()
890 .getDefaultMinutes();
891 List<ArtifactDefinition> listOfCloudSpecificArts = new ArrayList<>();
892 for (ArtifactDefinition artifact : componentDeploymentArtifacts.values()) {
893 String type = artifact.getArtifactType();
894 if (!type.equalsIgnoreCase(ArtifactTypeEnum.HEAT_ENV.getType())) {
895 finalDeploymentArtifacts.put(artifact.getArtifactLabel(), artifact);
897 if (type.equalsIgnoreCase(ArtifactTypeEnum.HEAT.getType()) || type.equalsIgnoreCase(ArtifactTypeEnum.HELM.getType()) || type
898 .equalsIgnoreCase(ArtifactTypeEnum.HEAT_NET.getType()) || type.equalsIgnoreCase(ArtifactTypeEnum.HEAT_VOL.getType()) || type
899 .equalsIgnoreCase(ArtifactTypeEnum.CLOUD_TECHNOLOGY_SPECIFIC_ARTIFACT.getType())) {
900 artifact.setTimeout(defaultHeatTimeout);
904 if (artifact.checkEsIdExist()) {
905 ArtifactDefinition artifactDefinition = artifactBusinessLogic
906 .createHeatEnvPlaceHolder(new ArrayList<>(), artifact, ArtifactsBusinessLogic.HEAT_ENV_NAME, componentInstance.getUniqueId(),
907 NodeTypeEnum.ResourceInstance, componentInstance.getName(), user, containerComponent, existingEnvVersions);
909 finalDeploymentArtifacts.put(artifactDefinition.getArtifactLabel(), artifactDefinition);
910 if (CollectionUtils.isNotEmpty(originComponent.getGroups())) {
911 filteredGroups = originComponent.getGroups().stream().filter(g -> g.getType().equals(VF_MODULE)).collect(Collectors.toList());
913 if (isCloudSpecificArtifact(artifactDefinition.getArtifactName())) {
914 listOfCloudSpecificArts.add(artifact);
916 if (CollectionUtils.isNotEmpty(filteredGroups)) {
917 filteredGroups.stream()
918 .filter(g -> g.getArtifacts().stream().anyMatch(p -> p.equals(artifactDefinition.getGeneratedFromId()))).findFirst()
919 .ifPresent(g -> fillInstanceArtifactMap(groupInstancesArtifacts, artifactDefinition, g));
923 groupInstancesArtifacts.forEach((k, v) -> v.addAll(listOfCloudSpecificArts));
924 filteredGroups.forEach(g -> listOfCloudSpecificArts.forEach(e -> {
925 g.getArtifactsUuid().add(e.getArtifactUUID());
926 g.getArtifacts().add(e.getUniqueId());
928 artStatus = toscaOperationFacade
929 .addDeploymentArtifactsToInstance(containerComponent.getUniqueId(), componentInstance, finalDeploymentArtifacts);
930 if (artStatus != StorageOperationStatus.OK) {
931 log.debug("Failed to add instance deployment artifacts for instance {} in conatiner {} error {}", componentInstance.getUniqueId(),
932 containerComponent.getUniqueId(), artStatus);
933 throw new ByResponseFormatComponentException(
934 componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponseForResourceInstance(artStatus, false)));
936 StorageOperationStatus result = toscaOperationFacade
937 .addGroupInstancesToComponentInstance(containerComponent, componentInstance, filteredGroups, groupInstancesArtifacts);
938 if (result != StorageOperationStatus.OK) {
939 log.debug("failed to update group instance for component instance {}", componentInstance.getUniqueId());
940 throw new ByResponseFormatComponentException(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(result)));
942 componentInstance.setDeploymentArtifacts(finalDeploymentArtifacts);
944 artStatus = toscaOperationFacade
945 .addInformationalArtifactsToInstance(containerComponent.getUniqueId(), componentInstance, originComponent.getArtifacts());
946 if (artStatus != StorageOperationStatus.OK) {
947 log.debug("Failed to add informational artifacts to the instance {} belonging to the conatiner {}. Status is {}",
948 componentInstance.getUniqueId(), containerComponent.getUniqueId(), artStatus);
949 throw new ByResponseFormatComponentException(
950 componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponseForResourceInstance(artStatus, false)));
952 componentInstance.setArtifacts(originComponent.getArtifacts());
953 return ActionStatus.OK;
956 private void fillInstanceArtifactMap(Map<String, List<ArtifactDefinition>> groupInstancesArtifacts, ArtifactDefinition artifactDefinition,
957 GroupDefinition groupInstance) {
958 List<ArtifactDefinition> artifactsUid;
959 if (groupInstancesArtifacts.containsKey(groupInstance.getUniqueId())) {
960 artifactsUid = groupInstancesArtifacts.get(groupInstance.getUniqueId());
962 artifactsUid = new ArrayList<>();
964 artifactsUid.add(artifactDefinition);
965 groupInstancesArtifacts.put(groupInstance.getUniqueId(), artifactsUid);
968 private ActionStatus setResourceArtifactsOnResourceInstance(ComponentInstance resourceInstance) {
969 Either<Map<String, ArtifactDefinition>, StorageOperationStatus> getResourceDeploymentArtifacts = artifactBusinessLogic
970 .getArtifacts(resourceInstance.getComponentUid(), NodeTypeEnum.Resource, ArtifactGroupTypeEnum.DEPLOYMENT, null);
971 Map<String, ArtifactDefinition> deploymentArtifacts = new HashMap<>();
972 if (getResourceDeploymentArtifacts.isRight()) {
973 StorageOperationStatus status = getResourceDeploymentArtifacts.right().value();
974 if (status != StorageOperationStatus.NOT_FOUND) {
975 log.debug("Failed to fetch resource: {} artifacts. status is {}", resourceInstance.getComponentUid(), status);
976 return componentsUtils.convertFromStorageResponseForResourceInstance(status, true);
979 deploymentArtifacts = getResourceDeploymentArtifacts.left().value();
981 if (!deploymentArtifacts.isEmpty()) {
982 Map<String, ArtifactDefinition> tempDeploymentArtifacts = new HashMap<>(deploymentArtifacts);
983 for (Entry<String, ArtifactDefinition> artifact : deploymentArtifacts.entrySet()) {
984 if (!artifact.getValue().checkEsIdExist()) {
985 tempDeploymentArtifacts.remove(artifact.getKey());
988 resourceInstance.setDeploymentArtifacts(tempDeploymentArtifacts);
990 return ActionStatus.OK;
993 public Either<ComponentInstance, ResponseFormat> updateComponentInstanceMetadata(String containerComponentParam, String containerComponentId,
994 String componentInstanceId, String userId,
995 ComponentInstance componentInstance) {
996 return updateComponentInstanceMetadata(containerComponentParam, containerComponentId, componentInstanceId, userId, componentInstance, true);
999 public Either<ComponentInstance, ResponseFormat> updateComponentInstanceMetadata(final String containerComponentParam,
1000 final String containerComponentId,
1001 final String componentInstanceId, final String userId,
1002 ComponentInstance componentInstance, boolean needLock) {
1003 validateUserExists(userId);
1004 final ComponentTypeEnum containerComponentType = validateComponentType(containerComponentParam);
1005 final Component containerComponent = validateComponentExists(containerComponentId, containerComponentType, null);
1006 validateCanWorkOnComponent(containerComponent, userId);
1007 ComponentTypeEnum instanceType = getComponentType(containerComponentType);
1008 Either<Boolean, StorageOperationStatus> validateParentStatus = toscaOperationFacade
1009 .validateComponentExists(componentInstance.getComponentUid());
1010 if (validateParentStatus.isRight()) {
1011 log.debug("Failed to get component instance {} on service {}", componentInstanceId, containerComponentId);
1012 throw new ByActionStatusComponentException(ActionStatus.COMPONENT_INSTANCE_NOT_FOUND, componentInstance.getName(),
1013 instanceType.getValue().toLowerCase());
1015 if (!Boolean.TRUE.equals(validateParentStatus.left().value())) {
1016 throw new ByActionStatusComponentException(ActionStatus.COMPONENT_INSTANCE_NOT_FOUND_ON_CONTAINER, componentInstance.getName(),
1017 instanceType.getValue().toLowerCase(), containerComponentType.getValue().toLowerCase(), containerComponentId);
1020 lockComponent(containerComponent, "updateComponentInstance");
1022 Component origComponent;
1023 boolean failed = false;
1025 origComponent = getOriginComponentFromComponentInstance(componentInstance);
1026 componentInstance = updateComponentInstanceMetadata(containerComponent, containerComponentType, origComponent, componentInstanceId,
1028 } catch (ComponentException e) {
1033 unlockComponent(failed, containerComponent);
1036 return Either.left(componentInstance);
1039 // New Multiple Instance Update API
1040 public List<ComponentInstance> updateComponentInstance(String containerComponentParam, Component containerComponent, String containerComponentId,
1041 String userId, List<ComponentInstance> componentInstanceList, boolean needLock) {
1042 boolean failed = false;
1044 validateUserExists(userId);
1045 final ComponentTypeEnum containerComponentType = validateComponentType(containerComponentParam);
1046 ComponentParametersView componentFilter = new ComponentParametersView();
1047 componentFilter.disableAll();
1048 componentFilter.setIgnoreUsers(false);
1049 componentFilter.setIgnoreComponentInstances(false);
1050 if (containerComponent == null) {
1051 containerComponent = validateComponentExistsByFilter(containerComponentId, containerComponentType, componentFilter);
1053 validateCanWorkOnComponent(containerComponent, userId);
1054 ComponentTypeEnum instanceType = getComponentType(containerComponentType);
1055 for (ComponentInstance componentInstance : componentInstanceList) {
1056 boolean validateParent = validateParent(containerComponent, componentInstance.getUniqueId());
1057 if (!validateParent) {
1058 throw new ByActionStatusComponentException(ActionStatus.COMPONENT_INSTANCE_NOT_FOUND_ON_CONTAINER, componentInstance.getName(),
1059 instanceType.getValue().toLowerCase(), containerComponentType.getValue().toLowerCase(), containerComponentId);
1063 lockComponent(containerComponent, "updateComponentInstance");
1065 List<ComponentInstance> updatedList = new ArrayList<>();
1066 List<ComponentInstance> instancesFromContainerComponent = containerComponent.getComponentInstances();
1067 List<ComponentInstance> listForUpdate = new ArrayList<>();
1068 if (instancesFromContainerComponent == null || instancesFromContainerComponent.isEmpty()) {
1069 containerComponent.setComponentInstances(componentInstanceList);
1071 Iterator<ComponentInstance> iterator = instancesFromContainerComponent.iterator();
1072 while (iterator.hasNext()) {
1073 ComponentInstance origInst = iterator.next();
1074 Optional<ComponentInstance> op = componentInstanceList.stream().filter(ci -> ci.getUniqueId().equals(origInst.getUniqueId()))
1076 if (op.isPresent()) {
1077 ComponentInstance updatedCi = op.get();
1078 updatedCi = buildComponentInstance(updatedCi, origInst);
1079 Boolean isUniqueName = validateInstanceNameUniquenessUponUpdate(containerComponent, origInst, updatedCi.getName());
1080 if (!Boolean.TRUE.equals(isUniqueName)) {
1081 CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG,
1082 "Failed to update the name of the component instance {} to {}. A component instance with the same name already exists. ",
1083 origInst.getName(), updatedCi.getName());
1084 throw new ByResponseFormatComponentException(componentsUtils
1085 .getResponseFormat(ActionStatus.COMPONENT_NAME_ALREADY_EXIST, containerComponentType.getValue(), origInst.getName()));
1087 listForUpdate.add(updatedCi);
1089 listForUpdate.add(origInst);
1092 containerComponent.setComponentInstances(listForUpdate);
1093 Either<Component, StorageOperationStatus> updateStatus = toscaOperationFacade
1094 .updateComponentInstanceMetadataOfTopologyTemplate(containerComponent, componentFilter);
1095 if (updateStatus.isRight()) {
1097 .addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to update metadata belonging to container component {}. Status is {}. ",
1098 containerComponent.getName(), updateStatus.right().value());
1099 throw new ByResponseFormatComponentException(componentsUtils.getResponseFormatForResourceInstance(
1100 componentsUtils.convertFromStorageResponseForResourceInstance(updateStatus.right().value(), true), "", null));
1102 for (ComponentInstance updatedInstance : updateStatus.left().value().getComponentInstances()) {
1103 Optional<ComponentInstance> op = componentInstanceList.stream().filter(ci -> ci.getName().equals(updatedInstance.getName()))
1105 if (op.isPresent()) {
1106 updatedList.add(updatedInstance);
1111 } catch (ComponentException e) {
1116 unlockComponent(failed, containerComponent);
1121 private boolean validateParent(org.openecomp.sdc.be.model.Component containerComponent, String nodeTemplateId) {
1122 return containerComponent.getComponentInstances().stream().anyMatch(p -> p.getUniqueId().equals(nodeTemplateId));
1125 private ComponentTypeEnum getComponentType(ComponentTypeEnum containerComponentType) {
1126 if (ComponentTypeEnum.PRODUCT == containerComponentType) {
1127 return ComponentTypeEnum.SERVICE_INSTANCE;
1129 return ComponentTypeEnum.RESOURCE_INSTANCE;
1133 private ComponentInstance updateComponentInstanceMetadata(Component containerComponent, ComponentTypeEnum containerComponentType,
1134 org.openecomp.sdc.be.model.Component origComponent, String componentInstanceId,
1135 ComponentInstance componentInstance) {
1136 Optional<ComponentInstance> componentInstanceOptional;
1137 Either<ImmutablePair<Component, String>, StorageOperationStatus> updateRes = null;
1138 ComponentInstance oldComponentInstance = null;
1139 boolean isNameChanged = false;
1140 componentInstanceOptional = containerComponent.getComponentInstances().stream()
1141 .filter(ci -> ci.getUniqueId().equals(componentInstance.getUniqueId())).findFirst();
1142 if (!componentInstanceOptional.isPresent()) {
1143 CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to find the component instance {} in container component {}. ",
1144 componentInstance.getName(), containerComponent.getName());
1145 throw new ByActionStatusComponentException(ActionStatus.COMPONENT_INSTANCE_NOT_FOUND_ON_CONTAINER, componentInstance.getName());
1147 String oldComponentName;
1148 oldComponentInstance = componentInstanceOptional.get();
1149 oldComponentName = oldComponentInstance.getName();
1150 String newInstanceName = componentInstance.getName();
1151 if (oldComponentName != null && !oldComponentInstance.getName().equals(newInstanceName)) {
1152 isNameChanged = true;
1154 Boolean isUniqueName = validateInstanceNameUniquenessUponUpdate(containerComponent, oldComponentInstance, newInstanceName);
1155 if (!Boolean.TRUE.equals(isUniqueName)) {
1156 CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG,
1157 "Failed to update the name of the component instance {} to {}. A component instance with the same name already exists. ",
1158 oldComponentInstance.getName(), newInstanceName);
1159 throw new ByActionStatusComponentException(ActionStatus.COMPONENT_NAME_ALREADY_EXIST, containerComponentType.getValue(),
1160 componentInstance.getName());
1162 if (!DirectivesUtil.isValid(componentInstance.getDirectives())) {
1163 final String directivesStr = componentInstance.getDirectives().stream().collect(Collectors.joining(" , ", " [ ", " ] "));
1164 CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG,
1165 "Failed to update the directives of the component instance {} to {}. Directives data {} is invalid. ", oldComponentInstance.getName(),
1166 newInstanceName, directivesStr);
1167 throw new ByActionStatusComponentException(ActionStatus.DIRECTIVES_INVALID_VALUE, containerComponentType.getValue(),
1168 componentInstance.getName());
1170 updateRes = toscaOperationFacade.updateComponentInstanceMetadataOfTopologyTemplate(containerComponent, origComponent,
1171 updateComponentInstanceMetadata(oldComponentInstance, componentInstance));
1172 if (updateRes.isRight()) {
1173 CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG,
1174 "Failed to update metadata of component instance {} belonging to container component {}. Status is {}. ", componentInstance.getName(),
1175 containerComponent.getName(), updateRes.right().value());
1176 throw new ByResponseFormatComponentException(componentsUtils
1177 .getResponseFormatForResourceInstance(componentsUtils.convertFromStorageResponseForResourceInstance(updateRes.right().value(), true),
1180 // region - Update instance Groups
1181 if (isNameChanged) {
1182 Either<StorageOperationStatus, StorageOperationStatus> result = toscaOperationFacade
1183 .cleanAndAddGroupInstancesToComponentInstance(containerComponent, oldComponentInstance, componentInstanceId);
1184 if (result.isRight()) {
1186 .addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to rename group instances for container {}. error {} ", componentInstanceId,
1187 result.right().value());
1189 if (containerComponent instanceof Service) {
1190 Either<ComponentInstance, ResponseFormat> renameEither = renameServiceFilter((Service) containerComponent, newInstanceName,
1191 oldComponentInstance.getName());
1192 if (renameEither.isRight()) {
1193 throw new ByResponseFormatComponentException(renameEither.right().value());
1195 updateForwardingPathDefinition(containerComponent, componentInstance, oldComponentName);
1200 String newInstanceId = updateRes.left().value().getRight();
1201 Optional<ComponentInstance> updatedInstanceOptional = updateRes.left().value().getLeft().getComponentInstances().stream()
1202 .filter(ci -> ci.getUniqueId().equals(newInstanceId)).findFirst();
1203 if (!updatedInstanceOptional.isPresent()) {
1204 log.debug("Failed to update metadata of component instance {} of container component {}", componentInstance.getName(),
1205 containerComponent.getName());
1206 throw new ByResponseFormatComponentException(
1207 componentsUtils.getResponseFormat(ActionStatus.COMPONENT_INSTANCE_NOT_FOUND_ON_CONTAINER, componentInstance.getName()));
1209 return componentInstanceOptional.get();
1212 private void updateForwardingPathDefinition(Component containerComponent, ComponentInstance componentInstance, String oldComponentName) {
1213 Collection<ForwardingPathDataDefinition> forwardingPathDataDefinitions = getForwardingPathDataDefinitions(containerComponent.getUniqueId());
1214 Set<ForwardingPathDataDefinition> updated = new ForwardingPathUtils()
1215 .updateComponentInstanceName(forwardingPathDataDefinitions, oldComponentName, componentInstance.getName());
1216 updated.forEach(fp -> {
1217 Either<ForwardingPathDataDefinition, StorageOperationStatus> resultEither = forwardingPathOperation
1218 .updateForwardingPath(containerComponent.getUniqueId(), fp);
1219 if (resultEither.isRight()) {
1220 CommonUtility.addRecordToLog(log, LogLevelEnum.ERROR, "Failed to rename forwarding path for container {}. error {} ",
1221 containerComponent.getName(), resultEither.right().value());
1226 public Either<ComponentInstance, ResponseFormat> renameServiceFilter(final Service containerComponent, final String newInstanceName,
1227 final String oldInstanceName) {
1228 Map<String, CINodeFilterDataDefinition> renamedNodesFilter = ServiceFilterUtils
1229 .getRenamedNodesFilter(containerComponent, oldInstanceName, newInstanceName);
1230 for (Entry<String, CINodeFilterDataDefinition> entry : renamedNodesFilter.entrySet()) {
1231 Either<CINodeFilterDataDefinition, StorageOperationStatus> renameEither = nodeFilterOperation
1232 .updateNodeFilter(containerComponent.getUniqueId(), entry.getKey(), entry.getValue());
1233 if (renameEither.isRight()) {
1234 return Either.right(componentsUtils.getResponseFormatForResourceInstance(
1235 componentsUtils.convertFromStorageResponse(renameEither.right().value(), ComponentTypeEnum.SERVICE), containerComponent.getName(),
1239 return Either.left(null);
1243 * @param oldPrefix- The normalized old vf name
1244 * @param newNormailzedPrefix- The normalized new vf name
1245 * @param qualifiedGroupInstanceName- old Group Instance Name
1248 // modify group names
1249 private String getNewGroupName(String oldPrefix, String newNormailzedPrefix, String qualifiedGroupInstanceName) {
1250 if (qualifiedGroupInstanceName == null) {
1251 log.info("CANNOT change group name ");
1254 if (qualifiedGroupInstanceName.startsWith(oldPrefix) || qualifiedGroupInstanceName
1255 .startsWith(ValidationUtils.normalizeComponentInstanceName(oldPrefix))) {
1256 return qualifiedGroupInstanceName.replaceFirst(oldPrefix, newNormailzedPrefix);
1258 return qualifiedGroupInstanceName;
1261 private ComponentInstance updateComponentInstanceMetadata(ComponentInstance oldComponentInstance, ComponentInstance newComponentInstance) {
1262 oldComponentInstance.setName(newComponentInstance.getName());
1263 oldComponentInstance.setModificationTime(System.currentTimeMillis());
1264 oldComponentInstance.setCustomizationUUID(UUID.randomUUID().toString());
1265 oldComponentInstance.setDirectives(newComponentInstance.getDirectives());
1266 if (oldComponentInstance.getGroupInstances() != null) {
1267 oldComponentInstance.getGroupInstances().forEach(group -> group.setName(getNewGroupName(oldComponentInstance.getNormalizedName(),
1268 ValidationUtils.normalizeComponentInstanceName(newComponentInstance.getName()), group.getName())));
1270 return oldComponentInstance;
1273 public ComponentInstance deleteComponentInstance(final String containerComponentParam, final String containerComponentId,
1274 final String componentInstanceId, String userId) throws BusinessLogicException {
1275 validateUserExists(userId);
1276 final ComponentTypeEnum containerComponentType = validateComponentType(containerComponentParam);
1277 final Component containerComponent = validateComponentExists(containerComponentId, containerComponentType, null);
1278 validateCanWorkOnComponent(containerComponent, userId);
1279 boolean failed = false;
1280 final Optional<ComponentInstance> componentInstanceOptional = containerComponent.getComponentInstanceById(componentInstanceId);
1281 if (!componentInstanceOptional.isPresent()) {
1282 throw new BusinessLogicException(componentsUtils.getResponseFormat(ActionStatus.COMPONENT_INSTANCE_NOT_FOUND));
1284 ComponentInstance componentInstance = componentInstanceOptional.get();
1286 if (containerComponent instanceof Service || containerComponent instanceof Resource) {
1287 final Either<String, StorageOperationStatus> deleteServiceFilterEither = nodeFilterOperation
1288 .deleteNodeFilter(containerComponent, componentInstanceId);
1289 if (deleteServiceFilterEither.isRight()) {
1290 final ActionStatus status = componentsUtils
1291 .convertFromStorageResponse(deleteServiceFilterEither.right().value(), containerComponentType);
1292 janusGraphDao.rollback();
1293 throw new ByResponseFormatComponentException(componentsUtils.getResponseFormat(status, componentInstanceId));
1295 final Either<ComponentInstance, ResponseFormat> resultOp = deleteNodeFiltersFromComponentInstance(containerComponent,
1296 componentInstance, containerComponentType, userId);
1297 if (resultOp.isRight()) {
1298 janusGraphDao.rollback();
1299 throw new ByResponseFormatComponentException(resultOp.right().value());
1302 lockComponent(containerComponent, "deleteComponentInstance");
1303 final ComponentInstance deletedCompInstance = deleteComponentInstance(containerComponent, componentInstanceId, containerComponentType);
1304 componentInstance = deleteForwardingPathsRelatedTobeDeletedComponentInstance(containerComponentId, containerComponentType,
1305 deletedCompInstance);
1306 final ActionStatus onDeleteOperationsStatus = onChangeInstanceOperationOrchestrator
1307 .doOnDeleteInstanceOperations(containerComponent, componentInstanceId);
1308 if (ActionStatus.OK != onDeleteOperationsStatus) {
1309 throw new ByActionStatusComponentException(onDeleteOperationsStatus);
1311 } catch (final ComponentException e) {
1315 unlockComponent(failed, containerComponent);
1317 return componentInstance;
1321 * Try to modify the delete and return two cases
1323 * @param containerComponentParam
1324 * @param containerComponentId
1325 * @param componentInstanceId
1329 public Either<ComponentInstance, ResponseFormat> deleteAbstractComponentInstance(String containerComponentParam, String containerComponentId,
1330 String componentInstanceId, String userId) {
1331 log.debug("enter deleteAbstractComponentInstance");
1332 validateUserExists(userId);
1333 final ComponentTypeEnum containerComponentType = validateComponentType(containerComponentParam);
1334 org.openecomp.sdc.be.model.Component containerComponent = validateComponentExists(containerComponentId, containerComponentType, null);
1335 validateCanWorkOnComponent(containerComponent, userId);
1336 boolean failed = false;
1337 ComponentInstance deletedRelatedInst;
1339 if (containerComponent instanceof Service) {
1340 final Optional<ComponentInstance> componentInstanceById = containerComponent.getComponentInstanceById(componentInstanceId);
1341 if (componentInstanceById.isPresent()) {
1342 ComponentInstance componentInstance = componentInstanceById.get();
1343 Either<String, StorageOperationStatus> deleteServiceFilterEither = nodeFilterOperation
1344 .deleteNodeFilter(containerComponent, componentInstanceId);
1345 if (deleteServiceFilterEither.isRight()) {
1346 log.debug("enter deleteAbstractComponentInstance:deleteServiceFilterEither is right, filed");
1347 ActionStatus status = componentsUtils
1348 .convertFromStorageResponse(deleteServiceFilterEither.right().value(), containerComponentType);
1349 janusGraphDao.rollback();
1350 return Either.right(componentsUtils.getResponseFormat(status, componentInstance.getName()));
1352 Either<ComponentInstance, ResponseFormat> resultOp = deleteNodeFiltersFromComponentInstance(containerComponent, componentInstance,
1353 ComponentTypeEnum.SERVICE, userId);
1354 if (resultOp.isRight()) {
1355 log.debug("enter deleteAbstractComponentInstance:resultOp is right, filed");
1356 janusGraphDao.rollback();
1361 log.debug("enter deleteAbstractComponentInstance:");
1362 lockComponent(containerComponent, "deleteComponentInstance");
1363 ComponentInstance deletedCompInstance = deleteComponentInstance(containerComponent, componentInstanceId, containerComponentType);
1364 deletedRelatedInst = deleteForwardingPathsRelatedTobeDeletedComponentInstance(containerComponentId, containerComponentType,
1365 deletedCompInstance);
1366 ActionStatus onDeleteOperationsStatus = onChangeInstanceOperationOrchestrator
1367 .doOnDeleteInstanceOperations(containerComponent, componentInstanceId);
1368 log.debug("enter deleteAbstractComponentInstance,get onDeleteOperationsStatus:{}", onDeleteOperationsStatus);
1369 if (ActionStatus.OK != onDeleteOperationsStatus) {
1370 throw new ByActionStatusComponentException(onDeleteOperationsStatus);
1372 } catch (ComponentException e) {
1376 unlockComponent(failed, containerComponent);
1378 log.debug("enter deleteAbstractComponentInstance,deleted RelatedInst success");
1379 return Either.left(deletedRelatedInst);
1382 public Either<ComponentInstance, ResponseFormat> deleteNodeFiltersFromComponentInstance(final Component component,
1383 final ComponentInstance componentInstance,
1384 final ComponentTypeEnum containerComponentType,
1385 final String userId) {
1386 final Set<String> componentFiltersIDsToBeDeleted = getComponentFiltersRelatedToComponentInstance(component.getUniqueId(), componentInstance);
1387 if (!componentFiltersIDsToBeDeleted.isEmpty()) {
1388 final Set<String> ids = component.getComponentInstances().stream().filter(ci -> componentFiltersIDsToBeDeleted.contains(ci.getName()))
1389 .map(ComponentInstance::getUniqueId).collect(Collectors.toSet());
1390 final Either<Set<String>, StorageOperationStatus> deleteComponentNodeFiltersEither = nodeFilterOperation
1391 .deleteNodeFilters(component, ids);
1392 if (deleteComponentNodeFiltersEither.isRight()) {
1393 final ActionStatus status = componentsUtils
1394 .convertFromStorageResponse(deleteComponentNodeFiltersEither.right().value(), containerComponentType);
1395 return Either.right(componentsUtils.getResponseFormat(status, componentInstance.getName()));
1397 for (final String id : ids) {
1398 final Optional<ComponentInstance> componentInstanceById = component.getComponentInstanceById(id);
1399 if (!componentInstanceById.isPresent()) {
1400 return Either.right(componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR));
1402 final ComponentInstance componentInstanceToBeUpdated = componentInstanceById.get();
1403 componentInstanceToBeUpdated.setDirectives(Collections.emptyList());
1404 final Either<ComponentInstance, ResponseFormat> componentInstanceResponseFormatEither = updateComponentInstanceMetadata(
1405 containerComponentType.getValue(), component.getUniqueId(), componentInstanceToBeUpdated.getUniqueId(), userId,
1406 componentInstanceToBeUpdated, false);
1407 if (componentInstanceResponseFormatEither.isRight()) {
1408 return componentInstanceResponseFormatEither;
1412 return Either.left(componentInstance);
1415 private Set<String> getComponentFiltersRelatedToComponentInstance(String containerComponentId, ComponentInstance componentInstance) {
1416 ComponentParametersView filter = new ComponentParametersView(true);
1417 filter.setIgnoreComponentInstances(false);
1418 Either<Component, StorageOperationStatus> componentFilterOrigin = toscaOperationFacade.getToscaElement(containerComponentId, filter);
1419 final Component component = componentFilterOrigin.left().value();
1420 return ComponentsUtils.getNodesFiltersToBeDeleted(component, componentInstance);
1423 ComponentInstance deleteForwardingPathsRelatedTobeDeletedComponentInstance(String containerComponentId, ComponentTypeEnum containerComponentType,
1424 ComponentInstance componentInstance) {
1425 if (containerComponentType == ComponentTypeEnum.SERVICE) {
1426 List<String> pathIDsToBeDeleted = getForwardingPathsRelatedToComponentInstance(containerComponentId, componentInstance.getName());
1427 if (!pathIDsToBeDeleted.isEmpty()) {
1428 deleteForwardingPaths(containerComponentId, pathIDsToBeDeleted);
1431 return componentInstance;
1434 private void deleteForwardingPaths(String serviceId, List<String> pathIdsToDelete) {
1435 Either<Service, StorageOperationStatus> storageStatus = toscaOperationFacade.getToscaElement(serviceId);
1436 if (storageStatus.isRight()) {
1437 throw new ByActionStatusComponentException(componentsUtils.convertFromStorageResponse(storageStatus.right().value()));
1439 Either<Set<String>, StorageOperationStatus> result = forwardingPathOperation
1440 .deleteForwardingPath(storageStatus.left().value(), Sets.newHashSet(pathIdsToDelete));
1441 if (result.isRight()) {
1442 throw new ByActionStatusComponentException(componentsUtils.convertFromStorageResponse(result.right().value()));
1446 private List<String> getForwardingPathsRelatedToComponentInstance(String containerComponentId, String componentInstanceId) {
1447 Collection<ForwardingPathDataDefinition> allPaths = getForwardingPathDataDefinitions(containerComponentId);
1448 List<String> pathIDsToBeDeleted = new ArrayList<>();
1449 allPaths.stream().filter(path -> isPathRelatedToComponent(path, componentInstanceId))
1450 .forEach(path -> pathIDsToBeDeleted.add(path.getUniqueId()));
1451 return pathIDsToBeDeleted;
1454 private Collection<ForwardingPathDataDefinition> getForwardingPathDataDefinitions(String containerComponentId) {
1455 ComponentParametersView filter = new ComponentParametersView(true);
1456 filter.setIgnoreServicePath(false);
1457 Either<Service, StorageOperationStatus> forwardingPathOrigin = toscaOperationFacade.getToscaElement(containerComponentId, filter);
1458 return forwardingPathOrigin.left().value().getForwardingPaths().values();
1461 private boolean isPathRelatedToComponent(ForwardingPathDataDefinition pathDataDefinition, String componentInstanceId) {
1462 return pathDataDefinition.getPathElements().getListToscaDataDefinition().stream().anyMatch(
1463 elementDataDefinition -> elementDataDefinition.getFromNode().equalsIgnoreCase(componentInstanceId) || elementDataDefinition.getToNode()
1464 .equalsIgnoreCase(componentInstanceId));
1467 private ComponentInstance deleteComponentInstance(Component containerComponent, String componentInstanceId,
1468 ComponentTypeEnum containerComponentType) {
1469 Either<ImmutablePair<Component, String>, StorageOperationStatus> deleteRes = toscaOperationFacade
1470 .deleteComponentInstanceFromTopologyTemplate(containerComponent, componentInstanceId);
1471 if (deleteRes.isRight()) {
1472 log.debug("Failed to delete entry on graph for resourceInstance {}", componentInstanceId);
1473 ActionStatus status = componentsUtils.convertFromStorageResponse(deleteRes.right().value(), containerComponentType);
1474 throw new ByActionStatusComponentException(status, componentInstanceId);
1476 log.debug("The component instance {} has been removed from container component {}. ", componentInstanceId, containerComponent);
1477 ComponentInstance deletedInstance = findAndRemoveComponentInstanceFromContainerComponent(componentInstanceId, containerComponent);
1478 if (CollectionUtils.isNotEmpty(containerComponent.getInputs())) {
1479 List<InputDefinition> inputsToDelete = containerComponent.getInputs().stream()
1480 .filter(i -> i.getInstanceUniqueId() != null && i.getInstanceUniqueId().equals(componentInstanceId)).collect(Collectors.toList());
1481 if (CollectionUtils.isNotEmpty(inputsToDelete)) {
1482 StorageOperationStatus deleteInputsRes = toscaOperationFacade
1483 .deleteComponentInstanceInputsFromTopologyTemplate(containerComponent, inputsToDelete);
1484 if (deleteInputsRes != StorageOperationStatus.OK) {
1485 log.debug("Failed to delete inputs of the component instance {} from container component. ", componentInstanceId);
1486 throw new ByActionStatusComponentException(componentsUtils.convertFromStorageResponse(deleteInputsRes, containerComponentType),
1487 componentInstanceId);
1491 if (CollectionUtils.isNotEmpty(containerComponent.getOutputs())) {
1492 final List<OutputDefinition> outputsToDelete = containerComponent.getOutputs().stream()
1493 .filter(i -> i.getInstanceUniqueId() != null && i.getInstanceUniqueId().equals(componentInstanceId)).collect(Collectors.toList());
1494 if (CollectionUtils.isNotEmpty(outputsToDelete)) {
1495 final StorageOperationStatus deleteOutputsRes = toscaOperationFacade
1496 .deleteComponentInstanceOutputsFromTopologyTemplate(containerComponent, outputsToDelete);
1497 if (deleteOutputsRes != StorageOperationStatus.OK) {
1498 log.debug("Failed to delete outputs of the component instance {} from container component. ", componentInstanceId);
1499 throw new ByActionStatusComponentException(componentsUtils.convertFromStorageResponse(deleteOutputsRes, containerComponentType),
1500 componentInstanceId);
1504 return deletedInstance;
1507 private ComponentInstance findAndRemoveComponentInstanceFromContainerComponent(String componentInstanceId, Component containerComponent) {
1508 ComponentInstance foundInstance = null;
1509 for (ComponentInstance instance : containerComponent.getComponentInstances()) {
1510 if (instance.getUniqueId().equals(componentInstanceId)) {
1511 foundInstance = instance;
1512 containerComponent.getComponentInstances().remove(instance);
1516 findAndRemoveComponentInstanceRelations(componentInstanceId, containerComponent);
1517 return foundInstance;
1520 private void findAndRemoveComponentInstanceRelations(String componentInstanceId, Component containerComponent) {
1521 if (CollectionUtils.isNotEmpty(containerComponent.getComponentInstancesRelations())) {
1522 containerComponent.setComponentInstancesRelations(
1523 containerComponent.getComponentInstancesRelations().stream().filter(r -> isNotBelongingRelation(componentInstanceId, r))
1524 .collect(Collectors.toList()));
1528 private boolean isNotBelongingRelation(String componentInstanceId, RequirementCapabilityRelDef relation) {
1529 return !relation.getToNode().equals(componentInstanceId) && !relation.getFromNode().equals(componentInstanceId);
1532 public RequirementCapabilityRelDef associateRIToRI(String componentId, String userId, RequirementCapabilityRelDef requirementDef,
1533 ComponentTypeEnum componentTypeEnum) {
1534 return associateRIToRI(componentId, userId, requirementDef, componentTypeEnum, true);
1537 public RequirementCapabilityRelDef associateRIToRI(String componentId, String userId, RequirementCapabilityRelDef requirementDef,
1538 ComponentTypeEnum componentTypeEnum, boolean needLock) {
1539 validateUserExists(userId);
1540 RequirementCapabilityRelDef requirementCapabilityRelDef;
1541 org.openecomp.sdc.be.model.Component containerComponent = validateComponentExists(componentId, componentTypeEnum, null);
1542 validateCanWorkOnComponent(containerComponent, userId);
1543 boolean failed = false;
1546 lockComponent(containerComponent, ASSOCIATE_RI_TO_RI);
1548 requirementCapabilityRelDef = associateRIToRIOnGraph(containerComponent, requirementDef);
1549 } catch (ComponentException e) {
1554 unlockComponent(failed, containerComponent);
1557 return requirementCapabilityRelDef;
1560 public RequirementCapabilityRelDef associateRIToRIOnGraph(Component containerComponent, RequirementCapabilityRelDef requirementDef) {
1561 log.debug(TRY_TO_CREATE_ENTRY_ON_GRAPH);
1562 Either<RequirementCapabilityRelDef, StorageOperationStatus> result = toscaOperationFacade
1563 .associateResourceInstances(null, containerComponent.getUniqueId(), requirementDef);
1564 if (result.isLeft()) {
1565 log.debug(ENTITY_ON_GRAPH_IS_CREATED);
1566 return result.left().value();
1568 log.debug("Failed to associate node: {} with node {}", requirementDef.getFromNode(), requirementDef.getToNode());
1569 String fromNameOrId = "";
1570 String toNameOrId = "";
1571 Either<ComponentInstance, StorageOperationStatus> fromResult = getResourceInstanceById(containerComponent, requirementDef.getFromNode());
1572 Either<ComponentInstance, StorageOperationStatus> toResult = getResourceInstanceById(containerComponent, requirementDef.getToNode());
1573 toNameOrId = requirementDef.getFromNode();
1574 fromNameOrId = requirementDef.getFromNode();
1575 if (fromResult.isLeft()) {
1576 fromNameOrId = fromResult.left().value().getName();
1578 if (toResult.isLeft()) {
1579 toNameOrId = toResult.left().value().getName();
1581 throw new ByActionStatusComponentException(componentsUtils.convertFromStorageResponseForResourceInstance(result.right().value(), true),
1582 fromNameOrId, toNameOrId, requirementDef.getRelationships().get(0).getRelation().getRequirement());
1587 * @param componentId
1589 * @param requirementDefList
1590 * @param componentTypeEnum
1593 public List<RequirementCapabilityRelDef> batchDissociateRIFromRI(String componentId, String userId,
1594 List<RequirementCapabilityRelDef> requirementDefList,
1595 ComponentTypeEnum componentTypeEnum) {
1596 validateUserExists(userId);
1597 org.openecomp.sdc.be.model.Component containerComponent = validateComponentExists(componentId, componentTypeEnum, null);
1598 validateCanWorkOnComponent(containerComponent, userId);
1599 boolean failed = false;
1600 List<RequirementCapabilityRelDef> delOkResult = new ArrayList<>();
1602 lockComponent(containerComponent, ASSOCIATE_RI_TO_RI);
1603 for (RequirementCapabilityRelDef requirementDef : requirementDefList) {
1604 RequirementCapabilityRelDef requirementCapabilityRelDef = dissociateRIFromRI(componentId, userId, requirementDef,
1605 containerComponent.getComponentType());
1606 delOkResult.add(requirementCapabilityRelDef);
1608 } catch (ComponentException e) {
1612 unlockComponent(failed, containerComponent);
1617 public RequirementCapabilityRelDef dissociateRIFromRI(String componentId, String userId, RequirementCapabilityRelDef requirementDef,
1618 ComponentTypeEnum componentTypeEnum) {
1619 validateUserExists(userId);
1620 org.openecomp.sdc.be.model.Component containerComponent = validateComponentExists(componentId, componentTypeEnum, null);
1621 validateCanWorkOnComponent(containerComponent, userId);
1622 boolean failed = false;
1624 lockComponent(containerComponent, ASSOCIATE_RI_TO_RI);
1625 log.debug(TRY_TO_CREATE_ENTRY_ON_GRAPH);
1626 Either<RequirementCapabilityRelDef, StorageOperationStatus> result = toscaOperationFacade
1627 .dissociateResourceInstances(componentId, requirementDef);
1628 if (result.isLeft()) {
1629 log.debug(ENTITY_ON_GRAPH_IS_CREATED);
1630 return result.left().value();
1632 log.debug("Failed to dissocaite node {} from node {}", requirementDef.getFromNode(), requirementDef.getToNode());
1633 String fromNameOrId = "";
1634 String toNameOrId = "";
1635 Either<ComponentInstance, StorageOperationStatus> fromResult = getResourceInstanceById(containerComponent,
1636 requirementDef.getFromNode());
1637 Either<ComponentInstance, StorageOperationStatus> toResult = getResourceInstanceById(containerComponent, requirementDef.getToNode());
1638 toNameOrId = requirementDef.getFromNode();
1639 fromNameOrId = requirementDef.getFromNode();
1640 if (fromResult.isLeft()) {
1641 fromNameOrId = fromResult.left().value().getName();
1643 if (toResult.isLeft()) {
1644 toNameOrId = toResult.left().value().getName();
1646 throw new ByActionStatusComponentException(
1647 componentsUtils.convertFromStorageResponseForResourceInstance(result.right().value(), true), fromNameOrId, toNameOrId,
1648 requirementDef.getRelationships().get(0).getRelation().getRequirement());
1650 } catch (ComponentException e) {
1654 unlockComponent(failed, containerComponent);
1659 * Allows to get relation contained in specified component according to received Id
1661 * @param componentId
1664 * @param componentTypeEnum
1667 public Either<RequirementCapabilityRelDef, ResponseFormat> getRelationById(String componentId, String relationId, String userId,
1668 ComponentTypeEnum componentTypeEnum) {
1669 Either<RequirementCapabilityRelDef, ResponseFormat> resultOp = null;
1671 org.openecomp.sdc.be.model.Component containerComponent = null;
1672 RequirementCapabilityRelDef foundRelation = null;
1673 validateUserExists(userId);
1674 containerComponent = validateComponentExists(componentId, componentTypeEnum, null);
1675 List<RequirementCapabilityRelDef> requirementCapabilityRelations = containerComponent.getComponentInstancesRelations();
1676 foundRelation = findRelation(relationId, requirementCapabilityRelations);
1677 if (foundRelation == null) {
1678 ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.RELATION_NOT_FOUND, relationId, componentId);
1679 log.debug("Relation with id {} was not found on the component", relationId, componentId);
1680 resultOp = Either.right(responseFormat);
1682 if (resultOp == null) {
1683 resultOp = setRelatedCapability(foundRelation, containerComponent);
1685 if (resultOp.isLeft()) {
1686 resultOp = setRelatedRequirement(foundRelation, containerComponent);
1688 } catch (Exception e) {
1689 log.error("The exception {} occured upon get relation {} of the component {} ", e, relationId, componentId);
1690 resultOp = Either.right(componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR));
1695 private RequirementCapabilityRelDef findRelation(String relationId, List<RequirementCapabilityRelDef> requirementCapabilityRelations) {
1696 for (RequirementCapabilityRelDef relationship : requirementCapabilityRelations) {
1697 if (relationship.getRelationships().stream().anyMatch(r -> r.getRelation().getId().equals(relationId))) {
1698 return relationship;
1704 private Either<RequirementCapabilityRelDef, ResponseFormat> setRelatedRequirement(RequirementCapabilityRelDef foundRelation,
1705 Component containerComponent) {
1706 Either<RequirementCapabilityRelDef, ResponseFormat> result = null;
1707 RelationshipInfo relationshipInfo = foundRelation.resolveSingleRelationship().getRelation();
1708 String instanceId = foundRelation.getFromNode();
1709 Optional<RequirementDefinition> foundRequirement;
1710 Optional<ComponentInstance> instance = containerComponent.getComponentInstances().stream().filter(i -> i.getUniqueId().equals(instanceId))
1712 if (!instance.isPresent()) {
1713 ResponseFormat responseFormat = componentsUtils
1714 .getResponseFormat(ActionStatus.COMPONENT_INSTANCE_NOT_FOUND_ON_CONTAINER, instanceId, "instance",
1715 containerComponent.getComponentType().getValue(), containerComponent.getName());
1716 log.debug("Component instance with id {} was not found on the component", instanceId, containerComponent.getUniqueId());
1717 result = Either.right(responseFormat);
1719 if (result == null && instance.isPresent()) {
1720 for (List<RequirementDefinition> requirements : instance.get().getRequirements().values()) {
1721 foundRequirement = requirements.stream()
1722 .filter(r -> isBelongingCalcRequirement(relationshipInfo, r, containerComponent.getLifecycleState())).findFirst();
1723 if (foundRequirement.isPresent()) {
1724 foundRelation.resolveSingleRelationship().setRequirement(foundRequirement.get());
1725 result = Either.left(foundRelation);
1729 if (result == null) {
1730 Either<RequirementDataDefinition, StorageOperationStatus> getfulfilledRequirementRes = toscaOperationFacade
1731 .getFulfilledRequirementByRelation(containerComponent.getUniqueId(), instanceId, foundRelation, this::isBelongingFullRequirement);
1732 if (getfulfilledRequirementRes.isRight()) {
1733 ResponseFormat responseFormat = componentsUtils
1734 .getResponseFormat(ActionStatus.REQUIREMENT_OF_INSTANCE_NOT_FOUND_ON_CONTAINER, relationshipInfo.getRequirement(), instanceId,
1735 containerComponent.getUniqueId());
1736 log.debug("Requirement {} of instance {} was not found on the container {}. ", relationshipInfo.getCapability(), instanceId,
1737 containerComponent.getUniqueId());
1738 result = Either.right(responseFormat);
1740 foundRelation.resolveSingleRelationship().setRequirement(getfulfilledRequirementRes.left().value());
1743 if (result == null) {
1744 result = Either.left(foundRelation);
1749 private boolean isBelongingFullRequirement(RelationshipInfo relationshipInfo, RequirementDataDefinition req) {
1750 return req.getName().equals(relationshipInfo.getRequirement()) && req.getUniqueId().equals(relationshipInfo.getRequirementUid()) && req
1751 .getOwnerId().equals(relationshipInfo.getRequirementOwnerId());
1754 private boolean isBelongingCalcRequirement(RelationshipInfo relationshipInfo, RequirementDataDefinition req, LifecycleStateEnum state) {
1755 return nameMatches(relationshipInfo.getRequirement(), req.getName(), req.getPreviousName(), state) && req.getUniqueId()
1756 .equals(relationshipInfo.getRequirementUid()) && req.getOwnerId().equals(relationshipInfo.getRequirementOwnerId());
1759 private Either<RequirementCapabilityRelDef, ResponseFormat> setRelatedCapability(RequirementCapabilityRelDef foundRelation,
1760 Component containerComponent) {
1761 Either<RequirementCapabilityRelDef, ResponseFormat> result = null;
1762 RelationshipInfo relationshipInfo = foundRelation.resolveSingleRelationship().getRelation();
1763 String instanceId = foundRelation.getToNode();
1764 Optional<CapabilityDefinition> foundCapability;
1765 Optional<ComponentInstance> instance = containerComponent.getComponentInstances().stream().filter(i -> i.getUniqueId().equals(instanceId))
1767 if (!instance.isPresent()) {
1768 ResponseFormat responseFormat = componentsUtils
1769 .getResponseFormat(ActionStatus.COMPONENT_INSTANCE_NOT_FOUND_ON_CONTAINER, instanceId, "instance",
1770 containerComponent.getComponentType().getValue(), containerComponent.getName());
1771 log.debug("Component instance with id {} was not found on the component", instanceId, containerComponent.getUniqueId());
1772 result = Either.right(responseFormat);
1774 if (result == null && instance.isPresent()) {
1775 for (List<CapabilityDefinition> capabilities : instance.get().getCapabilities().values()) {
1776 foundCapability = capabilities.stream()
1777 .filter(c -> isBelongingCalcCapability(relationshipInfo, c, containerComponent.getLifecycleState())).findFirst();
1778 if (foundCapability.isPresent()) {
1779 foundRelation.resolveSingleRelationship().setCapability(foundCapability.get());
1780 result = Either.left(foundRelation);
1784 if (result == null) {
1785 Either<CapabilityDataDefinition, StorageOperationStatus> getfulfilledRequirementRes = toscaOperationFacade
1786 .getFulfilledCapabilityByRelation(containerComponent.getUniqueId(), instanceId, foundRelation, this::isBelongingFullCapability);
1787 if (getfulfilledRequirementRes.isRight()) {
1788 ResponseFormat responseFormat = componentsUtils
1789 .getResponseFormat(ActionStatus.CAPABILITY_OF_INSTANCE_NOT_FOUND_ON_CONTAINER, relationshipInfo.getCapability(), instanceId,
1790 containerComponent.getUniqueId());
1791 log.debug("Capability {} of instance {} was not found on the container {}. ", relationshipInfo.getCapability(), instanceId,
1792 containerComponent.getUniqueId());
1793 result = Either.right(responseFormat);
1795 foundRelation.resolveSingleRelationship().setCapability(getfulfilledRequirementRes.left().value());
1798 if (result == null) {
1799 result = Either.left(foundRelation);
1804 private boolean isBelongingFullCapability(RelationshipInfo relationshipInfo, CapabilityDataDefinition cap) {
1805 return cap.getName().equals(relationshipInfo.getCapability()) && cap.getUniqueId().equals(relationshipInfo.getCapabilityUid()) && cap
1806 .getOwnerId().equals(relationshipInfo.getCapabilityOwnerId());
1809 private boolean isBelongingCalcCapability(RelationshipInfo relationshipInfo, CapabilityDataDefinition cap, LifecycleStateEnum state) {
1810 return nameMatches(relationshipInfo.getCapability(), cap.getName(), cap.getPreviousName(), state) && cap.getUniqueId()
1811 .equals(relationshipInfo.getCapabilityUid()) && cap.getOwnerId().equals(relationshipInfo.getCapabilityOwnerId());
1814 private boolean nameMatches(String nameFromRelationship, String currName, String previousName, LifecycleStateEnum state) {
1815 return state == LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT ? currName.equals(nameFromRelationship)
1816 : previousName != null && previousName.equals(nameFromRelationship);
1819 private Either<ComponentInstanceProperty, ResponseFormat> updateAttributeValue(ComponentInstanceProperty attribute, String resourceInstanceId) {
1820 Either<ComponentInstanceProperty, StorageOperationStatus> eitherAttribute = componentInstanceOperation
1821 .updateAttributeValueInResourceInstance(attribute, resourceInstanceId, true);
1822 Either<ComponentInstanceProperty, ResponseFormat> result;
1823 if (eitherAttribute.isLeft()) {
1824 log.debug("Attribute value {} was updated on graph.", attribute.getValueUniqueUid());
1825 ComponentInstanceProperty instanceAttribute = eitherAttribute.left().value();
1826 result = Either.left(instanceAttribute);
1828 log.debug("Failed to update attribute value {} in resource instance {}", attribute, resourceInstanceId);
1829 ActionStatus actionStatus = componentsUtils.convertFromStorageResponseForResourceInstanceProperty(eitherAttribute.right().value());
1830 result = Either.right(componentsUtils.getResponseFormat(actionStatus, ""));
1835 private Either<ComponentInstanceProperty, ResponseFormat> createAttributeValue(ComponentInstanceProperty attribute, String resourceInstanceId) {
1836 Either<ComponentInstanceProperty, ResponseFormat> result;
1837 Wrapper<Integer> indexCounterWrapper = new Wrapper<>();
1838 Wrapper<ResponseFormat> errorWrapper = new Wrapper<>();
1839 validateIncrementCounter(resourceInstanceId, GraphPropertiesDictionary.ATTRIBUTE_COUNTER, indexCounterWrapper, errorWrapper);
1840 if (!errorWrapper.isEmpty()) {
1841 result = Either.right(errorWrapper.getInnerElement());
1843 Either<ComponentInstanceProperty, StorageOperationStatus> eitherAttribute = componentInstanceOperation
1844 .addAttributeValueToResourceInstance(attribute, resourceInstanceId, indexCounterWrapper.getInnerElement(), true);
1845 if (eitherAttribute.isLeft()) {
1846 log.debug("Attribute value was added to resource instance {}", resourceInstanceId);
1847 ComponentInstanceProperty instanceAttribute = eitherAttribute.left().value();
1848 result = Either.left(instanceAttribute);
1850 log.debug("Failed to add attribute value {} to resource instance {}", attribute, resourceInstanceId);
1851 ActionStatus actionStatus = componentsUtils.convertFromStorageResponseForResourceInstanceProperty(eitherAttribute.right().value());
1852 result = Either.right(componentsUtils.getResponseFormatForResourceInstanceProperty(actionStatus, ""));
1859 * Create Or Updates Attribute Instance
1861 * @param componentTypeEnum
1862 * @param componentId
1863 * @param resourceInstanceId
1868 public Either<ComponentInstanceProperty, ResponseFormat> createOrUpdateAttributeValue(ComponentTypeEnum componentTypeEnum, String componentId,
1869 String resourceInstanceId,
1870 ComponentInstanceProperty attribute, String userId) {
1871 Either<ComponentInstanceProperty, ResponseFormat> result = null;
1872 Wrapper<ResponseFormat> errorWrapper = new Wrapper<>();
1873 validateUserExists(userId);
1874 if (errorWrapper.isEmpty()) {
1875 validateComponentTypeEnum(componentTypeEnum, "CreateOrUpdateAttributeValue", errorWrapper);
1877 if (errorWrapper.isEmpty()) {
1878 validateCanWorkOnComponent(componentId, componentTypeEnum, userId, errorWrapper);
1880 if (errorWrapper.isEmpty()) {
1881 validateComponentLock(componentId, componentTypeEnum, errorWrapper);
1884 if (errorWrapper.isEmpty()) {
1885 final boolean isCreate = Objects.isNull(attribute.getValueUniqueUid());
1887 result = createAttributeValue(attribute, resourceInstanceId);
1889 result = updateAttributeValue(attribute, resourceInstanceId);
1892 result = Either.right(errorWrapper.getInnerElement());
1896 if (result == null || result.isRight()) {
1897 janusGraphDao.rollback();
1899 janusGraphDao.commit();
1902 graphLockOperation.unlockComponent(componentId, componentTypeEnum.getNodeType());
1906 public Either<List<ComponentInstanceProperty>, ResponseFormat> createOrUpdatePropertiesValues(ComponentTypeEnum componentTypeEnum,
1907 String componentId, String resourceInstanceId,
1908 List<ComponentInstanceProperty> properties,
1910 Either<List<ComponentInstanceProperty>, ResponseFormat> resultOp = null;
1911 /*-------------------------------Validations---------------------------------*/
1912 validateUserExists(userId);
1914 if (componentTypeEnum == null) {
1915 BeEcompErrorManager.getInstance().logInvalidInputError("CreateOrUpdatePropertiesValues", INVALID_COMPONENT_TYPE, ErrorSeverity.INFO);
1916 resultOp = Either.right(componentsUtils.getResponseFormat(ActionStatus.NOT_ALLOWED));
1919 Either<Component, StorageOperationStatus> getResourceResult = toscaOperationFacade.getToscaElement(componentId, JsonParseFlagEnum.ParseAll);
1921 if (getResourceResult.isRight()) {
1922 log.debug(FAILED_TO_RETRIEVE_COMPONENT_COMPONENT_ID, componentId);
1923 ActionStatus actionStatus = componentsUtils.convertFromStorageResponse(getResourceResult.right().value(), componentTypeEnum);
1924 return Either.right(componentsUtils.getResponseFormat(actionStatus, componentId));
1926 Component containerComponent = getResourceResult.left().value();
1928 if (!ComponentValidationUtils.canWorkOnComponent(containerComponent, userId)) {
1929 if (Boolean.TRUE.equals(containerComponent.isArchived())) {
1930 log.info(COMPONENT_ARCHIVED, componentId);
1931 return Either.right(componentsUtils.getResponseFormat(ActionStatus.COMPONENT_IS_ARCHIVED, containerComponent.getName()));
1933 log.info(RESTRICTED_OPERATION_ON_SERVIVE, userId, componentId);
1934 return Either.right(componentsUtils.getResponseFormat(ActionStatus.RESTRICTED_OPERATION));
1937 Either<ComponentInstance, StorageOperationStatus> resourceInstanceStatus = getResourceInstanceById(containerComponent, resourceInstanceId);
1938 if (resourceInstanceStatus.isRight()) {
1939 return Either.right(componentsUtils.getResponseFormat(ActionStatus.COMPONENT_INSTANCE_NOT_FOUND_ON_CONTAINER,
1940 resourceInstanceId, RESOURCE_INSTANCE, SERVICE, componentId));
1942 ComponentInstance foundResourceInstance = resourceInstanceStatus.left().value();
1945 StorageOperationStatus lockStatus = graphLockOperation.lockComponent(componentId, componentTypeEnum.getNodeType());
1946 if (lockStatus != StorageOperationStatus.OK) {
1947 log.debug(FAILED_TO_LOCK_SERVICE, componentId);
1948 return Either.right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(lockStatus)));
1950 List<ComponentInstanceProperty> updatedProperties = new ArrayList<>();
1952 for (ComponentInstanceProperty property : properties) {
1953 validateMandatoryFields(property);
1954 ComponentInstanceProperty componentInstanceProperty = validatePropertyExistsOnComponent(property, containerComponent,
1955 foundResourceInstance);
1956 String propertyParentUniqueId = property.getParentUniqueId();
1957 Either<String, ResponseFormat> updatedPropertyValue = updatePropertyObjectValue(property, false);
1958 if (updatedPropertyValue.isRight()) {
1959 log.error("Failed to update property object value of property: {}",
1961 throw new ByResponseFormatComponentException(updatedPropertyValue.right().value());
1963 Optional<CapabilityDefinition>
1964 capPropDefinition = getPropertyCapabilityOfChildInstance(propertyParentUniqueId, foundResourceInstance.getCapabilities());
1965 if (capPropDefinition.isPresent()) {
1966 updatedPropertyValue
1967 .bimap(updatedValue -> updateCapabilityPropFromUpdateInstProp(property, updatedValue,
1968 containerComponent, foundResourceInstance, capPropDefinition.get().getType(),
1969 capPropDefinition.get().getName()), Either::right);
1971 updatedPropertyValue.bimap(
1973 componentInstanceProperty.setValue(updatedValue);
1974 return updatePropertyOnContainerComponent(property, updatedValue,
1975 containerComponent, foundResourceInstance);
1977 updatedProperties.add(componentInstanceProperty);
1981 Either<Component, StorageOperationStatus> updateContainerRes = toscaOperationFacade
1982 .updateComponentInstanceMetadataOfTopologyTemplate(containerComponent);
1983 if (updateContainerRes.isRight()) {
1984 ActionStatus actionStatus = componentsUtils.convertFromStorageResponseForResourceInstanceProperty(updateContainerRes.right().value());
1985 resultOp = Either.right(componentsUtils.getResponseFormatForResourceInstanceProperty(actionStatus, ""));
1988 resultOp = Either.left(updatedProperties);
1991 } catch (final ComponentException e) {
1992 return Either.right(e.getResponseFormat());
1994 if (resultOp == null || resultOp.isRight()) {
1995 janusGraphDao.rollback();
1997 janusGraphDao.commit();
2000 graphLockOperation.unlockComponent(componentId, componentTypeEnum.getNodeType());
2004 public Either<List<ComponentInstanceAttribute>, ResponseFormat> createOrUpdateAttributeValues(final ComponentTypeEnum componentTypeEnum,
2005 final String componentId,
2006 final String resourceInstanceId,
2007 final List<ComponentInstanceAttribute> attributes,
2008 final String userId) {
2009 Either<List<ComponentInstanceAttribute>, ResponseFormat> resultOp = null;
2010 /*-------------------------------Validations---------------------------------*/
2011 validateUserExists(userId);
2013 if (componentTypeEnum == null) {
2014 BeEcompErrorManager.getInstance().logInvalidInputError("CreateOrUpdatePropertiesValues", INVALID_COMPONENT_TYPE, ErrorSeverity.INFO);
2015 resultOp = Either.right(componentsUtils.getResponseFormat(ActionStatus.NOT_ALLOWED));
2018 final Either<Component, StorageOperationStatus> getResourceResult = toscaOperationFacade
2019 .getToscaElement(componentId, JsonParseFlagEnum.ParseAll);
2021 if (getResourceResult.isRight()) {
2022 log.debug(FAILED_TO_RETRIEVE_COMPONENT_COMPONENT_ID, componentId);
2023 final ActionStatus actionStatus = componentsUtils.convertFromStorageResponse(getResourceResult.right().value(), componentTypeEnum);
2024 return Either.right(componentsUtils.getResponseFormat(actionStatus, componentId));
2026 final Component containerComponent = getResourceResult.left().value();
2028 if (!ComponentValidationUtils.canWorkOnComponent(containerComponent, userId)) {
2029 if (Boolean.TRUE.equals(containerComponent.isArchived())) {
2030 log.info(COMPONENT_ARCHIVED, componentId);
2031 return Either.right(componentsUtils.getResponseFormat(ActionStatus.COMPONENT_IS_ARCHIVED, containerComponent.getName()));
2033 log.info(RESTRICTED_OPERATION_ON_SERVIVE, userId, componentId);
2034 return Either.right(componentsUtils.getResponseFormat(ActionStatus.RESTRICTED_OPERATION));
2037 final Either<ComponentInstance, StorageOperationStatus> resourceInstanceStatus = getResourceInstanceById(containerComponent,
2038 resourceInstanceId);
2039 if (resourceInstanceStatus.isRight()) {
2040 return Either.right(componentsUtils.getResponseFormat(ActionStatus.COMPONENT_INSTANCE_NOT_FOUND_ON_CONTAINER,
2041 resourceInstanceId, RESOURCE_INSTANCE, SERVICE, componentId));
2043 final ComponentInstance foundResourceInstance = resourceInstanceStatus.left().value();
2046 final StorageOperationStatus lockStatus = graphLockOperation.lockComponent(componentId, componentTypeEnum.getNodeType());
2047 if (lockStatus != StorageOperationStatus.OK) {
2048 log.debug(FAILED_TO_LOCK_SERVICE, componentId);
2049 return Either.right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(lockStatus)));
2051 final List<ComponentInstanceAttribute> updatedProperties = new ArrayList<>();
2053 for (final ComponentInstanceAttribute attribute : attributes) {
2054 final ComponentInstanceAttribute componentInstanceProperty = validateAttributeExistsOnComponent(attribute, containerComponent,
2055 foundResourceInstance);
2056 final Either<String, ResponseFormat> updatedPropertyValue = updateAttributeObjectValue(attribute);
2057 if (updatedPropertyValue.isRight()) {
2058 log.error("Failed to update attribute object value of attribute: {}", attribute);
2059 throw new ByResponseFormatComponentException(updatedPropertyValue.right().value());
2061 updatedPropertyValue.bimap(
2063 componentInstanceProperty.setValue(updatedValue);
2064 return updateAttributeOnContainerComponent(attribute, updatedValue,
2065 containerComponent, foundResourceInstance);
2067 updatedProperties.add(componentInstanceProperty);
2070 final Either<Component, StorageOperationStatus> updateContainerRes = toscaOperationFacade
2071 .updateComponentInstanceMetadataOfTopologyTemplate(containerComponent);
2072 if (updateContainerRes.isRight()) {
2073 final ActionStatus actionStatus = componentsUtils
2074 .convertFromStorageResponseForResourceInstanceProperty(updateContainerRes.right().value());
2075 resultOp = Either.right(componentsUtils.getResponseFormatForResourceInstanceProperty(actionStatus, ""));
2078 resultOp = Either.left(updatedProperties);
2081 } catch (final ComponentException e) {
2082 return Either.right(e.getResponseFormat());
2084 if (resultOp == null || resultOp.isRight()) {
2085 janusGraphDao.rollback();
2087 janusGraphDao.commit();
2090 graphLockOperation.unlockComponent(componentId, componentTypeEnum.getNodeType());
2094 private void validateMandatoryFields(PropertyDataDefinition property) {
2095 if (StringUtils.isEmpty(property.getName())) {
2096 throw new ByActionStatusComponentException(ActionStatus.MISSING_PROPERTY_NAME);
2100 private ComponentInstanceProperty validatePropertyExistsOnComponent(ComponentInstanceProperty property, Component containerComponent,
2101 ComponentInstance foundResourceInstance) {
2102 List<ComponentInstanceProperty> instanceProperties = containerComponent.getComponentInstancesProperties()
2103 .get(foundResourceInstance.getUniqueId());
2104 Optional<ComponentInstanceProperty> instanceProperty = instanceProperties.stream().filter(p -> p.getName().equals(property.getName()))
2106 if (!instanceProperty.isPresent()) {
2107 throw new ByActionStatusComponentException(ActionStatus.PROPERTY_NOT_FOUND, property.getName());
2109 return instanceProperty.get();
2112 private ComponentInstanceAttribute validateAttributeExistsOnComponent(final ComponentInstanceAttribute attribute,
2113 final Component containerComponent,
2114 final ComponentInstance foundResourceInstance) {
2115 final List<ComponentInstanceAttribute> instanceProperties =
2116 containerComponent.getComponentInstancesAttributes().get(foundResourceInstance.getUniqueId());
2117 final Optional<ComponentInstanceAttribute> instanceAttribute =
2118 instanceProperties.stream().filter(p -> p.getName().equals(attribute.getName())).findAny();
2119 if (!instanceAttribute.isPresent()) {
2120 throw new ByActionStatusComponentException(ActionStatus.PROPERTY_NOT_FOUND, attribute.getName());
2122 return instanceAttribute.get();
2125 private ResponseFormat updateCapabilityPropertyOnContainerComponent(ComponentInstanceProperty property,
2126 String newValue, Component containerComponent,
2127 ComponentInstance foundResourceInstance,
2128 String capabilityType, String capabilityName) {
2129 String componentInstanceUniqueId = foundResourceInstance.getUniqueId();
2130 ResponseFormat actionStatus = updateCapPropOnContainerComponent(property, newValue, containerComponent,
2131 foundResourceInstance, capabilityType, capabilityName, componentInstanceUniqueId);
2132 if (actionStatus != null) {
2133 return actionStatus;
2136 return componentsUtils.getResponseFormat(ActionStatus.OK);
2139 private ResponseFormat updateCapabilityPropFromUpdateInstProp(ComponentInstanceProperty property,
2140 String newValue, Component containerComponent,
2141 ComponentInstance foundResourceInstance,
2142 String capabilityType, String capabilityName) {
2143 String componentInstanceUniqueId = foundResourceInstance.getUniqueId();
2144 Either<Component, StorageOperationStatus> getComponentRes =
2145 toscaOperationFacade.getToscaFullElement(foundResourceInstance.getComponentUid());
2146 if (getComponentRes.isRight()) {
2147 return componentsUtils.getResponseFormat(getComponentRes.right().value());
2150 ResponseFormat actionStatus = updateCapPropOnContainerComponent(property, newValue, containerComponent,
2151 foundResourceInstance, capabilityType, capabilityName, componentInstanceUniqueId);
2152 if (actionStatus != null) {
2153 return actionStatus;
2156 return componentsUtils.getResponseFormat(ActionStatus.OK);
2159 private ResponseFormat updateCapPropOnContainerComponent(ComponentInstanceProperty property, String newValue,
2160 Component containerComponent,
2161 ComponentInstance foundResourceInstance,
2162 String capabilityType, String capabilityName,
2163 String componentInstanceUniqueId) {
2164 Map<String, List<CapabilityDefinition>> capabilities =
2165 Optional.ofNullable(foundResourceInstance.getCapabilities()).orElse(Collections.emptyMap());
2166 List<CapabilityDefinition> capPerType =
2167 Optional.ofNullable(capabilities.get(capabilityType)).orElse(Collections.emptyList());
2168 Optional<CapabilityDefinition> cap =
2169 capPerType.stream().filter(c -> c.getName().equals(capabilityName)).findAny();
2170 if (cap.isPresent()) {
2171 List<ComponentInstanceProperty> capProperties = cap.get().getProperties();
2172 if (capProperties != null) {
2173 Optional<ComponentInstanceProperty> instanceProperty =
2174 capProperties.stream().filter(p -> p.getUniqueId().equals(property.getUniqueId())).findAny();
2175 StorageOperationStatus status;
2176 if (instanceProperty.isPresent()) {
2177 String capKey = ModelConverter
2178 .buildCapabilityPropertyKey(foundResourceInstance.getOriginType().isAtomicType(), capabilityType, capabilityName,
2179 componentInstanceUniqueId, cap.get());
2180 instanceProperty.get().setValue(newValue);
2181 List<String> path = new ArrayList<>();
2182 path.add(componentInstanceUniqueId);
2184 instanceProperty.get().setPath(path);
2185 status = toscaOperationFacade.updateComponentInstanceCapabiltyProperty(containerComponent,
2186 componentInstanceUniqueId, capKey, instanceProperty.get());
2187 if (status != StorageOperationStatus.OK) {
2188 ActionStatus actionStatus =
2189 componentsUtils.convertFromStorageResponseForResourceInstanceProperty(status);
2190 return componentsUtils.getResponseFormatForResourceInstanceProperty(actionStatus, "");
2193 foundResourceInstance.setCustomizationUUID(UUID.randomUUID().toString());
2200 private ResponseFormat updatePropertyOnContainerComponent(ComponentInstanceProperty instanceProperty, String newValue,
2201 Component containerComponent, ComponentInstance foundResourceInstance) {
2202 StorageOperationStatus status;
2203 instanceProperty.setValue(newValue);
2204 status = toscaOperationFacade.updateComponentInstanceProperty(containerComponent, foundResourceInstance.getUniqueId(), instanceProperty);
2205 if (status != StorageOperationStatus.OK) {
2206 ActionStatus actionStatus = componentsUtils.convertFromStorageResponseForResourceInstanceProperty(status);
2207 return componentsUtils.getResponseFormatForResourceInstanceProperty(actionStatus, "");
2209 foundResourceInstance.setCustomizationUUID(UUID.randomUUID().toString());
2210 return componentsUtils.getResponseFormat(ActionStatus.OK);
2213 private ResponseFormat updateAttributeOnContainerComponent(final ComponentInstanceAttribute instanceAttribute,
2214 final String newValue,
2215 final Component containerComponent,
2216 final ComponentInstance foundResourceInstance) {
2218 instanceAttribute.setValue(newValue);
2219 final StorageOperationStatus status =
2220 toscaOperationFacade.updateComponentInstanceAttribute(containerComponent, foundResourceInstance.getUniqueId(), instanceAttribute);
2221 if (status != StorageOperationStatus.OK) {
2222 final ActionStatus actionStatus = componentsUtils.convertFromStorageResponseForResourceInstanceProperty(status);
2223 return componentsUtils.getResponseFormatForResourceInstanceProperty(actionStatus, "");
2225 foundResourceInstance.setCustomizationUUID(UUID.randomUUID().toString());
2226 return componentsUtils.getResponseFormat(ActionStatus.OK);
2229 private <T extends PropertyDefinition> Either<String, ResponseFormat> validatePropertyObjectValue(T property, String newValue, boolean isInput) {
2230 final Map<String, DataTypeDefinition> allDataTypes = componentsUtils.getAllDataTypes(applicationDataTypeCache, property.getModel());
2231 String propertyType = property.getType();
2232 String innerType = getInnerType(property);
2234 // Specific Update Logic
2235 Either<Object, Boolean> isValid = propertyOperation
2236 .validateAndUpdatePropertyValue(property.getType(), newValue, true, innerType, allDataTypes);
2237 if (isValid.isRight()) {
2238 if (!Boolean.TRUE.equals(isValid.right().value())) {
2239 log.error("Invalid value {} of property {} ", newValue, property.getName());
2240 return Either.right(componentsUtils.getResponseFormat(ActionStatus.INVALID_CONTENT));
2243 Object object = isValid.left().value();
2244 if (object != null) {
2245 newValue = object.toString();
2248 if (validateAndUpdateRules(property, isInput, allDataTypes, innerType, propertyType)) {
2249 return Either.right(componentsUtils.getResponseFormat(componentsUtils
2250 .convertFromStorageResponse(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(JanusGraphOperationStatus.ILLEGAL_ARGUMENT))));
2252 return Either.left(newValue);
2255 private <T extends PropertyDefinition> boolean validateAndUpdateRules(T property, boolean isInput, Map<String, DataTypeDefinition> allDataTypes,
2256 String innerType, String propertyType) {
2258 ImmutablePair<String, Boolean> pair = propertyOperation
2259 .validateAndUpdateRules(propertyType, ((ComponentInstanceProperty) property).getRules(), innerType, allDataTypes, true);
2260 if (pair.getRight() != null && !pair.getRight()) {
2261 BeEcompErrorManager.getInstance().logBeInvalidValueError("Add property value", pair.getLeft(), property.getName(), propertyType);
2268 private <T extends PropertyDefinition> Either<String, ResponseFormat> updatePropertyObjectValue(T property, boolean isInput) {
2269 final Map<String, DataTypeDefinition> allDataTypes = componentsUtils.getAllDataTypes(applicationDataTypeCache, property.getModel());
2270 String innerType = null;
2271 String propertyType = property.getType();
2272 ToscaPropertyType type = ToscaPropertyType.isValidType(propertyType);
2273 log.debug("The type of the property {} is {}", property.getUniqueId(), propertyType);
2275 if (type == ToscaPropertyType.LIST || type == ToscaPropertyType.MAP) {
2276 SchemaDefinition def = property.getSchema();
2278 log.debug("Schema doesn't exists for property of type {}", type);
2280 .right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(StorageOperationStatus.INVALID_VALUE)));
2282 PropertyDataDefinition propDef = def.getProperty();
2283 if (propDef == null) {
2284 log.debug("Property in Schema Definition inside property of type {} doesn't exist", type);
2286 .right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(StorageOperationStatus.INVALID_VALUE)));
2288 innerType = propDef.getType();
2291 // Specific Update Logic
2292 String newValue = property.getValue();
2294 if (property.getToscaGetFunctionType() != null) {
2295 validateToscaGetFunction(property);
2296 return Either.left(newValue);
2299 Either<Object, Boolean> isValid = propertyOperation
2300 .validateAndUpdatePropertyValue(propertyType, property.getValue(), true, innerType, allDataTypes);
2301 if (isValid.isRight()) {
2302 if (!Boolean.TRUE.equals(isValid.right().value())) {
2303 log.debug("validate and update property value has failed with value: {}", property.getValue());
2304 throw new ByActionStatusComponentException(componentsUtils.convertFromStorageResponse(
2305 DaoStatusConverter.convertJanusGraphStatusToStorageStatus(JanusGraphOperationStatus.ILLEGAL_ARGUMENT)));
2308 Object object = isValid.left().value();
2309 if (object != null) {
2310 newValue = object.toString();
2314 ImmutablePair<String, Boolean> pair = propertyOperation
2315 .validateAndUpdateRules(propertyType, ((ComponentInstanceProperty) property).getRules(), innerType, allDataTypes, true);
2316 if (pair.getRight() != null && Boolean.FALSE.equals(pair.getRight())) {
2317 BeEcompErrorManager.getInstance().logBeInvalidValueError("Add property value", pair.getLeft(), property.getName(), propertyType);
2318 return Either.right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(
2319 DaoStatusConverter.convertJanusGraphStatusToStorageStatus(JanusGraphOperationStatus.ILLEGAL_ARGUMENT))));
2322 return Either.left(newValue);
2325 private <T extends AttributeDefinition> Either<String, ResponseFormat> updateAttributeObjectValue(final T attribute) {
2326 String innerType = null;
2327 final String attributeType = attribute.getType();
2328 final ToscaPropertyType type = ToscaPropertyType.isValidType(attributeType);
2329 log.debug("The type of the attribute {} is {}", attribute.getUniqueId(), attributeType);
2331 if (type == ToscaPropertyType.LIST || type == ToscaPropertyType.MAP) {
2332 final SchemaDefinition def = attribute.getSchema();
2334 log.debug("Schema doesn't exists for attribute of type {}", type);
2336 .right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(StorageOperationStatus.INVALID_VALUE)));
2338 PropertyDataDefinition propDef = def.getProperty();
2339 if (propDef == null) {
2340 log.debug("Property in Schema Definition inside attribute of type {} doesn't exist", type);
2342 .right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(StorageOperationStatus.INVALID_VALUE)));
2344 innerType = propDef.getType();
2347 // Specific Update Logic
2348 String newValue = attribute.getValue();
2350 final var isValid = attributeOperation.validateAndUpdateAttributeValue(attribute, innerType,
2351 componentsUtils.getAllDataTypes(applicationDataTypeCache, attribute.getModel()));
2352 if (isValid.isRight()) {
2353 final Boolean res = isValid.right().value();
2354 if (!Boolean.TRUE.equals(res)) {
2355 log.debug("validate and update attribute value has failed with value: {}", newValue);
2356 throw new ByActionStatusComponentException(componentsUtils.convertFromStorageResponse(
2357 DaoStatusConverter.convertJanusGraphStatusToStorageStatus(JanusGraphOperationStatus.ILLEGAL_ARGUMENT)));
2360 final Object object = isValid.left().value();
2361 if (object != null) {
2362 newValue = object.toString();
2365 return Either.left(newValue);
2368 private <T extends PropertyDefinition> void validateToscaGetFunction(T property) {
2369 if (property.getToscaGetFunctionType() == ToscaGetFunctionType.GET_INPUT) {
2370 final List<GetInputValueDataDefinition> getInputValues = property.getGetInputValues();
2371 if (CollectionUtils.isEmpty(getInputValues)) {
2372 log.debug("No input information provided. Cannot set get_input.");
2373 throw new ByActionStatusComponentException(ActionStatus.INVALID_CONTENT);
2375 if (getInputValues.size() > 1) {
2376 log.debug("More than one input provided. Cannot set get_input.");
2377 throw new ByActionStatusComponentException(ActionStatus.INVALID_CONTENT);
2379 final GetInputValueDataDefinition getInputValueDataDefinition = getInputValues.get(0);
2381 if (!property.getType().equals(getInputValueDataDefinition.getInputType())) {
2382 log.debug("Input type '{}' diverges from the property type '{}'. Cannot set get_input.",
2383 getInputValueDataDefinition.getInputType(), property.getType());
2384 throw new ByActionStatusComponentException(ActionStatus.INVALID_CONTENT);
2389 throw new ByActionStatusComponentException(ActionStatus.NOT_SUPPORTED,
2390 "Tosca function " + property.getToscaGetFunctionType().getToscaGetFunctionName());
2393 private ResponseFormat updateInputOnContainerComponent(ComponentInstanceInput input, String newValue, Component containerComponent,
2394 ComponentInstance foundResourceInstance) {
2395 StorageOperationStatus status;
2396 input.setValue(newValue);
2397 status = toscaOperationFacade.updateComponentInstanceInput(containerComponent, foundResourceInstance.getUniqueId(), input);
2398 if (status != StorageOperationStatus.OK) {
2399 ActionStatus actionStatus = componentsUtils.convertFromStorageResponseForResourceInstanceProperty(status);
2400 return componentsUtils.getResponseFormatForResourceInstanceProperty(actionStatus, "");
2402 foundResourceInstance.setCustomizationUUID(UUID.randomUUID().toString());
2403 return componentsUtils.getResponseFormat(ActionStatus.OK);
2406 public Either<List<ComponentInstanceInput>, ResponseFormat> createOrUpdateInstanceInputValues(ComponentTypeEnum componentTypeEnum,
2407 String componentId, String resourceInstanceId,
2408 List<ComponentInstanceInput> inputs,
2411 Either<List<ComponentInstanceInput>, ResponseFormat> resultOp = null;
2413 validateUserExists(userId);
2415 if (componentTypeEnum == null) {
2416 BeEcompErrorManager.getInstance().logInvalidInputError(CREATE_OR_UPDATE_PROPERTY_VALUE, INVALID_COMPONENT_TYPE, ErrorSeverity.INFO);
2417 resultOp = Either.right(componentsUtils.getResponseFormat(ActionStatus.NOT_ALLOWED));
2420 Either<Component, StorageOperationStatus> getResourceResult = toscaOperationFacade.getToscaElement(componentId, JsonParseFlagEnum.ParseAll);
2422 if (getResourceResult.isRight()) {
2423 log.debug(FAILED_TO_RETRIEVE_COMPONENT_COMPONENT_ID, componentId);
2424 ActionStatus actionStatus = componentsUtils.convertFromStorageResponse(getResourceResult.right().value(), componentTypeEnum);
2425 return Either.right(componentsUtils.getResponseFormat(actionStatus, componentId));
2427 Component containerComponent = getResourceResult.left().value();
2429 if (!ComponentValidationUtils.canWorkOnComponent(containerComponent, userId)) {
2430 if (Boolean.TRUE.equals(containerComponent.isArchived())) {
2431 log.info(COMPONENT_ARCHIVED, componentId);
2432 return Either.right(componentsUtils.getResponseFormat(ActionStatus.COMPONENT_IS_ARCHIVED, containerComponent.getName()));
2434 log.info(RESTRICTED_OPERATION_ON_SERVIVE, userId, componentId);
2435 resultOp = Either.right(componentsUtils.getResponseFormat(ActionStatus.RESTRICTED_OPERATION));
2438 Either<ComponentInstance, StorageOperationStatus> resourceInstanceStatus = getResourceInstanceById(containerComponent, resourceInstanceId);
2439 if (resourceInstanceStatus.isRight()) {
2440 return Either.right(componentsUtils.getResponseFormat(ActionStatus.COMPONENT_INSTANCE_NOT_FOUND_ON_CONTAINER,
2441 resourceInstanceId, RESOURCE_INSTANCE, SERVICE, componentId));
2444 ComponentInstance foundResourceInstance = resourceInstanceStatus.left().value();
2447 StorageOperationStatus lockStatus = graphLockOperation.lockComponent(componentId, componentTypeEnum.getNodeType());
2448 if (lockStatus != StorageOperationStatus.OK) {
2449 log.debug(FAILED_TO_LOCK_SERVICE, componentId);
2450 return Either.right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(lockStatus)));
2452 List<ComponentInstanceInput> updatedInputs = new ArrayList<>();
2454 for (ComponentInstanceInput input : inputs) {
2455 validateMandatoryFields(input);
2456 ComponentInstanceInput componentInstanceInput = validateInputExistsOnComponent(input, containerComponent, foundResourceInstance);
2457 Either<String, ResponseFormat> validatedInputValue = validatePropertyObjectValue(componentInstanceInput, input.getValue(), true);
2458 if (validatedInputValue.isRight()) {
2459 throw new ByActionStatusComponentException(ActionStatus.INVALID_CONTENT, input.getName());
2461 updateInputOnContainerComponent(componentInstanceInput, validatedInputValue.left().value(), containerComponent,
2462 foundResourceInstance);
2463 updatedInputs.add(componentInstanceInput);
2465 Either<Component, StorageOperationStatus> updateContainerRes = toscaOperationFacade
2466 .updateComponentInstanceMetadataOfTopologyTemplate(containerComponent);
2467 if (updateContainerRes.isRight()) {
2468 ActionStatus actionStatus = componentsUtils.convertFromStorageResponseForResourceInstanceProperty(updateContainerRes.right().value());
2469 resultOp = Either.right(componentsUtils.getResponseFormatForResourceInstanceProperty(actionStatus, ""));
2472 resultOp = Either.left(updatedInputs);
2476 if (resultOp == null || resultOp.isRight()) {
2477 janusGraphDao.rollback();
2479 janusGraphDao.commit();
2482 graphLockOperation.unlockComponent(componentId, componentTypeEnum.getNodeType());
2487 private ComponentInstanceInput validateInputExistsOnComponent(ComponentInstanceInput input, Component containerComponent,
2488 ComponentInstance foundResourceInstance) {
2489 List<ComponentInstanceInput> instanceProperties = containerComponent.getComponentInstancesInputs().get(foundResourceInstance.getUniqueId());
2490 Optional<ComponentInstanceInput> instanceInput = instanceProperties.stream().filter(p -> p.getName().equals(input.getName())).findAny();
2491 if (!instanceInput.isPresent()) {
2492 throw new ByActionStatusComponentException(ActionStatus.PROPERTY_NOT_FOUND, input.getName());
2494 return instanceInput.get();
2497 public Either<ComponentInstanceProperty, ResponseFormat> createOrUpdateGroupInstancePropertyValue(ComponentTypeEnum componentTypeEnum,
2498 String componentId, String resourceInstanceId,
2499 String groupInstanceId,
2500 ComponentInstanceProperty property,
2503 Either<ComponentInstanceProperty, ResponseFormat> resultOp = null;
2505 validateUserExists(userId);
2507 if (componentTypeEnum == null) {
2508 BeEcompErrorManager.getInstance().logInvalidInputError(CREATE_OR_UPDATE_PROPERTY_VALUE, INVALID_COMPONENT_TYPE, ErrorSeverity.INFO);
2509 resultOp = Either.right(componentsUtils.getResponseFormat(ActionStatus.NOT_ALLOWED));
2513 if (!ComponentValidationUtils.canWorkOnComponent(componentId, toscaOperationFacade, userId)) {
2514 log.info("Restricted operation for user: {} on service: {}", userId, componentId);
2515 resultOp = Either.right(componentsUtils.getResponseFormat(ActionStatus.RESTRICTED_OPERATION));
2519 StorageOperationStatus lockStatus = graphLockOperation.lockComponent(componentId, componentTypeEnum.getNodeType());
2520 if (lockStatus != StorageOperationStatus.OK) {
2521 log.debug(FAILED_TO_LOCK_SERVICE, componentId);
2522 resultOp = Either.right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(lockStatus)));
2526 String propertyValueUid = property.getValueUniqueUid();
2528 if (propertyValueUid == null) {
2530 Either<Integer, StorageOperationStatus> counterRes = groupInstanceOperation
2531 .increaseAndGetGroupInstancePropertyCounter(groupInstanceId);
2533 if (counterRes.isRight()) {
2534 log.debug("increaseAndGetResourcePropertyCounter failed resource instance: {} property: {}", resourceInstanceId, property);
2535 StorageOperationStatus status = counterRes.right().value();
2536 ActionStatus actionStatus = componentsUtils.convertFromStorageResponseForResourceInstanceProperty(status);
2537 resultOp = Either.right(componentsUtils.getResponseFormat(actionStatus));
2539 Integer index = counterRes.left().value();
2540 Either<ComponentInstanceProperty, StorageOperationStatus> result = groupInstanceOperation
2541 .addPropertyValueToGroupInstance(property, resourceInstanceId, index, true);
2543 if (result.isLeft()) {
2544 log.trace("Property value was added to resource instance {}", resourceInstanceId);
2545 ComponentInstanceProperty instanceProperty = result.left().value();
2547 resultOp = Either.left(instanceProperty);
2550 log.debug("Failed to add property value: {} to resource instance {}", property, resourceInstanceId);
2552 ActionStatus actionStatus = componentsUtils.convertFromStorageResponseForResourceInstanceProperty(result.right().value());
2554 resultOp = Either.right(componentsUtils.getResponseFormatForResourceInstanceProperty(actionStatus, ""));
2558 Either<ComponentInstanceProperty, StorageOperationStatus> result = groupInstanceOperation
2559 .updatePropertyValueInGroupInstance(property, resourceInstanceId, true);
2561 if (result.isLeft()) {
2562 log.debug("Property value {} was updated on graph.", property.getValueUniqueUid());
2563 ComponentInstanceProperty instanceProperty = result.left().value();
2565 resultOp = Either.left(instanceProperty);
2568 log.debug("Failed to update property value: {}, in resource instance {}", property, resourceInstanceId);
2570 ActionStatus actionStatus = componentsUtils.convertFromStorageResponseForResourceInstanceProperty(result.right().value());
2572 resultOp = Either.right(componentsUtils.getResponseFormatForResourceInstanceProperty(actionStatus, ""));
2575 if (resultOp.isLeft()) {
2576 StorageOperationStatus updateCustomizationUUID = componentInstanceOperation.updateCustomizationUUID(resourceInstanceId);
2577 if (updateCustomizationUUID != StorageOperationStatus.OK) {
2578 ActionStatus actionStatus = componentsUtils.convertFromStorageResponseForResourceInstanceProperty(updateCustomizationUUID);
2580 resultOp = Either.right(componentsUtils.getResponseFormatForResourceInstanceProperty(actionStatus, ""));
2587 if (resultOp == null || resultOp.isRight()) {
2588 janusGraphDao.rollback();
2590 janusGraphDao.commit();
2593 graphLockOperation.unlockComponent(componentId, componentTypeEnum.getNodeType());
2598 public Either<ComponentInstanceProperty, ResponseFormat> deletePropertyValue(ComponentTypeEnum componentTypeEnum, String serviceId,
2599 String resourceInstanceId, String propertyValueId, String userId) {
2601 validateUserExists(userId);
2603 Either<ComponentInstanceProperty, ResponseFormat> resultOp = null;
2605 if (componentTypeEnum == null) {
2606 BeEcompErrorManager.getInstance().logInvalidInputError(CREATE_OR_UPDATE_PROPERTY_VALUE, INVALID_COMPONENT_TYPE, ErrorSeverity.INFO);
2607 resultOp = Either.right(componentsUtils.getResponseFormat(ActionStatus.NOT_ALLOWED));
2611 if (!ComponentValidationUtils.canWorkOnComponent(serviceId, toscaOperationFacade, userId)) {
2612 log.info("Restricted operation for user {} on service {}", userId, serviceId);
2613 resultOp = Either.right(componentsUtils.getResponseFormat(ActionStatus.RESTRICTED_OPERATION));
2617 StorageOperationStatus lockStatus = graphLockOperation.lockComponent(serviceId, componentTypeEnum.getNodeType());
2618 if (lockStatus != StorageOperationStatus.OK) {
2619 log.debug(FAILED_TO_LOCK_SERVICE, serviceId);
2620 resultOp = Either.right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(lockStatus)));
2624 Either<ComponentInstanceProperty, StorageOperationStatus> result = propertyOperation
2625 .removePropertyValueFromResourceInstance(propertyValueId, resourceInstanceId, true);
2627 if (result.isLeft()) {
2628 log.debug("Property value {} was removed from graph.", propertyValueId);
2629 ComponentInstanceProperty instanceProperty = result.left().value();
2631 resultOp = Either.left(instanceProperty);
2635 log.debug("Failed to remove property value {} in resource instance {}", propertyValueId, resourceInstanceId);
2637 ActionStatus actionStatus = componentsUtils.convertFromStorageResponseForResourceInstanceProperty(result.right().value());
2639 resultOp = Either.right(componentsUtils.getResponseFormatForResourceInstanceProperty(actionStatus, ""));
2645 if (resultOp == null || resultOp.isRight()) {
2646 janusGraphDao.rollback();
2648 janusGraphDao.commit();
2651 graphLockOperation.unlockComponent(serviceId, componentTypeEnum.getNodeType());
2656 private Component getAndValidateOriginComponentOfComponentInstance(Component containerComponent, ComponentInstance componentInstance) {
2658 ComponentTypeEnum componentType = getComponentTypeByParentComponentType(containerComponent.getComponentType());
2659 Component component;
2660 Either<Component, StorageOperationStatus> getComponentRes = toscaOperationFacade.getToscaFullElement(componentInstance.getComponentUid());
2661 if (getComponentRes.isRight()) {
2662 log.debug("Failed to get the component with id {} for component instance {} creation. ", componentInstance.getComponentUid(),
2663 componentInstance.getName());
2664 ActionStatus actionStatus = componentsUtils.convertFromStorageResponse(getComponentRes.right().value(), componentType);
2665 throw new ByActionStatusComponentException(actionStatus, Constants.EMPTY_STRING);
2667 component = getComponentRes.left().value();
2668 LifecycleStateEnum resourceCurrState = component.getLifecycleState();
2669 if (resourceCurrState == LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT) {
2670 ActionStatus actionStatus = ActionStatus.CONTAINER_CANNOT_CONTAIN_COMPONENT_IN_STATE;
2671 throw new ByActionStatusComponentException(actionStatus, containerComponent.getComponentType().toString(), resourceCurrState.toString());
2673 if (Boolean.TRUE.equals(component.isArchived())) {
2674 ActionStatus actionStatus = ActionStatus.COMPONENT_IS_ARCHIVED;
2675 throw new ByActionStatusComponentException(actionStatus, component.getName());
2677 final Map<String, InterfaceDefinition> componentInterfaces = component.getInterfaces();
2678 if (MapUtils.isNotEmpty(componentInterfaces)) {
2679 componentInterfaces.forEach(componentInstance::addInterface);
2684 public Either<Set<String>, ResponseFormat> forwardingPathOnVersionChange(String containerComponentParam,
2685 String containerComponentId,
2686 String componentInstanceId,
2687 ComponentInstance newComponentInstance) {
2688 Either<Set<String>, ResponseFormat> resultOp;
2689 final ComponentTypeEnum containerComponentType = validateComponentType(containerComponentParam);
2690 ComponentParametersView componentParametersView = getComponentParametersViewForForwardingPath();
2693 Component containerComponent = validateComponentExists(containerComponentId, containerComponentType, componentParametersView);
2695 //Fetch current component instance
2696 Either<ComponentInstance, StorageOperationStatus> eitherResourceInstance =
2697 getResourceInstanceById(containerComponent, componentInstanceId);
2698 if (eitherResourceInstance.isRight()) {
2699 resultOp = Either.right(componentsUtils.getResponseFormat(
2700 ActionStatus.RESOURCE_INSTANCE_NOT_FOUND_ON_SERVICE, componentInstanceId, containerComponentId));
2703 ComponentInstance currentResourceInstance = eitherResourceInstance.left().value();
2705 //Check whether new componentInstance exists
2706 String resourceId = newComponentInstance.getComponentUid();
2707 Either<Boolean, StorageOperationStatus> componentExistsRes = toscaOperationFacade.validateComponentExists(resourceId);
2708 if (componentExistsRes.isRight()) {
2709 log.debug("Failed to find resource {}", resourceId);
2710 resultOp = Either.right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse
2711 (componentExistsRes.right().value()), resourceId));
2713 } else if (!Boolean.TRUE.equals(componentExistsRes.left().value())) {
2714 log.debug("The resource {} not found ", resourceId);
2715 resultOp = Either.right(componentsUtils.getResponseFormat(ActionStatus.RESOURCE_NOT_FOUND, resourceId));
2719 //Fetch component using new component instance uid
2720 Component updatedContainerComponent = getOriginComponentFromComponentInstance(newComponentInstance);
2721 Set<String> toDeleteForwardingPaths = getForwardingPaths(containerComponent,
2722 currentResourceInstance, updatedContainerComponent);
2723 resultOp = Either.left(toDeleteForwardingPaths);
2728 private Set<String> getForwardingPaths(Component containerComponent, ComponentInstance currentResourceInstance,
2729 Component updatedContainerComponent) {
2730 DataForMergeHolder dataForMergeHolder = new DataForMergeHolder();
2731 dataForMergeHolder.setOrigComponentInstId(currentResourceInstance.getName());
2733 Service service = (Service) containerComponent;
2734 ForwardingPathUtils forwardingPathUtils = new ForwardingPathUtils();
2736 return forwardingPathUtils.
2737 getForwardingPathsToBeDeletedOnVersionChange(service, dataForMergeHolder, updatedContainerComponent);
2740 private ComponentParametersView getComponentParametersViewForForwardingPath() {
2741 ComponentParametersView componentParametersView = new ComponentParametersView();
2742 componentParametersView.setIgnoreCapabiltyProperties(false);
2743 componentParametersView.setIgnoreServicePath(false);
2744 return componentParametersView;
2747 public ComponentInstance changeComponentInstanceVersion(String containerComponentParam, String containerComponentId, String componentInstanceId,
2748 String userId, ComponentInstance newComponentInstance) {
2750 User user = validateUserExists(userId);
2751 final ComponentTypeEnum containerComponentType = validateComponentType(containerComponentParam);
2752 ComponentParametersView componentParametersView = new ComponentParametersView();
2753 componentParametersView.setIgnoreCapabiltyProperties(false);
2755 org.openecomp.sdc.be.model.Component containerComponent = validateComponentExists(containerComponentId, containerComponentType,
2756 componentParametersView);
2758 validateCanWorkOnComponent(containerComponent, userId);
2760 Either<ComponentInstance, StorageOperationStatus> resourceInstanceStatus = getResourceInstanceById(containerComponent, componentInstanceId);
2761 if (resourceInstanceStatus.isRight()) {
2762 throw new ByActionStatusComponentException(ActionStatus.RESOURCE_INSTANCE_NOT_FOUND_ON_SERVICE, componentInstanceId,
2763 containerComponentId);
2766 ComponentInstance currentResourceInstance = resourceInstanceStatus.left().value();
2768 return changeInstanceVersion(containerComponent, currentResourceInstance, newComponentInstance, user, containerComponentType);
2771 public ComponentInstance changeInstanceVersion(org.openecomp.sdc.be.model.Component containerComponent,
2772 ComponentInstance currentResourceInstance,
2773 ComponentInstance newComponentInstance,
2775 final ComponentTypeEnum containerComponentType) {
2776 boolean failed = false;
2777 Either<ComponentInstance, StorageOperationStatus> resourceInstanceStatus;
2780 lockComponent(containerComponent, "changeComponentInstanceVersion");
2781 String containerComponentId = containerComponent.getUniqueId();
2782 String componentInstanceId = currentResourceInstance.getUniqueId();
2783 if (currentResourceInstance.getComponentUid().equals(newComponentInstance.getComponentUid())) {
2784 return currentResourceInstance;
2786 String resourceId = newComponentInstance.getComponentUid();
2788 Either<Boolean, StorageOperationStatus> componentExistsRes = toscaOperationFacade
2789 .validateComponentExists(resourceId);
2790 if (componentExistsRes.isRight()) {
2791 StorageOperationStatus errorStatus = componentExistsRes.right().value();
2793 log.debug("Failed to validate existing of the component {}. Status is {} ", resourceId, errorStatus);
2794 throw new ByActionStatusComponentException(
2795 componentsUtils.convertFromStorageResponse(errorStatus), resourceId);
2796 } else if (!Boolean.TRUE.equals(componentExistsRes.left().value())) {
2797 log.debug("The resource {} not found ", resourceId);
2798 throw new ByActionStatusComponentException(ActionStatus.RESOURCE_NOT_FOUND, resourceId);
2801 Component eitherOriginComponent = getInstanceOriginNode(currentResourceInstance);
2802 DataForMergeHolder dataHolder = compInstMergeDataBL
2803 .saveAllDataBeforeDeleting(containerComponent, currentResourceInstance, eitherOriginComponent);
2804 ComponentInstance resResourceInfo = deleteComponentInstance(containerComponent, componentInstanceId,
2805 containerComponentType);
2807 if (resResourceInfo == null) {
2808 log.error("Calling `deleteComponentInstance` for the resource {} returned a null", resourceId);
2809 throw new ByActionStatusComponentException(ActionStatus.RESOURCE_NOT_FOUND, resourceId);
2811 Component origComponent = null;
2812 OriginTypeEnum originType = currentResourceInstance.getOriginType();
2813 newComponentInstance.setOriginType(originType);
2814 if (originType == OriginTypeEnum.ServiceProxy) {
2815 Either<Component, StorageOperationStatus> serviceProxyOrigin = toscaOperationFacade
2816 .getLatestByName(SERVICE_PROXY, null);
2817 if (isServiceProxyOrigin(serviceProxyOrigin)) {
2818 throw new ByActionStatusComponentException(
2819 componentsUtils.convertFromStorageResponse(serviceProxyOrigin.right().value()));
2821 origComponent = serviceProxyOrigin.left().value();
2823 StorageOperationStatus fillProxyRes = fillInstanceData(newComponentInstance, origComponent);
2825 if (isFillProxyRes(fillProxyRes)) {
2826 throw new ByActionStatusComponentException(
2827 componentsUtils.convertFromStorageResponse(fillProxyRes));
2829 } else if (originType == OriginTypeEnum.ServiceSubstitution) {
2830 final Either<Component, StorageOperationStatus> getServiceResult = toscaOperationFacade
2831 .getToscaFullElement(newComponentInstance.getComponentUid());
2832 if (getServiceResult.isRight()) {
2833 throw new ByActionStatusComponentException(componentsUtils.convertFromStorageResponse(getServiceResult.right().value()));
2835 final Component service = getServiceResult.left().value();
2837 final Either<Component, StorageOperationStatus> getServiceDerivedFromTypeResult = toscaOperationFacade
2838 .getLatestByToscaResourceName(service.getDerivedFromGenericType(), service.getModel());
2839 if (getServiceDerivedFromTypeResult.isRight()) {
2840 throw new ByActionStatusComponentException(componentsUtils.convertFromStorageResponse(getServiceResult.right().value()));
2843 origComponent = getServiceDerivedFromTypeResult.left().value();
2845 final StorageOperationStatus fillProxyRes = fillInstanceData(newComponentInstance, origComponent);
2846 if (isFillProxyRes(fillProxyRes)) {
2847 throw new ByActionStatusComponentException(
2848 componentsUtils.convertFromStorageResponse(fillProxyRes));
2851 origComponent = getOriginComponentFromComponentInstance(newComponentInstance);
2852 newComponentInstance.setName(resResourceInfo.getName());
2855 newComponentInstance.setInvariantName(resResourceInfo.getInvariantName());
2856 newComponentInstance.setPosX(resResourceInfo.getPosX());
2857 newComponentInstance.setPosY(resResourceInfo.getPosY());
2858 newComponentInstance.setDescription(resResourceInfo.getDescription());
2860 ComponentInstance updatedComponentInstance =
2861 createComponentInstanceOnGraph(containerComponent, origComponent, newComponentInstance, user);
2862 dataHolder.setCurrInstanceNode(origComponent);
2864 .mergeComponentUserOrigData(user, dataHolder, containerComponent, containerComponentId, newComponentInstance.getUniqueId());
2866 ActionStatus postChangeVersionResult = onChangeInstanceOperationOrchestrator
2867 .doPostChangeVersionOperations(containerComponent, currentResourceInstance, newComponentInstance);
2868 if (postChangeVersionResult != ActionStatus.OK) {
2869 throw new ByActionStatusComponentException(postChangeVersionResult);
2872 ComponentParametersView filter = new ComponentParametersView(true);
2873 filter.setIgnoreComponentInstances(false);
2874 Either<Component, StorageOperationStatus> updatedComponentRes = toscaOperationFacade.getToscaElement(containerComponentId, filter);
2875 if (updatedComponentRes.isRight()) {
2876 StorageOperationStatus storageOperationStatus = updatedComponentRes.right().value();
2877 ActionStatus actionStatus = componentsUtils
2878 .convertFromStorageResponse(storageOperationStatus, containerComponent.getComponentType());
2879 log.debug("Component with id {} was not found", containerComponentId);
2880 throw new ByActionStatusComponentException(actionStatus, Constants.EMPTY_STRING);
2882 resourceInstanceStatus = getResourceInstanceById(updatedComponentRes.left().value(),
2883 updatedComponentInstance.getUniqueId());
2884 if (resourceInstanceStatus.isRight()) {
2885 throw new ByActionStatusComponentException(componentsUtils.convertFromStorageResponse
2886 (resourceInstanceStatus.right().value()), updatedComponentInstance.getUniqueId());
2888 return resourceInstanceStatus.left().value();
2890 } catch (ComponentException e) {
2894 unlockComponent(failed, containerComponent);
2898 private boolean isFillProxyRes(StorageOperationStatus fillProxyRes) {
2899 if (fillProxyRes != StorageOperationStatus.OK) {
2900 log.debug("Failed to fill service proxy resource data with data from service, error {}", fillProxyRes);
2907 public List<ComponentInstanceProperty> getComponentInstancePropertiesById(String containerComponentTypeParam, String containerComponentId,
2908 String componentInstanceUniqueId, String userId) {
2909 Component containerComponent = null;
2911 boolean failed = false;
2913 validateUserExists(userId);
2914 validateComponentType(containerComponentTypeParam);
2916 Either<Component, StorageOperationStatus> validateContainerComponentExists = toscaOperationFacade.getToscaElement(containerComponentId);
2917 if (validateContainerComponentExists.isRight()) {
2918 throw new ByActionStatusComponentException(
2919 componentsUtils.convertFromStorageResponse(validateContainerComponentExists.right().value()));
2921 containerComponent = validateContainerComponentExists.left().value();
2923 Either<ComponentInstance, StorageOperationStatus> resourceInstanceStatus = getResourceInstanceById(containerComponent,
2924 componentInstanceUniqueId);
2925 if (resourceInstanceStatus.isRight()) {
2926 throw new ByActionStatusComponentException(ActionStatus.RESOURCE_INSTANCE_NOT_FOUND_ON_SERVICE, componentInstanceUniqueId,
2927 containerComponentId);
2930 List<ComponentInstanceProperty> instanceProperties = containerComponent.getComponentInstancesProperties().get(componentInstanceUniqueId);
2931 if (CollectionUtils.isEmpty(instanceProperties)) {
2932 instanceProperties = new ArrayList<>();
2934 return instanceProperties;
2935 } catch (ComponentException e) {
2939 unlockComponent(failed, containerComponent);
2943 public List<ComponentInstanceAttribute> getComponentInstanceAttributesById(final String containerComponentTypeParam,
2944 final String containerComponentId,
2945 final String componentInstanceUniqueId,
2946 final String userId) {
2947 Component containerComponent = null;
2949 boolean failed = false;
2951 validateUserExists(userId);
2952 validateComponentType(containerComponentTypeParam);
2954 final Either<Component, StorageOperationStatus> validateContainerComponentExists =
2955 toscaOperationFacade.getToscaElement(containerComponentId);
2956 if (validateContainerComponentExists.isRight()) {
2957 throw new ByActionStatusComponentException(
2958 componentsUtils.convertFromStorageResponse(validateContainerComponentExists.right().value()));
2960 containerComponent = validateContainerComponentExists.left().value();
2962 if (getResourceInstanceById(containerComponent, componentInstanceUniqueId).isRight()) {
2963 throw new ByActionStatusComponentException(
2964 ActionStatus.RESOURCE_INSTANCE_NOT_FOUND_ON_SERVICE, componentInstanceUniqueId, containerComponentId);
2967 final Map<String, List<ComponentInstanceAttribute>> componentInstancesAttributes = containerComponent.getComponentInstancesAttributes();
2968 return componentInstancesAttributes == null ? new ArrayList<>()
2969 : componentInstancesAttributes.getOrDefault(componentInstanceUniqueId, new ArrayList<>());
2970 } catch (final ComponentException e) {
2974 unlockComponent(failed, containerComponent);
2978 protected void validateIncrementCounter(String resourceInstanceId, GraphPropertiesDictionary counterType,
2979 Wrapper<Integer> instaceCounterWrapper,
2980 Wrapper<ResponseFormat> errorWrapper) {
2981 Either<Integer, StorageOperationStatus> counterRes = componentInstanceOperation
2982 .increaseAndGetResourceInstanceSpecificCounter(resourceInstanceId, counterType, true);
2984 if (counterRes.isRight()) {
2985 log.debug("increase And Get {} failed resource instance {}", counterType, resourceInstanceId);
2986 StorageOperationStatus status = counterRes.right().value();
2987 ActionStatus actionStatus = componentsUtils.convertFromStorageResponseForResourceInstanceProperty(status);
2988 errorWrapper.setInnerElement(componentsUtils.getResponseFormat(actionStatus));
2990 instaceCounterWrapper.setInnerElement(counterRes.left().value());
2996 * updates componentInstance modificationTime
2998 * @param componentInstance
2999 * @param componentInstanceType
3000 * @param modificationTime
3001 * @param inTransaction
3004 public Either<ComponentInstanceData, ResponseFormat> updateComponentInstanceModificationTimeAndCustomizationUuid(
3005 ComponentInstance componentInstance, NodeTypeEnum componentInstanceType, Long modificationTime, boolean inTransaction) {
3006 Either<ComponentInstanceData, ResponseFormat> result;
3007 Either<ComponentInstanceData, StorageOperationStatus> updateComponentInstanceRes = componentInstanceOperation
3008 .updateComponentInstanceModificationTimeAndCustomizationUuidOnGraph(componentInstance, componentInstanceType, modificationTime,
3010 if (updateComponentInstanceRes.isRight()) {
3011 log.debug("Failed to update component instance {} with new last update date and mofifier. Status is {}. ", componentInstance.getName(),
3012 updateComponentInstanceRes.right().value());
3014 .right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(updateComponentInstanceRes.right().value())));
3016 result = Either.left(updateComponentInstanceRes.left().value());
3021 public Either<ComponentInstance, ResponseFormat> deleteServiceProxy() {
3022 // TODO Add implementation
3023 return Either.left(new ComponentInstance());
3026 public Either<ComponentInstance, ResponseFormat> createServiceProxy() {
3027 // TODO Add implementation
3028 return Either.left(new ComponentInstance());
3031 public Either<ComponentInstance, ResponseFormat> changeServiceProxyVersion() {
3032 // TODO Add implementation
3033 return Either.left(new ComponentInstance());
3036 private Boolean validateInstanceNameUniquenessUponUpdate(Component containerComponent, ComponentInstance oldComponentInstance,
3037 String newInstanceName) {
3038 return ComponentValidations.validateNameIsUniqueInComponent(oldComponentInstance.getName(), newInstanceName, containerComponent);
3041 private Either<ComponentInstance, StorageOperationStatus> getResourceInstanceById(Component containerComponent, String instanceId) {
3042 Either<ComponentInstance, StorageOperationStatus> result = Either.right(StorageOperationStatus.NOT_FOUND);
3043 List<ComponentInstance> instances = containerComponent.getComponentInstances();
3044 Optional<ComponentInstance> foundInstance = Optional.empty();
3045 if (!CollectionUtils.isEmpty(instances)) {
3046 if (result.isRight()) {
3047 foundInstance = instances.stream().filter(i -> i.getUniqueId().equals(instanceId)).findFirst();
3048 if (!foundInstance.isPresent()) {
3049 result = Either.right(StorageOperationStatus.NOT_FOUND);
3052 if (result.isRight() && foundInstance.isPresent()) {
3053 result = Either.left(foundInstance.get());
3059 private ComponentInstance buildComponentInstance(ComponentInstance resourceInstanceForUpdate, ComponentInstance origInstanceForUpdate) {
3060 Long creationDate = origInstanceForUpdate.getCreationTime();
3061 Long modificationTime = System.currentTimeMillis();
3062 resourceInstanceForUpdate.setCreationTime(creationDate);
3063 resourceInstanceForUpdate.setModificationTime(modificationTime);
3064 resourceInstanceForUpdate.setCustomizationUUID(origInstanceForUpdate.getCustomizationUUID());
3065 if (StringUtils.isEmpty(resourceInstanceForUpdate.getName()) && StringUtils.isNotEmpty(origInstanceForUpdate.getName())) {
3066 resourceInstanceForUpdate.setName(origInstanceForUpdate.getName());
3068 resourceInstanceForUpdate.setNormalizedName(ValidationUtils.normalizeComponentInstanceName(resourceInstanceForUpdate.getName()));
3069 if (StringUtils.isEmpty(resourceInstanceForUpdate.getIcon())) {
3070 resourceInstanceForUpdate.setIcon(origInstanceForUpdate.getIcon());
3072 if (StringUtils.isEmpty(resourceInstanceForUpdate.getComponentVersion())) {
3073 resourceInstanceForUpdate.setComponentVersion(origInstanceForUpdate.getComponentVersion());
3075 if (StringUtils.isEmpty(resourceInstanceForUpdate.getComponentName())) {
3076 resourceInstanceForUpdate.setComponentName(origInstanceForUpdate.getComponentName());
3078 if (StringUtils.isEmpty(resourceInstanceForUpdate.getToscaComponentName())) {
3079 resourceInstanceForUpdate.setToscaComponentName(origInstanceForUpdate.getToscaComponentName());
3081 if (resourceInstanceForUpdate.getOriginType() == null) {
3082 resourceInstanceForUpdate.setOriginType(origInstanceForUpdate.getOriginType());
3084 if (resourceInstanceForUpdate.getOriginType() == OriginTypeEnum.ServiceProxy) {
3085 resourceInstanceForUpdate.setIsProxy(true);
3087 if (resourceInstanceForUpdate.getSourceModelInvariant() == null) {
3088 resourceInstanceForUpdate.setSourceModelInvariant(origInstanceForUpdate.getSourceModelInvariant());
3090 if (resourceInstanceForUpdate.getSourceModelName() == null) {
3091 resourceInstanceForUpdate.setSourceModelName(origInstanceForUpdate.getSourceModelName());
3093 if (resourceInstanceForUpdate.getSourceModelUuid() == null) {
3094 resourceInstanceForUpdate.setSourceModelUuid(origInstanceForUpdate.getSourceModelUuid());
3096 if (resourceInstanceForUpdate.getSourceModelUid() == null) {
3097 resourceInstanceForUpdate.setSourceModelUid(origInstanceForUpdate.getSourceModelUid());
3099 if (resourceInstanceForUpdate.getCreatedFrom() == null) {
3100 resourceInstanceForUpdate.setCreatedFrom(origInstanceForUpdate.getCreatedFrom());
3102 return resourceInstanceForUpdate;
3106 * Returns list of ComponentInstanceProperty belonging to component instance capability specified by name, type and ownerId
3108 * @param containerComponentType
3109 * @param containerComponentId
3110 * @param componentInstanceUniqueId
3111 * @param capabilityType
3112 * @param capabilityName
3117 public List<ComponentInstanceProperty> getComponentInstanceCapabilityPropertiesById(String containerComponentType, String containerComponentId,
3118 String componentInstanceUniqueId, String capabilityType,
3119 String capabilityName, String ownerId, String userId) {
3120 Component containerComponent = null;
3121 List<ComponentInstanceProperty> resultOp = null;
3123 validateUserExists(userId);
3124 validateComponentType(containerComponentType);
3125 containerComponent = toscaOperationFacade.getToscaFullElement(containerComponentId).left().on(this::componentException);
3126 ComponentInstance resourceInstanceStatus = getResourceInstanceById(containerComponent, componentInstanceUniqueId).left()
3127 .on(this::componentInstanceException);
3128 resultOp = findCapabilityOfInstance(containerComponentId, componentInstanceUniqueId, capabilityType, capabilityName, ownerId,
3129 resourceInstanceStatus.getCapabilities());
3130 } catch (StorageException | ComponentException e) {
3131 unlockRollbackWithException(containerComponent, e);
3132 } catch (Exception e) {
3133 unlockRollbackWithException(containerComponent, new ByActionStatusComponentException(ActionStatus.GENERAL_ERROR));
3135 unlockWithCommit(containerComponent);
3139 private List<ComponentInstanceProperty> findCapabilityOfInstance(String componentId, String instanceId, String capabilityType,
3140 String capabilityName, String ownerId,
3141 Map<String, List<CapabilityDefinition>> instanceCapabilities) {
3142 CapabilityDefinition foundCapability;
3143 if (MapUtils.isNotEmpty(instanceCapabilities)) {
3144 List<CapabilityDefinition> capabilitiesPerType = instanceCapabilities.get(capabilityType);
3145 if (capabilitiesPerType != null) {
3146 Optional<CapabilityDefinition> capabilityOpt = capabilitiesPerType.stream()
3147 .filter(c -> c.getName().equals(capabilityName) && c.getOwnerId().equals(ownerId)).findFirst();
3148 if (capabilityOpt.isPresent()) {
3149 foundCapability = capabilityOpt.get();
3150 return foundCapability.getProperties() == null ? new ArrayList<>() : foundCapability.getProperties();
3154 return fetchComponentInstanceCapabilityProperties(componentId, instanceId, capabilityType, capabilityName, ownerId);
3157 private List<ComponentInstanceProperty> fetchComponentInstanceCapabilityProperties(String componentId, String instanceId, String capabilityType,
3158 String capabilityName, String ownerId) {
3160 return toscaOperationFacade.getComponentInstanceCapabilityProperties(componentId, instanceId, capabilityName, capabilityType, ownerId)
3161 .left().on(this::componentInstancePropertyListException);
3162 } catch (Exception e) {
3163 log.debug("The exception {} occurred upon the component {} instance {} capability {} properties retrieving. ", componentId, instanceId,
3165 throw new ByActionStatusComponentException(ActionStatus.GENERAL_ERROR);
3169 public Either<RequirementDefinition, ResponseFormat> updateInstanceRequirement(ComponentTypeEnum componentTypeEnum, String containerComponentId,
3170 String componentInstanceUniqueId,
3171 RequirementDefinition requirementDef, String userId) {
3172 Either<RequirementDefinition, ResponseFormat> resultOp = null;
3173 validateUserExists(userId);
3174 if (componentTypeEnum == null) {
3175 BeEcompErrorManager.getInstance().logInvalidInputError("updateInstanceRequirement", INVALID_COMPONENT_TYPE, ErrorSeverity.INFO);
3176 return Either.right(componentsUtils.getResponseFormat(ActionStatus.NOT_ALLOWED));
3178 Either<Component, StorageOperationStatus> getResourceResult = toscaOperationFacade.getToscaFullElement(containerComponentId);
3179 if (getResourceResult.isRight()) {
3180 log.debug(FAILED_TO_RETRIEVE_COMPONENT_COMPONENT_ID, containerComponentId);
3181 return Either.right(componentsUtils.getResponseFormat(ActionStatus.RESTRICTED_OPERATION));
3183 Component containerComponent = getResourceResult.left().value();
3184 if (!ComponentValidationUtils.canWorkOnComponent(containerComponent, userId)) {
3185 log.info(RESTRICTED_OPERATION_ON_COMPONENT, userId, containerComponentId);
3186 return Either.right(componentsUtils.getResponseFormat(ActionStatus.RESTRICTED_OPERATION));
3188 Either<ComponentInstance, StorageOperationStatus> resourceInstanceStatus = getResourceInstanceById(containerComponent,
3189 componentInstanceUniqueId);
3190 if (resourceInstanceStatus.isRight()) {
3191 return Either.right(componentsUtils
3192 .getResponseFormat(ActionStatus.RESOURCE_INSTANCE_NOT_FOUND_ON_SERVICE, componentInstanceUniqueId, containerComponentId));
3195 StorageOperationStatus lockStatus = graphLockOperation.lockComponent(containerComponentId, componentTypeEnum.getNodeType());
3196 if (lockStatus != StorageOperationStatus.OK) {
3197 log.debug(FAILED_TO_LOCK_COMPONENT, containerComponentId);
3198 return Either.right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(lockStatus)));
3201 StorageOperationStatus updateRequirementStatus = toscaOperationFacade
3202 .updateComponentInstanceRequirement(containerComponentId, componentInstanceUniqueId, requirementDef);
3203 if (updateRequirementStatus != StorageOperationStatus.OK) {
3204 log.debug("Failed to update component instance requirement on instance {} in container {}", componentInstanceUniqueId,
3205 containerComponentId);
3206 return Either.right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(updateRequirementStatus)));
3208 Either<Component, StorageOperationStatus> updateContainerRes = toscaOperationFacade
3209 .updateComponentInstanceMetadataOfTopologyTemplate(containerComponent);
3210 if (updateContainerRes.isRight()) {
3211 ActionStatus actionStatus = componentsUtils.convertFromStorageResponseForResourceInstanceProperty(updateContainerRes.right().value());
3212 resultOp = Either.right(componentsUtils.getResponseFormatForResourceInstanceProperty(actionStatus, ""));
3215 resultOp = Either.left(requirementDef);
3218 if (resultOp == null || resultOp.isRight()) {
3219 janusGraphDao.rollback();
3221 janusGraphDao.commit();
3224 graphLockOperation.unlockComponent(containerComponentId, componentTypeEnum.getNodeType());
3228 public Either<CapabilityDefinition, ResponseFormat> updateInstanceCapability(final ComponentTypeEnum containerComponentType,
3229 final String containerComponentId,
3230 final String componentInstanceUniqueId,
3231 final CapabilityDefinition capabilityDefinition,
3232 final String userId) {
3233 if (containerComponentType == null) {
3234 BeEcompErrorManager.getInstance().logInvalidInputError("updateInstanceCapability", INVALID_COMPONENT_TYPE, ErrorSeverity.INFO);
3235 return Either.right(componentsUtils.getResponseFormat(ActionStatus.NOT_ALLOWED));
3237 validateUserExists(userId);
3238 final Either<Component, StorageOperationStatus> getResourceResult = toscaOperationFacade.getToscaFullElement(containerComponentId);
3239 if (getResourceResult.isRight()) {
3240 log.debug(FAILED_TO_RETRIEVE_COMPONENT_COMPONENT_ID, containerComponentId);
3241 return Either.right(componentsUtils.getResponseFormat(ActionStatus.COMPONENT_NOT_FOUND, containerComponentId));
3243 final Component containerComponent = getResourceResult.left().value();
3244 if (!ComponentValidationUtils.canWorkOnComponent(containerComponent, userId)) {
3245 log.info(RESTRICTED_OPERATION_ON_COMPONENT, userId, containerComponentId);
3246 return Either.right(componentsUtils.getResponseFormat(ActionStatus.RESTRICTED_OPERATION));
3248 final Either<ComponentInstance, StorageOperationStatus> resourceInstanceStatus =
3249 getResourceInstanceById(containerComponent, componentInstanceUniqueId);
3250 if (resourceInstanceStatus.isRight()) {
3251 return Either.right(componentsUtils
3252 .getResponseFormat(ActionStatus.RESOURCE_INSTANCE_NOT_FOUND_ON_SERVICE, componentInstanceUniqueId, containerComponentId));
3255 final StorageOperationStatus lockStatus = graphLockOperation.lockComponent(containerComponentId, containerComponentType.getNodeType());
3256 if (lockStatus != StorageOperationStatus.OK) {
3257 log.debug(FAILED_TO_LOCK_COMPONENT, containerComponentId);
3258 return Either.right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(lockStatus)));
3260 var success = false;
3262 final CapabilityDataDefinition updatedCapabilityDefinition = toscaOperationFacade
3263 .updateComponentInstanceCapability(containerComponentId, componentInstanceUniqueId, capabilityDefinition);
3264 final Either<Component, StorageOperationStatus> updateContainerEither = toscaOperationFacade
3265 .updateComponentInstanceMetadataOfTopologyTemplate(containerComponent);
3266 if (updateContainerEither.isRight()) {
3267 var actionStatus = componentsUtils.convertFromStorageResponse(updateContainerEither.right().value(), containerComponentType);
3268 return Either.right(componentsUtils.getResponseFormat(actionStatus));
3271 return Either.left(new CapabilityDefinition(updatedCapabilityDefinition));
3272 } catch (final BusinessException e) {
3273 log.error(EcompLoggerErrorCode.BUSINESS_PROCESS_ERROR, NodeTemplateOperation.class.getName(), (ErrorLogOptionalData) null,
3274 FAILED_TO_UPDATE_COMPONENT_INSTANCE_CAPABILITY, componentInstanceUniqueId, containerComponentId);
3276 } catch (final Exception e) {
3277 log.error(EcompLoggerErrorCode.BUSINESS_PROCESS_ERROR, NodeTemplateOperation.class.getName(), (ErrorLogOptionalData) null,
3278 FAILED_TO_UPDATE_COMPONENT_INSTANCE_CAPABILITY, componentInstanceUniqueId, containerComponentId);
3279 throw new ByResponseFormatComponentException(componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR));
3282 janusGraphDao.commit();
3284 janusGraphDao.rollback();
3287 graphLockOperation.unlockComponent(containerComponentId, containerComponentType.getNodeType());
3291 public Either<List<ComponentInstanceProperty>, ResponseFormat> updateInstanceCapabilityProperties(ComponentTypeEnum componentTypeEnum,
3292 String containerComponentId,
3293 String componentInstanceUniqueId,
3294 String capabilityType, String capabilityName,
3295 List<ComponentInstanceProperty> properties,
3297 Either<List<ComponentInstanceProperty>, ResponseFormat> resultOp = null;
3298 validateUserExists(userId);
3299 if (componentTypeEnum == null) {
3300 BeEcompErrorManager.getInstance().logInvalidInputError("updateInstanceCapabilityProperty", INVALID_COMPONENT_TYPE, ErrorSeverity.INFO);
3301 return Either.right(componentsUtils.getResponseFormat(ActionStatus.NOT_ALLOWED));
3303 Either<Component, StorageOperationStatus> getResourceResult = toscaOperationFacade.getToscaFullElement(containerComponentId);
3304 if (getResourceResult.isRight()) {
3305 log.debug(FAILED_TO_RETRIEVE_COMPONENT_COMPONENT_ID, containerComponentId);
3306 return Either.right(componentsUtils.getResponseFormat(ActionStatus.RESTRICTED_OPERATION));
3308 Component containerComponent = getResourceResult.left().value();
3309 if (!ComponentValidationUtils.canWorkOnComponent(containerComponent, userId)) {
3310 log.info(RESTRICTED_OPERATION_ON_COMPONENT, userId, containerComponentId);
3311 return Either.right(componentsUtils.getResponseFormat(ActionStatus.RESTRICTED_OPERATION));
3313 Either<ComponentInstance, StorageOperationStatus> resourceInstanceStatus = getResourceInstanceById(containerComponent,
3314 componentInstanceUniqueId);
3315 if (resourceInstanceStatus.isRight()) {
3316 return Either.right(componentsUtils
3317 .getResponseFormat(ActionStatus.RESOURCE_INSTANCE_NOT_FOUND_ON_SERVICE, componentInstanceUniqueId, containerComponentId));
3319 ComponentInstance foundResourceInstance = resourceInstanceStatus.left().value();
3321 StorageOperationStatus lockStatus = graphLockOperation.lockComponent(containerComponentId, componentTypeEnum.getNodeType());
3322 if (lockStatus != StorageOperationStatus.OK) {
3323 log.debug(FAILED_TO_LOCK_COMPONENT, containerComponentId);
3324 return Either.right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(lockStatus)));
3327 for (ComponentInstanceProperty property : properties) {
3328 Either<String, ResponseFormat> newPropertyValueEither = validatePropertyObjectValue(property, property.getValue(), false);
3329 newPropertyValueEither.bimap(
3330 updatedValue -> updateCapabilityPropertyOnContainerComponent(property, updatedValue, containerComponent, foundResourceInstance,
3331 capabilityType, capabilityName), Either::right);
3333 Either<Component, StorageOperationStatus> updateContainerRes = toscaOperationFacade
3334 .updateComponentInstanceMetadataOfTopologyTemplate(containerComponent);
3335 if (updateContainerRes.isRight()) {
3336 ActionStatus actionStatus = componentsUtils.convertFromStorageResponseForResourceInstanceProperty(updateContainerRes.right().value());
3337 resultOp = Either.right(componentsUtils.getResponseFormatForResourceInstanceProperty(actionStatus, ""));
3340 resultOp = Either.left(properties);
3343 if (resultOp == null || resultOp.isRight()) {
3344 janusGraphDao.rollback();
3346 janusGraphDao.commit();
3349 graphLockOperation.unlockComponent(containerComponentId, componentTypeEnum.getNodeType());
3353 public Either<Map<String, ComponentInstance>, ResponseFormat> copyComponentInstance(ComponentInstance inputComponentInstance,
3354 String containerComponentId, String componentInstanceId,
3356 Map<String, ComponentInstance> resultMap = new HashMap<>();
3357 Either<Component, StorageOperationStatus> getOrigComponent = toscaOperationFacade.getToscaElement(containerComponentId);
3358 if (getOrigComponent.isRight()) {
3359 log.error("Failed to get the original component information");
3360 return Either.right(componentsUtils.getResponseFormat(ActionStatus.USER_DEFINED, FAILED_TO_COPY_COMP_INSTANCE_TO_CANVAS));
3362 Component origComponent = getOrigComponent.left().value();
3364 lockComponent(origComponent, "copyComponentInstance");
3365 } catch (ComponentException e) {
3366 log.error("destComponentInstance's data is {}", origComponent.toString());
3367 return Either.right(componentsUtils
3368 .getResponseFormat(ActionStatus.USER_DEFINED, "Failed to lock component destComponentInstance's data is {}",
3369 origComponent.toString()));
3371 boolean failed = false;
3372 ComponentInstance actionResponse = null;
3374 actionResponse = createComponentInstance("services", containerComponentId, userId, inputComponentInstance, false);
3375 } catch (ComponentException e) {
3377 // on failure of the create instance unlock the resource and rollback the transaction.
3378 return Either.right(componentsUtils.getResponseFormat(ActionStatus.USER_DEFINED, FAILED_TO_COPY_COMP_INSTANCE_TO_CANVAS));
3380 // on failure of the create instance unlock the resource and rollback the transaction.
3381 if (null == actionResponse) {
3382 log.error(FAILED_TO_COPY_COMP_INSTANCE_TO_CANVAS);
3383 unlockComponent(failed, origComponent);
3386 Either<String, ResponseFormat> resultOp = null;
3388 ComponentInstance destComponentInstance = actionResponse;
3389 log.debug("destComponentInstance's data is {}", destComponentInstance);
3390 resultOp = deepCopyComponentInstance(origComponent, containerComponentId, componentInstanceId, destComponentInstance, userId);
3391 resultMap.put("componentInstance", destComponentInstance);
3394 if (resultOp == null || resultOp.isRight()) {
3395 unlockComponent(true, origComponent);
3396 janusGraphDao.rollback();
3397 log.error("Failed to deep copy component instance");
3399 unlockComponent(false, origComponent);
3400 janusGraphDao.commit();
3401 log.debug("Success trasaction commit");
3404 if (resultOp == null || resultOp.isRight()) {
3406 .right(componentsUtils.getResponseFormat(ActionStatus.USER_DEFINED, "Failed to deep copy the component instance to the canvas"));
3408 return Either.left(resultMap);
3412 private Either<String, ResponseFormat> deepCopyComponentInstance(Component sourceComponent, String containerComponentId,
3413 String sourceComponentInstanceId, ComponentInstance destComponentInstance,
3415 Either<Component, StorageOperationStatus> getDestComponent = toscaOperationFacade.getToscaElement(containerComponentId);
3416 if (getDestComponent.isRight()) {
3417 log.error("Failed to get the dest component information");
3418 return Either.right(componentsUtils.getResponseFormat(ActionStatus.USER_DEFINED, FAILED_TO_COPY_COMP_INSTANCE_TO_CANVAS));
3420 Component destComponent = getDestComponent.left().value();
3421 Either<String, ResponseFormat> copyComponentInstanceWithPropertiesAndInputs = copyComponentInstanceWithPropertiesAndInputs(sourceComponent,
3422 destComponent, sourceComponentInstanceId, destComponentInstance);
3423 if (copyComponentInstanceWithPropertiesAndInputs.isRight()) {
3424 log.error("Failed to copy component instance with properties and inputs as part of deep copy");
3425 return Either.right(componentsUtils.getResponseFormat(ActionStatus.USER_DEFINED,
3426 "Failed to copy the component instance with properties and inputs as part of deep copy"));
3428 Either<String, ResponseFormat> copyComponentInstanceWithAttributes = copyComponentInstanceWithAttributes(sourceComponent, destComponent,
3429 sourceComponentInstanceId, destComponentInstance, userId);
3430 if (copyComponentInstanceWithAttributes.isRight()) {
3431 log.error("Failed to copy component instance with attributes as part of deep copy");
3432 return Either.right(componentsUtils
3433 .getResponseFormat(ActionStatus.USER_DEFINED, "Failed to copy the component instance with attributes as part of deep copy"));
3435 return Either.left(COPY_COMPONENT_INSTANCE_OK);
3438 private Either<String, ResponseFormat> copyComponentInstanceWithPropertiesAndInputs(Component sourceComponent, Component destComponent,
3439 String sourceComponentInstanceId,
3440 ComponentInstance destComponentInstance) {
3441 log.debug("start to copy ComponentInstance with properties and inputs");
3442 List<ComponentInstanceProperty> sourcePropList = null;
3443 if (sourceComponent.getComponentInstancesProperties() != null
3444 && sourceComponent.getComponentInstancesProperties().get(sourceComponentInstanceId) != null) {
3445 sourcePropList = sourceComponent.getComponentInstancesProperties().get(sourceComponentInstanceId);
3446 log.debug("sourcePropList");
3448 List<ComponentInstanceProperty> destPropList = null;
3449 String destComponentInstanceId = destComponentInstance.getUniqueId();
3450 log.debug("destComponentInstanceId: {}", destComponentInstance.getUniqueId());
3451 if (destComponent.getComponentInstancesProperties() != null
3452 && destComponent.getComponentInstancesProperties().get(destComponentInstanceId) != null) {
3453 destPropList = destComponent.getComponentInstancesProperties().get(destComponentInstanceId);
3454 log.debug("destPropList {}");
3456 List<ComponentInstancePropInput> componentInstancePropInputList = new ArrayList<>();
3457 if (null != destPropList && null != sourcePropList) {
3458 log.debug("start to set property and attribute");
3459 for (ComponentInstanceProperty destProp : destPropList) {
3460 String destPropertyName = destProp.getName();
3461 for (ComponentInstanceProperty sourceProp : sourcePropList) {
3462 if (!destPropertyName.equals(sourceProp.getName())) {
3465 log.debug("now set property");
3466 final List<GetInputValueDataDefinition> getInputValues = sourceProp.getGetInputValues();
3467 if (getInputValues == null && !StringUtils.isEmpty(sourceProp.getValue()) && (destProp.getValue() == null || !destProp.getValue()
3468 .equals(sourceProp.getValue()))) {
3469 log.debug("Now starting to copy the property {} in value {}", destPropertyName, sourceProp.getValue());
3470 destProp.setValue(sourceProp.getValue());
3471 Either<String, ResponseFormat> updatePropertyValueEither = updateComponentInstanceProperty(destComponent.getUniqueId(),
3472 destComponentInstanceId, destProp);
3473 if (updatePropertyValueEither.isRight()) {
3474 log.error("Failed to copy the property {}", destPropertyName);
3475 return Either.right(componentsUtils.getResponseFormat(ActionStatus.INVALID_CONTENT_PARAM,
3476 "Failed to paste component instance to the canvas, property copy"));
3480 log.debug("Now start to update inputs");
3481 if (getInputValues != null) {
3482 if (getInputValues.isEmpty()) {
3483 log.debug("property is return from input, set by man");
3486 log.debug("Now starting to copy the {} property", destPropertyName);
3487 Either<String, ResponseFormat> getSourceInputDefaultValue = getInputListDefaultValue(sourceComponent,
3488 getInputValues.get(0).getInputId());
3489 if (getSourceInputDefaultValue.isRight()) {
3490 return Either.right(getSourceInputDefaultValue.right().value());
3492 componentInstancePropInputList.add(new ComponentInstancePropInput(destProp));
3497 return Either.left(COPY_COMPONENT_INSTANCE_OK);
3500 private Either<String, ResponseFormat> copyComponentInstanceWithAttributes(Component sourceComponent, Component destComponent,
3501 String sourceComponentInstanceId,
3502 ComponentInstance destComponentInstance, String userId) {
3503 String destComponentInstanceId = destComponentInstance.getUniqueId();
3504 log.info("start to copy component instance with attributes");
3505 List<ComponentInstanceAttribute> sourceAttributeList = null;
3506 if (sourceComponent.getComponentInstancesAttributes() != null
3507 && sourceComponent.getComponentInstancesAttributes().get(sourceComponentInstanceId) != null) {
3508 sourceAttributeList = sourceComponent.getComponentInstancesAttributes().get(sourceComponentInstanceId);
3509 log.info("sourceAttributes {}");
3511 List<ComponentInstanceAttribute> destAttributeList = null;
3512 if (destComponent.getComponentInstancesAttributes() != null
3513 && destComponent.getComponentInstancesAttributes().get(destComponentInstanceId) != null) {
3514 destAttributeList = destComponent.getComponentInstancesAttributes().get(destComponentInstanceId);
3515 log.info("destAttributeList {}");
3517 if (null != sourceAttributeList && null != destAttributeList) {
3518 log.info("set attribute");
3519 for (ComponentInstanceAttribute sourceAttribute : sourceAttributeList) {
3520 String sourceAttributeName = sourceAttribute.getName();
3521 for (ComponentInstanceAttribute destAttribute : destAttributeList) {
3522 if (sourceAttributeName.equals(destAttribute.getName())) {
3523 log.debug("Start to copy the attribute exists {}", sourceAttributeName);
3524 sourceAttribute.setUniqueId(
3525 UniqueIdBuilder.buildResourceInstanceUniuqeId("attribute", destComponentInstanceId.split("\\.")[1], sourceAttributeName));
3526 Either<ComponentInstanceAttribute, ResponseFormat> updateAttributeValueEither = createOrUpdateAttributeValueForCopyPaste(
3527 ComponentTypeEnum.SERVICE, destComponent.getUniqueId(), destComponentInstanceId, sourceAttribute, userId);
3528 if (updateAttributeValueEither.isRight()) {
3529 log.error("Failed to copy the attribute");
3530 return Either.right(componentsUtils.getResponseFormat(ActionStatus.INVALID_CONTENT_PARAM,
3531 "Failed to paste component instance to the canvas, attribute copy"));
3538 return Either.left(COPY_COMPONENT_INSTANCE_OK);
3541 private Either<ComponentInstanceAttribute, ResponseFormat> createOrUpdateAttributeValueForCopyPaste(ComponentTypeEnum componentTypeEnum,
3542 String componentId, String resourceInstanceId,
3543 ComponentInstanceAttribute attribute,
3545 Either<ComponentInstanceAttribute, ResponseFormat> resultOp = null;
3546 validateUserExists(userId);
3547 if (componentTypeEnum == null) {
3548 BeEcompErrorManager.getInstance()
3549 .logInvalidInputError("createOrUpdateAttributeValueForCopyPaste", INVALID_COMPONENT_TYPE, ErrorSeverity.INFO);
3550 resultOp = Either.right(componentsUtils.getResponseFormat(ActionStatus.NOT_ALLOWED));
3553 Either<Component, StorageOperationStatus> getResourceResult = toscaOperationFacade.getToscaElement(componentId, JsonParseFlagEnum.ParseAll);
3554 if (getResourceResult.isRight()) {
3555 log.info("Failed to retrieve component id {}", componentId);
3556 resultOp = Either.right(componentsUtils.getResponseFormat(ActionStatus.RESTRICTED_OPERATION));
3559 Component containerComponent = getResourceResult.left().value();
3560 Either<ComponentInstance, StorageOperationStatus> resourceInstanceStatus = getResourceInstanceById(containerComponent, resourceInstanceId);
3561 if (resourceInstanceStatus.isRight()) {
3563 .right(componentsUtils.getResponseFormat(ActionStatus.RESOURCE_INSTANCE_NOT_FOUND_ON_SERVICE, resourceInstanceId, componentId));
3566 ComponentInstance foundResourceInstance = resourceInstanceStatus.left().value();
3567 String propertyType = attribute.getType();
3568 ToscaPropertyType type = ToscaPropertyType.isValidType(propertyType);
3569 log.info("The type of attribute id{},is {} ", attribute.getUniqueId(), propertyType);
3570 if (type == ToscaPropertyType.LIST || type == ToscaPropertyType.MAP) {
3571 SchemaDefinition def = attribute.getSchema();
3573 log.info("Schema doesn't exists for attribute of type {}", type);
3575 .right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(StorageOperationStatus.INVALID_VALUE)));
3577 PropertyDataDefinition propDef = def.getProperty();
3578 if (propDef == null) {
3579 log.info("Attribute in Schema Definition inside attribute of type {} doesn't exist", type);
3581 .right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(StorageOperationStatus.INVALID_VALUE)));
3584 List<ComponentInstanceAttribute> instanceAttributes = containerComponent.getComponentInstancesAttributes().get(resourceInstanceId);
3585 Optional<ComponentInstanceAttribute> instanceAttribute = instanceAttributes.stream()
3586 .filter(p -> p.getUniqueId().equals(attribute.getUniqueId())).findAny();
3587 StorageOperationStatus status;
3588 if (instanceAttribute.isPresent()) {
3589 log.info("updateComponentInstanceAttribute");
3590 status = toscaOperationFacade.updateComponentInstanceAttribute(containerComponent, foundResourceInstance.getUniqueId(), attribute);
3592 log.info("addComponentInstanceAttribute");
3593 status = toscaOperationFacade.addComponentInstanceAttribute(containerComponent, foundResourceInstance.getUniqueId(), attribute);
3595 if (status != StorageOperationStatus.OK) {
3596 ActionStatus actionStatus = componentsUtils.convertFromStorageResponseForResourceInstanceProperty(status);
3597 resultOp = Either.right(componentsUtils.getResponseFormatForResourceInstanceProperty(actionStatus, ""));
3600 List<String> path = new ArrayList<>();
3601 path.add(foundResourceInstance.getUniqueId());
3602 attribute.setPath(path);
3603 foundResourceInstance.setCustomizationUUID(UUID.randomUUID().toString());
3604 Either<Component, StorageOperationStatus> updateContainerRes = toscaOperationFacade
3605 .updateComponentInstanceMetadataOfTopologyTemplate(containerComponent);
3606 if (updateContainerRes.isRight()) {
3607 ActionStatus actionStatus = componentsUtils.convertFromStorageResponseForResourceInstanceProperty(updateContainerRes.right().value());
3608 resultOp = Either.right(componentsUtils.getResponseFormatForResourceInstanceProperty(actionStatus, ""));
3611 resultOp = Either.left(attribute);
3615 private Either<String, ResponseFormat> updateComponentInstanceProperty(String containerComponentId, String componentInstanceId,
3616 ComponentInstanceProperty property) {
3617 Either<String, ResponseFormat> resultOp;
3618 Either<Component, StorageOperationStatus> getComponent = toscaOperationFacade.getToscaElement(containerComponentId);
3619 if (getComponent.isRight()) {
3620 log.error("Failed to get the component information");
3621 return Either.right(componentsUtils
3622 .getResponseFormatForResourceInstanceProperty(ActionStatus.INVALID_CONTENT_PARAM, "Failed to get the component information"));
3624 Component containerComponent = getComponent.left().value();
3625 StorageOperationStatus status = toscaOperationFacade.updateComponentInstanceProperty(containerComponent, componentInstanceId, property);
3626 if (status != StorageOperationStatus.OK) {
3627 ActionStatus actionStatus = componentsUtils.convertFromStorageResponseForResourceInstanceProperty(status);
3628 resultOp = Either.right(componentsUtils.getResponseFormatForResourceInstanceProperty(actionStatus, ""));
3631 Either<Component, StorageOperationStatus> updateContainerRes = toscaOperationFacade
3632 .updateComponentInstanceMetadataOfTopologyTemplate(containerComponent);
3633 if (updateContainerRes.isRight()) {
3634 ActionStatus actionStatus = componentsUtils.convertFromStorageResponseForResourceInstanceProperty(updateContainerRes.right().value());
3635 resultOp = Either.right(componentsUtils.getResponseFormatForResourceInstanceProperty(actionStatus, ""));
3638 return Either.left("Update OK");
3641 private Either<String, ResponseFormat> getInputListDefaultValue(Component component, String inputId) {
3642 List<InputDefinition> inputList = component.getInputs();
3643 for (InputDefinition input : inputList) {
3644 if (input.getUniqueId().equals(inputId)) {
3645 if (input.getDefaultValue() == null) {
3646 log.debug("The input's default value is null");
3647 return Either.left(null);
3649 return Either.left(input.getDefaultValue());
3652 log.error("The input's default value with id {} is not found", inputId);
3653 return Either.right(componentsUtils.getResponseFormat(ActionStatus.USER_DEFINED, "Failed to paste component instance to the canvas"));
3657 * Method to delete selected nodes and edges on composition page
3659 * @param containerComponentType
3660 * @param componentId
3661 * @param componentInstanceIdList
3665 public Map<String, List<String>> batchDeleteComponentInstance(String containerComponentType, String componentId,
3666 List<String> componentInstanceIdList, String userId) {
3667 List<String> deleteErrorIds = new ArrayList<>();
3668 Map<String, List<String>> deleteErrorMap = new HashMap<>();
3669 validateUserExists(userId);
3670 org.openecomp.sdc.be.model.Component containerComponent = validateComponentExists(componentId,
3671 ComponentTypeEnum.findByParamName(containerComponentType), null);
3672 boolean failed = false;
3674 lockComponent(containerComponent, "batchDeleteComponentInstance");
3675 for (String eachInstanceId : componentInstanceIdList) {
3676 Either<ComponentInstance, ResponseFormat> actionResponse = batchDeleteComponentInstance(containerComponent, containerComponentType,
3678 log.debug("batchDeleteResourceInstances actionResponse is {}", actionResponse);
3679 if (actionResponse.isRight()) {
3680 log.error("Failed to delete ComponentInstance [{}]", eachInstanceId);
3681 deleteErrorIds.add(eachInstanceId);
3684 //sending the ids of the error nodes that were not deleted to UI
3685 deleteErrorMap.put("deleteFailedIds", deleteErrorIds);
3686 return deleteErrorMap;
3687 } catch (ComponentException e) {
3691 unlockComponent(failed, containerComponent);
3695 private Either<ComponentInstance, ResponseFormat> batchDeleteComponentInstance(Component containerComponent, String containerComponentType,
3696 String componentInstanceId) {
3697 ComponentInstance resultOp;
3698 final ComponentTypeEnum containerComponentTypeEnum = ComponentTypeEnum.findByParamName(containerComponentType);
3700 resultOp = deleteComponentInstance(containerComponent, componentInstanceId, containerComponentTypeEnum);
3701 log.info("Successfully deleted instance with id {}", componentInstanceId);
3702 return Either.left(resultOp);
3703 } catch (ComponentException e) {
3704 log.error("Failed to deleteComponentInstance with instanceId[{}]", componentInstanceId);
3705 return Either.right(new ResponseFormat());
3709 public void validateUser(final String userId) {
3710 final User user = userValidations.validateUserExists(userId);
3711 userValidations.validateUserRole(user, Arrays.asList(Role.DESIGNER, Role.ADMIN));