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 * ================================================================================
22 package org.openecomp.sdc.be.components.impl;
24 import static org.apache.commons.collections.CollectionUtils.isNotEmpty;
25 import static org.openecomp.sdc.be.components.utils.ConsumptionUtils.handleConsumptionInputMappedToCapabilityProperty;
26 import static org.openecomp.sdc.be.components.utils.ConsumptionUtils.isAssignedValueFromValidType;
27 import static org.openecomp.sdc.be.components.utils.InterfaceOperationUtils.getOperationOutputName;
28 import static org.openecomp.sdc.be.components.utils.InterfaceOperationUtils.isOperationInputMappedToOtherOperationOutput;
29 import static org.openecomp.sdc.be.resources.data.auditing.AuditingActionEnum.UPDATE_SERVICE_METADATA;
30 import static org.openecomp.sdc.be.tosca.InterfacesOperationsConverter.SELF;
31 import static org.openecomp.sdc.be.types.ServiceConsumptionSource.SERVICE_INPUT;
32 import static org.openecomp.sdc.be.types.ServiceConsumptionSource.STATIC;
34 import com.google.common.annotations.VisibleForTesting;
35 import com.google.common.base.Strings;
36 import com.google.gson.Gson;
37 import com.google.gson.GsonBuilder;
38 import fj.data.Either;
39 import java.nio.charset.StandardCharsets;
40 import java.util.ArrayList;
41 import java.util.Arrays;
42 import java.util.Collection;
43 import java.util.Collections;
44 import java.util.Comparator;
45 import java.util.HashMap;
46 import java.util.List;
48 import java.util.Objects;
49 import java.util.Optional;
51 import java.util.concurrent.Callable;
52 import java.util.function.Function;
53 import java.util.stream.Collectors;
54 import javax.servlet.ServletContext;
55 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.path.ForwardingPathValidator;
71 import org.openecomp.sdc.be.components.utils.InterfaceOperationUtils;
72 import org.openecomp.sdc.be.components.utils.PropertiesUtils;
73 import org.openecomp.sdc.be.components.validation.ServiceDistributionValidation;
74 import org.openecomp.sdc.be.components.validation.component.ComponentContactIdValidator;
75 import org.openecomp.sdc.be.components.validation.component.ComponentDescriptionValidator;
76 import org.openecomp.sdc.be.components.validation.component.ComponentIconValidator;
77 import org.openecomp.sdc.be.components.validation.component.ComponentNameValidator;
78 import org.openecomp.sdc.be.components.validation.component.ComponentProjectCodeValidator;
79 import org.openecomp.sdc.be.components.validation.component.ComponentTagsValidator;
80 import org.openecomp.sdc.be.components.validation.component.ComponentValidator;
81 import org.openecomp.sdc.be.components.validation.service.ServiceCategoryValidator;
82 import org.openecomp.sdc.be.components.validation.service.ServiceFunctionValidator;
83 import org.openecomp.sdc.be.components.validation.service.ServiceInstantiationTypeValidator;
84 import org.openecomp.sdc.be.components.validation.service.ServiceRoleValidator;
85 import org.openecomp.sdc.be.components.validation.service.ServiceTypeValidator;
86 import org.openecomp.sdc.be.components.validation.service.ServiceValidator;
87 import org.openecomp.sdc.be.config.BeEcompErrorManager;
88 import org.openecomp.sdc.be.config.ConfigurationManager;
89 import org.openecomp.sdc.be.dao.api.ActionStatus;
90 import org.openecomp.sdc.be.dao.cassandra.AuditCassandraDao;
91 import org.openecomp.sdc.be.dao.jsongraph.types.JsonParseFlagEnum;
92 import org.openecomp.sdc.be.datamodel.ServiceRelations;
93 import org.openecomp.sdc.be.datamodel.utils.PropertyValueConstraintValidationUtil;
94 import org.openecomp.sdc.be.datamodel.utils.UiComponentDataConverter;
95 import org.openecomp.sdc.be.datatypes.elements.ForwardingPathDataDefinition;
96 import org.openecomp.sdc.be.datatypes.elements.InterfaceDataDefinition;
97 import org.openecomp.sdc.be.datatypes.elements.ListDataDefinition;
98 import org.openecomp.sdc.be.datatypes.elements.OperationInputDefinition;
99 import org.openecomp.sdc.be.datatypes.elements.OperationOutputDefinition;
100 import org.openecomp.sdc.be.datatypes.enums.ComponentFieldsEnum;
101 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
102 import org.openecomp.sdc.be.datatypes.enums.JsonPresentationFields;
103 import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
104 import org.openecomp.sdc.be.datatypes.enums.OriginTypeEnum;
105 import org.openecomp.sdc.be.externalapi.servlet.representation.ServiceDistributionReqInfo;
106 import org.openecomp.sdc.be.impl.ForwardingPathUtils;
107 import org.openecomp.sdc.be.impl.WebAppContextWrapper;
108 import org.openecomp.sdc.be.model.ArtifactDefinition;
109 import org.openecomp.sdc.be.model.CapabilityDefinition;
110 import org.openecomp.sdc.be.model.Component;
111 import org.openecomp.sdc.be.model.ComponentInstance;
112 import org.openecomp.sdc.be.model.ComponentInstanceInterface;
113 import org.openecomp.sdc.be.model.ComponentInstanceProperty;
114 import org.openecomp.sdc.be.model.ComponentParametersView;
115 import org.openecomp.sdc.be.model.DistributionStatusEnum;
116 import org.openecomp.sdc.be.model.GroupInstance;
117 import org.openecomp.sdc.be.model.GroupInstanceProperty;
118 import org.openecomp.sdc.be.model.InputDefinition;
119 import org.openecomp.sdc.be.model.InterfaceDefinition;
120 import org.openecomp.sdc.be.model.LifecycleStateEnum;
121 import org.openecomp.sdc.be.model.Operation;
122 import org.openecomp.sdc.be.model.PropertyDefinition;
123 import org.openecomp.sdc.be.model.Resource;
124 import org.openecomp.sdc.be.model.Service;
125 import org.openecomp.sdc.be.model.User;
126 import org.openecomp.sdc.be.model.category.CategoryDefinition;
127 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.ArtifactsOperations;
128 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.ForwardingPathOperation;
129 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.InterfaceOperation;
130 import org.openecomp.sdc.be.model.operations.api.IElementOperation;
131 import org.openecomp.sdc.be.model.operations.api.IGroupInstanceOperation;
132 import org.openecomp.sdc.be.model.operations.api.IGroupOperation;
133 import org.openecomp.sdc.be.model.operations.api.IGroupTypeOperation;
134 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
135 import org.openecomp.sdc.be.model.operations.impl.InterfaceLifecycleOperation;
136 import org.openecomp.sdc.be.model.operations.impl.UniqueIdBuilder;
137 import org.openecomp.sdc.be.model.operations.utils.ComponentValidationUtils;
138 import org.openecomp.sdc.be.plugins.ServiceCreationPlugin;
139 import org.openecomp.sdc.be.resources.data.ComponentInstanceData;
140 import org.openecomp.sdc.be.resources.data.ComponentMetadataData;
141 import org.openecomp.sdc.be.resources.data.auditing.AuditingActionEnum;
142 import org.openecomp.sdc.be.resources.data.auditing.AuditingGenericEvent;
143 import org.openecomp.sdc.be.resources.data.auditing.DistributionDeployEvent;
144 import org.openecomp.sdc.be.resources.data.auditing.DistributionNotificationEvent;
145 import org.openecomp.sdc.be.resources.data.auditing.ResourceAdminEvent;
146 import org.openecomp.sdc.be.resources.data.auditing.model.ResourceCommonInfo;
147 import org.openecomp.sdc.be.resources.data.auditing.model.ResourceVersionInfo;
148 import org.openecomp.sdc.be.types.ServiceConsumptionData;
149 import org.openecomp.sdc.be.types.ServiceConsumptionSource;
150 import org.openecomp.sdc.be.ui.model.UiComponentDataTransfer;
151 import org.openecomp.sdc.be.user.Role;
152 import org.openecomp.sdc.common.api.ArtifactGroupTypeEnum;
153 import org.openecomp.sdc.common.api.ArtifactTypeEnum;
154 import org.openecomp.sdc.common.api.Constants;
155 import org.openecomp.sdc.common.datastructure.Wrapper;
156 import org.openecomp.sdc.common.kpi.api.ASDCKpiApi;
157 import org.openecomp.sdc.common.log.wrappers.Logger;
158 import org.openecomp.sdc.common.util.GeneralUtility;
159 import org.openecomp.sdc.common.util.ThreadLocalsHolder;
160 import org.openecomp.sdc.common.util.ValidationUtils;
161 import org.openecomp.sdc.exception.ResponseFormat;
162 import org.openecomp.sdc.tosca.datatypes.ToscaFunctions;
163 import org.springframework.beans.factory.annotation.Autowired;
164 import org.springframework.http.HttpStatus;
165 import org.springframework.web.context.WebApplicationContext;
167 @org.springframework.stereotype.Component("serviceBusinessLogic")
168 public class ServiceBusinessLogic extends ComponentBusinessLogic {
170 static final String IS_VALID = "isValid";
171 private static final String THE_SERVICE_WITH_SYSTEM_NAME_LOCKED = "The service with system name {} locked. ";
172 private static final String FAILED_TO_LOCK_SERVICE_RESPONSE_IS = "Failed to lock service {}. Response is {}. ";
173 private static final String AUDIT_BEFORE_SENDING_RESPONSE = "audit before sending response";
174 private static final Logger log = Logger.getLogger(ServiceBusinessLogic.class);
175 private static final String INITIAL_VERSION = "0.1";
176 private static final String STATUS_SUCCESS_200 = "200";
177 private static final String STATUS_DEPLOYED = "DEPLOYED";
178 private static final String PLACE_HOLDER_RESOURCE_TYPES = "validForResourceTypes";
179 private final IDistributionEngine distributionEngine;
180 private final ComponentInstanceBusinessLogic componentInstanceBusinessLogic;
181 private final ServiceDistributionValidation serviceDistributionValidation;
182 private final ForwardingPathValidator forwardingPathValidator;
183 private final UiComponentDataConverter uiComponentDataConverter;
184 private ForwardingPathOperation forwardingPathOperation;
185 private AuditCassandraDao auditCassandraDao;
186 private ServiceTypeValidator serviceTypeValidator;
187 private List<ServiceCreationPlugin> serviceCreationPluginList;
188 private ServiceFunctionValidator serviceFunctionValidator;
190 private ServiceRoleValidator serviceRoleValidator;
192 private ServiceInstantiationTypeValidator serviceInstantiationTypeValidator;
194 private ServiceCategoryValidator serviceCategoryValidator;
196 private ServiceValidator serviceValidator;
199 public ServiceBusinessLogic(IElementOperation elementDao, IGroupOperation groupOperation, IGroupInstanceOperation groupInstanceOperation,
200 IGroupTypeOperation groupTypeOperation, GroupBusinessLogic groupBusinessLogic, InterfaceOperation interfaceOperation,
201 InterfaceLifecycleOperation interfaceLifecycleTypeOperation, ArtifactsBusinessLogic artifactsBusinessLogic,
202 IDistributionEngine distributionEngine, ComponentInstanceBusinessLogic componentInstanceBusinessLogic,
203 ServiceDistributionValidation serviceDistributionValidation, ForwardingPathValidator forwardingPathValidator,
204 UiComponentDataConverter uiComponentDataConverter, ArtifactsOperations artifactToscaOperation,
205 ComponentContactIdValidator componentContactIdValidator, ComponentNameValidator componentNameValidator,
206 ComponentTagsValidator componentTagsValidator, ComponentValidator componentValidator,
207 ComponentIconValidator componentIconValidator, ComponentProjectCodeValidator componentProjectCodeValidator,
208 ComponentDescriptionValidator componentDescriptionValidator) {
209 super(elementDao, groupOperation, groupInstanceOperation, groupTypeOperation, groupBusinessLogic, interfaceOperation,
210 interfaceLifecycleTypeOperation, artifactsBusinessLogic, artifactToscaOperation, componentContactIdValidator, componentNameValidator,
211 componentTagsValidator, componentValidator, componentIconValidator, componentProjectCodeValidator, componentDescriptionValidator);
212 this.distributionEngine = distributionEngine;
213 this.componentInstanceBusinessLogic = componentInstanceBusinessLogic;
214 this.serviceDistributionValidation = serviceDistributionValidation;
215 this.forwardingPathValidator = forwardingPathValidator;
216 this.uiComponentDataConverter = uiComponentDataConverter;
220 public void setServiceTypeValidator(ServiceTypeValidator serviceTypeValidator) {
221 this.serviceTypeValidator = serviceTypeValidator;
225 public void setServiceFunctionValidator(ServiceFunctionValidator serviceFunctionValidator) {
226 this.serviceFunctionValidator = serviceFunctionValidator;
229 public Either<List<Map<String, Object>>, ResponseFormat> getComponentAuditRecords(String componentVersion, String componentUUID, String userId) {
230 validateUserExists(userId);
231 Either<List<Map<String, Object>>, ActionStatus> result;
234 if (componentVersion.endsWith(".0")) {
235 Either<List<ResourceAdminEvent>, ActionStatus> eitherAuditingForCertified = auditCassandraDao.getByServiceInstanceId(componentUUID);
236 if (eitherAuditingForCertified.isLeft()) {
237 result = Either.left(getAuditingFieldsList(eitherAuditingForCertified.left().value()));
239 result = Either.right(eitherAuditingForCertified.right().value());
242 // Uncertified Version
244 result = getAuditRecordsForUncertifiedComponent(componentUUID, componentVersion);
246 } catch (Exception e) {
247 log.debug("get Audit Records failed with exception {}", e);
248 result = Either.right(ActionStatus.GENERAL_ERROR);
250 if (result.isRight()) {
251 return Either.right(componentsUtils.getResponseFormat(result.right().value()));
253 return Either.left(result.left().value());
257 public Either<List<Operation>, ResponseFormat> addServiceConsumptionData(String serviceId, String serviceInstanceId, String operationId,
258 List<ServiceConsumptionData> serviceConsumptionDataList, String userId) {
259 List<Operation> operationList = new ArrayList<>();
260 Either<Service, StorageOperationStatus> serviceEither = toscaOperationFacade.getToscaElement(serviceId);
261 if (serviceEither.isRight()) {
262 return Either.right(componentsUtils.getResponseFormat(serviceEither.right().value()));
264 Service service = serviceEither.left().value();
265 StorageOperationStatus storageOperationStatus = graphLockOperation.lockComponent(service.getUniqueId(), NodeTypeEnum.Service);
266 if (storageOperationStatus != StorageOperationStatus.OK) {
267 return Either.right(componentsUtils.getResponseFormat(storageOperationStatus));
270 for (ServiceConsumptionData serviceConsumptionData : serviceConsumptionDataList) {
271 Either<Operation, ResponseFormat> operationEither = addPropertyServiceConsumption(serviceId, serviceInstanceId, operationId, userId,
272 serviceConsumptionData);
273 if (operationEither.isRight()) {
274 return Either.right(operationEither.right().value());
276 operationList.add(operationEither.left().value());
278 janusGraphDao.commit();
279 return Either.left(operationList);
280 } catch (Exception e) {
281 janusGraphDao.rollback();
282 return Either.right(componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR));
284 graphLockOperation.unlockComponent(service.getUniqueId(), NodeTypeEnum.Service);
288 public Either<Operation, ResponseFormat> addPropertyServiceConsumption(String serviceId, String serviceInstanceId, String operationId,
289 String userId, ServiceConsumptionData serviceConsumptionData) {
290 validateUserExists(userId);
291 Either<Service, StorageOperationStatus> serviceEither = toscaOperationFacade.getToscaElement(serviceId);
292 if (serviceEither.isRight()) {
293 return Either.right(componentsUtils.getResponseFormat(serviceEither.right().value()));
295 Service parentService = serviceEither.left().value();
296 List<ComponentInstance> componentInstances = parentService.getComponentInstances();
297 if (CollectionUtils.isEmpty(componentInstances)) {
298 return Either.right(componentsUtils.getResponseFormat(ActionStatus.INTERFACE_OPERATION_NOT_FOUND, serviceInstanceId));
300 Optional<ComponentInstance> serviceInstanceCandidate = componentInstances.stream()
301 .filter(instance -> instance.getUniqueId().equals(serviceInstanceId)).findAny();
302 if (!serviceInstanceCandidate.isPresent()) {
303 return Either.right(componentsUtils.getResponseFormat(ActionStatus.INTERFACE_OPERATION_NOT_FOUND, serviceInstanceId));
305 Map<String, List<ComponentInstanceInterface>> componentInstancesInterfaces = parentService.getComponentInstancesInterfaces();
306 if (MapUtils.isEmpty(componentInstancesInterfaces)) {
307 return Either.right(componentsUtils.getResponseFormat(ActionStatus.INTERFACE_OPERATION_NOT_FOUND, serviceInstanceId));
309 List<InterfaceDefinition> interfaces = new ArrayList<>();
310 for (ComponentInstanceInterface componentInstanceInterface : componentInstancesInterfaces.get(serviceInstanceId)) {
311 interfaces.add(componentInstanceInterface);
313 ComponentInstance serviceInstance = serviceInstanceCandidate.get();
314 Optional<InterfaceDefinition> interfaceCandidate = InterfaceOperationUtils.getInterfaceDefinitionFromOperationId(interfaces, operationId);
315 if (!interfaceCandidate.isPresent()) {
316 return Either.right(componentsUtils.getResponseFormat(ActionStatus.INTERFACE_OPERATION_NOT_FOUND, serviceInstanceId));
318 InterfaceDefinition interfaceDefinition = interfaceCandidate.get();
319 Map<String, Operation> operations = interfaceDefinition.getOperationsMap();
320 if (MapUtils.isEmpty(operations)) {
321 return Either.right(componentsUtils.getResponseFormat(ActionStatus.INTERFACE_OPERATION_NOT_FOUND, serviceInstanceId));
323 Operation operation = operations.get(operationId);
324 Either<Operation, ResponseFormat> operationEither = Either.left(operation);
325 ListDataDefinition<OperationInputDefinition> inputs = operation.getInputs();
326 Optional<OperationInputDefinition> inputCandidate = getOperationInputByInputId(serviceConsumptionData, inputs);
327 if (!inputCandidate.isPresent()) {
328 return Either.right(new ResponseFormat(HttpStatus.NOT_FOUND.value()));
330 OperationInputDefinition operationInputDefinition = inputCandidate.get();
331 // add data to operation
332 if (Objects.nonNull(serviceConsumptionData.getValue())) {
333 operationEither = handleConsumptionValue(parentService, serviceInstanceId, serviceConsumptionData, operation, operationInputDefinition);
335 if (operationEither.isRight()) {
336 return Either.right(operationEither.right().value());
338 Operation updatedOperation = operationEither.left().value();
339 operations.remove(operationId);
340 operations.put(operationId, updatedOperation);
341 interfaceDefinition.setOperationsMap(operations);
342 parentService.getComponentInstances().remove(serviceInstance);
343 if (CollectionUtils.isEmpty(parentService.getComponentInstances())) {
344 parentService.setComponentInstances(new ArrayList<>());
346 Map<String, Object> instanceInterfaces =
347 MapUtils.isEmpty(serviceInstance.getInterfaces()) ? new HashMap<>() : serviceInstance.getInterfaces();
348 instanceInterfaces.remove(interfaceDefinition.getUniqueId());
349 instanceInterfaces.put(interfaceDefinition.getUniqueId(), interfaceDefinition);
350 serviceInstance.setInterfaces(instanceInterfaces);
351 removeComponentInstanceInterfaceByInterfaceId(interfaceDefinition.getUniqueId(), componentInstancesInterfaces.get(serviceInstanceId));
352 componentInstancesInterfaces.get(serviceInstanceId)
353 .add(new ComponentInstanceInterface(interfaceDefinition.getUniqueId(), interfaceDefinition));
354 parentService.getComponentInstances().add(serviceInstance);
355 StorageOperationStatus status = toscaOperationFacade.updateComponentInstanceInterfaces(parentService, serviceInstanceId);
356 if (status != StorageOperationStatus.OK) {
357 return Either.right(componentsUtils.getResponseFormat(ActionStatus.INTERFACE_OPERATION_NOT_FOUND, serviceInstanceId));
359 return Either.left(operation);
362 private void removeComponentInstanceInterfaceByInterfaceId(String interfaceIdToRemove, List<ComponentInstanceInterface> instanceInterfaces) {
363 if (CollectionUtils.isEmpty(instanceInterfaces)) {
366 Optional<ComponentInstanceInterface> interfaceToRemove = instanceInterfaces.stream()
367 .filter(instInterface -> instInterface.getUniqueId().equals(interfaceIdToRemove)).findAny();
368 if (interfaceToRemove.isPresent()) {
369 instanceInterfaces.remove(interfaceToRemove.get());
373 private Either<Operation, ResponseFormat> handleConsumptionValue(Service containerService, String serviceInstanceId,
374 ServiceConsumptionData serviceConsumptionData, Operation operation,
375 OperationInputDefinition operationInputDefinition) {
376 String source = serviceConsumptionData.getSource();
377 String consumptionValue = serviceConsumptionData.getValue();
378 String type = serviceConsumptionData.getType();
379 String operationIdentifier =
380 consumptionValue.contains(".") ? consumptionValue.substring(0, consumptionValue.lastIndexOf('.')) : consumptionValue;
381 ServiceConsumptionSource sourceValue = ServiceConsumptionSource.getSourceValue(source);
382 if (STATIC.equals(sourceValue)) {
383 // Validate constraint on input value
384 Either<Boolean, ResponseFormat> constraintValidationResult = validateOperationInputConstraint(operationInputDefinition, consumptionValue,
385 type, containerService.getModel());
386 if (constraintValidationResult.isRight()) {
387 return Either.right(constraintValidationResult.right().value());
389 return handleConsumptionStaticValue(consumptionValue, type, operation, operationInputDefinition, containerService.getModel());
391 if (Objects.isNull(sourceValue)) {
392 List<PropertyDefinition> propertyDefinitions;
393 Map<String, List<CapabilityDefinition>> capabilities = null;
394 String componentName;
395 List<OperationOutputDefinition> outputs = null;
396 if (source.equals(containerService.getUniqueId())) {
397 Either<Service, StorageOperationStatus> serviceToTakePropEither = toscaOperationFacade.getToscaElement(source);
398 if (serviceToTakePropEither.isRight()) {
399 return Either.right(componentsUtils.getResponseFormat(serviceToTakePropEither.right().value()));
401 Service service = serviceToTakePropEither.left().value();
402 operationInputDefinition.setSource(service.getUniqueId());
403 sourceValue = SERVICE_INPUT;
404 propertyDefinitions = service.getProperties();
405 componentName = service.getName();
406 outputs = InterfaceOperationUtils.getOtherOperationOutputsOfComponent(operationIdentifier, service.getInterfaces())
407 .getListToscaDataDefinition();
409 Optional<ComponentInstance> getComponentInstance = containerService.getComponentInstanceById(source);
410 if (!getComponentInstance.isPresent()) {
411 return Either.right(componentsUtils.getResponseFormat(ActionStatus.COMPONENT_INSTANCE_NOT_FOUND_ON_CONTAINER, source));
413 ComponentInstance componentInstance = getComponentInstance.get();
414 operationInputDefinition.setSource(componentInstance.getUniqueId());
415 propertyDefinitions = componentInstance.getProperties();
416 capabilities = componentInstance.getCapabilities();
417 componentName = source.equals(serviceInstanceId) ? SELF : componentInstance.getName();
418 if (MapUtils.isNotEmpty(componentInstance.getInterfaces())) {
419 Map<String, InterfaceDataDefinition> componentInstanceInterfaces = componentInstance.getInterfaces().entrySet().stream()
420 .collect(Collectors.toMap((Map.Entry::getKey), (interfaceEntry -> (InterfaceDataDefinition) interfaceEntry.getValue())));
421 outputs = InterfaceOperationUtils.getOtherOperationOutputsOfComponent(operationIdentifier, componentInstanceInterfaces)
422 .getListToscaDataDefinition();
425 if (sourceValue == ServiceConsumptionSource.SERVICE_INPUT) {
426 //The operation input in service consumption has been mapped to an input in the parent service
427 return handleConsumptionInputValue(consumptionValue, containerService, operation, operationInputDefinition);
429 return handleConsumptionPropertyValue(operation, operationInputDefinition, serviceConsumptionData, propertyDefinitions, capabilities,
430 outputs, componentName);
432 operationInputDefinition.setToscaPresentationValue(JsonPresentationFields.SOURCE, source);
433 operationInputDefinition.setSource(source);
434 return Either.left(operation);
437 private Optional<OperationInputDefinition> getOperationInputByInputId(ServiceConsumptionData serviceConsumptionData,
438 ListDataDefinition<OperationInputDefinition> inputs) {
439 if (CollectionUtils.isEmpty(inputs.getListToscaDataDefinition())) {
440 return Optional.empty();
442 return inputs.getListToscaDataDefinition().stream()
443 .filter(operationInput -> operationInput.getInputId().equals(serviceConsumptionData.getInputId())).findAny();
446 private Either<Operation, ResponseFormat> handleConsumptionPropertyValue(Operation operation, OperationInputDefinition operationInputDefinition,
447 ServiceConsumptionData serviceConsumptionData,
448 List<PropertyDefinition> properties,
449 Map<String, List<CapabilityDefinition>> capabilities,
450 List<OperationOutputDefinition> outputs, String componentName) {
451 if (CollectionUtils.isEmpty(properties) && CollectionUtils.isEmpty(outputs)) {
452 return Either.left(operation);
454 String consumptionValue = serviceConsumptionData.getValue();
455 if (CollectionUtils.isNotEmpty(outputs) && isOperationInputMappedToOtherOperationOutput(getOperationOutputName(consumptionValue), outputs)) {
456 return handleConsumptionInputMappedToOperationOutput(operation, operationInputDefinition, outputs, consumptionValue, componentName);
458 if (CollectionUtils.isNotEmpty(properties) && PropertiesUtils.isNodeProperty(consumptionValue, properties)) {
459 return handleConsumptionInputMappedToProperty(operation, operationInputDefinition, serviceConsumptionData, properties, componentName);
461 if (MapUtils.isNotEmpty(capabilities)) {
462 return handleConsumptionInputMappedToCapabilityProperty(operation, operationInputDefinition, serviceConsumptionData, capabilities,
465 return Either.left(operation);
468 private Either<Operation, ResponseFormat> handleConsumptionInputMappedToProperty(Operation operation,
469 OperationInputDefinition operationInputDefinition,
470 ServiceConsumptionData serviceConsumptionData,
471 List<PropertyDefinition> properties, String componentName) {
472 Optional<PropertyDefinition> servicePropertyCandidate = properties.stream()
473 .filter(property -> property.getName().equals(serviceConsumptionData.getValue())).findAny();
474 if (servicePropertyCandidate.isPresent()) {
475 boolean isInputTypeSimilarToOperation = isAssignedValueFromValidType(operationInputDefinition.getType(), servicePropertyCandidate.get());
476 if (!isInputTypeSimilarToOperation) {
477 return Either.right(componentsUtils.getResponseFormat(ActionStatus.INVALID_CONSUMPTION_TYPE, operationInputDefinition.getType()));
479 addPropertyToInputValue(componentName, operation, operationInputDefinition, servicePropertyCandidate.get());
481 return Either.left(operation);
484 private Either<Operation, ResponseFormat> handleConsumptionInputMappedToOperationOutput(Operation operation,
485 OperationInputDefinition operationInputDefinition,
486 List<OperationOutputDefinition> outputs,
487 String consumptionValue, String componentName) {
488 String outputName = getOperationOutputName(consumptionValue);
489 Optional<OperationOutputDefinition> servicePropertyOutputCandidate = outputs.stream().filter(output -> output.getName().equals(outputName))
491 if (servicePropertyOutputCandidate.isPresent()) {
492 boolean isInputTypeSimilarToOperation = isAssignedValueFromValidType(operationInputDefinition.getType(),
493 servicePropertyOutputCandidate.get());
494 if (!isInputTypeSimilarToOperation) {
495 return Either.right(componentsUtils.getResponseFormat(ActionStatus.INVALID_CONSUMPTION_TYPE, operationInputDefinition.getType()));
497 addOutputToInputValue(componentName, consumptionValue, operation, operationInputDefinition);
499 return Either.left(operation);
502 private void addPropertyToInputValue(String componentName, Operation operation, OperationInputDefinition operationInputDefinition,
503 PropertyDefinition serviceProperty) {
504 Map<String, List<String>> getProperty = new HashMap<>();
505 List<String> getPropertyValues = new ArrayList<>();
506 getPropertyValues.add(componentName);
507 getPropertyValues.add(serviceProperty.getName());
508 getProperty.put(ToscaFunctions.GET_PROPERTY.getFunctionName(), getPropertyValues);
509 operationInputDefinition.setSourceProperty(serviceProperty.getUniqueId());
510 operation.getInputs().delete(operationInputDefinition);
511 operationInputDefinition.setToscaPresentationValue(JsonPresentationFields.GET_PROPERTY, getPropertyValues);
512 operationInputDefinition.setValue((new Gson()).toJson(getProperty));
513 operation.getInputs().add(operationInputDefinition);
516 private void addOutputToInputValue(String componentName, String consumptionValue, Operation operation,
517 OperationInputDefinition operationInputDefinition) {
518 Map<String, List<String>> getOperationOutput = InterfaceOperationUtils.createMappedOutputDefaultValue(componentName, consumptionValue);
519 operation.getInputs().delete(operationInputDefinition);
520 operationInputDefinition.setToscaPresentationValue(JsonPresentationFields.GET_OPERATION_OUTPUT, getOperationOutput);
521 operationInputDefinition.setValue((new Gson()).toJson(getOperationOutput));
522 operation.getInputs().add(operationInputDefinition);
525 public Either<Operation, ResponseFormat> handleConsumptionStaticValue(String value, String type, Operation operation,
526 OperationInputDefinition operationInputDefinition, String model) {
527 boolean isInputTypeSimilarToOperation = isAssignedValueFromValidType(type, value);
528 if (!isInputTypeSimilarToOperation) {
529 return Either.right(componentsUtils.getResponseFormat(ActionStatus.INVALID_CONSUMPTION_TYPE, type));
531 //Validate Constraint and Value
532 Either<Boolean, ResponseFormat> constraintValidationResponse = validateOperationInputConstraint(operationInputDefinition, value, type, model);
533 if (constraintValidationResponse.isRight()) {
534 return Either.right(constraintValidationResponse.right().value());
536 addStaticValueToInputOperation(value, operation, operationInputDefinition);
537 return Either.left(operation);
540 private Either<Boolean, ResponseFormat> validateOperationInputConstraint(OperationInputDefinition operationInputDefinition, String value,
541 String type, String model) {
542 ComponentInstanceProperty propertyDefinition = new ComponentInstanceProperty();
543 propertyDefinition.setType(operationInputDefinition.getParentPropertyType());
544 InputDefinition inputDefinition = new InputDefinition();
545 inputDefinition.setDefaultValue(value);
546 inputDefinition.setInputPath(operationInputDefinition.getSubPropertyInputPath());
547 inputDefinition.setType(type);
548 if (Objects.nonNull(operationInputDefinition.getParentPropertyType())) {
549 inputDefinition.setProperties(Collections.singletonList(propertyDefinition));
551 return PropertyValueConstraintValidationUtil.getInstance().validatePropertyConstraints(Collections.singletonList(inputDefinition),
552 applicationDataTypeCache, model);
555 private void addStaticValueToInputOperation(String value, Operation operation, OperationInputDefinition operationInputDefinition) {
556 operation.getInputs().delete(operationInputDefinition);
557 operationInputDefinition.setSource(STATIC.getSource());
558 operationInputDefinition.setSourceProperty(null);
559 operationInputDefinition.setValue(value);
560 operation.getInputs().add(operationInputDefinition);
563 private Either<Operation, ResponseFormat> handleConsumptionInputValue(String inputId, Service service, Operation operation,
564 OperationInputDefinition operationInputDefinition) {
565 List<InputDefinition> serviceInputs = service.getInputs();
566 Optional<InputDefinition> inputForValue = serviceInputs.stream().filter(input -> input.getUniqueId().contains(inputId)).findAny();
567 if (inputForValue.isPresent()) {
568 boolean isInputTypeSimilarToOperation = isAssignedValueFromValidType(operationInputDefinition.getType(), inputForValue.get());
569 if (!isInputTypeSimilarToOperation) {
570 return Either.right(componentsUtils.getResponseFormat(ActionStatus.INVALID_CONSUMPTION_TYPE, operationInputDefinition.getType()));
572 addGetInputValueToOperationInput(operation, operationInputDefinition, inputForValue.get());
574 return Either.left(operation);
577 private void addGetInputValueToOperationInput(Operation operation, OperationInputDefinition operationInputDefinition,
578 InputDefinition inputForValue) {
579 operation.getInputs().delete(operationInputDefinition);
580 Map<String, String> getInputMap = new HashMap<>();
581 getInputMap.put(ToscaFunctions.GET_INPUT.getFunctionName(), inputForValue.getName());
582 operationInputDefinition.setSourceProperty(inputForValue.getUniqueId());
583 operationInputDefinition.setToscaPresentationValue(JsonPresentationFields.GET_INPUT, getInputMap);
584 operationInputDefinition.setValue(new Gson().toJson(getInputMap));
585 operation.getInputs().add(operationInputDefinition);
588 private Either<List<Map<String, Object>>, ActionStatus> getAuditRecordsForUncertifiedComponent(String componentUUID, String componentVersion) {
590 Either<List<ResourceAdminEvent>, ActionStatus> eitherprevVerAudit = auditCassandraDao
591 .getAuditByServiceIdAndPrevVersion(componentUUID, componentVersion);
592 if (eitherprevVerAudit.isRight()) {
593 return Either.right(eitherprevVerAudit.right().value());
596 Either<List<ResourceAdminEvent>, ActionStatus> eitherCurrVerAudit = auditCassandraDao
597 .getAuditByServiceIdAndCurrVersion(componentUUID, componentVersion);
598 if (eitherCurrVerAudit.isRight()) {
599 return Either.right(eitherCurrVerAudit.right().value());
601 Either<List<ResourceAdminEvent>, ActionStatus> eitherArchiveRestoreList = getArchiveRestoreEventList(componentUUID);
602 if (eitherArchiveRestoreList.isRight()) {
603 return Either.right(eitherArchiveRestoreList.right().value());
605 List<Map<String, Object>> prevVerAuditList = getAuditingFieldsList(eitherprevVerAudit.left().value());
606 List<Map<String, Object>> currVerAuditList = getAuditingFieldsList(eitherCurrVerAudit.left().value());
607 List<Map<String, Object>> duplicateElements = new ArrayList<>();
608 duplicateElements.addAll(prevVerAuditList);
609 duplicateElements.retainAll(currVerAuditList);
610 List<Map<String, Object>> joinedNonDuplicatedList = new ArrayList<>();
611 joinedNonDuplicatedList.addAll(prevVerAuditList);
612 joinedNonDuplicatedList.removeAll(duplicateElements);
613 joinedNonDuplicatedList.addAll(currVerAuditList);
614 joinedNonDuplicatedList.addAll(getAuditingFieldsList(eitherArchiveRestoreList.left().value()));
615 return Either.left(joinedNonDuplicatedList);
618 private Either<List<ResourceAdminEvent>, ActionStatus> getArchiveRestoreEventList(String componentUUID) {
620 Either<List<ResourceAdminEvent>, ActionStatus> eitherArchiveAudit = auditCassandraDao.getArchiveAuditByServiceInstanceId(componentUUID);
621 if (eitherArchiveAudit.isRight()) {
622 return Either.right(eitherArchiveAudit.right().value());
625 Either<List<ResourceAdminEvent>, ActionStatus> eitherRestoreAudit = auditCassandraDao.getRestoreAuditByServiceInstanceId(componentUUID);
626 if (eitherRestoreAudit.isRight()) {
627 return Either.right(eitherRestoreAudit.right().value());
629 List<ResourceAdminEvent> archiveAudit = new ArrayList<>();
630 archiveAudit.addAll(eitherArchiveAudit.left().value());
631 archiveAudit.addAll(eitherRestoreAudit.left().value());
632 return Either.left(archiveAudit);
636 public void setServiceValidator(ServiceValidator serviceValidator) {
637 this.serviceValidator = serviceValidator;
641 public void setServiceCategoryValidator(ServiceCategoryValidator serviceCategoryValidator) {
642 this.serviceCategoryValidator = serviceCategoryValidator;
645 private List<Map<String, Object>> getAuditingFieldsList(List<? extends AuditingGenericEvent> prevVerAuditList) {
646 List<Map<String, Object>> prevVerAudit = new ArrayList<>();
647 for (AuditingGenericEvent auditEvent : prevVerAuditList) {
648 auditEvent.fillFields();
649 prevVerAudit.add(auditEvent.getFields());
657 * @param service - Service
658 * @param user - modifier data (userId)
659 * @return Either<Service, responseFormat>
661 public Either<Service, ResponseFormat> createService(Service service, User user) {
663 user = validateUser(user, "Create Service", service, AuditingActionEnum.CREATE_RESOURCE, false);
664 log.debug("User returned from validation: " + user.toString());
665 // validate user role
666 validateUserRole(user, service, new ArrayList<>(), AuditingActionEnum.CREATE_RESOURCE, null);
667 service.setCreatorUserId(user.getUserId());
668 // warn on overridden fields
669 checkFieldsForOverideAttampt(service);
671 log.debug("enrich service with version and state");
672 service.setState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
673 service.setVersion(INITIAL_VERSION);
674 service.setConformanceLevel(ConfigurationManager.getConfigurationManager().getConfiguration().getToscaConformanceLevel());
675 service.setDistributionStatus(DistributionStatusEnum.DISTRIBUTION_NOT_APPROVED);
676 service.setComponentType(ComponentTypeEnum.SERVICE);
677 Either<Service, ResponseFormat> createServiceResponse = validateServiceBeforeCreate(service, user, AuditingActionEnum.CREATE_RESOURCE);
678 if (createServiceResponse.isRight()) {
679 return createServiceResponse;
681 return createServiceByDao(service, user).left().bind(c -> updateCatalog(c, ChangeTypeEnum.LIFECYCLE).left().map(r -> (Service) r));
684 private void checkFieldsForOverideAttampt(Service service) {
685 checkComponentFieldsForOverrideAttempt(service);
686 if (service.getDistributionStatus() != null) {
687 log.info("Distribution Status cannot be defined by user. This field will be overridden by the application");
691 private Either<Service, ResponseFormat> createServiceByDao(final Service service, final User user) {
692 log.debug("send service {} to dao for create", service.getComponentMetadataDefinition().getMetadataDataDefinition().getName());
693 Either<Boolean, ResponseFormat> lockResult = lockComponentByName(service.getSystemName(), service, "Create Service");
694 if (lockResult.isRight()) {
695 ResponseFormat responseFormat = lockResult.right().value();
696 componentsUtils.auditComponentAdmin(responseFormat, user, service, AuditingActionEnum.CREATE_RESOURCE, ComponentTypeEnum.SERVICE);
697 return Either.right(responseFormat);
699 log.debug("System name locked is {}, status = {}", service.getSystemName(), lockResult);
701 createMandatoryArtifactsData(service, user);
702 createServiceApiArtifactsData(service, user);
703 setToscaArtifactsPlaceHolders(service, user);
704 if (service.isSubstituteCandidate()) {
705 final Resource genericType = fetchAndSetDerivedFromGenericType(service);
706 generatePropertiesFromGenericType(service, genericType);
707 generateAndAddInputsFromGenericTypeProperties(service, genericType);
709 beforeCreate(service);
710 Either<Service, StorageOperationStatus> dataModelResponse = toscaOperationFacade.createToscaComponent(service);
711 if (dataModelResponse.isLeft()) {
712 log.debug("Service '{}' created successfully", service.getName());
713 ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.CREATED);
714 componentsUtils.auditComponentAdmin(responseFormat, user, service, AuditingActionEnum.CREATE_RESOURCE, ComponentTypeEnum.SERVICE);
715 ASDCKpiApi.countCreatedServicesKPI();
716 return Either.left(dataModelResponse.left().value());
718 ResponseFormat responseFormat = componentsUtils
719 .getResponseFormatByComponent(componentsUtils.convertFromStorageResponse(dataModelResponse.right().value()), service,
720 ComponentTypeEnum.SERVICE);
721 log.debug(AUDIT_BEFORE_SENDING_RESPONSE);
722 componentsUtils.auditComponentAdmin(responseFormat, user, service, AuditingActionEnum.CREATE_RESOURCE, ComponentTypeEnum.SERVICE);
723 return Either.right(responseFormat);
725 graphLockOperation.unlockComponentByName(service.getSystemName(), service.getUniqueId(), NodeTypeEnum.Service);
729 private void beforeCreate(final Service service) {
730 if (CollectionUtils.isEmpty(serviceCreationPluginList)) {
733 serviceCreationPluginList.stream().sorted(Comparator.comparingInt(ServiceCreationPlugin::getOrder)).forEach(serviceCreationPlugin -> {
735 serviceCreationPlugin.beforeCreate(service);
736 } catch (final Exception e) {
737 log.error("An error has occurred while running the serviceCreationPlugin '{}'", serviceCreationPlugin.getClass(), e);
742 @SuppressWarnings("unchecked")
743 private void createServiceApiArtifactsData(Service service, User user) {
744 // create mandatory artifacts
746 // TODO it must be removed after that artifact uniqueId creation will be
748 // moved to ArtifactOperation
749 String serviceUniqueId = service.getUniqueId();
750 Map<String, ArtifactDefinition> artifactMap = service.getServiceApiArtifacts();
751 if (artifactMap == null) {
752 artifactMap = new HashMap<>();
754 Map<String, Object> serviceApiArtifacts = ConfigurationManager.getConfigurationManager().getConfiguration().getServiceApiArtifacts();
755 List<String> exludeServiceCategory = ConfigurationManager.getConfigurationManager().getConfiguration().getExcludeServiceCategory();
756 List<CategoryDefinition> categories = service.getCategories();
757 boolean isCreateArtifact = true;
758 if (categories != null && exludeServiceCategory != null && !exludeServiceCategory.isEmpty()) {
759 for (String exlude : exludeServiceCategory) {
760 if (exlude.equalsIgnoreCase(categories.get(0).getName())) {
761 isCreateArtifact = false;
766 if (serviceApiArtifacts != null && isCreateArtifact) {
767 Set<String> keys = serviceApiArtifacts.keySet();
768 for (String serviceApiArtifactName : keys) {
769 Map<String, Object> artifactInfoMap = (Map<String, Object>) serviceApiArtifacts.get(serviceApiArtifactName);
770 ArtifactDefinition artifactDefinition = createArtifactDefinition(serviceUniqueId, serviceApiArtifactName, artifactInfoMap, user,
772 artifactDefinition.setArtifactGroupType(ArtifactGroupTypeEnum.SERVICE_API);
773 artifactMap.put(artifactDefinition.getArtifactLabel(), artifactDefinition);
775 service.setServiceApiArtifacts(artifactMap);
780 protected Either<Service, ResponseFormat> validateServiceBeforeCreate(Service service, User user, AuditingActionEnum actionEnum) {
782 serviceValidator.validate(user, service, actionEnum);
783 } catch (ComponentException exp) {
784 ResponseFormat responseFormat = componentsUtils.getResponseFormat(exp);
785 componentsUtils.auditComponentAdmin(responseFormat, user, service, AuditingActionEnum.CREATE_SERVICE, ComponentTypeEnum.SERVICE);
788 service.setCreatorFullName(user.getFirstName() + " " + user.getLastName());
789 service.setContactId(service.getContactId().toLowerCase());
790 // Generate invariant UUID - must be here and not in operation since it
792 // should stay constant during clone
793 String invariantUUID = UniqueIdBuilder.buildInvariantUUID();
794 service.setInvariantUUID(invariantUUID);
795 return Either.left(service);
798 public Either<Map<String, Boolean>, ResponseFormat> validateServiceNameExists(String serviceName, String userId) {
799 validateUserExists(userId);
800 Either<Boolean, StorageOperationStatus> dataModelResponse = toscaOperationFacade
801 .validateComponentNameUniqueness(serviceName, null, ComponentTypeEnum.SERVICE);
803 janusGraphDao.commit();
804 if (dataModelResponse.isLeft()) {
805 Map<String, Boolean> result = new HashMap<>();
806 result.put(IS_VALID, dataModelResponse.left().value());
807 log.debug("validation was successfully performed.");
808 return Either.left(result);
810 ResponseFormat responseFormat = componentsUtils
811 .getResponseFormat(componentsUtils.convertFromStorageResponse(dataModelResponse.right().value()));
812 return Either.right(responseFormat);
815 public void setElementDao(IElementOperation elementDao) {
816 this.elementDao = elementDao;
820 public void setCassandraAuditingDao(AuditCassandraDao auditingDao) {
821 this.auditCassandraDao = auditingDao;
824 public ArtifactsBusinessLogic getArtifactBl() {
825 return artifactsBusinessLogic;
828 public void setArtifactBl(ArtifactsBusinessLogic artifactBl) {
829 this.artifactsBusinessLogic = artifactBl;
832 public Either<Service, ResponseFormat> updateServiceMetadata(String serviceId, Service serviceUpdate, User user) {
833 user = validateUser(user, "updateServiceMetadata", serviceUpdate, null, false);
834 // validate user role
835 validateUserRole(user, serviceUpdate, new ArrayList<>(), null, null);
836 Either<Service, StorageOperationStatus> storageStatus = toscaOperationFacade.getToscaElement(serviceId);
837 if (storageStatus.isRight()) {
838 return Either.right(componentsUtils
839 .getResponseFormat(componentsUtils.convertFromStorageResponse(storageStatus.right().value(), ComponentTypeEnum.SERVICE), ""));
841 Service currentService = storageStatus.left().value();
842 if (!ComponentValidationUtils.canWorkOnComponent(currentService, user.getUserId())) {
843 log.info("Restricted operation for user: {}, on service: {}", user.getUserId(), currentService.getCreatorUserId());
844 return Either.right(componentsUtils.getResponseFormat(ActionStatus.RESTRICTED_OPERATION));
846 Either<Service, ResponseFormat> validationRsponse = validateAndUpdateServiceMetadata(user, currentService, serviceUpdate);
847 if (validationRsponse.isRight()) {
848 log.info("service update metadata: validations field.");
849 return validationRsponse;
851 Service serviceToUpdate = validationRsponse.left().value();
853 lockComponent(serviceId, currentService, "Update Service Metadata");
855 return toscaOperationFacade.updateToscaElement(serviceToUpdate).right().map(rf -> {
856 janusGraphDao.rollback();
857 BeEcompErrorManager.getInstance().logBeSystemError("Update Service Metadata");
858 log.debug("failed to update sevice {}", serviceToUpdate.getUniqueId());
859 return (componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR));
860 }).left().bind(c -> updateCatalogAndCommit(c));
862 graphLockOperation.unlockComponent(serviceId, NodeTypeEnum.Service);
866 private Either<Service, ResponseFormat> updateCatalogAndCommit(Service service) {
867 Either<Service, ResponseFormat> res = updateCatalog(service, ChangeTypeEnum.LIFECYCLE).left().map(s -> (Service) s);
868 janusGraphDao.commit();
872 public Set<String> deleteForwardingPaths(String serviceId, Set<String> pathIdsToDelete, User user, boolean lock) {
873 Service serviceToDelete = initServiceToDeletePaths(serviceId, pathIdsToDelete);
874 user = validateUser(user, "deleteForwardingPaths", serviceToDelete, null, false);
875 // validate user role
876 validateUserRole(user, serviceToDelete, new ArrayList<>(), null, null);
877 Either<Service, StorageOperationStatus> storageStatus = toscaOperationFacade.getToscaElement(serviceId);
878 if (storageStatus.isRight()) {
879 throw new ByActionStatusComponentException(
880 componentsUtils.convertFromStorageResponse(storageStatus.right().value(), ComponentTypeEnum.SERVICE), "");
882 Service service = storageStatus.left().value();
883 Either<Set<String>, StorageOperationStatus> result = null;
886 lockComponent(service.getUniqueId(), service, "Delete Forwarding Path on Service");
887 } catch (ComponentException e) {
888 janusGraphDao.rollback();
889 throw new ByActionStatusComponentException(
890 componentsUtils.convertFromStorageResponse(storageStatus.right().value(), ComponentTypeEnum.SERVICE), "");
894 result = forwardingPathOperation.deleteForwardingPath(service, pathIdsToDelete);
895 if (result.isRight()) {
896 log.debug(FAILED_TO_LOCK_SERVICE_RESPONSE_IS, service.getName(), result.right().value());
897 janusGraphDao.rollback();
898 throw new ByActionStatusComponentException(
899 componentsUtils.convertFromStorageResponse(storageStatus.right().value(), ComponentTypeEnum.SERVICE));
901 janusGraphDao.commit();
902 log.debug(THE_SERVICE_WITH_SYSTEM_NAME_LOCKED, service.getSystemName());
903 } catch (ComponentException e) {
904 log.error("Exception occurred during delete forwarding path : {}", e.getMessage(), e);
905 janusGraphDao.rollback();
906 throw new ByActionStatusComponentException(ActionStatus.GENERAL_ERROR);
908 graphLockOperation.unlockComponent(service.getUniqueId(), NodeTypeEnum.Service);
910 return result.left().value();
913 private Service initServiceToDeletePaths(String serviceId, Collection<String> pathIdsToDelete) {
914 Service serviceToDelete = new Service();
915 serviceToDelete.setUniqueId(serviceId);
916 serviceToDelete.setForwardingPaths(new HashMap<>());
917 pathIdsToDelete.forEach(pathIdToDelete -> serviceToDelete.getForwardingPaths().put(pathIdToDelete, new ForwardingPathDataDefinition()));
918 return serviceToDelete;
921 public Service updateForwardingPath(String serviceId, Service serviceUpdate, User user, boolean lock) {
922 return createOrUpdateForwardingPath(serviceId, serviceUpdate, user, true, "updateForwardingPath", lock);
925 public Service createForwardingPath(String serviceId, Service serviceUpdate, User user, boolean lock) {
926 return createOrUpdateForwardingPath(serviceId, serviceUpdate, user, false, "createForwardingPath", lock);
929 private ForwardingPathDataDefinition getTrimmedValues(ForwardingPathDataDefinition path) {
930 ForwardingPathDataDefinition dataDefinition = new ForwardingPathDataDefinition(path.getName());
931 dataDefinition.setName(Strings.nullToEmpty(path.getName()).trim());
932 dataDefinition.setProtocol(Strings.nullToEmpty(path.getProtocol()).trim());
933 dataDefinition.setDestinationPortNumber(Strings.nullToEmpty(path.getDestinationPortNumber()).trim());
934 dataDefinition.setUniqueId(path.getUniqueId());
935 dataDefinition.setPathElements(path.getPathElements());
936 dataDefinition.setDescription(path.getDescription());
937 dataDefinition.setToscaResourceName(path.getToscaResourceName());
938 return dataDefinition;
941 private Service createOrUpdateForwardingPath(String serviceId, Service serviceUpdate, User user, boolean isUpdate, String errorContext,
943 validateUserAndRole(serviceUpdate, user, errorContext);
944 Map<String, ForwardingPathDataDefinition> forwardingPaths = serviceUpdate.getForwardingPaths();
945 Map<String, ForwardingPathDataDefinition> trimmedForwardingPaths = forwardingPaths.entrySet().stream()
946 .collect(Collectors.toMap(Map.Entry::getKey, entry -> new ForwardingPathDataDefinition(getTrimmedValues(entry.getValue()))));
947 forwardingPathValidator.validateForwardingPaths(trimmedForwardingPaths.values(), serviceId, isUpdate);
948 Either<Service, StorageOperationStatus> serviceStorageOperationStatusEither = toscaOperationFacade.getToscaElement(serviceId);
949 if (serviceStorageOperationStatusEither.isRight()) {
950 StorageOperationStatus errorStatus = serviceStorageOperationStatusEither.right().value();
951 log.debug("Failed to fetch service information by service id, error {}", errorStatus);
952 throw new ByActionStatusComponentException(componentsUtils.convertFromStorageResponse(errorStatus));
954 Service storedService = serviceStorageOperationStatusEither.left().value();
955 Either<ForwardingPathDataDefinition, StorageOperationStatus> result;
956 Component component = getForwardingPathOriginComponent();
957 final String toscaResourceName;
958 if (component.getComponentType() == ComponentTypeEnum.RESOURCE) {
959 toscaResourceName = ((Resource) component).getToscaResourceName();
961 toscaResourceName = "";
964 lockComponent(storedService.getUniqueId(), storedService, "Add or Update Forwarding Path on Service");
965 log.debug(THE_SERVICE_WITH_SYSTEM_NAME_LOCKED, storedService.getSystemName());
967 Map<String, ForwardingPathDataDefinition> resultMap = new HashMap<>();
969 trimmedForwardingPaths.values().forEach(fp -> fp.setToscaResourceName(toscaResourceName));
970 populateForwardingPaths(serviceId, isUpdate, trimmedForwardingPaths, resultMap);
971 janusGraphDao.commit();
974 graphLockOperation.unlockComponent(storedService.getUniqueId(), NodeTypeEnum.Service);
977 return createServiceWithForwardingPathForResponse(serviceId, resultMap);
980 private Component getForwardingPathOriginComponent() {
981 Either<Component, StorageOperationStatus> forwardingPathOrigin = toscaOperationFacade
982 .getLatestByName(ForwardingPathUtils.FORWARDING_PATH_NODE_NAME, null);
983 if (forwardingPathOrigin.isRight()) {
984 StorageOperationStatus errorStatus = forwardingPathOrigin.right().value();
985 log.debug("Failed to fetch normative forwarding path resource by tosca name, error {}", errorStatus);
986 throw new ByActionStatusComponentException(componentsUtils.convertFromStorageResponse(errorStatus));
988 return forwardingPathOrigin.left().value();
991 private void populateForwardingPaths(String serviceId, boolean isUpdate, Map<String, ForwardingPathDataDefinition> trimmedForwardingPaths,
992 Map<String, ForwardingPathDataDefinition> resultMap) {
993 Either<ForwardingPathDataDefinition, StorageOperationStatus> result;
995 for (ForwardingPathDataDefinition forwardingPathDataDefinition : trimmedForwardingPaths.values()) {
997 result = forwardingPathOperation.updateForwardingPath(serviceId, forwardingPathDataDefinition);
999 result = forwardingPathOperation.addForwardingPath(serviceId, forwardingPathDataDefinition);
1001 if (result.isRight()) {
1002 janusGraphDao.rollback();
1003 throw new ByResponseFormatComponentException(componentsUtils
1004 .getResponseFormat(componentsUtils.convertFromStorageResponse(result.right().value(), ComponentTypeEnum.SERVICE), ""));
1006 ForwardingPathDataDefinition fpDataDefinition = result.left().value();
1007 resultMap.put(fpDataDefinition.getUniqueId(), forwardingPathDataDefinition);
1010 } catch (ComponentException e) {
1011 janusGraphDao.rollback();
1012 log.error("Exception occurred during add or update forwarding path property values: {}", e.getMessage(), e);
1013 throw new ByActionStatusComponentException(ActionStatus.GENERAL_ERROR);
1017 private Service createServiceWithForwardingPathForResponse(String serviceId,
1018 Map<String, ForwardingPathDataDefinition> forwardingPathDataDefinitionMap) {
1019 Service service = new Service();
1020 service.setUniqueId(serviceId);
1021 service.setForwardingPaths(forwardingPathDataDefinitionMap);
1025 private void validateUserAndRole(Service serviceUpdate, User user, String errorContext) {
1026 user = validateUser(user, errorContext, serviceUpdate, null, false);
1027 validateUserRole(user, serviceUpdate, new ArrayList<>(), null, null);
1031 Either<Service, ResponseFormat> validateAndUpdateServiceMetadata(User user, Service currentService, Service serviceUpdate) {
1033 boolean hasBeenCertified = ValidationUtils.hasBeenCertified(currentService.getVersion());
1034 Either<Boolean, ResponseFormat> response = validateAndUpdateCategory(user, currentService, serviceUpdate, hasBeenCertified,
1035 UPDATE_SERVICE_METADATA);
1036 if (response.isRight()) {
1037 ResponseFormat errorResponse = response.right().value();
1038 return Either.right(errorResponse);
1040 verifyValuesAreIdentical(serviceUpdate.getCreatorUserId(), currentService.getCreatorUserId(), "creatorUserId");
1041 verifyValuesAreIdentical(serviceUpdate.getCreatorFullName(), currentService.getCreatorFullName(), "creatorFullName");
1042 verifyValuesAreIdentical(serviceUpdate.getLastUpdaterUserId(), currentService.getLastUpdaterUserId(), "lastUpdaterUserId");
1043 verifyValuesAreIdentical(serviceUpdate.getLastUpdaterFullName(), currentService.getLastUpdaterFullName(), "lastUpdaterFullName");
1044 response = validateAndUpdateServiceName(user, currentService, serviceUpdate, hasBeenCertified, null);
1045 if (response.isRight()) {
1046 return Either.right(response.right().value());
1048 verifyValuesAreIdentical(serviceUpdate.getDistributionStatus(), currentService.getDistributionStatus(), "distributionStatus");
1049 if (serviceUpdate.getProjectCode() != null) {
1050 response = validateAndUpdateProjectCode(user, currentService, serviceUpdate, UPDATE_SERVICE_METADATA);
1051 if (response.isRight()) {
1052 return Either.right(response.right().value());
1055 response = validateAndUpdateIcon(user, currentService, serviceUpdate, hasBeenCertified, UPDATE_SERVICE_METADATA);
1056 if (response.isRight()) {
1057 return Either.right(response.right().value());
1059 verifyValuesAreIdentical(serviceUpdate.getCreationDate(), currentService.getCreationDate(), "creationDate");
1060 verifyValuesAreIdentical(serviceUpdate.getVersion(), currentService.getVersion(), "version");
1061 response = validateAndUpdateDescription(user, currentService, serviceUpdate, UPDATE_SERVICE_METADATA);
1062 if (response.isRight()) {
1063 return Either.right(response.right().value());
1065 response = validateAndUpdateTags(user, currentService, serviceUpdate, UPDATE_SERVICE_METADATA);
1066 if (response.isRight()) {
1067 return Either.right(response.right().value());
1069 response = validateAndUpdateContactId(user, currentService, serviceUpdate, UPDATE_SERVICE_METADATA);
1070 if (response.isRight()) {
1071 return Either.right(response.right().value());
1073 verifyValuesAreIdentical(serviceUpdate.getLastUpdateDate(), currentService.getLastUpdateDate(), "lastUpdateDate");
1074 verifyValuesAreIdentical(serviceUpdate.getLifecycleState(), currentService.getLifecycleState(), "lifecycleState");
1075 verifyValuesAreIdentical(serviceUpdate.isHighestVersion(), currentService.isHighestVersion(), "isHighestVersion");
1076 verifyValuesAreIdentical(serviceUpdate.getUUID(), currentService.getUUID(), "uuid");
1077 validateAndUpdateServiceType(currentService, serviceUpdate);
1078 validateAndUpdateServiceFunction(currentService, serviceUpdate);
1079 response = validateAndUpdateServiceRole(user, currentService, serviceUpdate, UPDATE_SERVICE_METADATA);
1080 if (response.isRight()) {
1081 return Either.right(response.right().value());
1083 response = validateAndUpdateInstantiationTypeValue(user, currentService, serviceUpdate, UPDATE_SERVICE_METADATA);
1084 if (response.isRight()) {
1085 return Either.right(response.right().value());
1087 verifyValuesAreIdentical(serviceUpdate.getInvariantUUID(), currentService.getInvariantUUID(), "invariantUUID");
1088 validateAndUpdateEcompNaming(currentService, serviceUpdate);
1089 currentService.setEnvironmentContext(serviceUpdate.getEnvironmentContext());
1090 currentService.setCategorySpecificMetadata(serviceUpdate.getCategorySpecificMetadata());
1091 return Either.left(currentService);
1092 } catch (ComponentException exception) {
1093 ResponseFormat responseFormat = componentsUtils.getResponseFormat(exception);
1095 .auditComponentAdmin(responseFormat, user, serviceUpdate, AuditingActionEnum.UPDATE_SERVICE_METADATA, ComponentTypeEnum.SERVICE);
1096 return Either.right(responseFormat);
1100 private void verifyValuesAreIdentical(Object updatedValue, Object originalValue, String fieldName) {
1101 if (updatedValue != null && !updatedValue.equals(originalValue)) {
1102 log.info("update service: received request to update {} to {} the field is not updatable ignoring.", fieldName, updatedValue);
1106 private void validateAndUpdateEcompNaming(Service currentService, Service serviceUpdate) {
1107 Boolean isEcompGeneratedCurr = currentService.isEcompGeneratedNaming();
1108 Boolean isEcompGeneratedUpdate = serviceUpdate.isEcompGeneratedNaming();
1109 if (isEcompGeneratedUpdate != null && !isEcompGeneratedUpdate.equals(isEcompGeneratedCurr)) {
1110 currentService.setEcompGeneratedNaming(isEcompGeneratedUpdate);
1112 String namingPolicyUpdate = serviceUpdate.getNamingPolicy();
1113 if (currentService.isEcompGeneratedNaming() != null && currentService.isEcompGeneratedNaming()) {
1114 currentService.setNamingPolicy(namingPolicyUpdate);
1116 if (!StringUtils.isEmpty(namingPolicyUpdate)) {
1117 log.warn("NamingPolicy must be empty for EcompGeneratedNaming=false");
1119 currentService.setNamingPolicy("");
1123 private Either<Boolean, ResponseFormat> validateAndUpdateContactId(User user, Service currentService, Service serviceUpdate,
1124 AuditingActionEnum audatingAction) {
1125 String contactIdUpdated = serviceUpdate.getContactId();
1126 String contactIdCurrent = currentService.getContactId();
1127 if (!contactIdCurrent.equals(contactIdUpdated)) {
1128 componentContactIdValidator.validateAndCorrectField(user, serviceUpdate, audatingAction);
1129 currentService.setContactId(contactIdUpdated.toLowerCase());
1131 return Either.left(true);
1134 private Either<Boolean, ResponseFormat> validateAndUpdateTags(User user, Service currentService, Service serviceUpdate,
1135 AuditingActionEnum audatingAction) {
1136 List<String> tagsUpdated = serviceUpdate.getTags();
1137 List<String> tagsCurrent = currentService.getTags();
1138 if (tagsUpdated == null || tagsUpdated.isEmpty()) {
1139 ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.COMPONENT_MISSING_TAGS);
1140 componentsUtils.auditComponentAdmin(responseFormat, user, serviceUpdate, audatingAction, ComponentTypeEnum.SERVICE);
1141 return Either.right(responseFormat);
1143 if (!(tagsCurrent.containsAll(tagsUpdated) && tagsUpdated.containsAll(tagsCurrent))) {
1144 componentTagsValidator.validateAndCorrectField(user, serviceUpdate, audatingAction);
1145 currentService.setTags(tagsUpdated);
1147 return Either.left(true);
1150 private Either<Boolean, ResponseFormat> validateAndUpdateDescription(User user, Service currentService, Service serviceUpdate,
1151 AuditingActionEnum audatingAction) {
1152 String descriptionUpdated = serviceUpdate.getDescription();
1153 String descriptionCurrent = currentService.getDescription();
1154 if (!descriptionCurrent.equals(descriptionUpdated)) {
1155 componentDescriptionValidator.validateAndCorrectField(user, serviceUpdate, audatingAction);
1156 currentService.setDescription(serviceUpdate.getDescription());
1158 return Either.left(true);
1161 private Either<Boolean, ResponseFormat> validateAndUpdateProjectCode(User user, Service currentService, Service serviceUpdate,
1162 AuditingActionEnum audatingAction) {
1163 String projectCodeUpdated = serviceUpdate.getProjectCode();
1164 String projectCodeCurrent = currentService.getProjectCode();
1165 if (StringUtils.isEmpty(projectCodeCurrent) || !projectCodeCurrent.equals(projectCodeUpdated)) {
1167 componentProjectCodeValidator.validateAndCorrectField(user, serviceUpdate, audatingAction);
1168 } catch (ComponentException exp) {
1169 ResponseFormat errorRespons = exp.getResponseFormat();
1170 return Either.right(errorRespons);
1172 currentService.setProjectCode(projectCodeUpdated);
1174 return Either.left(true);
1177 private Either<Boolean, ResponseFormat> validateAndUpdateIcon(User user, Service currentService, Service serviceUpdate, boolean hasBeenCertified,
1178 AuditingActionEnum audatingAction) {
1179 String iconUpdated = serviceUpdate.getIcon();
1180 String iconCurrent = currentService.getIcon();
1181 if (!iconCurrent.equals(iconUpdated)) {
1182 if (!hasBeenCertified) {
1183 componentIconValidator.validateAndCorrectField(user, serviceUpdate, audatingAction);
1184 currentService.setIcon(iconUpdated);
1186 log.info("icon {} cannot be updated once the service has been certified once.", iconUpdated);
1187 ResponseFormat errorResponse = componentsUtils.getResponseFormat(ActionStatus.SERVICE_ICON_CANNOT_BE_CHANGED);
1188 return Either.right(errorResponse);
1191 return Either.left(true);
1194 private Either<Boolean, ResponseFormat> validateAndUpdateServiceName(User user, Service currentService, Service serviceUpdate,
1195 boolean hasBeenCertified, AuditingActionEnum auditingAction) {
1196 String serviceNameUpdated = serviceUpdate.getName();
1197 String serviceNameCurrent = currentService.getName();
1198 if (!serviceNameCurrent.equals(serviceNameUpdated)) {
1199 if (!hasBeenCertified) {
1200 componentNameValidator.validateAndCorrectField(user, serviceUpdate, auditingAction);
1202 componentNameValidator.validateComponentNameUnique(user, serviceUpdate, auditingAction);
1203 } catch (ComponentException exp) {
1204 return Either.right(exp.getResponseFormat());
1206 currentService.setName(serviceNameUpdated);
1207 currentService.getComponentMetadataDefinition().getMetadataDataDefinition()
1208 .setNormalizedName(ValidationUtils.normaliseComponentName(serviceNameUpdated));
1209 currentService.getComponentMetadataDefinition().getMetadataDataDefinition()
1210 .setSystemName(ValidationUtils.convertToSystemName(serviceNameUpdated));
1212 log.info("service name {} cannot be updated once the service has been certified once.", serviceNameUpdated);
1213 ResponseFormat errorResponse = componentsUtils.getResponseFormat(ActionStatus.SERVICE_NAME_CANNOT_BE_CHANGED);
1214 return Either.right(errorResponse);
1217 return Either.left(true);
1220 private void validateAndUpdateServiceType(Service currentService, Service updatedService) {
1221 String updatedServiceType = updatedService.getServiceType();
1222 String currentServiceType = currentService.getServiceType();
1223 if (!currentServiceType.equals(updatedServiceType)) {
1224 serviceTypeValidator.validateAndCorrectField(null, updatedService, null);
1225 currentService.setServiceType(updatedServiceType);
1229 private void validateAndUpdateServiceFunction(Service currentService, Service updatedService) {
1230 String updatedServiceFunction = updatedService.getServiceFunction();
1231 String currentServiceFunction = currentService.getServiceFunction();
1232 if (!currentServiceFunction.equals(updatedServiceFunction)) {
1233 serviceFunctionValidator.validateAndCorrectField(null, updatedService, null);
1234 currentService.setServiceFunction(updatedService.getServiceFunction());
1238 private Either<Boolean, ResponseFormat> validateAndUpdateServiceRole(User user, Service currentService, Service updatedService,
1239 AuditingActionEnum auditingAction) {
1240 String updatedServiceRole = updatedService.getServiceRole();
1241 String currentServiceRole = currentService.getServiceRole();
1242 if (!currentServiceRole.equals(updatedServiceRole)) {
1244 serviceRoleValidator.validateAndCorrectField(user, updatedService, auditingAction);
1245 } catch (ComponentException exp) {
1246 ResponseFormat errorResponse = exp.getResponseFormat();
1247 componentsUtils.auditComponentAdmin(errorResponse, user, updatedService, auditingAction, ComponentTypeEnum.SERVICE);
1248 return Either.right(errorResponse);
1250 currentService.setServiceRole(updatedServiceRole);
1252 return Either.left(true);
1255 private Either<Boolean, ResponseFormat> validateAndUpdateInstantiationTypeValue(User user, Service currentService, Service updatedService,
1256 AuditingActionEnum auditingAction) {
1257 String updatedInstaType = updatedService.getInstantiationType();
1258 String currentInstaType = currentService.getInstantiationType();
1259 if (!currentInstaType.equals(updatedInstaType)) {
1261 serviceInstantiationTypeValidator.validateAndCorrectField(user, updatedService, auditingAction);
1262 } catch (ComponentException exp) {
1263 ResponseFormat errorResponse = exp.getResponseFormat();
1264 componentsUtils.auditComponentAdmin(errorResponse, user, updatedService, auditingAction, ComponentTypeEnum.SERVICE);
1265 return Either.right(errorResponse);
1267 currentService.setInstantiationType(updatedInstaType);
1269 return Either.left(true);
1272 private Either<Boolean, ResponseFormat> validateAndUpdateCategory(User user, Service currentService, Service serviceUpdate,
1273 boolean hasBeenCertified, AuditingActionEnum audatingAction) {
1275 List<CategoryDefinition> categoryUpdated = serviceUpdate.getCategories();
1276 List<CategoryDefinition> categoryCurrent = currentService.getCategories();
1277 serviceCategoryValidator.validateAndCorrectField(user, serviceUpdate, audatingAction);
1278 if (!categoryCurrent.get(0).getName().equals(categoryUpdated.get(0).getName())) {
1279 if (!hasBeenCertified) {
1280 currentService.setCategories(categoryUpdated);
1282 log.info("category {} cannot be updated once the service has been certified once.", categoryUpdated);
1283 ResponseFormat errorResponse = componentsUtils.getResponseFormat(ActionStatus.SERVICE_CATEGORY_CANNOT_BE_CHANGED);
1284 return Either.right(errorResponse);
1287 } catch (ComponentException exp) {
1288 return Either.right(exp.getResponseFormat());
1290 return Either.left(true);
1293 public Either<ServiceRelations, ResponseFormat> getServiceComponentsRelations(String serviceId, User user) {
1294 Either<Service, ResponseFormat> serviceResponseFormatEither = getService(serviceId, user);
1295 if (serviceResponseFormatEither.isRight()) {
1296 return Either.right(serviceResponseFormatEither.right().value());
1298 final ServiceRelations serviceRelations = new ForwardingPathUtils()
1299 .convertServiceToServiceRelations(serviceResponseFormatEither.left().value());
1300 return Either.left(serviceRelations);
1303 public ResponseFormat deleteService(String serviceId, User user) {
1304 ResponseFormat responseFormat;
1305 validateUserExists(user);
1306 Either<Service, StorageOperationStatus> serviceStatus = toscaOperationFacade.getToscaElement(serviceId);
1307 if (serviceStatus.isRight()) {
1308 log.debug("failed to get service {}", serviceId);
1309 return componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(serviceStatus.right().value()), "");
1311 Service service = serviceStatus.left().value();
1312 StorageOperationStatus result = StorageOperationStatus.OK;
1314 lockComponent(service, "Mark service to delete");
1315 result = markComponentToDelete(service);
1316 if (result == StorageOperationStatus.OK) {
1317 responseFormat = componentsUtils.getResponseFormat(ActionStatus.NO_CONTENT);
1319 ActionStatus actionStatus = componentsUtils.convertFromStorageResponse(result);
1320 responseFormat = componentsUtils.getResponseFormatByResource(actionStatus, service.getName());
1322 return responseFormat;
1323 } catch (ComponentException e) {
1324 return e.getResponseFormat();
1326 if (result == null || result != StorageOperationStatus.OK) {
1327 log.warn("operation failed. do rollback");
1328 BeEcompErrorManager.getInstance().logBeSystemError("Delete Service");
1329 janusGraphDao.rollback();
1331 log.debug("operation success. do commit");
1332 janusGraphDao.commit();
1334 graphLockOperation.unlockComponent(serviceId, NodeTypeEnum.Service);
1338 public ResponseFormat deleteServiceByNameAndVersion(String serviceName, String version, User user) {
1339 ResponseFormat responseFormat;
1340 String ecompErrorContext = "delete service";
1341 validateUserNotEmpty(user, ecompErrorContext);
1342 user = validateUserExists(user);
1343 Either<Service, ResponseFormat> getResult = getServiceByNameAndVersion(serviceName, version, user.getUserId());
1344 if (getResult.isRight()) {
1345 return getResult.right().value();
1347 Service service = getResult.left().value();
1348 StorageOperationStatus result = StorageOperationStatus.OK;
1350 lockComponent(service, "Mark service to delete");
1351 result = markComponentToDelete(service);
1352 if (result == StorageOperationStatus.OK) {
1353 responseFormat = componentsUtils.getResponseFormat(ActionStatus.NO_CONTENT);
1355 ActionStatus actionStatus = componentsUtils.convertFromStorageResponse(result);
1356 responseFormat = componentsUtils.getResponseFormatByResource(actionStatus, service.getName());
1358 return responseFormat;
1359 } catch (ComponentException e) {
1360 result = StorageOperationStatus.GENERAL_ERROR;
1361 return componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR);
1363 if (result == null || result != StorageOperationStatus.OK) {
1364 log.warn("operation failed. do rollback");
1365 BeEcompErrorManager.getInstance().logBeSystemError("Delete Service");
1366 janusGraphDao.rollback();
1368 log.debug("operation success. do commit");
1369 janusGraphDao.commit();
1371 graphLockOperation.unlockComponent(service.getUniqueId(), NodeTypeEnum.Service);
1375 public Either<Service, ResponseFormat> getService(String serviceId, User user) {
1376 String ecompErrorContext = "Get service";
1377 validateUserNotEmpty(user, ecompErrorContext);
1378 validateUserExists(user);
1379 Either<Service, StorageOperationStatus> storageStatus = toscaOperationFacade.getToscaElement(serviceId);
1380 if (storageStatus.isRight()) {
1381 log.debug("failed to get service by id {}", serviceId);
1382 return Either.right(componentsUtils
1383 .getResponseFormat(componentsUtils.convertFromStorageResponse(storageStatus.right().value(), ComponentTypeEnum.SERVICE), serviceId));
1385 if (!(storageStatus.left().value() instanceof Service)) {
1387 .right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(StorageOperationStatus.NOT_FOUND), serviceId));
1389 Service service = storageStatus.left().value();
1390 return Either.left(service);
1393 public Either<Service, ResponseFormat> getServiceByNameAndVersion(String serviceName, String serviceVersion, String userId) {
1394 validateUserExists(userId);
1395 Either<Service, StorageOperationStatus> storageStatus = toscaOperationFacade
1396 .getComponentByNameAndVersion(ComponentTypeEnum.SERVICE, serviceName, serviceVersion);
1397 if (storageStatus.isRight()) {
1398 log.debug("failed to get service by name {} and version {}", serviceName, serviceVersion);
1399 return Either.right(componentsUtils
1400 .getResponseFormat(componentsUtils.convertFromStorageResponse(storageStatus.right().value(), ComponentTypeEnum.SERVICE),
1403 Service service = storageStatus.left().value();
1404 return Either.left(service);
1407 @SuppressWarnings("unchecked")
1408 private void createMandatoryArtifactsData(Service service, User user) {
1409 // create mandatory artifacts
1411 // TODO it must be removed after that artifact uniqueId creation will be
1413 // moved to ArtifactOperation
1414 String serviceUniqueId = service.getUniqueId();
1415 Map<String, ArtifactDefinition> artifactMap = service.getArtifacts();
1416 if (artifactMap == null) {
1417 artifactMap = new HashMap<>();
1419 Map<String, Object> informationalServiceArtifacts = ConfigurationManager.getConfigurationManager().getConfiguration()
1420 .getInformationalServiceArtifacts();
1421 List<String> exludeServiceCategory = ConfigurationManager.getConfigurationManager().getConfiguration().getExcludeServiceCategory();
1422 String category = service.getCategories().get(0).getName();
1423 boolean isCreateArtifact = true;
1424 if (category != null && exludeServiceCategory != null && !exludeServiceCategory.isEmpty()) {
1425 for (String exlude : exludeServiceCategory) {
1426 if (exlude.equalsIgnoreCase(category)) {
1427 isCreateArtifact = false;
1432 if (informationalServiceArtifacts != null && isCreateArtifact) {
1433 Set<String> keys = informationalServiceArtifacts.keySet();
1434 for (String informationalServiceArtifactName : keys) {
1435 Map<String, Object> artifactInfoMap = (Map<String, Object>) informationalServiceArtifacts.get(informationalServiceArtifactName);
1436 ArtifactDefinition artifactDefinition = createArtifactDefinition(serviceUniqueId, informationalServiceArtifactName, artifactInfoMap,
1438 artifactMap.put(artifactDefinition.getArtifactLabel(), artifactDefinition);
1440 service.setArtifacts(artifactMap);
1444 private ArtifactDefinition createArtifactDefinition(String serviceId, String logicalName, Map<String, Object> artifactInfoMap, User user,
1445 Boolean isServiceApi) {
1446 ArtifactDefinition artifactInfo = artifactsBusinessLogic
1447 .createArtifactPlaceHolderInfo(serviceId, logicalName, artifactInfoMap, user, ArtifactGroupTypeEnum.INFORMATIONAL);
1449 artifactInfo.setMandatory(false);
1450 artifactInfo.setServiceApi(true);
1452 return artifactInfo;
1455 private String getEnvNameFromConfiguration() {
1456 String configuredEnvName = ConfigurationManager.getConfigurationManager().getDistributionEngineConfiguration().getEnvironments().get(0);
1457 log.trace("Update environment name to be {}", configuredEnvName);
1458 return configuredEnvName;
1461 public Either<String, ResponseFormat> activateServiceOnTenantEnvironment(String serviceId, String envId, User modifier,
1462 ServiceDistributionReqInfo data) {
1463 Either<ActivationRequestInformation, ResponseFormat> activationRequestInformationEither = serviceDistributionValidation
1464 .validateActivateServiceRequest(serviceId, envId, modifier, data);
1465 if (activationRequestInformationEither.isRight()) {
1466 return Either.right(activationRequestInformationEither.right().value());
1468 ActivationRequestInformation activationRequestInformation = activationRequestInformationEither.left().value();
1469 String did = ThreadLocalsHolder.getUuid();
1470 Service service = activationRequestInformation.getServiceToActivate();
1471 return buildAndSendServiceNotification(service, envId, did, activationRequestInformation.getWorkloadContext(), modifier);
1474 private Either<String, ResponseFormat> buildAndSendServiceNotification(Service service, String envId, String did, String workloadContext,
1476 String envName = getEnvNameFromConfiguration();
1477 INotificationData notificationData = distributionEngine.buildServiceForDistribution(service, did, workloadContext);
1478 ActionStatus notifyServiceResponse = distributionEngine.notifyService(did, service, notificationData, envId, envName, modifier);
1479 if (notifyServiceResponse == ActionStatus.OK) {
1480 return Either.left(did);
1482 BeEcompErrorManager.getInstance().logBeSystemError("Activate Distribution - send notification");
1483 log.debug("distributionEngine.notifyService response is: {}", notifyServiceResponse);
1484 ResponseFormat error = componentsUtils.getResponseFormat(ActionStatus.INVALID_RESPONSE_FROM_PROXY);
1485 return Either.right(error);
1489 public Either<Service, ResponseFormat> activateDistribution(String serviceId, String envName, User modifier, HttpServletRequest request) {
1490 User user = validateUserExists(modifier.getUserId());
1491 validateUserRole(user, Collections.singletonList(Role.DESIGNER));
1492 Either<Service, ResponseFormat> result;
1493 ResponseFormat response;
1494 Service updatedService;
1495 String did = ThreadLocalsHolder.getUuid();
1497 String configuredEnvName = ConfigurationManager.getConfigurationManager().getDistributionEngineConfiguration().getEnvironments().get(0);
1498 if (configuredEnvName != null && !configuredEnvName.equals(envName)) {
1499 log.trace("Update environment name to be {} instead of {}", configuredEnvName, envName);
1500 envName = configuredEnvName;
1503 ServletContext servletContext = request.getSession().getServletContext();
1504 boolean isDistributionEngineUp = getHealthCheckBL(servletContext).isDistributionEngineUp(); // DE
1505 if (!isDistributionEngineUp) {
1506 BeEcompErrorManager.getInstance().logBeSystemError("Distribution Engine is DOWN");
1507 log.debug("Distribution Engine is DOWN");
1508 response = componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR);
1509 return Either.right(response);
1511 Either<Service, StorageOperationStatus> serviceRes = toscaOperationFacade.getToscaElement(serviceId);
1512 if (serviceRes.isRight()) {
1513 log.debug("failed retrieving service");
1514 response = componentsUtils
1515 .getResponseFormat(componentsUtils.convertFromStorageResponse(serviceRes.right().value(), ComponentTypeEnum.SERVICE), serviceId);
1516 componentsUtils.auditComponent(response, user, null, AuditingActionEnum.DISTRIBUTION_STATE_CHANGE_REQUEST,
1517 new ResourceCommonInfo(ComponentTypeEnum.SERVICE.getValue()), ResourceVersionInfo.newBuilder().build(), did);
1518 return Either.right(response);
1520 Service service = serviceRes.left().value();
1521 if (service.isArchived()) {
1522 log.info("Component is archived. Component id: {}", serviceId);
1523 return Either.right(componentsUtils.getResponseFormat(ActionStatus.COMPONENT_IS_ARCHIVED, service.getName()));
1525 if (service.getLifecycleState() != LifecycleStateEnum.CERTIFIED) {
1526 log.info("service {} is not available for distribution. Should be in certified state", service.getUniqueId());
1527 ResponseFormat responseFormat = componentsUtils
1528 .getResponseFormat(ActionStatus.SERVICE_NOT_AVAILABLE_FOR_DISTRIBUTION, service.getVersion(), service.getName());
1529 return Either.right(responseFormat);
1531 String dcurrStatus = service.getDistributionStatus().name();
1532 String updatedStatus = dcurrStatus;
1533 StorageOperationStatus readyForDistribution = distributionEngine.isReadyForDistribution(envName);
1534 if (readyForDistribution == StorageOperationStatus.OK) {
1535 INotificationData notificationData = distributionEngine.buildServiceForDistribution(service, did, null);
1536 ActionStatus notifyServiceResponse = distributionEngine.notifyService(did, service, notificationData, envName, user);
1537 if (notifyServiceResponse == ActionStatus.OK) {
1538 Either<Service, ResponseFormat> updateStateRes = updateDistributionStatusForActivation(service, user,
1539 DistributionStatusEnum.DISTRIBUTED);
1540 if (updateStateRes.isLeft() && updateStateRes.left().value() != null) {
1541 updatedService = updateStateRes.left().value();
1542 updatedStatus = updatedService.getDistributionStatus().name();
1544 // The response is not relevant
1545 updatedService = service;
1547 ASDCKpiApi.countActivatedDistribution();
1548 response = componentsUtils.getResponseFormat(ActionStatus.OK);
1549 result = Either.left(updatedService);
1551 BeEcompErrorManager.getInstance().logBeSystemError("Activate Distribution - send notification");
1552 log.debug("distributionEngine.notifyService response is: {}", notifyServiceResponse);
1553 response = componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR);
1554 result = Either.right(response);
1557 response = componentsUtils
1558 .getResponseFormatByDE(componentsUtils.convertFromStorageResponse(readyForDistribution, ComponentTypeEnum.SERVICE), envName);
1559 result = Either.right(response);
1561 componentsUtils.auditComponent(response, user, service, AuditingActionEnum.DISTRIBUTION_STATE_CHANGE_REQUEST,
1562 new ResourceCommonInfo(service.getName(), ComponentTypeEnum.SERVICE.getValue()),
1563 ResourceVersionInfo.newBuilder().distributionStatus(dcurrStatus).build(),
1564 ResourceVersionInfo.newBuilder().distributionStatus(updatedStatus).build(), null, null, did);
1568 // convert to private after deletion of temp url
1569 public Either<Service, ResponseFormat> updateDistributionStatusForActivation(Service service, User user, DistributionStatusEnum state) {
1570 validateUserExists(user.getUserId());
1571 String serviceId = service.getUniqueId();
1572 lockComponent(serviceId, service, "updateDistributionStatusForActivation");
1574 Either<Service, StorageOperationStatus> result = toscaOperationFacade.updateDistributionStatus(service, user, state);
1575 if (result.isRight()) {
1576 janusGraphDao.rollback();
1577 BeEcompErrorManager.getInstance().logBeSystemError("updateDistributionStatusForActivation");
1578 log.debug("service {} change distribution status failed", serviceId);
1579 return Either.right(componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR));
1581 janusGraphDao.commit();
1582 updateCatalog(service, ChangeTypeEnum.LIFECYCLE);
1583 return Either.left(result.left().value());
1585 graphLockOperation.unlockComponent(serviceId, NodeTypeEnum.Service);
1589 public Either<Service, ResponseFormat> markDistributionAsDeployed(String serviceId, String did, User user) {
1590 validateUserExists(user.getUserId());
1591 log.debug("mark distribution deployed");
1592 AuditingActionEnum auditAction = AuditingActionEnum.DISTRIBUTION_DEPLOY;
1593 Either<Service, StorageOperationStatus> getServiceResponse = toscaOperationFacade.getToscaElement(serviceId);
1594 if (getServiceResponse.isRight()) {
1595 BeEcompErrorManager.getInstance()
1596 .logBeComponentMissingError("markDistributionAsDeployed", ComponentTypeEnum.SERVICE.getValue(), serviceId);
1597 log.debug("service {} not found", serviceId);
1598 ResponseFormat responseFormat = auditDeployError(did, user, auditAction, null,
1599 componentsUtils.convertFromStorageResponse(getServiceResponse.right().value(), ComponentTypeEnum.SERVICE), "");
1600 return Either.right(responseFormat);
1602 Service service = getServiceResponse.left().value();
1603 user = validateRoleForDeploy(did, user, auditAction, service);
1604 return checkDistributionAndDeploy(did, user, auditAction, service);
1607 public Either<Service, ResponseFormat> generateVfModuleArtifacts(Service service, User modifier, boolean shouldLock, boolean inTransaction) {
1608 Function<ComponentInstance, List<ArtifactGenerator<ArtifactDefinition>>> artifactTaskGeneratorCreator = ri ->
1609 // Only one VF Module Artifact per instance - add it to a list of one
1610 buildArtifactGenList(service, modifier, shouldLock, inTransaction, ri);
1611 return generateDeploymentArtifacts(service, artifactTaskGeneratorCreator);
1614 private List<ArtifactGenerator<ArtifactDefinition>> buildArtifactGenList(Service service, User modifier, boolean shouldLock,
1615 boolean inTransaction, ComponentInstance ri) {
1616 List<ArtifactGenerator<ArtifactDefinition>> asList = new ArrayList<>();
1617 if (ri.getOriginType() == OriginTypeEnum.VF) {
1618 asList = Arrays.asList(new VfModuleArtifactGenerator(modifier, ri, service, shouldLock, inTransaction));
1623 private List<GroupInstance> collectGroupsInstanceForCompInstance(ComponentInstance currVF) {
1624 Map<String, ArtifactDefinition> deploymentArtifacts = currVF.getDeploymentArtifacts();
1625 if (currVF.getGroupInstances() != null) {
1626 currVF.getGroupInstances().forEach(gi -> gi.alignArtifactsUuid(deploymentArtifacts));
1628 return currVF.getGroupInstances();
1631 private ArtifactDefinition getVfModuleInstArtifactForCompInstance(ComponentInstance currVF, Service service, Wrapper<String> payloadWrapper,
1632 Wrapper<ResponseFormat> responseWrapper) {
1633 ArtifactDefinition vfModuleAertifact = null;
1634 if (MapUtils.isNotEmpty(currVF.getDeploymentArtifacts())) {
1635 final Optional<ArtifactDefinition> optionalVfModuleArtifact = currVF.getDeploymentArtifacts().values().stream()
1636 .filter(p -> p.getArtifactType().equals(ArtifactTypeEnum.VF_MODULES_METADATA.getType())).findAny();
1637 if (optionalVfModuleArtifact.isPresent()) {
1638 vfModuleAertifact = optionalVfModuleArtifact.get();
1641 if (vfModuleAertifact == null) {
1642 Either<ArtifactDefinition, ResponseFormat> createVfModuleArtifact = createVfModuleArtifact(currVF, service,
1643 payloadWrapper.getInnerElement());
1644 if (createVfModuleArtifact.isLeft()) {
1645 vfModuleAertifact = createVfModuleArtifact.left().value();
1647 responseWrapper.setInnerElement(createVfModuleArtifact.right().value());
1650 return vfModuleAertifact;
1653 private void fillVfModuleInstHeatEnvPayload(List<GroupInstance> groupsForCurrVF, Wrapper<String> payloadWrapper) {
1654 List<VfModuleArtifactPayload> vfModulePayloads = new ArrayList<>();
1655 if (groupsForCurrVF != null) {
1656 for (GroupInstance groupInstance : groupsForCurrVF) {
1657 VfModuleArtifactPayload modulePayload = new VfModuleArtifactPayload(groupInstance);
1658 vfModulePayloads.add(modulePayload);
1660 vfModulePayloads.sort(VfModuleArtifactPayload::compareByGroupName);
1661 final Gson gson = new GsonBuilder().setPrettyPrinting().create();
1662 String vfModulePayloadString = gson.toJson(vfModulePayloads);
1663 payloadWrapper.setInnerElement(vfModulePayloadString);
1667 private Either<ArtifactDefinition, ResponseFormat> generateVfModuleInstanceArtifact(User modifier, ComponentInstance currVFInstance,
1668 Service service, boolean shouldLock, boolean inTransaction) {
1669 ArtifactDefinition vfModuleArtifact = null;
1670 Wrapper<ResponseFormat> responseWrapper = new Wrapper<>();
1671 Wrapper<String> payloadWrapper = new Wrapper<>();
1672 List<GroupInstance> groupsForCurrVF = collectGroupsInstanceForCompInstance(currVFInstance);
1673 if (responseWrapper.isEmpty()) {
1674 fillVfModuleInstHeatEnvPayload(groupsForCurrVF, payloadWrapper);
1676 if (responseWrapper.isEmpty() && payloadWrapper.getInnerElement() != null) {
1677 vfModuleArtifact = getVfModuleInstArtifactForCompInstance(currVFInstance, service, payloadWrapper, responseWrapper);
1679 if (responseWrapper.isEmpty() && vfModuleArtifact != null) {
1680 vfModuleArtifact = fillVfModulePayload(modifier, currVFInstance, vfModuleArtifact, shouldLock, inTransaction, payloadWrapper,
1681 responseWrapper, service);
1683 Either<ArtifactDefinition, ResponseFormat> result;
1684 if (responseWrapper.isEmpty()) {
1685 result = Either.left(vfModuleArtifact);
1687 result = Either.right(responseWrapper.getInnerElement());
1692 private ArtifactDefinition fillVfModulePayload(User modifier, ComponentInstance currVF, ArtifactDefinition vfModuleArtifact, boolean shouldLock,
1693 boolean inTransaction, Wrapper<String> payloadWrapper, Wrapper<ResponseFormat> responseWrapper,
1695 ArtifactDefinition result = null;
1696 Either<ArtifactDefinition, ResponseFormat> eitherPayload = artifactsBusinessLogic
1697 .generateArtifactPayload(vfModuleArtifact, ComponentTypeEnum.RESOURCE_INSTANCE, service, currVF.getName(), modifier, shouldLock,
1698 inTransaction, System::currentTimeMillis, () -> Either.left(
1699 artifactsBusinessLogic.createEsArtifactData(vfModuleArtifact, payloadWrapper.getInnerElement().getBytes(StandardCharsets.UTF_8))),
1700 currVF.getUniqueId());
1701 if (eitherPayload.isLeft()) {
1702 result = eitherPayload.left().value();
1704 responseWrapper.setInnerElement(eitherPayload.right().value());
1706 if (result == null) {
1707 result = vfModuleArtifact;
1712 private Either<ArtifactDefinition, ResponseFormat> createVfModuleArtifact(ComponentInstance currVF, Service service,
1713 String vfModulePayloadString) {
1714 ArtifactDefinition vfModuleArtifactDefinition = new ArtifactDefinition();
1715 String newCheckSum = null;
1716 vfModuleArtifactDefinition.setDescription("Auto-generated VF Modules information artifact");
1717 vfModuleArtifactDefinition.setArtifactDisplayName("Vf Modules Metadata");
1718 vfModuleArtifactDefinition.setArtifactType(ArtifactTypeEnum.VF_MODULES_METADATA.getType());
1719 vfModuleArtifactDefinition.setArtifactGroupType(ArtifactGroupTypeEnum.DEPLOYMENT);
1720 vfModuleArtifactDefinition.setArtifactLabel("vfModulesMetadata");
1721 vfModuleArtifactDefinition.setTimeout(0);
1722 vfModuleArtifactDefinition.setArtifactName(currVF.getNormalizedName() + "_modules.json");
1723 vfModuleArtifactDefinition.setPayloadData(vfModulePayloadString);
1724 if (vfModulePayloadString != null) {
1725 newCheckSum = GeneralUtility.calculateMD5Base64EncodedByByteArray(vfModulePayloadString.getBytes());
1727 vfModuleArtifactDefinition.setArtifactChecksum(newCheckSum);
1728 Either<ArtifactDefinition, StorageOperationStatus> addArtifactToComponent = artifactToscaOperation
1729 .addArtifactToComponent(vfModuleArtifactDefinition, service, NodeTypeEnum.ResourceInstance, true, currVF.getUniqueId());
1730 Either<ArtifactDefinition, ResponseFormat> result;
1731 if (addArtifactToComponent.isLeft()) {
1732 result = Either.left(addArtifactToComponent.left().value());
1735 .right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(addArtifactToComponent.right().value())));
1740 public Either<Service, ResponseFormat> generateHeatEnvArtifacts(Service service, User modifier, boolean shouldLock, boolean inTransaction) {
1741 Function<ComponentInstance, List<ArtifactGenerator<ArtifactDefinition>>> artifactTaskGeneratorCreator = resourceInstance ->
1742 // Get All Deployment Artifacts
1743 service.getComponentInstances().stream().filter(ri -> ri != null && ri == resourceInstance)
1744 .filter(ri -> ri.getDeploymentArtifacts() != null).flatMap(ri -> ri.getDeploymentArtifacts().values().stream()).
1745 // Filter in Only Heat Env
1746 filter(depArtifact -> ArtifactTypeEnum.HEAT_ENV.getType().equals(depArtifact.getArtifactType())).
1747 // Create ArtifactGenerator from those Artifacts
1749 depArtifact -> new HeatEnvArtifactGenerator(depArtifact, service, resourceInstance.getName(), modifier, shouldLock, inTransaction,
1750 resourceInstance.getUniqueId())).collect(Collectors.toList());
1751 return generateDeploymentArtifacts(service, artifactTaskGeneratorCreator);
1754 private <CallVal> Either<Service, ResponseFormat> generateDeploymentArtifacts(Service service,
1755 Function<ComponentInstance, List<ArtifactGenerator<CallVal>>> artifactTaskGeneratorCreator) {
1756 // Get Flat List of (Callable) ArtifactGenerator for all the RI in the
1759 if (service.getComponentInstances() != null) {
1760 List<ArtifactGenerator<CallVal>> artifactGenList = service.getComponentInstances().stream()
1761 .flatMap(ri -> artifactTaskGeneratorCreator.apply(ri).stream()).collect(Collectors.toList());
1762 if (artifactGenList != null && !artifactGenList.isEmpty()) {
1763 Either<Service, ResponseFormat> callRes = checkDeploymentArtifact(artifactGenList);
1764 if (callRes != null) {
1769 Either<Service, StorageOperationStatus> storageStatus = toscaOperationFacade.getToscaFullElement(service.getUniqueId());
1770 if (storageStatus.isRight()) {
1771 return Either.right(componentsUtils
1772 .getResponseFormat(componentsUtils.convertFromStorageResponse(storageStatus.right().value(), ComponentTypeEnum.SERVICE), ""));
1774 Service currentService = storageStatus.left().value();
1775 return Either.left(currentService);
1778 private <CallVal> Either<Service, ResponseFormat> checkDeploymentArtifact(List<ArtifactGenerator<CallVal>> artifactGenList) {
1779 for (ArtifactGenerator<CallVal> entry : artifactGenList) {
1780 Either<CallVal, ResponseFormat> callRes;
1782 callRes = entry.call();
1783 if (callRes.isRight()) {
1784 log.debug("Failed to generate artifact error : {}", callRes.right().value());
1785 return Either.right(callRes.right().value());
1787 } catch (Exception e) {
1788 log.debug("Failed to generate artifact exception : {}", e);
1789 return Either.right(componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR));
1795 private synchronized Either<Service, ResponseFormat> checkDistributionAndDeploy(String distributionId, User user, AuditingActionEnum auditAction,
1797 boolean isDeployed = isDistributionDeployed(distributionId);
1799 return Either.left(service);
1801 Either<Boolean, ResponseFormat> distributionSuccess = checkDistributionSuccess(distributionId, user, auditAction, service);
1802 if (distributionSuccess.isRight()) {
1803 return Either.right(distributionSuccess.right().value());
1805 log.debug("mark distribution {} as deployed - success", distributionId);
1807 .auditServiceDistributionDeployed(service.getName(), service.getVersion(), service.getUUID(), distributionId, STATUS_DEPLOYED, "OK",
1809 return Either.left(service);
1812 private boolean isDistributionDeployed(String distributionId) {
1813 Either<List<DistributionDeployEvent>, ActionStatus> alreadyDeployed = auditCassandraDao
1814 .getDistributionDeployByStatus(distributionId, AuditingActionEnum.DISTRIBUTION_DEPLOY.getName(), STATUS_DEPLOYED);
1815 boolean isDeployed = false;
1816 if (alreadyDeployed.isLeft() && !alreadyDeployed.left().value().isEmpty()) {
1818 log.debug("distribution {} is already deployed", distributionId);
1824 protected Either<Boolean, ResponseFormat> checkDistributionSuccess(String did, User user, AuditingActionEnum auditAction, Service service) {
1825 log.trace("checkDistributionSuccess");
1826 // get all "DRequest" records for this distribution
1827 Either<List<ResourceAdminEvent>, ActionStatus> distRequestsResponse = auditCassandraDao
1828 .getDistributionRequest(did, AuditingActionEnum.DISTRIBUTION_STATE_CHANGE_REQUEST.getName());
1829 if (distRequestsResponse.isRight()) {
1830 ResponseFormat error = auditDeployError(did, user, auditAction, service, distRequestsResponse.right().value());
1831 return Either.right(error);
1833 List<ResourceAdminEvent> distributionRequests = distRequestsResponse.left().value();
1834 if (distributionRequests.isEmpty()) {
1835 BeEcompErrorManager.getInstance().logBeDistributionMissingError("markDistributionAsDeployed", did);
1836 log.info("distribution {} is not found", did);
1837 ResponseFormat error = auditDeployError(did, user, auditAction, service, ActionStatus.DISTRIBUTION_REQUESTED_NOT_FOUND);
1838 return Either.right(error);
1840 boolean isRequestSucceeded = false;
1841 for (ResourceAdminEvent event : distributionRequests) {
1842 String eventStatus = event.getStatus();
1843 if (eventStatus != null && eventStatus.equals(STATUS_SUCCESS_200)) {
1844 isRequestSucceeded = true;
1848 // get all "DNotify" records for this distribution
1849 Either<List<DistributionNotificationEvent>, ActionStatus> distNotificationsResponse = auditCassandraDao
1850 .getDistributionNotify(did, AuditingActionEnum.DISTRIBUTION_NOTIFY.getName());
1851 if (distNotificationsResponse.isRight()) {
1852 ResponseFormat error = auditDeployError(did, user, auditAction, service, distNotificationsResponse.right().value());
1853 return Either.right(error);
1855 List<DistributionNotificationEvent> distributionNotifications = distNotificationsResponse.left().value();
1856 boolean isNotificationsSucceeded = false;
1857 for (DistributionNotificationEvent event : distributionNotifications) {
1858 String eventStatus = event.getStatus();
1859 if (eventStatus != null && eventStatus.equals(STATUS_SUCCESS_200)) {
1860 isNotificationsSucceeded = true;
1864 // if request failed OR there are notifications that failed
1865 if (!(isRequestSucceeded && isNotificationsSucceeded)) {
1866 log.info("distribution {} has failed", did);
1867 ResponseFormat error = componentsUtils.getResponseFormat(ActionStatus.DISTRIBUTION_REQUESTED_FAILED, did);
1868 auditDeployError(did, user, auditAction, service, ActionStatus.DISTRIBUTION_REQUESTED_FAILED, did);
1869 return Either.right(error);
1871 return Either.left(true);
1874 private ResponseFormat auditDeployError(String did, User user, AuditingActionEnum auditAction, Service service, ActionStatus status,
1876 ResponseFormat error = componentsUtils.getResponseFormat(status, params);
1877 String message = "";
1878 if (error.getMessageId() != null) {
1879 message = error.getMessageId() + ": ";
1881 message += error.getFormattedMessage();
1882 if (service != null) {
1884 .auditServiceDistributionDeployed(service.getName(), service.getVersion(), service.getUUID(), did, error.getStatus().toString(),
1887 componentsUtils.auditServiceDistributionDeployed("", "", "", did, error.getStatus().toString(), message, user);
1892 private User validateRoleForDeploy(String did, User user, AuditingActionEnum auditAction, Service service) {
1893 user = userAdmin.getUser(user.getUserId());
1894 log.debug("validate user role");
1895 List<Role> roles = new ArrayList<>();
1896 roles.add(Role.ADMIN);
1897 roles.add(Role.DESIGNER);
1899 validateUserRole(user, service, roles, auditAction, null);
1900 } catch (ByActionStatusComponentException e) {
1901 log.info("role {} is not allowed to perform this action", user.getRole());
1902 auditDeployError(did, user, auditAction, service, e.getActionStatus());
1909 public void setDeploymentArtifactsPlaceHolder(Component component, User user) {
1910 if (component instanceof Service) {
1911 Service service = (Service) component;
1912 Map<String, ArtifactDefinition> artifactMap = service.getDeploymentArtifacts();
1913 if (artifactMap == null) {
1914 artifactMap = new HashMap<>();
1916 service.setDeploymentArtifacts(artifactMap);
1917 } else if (component instanceof Resource) {
1918 Resource resource = (Resource) component;
1919 Map<String, ArtifactDefinition> artifactMap = resource.getDeploymentArtifacts();
1920 if (artifactMap == null) {
1921 artifactMap = new HashMap<>();
1923 Map<String, Object> deploymentResourceArtifacts = ConfigurationManager.getConfigurationManager().getConfiguration()
1924 .getDeploymentResourceArtifacts();
1925 if (deploymentResourceArtifacts != null) {
1926 Map<String, ArtifactDefinition> finalArtifactMap = artifactMap;
1927 deploymentResourceArtifacts.forEach((k, v) -> processDeploymentResourceArtifacts(user, resource, finalArtifactMap, k, v));
1929 resource.setDeploymentArtifacts(artifactMap);
1933 private void processDeploymentResourceArtifacts(User user, Resource resource, Map<String, ArtifactDefinition> artifactMap, String k, Object v) {
1934 Map<String, Object> artifactDetails = (Map<String, Object>) v;
1935 Object object = artifactDetails.get(PLACE_HOLDER_RESOURCE_TYPES);
1936 if (object != null) {
1937 List<String> artifactTypes = (List<String>) object;
1938 if (!artifactTypes.contains(resource.getResourceType().name())) {
1942 log.info("resource types for artifact placeholder {} were not defined. default is all resources", k);
1944 if (artifactsBusinessLogic != null) {
1945 ArtifactDefinition artifactDefinition = artifactsBusinessLogic
1946 .createArtifactPlaceHolderInfo(resource.getUniqueId(), k, (Map<String, Object>) v, user, ArtifactGroupTypeEnum.DEPLOYMENT);
1947 if (artifactDefinition != null && !artifactMap.containsKey(artifactDefinition.getArtifactLabel())) {
1948 artifactMap.put(artifactDefinition.getArtifactLabel(), artifactDefinition);
1954 public Either<List<String>, ResponseFormat> deleteMarkedComponents() {
1955 return deleteMarkedComponents(ComponentTypeEnum.SERVICE);
1958 private HealthCheckBusinessLogic getHealthCheckBL(ServletContext context) {
1959 WebAppContextWrapper webApplicationContextWrapper = (WebAppContextWrapper) context
1960 .getAttribute(Constants.WEB_APPLICATION_CONTEXT_WRAPPER_ATTR);
1961 WebApplicationContext webApplicationContext = webApplicationContextWrapper.getWebAppContext(context);
1962 return webApplicationContext.getBean(HealthCheckBusinessLogic.class);
1966 public ComponentInstanceBusinessLogic getComponentInstanceBL() {
1967 return componentInstanceBusinessLogic;
1971 public Either<List<ComponentInstance>, ResponseFormat> getComponentInstancesFilteredByPropertiesAndInputs(String componentId, String userId) {
1972 validateUserExists(userId);
1973 Either<Component, StorageOperationStatus> getComponentRes = toscaOperationFacade.getToscaElement(componentId, JsonParseFlagEnum.ParseAll);
1974 if (getComponentRes.isRight()) {
1975 ResponseFormat responseFormat = componentsUtils
1976 .getResponseFormat(componentsUtils.convertFromStorageResponse(getComponentRes.right().value()));
1977 return Either.right(responseFormat);
1979 List<ComponentInstance> componentInstances = getComponentRes.left().value().getComponentInstances();
1980 return Either.left(componentInstances);
1984 public void setForwardingPathOperation(ForwardingPathOperation forwardingPathOperation) {
1985 this.forwardingPathOperation = forwardingPathOperation;
1989 * updates group instance with new property values in case of successful update of group instance related component instance will be updated with
1990 * new modification time and related service will be updated with new last update date
1992 public Either<List<GroupInstanceProperty>, ResponseFormat> updateGroupInstancePropertyValues(User modifier, String serviceId,
1993 String componentInstanceId, String groupInstanceId,
1994 List<GroupInstanceProperty> newProperties) {
1995 Either<List<GroupInstanceProperty>, ResponseFormat> actionResult = null;
1996 Either<ImmutablePair<Component, User>, ResponseFormat> validateUserAndComponentRes;
1997 Component component = null;
1998 Either<Boolean, ResponseFormat> lockResult = null;
1999 log.debug("Going to update group instance {} of service {} with new property values. ", groupInstanceId, serviceId);
2001 validateUserAndComponentRes = validateUserAndComponent(serviceId, modifier);
2002 if (validateUserAndComponentRes.isRight()) {
2003 log.debug("Cannot update group instance {} of service {} with new property values. Validation failed. ", groupInstanceId, serviceId);
2004 actionResult = Either.right(validateUserAndComponentRes.right().value());
2006 if (actionResult == null) {
2007 component = validateUserAndComponentRes.left().value().getKey();
2008 lockResult = lockComponentByName(component.getSystemName(), component, "Update Group Instance on Service");
2009 if (lockResult.isRight()) {
2010 log.debug(FAILED_TO_LOCK_SERVICE_RESPONSE_IS, component.getName(), lockResult.right().value().getFormattedMessage());
2011 actionResult = Either.right(lockResult.right().value());
2013 log.debug(THE_SERVICE_WITH_SYSTEM_NAME_LOCKED, component.getSystemName());
2016 if (actionResult == null) {
2017 actionResult = validateAndUpdateGroupInstancePropertyValuesAndContainingParents(component, componentInstanceId, groupInstanceId,
2019 if (actionResult.isRight()) {
2020 log.debug("Failed to validate and update group instance {} property values and containing parents. The message is {}. ",
2021 groupInstanceId, actionResult.right().value().getFormattedMessage());
2024 } catch (Exception e) {
2025 log.error("Exception occured during update Group Instance property values: {}", e.getMessage(), e);
2026 actionResult = Either.right(componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR));
2028 if (lockResult != null && lockResult.isLeft() && lockResult.left().value()) {
2029 graphLockOperation.unlockComponentByName(component.getSystemName(), component.getUniqueId(), NodeTypeEnum.Service);
2032 return actionResult;
2035 private Either<List<GroupInstanceProperty>, ResponseFormat> validateAndUpdateGroupInstancePropertyValuesAndContainingParents(Component component,
2036 String componentInstanceId,
2037 String groupInstanceId,
2038 List<GroupInstanceProperty> newProperties) {
2039 Either<List<GroupInstanceProperty>, ResponseFormat> actionResult = null;
2040 Either<ImmutablePair<ComponentInstance, GroupInstance>, ResponseFormat> findGroupInstanceRes;
2041 Either<ImmutablePair<ComponentMetadataData, ComponentInstanceData>, ResponseFormat> updateParentsModificationTimeRes;
2042 ComponentInstance relatedComponentInstance = null;
2043 GroupInstance oldGroupInstance = null;
2044 Either<GroupInstance, ResponseFormat> updateGroupInstanceResult = null;
2045 GroupInstance updatedGroupInstance = null;
2046 boolean inTransaction = true;
2047 findGroupInstanceRes = findGroupInstanceOnRelatedComponentInstance(component, componentInstanceId, groupInstanceId);
2048 if (findGroupInstanceRes.isRight()) {
2049 log.debug("#validateAndUpdateGroupInstancePropertyValuesAndContainingParents - Group instance {} not found. ", groupInstanceId);
2050 actionResult = Either.right(findGroupInstanceRes.right().value());
2052 if (actionResult == null) {
2053 oldGroupInstance = findGroupInstanceRes.left().value().getValue();
2054 relatedComponentInstance = findGroupInstanceRes.left().value().getKey();
2055 updateGroupInstanceResult = groupBusinessLogic
2056 .validateAndUpdateGroupInstancePropertyValues(component.getUniqueId(), componentInstanceId, oldGroupInstance, newProperties);
2057 if (updateGroupInstanceResult.isRight()) {
2058 log.debug("#validateAndUpdateGroupInstancePropertyValuesAndContainingParents - Failed to update group instance {} property values. ",
2059 oldGroupInstance.getName());
2060 actionResult = Either.right(updateGroupInstanceResult.right().value());
2063 if (actionResult == null) {
2064 updatedGroupInstance = updateGroupInstanceResult.left().value();
2065 if (!oldGroupInstance.getModificationTime().equals(updatedGroupInstance.getModificationTime())) {
2066 updateParentsModificationTimeRes = updateParentsModificationTimeAndCustomizationUuid(component, relatedComponentInstance,
2067 updatedGroupInstance, inTransaction);
2068 if (updateParentsModificationTimeRes.isRight()) {
2070 "#validateAndUpdateGroupInstancePropertyValuesAndContainingParents - Failed to update modification time for group instance {}. ",
2071 oldGroupInstance.getName());
2072 actionResult = Either.right(updateParentsModificationTimeRes.right().value());
2076 if (actionResult == null) {
2077 actionResult = Either.left(updatedGroupInstance.convertToGroupInstancesProperties());
2079 return actionResult;
2082 private Either<ImmutablePair<ComponentMetadataData, ComponentInstanceData>, ResponseFormat> updateParentsModificationTimeAndCustomizationUuid(
2083 Component component, ComponentInstance relatedComponentInstance, GroupInstance updatedGroupInstance, boolean inTranscation) {
2084 Either<ImmutablePair<ComponentMetadataData, ComponentInstanceData>, ResponseFormat> actionResult;
2085 Either<ComponentMetadataData, StorageOperationStatus> serviceMetadataUpdateResult;
2086 Either<ComponentInstanceData, ResponseFormat> updateComponentInstanceRes = componentInstanceBusinessLogic
2087 .updateComponentInstanceModificationTimeAndCustomizationUuid(relatedComponentInstance, NodeTypeEnum.ResourceInstance,
2088 updatedGroupInstance.getModificationTime(), inTranscation);
2089 if (updateComponentInstanceRes.isRight()) {
2090 log.debug("Failed to update component instance {} after update of group instance {}. ", relatedComponentInstance.getName(),
2091 updatedGroupInstance.getName());
2092 actionResult = Either.right(updateComponentInstanceRes.right().value());
2094 serviceMetadataUpdateResult = toscaOperationFacade.updateComponentLastUpdateDateOnGraph(component);
2095 if (serviceMetadataUpdateResult.isRight()) {
2096 log.debug("Failed to update service {} after update of component instance {} with new property values of group instance {}. ",
2097 component.getName(), relatedComponentInstance.getName(), updatedGroupInstance.getName());
2098 actionResult = Either.right(
2099 componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(serviceMetadataUpdateResult.right().value())));
2101 actionResult = Either
2102 .left(new ImmutablePair<>(serviceMetadataUpdateResult.left().value(), updateComponentInstanceRes.left().value()));
2105 return actionResult;
2108 private Either<ImmutablePair<Component, User>, ResponseFormat> validateUserAndComponent(String serviceId, User modifier) {
2109 Either<ImmutablePair<Component, User>, ResponseFormat> result = null;
2110 User currUser = null;
2111 Component component = null;
2112 Either<User, ResponseFormat> validationUserResult = validateUserIgnoreAudit(modifier, "updateGroupInstancePropertyValues");
2113 if (validationUserResult.isRight()) {
2114 log.debug("#validateUserAndComponent - Failed to validate user with userId {}, for update service {}. ", modifier.getUserId(), serviceId);
2115 result = Either.right(validationUserResult.right().value());
2117 if (result == null) {
2118 currUser = validationUserResult.left().value();
2120 component = validateComponentExists(serviceId, ComponentTypeEnum.SERVICE, null);
2121 if (!ComponentValidationUtils.canWorkOnComponent(component, currUser.getUserId())) {
2122 log.info("#validateUserAndComponent - Restricted operation for user: {}, on service: {}", currUser.getUserId(),
2123 component.getCreatorUserId());
2124 return Either.right(componentsUtils.getResponseFormat(ActionStatus.RESTRICTED_OPERATION));
2126 } catch (ComponentException e) {
2127 log.debug("#validateUserAndComponent - Failed to validate service existing {}. ", serviceId);
2128 result = Either.right(e.getResponseFormat());
2131 if (result == null) {
2132 result = Either.left(new ImmutablePair<>(component, currUser));
2137 private Either<ImmutablePair<ComponentInstance, GroupInstance>, ResponseFormat> findGroupInstanceOnRelatedComponentInstance(Component component,
2138 String componentInstanceId,
2139 String groupInstanceId) {
2140 Either<ImmutablePair<ComponentInstance, GroupInstance>, ResponseFormat> actionResult = null;
2141 GroupInstance groupInstance = null;
2142 ComponentInstance foundComponentInstance = findRelatedComponentInstance(component, componentInstanceId);
2143 if (foundComponentInstance == null) {
2144 log.debug("Component instance {} not found on service {}. ", componentInstanceId, component.getName());
2145 actionResult = Either.right(componentsUtils
2146 .getResponseFormat(ActionStatus.COMPONENT_INSTANCE_NOT_FOUND_ON_CONTAINER, componentInstanceId, "resource instance", "service",
2147 component.getName()));
2148 } else if (isNotEmpty(foundComponentInstance.getGroupInstances())) {
2149 groupInstance = foundComponentInstance.getGroupInstances().stream().filter(gi -> gi.getUniqueId().equals(groupInstanceId)).findFirst()
2151 if (groupInstance == null) {
2152 log.debug("Group instance {} not found on component instance {}. ", groupInstanceId, foundComponentInstance.getName());
2153 actionResult = Either.right(componentsUtils
2154 .getResponseFormat(ActionStatus.GROUP_INSTANCE_NOT_FOUND_ON_COMPONENT_INSTANCE, groupInstanceId,
2155 foundComponentInstance.getName()));
2158 if (actionResult == null) {
2159 actionResult = Either.left(new ImmutablePair<>(foundComponentInstance, groupInstance));
2161 return actionResult;
2164 private ComponentInstance findRelatedComponentInstance(Component component, String componentInstanceId) {
2165 ComponentInstance componentInstance = null;
2166 if (isNotEmpty(component.getComponentInstances())) {
2167 componentInstance = component.getComponentInstances().stream().filter(ci -> ci.getUniqueId().equals(componentInstanceId)).findFirst()
2170 return componentInstance;
2173 private Either<User, ResponseFormat> validateUserIgnoreAudit(User modifier, String ecompErrorContext) {
2174 User user = validateUser(modifier, ecompErrorContext, null, null, false);
2175 List<Role> roles = new ArrayList<>();
2176 roles.add(Role.ADMIN);
2177 roles.add(Role.DESIGNER);
2178 validateUserRole(user, roles);
2179 return Either.left(user);
2182 public Either<UiComponentDataTransfer, ResponseFormat> getUiComponentDataTransferByComponentId(String serviceId,
2183 List<String> dataParamsToReturn) {
2184 ComponentParametersView paramsToReturn = new ComponentParametersView(dataParamsToReturn);
2185 paramsToReturn.setIgnoreComponentInstancesProperties(false);
2186 Either<Service, StorageOperationStatus> serviceResultEither = toscaOperationFacade.getToscaElement(serviceId, paramsToReturn);
2187 if (serviceResultEither.isRight()) {
2188 if (serviceResultEither.right().value() == StorageOperationStatus.NOT_FOUND) {
2189 log.debug("#getUiComponentDataTransferByComponentId - Failed to find service with id {} ", serviceId);
2190 return Either.right(componentsUtils.getResponseFormat(ActionStatus.SERVICE_NOT_FOUND, serviceId));
2192 log.debug("#getUiComponentDataTransferByComponentId - failed to get service by id {} with filters {}", serviceId, dataParamsToReturn);
2193 return Either.right(
2194 componentsUtils.getResponseFormatByResource(componentsUtils.convertFromStorageResponse(serviceResultEither.right().value()), ""));
2196 Service service = serviceResultEither.left().value();
2197 if (dataParamsToReturn.contains(ComponentFieldsEnum.INPUTS.getValue())) {
2198 ListUtils.emptyIfNull(service.getInputs()).forEach(input -> input.setConstraints(setInputConstraint(input)));
2200 UiComponentDataTransfer dataTransfer = uiComponentDataConverter.getUiDataTransferFromServiceByParams(service, dataParamsToReturn);
2201 return Either.left(dataTransfer);
2204 @Autowired(required = false)
2205 public void setServiceCreationPluginList(List<ServiceCreationPlugin> serviceCreationPluginList) {
2206 this.serviceCreationPluginList = serviceCreationPluginList;
2209 public boolean isServiceExist(String serviceName) {
2210 Either<Service, StorageOperationStatus> latestByName = toscaOperationFacade.getLatestByServiceName(serviceName);
2211 return latestByName.isLeft();
2214 abstract class ArtifactGenerator<CallVal> implements Callable<Either<CallVal, ResponseFormat>> {
2219 class HeatEnvArtifactGenerator extends ArtifactGenerator<ArtifactDefinition> {
2221 private ArtifactDefinition artifactDefinition;
2222 private Service service;
2223 private String resourceInstanceName;
2224 private User modifier;
2225 private String instanceId;
2226 private boolean shouldLock;
2227 private boolean inTransaction;
2229 HeatEnvArtifactGenerator(ArtifactDefinition artifactDefinition, Service service, String resourceInstanceName, User modifier,
2230 boolean shouldLock, boolean inTransaction, String instanceId) {
2231 this.artifactDefinition = artifactDefinition;
2232 this.service = service;
2233 this.resourceInstanceName = resourceInstanceName;
2234 this.modifier = modifier;
2235 this.shouldLock = shouldLock;
2236 this.instanceId = instanceId;
2237 this.inTransaction = inTransaction;
2241 public Either<ArtifactDefinition, ResponseFormat> call() throws Exception {
2242 return artifactsBusinessLogic
2243 .forceGenerateHeatEnvArtifact(artifactDefinition, ComponentTypeEnum.RESOURCE_INSTANCE, service, resourceInstanceName, modifier,
2244 shouldLock, inTransaction, instanceId);
2248 class VfModuleArtifactGenerator extends ArtifactGenerator<ArtifactDefinition> {
2251 boolean inTransaction;
2253 private ComponentInstance componentInstance;
2254 private Service service;
2256 private VfModuleArtifactGenerator(User user, ComponentInstance componentInstance, Service service, boolean shouldLock,
2257 boolean inTransaction) {
2260 this.componentInstance = componentInstance;
2261 this.service = service;
2262 this.shouldLock = shouldLock;
2263 this.inTransaction = inTransaction;
2267 public Either<ArtifactDefinition, ResponseFormat> call() throws Exception {
2268 return generateVfModuleInstanceArtifact(user, componentInstance, service, shouldLock, inTransaction);