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=========================================================
19 * Modifications copyright (c) 2019 Nokia
20 * ================================================================================
23 package org.openecomp.sdc.be.components.impl;
25 import static org.apache.commons.collections.CollectionUtils.isNotEmpty;
26 import static org.openecomp.sdc.be.components.utils.ConsumptionUtils.handleConsumptionInputMappedToCapabilityProperty;
27 import static org.openecomp.sdc.be.components.utils.ConsumptionUtils.isAssignedValueFromValidType;
28 import static org.openecomp.sdc.be.components.utils.InterfaceOperationUtils.getOperationOutputName;
29 import static org.openecomp.sdc.be.components.utils.InterfaceOperationUtils.isOperationInputMappedToOtherOperationOutput;
30 import static org.openecomp.sdc.be.resources.data.auditing.AuditingActionEnum.UPDATE_SERVICE_METADATA;
31 import static org.openecomp.sdc.be.tosca.InterfacesOperationsConverter.SELF;
32 import static org.openecomp.sdc.be.types.ServiceConsumptionSource.SERVICE_INPUT;
33 import static org.openecomp.sdc.be.types.ServiceConsumptionSource.STATIC;
35 import com.google.common.annotations.VisibleForTesting;
36 import com.google.common.base.Strings;
37 import com.google.gson.Gson;
38 import com.google.gson.GsonBuilder;
39 import fj.data.Either;
40 import java.nio.charset.StandardCharsets;
41 import java.util.ArrayList;
42 import java.util.Arrays;
43 import java.util.Collection;
44 import java.util.Collections;
45 import java.util.Comparator;
46 import java.util.HashMap;
47 import java.util.List;
49 import java.util.Objects;
50 import java.util.Optional;
52 import java.util.concurrent.Callable;
53 import java.util.function.Function;
54 import java.util.stream.Collectors;
55 import javax.servlet.ServletContext;
56 import javax.servlet.http.HttpServletRequest;
57 import org.apache.commons.collections.CollectionUtils;
58 import org.apache.commons.collections.MapUtils;
59 import org.apache.commons.collections4.ListUtils;
60 import org.apache.commons.lang3.StringUtils;
61 import org.apache.commons.lang3.tuple.ImmutablePair;
62 import org.openecomp.sdc.be.catalog.enums.ChangeTypeEnum;
63 import org.openecomp.sdc.be.components.distribution.engine.IDistributionEngine;
64 import org.openecomp.sdc.be.components.distribution.engine.INotificationData;
65 import org.openecomp.sdc.be.components.distribution.engine.VfModuleArtifactPayload;
66 import org.openecomp.sdc.be.components.health.HealthCheckBusinessLogic;
67 import org.openecomp.sdc.be.components.impl.exceptions.ByActionStatusComponentException;
68 import org.openecomp.sdc.be.components.impl.exceptions.ByResponseFormatComponentException;
69 import org.openecomp.sdc.be.components.impl.exceptions.ComponentException;
70 import org.openecomp.sdc.be.components.lifecycle.LifecycleChangeInfoWithAction;
71 import org.openecomp.sdc.be.components.path.ForwardingPathValidator;
72 import org.openecomp.sdc.be.components.utils.InterfaceOperationUtils;
73 import org.openecomp.sdc.be.components.utils.PropertiesUtils;
74 import org.openecomp.sdc.be.components.validation.ServiceDistributionValidation;
75 import org.openecomp.sdc.be.components.validation.component.ComponentContactIdValidator;
76 import org.openecomp.sdc.be.components.validation.component.ComponentDescriptionValidator;
77 import org.openecomp.sdc.be.components.validation.component.ComponentIconValidator;
78 import org.openecomp.sdc.be.components.validation.component.ComponentNameValidator;
79 import org.openecomp.sdc.be.components.validation.component.ComponentProjectCodeValidator;
80 import org.openecomp.sdc.be.components.validation.component.ComponentTagsValidator;
81 import org.openecomp.sdc.be.components.validation.component.ComponentValidator;
82 import org.openecomp.sdc.be.components.validation.service.ServiceCategoryValidator;
83 import org.openecomp.sdc.be.components.validation.service.ServiceFunctionValidator;
84 import org.openecomp.sdc.be.components.validation.service.ServiceInstantiationTypeValidator;
85 import org.openecomp.sdc.be.components.validation.service.ServiceRoleValidator;
86 import org.openecomp.sdc.be.components.validation.service.ServiceTypeValidator;
87 import org.openecomp.sdc.be.components.validation.service.ServiceValidator;
88 import org.openecomp.sdc.be.config.BeEcompErrorManager;
89 import org.openecomp.sdc.be.config.ConfigurationManager;
90 import org.openecomp.sdc.be.dao.api.ActionStatus;
91 import org.openecomp.sdc.be.dao.cassandra.AuditCassandraDao;
92 import org.openecomp.sdc.be.dao.jsongraph.types.JsonParseFlagEnum;
93 import org.openecomp.sdc.be.datamodel.ServiceRelations;
94 import org.openecomp.sdc.be.datamodel.utils.PropertyValueConstraintValidationUtil;
95 import org.openecomp.sdc.be.datamodel.utils.UiComponentDataConverter;
96 import org.openecomp.sdc.be.datatypes.elements.ForwardingPathDataDefinition;
97 import org.openecomp.sdc.be.datatypes.elements.InterfaceDataDefinition;
98 import org.openecomp.sdc.be.datatypes.elements.ListDataDefinition;
99 import org.openecomp.sdc.be.datatypes.elements.OperationInputDefinition;
100 import org.openecomp.sdc.be.datatypes.elements.OperationOutputDefinition;
101 import org.openecomp.sdc.be.datatypes.enums.ComponentFieldsEnum;
102 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
103 import org.openecomp.sdc.be.datatypes.enums.JsonPresentationFields;
104 import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
105 import org.openecomp.sdc.be.datatypes.enums.OriginTypeEnum;
106 import org.openecomp.sdc.be.externalapi.servlet.representation.ServiceDistributionReqInfo;
107 import org.openecomp.sdc.be.impl.ForwardingPathUtils;
108 import org.openecomp.sdc.be.impl.WebAppContextWrapper;
109 import org.openecomp.sdc.be.model.ArtifactDefinition;
110 import org.openecomp.sdc.be.model.CapabilityDefinition;
111 import org.openecomp.sdc.be.model.Component;
112 import org.openecomp.sdc.be.model.ComponentInstance;
113 import org.openecomp.sdc.be.model.ComponentInstanceInterface;
114 import org.openecomp.sdc.be.model.ComponentInstanceProperty;
115 import org.openecomp.sdc.be.model.ComponentParametersView;
116 import org.openecomp.sdc.be.model.DistributionStatusEnum;
117 import org.openecomp.sdc.be.model.DistributionTransitionEnum;
118 import org.openecomp.sdc.be.model.GroupInstance;
119 import org.openecomp.sdc.be.model.GroupInstanceProperty;
120 import org.openecomp.sdc.be.model.InputDefinition;
121 import org.openecomp.sdc.be.model.InterfaceDefinition;
122 import org.openecomp.sdc.be.model.LifecycleStateEnum;
123 import org.openecomp.sdc.be.model.Operation;
124 import org.openecomp.sdc.be.model.PropertyDefinition;
125 import org.openecomp.sdc.be.model.Resource;
126 import org.openecomp.sdc.be.model.Service;
127 import org.openecomp.sdc.be.model.User;
128 import org.openecomp.sdc.be.model.category.CategoryDefinition;
129 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.ArtifactsOperations;
130 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.ForwardingPathOperation;
131 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.InterfaceOperation;
132 import org.openecomp.sdc.be.model.operations.api.IElementOperation;
133 import org.openecomp.sdc.be.model.operations.api.IGroupInstanceOperation;
134 import org.openecomp.sdc.be.model.operations.api.IGroupOperation;
135 import org.openecomp.sdc.be.model.operations.api.IGroupTypeOperation;
136 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
137 import org.openecomp.sdc.be.model.operations.impl.InterfaceLifecycleOperation;
138 import org.openecomp.sdc.be.model.operations.impl.UniqueIdBuilder;
139 import org.openecomp.sdc.be.model.operations.utils.ComponentValidationUtils;
140 import org.openecomp.sdc.be.plugins.ServiceCreationPlugin;
141 import org.openecomp.sdc.be.resources.data.ComponentInstanceData;
142 import org.openecomp.sdc.be.resources.data.ComponentMetadataData;
143 import org.openecomp.sdc.be.resources.data.auditing.AuditingActionEnum;
144 import org.openecomp.sdc.be.resources.data.auditing.AuditingGenericEvent;
145 import org.openecomp.sdc.be.resources.data.auditing.DistributionDeployEvent;
146 import org.openecomp.sdc.be.resources.data.auditing.DistributionNotificationEvent;
147 import org.openecomp.sdc.be.resources.data.auditing.ResourceAdminEvent;
148 import org.openecomp.sdc.be.resources.data.auditing.model.ResourceCommonInfo;
149 import org.openecomp.sdc.be.resources.data.auditing.model.ResourceVersionInfo;
150 import org.openecomp.sdc.be.types.ServiceConsumptionData;
151 import org.openecomp.sdc.be.types.ServiceConsumptionSource;
152 import org.openecomp.sdc.be.ui.model.UiComponentDataTransfer;
153 import org.openecomp.sdc.be.user.Role;
154 import org.openecomp.sdc.common.api.ArtifactGroupTypeEnum;
155 import org.openecomp.sdc.common.api.ArtifactTypeEnum;
156 import org.openecomp.sdc.common.api.Constants;
157 import org.openecomp.sdc.common.datastructure.Wrapper;
158 import org.openecomp.sdc.common.kpi.api.ASDCKpiApi;
159 import org.openecomp.sdc.common.log.wrappers.Logger;
160 import org.openecomp.sdc.common.util.GeneralUtility;
161 import org.openecomp.sdc.common.util.ThreadLocalsHolder;
162 import org.openecomp.sdc.common.util.ValidationUtils;
163 import org.openecomp.sdc.exception.ResponseFormat;
164 import org.openecomp.sdc.tosca.datatypes.ToscaFunctions;
165 import org.springframework.beans.factory.annotation.Autowired;
166 import org.springframework.http.HttpStatus;
167 import org.springframework.web.context.WebApplicationContext;
170 @org.springframework.stereotype.Component("serviceBusinessLogic")
171 public class ServiceBusinessLogic extends ComponentBusinessLogic {
173 private static final String CHANGE_SERVICE_DISTRIBUTION = "Change Service Distribution";
174 private static final String THE_SERVICE_WITH_SYSTEM_NAME_LOCKED = "The service with system name {} locked. ";
175 private static final String FAILED_TO_LOCK_SERVICE_RESPONSE_IS = "Failed to lock service {}. Response is {}. ";
176 private static final String AUDIT_BEFORE_SENDING_RESPONSE = "audit before sending response";
177 private static final Logger log = Logger.getLogger(ServiceBusinessLogic.class);
178 private static final String INITIAL_VERSION = "0.1";
179 private static final String STATUS_SUCCESS_200 = "200";
180 private static final String STATUS_DEPLOYED = "DEPLOYED";
181 static final String IS_VALID = "isValid";
182 private static final String PLACE_HOLDER_RESOURCE_TYPES = "validForResourceTypes";
184 private ForwardingPathOperation forwardingPathOperation;
185 private AuditCassandraDao auditCassandraDao;
187 private final IDistributionEngine distributionEngine;
188 private final ComponentInstanceBusinessLogic componentInstanceBusinessLogic;
189 private final ServiceDistributionValidation serviceDistributionValidation;
190 private final ForwardingPathValidator forwardingPathValidator;
191 private final UiComponentDataConverter uiComponentDataConverter;
193 private ServiceTypeValidator serviceTypeValidator;
194 private List<ServiceCreationPlugin> serviceCreationPluginList;
197 public void setServiceTypeValidator(ServiceTypeValidator serviceTypeValidator) {
198 this.serviceTypeValidator = serviceTypeValidator;
202 private ServiceFunctionValidator serviceFunctionValidator;
205 public void setServiceFunctionValidator(ServiceFunctionValidator serviceFunctionValidator) {
206 this.serviceFunctionValidator = serviceFunctionValidator;
210 private ServiceRoleValidator serviceRoleValidator;
213 private ServiceInstantiationTypeValidator serviceInstantiationTypeValidator;
216 private ServiceCategoryValidator serviceCategoryValidator;
219 private ServiceValidator serviceValidator;
223 public ServiceBusinessLogic(IElementOperation elementDao,
224 IGroupOperation groupOperation,
225 IGroupInstanceOperation groupInstanceOperation,
226 IGroupTypeOperation groupTypeOperation,
227 GroupBusinessLogic groupBusinessLogic,
228 InterfaceOperation interfaceOperation,
229 InterfaceLifecycleOperation interfaceLifecycleTypeOperation,
230 ArtifactsBusinessLogic artifactsBusinessLogic,
231 IDistributionEngine distributionEngine, ComponentInstanceBusinessLogic componentInstanceBusinessLogic,
232 ServiceDistributionValidation serviceDistributionValidation, ForwardingPathValidator forwardingPathValidator,
233 UiComponentDataConverter uiComponentDataConverter,
234 ArtifactsOperations artifactToscaOperation,
235 ComponentContactIdValidator componentContactIdValidator,
236 ComponentNameValidator componentNameValidator,
237 ComponentTagsValidator componentTagsValidator,
238 ComponentValidator componentValidator,
239 ComponentIconValidator componentIconValidator,
240 ComponentProjectCodeValidator componentProjectCodeValidator,
241 ComponentDescriptionValidator componentDescriptionValidator) {
242 super(elementDao, groupOperation, groupInstanceOperation, groupTypeOperation, groupBusinessLogic,
243 interfaceOperation, interfaceLifecycleTypeOperation, artifactsBusinessLogic, artifactToscaOperation, componentContactIdValidator,
244 componentNameValidator, componentTagsValidator, componentValidator,
245 componentIconValidator, componentProjectCodeValidator, componentDescriptionValidator);
246 this.distributionEngine = distributionEngine;
247 this.componentInstanceBusinessLogic = componentInstanceBusinessLogic;
248 this.serviceDistributionValidation = serviceDistributionValidation;
249 this.forwardingPathValidator = forwardingPathValidator;
250 this.uiComponentDataConverter = uiComponentDataConverter;
254 public Either<List<Map<String, Object>>, ResponseFormat> getComponentAuditRecords(String componentVersion, String componentUUID, String userId) {
255 validateUserExists(userId);
256 Either<List<Map<String, Object>>, ActionStatus> result;
260 if (componentVersion.endsWith(".0")) {
261 Either<List<ResourceAdminEvent>, ActionStatus> eitherAuditingForCertified = auditCassandraDao.getByServiceInstanceId(componentUUID);
262 if (eitherAuditingForCertified.isLeft()) {
263 result = Either.left(getAuditingFieldsList(eitherAuditingForCertified.left().value()));
265 result = Either.right(eitherAuditingForCertified.right().value());
268 // Uncertified Version
270 result = getAuditRecordsForUncertifiedComponent(componentUUID, componentVersion);
272 } catch (Exception e) {
273 log.debug("get Audit Records failed with exception {}", e);
274 result = Either.right(ActionStatus.GENERAL_ERROR);
277 if (result.isRight()) {
278 return Either.right(componentsUtils.getResponseFormat(result.right().value()));
280 return Either.left(result.left().value());
285 public Either<List<Operation>, ResponseFormat> addServiceConsumptionData(String serviceId,
286 String serviceInstanceId,
288 List<ServiceConsumptionData> serviceConsumptionDataList,
290 List<Operation> operationList = new ArrayList<>();
292 Either<Service, StorageOperationStatus> serviceEither =
293 toscaOperationFacade.getToscaElement(serviceId);
294 if(serviceEither.isRight()) {
295 return Either.right(componentsUtils.getResponseFormat
296 (serviceEither.right().value()));
299 Service service = serviceEither.left().value();
302 StorageOperationStatus storageOperationStatus =
303 graphLockOperation.lockComponent(service.getUniqueId(), NodeTypeEnum.Service);
304 if (storageOperationStatus != StorageOperationStatus.OK) {
305 return Either.right(componentsUtils.getResponseFormat(storageOperationStatus));
309 for (ServiceConsumptionData serviceConsumptionData : serviceConsumptionDataList) {
310 Either<Operation, ResponseFormat> operationEither =
311 addPropertyServiceConsumption(serviceId, serviceInstanceId, operationId,
312 userId, serviceConsumptionData);
314 if (operationEither.isRight()) {
315 return Either.right(operationEither.right().value());
318 operationList.add(operationEither.left().value());
321 janusGraphDao.commit();
322 return Either.left(operationList);
323 } catch (Exception e) {
324 janusGraphDao.rollback();
325 return Either.right(componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR));
328 graphLockOperation.unlockComponent(service.getUniqueId(), NodeTypeEnum.Service);
333 public Either <Operation, ResponseFormat> addPropertyServiceConsumption(String serviceId,
334 String serviceInstanceId,
337 ServiceConsumptionData serviceConsumptionData) {
338 validateUserExists(userId);
340 Either<Service, StorageOperationStatus> serviceEither =
341 toscaOperationFacade.getToscaElement(serviceId);
342 if(serviceEither.isRight()) {
343 return Either.right(componentsUtils.getResponseFormat(serviceEither.right
347 Service parentService = serviceEither.left().value();
349 List<ComponentInstance> componentInstances = parentService.getComponentInstances();
350 if(CollectionUtils.isEmpty(componentInstances)) {
351 return Either.right(componentsUtils.getResponseFormat(ActionStatus
352 .INTERFACE_OPERATION_NOT_FOUND, serviceInstanceId));
355 Optional<ComponentInstance> serviceInstanceCandidate =
356 componentInstances.stream().filter(instance -> instance.getUniqueId().equals
357 (serviceInstanceId)).findAny();
359 if(!serviceInstanceCandidate.isPresent()) {
360 return Either.right(componentsUtils.getResponseFormat(ActionStatus
361 .INTERFACE_OPERATION_NOT_FOUND, serviceInstanceId));
364 Map<String, List<ComponentInstanceInterface>> componentInstancesInterfaces =
365 parentService.getComponentInstancesInterfaces();
366 if(MapUtils.isEmpty(componentInstancesInterfaces)) {
367 return Either.right(componentsUtils.getResponseFormat(ActionStatus
368 .INTERFACE_OPERATION_NOT_FOUND, serviceInstanceId));
371 List<InterfaceDefinition> interfaces = new ArrayList<>();
372 for(ComponentInstanceInterface componentInstanceInterface :
373 componentInstancesInterfaces.get(serviceInstanceId)) {
374 interfaces.add(componentInstanceInterface);
377 ComponentInstance serviceInstance = serviceInstanceCandidate.get();
378 Optional<InterfaceDefinition> interfaceCandidate = InterfaceOperationUtils
379 .getInterfaceDefinitionFromOperationId(interfaces, operationId);
381 if(!interfaceCandidate.isPresent()) {
382 return Either.right(componentsUtils.getResponseFormat(ActionStatus
383 .INTERFACE_OPERATION_NOT_FOUND, serviceInstanceId));
386 InterfaceDefinition interfaceDefinition = interfaceCandidate.get();
387 Map<String, Operation> operations = interfaceDefinition.getOperationsMap();
388 if(MapUtils.isEmpty(operations)) {
389 return Either.right(componentsUtils.getResponseFormat(ActionStatus
390 .INTERFACE_OPERATION_NOT_FOUND, serviceInstanceId));
393 Operation operation = operations.get(operationId);
394 Either<Operation, ResponseFormat> operationEither = Either.left(operation);
396 ListDataDefinition<OperationInputDefinition> inputs = operation.getInputs();
397 Optional<OperationInputDefinition> inputCandidate =
398 getOperationInputByInputId(serviceConsumptionData, inputs);
400 if(!inputCandidate.isPresent()) {
401 return Either.right(new ResponseFormat(HttpStatus.NOT_FOUND.value()));
404 OperationInputDefinition operationInputDefinition = inputCandidate.get();
405 // add data to operation
407 if(Objects.nonNull(serviceConsumptionData.getValue())) {
409 handleConsumptionValue(parentService, serviceInstanceId, serviceConsumptionData, operation,
410 operationInputDefinition);
413 if(operationEither.isRight()) {
414 return Either.right(operationEither.right().value());
417 Operation updatedOperation = operationEither.left().value();
418 operations.remove(operationId);
419 operations.put(operationId, updatedOperation);
420 interfaceDefinition.setOperationsMap(operations);
422 parentService.getComponentInstances().remove(serviceInstance);
423 if(CollectionUtils.isEmpty(parentService.getComponentInstances())) {
424 parentService.setComponentInstances(new ArrayList<>());
427 Map<String, Object> instanceInterfaces =
428 MapUtils.isEmpty(serviceInstance.getInterfaces())? new HashMap<>() : serviceInstance.getInterfaces();
429 instanceInterfaces.remove(interfaceDefinition.getUniqueId());
430 instanceInterfaces.put(interfaceDefinition.getUniqueId(), interfaceDefinition);
431 serviceInstance.setInterfaces(instanceInterfaces);
433 removeComponentInstanceInterfaceByInterfaceId(interfaceDefinition.getUniqueId(), componentInstancesInterfaces.get(serviceInstanceId));
434 componentInstancesInterfaces.get(serviceInstanceId).add(new ComponentInstanceInterface(interfaceDefinition.getUniqueId(), interfaceDefinition));
436 parentService.getComponentInstances().add(serviceInstance);
438 StorageOperationStatus status = toscaOperationFacade.updateComponentInstanceInterfaces(parentService, serviceInstanceId);
440 if(status != StorageOperationStatus.OK) {
441 return Either.right(componentsUtils.getResponseFormat(ActionStatus
442 .INTERFACE_OPERATION_NOT_FOUND, serviceInstanceId));
445 return Either.left(operation);
448 private void removeComponentInstanceInterfaceByInterfaceId(String interfaceIdToRemove,
449 List<ComponentInstanceInterface> instanceInterfaces) {
450 if(CollectionUtils.isEmpty(instanceInterfaces)) {
454 Optional<ComponentInstanceInterface> interfaceToRemove =
455 instanceInterfaces.stream().filter(instInterface -> instInterface.getUniqueId().equals
456 (interfaceIdToRemove)).findAny();
458 if(interfaceToRemove.isPresent()) {
459 instanceInterfaces.remove(interfaceToRemove.get());
464 private Either<Operation, ResponseFormat> handleConsumptionValue(Service containerService,
465 String serviceInstanceId,
466 ServiceConsumptionData serviceConsumptionData,
468 OperationInputDefinition
469 operationInputDefinition) {
470 String source = serviceConsumptionData.getSource();
471 String consumptionValue = serviceConsumptionData.getValue();
472 String type = serviceConsumptionData.getType();
473 String operationIdentifier = consumptionValue.contains(".")
474 ? consumptionValue.substring(0, consumptionValue.lastIndexOf('.'))
477 ServiceConsumptionSource sourceValue = ServiceConsumptionSource.getSourceValue(source);
479 if(STATIC.equals(sourceValue)) {
480 // Validate constraint on input value
481 Either<Boolean, ResponseFormat> constraintValidationResult =
482 validateOperationInputConstraint(operationInputDefinition, consumptionValue, type);
484 if (constraintValidationResult.isRight()) {
485 return Either.right(constraintValidationResult.right().value());
487 return handleConsumptionStaticValue(consumptionValue, type, operation,
488 operationInputDefinition);
491 if (Objects.isNull(sourceValue)) {
492 List<PropertyDefinition> propertyDefinitions;
493 Map<String, List<CapabilityDefinition>> capabilities = null;
494 String componentName;
495 List<OperationOutputDefinition> outputs = null;
496 if (source.equals(containerService.getUniqueId())) {
497 Either<Service, StorageOperationStatus> serviceToTakePropEither =
498 toscaOperationFacade.getToscaElement(source);
499 if (serviceToTakePropEither.isRight()) {
500 return Either.right(componentsUtils.getResponseFormat(serviceToTakePropEither.right().value()));
502 Service service = serviceToTakePropEither.left().value();
503 operationInputDefinition.setSource(service.getUniqueId());
504 sourceValue = SERVICE_INPUT;
505 propertyDefinitions = service.getProperties();
506 componentName = service.getName();
507 outputs = InterfaceOperationUtils.getOtherOperationOutputsOfComponent(operationIdentifier,
508 service.getInterfaces()).getListToscaDataDefinition();
510 Optional<ComponentInstance> getComponentInstance = containerService.getComponentInstanceById(source);
511 if(!getComponentInstance.isPresent()){
512 return Either.right(componentsUtils.getResponseFormat(
513 ActionStatus.COMPONENT_INSTANCE_NOT_FOUND_ON_CONTAINER, source));
515 ComponentInstance componentInstance = getComponentInstance.get();
516 operationInputDefinition.setSource(componentInstance.getUniqueId());
517 propertyDefinitions = componentInstance.getProperties();
518 capabilities = componentInstance.getCapabilities();
519 componentName = source.equals(serviceInstanceId) ? SELF : componentInstance.getName();
520 if (MapUtils.isNotEmpty(componentInstance.getInterfaces())) {
521 Map<String, InterfaceDataDefinition> componentInstanceInterfaces =
522 componentInstance.getInterfaces().entrySet().stream()
523 .collect(Collectors.toMap((Map.Entry::getKey),
524 (interfaceEntry -> (InterfaceDataDefinition) interfaceEntry.getValue())));
525 outputs = InterfaceOperationUtils.getOtherOperationOutputsOfComponent(operationIdentifier,
526 componentInstanceInterfaces).getListToscaDataDefinition();
530 if(sourceValue == ServiceConsumptionSource.SERVICE_INPUT) {
531 //The operation input in service consumption has been mapped to an input in the parent service
532 return handleConsumptionInputValue(consumptionValue, containerService, operation,
533 operationInputDefinition);
535 return handleConsumptionPropertyValue(operation, operationInputDefinition,
536 serviceConsumptionData, propertyDefinitions, capabilities, outputs, componentName);
539 operationInputDefinition.setToscaPresentationValue(JsonPresentationFields.SOURCE, source);
540 operationInputDefinition.setSource(source);
542 return Either.left(operation);
545 private Optional<OperationInputDefinition> getOperationInputByInputId(ServiceConsumptionData serviceConsumptionData,
546 ListDataDefinition<OperationInputDefinition> inputs) {
548 if(CollectionUtils.isEmpty(inputs.getListToscaDataDefinition())) {
549 return Optional.empty();
552 return inputs.getListToscaDataDefinition().stream().filter(operationInput -> operationInput.getInputId().equals
553 (serviceConsumptionData.getInputId()))
557 private Either<Operation, ResponseFormat> handleConsumptionPropertyValue(
558 Operation operation, OperationInputDefinition operationInputDefinition,
559 ServiceConsumptionData serviceConsumptionData, List<PropertyDefinition> properties,Map<String,
560 List<CapabilityDefinition>> capabilities,
561 List<OperationOutputDefinition> outputs, String componentName) {
563 if (CollectionUtils.isEmpty(properties) && CollectionUtils.isEmpty(outputs)) {
564 return Either.left(operation);
566 String consumptionValue = serviceConsumptionData.getValue();
568 if (CollectionUtils.isNotEmpty(outputs)
569 && isOperationInputMappedToOtherOperationOutput(getOperationOutputName(consumptionValue), outputs)) {
570 return handleConsumptionInputMappedToOperationOutput(operation, operationInputDefinition, outputs,
571 consumptionValue, componentName);
574 if (CollectionUtils.isNotEmpty(properties) && PropertiesUtils.isNodeProperty(consumptionValue, properties)) {
575 return handleConsumptionInputMappedToProperty(operation, operationInputDefinition, serviceConsumptionData,
576 properties, componentName);
579 if (MapUtils.isNotEmpty(capabilities)) {
580 return handleConsumptionInputMappedToCapabilityProperty(operation, operationInputDefinition,
581 serviceConsumptionData, capabilities, componentName);
584 return Either.left(operation);
587 private Either<Operation, ResponseFormat> handleConsumptionInputMappedToProperty(Operation operation,
588 OperationInputDefinition operationInputDefinition, ServiceConsumptionData serviceConsumptionData,
589 List<PropertyDefinition> properties, String componentName) {
590 Optional<PropertyDefinition> servicePropertyCandidate =
591 properties.stream().filter(property -> property.getName()
592 .equals(serviceConsumptionData.getValue())).findAny();
594 if (servicePropertyCandidate.isPresent()) {
595 boolean isInputTypeSimilarToOperation =
596 isAssignedValueFromValidType(operationInputDefinition.getType(),
597 servicePropertyCandidate.get());
599 if (!isInputTypeSimilarToOperation) {
600 return Either.right(componentsUtils.getResponseFormat(
601 ActionStatus.INVALID_CONSUMPTION_TYPE, operationInputDefinition.getType()));
604 addPropertyToInputValue(componentName, operation, operationInputDefinition,
605 servicePropertyCandidate.get());
607 return Either.left(operation);
610 private Either<Operation, ResponseFormat> handleConsumptionInputMappedToOperationOutput(Operation operation,
611 OperationInputDefinition operationInputDefinition, List<OperationOutputDefinition> outputs,
612 String consumptionValue, String componentName) {
613 String outputName = getOperationOutputName(consumptionValue);
614 Optional<OperationOutputDefinition> servicePropertyOutputCandidate = outputs.stream()
615 .filter(output -> output.getName().equals(outputName)).findAny();
616 if (servicePropertyOutputCandidate.isPresent()) {
617 boolean isInputTypeSimilarToOperation =
618 isAssignedValueFromValidType(operationInputDefinition.getType(),
619 servicePropertyOutputCandidate.get());
620 if (!isInputTypeSimilarToOperation) {
621 return Either.right(componentsUtils.getResponseFormat(
622 ActionStatus.INVALID_CONSUMPTION_TYPE, operationInputDefinition.getType()));
624 addOutputToInputValue(componentName, consumptionValue, operation, operationInputDefinition);
626 return Either.left(operation);
629 private void addPropertyToInputValue(String componentName, Operation operation,
630 OperationInputDefinition operationInputDefinition,
631 PropertyDefinition serviceProperty) {
632 Map<String, List<String>> getProperty = new HashMap<>();
633 List<String> getPropertyValues = new ArrayList<>();
634 getPropertyValues.add(componentName);
635 getPropertyValues.add(serviceProperty.getName());
636 getProperty.put(ToscaFunctions.GET_PROPERTY.getFunctionName(), getPropertyValues);
638 operationInputDefinition.setSourceProperty(serviceProperty.getUniqueId());
639 operation.getInputs().delete(operationInputDefinition);
640 operationInputDefinition.setToscaPresentationValue(JsonPresentationFields.GET_PROPERTY,
642 operationInputDefinition.setValue((new Gson()).toJson(getProperty));
643 operation.getInputs().add(operationInputDefinition);
646 private void addOutputToInputValue(String componentName, String consumptionValue,
647 Operation operation, OperationInputDefinition operationInputDefinition) {
648 Map<String, List<String>> getOperationOutput =
649 InterfaceOperationUtils.createMappedOutputDefaultValue(componentName, consumptionValue);
650 operation.getInputs().delete(operationInputDefinition);
651 operationInputDefinition.setToscaPresentationValue(JsonPresentationFields.GET_OPERATION_OUTPUT,
653 operationInputDefinition.setValue((new Gson()).toJson(getOperationOutput));
654 operation.getInputs().add(operationInputDefinition);
657 public Either<Operation, ResponseFormat> handleConsumptionStaticValue(String value, String type,
659 OperationInputDefinition
660 operationInputDefinition) {
661 boolean isInputTypeSimilarToOperation =
662 isAssignedValueFromValidType(type, value);
664 if(!isInputTypeSimilarToOperation) {
665 return Either.right(componentsUtils.getResponseFormat(
666 ActionStatus.INVALID_CONSUMPTION_TYPE, type));
669 //Validate Constraint and Value
670 Either<Boolean, ResponseFormat> constraintValidationResponse =
671 validateOperationInputConstraint(operationInputDefinition, value, type);
672 if(constraintValidationResponse.isRight()) {
673 return Either.right(constraintValidationResponse.right().value());
676 addStaticValueToInputOperation(value, operation, operationInputDefinition);
678 return Either.left(operation);
681 private Either<Boolean, ResponseFormat> validateOperationInputConstraint(
682 OperationInputDefinition operationInputDefinition, String value, String type) {
683 ComponentInstanceProperty propertyDefinition = new ComponentInstanceProperty();
684 propertyDefinition.setType(operationInputDefinition.getParentPropertyType());
686 InputDefinition inputDefinition = new InputDefinition();
687 inputDefinition.setDefaultValue(value);
688 inputDefinition.setInputPath(operationInputDefinition.getSubPropertyInputPath());
689 inputDefinition.setType(type);
690 if (Objects.nonNull(operationInputDefinition.getParentPropertyType())) {
691 inputDefinition.setProperties(Collections.singletonList(propertyDefinition));
694 return PropertyValueConstraintValidationUtil.getInstance()
695 .validatePropertyConstraints(Collections.singletonList(inputDefinition), applicationDataTypeCache);
698 private void addStaticValueToInputOperation(String value, Operation operation,
699 OperationInputDefinition operationInputDefinition) {
700 operation.getInputs().delete(operationInputDefinition);
701 operationInputDefinition.setSource(STATIC.getSource());
702 operationInputDefinition.setSourceProperty(null);
703 operationInputDefinition.setValue(value);
704 operation.getInputs().add(operationInputDefinition);
707 private Either<Operation, ResponseFormat> handleConsumptionInputValue(String inputId,
710 OperationInputDefinition
711 operationInputDefinition) {
712 List<InputDefinition> serviceInputs = service.getInputs();
713 Optional<InputDefinition> inputForValue =
714 serviceInputs.stream().filter(input -> input.getUniqueId().contains(inputId)).findAny();
716 if(inputForValue.isPresent()) {
717 boolean isInputTypeSimilarToOperation =
718 isAssignedValueFromValidType(operationInputDefinition.getType(), inputForValue.get());
720 if(!isInputTypeSimilarToOperation) {
721 return Either.right(componentsUtils.getResponseFormat(
722 ActionStatus.INVALID_CONSUMPTION_TYPE, operationInputDefinition.getType()));
724 addGetInputValueToOperationInput(operation, operationInputDefinition, inputForValue.get());
727 return Either.left(operation);
730 private void addGetInputValueToOperationInput(Operation operation,
731 OperationInputDefinition operationInputDefinition,
732 InputDefinition inputForValue) {
733 operation.getInputs().delete(operationInputDefinition);
734 Map<String, String> getInputMap = new HashMap<>();
735 getInputMap.put(ToscaFunctions.GET_INPUT.getFunctionName(), inputForValue.getName());
736 operationInputDefinition.setSourceProperty(inputForValue.getUniqueId());
737 operationInputDefinition.setToscaPresentationValue(JsonPresentationFields.GET_INPUT, getInputMap);
738 operationInputDefinition.setValue(new Gson().toJson(getInputMap));
739 operation.getInputs().add(operationInputDefinition);
742 private Either<List<Map<String, Object>>, ActionStatus> getAuditRecordsForUncertifiedComponent(String componentUUID, String componentVersion) {
744 Either<List<ResourceAdminEvent>, ActionStatus> eitherprevVerAudit = auditCassandraDao.getAuditByServiceIdAndPrevVersion(componentUUID, componentVersion);
746 if (eitherprevVerAudit.isRight()) {
747 return Either.right(eitherprevVerAudit.right().value());
751 Either<List<ResourceAdminEvent>, ActionStatus> eitherCurrVerAudit = auditCassandraDao.getAuditByServiceIdAndCurrVersion(componentUUID, componentVersion);
752 if (eitherCurrVerAudit.isRight()) {
753 return Either.right(eitherCurrVerAudit.right().value());
757 Either<List<ResourceAdminEvent>, ActionStatus> eitherArchiveRestoreList = getArchiveRestoreEventList(componentUUID);
758 if (eitherArchiveRestoreList.isRight()) {
759 return Either.right(eitherArchiveRestoreList.right().value());
762 List<Map<String, Object>> prevVerAuditList = getAuditingFieldsList(eitherprevVerAudit.left().value());
763 List<Map<String, Object>> currVerAuditList = getAuditingFieldsList(eitherCurrVerAudit.left().value());
765 List<Map<String, Object>> duplicateElements = new ArrayList<>();
766 duplicateElements.addAll(prevVerAuditList);
767 duplicateElements.retainAll(currVerAuditList);
769 List<Map<String, Object>> joinedNonDuplicatedList = new ArrayList<>();
770 joinedNonDuplicatedList.addAll(prevVerAuditList);
771 joinedNonDuplicatedList.removeAll(duplicateElements);
772 joinedNonDuplicatedList.addAll(currVerAuditList);
773 joinedNonDuplicatedList.addAll(getAuditingFieldsList(eitherArchiveRestoreList.left().value()));
776 return Either.left(joinedNonDuplicatedList);
779 private Either<List<ResourceAdminEvent>, ActionStatus> getArchiveRestoreEventList(String componentUUID) {
781 Either<List<ResourceAdminEvent>, ActionStatus> eitherArchiveAudit = auditCassandraDao.getArchiveAuditByServiceInstanceId(componentUUID);
782 if (eitherArchiveAudit.isRight()) {
783 return Either.right(eitherArchiveAudit.right().value());
787 Either<List<ResourceAdminEvent>, ActionStatus> eitherRestoreAudit = auditCassandraDao.getRestoreAuditByServiceInstanceId(componentUUID);
788 if (eitherRestoreAudit.isRight()) {
789 return Either.right(eitherRestoreAudit.right().value());
792 List<ResourceAdminEvent> archiveAudit = new ArrayList<>();
793 archiveAudit.addAll(eitherArchiveAudit.left().value());
794 archiveAudit.addAll(eitherRestoreAudit.left().value());
796 return Either.left(archiveAudit);
800 public void setServiceValidator(ServiceValidator serviceValidator) {
801 this.serviceValidator = serviceValidator;
805 public void setServiceCategoryValidator(ServiceCategoryValidator serviceCategoryValidator) {
806 this.serviceCategoryValidator = serviceCategoryValidator;
809 private List<Map<String, Object>> getAuditingFieldsList(List<? extends AuditingGenericEvent> prevVerAuditList) {
811 List<Map<String, Object>> prevVerAudit = new ArrayList<>();
812 for (AuditingGenericEvent auditEvent : prevVerAuditList) {
813 auditEvent.fillFields();
814 prevVerAudit.add(auditEvent.getFields());
825 * - modifier data (userId)
826 * @return Either<Service, responseFormat>
828 public Either<Service, ResponseFormat> createService(Service service, User user) {
831 user = validateUser(user, "Create Service", service, AuditingActionEnum.CREATE_RESOURCE, false);
832 log.debug("User returned from validation: "+ user.toString());
833 // validate user role
834 validateUserRole(user, service, new ArrayList<>(), AuditingActionEnum.CREATE_RESOURCE, null);
835 service.setCreatorUserId(user.getUserId());
836 // warn on overridden fields
837 checkFieldsForOverideAttampt(service);
839 log.debug("enrich service with version and state");
840 service.setState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
841 service.setVersion(INITIAL_VERSION);
842 service.setConformanceLevel(ConfigurationManager.getConfigurationManager().getConfiguration().getToscaConformanceLevel());
843 service.setDistributionStatus(DistributionStatusEnum.DISTRIBUTION_NOT_APPROVED);
844 service.setComponentType(ComponentTypeEnum.SERVICE);
845 Either<Service, ResponseFormat> createServiceResponse = validateServiceBeforeCreate(service, user, AuditingActionEnum.CREATE_RESOURCE);
846 if (createServiceResponse.isRight()) {
847 return createServiceResponse;
849 return createServiceByDao(service, user)
851 .bind(c -> updateCatalog(c, ChangeTypeEnum.LIFECYCLE)
853 .map (r -> (Service) r));
856 private void checkFieldsForOverideAttampt(Service service) {
857 checkComponentFieldsForOverrideAttempt(service);
858 if (service.getDistributionStatus() != null) {
859 log.info("Distribution Status cannot be defined by user. This field will be overridden by the application");
863 private Either<Service, ResponseFormat> createServiceByDao(final Service service, final User user) {
864 log.debug("send service {} to dao for create", service.getComponentMetadataDefinition().getMetadataDataDefinition().getName());
866 Either<Boolean, ResponseFormat> lockResult = lockComponentByName(service.getSystemName(), service, "Create Service");
867 if (lockResult.isRight()) {
868 ResponseFormat responseFormat = lockResult.right().value();
869 componentsUtils.auditComponentAdmin(responseFormat, user, service, AuditingActionEnum.CREATE_RESOURCE,
870 ComponentTypeEnum.SERVICE);
871 return Either.right(responseFormat);
874 log.debug("System name locked is {}, status = {}", service.getSystemName(), lockResult);
877 createMandatoryArtifactsData(service, user);
878 createServiceApiArtifactsData(service, user);
879 setToscaArtifactsPlaceHolders(service, user);
880 final Resource genericType = fetchAndSetDerivedFromGenericType(service);
881 generatePropertiesFromGenericType(service, genericType);
882 generateAndAddInputsFromGenericTypeProperties(service, genericType);
883 beforeCreate(service);
885 Either<Service, StorageOperationStatus> dataModelResponse = toscaOperationFacade.createToscaComponent(service);
886 if (dataModelResponse.isLeft()) {
887 log.debug("Service '{}' created successfully", service.getName());
888 ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.CREATED);
889 componentsUtils.auditComponentAdmin(responseFormat, user, service, AuditingActionEnum.CREATE_RESOURCE,
890 ComponentTypeEnum.SERVICE);
891 ASDCKpiApi.countCreatedServicesKPI();
892 return Either.left(dataModelResponse.left().value());
894 ResponseFormat responseFormat = componentsUtils.getResponseFormatByComponent(componentsUtils.convertFromStorageResponse(dataModelResponse.right().value()), service, ComponentTypeEnum.SERVICE);
895 log.debug(AUDIT_BEFORE_SENDING_RESPONSE);
896 componentsUtils.auditComponentAdmin(responseFormat, user, service, AuditingActionEnum.CREATE_RESOURCE,
897 ComponentTypeEnum.SERVICE);
898 return Either.right(responseFormat);
900 graphLockOperation.unlockComponentByName(service.getSystemName(), service.getUniqueId(), NodeTypeEnum.Service);
904 private void beforeCreate(final Service service) {
905 if (CollectionUtils.isEmpty(serviceCreationPluginList)) {
908 serviceCreationPluginList.stream()
909 .sorted(Comparator.comparingInt(ServiceCreationPlugin::getOrder))
910 .forEach(serviceCreationPlugin -> {
912 serviceCreationPlugin.beforeCreate(service);
913 } catch (final Exception e) {
914 log.error("An error has occurred while running the serviceCreationPlugin '{}'",
915 serviceCreationPlugin.getClass(), e);
920 private void generatePropertiesFromGenericType(final Service service, final Resource genericType) {
921 if (CollectionUtils.isEmpty(genericType.getProperties())) {
924 final List<PropertyDefinition> genericTypePropertyList = genericType.getProperties().stream()
925 .map(PropertyDefinition::new)
926 .peek(propertyDefinition -> propertyDefinition.setUniqueId(null))
927 .collect(Collectors.toList());
928 if (service.getProperties() == null) {
929 service.setProperties(new ArrayList<>(genericTypePropertyList));
931 List<PropertyDefinition> servicePropertyList = service.getProperties();
932 genericTypePropertyList.stream()
933 .filter(property -> servicePropertyList.stream()
934 .noneMatch(property1 -> property1.getName().equals(property.getName())))
935 .forEach(servicePropertyList::add);
938 service.getProperties().forEach(propertyDefinition -> propertyDefinition.setUniqueId(null));
941 @SuppressWarnings("unchecked")
942 private void createServiceApiArtifactsData(Service service, User user) {
943 // create mandatory artifacts
945 // TODO it must be removed after that artifact uniqueId creation will be
946 // moved to ArtifactOperation
947 String serviceUniqueId = service.getUniqueId();
948 Map<String, ArtifactDefinition> artifactMap = service.getServiceApiArtifacts();
949 if (artifactMap == null)
950 artifactMap = new HashMap<>();
952 Map<String, Object> serviceApiArtifacts = ConfigurationManager.getConfigurationManager().getConfiguration().getServiceApiArtifacts();
953 List<String> exludeServiceCategory = ConfigurationManager.getConfigurationManager().getConfiguration().getExcludeServiceCategory();
955 List<CategoryDefinition> categories = service.getCategories();
956 boolean isCreateArtifact = true;
957 if (categories != null && exludeServiceCategory != null && !exludeServiceCategory.isEmpty()) {
958 for (String exlude : exludeServiceCategory) {
959 if (exlude.equalsIgnoreCase(categories.get(0).getName())) {
960 isCreateArtifact = false;
967 if (serviceApiArtifacts != null && isCreateArtifact) {
968 Set<String> keys = serviceApiArtifacts.keySet();
969 for (String serviceApiArtifactName : keys) {
970 Map<String, Object> artifactInfoMap = (Map<String, Object>) serviceApiArtifacts.get(serviceApiArtifactName);
971 ArtifactDefinition artifactDefinition = createArtifactDefinition(serviceUniqueId, serviceApiArtifactName, artifactInfoMap, user, true);
972 artifactDefinition.setArtifactGroupType(ArtifactGroupTypeEnum.SERVICE_API);
973 artifactMap.put(artifactDefinition.getArtifactLabel(), artifactDefinition);
976 service.setServiceApiArtifacts(artifactMap);
981 protected Either<Service, ResponseFormat> validateServiceBeforeCreate(Service service, User user, AuditingActionEnum actionEnum) {
984 serviceValidator.validate(user,service,actionEnum);
985 } catch (ComponentException exp) {
986 ResponseFormat responseFormat = componentsUtils.getResponseFormat(exp);
987 componentsUtils.auditComponentAdmin(responseFormat, user, service,
988 AuditingActionEnum.CREATE_SERVICE, ComponentTypeEnum.SERVICE);
992 service.setCreatorFullName(user.getFirstName() + " " + user.getLastName());
993 service.setContactId(service.getContactId().toLowerCase());
995 // Generate invariant UUID - must be here and not in operation since it
996 // should stay constant during clone
997 String invariantUUID = UniqueIdBuilder.buildInvariantUUID();
998 service.setInvariantUUID(invariantUUID);
1000 return Either.left(service);
1003 public Either<Map<String, Boolean>, ResponseFormat> validateServiceNameExists(String serviceName, String userId) {
1004 validateUserExists(userId);
1006 Either<Boolean, StorageOperationStatus> dataModelResponse = toscaOperationFacade.validateComponentNameUniqueness(serviceName, null, ComponentTypeEnum.SERVICE);
1008 janusGraphDao.commit();
1010 if (dataModelResponse.isLeft()) {
1011 Map<String, Boolean> result = new HashMap<>();
1012 result.put(IS_VALID, dataModelResponse.left().value());
1013 log.debug("validation was successfully performed.");
1014 return Either.left(result);
1016 ResponseFormat responseFormat = componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(dataModelResponse.right().value()));
1017 return Either.right(responseFormat);
1020 public void setElementDao(IElementOperation elementDao) {
1021 this.elementDao = elementDao;
1025 public void setCassandraAuditingDao(AuditCassandraDao auditingDao) {
1026 this.auditCassandraDao = auditingDao;
1029 public ArtifactsBusinessLogic getArtifactBl() {
1030 return artifactsBusinessLogic;
1033 public void setArtifactBl(ArtifactsBusinessLogic artifactBl) {
1034 this.artifactsBusinessLogic = artifactBl;
1037 public Either<Service, ResponseFormat> updateServiceMetadata(String serviceId, Service serviceUpdate, User user) {
1038 user = validateUser(user, "updateServiceMetadata", serviceUpdate, null, false);
1039 // validate user role
1040 validateUserRole(user, serviceUpdate, new ArrayList<>(), null, null);
1042 Either<Service, StorageOperationStatus> storageStatus = toscaOperationFacade.getToscaElement(serviceId);
1043 if (storageStatus.isRight()) {
1044 return Either.right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(storageStatus.right().value(), ComponentTypeEnum.SERVICE), ""));
1047 Service currentService = storageStatus.left().value();
1049 if (!ComponentValidationUtils.canWorkOnComponent(currentService, user.getUserId())) {
1050 log.info("Restricted operation for user: {}, on service: {}", user.getUserId(), currentService.getCreatorUserId());
1051 return Either.right(componentsUtils.getResponseFormat(ActionStatus.RESTRICTED_OPERATION));
1054 Either<Service, ResponseFormat> validationRsponse = validateAndUpdateServiceMetadata(user, currentService, serviceUpdate);
1055 if (validationRsponse.isRight()) {
1056 log.info("service update metadata: validations field.");
1057 return validationRsponse;
1059 Service serviceToUpdate = validationRsponse.left().value();
1062 lockComponent(serviceId, currentService, "Update Service Metadata");
1064 return toscaOperationFacade.updateToscaElement(serviceToUpdate)
1067 janusGraphDao.rollback();
1068 BeEcompErrorManager.getInstance().logBeSystemError("Update Service Metadata");
1069 log.debug("failed to update sevice {}", serviceToUpdate.getUniqueId());
1070 return (componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR));
1073 .bind(c -> updateCatalogAndCommit(c));
1076 graphLockOperation.unlockComponent(serviceId, NodeTypeEnum.Service);
1080 private Either<Service, ResponseFormat> updateCatalogAndCommit(Service service){
1081 Either<Service, ResponseFormat> res = updateCatalog(service, ChangeTypeEnum.LIFECYCLE).left().map(s -> (Service)s);
1082 janusGraphDao.commit();
1087 public Set<String> deleteForwardingPaths(String serviceId, Set<String> pathIdsToDelete, User user, boolean lock) {
1088 Service serviceToDelete = initServiceToDeletePaths(serviceId, pathIdsToDelete);
1089 user = validateUser(user, "deleteForwardingPaths", serviceToDelete, null, false);
1090 // validate user role
1091 validateUserRole(user, serviceToDelete, new ArrayList<>(), null, null);
1092 Either<Service, StorageOperationStatus> storageStatus = toscaOperationFacade.getToscaElement(serviceId);
1093 if (storageStatus.isRight()) {
1094 throw new ByActionStatusComponentException(componentsUtils.convertFromStorageResponse(storageStatus.right().value(), ComponentTypeEnum.SERVICE), "");
1096 Service service = storageStatus.left().value();
1097 Either<Set<String>, StorageOperationStatus> result = null;
1100 lockComponent(service.getUniqueId(), service, "Delete Forwarding Path on Service");
1101 } catch (ComponentException e) {
1102 janusGraphDao.rollback();
1103 throw new ByActionStatusComponentException(componentsUtils.convertFromStorageResponse
1104 (storageStatus.right().value(), ComponentTypeEnum.SERVICE), "");
1108 result = forwardingPathOperation.deleteForwardingPath(service ,pathIdsToDelete);
1109 if (result.isRight()) {
1110 log.debug(FAILED_TO_LOCK_SERVICE_RESPONSE_IS, service.getName(), result.right().value());
1111 janusGraphDao.rollback();
1112 throw new ByActionStatusComponentException(componentsUtils.convertFromStorageResponse
1113 (storageStatus.right().value(), ComponentTypeEnum.SERVICE));
1115 janusGraphDao.commit();
1116 log.debug(THE_SERVICE_WITH_SYSTEM_NAME_LOCKED, service.getSystemName());
1118 } catch (ComponentException e){
1119 log.error("Exception occurred during delete forwarding path : {}", e.getMessage(), e);
1120 janusGraphDao.rollback();
1121 throw new ByActionStatusComponentException(ActionStatus.GENERAL_ERROR);
1123 graphLockOperation.unlockComponent(service.getUniqueId(), NodeTypeEnum.Service);
1125 return result.left().value();
1128 private Service initServiceToDeletePaths(String serviceId, Collection<String> pathIdsToDelete) {
1129 Service serviceToDelete = new Service();
1130 serviceToDelete.setUniqueId(serviceId);
1131 serviceToDelete.setForwardingPaths(new HashMap<>());
1132 pathIdsToDelete.forEach(pathIdToDelete -> serviceToDelete.getForwardingPaths().put(pathIdToDelete, new ForwardingPathDataDefinition()));
1133 return serviceToDelete;
1136 public Service updateForwardingPath(String serviceId, Service serviceUpdate, User user, boolean lock) {
1137 return createOrUpdateForwardingPath(serviceId, serviceUpdate, user, true,"updateForwardingPath", lock);
1140 public Service createForwardingPath(String serviceId, Service serviceUpdate, User user, boolean lock) {
1141 return createOrUpdateForwardingPath(serviceId, serviceUpdate, user, false, "createForwardingPath", lock);
1144 private ForwardingPathDataDefinition getTrimmedValues(ForwardingPathDataDefinition path){
1145 ForwardingPathDataDefinition dataDefinition = new ForwardingPathDataDefinition(path.getName());
1146 dataDefinition.setName(Strings.nullToEmpty(path.getName()).trim());
1147 dataDefinition.setProtocol(Strings.nullToEmpty(path.getProtocol()).trim());
1148 dataDefinition.setDestinationPortNumber(Strings.nullToEmpty(path.getDestinationPortNumber()).trim());
1149 dataDefinition.setUniqueId(path.getUniqueId());
1150 dataDefinition.setPathElements(path.getPathElements());
1151 dataDefinition.setDescription(path.getDescription());
1152 dataDefinition.setToscaResourceName(path.getToscaResourceName());
1153 return dataDefinition;
1156 private Service createOrUpdateForwardingPath(String serviceId, Service serviceUpdate, User user, boolean isUpdate, String errorContext, boolean lock) {
1157 validateUserAndRole(serviceUpdate, user, errorContext);
1159 Map<String, ForwardingPathDataDefinition> forwardingPaths = serviceUpdate.getForwardingPaths();
1161 Map<String, ForwardingPathDataDefinition> trimmedForwardingPaths =
1162 forwardingPaths.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey,
1163 entry -> new ForwardingPathDataDefinition(getTrimmedValues(entry.getValue()))));
1165 forwardingPathValidator.validateForwardingPaths(trimmedForwardingPaths.values(),
1166 serviceId, isUpdate);
1168 Either<Service, StorageOperationStatus> serviceStorageOperationStatusEither = toscaOperationFacade.getToscaElement(serviceId);
1170 if(serviceStorageOperationStatusEither.isRight()){
1171 StorageOperationStatus errorStatus = serviceStorageOperationStatusEither.right().value();
1172 log.debug("Failed to fetch service information by service id, error {}", errorStatus);
1173 throw new ByActionStatusComponentException(componentsUtils.convertFromStorageResponse(errorStatus));
1175 Service storedService = serviceStorageOperationStatusEither.left().value();
1177 Either<ForwardingPathDataDefinition, StorageOperationStatus> result;
1178 Component component = getForwardingPathOriginComponent();
1179 final String toscaResourceName;
1180 if ( component.getComponentType() == ComponentTypeEnum.RESOURCE) {
1181 toscaResourceName = ((Resource) component).getToscaResourceName();
1183 toscaResourceName = "";
1186 lockComponent(storedService.getUniqueId(), storedService, "Add or Update Forwarding Path on Service");
1187 log.debug(THE_SERVICE_WITH_SYSTEM_NAME_LOCKED, storedService.getSystemName());
1189 Map<String, ForwardingPathDataDefinition> resultMap = new HashMap<>();
1191 trimmedForwardingPaths.values().forEach(fp -> fp.setToscaResourceName(toscaResourceName));
1193 populateForwardingPaths(serviceId, isUpdate, trimmedForwardingPaths, resultMap);
1194 janusGraphDao.commit();
1197 graphLockOperation.unlockComponent(storedService.getUniqueId(), NodeTypeEnum.Service);
1200 return createServiceWithForwardingPathForResponse(serviceId, resultMap);
1203 private Component getForwardingPathOriginComponent() {
1204 Either<Component, StorageOperationStatus> forwardingPathOrigin = toscaOperationFacade.getLatestByName(ForwardingPathUtils.FORWARDING_PATH_NODE_NAME);
1205 if (forwardingPathOrigin.isRight()) {
1206 StorageOperationStatus errorStatus = forwardingPathOrigin.right().value();
1207 log.debug("Failed to fetch normative forwarding path resource by tosca name, error {}", errorStatus);
1208 throw new ByActionStatusComponentException(componentsUtils.convertFromStorageResponse(errorStatus));
1210 return forwardingPathOrigin.left().value();
1213 private void populateForwardingPaths(String serviceId, boolean isUpdate, Map<String, ForwardingPathDataDefinition> trimmedForwardingPaths, Map<String, ForwardingPathDataDefinition> resultMap) {
1214 Either<ForwardingPathDataDefinition, StorageOperationStatus> result;
1216 for (ForwardingPathDataDefinition forwardingPathDataDefinition : trimmedForwardingPaths.values()) {
1218 result = forwardingPathOperation.updateForwardingPath(serviceId, forwardingPathDataDefinition);
1220 result = forwardingPathOperation.addForwardingPath(serviceId, forwardingPathDataDefinition);
1222 if (result.isRight()) {
1223 janusGraphDao.rollback();
1224 throw new ByResponseFormatComponentException(componentsUtils.getResponseFormat(
1225 componentsUtils.convertFromStorageResponse(result.right().value(), ComponentTypeEnum.SERVICE),
1228 ForwardingPathDataDefinition fpDataDefinition = result.left().value();
1229 resultMap.put(fpDataDefinition.getUniqueId(), forwardingPathDataDefinition);
1233 } catch (ComponentException e) {
1234 janusGraphDao.rollback();
1235 log.error("Exception occurred during add or update forwarding path property values: {}",
1237 throw new ByActionStatusComponentException(ActionStatus.GENERAL_ERROR);
1241 private Service createServiceWithForwardingPathForResponse(String serviceId, Map<String,ForwardingPathDataDefinition> forwardingPathDataDefinitionMap) {
1242 Service service = new Service();
1243 service.setUniqueId(serviceId);
1244 service.setForwardingPaths(forwardingPathDataDefinitionMap);
1248 private void validateUserAndRole(Service serviceUpdate, User user, String errorContext) {
1249 user = validateUser(user, errorContext, serviceUpdate, null, false);
1250 validateUserRole(user, serviceUpdate, new ArrayList<>(), null, null);
1254 Either<Service, ResponseFormat> validateAndUpdateServiceMetadata(User user, Service currentService, Service serviceUpdate) {
1257 boolean hasBeenCertified = ValidationUtils.hasBeenCertified(currentService.getVersion());
1258 Either<Boolean, ResponseFormat> response = validateAndUpdateCategory(user, currentService, serviceUpdate, hasBeenCertified, UPDATE_SERVICE_METADATA);
1259 if (response.isRight()) {
1260 ResponseFormat errorResponse = response.right().value();
1261 return Either.right(errorResponse);
1264 verifyValuesAreIdentical(serviceUpdate.getCreatorUserId(), currentService.getCreatorUserId(), "creatorUserId");
1265 verifyValuesAreIdentical(serviceUpdate.getCreatorFullName(), currentService.getCreatorFullName(), "creatorFullName");
1266 verifyValuesAreIdentical(serviceUpdate.getLastUpdaterUserId(), currentService.getLastUpdaterUserId(), "lastUpdaterUserId");
1267 verifyValuesAreIdentical(serviceUpdate.getLastUpdaterFullName(), currentService.getLastUpdaterFullName(), "lastUpdaterFullName");
1269 response = validateAndUpdateServiceName(user, currentService, serviceUpdate, hasBeenCertified, null);
1270 if (response.isRight()) {
1271 return Either.right(response.right().value());
1274 verifyValuesAreIdentical(serviceUpdate.getDistributionStatus(), currentService.getDistributionStatus(), "distributionStatus");
1276 if (serviceUpdate.getProjectCode() != null) {
1277 response = validateAndUpdateProjectCode(user, currentService, serviceUpdate, UPDATE_SERVICE_METADATA);
1278 if (response.isRight()) {
1279 return Either.right(response.right().value());
1283 response = validateAndUpdateIcon(user, currentService, serviceUpdate, hasBeenCertified, UPDATE_SERVICE_METADATA);
1284 if (response.isRight()) {
1285 return Either.right(response.right().value());
1288 verifyValuesAreIdentical(serviceUpdate.getCreationDate(), currentService.getCreationDate(), "creationDate");
1289 verifyValuesAreIdentical(serviceUpdate.getVersion(), currentService.getVersion(), "version");
1291 response = validateAndUpdateDescription(user, currentService, serviceUpdate, UPDATE_SERVICE_METADATA);
1292 if (response.isRight()) {
1293 return Either.right(response.right().value());
1296 response = validateAndUpdateTags(user, currentService, serviceUpdate, UPDATE_SERVICE_METADATA);
1297 if (response.isRight()) {
1298 return Either.right(response.right().value());
1301 response = validateAndUpdateContactId(user, currentService, serviceUpdate, UPDATE_SERVICE_METADATA);
1302 if (response.isRight()) {
1303 return Either.right(response.right().value());
1306 verifyValuesAreIdentical(serviceUpdate.getLastUpdateDate(), currentService.getLastUpdateDate(), "lastUpdateDate");
1307 verifyValuesAreIdentical(serviceUpdate.getLifecycleState(), currentService.getLifecycleState(), "lifecycleState");
1308 verifyValuesAreIdentical(serviceUpdate.isHighestVersion(), currentService.isHighestVersion(), "isHighestVersion");
1309 verifyValuesAreIdentical(serviceUpdate.getUUID(), currentService.getUUID(), "uuid");
1311 validateAndUpdateServiceType(currentService, serviceUpdate);
1312 validateAndUpdateServiceFunction(currentService, serviceUpdate);
1314 response = validateAndUpdateServiceRole(user, currentService, serviceUpdate, UPDATE_SERVICE_METADATA);
1315 if (response.isRight()) {
1316 return Either.right(response.right().value());
1319 response = validateAndUpdateInstantiationTypeValue(user, currentService, serviceUpdate, UPDATE_SERVICE_METADATA);
1320 if (response.isRight()) {
1321 return Either.right(response.right().value());
1324 verifyValuesAreIdentical(serviceUpdate.getInvariantUUID(), currentService.getInvariantUUID(), "invariantUUID");
1326 validateAndUpdateEcompNaming(currentService, serviceUpdate);
1328 currentService.setEnvironmentContext(serviceUpdate.getEnvironmentContext());
1329 currentService.setCategorySpecificMetadata(serviceUpdate.getCategorySpecificMetadata());
1330 return Either.left(currentService);
1332 } catch (ComponentException exception) {
1333 ResponseFormat responseFormat = componentsUtils.getResponseFormat(exception);
1334 componentsUtils.auditComponentAdmin(responseFormat, user, serviceUpdate,
1335 AuditingActionEnum.UPDATE_SERVICE_METADATA, ComponentTypeEnum.SERVICE);
1336 return Either.right(responseFormat);
1340 private void verifyValuesAreIdentical(Object updatedValue, Object originalValue, String fieldName) {
1341 if (updatedValue != null && !updatedValue.equals(originalValue)) {
1342 log.info("update service: received request to update {} to {} the field is not updatable ignoring.", fieldName, updatedValue);
1346 private void validateAndUpdateEcompNaming(Service currentService, Service serviceUpdate) {
1347 Boolean isEcompGeneratedCurr = currentService.isEcompGeneratedNaming();
1348 Boolean isEcompGeneratedUpdate = serviceUpdate.isEcompGeneratedNaming();
1349 if (isEcompGeneratedUpdate != null && !isEcompGeneratedUpdate.equals(isEcompGeneratedCurr)) {
1350 currentService.setEcompGeneratedNaming(isEcompGeneratedUpdate);
1352 String namingPolicyUpdate = serviceUpdate.getNamingPolicy();
1353 if (currentService.isEcompGeneratedNaming() != null && currentService.isEcompGeneratedNaming()) {
1354 currentService.setNamingPolicy(namingPolicyUpdate);
1356 if (!StringUtils.isEmpty(namingPolicyUpdate)) {
1357 log.warn("NamingPolicy must be empty for EcompGeneratedNaming=false");
1359 currentService.setNamingPolicy("");
1363 private Either<Boolean, ResponseFormat> validateAndUpdateContactId(User user, Service currentService, Service serviceUpdate, AuditingActionEnum audatingAction) {
1364 String contactIdUpdated = serviceUpdate.getContactId();
1365 String contactIdCurrent = currentService.getContactId();
1366 if (!contactIdCurrent.equals(contactIdUpdated)) {
1367 componentContactIdValidator.validateAndCorrectField(user, serviceUpdate, audatingAction);
1368 currentService.setContactId(contactIdUpdated.toLowerCase());
1370 return Either.left(true);
1373 private Either<Boolean, ResponseFormat> validateAndUpdateTags(User user, Service currentService, Service serviceUpdate, AuditingActionEnum audatingAction) {
1374 List<String> tagsUpdated = serviceUpdate.getTags();
1375 List<String> tagsCurrent = currentService.getTags();
1376 if (tagsUpdated == null || tagsUpdated.isEmpty()) {
1377 ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.COMPONENT_MISSING_TAGS);
1378 componentsUtils.auditComponentAdmin(responseFormat, user, serviceUpdate, audatingAction, ComponentTypeEnum.SERVICE);
1379 return Either.right(responseFormat);
1382 if (!(tagsCurrent.containsAll(tagsUpdated) && tagsUpdated.containsAll(tagsCurrent))) {
1383 componentTagsValidator.validateAndCorrectField(user, serviceUpdate, audatingAction);
1384 currentService.setTags(tagsUpdated);
1386 return Either.left(true);
1389 private Either<Boolean, ResponseFormat> validateAndUpdateDescription(User user, Service currentService, Service serviceUpdate, AuditingActionEnum audatingAction) {
1390 String descriptionUpdated = serviceUpdate.getDescription();
1391 String descriptionCurrent = currentService.getDescription();
1392 if (!descriptionCurrent.equals(descriptionUpdated)) {
1393 componentDescriptionValidator.validateAndCorrectField(user, serviceUpdate, audatingAction);
1394 currentService.setDescription(serviceUpdate.getDescription());
1396 return Either.left(true);
1399 private Either<Boolean, ResponseFormat> validateAndUpdateProjectCode(User user, Service currentService, Service serviceUpdate, AuditingActionEnum audatingAction) {
1400 String projectCodeUpdated = serviceUpdate.getProjectCode();
1401 String projectCodeCurrent = currentService.getProjectCode();
1402 if (StringUtils.isEmpty(projectCodeCurrent)
1403 || !projectCodeCurrent.equals(projectCodeUpdated)) {
1406 componentProjectCodeValidator.validateAndCorrectField(user, serviceUpdate, audatingAction);
1407 } catch (ComponentException exp) {
1408 ResponseFormat errorRespons = exp.getResponseFormat();
1409 return Either.right(errorRespons);
1411 currentService.setProjectCode(projectCodeUpdated);
1414 return Either.left(true);
1417 private Either<Boolean, ResponseFormat> validateAndUpdateIcon(User user, Service currentService, Service serviceUpdate, boolean hasBeenCertified, AuditingActionEnum audatingAction) {
1418 String iconUpdated = serviceUpdate.getIcon();
1419 String iconCurrent = currentService.getIcon();
1420 if (!iconCurrent.equals(iconUpdated)) {
1421 if (!hasBeenCertified) {
1422 componentIconValidator.validateAndCorrectField(user, serviceUpdate, audatingAction);
1423 currentService.setIcon(iconUpdated);
1425 log.info("icon {} cannot be updated once the service has been certified once.", iconUpdated);
1426 ResponseFormat errorResponse = componentsUtils.getResponseFormat(ActionStatus.SERVICE_ICON_CANNOT_BE_CHANGED);
1427 return Either.right(errorResponse);
1430 return Either.left(true);
1433 private Either<Boolean, ResponseFormat> validateAndUpdateServiceName(User user, Service currentService, Service serviceUpdate, boolean hasBeenCertified, AuditingActionEnum auditingAction) {
1434 String serviceNameUpdated = serviceUpdate.getName();
1435 String serviceNameCurrent = currentService.getName();
1436 if (!serviceNameCurrent.equals(serviceNameUpdated)) {
1437 if (!hasBeenCertified) {
1438 componentNameValidator.validateAndCorrectField(user, serviceUpdate, auditingAction);
1440 componentNameValidator.validateComponentNameUnique(user, serviceUpdate, auditingAction);
1441 } catch (ComponentException exp) {
1442 return Either.right(exp.getResponseFormat());
1444 currentService.setName(serviceNameUpdated);
1445 currentService.getComponentMetadataDefinition().getMetadataDataDefinition().setNormalizedName(ValidationUtils.normaliseComponentName(serviceNameUpdated));
1446 currentService.getComponentMetadataDefinition().getMetadataDataDefinition().setSystemName(ValidationUtils.convertToSystemName(serviceNameUpdated));
1449 log.info("service name {} cannot be updated once the service has been certified once.", serviceNameUpdated);
1450 ResponseFormat errorResponse = componentsUtils.getResponseFormat(ActionStatus.SERVICE_NAME_CANNOT_BE_CHANGED);
1451 return Either.right(errorResponse);
1454 return Either.left(true);
1457 private void validateAndUpdateServiceType(Service currentService, Service updatedService) {
1458 String updatedServiceType = updatedService.getServiceType();
1459 String currentServiceType = currentService.getServiceType();
1460 if (!currentServiceType.equals(updatedServiceType)) {
1461 serviceTypeValidator.validateAndCorrectField(null, updatedService, null);
1462 currentService.setServiceType(updatedServiceType);
1466 private void validateAndUpdateServiceFunction(Service currentService, Service updatedService) {
1467 String updatedServiceFunction = updatedService.getServiceFunction();
1468 String currentServiceFunction = currentService.getServiceFunction();
1469 if (!currentServiceFunction.equals(updatedServiceFunction)) {
1470 serviceFunctionValidator.validateAndCorrectField(null, updatedService, null);
1471 currentService.setServiceFunction(updatedService.getServiceFunction());
1475 private Either<Boolean, ResponseFormat> validateAndUpdateServiceRole(User user, Service currentService, Service updatedService, AuditingActionEnum auditingAction) {
1476 String updatedServiceRole = updatedService.getServiceRole();
1477 String currentServiceRole = currentService.getServiceRole();
1478 if (!currentServiceRole.equals(updatedServiceRole)) {
1480 serviceRoleValidator.validateAndCorrectField(user, updatedService, auditingAction);
1481 } catch (ComponentException exp) {
1482 ResponseFormat errorResponse = exp.getResponseFormat();
1483 componentsUtils.auditComponentAdmin(errorResponse, user, updatedService, auditingAction, ComponentTypeEnum.SERVICE);
1484 return Either.right(errorResponse);
1486 currentService.setServiceRole(updatedServiceRole);
1488 return Either.left(true);
1491 private Either<Boolean, ResponseFormat> validateAndUpdateInstantiationTypeValue(User user, Service currentService, Service updatedService, AuditingActionEnum auditingAction) {
1492 String updatedInstaType= updatedService.getInstantiationType();
1493 String currentInstaType = currentService.getInstantiationType();
1494 if (!currentInstaType.equals(updatedInstaType)) {
1496 serviceInstantiationTypeValidator.validateAndCorrectField(user, updatedService, auditingAction);
1497 } catch (ComponentException exp) {
1498 ResponseFormat errorResponse = exp.getResponseFormat();
1499 componentsUtils.auditComponentAdmin(errorResponse, user, updatedService, auditingAction, ComponentTypeEnum.SERVICE);
1500 return Either.right(errorResponse);
1502 currentService.setInstantiationType(updatedInstaType);
1504 return Either.left(true);
1507 private Either<Boolean, ResponseFormat> validateAndUpdateCategory(User user, Service currentService, Service serviceUpdate, boolean hasBeenCertified, AuditingActionEnum audatingAction) {
1509 List<CategoryDefinition> categoryUpdated = serviceUpdate.getCategories();
1510 List<CategoryDefinition> categoryCurrent = currentService.getCategories();
1511 serviceCategoryValidator.validateAndCorrectField(user, serviceUpdate, audatingAction);
1512 if (!categoryCurrent.get(0).getName().equals(categoryUpdated.get(0).getName())) {
1513 if (!hasBeenCertified) {
1514 currentService.setCategories(categoryUpdated);
1516 log.info("category {} cannot be updated once the service has been certified once.", categoryUpdated);
1517 ResponseFormat errorResponse = componentsUtils.getResponseFormat(ActionStatus.SERVICE_CATEGORY_CANNOT_BE_CHANGED);
1518 return Either.right(errorResponse);
1521 } catch (ComponentException exp) {
1522 return Either.right(exp.getResponseFormat());
1524 return Either.left(true);
1528 public Either<ServiceRelations, ResponseFormat> getServiceComponentsRelations(String serviceId, User user) {
1529 Either<Service, ResponseFormat> serviceResponseFormatEither = getService(serviceId, user);
1530 if (serviceResponseFormatEither.isRight()){
1531 return Either.right(serviceResponseFormatEither.right().value());
1533 final ServiceRelations serviceRelations = new ForwardingPathUtils().convertServiceToServiceRelations(serviceResponseFormatEither.left().value());
1534 return Either.left(serviceRelations);
1539 public ResponseFormat deleteService(String serviceId, User user) {
1540 ResponseFormat responseFormat;
1542 validateUserExists(user);
1543 Either<Service, StorageOperationStatus> serviceStatus = toscaOperationFacade.getToscaElement(serviceId);
1544 if (serviceStatus.isRight()) {
1545 log.debug("failed to get service {}", serviceId);
1546 return componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(serviceStatus.right().value()), "");
1549 Service service = serviceStatus.left().value();
1551 StorageOperationStatus result = StorageOperationStatus.OK;
1553 lockComponent(service, "Mark service to delete");
1554 result = markComponentToDelete(service);
1555 if (result == StorageOperationStatus.OK) {
1556 responseFormat = componentsUtils.getResponseFormat(ActionStatus.NO_CONTENT);
1558 ActionStatus actionStatus = componentsUtils.convertFromStorageResponse(result);
1559 responseFormat = componentsUtils.getResponseFormatByResource(actionStatus, service.getName());
1561 return responseFormat;
1562 }catch (ComponentException e){
1563 return e.getResponseFormat();
1565 if (result == null || result != StorageOperationStatus.OK) {
1566 log.warn("operation failed. do rollback");
1567 BeEcompErrorManager.getInstance().logBeSystemError("Delete Service");
1568 janusGraphDao.rollback();
1570 log.debug("operation success. do commit");
1571 janusGraphDao.commit();
1573 graphLockOperation.unlockComponent(serviceId, NodeTypeEnum.Service);
1577 public ResponseFormat deleteServiceByNameAndVersion(String serviceName, String version, User user) {
1578 ResponseFormat responseFormat;
1579 String ecompErrorContext = "delete service";
1580 validateUserNotEmpty(user, ecompErrorContext);
1581 user = validateUserExists(user);
1583 Either<Service, ResponseFormat> getResult = getServiceByNameAndVersion(serviceName, version, user.getUserId());
1584 if (getResult.isRight()) {
1585 return getResult.right().value();
1587 Service service = getResult.left().value();
1589 StorageOperationStatus result = StorageOperationStatus.OK;
1592 lockComponent(service, "Mark service to delete");
1593 result = markComponentToDelete(service);
1594 if (result == StorageOperationStatus.OK) {
1595 responseFormat = componentsUtils.getResponseFormat(ActionStatus.NO_CONTENT);
1597 ActionStatus actionStatus = componentsUtils.convertFromStorageResponse(result);
1598 responseFormat = componentsUtils.getResponseFormatByResource(actionStatus, service.getName());
1600 return responseFormat;
1602 }catch (ComponentException e){
1603 result = StorageOperationStatus.GENERAL_ERROR;
1604 return componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR);
1606 if (result == null || result != StorageOperationStatus.OK) {
1607 log.warn("operation failed. do rollback");
1608 BeEcompErrorManager.getInstance().logBeSystemError("Delete Service");
1609 janusGraphDao.rollback();
1611 log.debug("operation success. do commit");
1612 janusGraphDao.commit();
1614 graphLockOperation.unlockComponent(service.getUniqueId(), NodeTypeEnum.Service);
1618 public Either<Service, ResponseFormat> getService(String serviceId, User user) {
1619 String ecompErrorContext = "Get service";
1620 validateUserNotEmpty(user, ecompErrorContext);
1621 validateUserExists(user);
1623 Either<Service, StorageOperationStatus> storageStatus = toscaOperationFacade.getToscaElement(serviceId);
1624 if (storageStatus.isRight()) {
1625 log.debug("failed to get service by id {}", serviceId);
1626 return Either.right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(storageStatus.right().value(), ComponentTypeEnum.SERVICE), serviceId));
1629 if(!(storageStatus.left().value() instanceof Service)){
1630 return Either.right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(StorageOperationStatus.NOT_FOUND), serviceId));
1632 Service service = storageStatus.left().value();
1633 return Either.left(service);
1640 public Either<Service, ResponseFormat> getServiceByNameAndVersion(String serviceName, String serviceVersion, String userId) {
1641 validateUserExists(userId);
1642 Either<Service, StorageOperationStatus> storageStatus = toscaOperationFacade.getComponentByNameAndVersion(ComponentTypeEnum.SERVICE, serviceName, serviceVersion);
1643 if (storageStatus.isRight()) {
1644 log.debug("failed to get service by name {} and version {}", serviceName, serviceVersion);
1645 return Either.right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(storageStatus.right().value(), ComponentTypeEnum.SERVICE), serviceName));
1647 Service service = storageStatus.left().value();
1648 return Either.left(service);
1651 @SuppressWarnings("unchecked")
1652 private void createMandatoryArtifactsData(Service service, User user) {
1653 // create mandatory artifacts
1655 // TODO it must be removed after that artifact uniqueId creation will be
1656 // moved to ArtifactOperation
1657 String serviceUniqueId = service.getUniqueId();
1658 Map<String, ArtifactDefinition> artifactMap = service.getArtifacts();
1659 if (artifactMap == null)
1660 artifactMap = new HashMap<>();
1662 Map<String, Object> informationalServiceArtifacts = ConfigurationManager.getConfigurationManager().getConfiguration().getInformationalServiceArtifacts();
1663 List<String> exludeServiceCategory = ConfigurationManager.getConfigurationManager().getConfiguration().getExcludeServiceCategory();
1665 String category = service.getCategories().get(0).getName();
1666 boolean isCreateArtifact = true;
1667 if (category != null && exludeServiceCategory != null && !exludeServiceCategory.isEmpty()) {
1668 for (String exlude : exludeServiceCategory) {
1669 if (exlude.equalsIgnoreCase(category)) {
1670 isCreateArtifact = false;
1677 if (informationalServiceArtifacts != null && isCreateArtifact) {
1678 Set<String> keys = informationalServiceArtifacts.keySet();
1679 for (String informationalServiceArtifactName : keys) {
1680 Map<String, Object> artifactInfoMap = (Map<String, Object>) informationalServiceArtifacts.get(informationalServiceArtifactName);
1681 ArtifactDefinition artifactDefinition = createArtifactDefinition(serviceUniqueId, informationalServiceArtifactName, artifactInfoMap, user, false);
1682 artifactMap.put(artifactDefinition.getArtifactLabel(), artifactDefinition);
1686 service.setArtifacts(artifactMap);
1690 private ArtifactDefinition createArtifactDefinition(String serviceId, String logicalName, Map<String, Object> artifactInfoMap, User user, Boolean isServiceApi) {
1692 ArtifactDefinition artifactInfo = artifactsBusinessLogic.createArtifactPlaceHolderInfo(serviceId, logicalName, artifactInfoMap, user, ArtifactGroupTypeEnum.INFORMATIONAL);
1695 artifactInfo.setMandatory(false);
1696 artifactInfo.setServiceApi(true);
1698 return artifactInfo;
1701 private DistributionTransitionEnum validateTransitionEnum(String distributionTransition) {
1702 DistributionTransitionEnum transitionEnum;
1704 transitionEnum = DistributionTransitionEnum.getFromDisplayName(distributionTransition);
1705 if (transitionEnum == null) {
1706 BeEcompErrorManager.getInstance().logBeSystemError(CHANGE_SERVICE_DISTRIBUTION);
1707 log.info("state operation is not valid. operations allowed are: {}", DistributionTransitionEnum.valuesAsString());
1708 throw new ByResponseFormatComponentException(componentsUtils.getResponseFormat(ActionStatus.UNSUPPORTED_DISTRIBUTION_STATUS, distributionTransition));
1711 return transitionEnum;
1714 private String validateComment(LifecycleChangeInfoWithAction comment) {
1715 if (comment==null || StringUtils.isEmpty(comment.getUserRemarks())) {
1718 String data = comment.getUserRemarks();
1719 data = ValidationUtils.removeNoneUtf8Chars(data);
1720 data = ValidationUtils.removeHtmlTags(data);
1721 data = ValidationUtils.normaliseWhitespace(data);
1722 data = ValidationUtils.stripOctets(data);
1724 if (!ValidationUtils.validateLength(data, ValidationUtils.COMMENT_MAX_LENGTH)) {
1725 BeEcompErrorManager.getInstance().logBeInvalidJsonInput(CHANGE_SERVICE_DISTRIBUTION);
1726 log.debug("user comment exceeds limit.");
1727 throw new ByResponseFormatComponentException(componentsUtils.getResponseFormat(ActionStatus.EXCEEDS_LIMIT, "comment", String.valueOf(ValidationUtils.COMMENT_MAX_LENGTH)));
1729 if (!ValidationUtils.validateCommentPattern(data)) {
1730 throw new ByResponseFormatComponentException(componentsUtils.getResponseFormat(ActionStatus.INVALID_CONTENT));
1736 private void createAudit(User user, AuditingActionEnum auditAction, String comment, Service component, ResponseFormat responseFormat) {
1737 log.debug(AUDIT_BEFORE_SENDING_RESPONSE);
1738 componentsUtils.auditComponent(responseFormat, user, component, auditAction, new ResourceCommonInfo(ComponentTypeEnum.SERVICE.getValue()),
1739 ResourceVersionInfo.newBuilder()
1740 .state(component.getLifecycleState().name())
1741 .version(component.getVersion())
1746 private String getEnvNameFromConfiguration() {
1747 String configuredEnvName = ConfigurationManager.getConfigurationManager().getDistributionEngineConfiguration().getEnvironments().get(0);
1748 log.trace("Update environment name to be {}", configuredEnvName);
1749 return configuredEnvName;
1752 public Either<String, ResponseFormat> activateServiceOnTenantEnvironment(String serviceId, String envId, User modifier, ServiceDistributionReqInfo data) {
1754 Either<ActivationRequestInformation, ResponseFormat> activationRequestInformationEither = serviceDistributionValidation.validateActivateServiceRequest(serviceId, envId, modifier, data);
1755 if (activationRequestInformationEither.isRight()) {
1756 return Either.right(activationRequestInformationEither.right().value());
1759 ActivationRequestInformation activationRequestInformation = activationRequestInformationEither.left().value();
1761 String did = ThreadLocalsHolder.getUuid();
1762 Service service = activationRequestInformation.getServiceToActivate();
1763 return buildAndSendServiceNotification(service, envId, did, activationRequestInformation.getWorkloadContext(), modifier);
1766 private Either<String, ResponseFormat> buildAndSendServiceNotification(Service service, String envId, String did, String workloadContext, User modifier) {
1767 String envName = getEnvNameFromConfiguration();
1768 INotificationData notificationData = distributionEngine.buildServiceForDistribution(service, did, workloadContext);
1769 ActionStatus notifyServiceResponse = distributionEngine.notifyService(did, service, notificationData, envId, envName, modifier);
1770 if (notifyServiceResponse == ActionStatus.OK) {
1771 return Either.left(did);
1773 BeEcompErrorManager.getInstance().logBeSystemError("Activate Distribution - send notification");
1774 log.debug("distributionEngine.notifyService response is: {}", notifyServiceResponse);
1775 ResponseFormat error = componentsUtils.getResponseFormat(ActionStatus.INVALID_RESPONSE_FROM_PROXY);
1776 return Either.right(error);
1780 public Either<Service, ResponseFormat> activateDistribution(String serviceId, String envName, User modifier, HttpServletRequest request) {
1782 User user = validateUserExists(modifier.getUserId());
1783 validateUserRole(user, Collections.singletonList(Role.DESIGNER));
1784 Either<Service, ResponseFormat> result;
1785 ResponseFormat response;
1786 Service updatedService;
1787 String did = ThreadLocalsHolder.getUuid();
1789 String configuredEnvName = ConfigurationManager.getConfigurationManager().getDistributionEngineConfiguration().getEnvironments().get(0);
1790 if (configuredEnvName != null && !configuredEnvName.equals(envName)) {
1791 log.trace("Update environment name to be {} instead of {}", configuredEnvName, envName);
1792 envName = configuredEnvName;
1796 ServletContext servletContext = request.getSession().getServletContext();
1797 boolean isDistributionEngineUp = getHealthCheckBL(servletContext).isDistributionEngineUp(); // DE
1798 if (!isDistributionEngineUp) {
1799 BeEcompErrorManager.getInstance().logBeSystemError("Distribution Engine is DOWN");
1800 log.debug("Distribution Engine is DOWN");
1801 response = componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR);
1802 return Either.right(response);
1805 Either<Service, StorageOperationStatus> serviceRes = toscaOperationFacade.getToscaElement(serviceId);
1806 if (serviceRes.isRight()) {
1807 log.debug("failed retrieving service");
1808 response = componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(serviceRes.right().value(), ComponentTypeEnum.SERVICE), serviceId);
1809 componentsUtils.auditComponent(response, user, null, AuditingActionEnum.DISTRIBUTION_STATE_CHANGE_REQUEST,
1810 new ResourceCommonInfo(ComponentTypeEnum.SERVICE.getValue()),
1811 ResourceVersionInfo.newBuilder()
1814 return Either.right(response);
1816 Service service = serviceRes.left().value();
1817 if (service.isArchived()) {
1818 log.info("Component is archived. Component id: {}", serviceId);
1819 return Either.right(componentsUtils.getResponseFormat(ActionStatus.COMPONENT_IS_ARCHIVED, service.getName()));
1821 if (service.getLifecycleState() != LifecycleStateEnum.CERTIFIED) {
1822 log.info("service {} is not available for distribution. Should be in certified state", service.getUniqueId());
1823 ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.SERVICE_NOT_AVAILABLE_FOR_DISTRIBUTION, service.getVersion(), service.getName());
1824 return Either.right(responseFormat);
1826 String dcurrStatus = service.getDistributionStatus().name();
1827 String updatedStatus = dcurrStatus;
1828 StorageOperationStatus readyForDistribution = distributionEngine.isReadyForDistribution(envName);
1829 if (readyForDistribution == StorageOperationStatus.OK) {
1830 INotificationData notificationData = distributionEngine.buildServiceForDistribution(service, did, null);
1831 ActionStatus notifyServiceResponse = distributionEngine.notifyService(did, service, notificationData, envName, user);
1832 if (notifyServiceResponse == ActionStatus.OK) {
1833 Either<Service, ResponseFormat> updateStateRes = updateDistributionStatusForActivation(service, user, DistributionStatusEnum.DISTRIBUTED);
1834 if (updateStateRes.isLeft() && updateStateRes.left().value() != null) {
1835 updatedService = updateStateRes.left().value();
1836 updatedStatus = updatedService.getDistributionStatus().name();
1838 // The response is not relevant
1839 updatedService = service;
1841 ASDCKpiApi.countActivatedDistribution();
1842 response = componentsUtils.getResponseFormat(ActionStatus.OK);
1843 result = Either.left(updatedService);
1845 BeEcompErrorManager.getInstance().logBeSystemError("Activate Distribution - send notification");
1846 log.debug("distributionEngine.notifyService response is: {}", notifyServiceResponse);
1847 response = componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR);
1848 result = Either.right(response);
1851 response = componentsUtils.getResponseFormatByDE(componentsUtils.convertFromStorageResponse(readyForDistribution, ComponentTypeEnum.SERVICE), envName);
1852 result = Either.right(response);
1854 componentsUtils.auditComponent(response, user, service, AuditingActionEnum.DISTRIBUTION_STATE_CHANGE_REQUEST,
1855 new ResourceCommonInfo(service.getName(),ComponentTypeEnum.SERVICE.getValue()),
1856 ResourceVersionInfo.newBuilder()
1857 .distributionStatus(dcurrStatus)
1859 ResourceVersionInfo.newBuilder()
1860 .distributionStatus(updatedStatus)
1866 // convert to private after deletion of temp url
1867 public Either<Service, ResponseFormat> updateDistributionStatusForActivation(Service service, User user, DistributionStatusEnum state) {
1869 validateUserExists(user.getUserId());
1871 String serviceId = service.getUniqueId();
1872 lockComponent(serviceId, service, "updateDistributionStatusForActivation");
1874 Either<Service, StorageOperationStatus> result = toscaOperationFacade.updateDistributionStatus(service, user, state);
1875 if (result.isRight()) {
1876 janusGraphDao.rollback();
1877 BeEcompErrorManager.getInstance().logBeSystemError("updateDistributionStatusForActivation");
1878 log.debug("service {} change distribution status failed", serviceId);
1879 return Either.right(componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR));
1881 janusGraphDao.commit();
1882 updateCatalog(service, ChangeTypeEnum.LIFECYCLE);
1883 return Either.left(result.left().value());
1885 graphLockOperation.unlockComponent(serviceId, NodeTypeEnum.Service);
1889 public Either<Service, ResponseFormat> markDistributionAsDeployed(String serviceId, String did, User user) {
1891 validateUserExists(user.getUserId());
1892 log.debug("mark distribution deployed");
1894 AuditingActionEnum auditAction = AuditingActionEnum.DISTRIBUTION_DEPLOY;
1895 Either<Service, StorageOperationStatus> getServiceResponse = toscaOperationFacade.getToscaElement(serviceId);
1896 if (getServiceResponse.isRight()) {
1897 BeEcompErrorManager.getInstance().logBeComponentMissingError("markDistributionAsDeployed", ComponentTypeEnum.SERVICE.getValue(), serviceId);
1898 log.debug("service {} not found", serviceId);
1899 ResponseFormat responseFormat = auditDeployError(did, user, auditAction, null, componentsUtils.convertFromStorageResponse(getServiceResponse.right().value(), ComponentTypeEnum.SERVICE), "");
1901 return Either.right(responseFormat);
1904 Service service = getServiceResponse.left().value();
1905 user = validateRoleForDeploy(did, user, auditAction, service);
1906 return checkDistributionAndDeploy(did, user, auditAction, service);
1910 public Either<Service, ResponseFormat> generateVfModuleArtifacts(Service service, User modifier, boolean shouldLock, boolean inTransaction) {
1911 Function<ComponentInstance, List<ArtifactGenerator<ArtifactDefinition>>> artifactTaskGeneratorCreator = ri ->
1912 // Only one VF Module Artifact per instance - add it to a list of one
1913 buildArtifactGenList(service, modifier, shouldLock, inTransaction, ri);
1915 return generateDeploymentArtifacts(service, artifactTaskGeneratorCreator);
1919 private List<ArtifactGenerator<ArtifactDefinition>> buildArtifactGenList(Service service, User modifier, boolean shouldLock, boolean inTransaction, ComponentInstance ri) {
1920 List<ArtifactGenerator<ArtifactDefinition>> asList = new ArrayList<>();
1922 if (ri.getOriginType() == OriginTypeEnum.VF) {
1923 asList = Arrays.asList(new VfModuleArtifactGenerator(modifier, ri, service, shouldLock, inTransaction));
1928 private List<GroupInstance> collectGroupsInstanceForCompInstance(ComponentInstance currVF) {
1929 Map<String, ArtifactDefinition> deploymentArtifacts = currVF.getDeploymentArtifacts();
1930 if(currVF.getGroupInstances() != null){
1931 currVF.getGroupInstances().forEach(gi -> gi.alignArtifactsUuid(deploymentArtifacts));
1933 return currVF.getGroupInstances();
1936 private ArtifactDefinition getVfModuleInstArtifactForCompInstance(ComponentInstance currVF, Service service, Wrapper<String> payloadWrapper, Wrapper<ResponseFormat> responseWrapper) {
1937 ArtifactDefinition vfModuleAertifact = null;
1938 if (MapUtils.isNotEmpty(currVF.getDeploymentArtifacts())) {
1939 final Optional<ArtifactDefinition> optionalVfModuleArtifact =
1940 currVF.getDeploymentArtifacts().values().stream()
1941 .filter(p -> p.getArtifactType().equals(ArtifactTypeEnum.VF_MODULES_METADATA.getType()))
1943 if (optionalVfModuleArtifact.isPresent()) {
1944 vfModuleAertifact = optionalVfModuleArtifact.get();
1947 if (vfModuleAertifact == null) {
1948 Either<ArtifactDefinition, ResponseFormat> createVfModuleArtifact = createVfModuleArtifact(currVF, service, payloadWrapper.getInnerElement());
1949 if (createVfModuleArtifact.isLeft()) {
1950 vfModuleAertifact = createVfModuleArtifact.left().value();
1952 responseWrapper.setInnerElement(createVfModuleArtifact.right().value());
1955 return vfModuleAertifact;
1958 private void fillVfModuleInstHeatEnvPayload(List<GroupInstance> groupsForCurrVF, Wrapper<String> payloadWrapper) {
1959 List<VfModuleArtifactPayload> vfModulePayloads = new ArrayList<>();
1960 if (groupsForCurrVF != null) {
1961 for (GroupInstance groupInstance : groupsForCurrVF) {
1962 VfModuleArtifactPayload modulePayload = new VfModuleArtifactPayload(groupInstance);
1963 vfModulePayloads.add(modulePayload);
1965 vfModulePayloads.sort(VfModuleArtifactPayload::compareByGroupName);
1967 final Gson gson = new GsonBuilder().setPrettyPrinting().create();
1969 String vfModulePayloadString = gson.toJson(vfModulePayloads);
1970 payloadWrapper.setInnerElement(vfModulePayloadString);
1975 private Either<ArtifactDefinition, ResponseFormat> generateVfModuleInstanceArtifact(User modifier, ComponentInstance currVFInstance, Service service, boolean shouldLock, boolean inTransaction) {
1976 ArtifactDefinition vfModuleArtifact = null;
1977 Wrapper<ResponseFormat> responseWrapper = new Wrapper<>();
1978 Wrapper<String> payloadWrapper = new Wrapper<>();
1979 List<GroupInstance> groupsForCurrVF = collectGroupsInstanceForCompInstance(currVFInstance);
1980 if (responseWrapper.isEmpty()) {
1981 fillVfModuleInstHeatEnvPayload(groupsForCurrVF, payloadWrapper);
1983 if (responseWrapper.isEmpty() && payloadWrapper.getInnerElement() != null) {
1984 vfModuleArtifact = getVfModuleInstArtifactForCompInstance(currVFInstance, service, payloadWrapper, responseWrapper);
1986 if (responseWrapper.isEmpty() && vfModuleArtifact != null) {
1987 vfModuleArtifact = fillVfModulePayload(modifier, currVFInstance, vfModuleArtifact, shouldLock, inTransaction, payloadWrapper, responseWrapper, service);
1990 Either<ArtifactDefinition, ResponseFormat> result;
1991 if (responseWrapper.isEmpty()) {
1992 result = Either.left(vfModuleArtifact);
1994 result = Either.right(responseWrapper.getInnerElement());
2000 private ArtifactDefinition fillVfModulePayload(User modifier, ComponentInstance currVF, ArtifactDefinition vfModuleArtifact, boolean shouldLock, boolean inTransaction, Wrapper<String> payloadWrapper, Wrapper<ResponseFormat> responseWrapper, Service service) {
2001 ArtifactDefinition result = null;
2002 Either<ArtifactDefinition, ResponseFormat> eitherPayload = artifactsBusinessLogic.generateArtifactPayload(vfModuleArtifact, ComponentTypeEnum.RESOURCE_INSTANCE, service, currVF.getName(), modifier, shouldLock, inTransaction, System::currentTimeMillis,
2003 () -> Either.left(artifactsBusinessLogic.createEsArtifactData(vfModuleArtifact, payloadWrapper.getInnerElement().getBytes(StandardCharsets.UTF_8))), currVF.getUniqueId());
2004 if (eitherPayload.isLeft()) {
2005 result = eitherPayload.left().value();
2007 responseWrapper.setInnerElement(eitherPayload.right().value());
2009 if (result == null) {
2010 result = vfModuleArtifact;
2016 private Either<ArtifactDefinition, ResponseFormat> createVfModuleArtifact(ComponentInstance currVF, Service service, String vfModulePayloadString) {
2018 ArtifactDefinition vfModuleArtifactDefinition = new ArtifactDefinition();
2019 String newCheckSum = null;
2021 vfModuleArtifactDefinition.setDescription("Auto-generated VF Modules information artifact");
2022 vfModuleArtifactDefinition.setArtifactDisplayName("Vf Modules Metadata");
2023 vfModuleArtifactDefinition.setArtifactType(ArtifactTypeEnum.VF_MODULES_METADATA.getType());
2024 vfModuleArtifactDefinition.setArtifactGroupType(ArtifactGroupTypeEnum.DEPLOYMENT);
2025 vfModuleArtifactDefinition.setArtifactLabel("vfModulesMetadata");
2026 vfModuleArtifactDefinition.setTimeout(0);
2027 vfModuleArtifactDefinition.setArtifactName(currVF.getNormalizedName() + "_modules.json");
2028 vfModuleArtifactDefinition.setPayloadData(vfModulePayloadString);
2029 if (vfModulePayloadString != null) {
2030 newCheckSum = GeneralUtility.calculateMD5Base64EncodedByByteArray(vfModulePayloadString.getBytes());
2032 vfModuleArtifactDefinition.setArtifactChecksum(newCheckSum);
2034 Either<ArtifactDefinition, StorageOperationStatus> addArtifactToComponent = artifactToscaOperation.addArtifactToComponent(
2035 vfModuleArtifactDefinition, service, NodeTypeEnum.ResourceInstance, true, currVF.getUniqueId());
2037 Either<ArtifactDefinition, ResponseFormat> result;
2038 if (addArtifactToComponent.isLeft()) {
2039 result = Either.left(addArtifactToComponent.left().value());
2041 result = Either.right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(addArtifactToComponent.right().value())));
2047 public Either<Service, ResponseFormat> generateHeatEnvArtifacts(Service service, User modifier, boolean shouldLock, boolean inTransaction) {
2049 Function<ComponentInstance, List<ArtifactGenerator<ArtifactDefinition>>> artifactTaskGeneratorCreator = resourceInstance ->
2050 // Get All Deployment Artifacts
2051 service.getComponentInstances().stream().filter(ri -> ri != null && ri == resourceInstance).filter(ri -> ri.getDeploymentArtifacts() != null).flatMap(ri -> ri.getDeploymentArtifacts().values().stream()).
2052 // Filter in Only Heat Env
2053 filter(depArtifact -> ArtifactTypeEnum.HEAT_ENV.getType().equals(depArtifact.getArtifactType())).
2054 // Create ArtifactGenerator from those Artifacts
2055 map(depArtifact -> new HeatEnvArtifactGenerator(depArtifact, service, resourceInstance.getName(), modifier, shouldLock, inTransaction, resourceInstance.getUniqueId())).collect(Collectors.toList());
2057 return generateDeploymentArtifacts(service, artifactTaskGeneratorCreator);
2061 private <CallVal> Either<Service, ResponseFormat> generateDeploymentArtifacts(Service service, Function<ComponentInstance, List<ArtifactGenerator<CallVal>>> artifactTaskGeneratorCreator) {
2063 // Get Flat List of (Callable) ArtifactGenerator for all the RI in the
2065 if (service.getComponentInstances() != null) {
2066 List<ArtifactGenerator<CallVal>> artifactGenList = service.getComponentInstances().stream().flatMap(ri -> artifactTaskGeneratorCreator.apply(ri).stream()).collect(Collectors.toList());
2067 if (artifactGenList != null && !artifactGenList.isEmpty()) {
2068 Either<Service, ResponseFormat> callRes = checkDeploymentArtifact(artifactGenList);
2069 if (callRes != null) return callRes;
2072 Either<Service, StorageOperationStatus> storageStatus = toscaOperationFacade.getToscaFullElement(service.getUniqueId());
2073 if (storageStatus.isRight()) {
2074 return Either.right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(storageStatus.right().value(), ComponentTypeEnum.SERVICE), ""));
2077 Service currentService = storageStatus.left().value();
2079 return Either.left(currentService);
2083 private <CallVal> Either<Service, ResponseFormat> checkDeploymentArtifact(List<ArtifactGenerator<CallVal>> artifactGenList) {
2084 for (ArtifactGenerator<CallVal> entry : artifactGenList) {
2085 Either<CallVal, ResponseFormat> callRes;
2087 callRes = entry.call();
2088 if (callRes.isRight()) {
2089 log.debug("Failed to generate artifact error : {}", callRes.right().value());
2090 return Either.right(callRes.right().value());
2092 } catch (Exception e) {
2093 log.debug("Failed to generate artifact exception : {}", e);
2094 return Either.right(componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR));
2100 abstract class ArtifactGenerator<CallVal> implements Callable<Either<CallVal, ResponseFormat>> {
2104 class HeatEnvArtifactGenerator extends ArtifactGenerator<ArtifactDefinition> {
2105 ArtifactDefinition artifactDefinition;
2107 String resourceInstanceName;
2111 boolean inTransaction;
2113 HeatEnvArtifactGenerator(ArtifactDefinition artifactDefinition, Service service, String resourceInstanceName, User modifier, boolean shouldLock, boolean inTransaction, String instanceId) {
2114 this.artifactDefinition = artifactDefinition;
2115 this.service = service;
2116 this.resourceInstanceName = resourceInstanceName;
2117 this.modifier = modifier;
2118 this.shouldLock = shouldLock;
2119 this.instanceId = instanceId;
2120 this.inTransaction = inTransaction;
2124 public Either<ArtifactDefinition, ResponseFormat> call() throws Exception {
2125 return artifactsBusinessLogic.forceGenerateHeatEnvArtifact(artifactDefinition, ComponentTypeEnum.RESOURCE_INSTANCE, service, resourceInstanceName, modifier, shouldLock, inTransaction, instanceId);
2128 public ArtifactDefinition getArtifactDefinition() {
2129 return artifactDefinition;
2134 class VfModuleArtifactGenerator extends ArtifactGenerator<ArtifactDefinition> {
2136 private ComponentInstance componentInstance;
2137 private Service service;
2139 boolean inTransaction;
2142 public Either<ArtifactDefinition, ResponseFormat> call() throws Exception {
2143 return generateVfModuleInstanceArtifact(user, componentInstance, service, shouldLock, inTransaction);
2146 private VfModuleArtifactGenerator(User user, ComponentInstance componentInstance, Service service, boolean shouldLock, boolean inTransaction) {
2149 this.componentInstance = componentInstance;
2150 this.service = service;
2151 this.shouldLock = shouldLock;
2152 this.inTransaction = inTransaction;
2157 private synchronized Either<Service, ResponseFormat> checkDistributionAndDeploy(String distributionId, User user, AuditingActionEnum auditAction, Service service) {
2158 boolean isDeployed = isDistributionDeployed(distributionId);
2160 return Either.left(service);
2162 Either<Boolean, ResponseFormat> distributionSuccess = checkDistributionSuccess(distributionId, user, auditAction, service);
2163 if (distributionSuccess.isRight()) {
2164 return Either.right(distributionSuccess.right().value());
2167 log.debug("mark distribution {} as deployed - success", distributionId);
2168 componentsUtils.auditServiceDistributionDeployed(service.getName(), service.getVersion(), service.getUUID(), distributionId, STATUS_DEPLOYED, "OK", user);
2169 return Either.left(service);
2172 private boolean isDistributionDeployed(String distributionId) {
2173 Either<List<DistributionDeployEvent>, ActionStatus> alreadyDeployed = auditCassandraDao.getDistributionDeployByStatus(distributionId, AuditingActionEnum.DISTRIBUTION_DEPLOY.getName(), STATUS_DEPLOYED);
2175 boolean isDeployed = false;
2176 if (alreadyDeployed.isLeft() && !alreadyDeployed.left().value().isEmpty()) {
2178 log.debug("distribution {} is already deployed", distributionId);
2184 protected Either<Boolean, ResponseFormat> checkDistributionSuccess(String did, User user, AuditingActionEnum auditAction, Service service) {
2186 log.trace("checkDistributionSuccess");
2187 // get all "DRequest" records for this distribution
2189 Either<List<ResourceAdminEvent>, ActionStatus> distRequestsResponse = auditCassandraDao.getDistributionRequest(did, AuditingActionEnum.DISTRIBUTION_STATE_CHANGE_REQUEST.getName());
2190 if (distRequestsResponse.isRight()) {
2191 ResponseFormat error = auditDeployError(did, user, auditAction, service, distRequestsResponse.right().value());
2192 return Either.right(error);
2195 List<ResourceAdminEvent> distributionRequests = distRequestsResponse.left().value();
2196 if (distributionRequests.isEmpty()) {
2197 BeEcompErrorManager.getInstance().logBeDistributionMissingError("markDistributionAsDeployed", did);
2198 log.info("distribution {} is not found", did);
2199 ResponseFormat error = auditDeployError(did, user, auditAction, service, ActionStatus.DISTRIBUTION_REQUESTED_NOT_FOUND);
2200 return Either.right(error);
2202 boolean isRequestSucceeded = false;
2203 for (ResourceAdminEvent event : distributionRequests) {
2204 String eventStatus = event.getStatus();
2205 if (eventStatus != null && eventStatus.equals(STATUS_SUCCESS_200)) {
2206 isRequestSucceeded = true;
2211 // get all "DNotify" records for this distribution
2212 Either<List<DistributionNotificationEvent>, ActionStatus> distNotificationsResponse = auditCassandraDao.getDistributionNotify(did, AuditingActionEnum.DISTRIBUTION_NOTIFY.getName());
2213 if (distNotificationsResponse.isRight()) {
2214 ResponseFormat error = auditDeployError(did, user, auditAction, service, distNotificationsResponse.right().value());
2215 return Either.right(error);
2218 List<DistributionNotificationEvent> distributionNotifications = distNotificationsResponse.left().value();
2219 boolean isNotificationsSucceeded = false;
2220 for (DistributionNotificationEvent event : distributionNotifications) {
2221 String eventStatus = event.getStatus();
2222 if (eventStatus != null && eventStatus.equals(STATUS_SUCCESS_200)) {
2223 isNotificationsSucceeded = true;
2228 // if request failed OR there are notifications that failed
2229 if (!(isRequestSucceeded && isNotificationsSucceeded)) {
2231 log.info("distribution {} has failed", did);
2232 ResponseFormat error = componentsUtils.getResponseFormat(ActionStatus.DISTRIBUTION_REQUESTED_FAILED, did);
2233 auditDeployError(did, user, auditAction, service, ActionStatus.DISTRIBUTION_REQUESTED_FAILED, did);
2234 return Either.right(error);
2236 return Either.left(true);
2239 private ResponseFormat auditDeployError(String did, User user, AuditingActionEnum auditAction, Service service, ActionStatus status, String... params) {
2241 ResponseFormat error = componentsUtils.getResponseFormat(status, params);
2242 String message = "";
2243 if (error.getMessageId() != null) {
2244 message = error.getMessageId() + ": ";
2246 message += error.getFormattedMessage();
2248 if (service != null) {
2249 componentsUtils.auditServiceDistributionDeployed(service.getName(), service.getVersion(), service.getUUID(), did, error.getStatus().toString(), message, user);
2251 componentsUtils.auditServiceDistributionDeployed("", "", "", did, error.getStatus().toString(), message, user);
2256 private User validateRoleForDeploy(String did, User user, AuditingActionEnum auditAction, Service service) {
2257 user = userAdmin.getUser(user.getUserId());
2258 log.debug("validate user role");
2259 List<Role> roles = new ArrayList<>();
2260 roles.add(Role.ADMIN);
2261 roles.add(Role.DESIGNER);
2263 validateUserRole(user, service, roles, auditAction, null);
2264 } catch (ByActionStatusComponentException e){
2265 log.info("role {} is not allowed to perform this action", user.getRole());
2266 auditDeployError(did, user, auditAction, service, e.getActionStatus());
2273 public void setDeploymentArtifactsPlaceHolder(Component component, User user) {
2274 if(component instanceof Service){
2275 Service service = (Service) component;
2276 Map<String, ArtifactDefinition> artifactMap = service.getDeploymentArtifacts();
2277 if (artifactMap == null) {
2278 artifactMap = new HashMap<>();
2280 service.setDeploymentArtifacts(artifactMap);
2281 }else if(component instanceof Resource){
2282 Resource resource = (Resource) component;
2283 Map<String, ArtifactDefinition> artifactMap = resource.getDeploymentArtifacts();
2284 if (artifactMap == null) {
2285 artifactMap = new HashMap<>();
2287 Map<String, Object> deploymentResourceArtifacts = ConfigurationManager.getConfigurationManager()
2288 .getConfiguration().getDeploymentResourceArtifacts();
2289 if (deploymentResourceArtifacts != null) {
2290 Map<String, ArtifactDefinition> finalArtifactMap = artifactMap;
2291 deploymentResourceArtifacts.forEach((k, v)->processDeploymentResourceArtifacts(user, resource, finalArtifactMap, k,v));
2293 resource.setDeploymentArtifacts(artifactMap);
2298 private void processDeploymentResourceArtifacts(User user, Resource resource, Map<String, ArtifactDefinition> artifactMap, String k, Object v) {
2299 Map<String, Object> artifactDetails = (Map<String, Object>) v;
2300 Object object = artifactDetails.get(PLACE_HOLDER_RESOURCE_TYPES);
2301 if (object != null) {
2302 List<String> artifactTypes = (List<String>) object;
2303 if (!artifactTypes.contains(resource.getResourceType().name())) {
2307 log.info("resource types for artifact placeholder {} were not defined. default is all resources",
2310 if (artifactsBusinessLogic != null) {
2311 ArtifactDefinition artifactDefinition = artifactsBusinessLogic.createArtifactPlaceHolderInfo(
2312 resource.getUniqueId(), k, (Map<String, Object>) v,
2313 user, ArtifactGroupTypeEnum.DEPLOYMENT);
2314 if (artifactDefinition != null
2315 && !artifactMap.containsKey(artifactDefinition.getArtifactLabel())) {
2316 artifactMap.put(artifactDefinition.getArtifactLabel(), artifactDefinition);
2322 public Either<List<String>, ResponseFormat> deleteMarkedComponents() {
2323 return deleteMarkedComponents(ComponentTypeEnum.SERVICE);
2326 private HealthCheckBusinessLogic getHealthCheckBL(ServletContext context) {
2327 WebAppContextWrapper webApplicationContextWrapper = (WebAppContextWrapper) context.getAttribute(Constants.WEB_APPLICATION_CONTEXT_WRAPPER_ATTR);
2328 WebApplicationContext webApplicationContext = webApplicationContextWrapper.getWebAppContext(context);
2329 return webApplicationContext.getBean(HealthCheckBusinessLogic.class);
2333 public ComponentInstanceBusinessLogic getComponentInstanceBL() {
2334 return componentInstanceBusinessLogic;
2338 public Either<List<ComponentInstance>, ResponseFormat> getComponentInstancesFilteredByPropertiesAndInputs(String componentId, String userId) {
2340 validateUserExists(userId);
2341 Either<Component, StorageOperationStatus> getComponentRes = toscaOperationFacade.getToscaElement(componentId, JsonParseFlagEnum.ParseAll);
2342 if (getComponentRes.isRight()) {
2343 ResponseFormat responseFormat = componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(getComponentRes.right().value()));
2344 return Either.right(responseFormat);
2347 List<ComponentInstance> componentInstances = getComponentRes.left().value().getComponentInstances();
2349 return Either.left(componentInstances);
2353 public void setForwardingPathOperation(ForwardingPathOperation forwardingPathOperation) {
2354 this.forwardingPathOperation = forwardingPathOperation;
2358 * updates group instance with new property values in case of successful update of group instance related component instance will be updated with new modification time and related service will be updated with new last update date
2361 public Either<List<GroupInstanceProperty>, ResponseFormat> updateGroupInstancePropertyValues(User modifier, String serviceId, String componentInstanceId, String groupInstanceId, List<GroupInstanceProperty> newProperties) {
2363 Either<List<GroupInstanceProperty>, ResponseFormat> actionResult = null;
2364 Either<ImmutablePair<Component, User>, ResponseFormat> validateUserAndComponentRes;
2365 Component component = null;
2366 Either<Boolean, ResponseFormat> lockResult = null;
2367 log.debug("Going to update group instance {} of service {} with new property values. ", groupInstanceId, serviceId);
2369 validateUserAndComponentRes = validateUserAndComponent(serviceId, modifier);
2370 if (validateUserAndComponentRes.isRight()) {
2371 log.debug("Cannot update group instance {} of service {} with new property values. Validation failed. ", groupInstanceId, serviceId);
2372 actionResult = Either.right(validateUserAndComponentRes.right().value());
2374 if (actionResult == null) {
2375 component = validateUserAndComponentRes.left().value().getKey();
2376 lockResult = lockComponentByName(component.getSystemName(), component, "Update Group Instance on Service");
2377 if (lockResult.isRight()) {
2378 log.debug(FAILED_TO_LOCK_SERVICE_RESPONSE_IS, component.getName(), lockResult.right().value().getFormattedMessage());
2379 actionResult = Either.right(lockResult.right().value());
2381 log.debug(THE_SERVICE_WITH_SYSTEM_NAME_LOCKED, component.getSystemName());
2384 if (actionResult == null) {
2385 actionResult = validateAndUpdateGroupInstancePropertyValuesAndContainingParents(component, componentInstanceId, groupInstanceId, newProperties);
2386 if (actionResult.isRight()) {
2387 log.debug("Failed to validate and update group instance {} property values and containing parents. The message is {}. ", groupInstanceId, actionResult.right().value().getFormattedMessage());
2390 } catch (Exception e) {
2391 log.error("Exception occured during update Group Instance property values: {}", e.getMessage(), e);
2392 actionResult = Either.right(componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR));
2394 if (lockResult != null && lockResult.isLeft() && lockResult.left().value()) {
2395 graphLockOperation.unlockComponentByName(component.getSystemName(), component.getUniqueId(), NodeTypeEnum.Service);
2398 return actionResult;
2401 private Either<List<GroupInstanceProperty>, ResponseFormat> validateAndUpdateGroupInstancePropertyValuesAndContainingParents(Component component, String componentInstanceId, String groupInstanceId, List<GroupInstanceProperty> newProperties) {
2403 Either<List<GroupInstanceProperty>, ResponseFormat> actionResult = null;
2404 Either<ImmutablePair<ComponentInstance, GroupInstance>, ResponseFormat> findGroupInstanceRes;
2405 Either<ImmutablePair<ComponentMetadataData, ComponentInstanceData>, ResponseFormat> updateParentsModificationTimeRes;
2406 ComponentInstance relatedComponentInstance = null;
2407 GroupInstance oldGroupInstance = null;
2408 Either<GroupInstance, ResponseFormat> updateGroupInstanceResult = null;
2409 GroupInstance updatedGroupInstance = null;
2410 boolean inTransaction = true;
2411 findGroupInstanceRes = findGroupInstanceOnRelatedComponentInstance(component, componentInstanceId, groupInstanceId);
2412 if (findGroupInstanceRes.isRight()) {
2413 log.debug("#validateAndUpdateGroupInstancePropertyValuesAndContainingParents - Group instance {} not found. ", groupInstanceId);
2414 actionResult = Either.right(findGroupInstanceRes.right().value());
2416 if (actionResult == null) {
2417 oldGroupInstance = findGroupInstanceRes.left().value().getValue();
2418 relatedComponentInstance = findGroupInstanceRes.left().value().getKey();
2419 updateGroupInstanceResult = groupBusinessLogic.validateAndUpdateGroupInstancePropertyValues(component.getUniqueId(), componentInstanceId, oldGroupInstance, newProperties);
2420 if (updateGroupInstanceResult.isRight()) {
2421 log.debug("#validateAndUpdateGroupInstancePropertyValuesAndContainingParents - Failed to update group instance {} property values. ", oldGroupInstance.getName());
2422 actionResult = Either.right(updateGroupInstanceResult.right().value());
2425 if (actionResult == null) {
2426 updatedGroupInstance = updateGroupInstanceResult.left().value();
2427 if (!oldGroupInstance.getModificationTime().equals(updatedGroupInstance.getModificationTime())) {
2428 updateParentsModificationTimeRes = updateParentsModificationTimeAndCustomizationUuid(component, relatedComponentInstance, updatedGroupInstance, inTransaction);
2429 if (updateParentsModificationTimeRes.isRight()) {
2430 log.debug("#validateAndUpdateGroupInstancePropertyValuesAndContainingParents - Failed to update modification time for group instance {}. ", oldGroupInstance.getName());
2431 actionResult = Either.right(updateParentsModificationTimeRes.right().value());
2435 if (actionResult == null) {
2436 actionResult = Either.left(updatedGroupInstance.convertToGroupInstancesProperties());
2438 return actionResult;
2441 private Either<ImmutablePair<ComponentMetadataData, ComponentInstanceData>, ResponseFormat> updateParentsModificationTimeAndCustomizationUuid(Component component, ComponentInstance relatedComponentInstance, GroupInstance updatedGroupInstance,
2442 boolean inTranscation) {
2444 Either<ImmutablePair<ComponentMetadataData, ComponentInstanceData>, ResponseFormat> actionResult;
2445 Either<ComponentMetadataData, StorageOperationStatus> serviceMetadataUpdateResult;
2446 Either<ComponentInstanceData, ResponseFormat> updateComponentInstanceRes = componentInstanceBusinessLogic.updateComponentInstanceModificationTimeAndCustomizationUuid(relatedComponentInstance, NodeTypeEnum.ResourceInstance,
2447 updatedGroupInstance.getModificationTime(), inTranscation);
2448 if (updateComponentInstanceRes.isRight()) {
2449 log.debug("Failed to update component instance {} after update of group instance {}. ", relatedComponentInstance.getName(), updatedGroupInstance.getName());
2450 actionResult = Either.right(updateComponentInstanceRes.right().value());
2452 serviceMetadataUpdateResult = toscaOperationFacade.updateComponentLastUpdateDateOnGraph(component);
2453 if (serviceMetadataUpdateResult.isRight()) {
2454 log.debug("Failed to update service {} after update of component instance {} with new property values of group instance {}. ", component.getName(), relatedComponentInstance.getName(), updatedGroupInstance.getName());
2455 actionResult = Either.right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(serviceMetadataUpdateResult.right().value())));
2457 actionResult = Either.left(new ImmutablePair<>(serviceMetadataUpdateResult.left().value(), updateComponentInstanceRes.left().value()));
2460 return actionResult;
2463 private Either<ImmutablePair<Component, User>, ResponseFormat> validateUserAndComponent(String serviceId, User modifier) {
2465 Either<ImmutablePair<Component, User>, ResponseFormat> result = null;
2466 User currUser = null;
2467 Component component = null;
2468 Either<User, ResponseFormat> validationUserResult = validateUserIgnoreAudit(modifier, "updateGroupInstancePropertyValues");
2469 if (validationUserResult.isRight()) {
2470 log.debug("#validateUserAndComponent - Failed to validate user with userId {}, for update service {}. ", modifier.getUserId(), serviceId);
2471 result = Either.right(validationUserResult.right().value());
2473 if (result == null) {
2474 currUser = validationUserResult.left().value();
2476 component = validateComponentExists(serviceId, ComponentTypeEnum.SERVICE, null);
2477 if (!ComponentValidationUtils.canWorkOnComponent(component, currUser.getUserId())) {
2478 log.info("#validateUserAndComponent - Restricted operation for user: {}, on service: {}", currUser.getUserId(), component.getCreatorUserId());
2479 return Either.right(componentsUtils.getResponseFormat(ActionStatus.RESTRICTED_OPERATION));
2481 } catch (ComponentException e) {
2482 log.debug("#validateUserAndComponent - Failed to validate service existing {}. ", serviceId);
2483 result = Either.right(e.getResponseFormat());
2487 if (result == null) {
2488 result = Either.left(new ImmutablePair<>(component, currUser));
2493 private Either<ImmutablePair<ComponentInstance, GroupInstance>, ResponseFormat> findGroupInstanceOnRelatedComponentInstance(Component component, String componentInstanceId, String groupInstanceId) {
2495 Either<ImmutablePair<ComponentInstance, GroupInstance>, ResponseFormat> actionResult = null;
2496 GroupInstance groupInstance = null;
2497 ComponentInstance foundComponentInstance = findRelatedComponentInstance(component, componentInstanceId);
2498 if (foundComponentInstance == null) {
2499 log.debug("Component instance {} not found on service {}. ", componentInstanceId, component.getName());
2500 actionResult = Either.right(componentsUtils.getResponseFormat(ActionStatus.COMPONENT_INSTANCE_NOT_FOUND_ON_CONTAINER, componentInstanceId, "resource instance", "service", component.getName()));
2502 else if (isNotEmpty(foundComponentInstance.getGroupInstances())) {
2503 groupInstance = foundComponentInstance.getGroupInstances().stream().filter(gi -> gi.getUniqueId().equals(groupInstanceId)).findFirst().orElse(null);
2504 if (groupInstance == null) {
2505 log.debug("Group instance {} not found on component instance {}. ", groupInstanceId, foundComponentInstance.getName());
2506 actionResult = Either.right(componentsUtils.getResponseFormat(ActionStatus.GROUP_INSTANCE_NOT_FOUND_ON_COMPONENT_INSTANCE, groupInstanceId, foundComponentInstance.getName()));
2509 if (actionResult == null) {
2510 actionResult = Either.left(new ImmutablePair<>(foundComponentInstance, groupInstance));
2512 return actionResult;
2515 private ComponentInstance findRelatedComponentInstance(Component component, String componentInstanceId) {
2516 ComponentInstance componentInstance = null;
2517 if (isNotEmpty(component.getComponentInstances())) {
2518 componentInstance = component.getComponentInstances().stream().filter(ci -> ci.getUniqueId().equals(componentInstanceId)).findFirst().orElse(null);
2520 return componentInstance;
2523 private Either<User, ResponseFormat> validateUserIgnoreAudit(User modifier, String ecompErrorContext) {
2524 User user = validateUser(modifier, ecompErrorContext, null, null, false);
2525 List<Role> roles = new ArrayList<>();
2526 roles.add(Role.ADMIN);
2527 roles.add(Role.DESIGNER);
2528 validateUserRole(user, roles);
2529 return Either.left(user);
2532 public Either<UiComponentDataTransfer, ResponseFormat> getUiComponentDataTransferByComponentId(String serviceId, List<String> dataParamsToReturn) {
2534 ComponentParametersView paramsToReturn = new ComponentParametersView(dataParamsToReturn);
2535 paramsToReturn.setIgnoreComponentInstancesProperties(false);
2536 Either<Service, StorageOperationStatus> serviceResultEither = toscaOperationFacade.getToscaElement(serviceId, paramsToReturn);
2538 if (serviceResultEither.isRight()) {
2539 if(serviceResultEither.right().value() == StorageOperationStatus.NOT_FOUND) {
2540 log.debug("#getUiComponentDataTransferByComponentId - Failed to find service with id {} ", serviceId);
2541 return Either.right(componentsUtils.getResponseFormat(ActionStatus.SERVICE_NOT_FOUND, serviceId));
2544 log.debug("#getUiComponentDataTransferByComponentId - failed to get service by id {} with filters {}", serviceId, dataParamsToReturn);
2545 return Either.right(componentsUtils.getResponseFormatByResource(componentsUtils.convertFromStorageResponse(serviceResultEither.right().value()), ""));
2548 Service service = serviceResultEither.left().value();
2549 if (dataParamsToReturn.contains(ComponentFieldsEnum.INPUTS.getValue())) {
2550 ListUtils.emptyIfNull(service.getInputs())
2551 .forEach(input -> input.setConstraints(setInputConstraint(input)));
2554 UiComponentDataTransfer dataTransfer = uiComponentDataConverter.getUiDataTransferFromServiceByParams(service, dataParamsToReturn);
2555 return Either.left(dataTransfer);
2558 @Autowired(required = false)
2559 public void setServiceCreationPluginList(List<ServiceCreationPlugin> serviceCreationPluginList) {
2560 this.serviceCreationPluginList = serviceCreationPluginList;
2563 public boolean isServiceExist(String serviceName) {
2564 Either<Service, StorageOperationStatus> latestByName = toscaOperationFacade.getLatestByServiceName(serviceName);
2565 return latestByName.isLeft();