2 * ============LICENSE_START=======================================================
4 * ================================================================================
5 * Copyright (C) 2019 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=========================================================
21 package org.openecomp.sdc.be.components.csar;
23 import com.google.gson.Gson;
24 import com.google.gson.JsonElement;
25 import com.google.gson.JsonObject;
26 import fj.data.Either;
27 import org.apache.commons.codec.binary.Base64;
28 import org.apache.commons.collections.CollectionUtils;
29 import org.apache.commons.collections.MapUtils;
30 import org.apache.commons.lang3.StringUtils;
31 import org.apache.commons.lang3.tuple.ImmutablePair;
32 import org.openecomp.sdc.be.components.impl.ArtifactsBusinessLogic;
33 import org.openecomp.sdc.be.components.impl.ArtifactsBusinessLogic.ArtifactOperationEnum;
34 import org.openecomp.sdc.be.components.impl.ArtifactsBusinessLogic.ArtifactOperationInfo;
35 import org.openecomp.sdc.be.components.impl.BaseBusinessLogic;
36 import org.openecomp.sdc.be.components.impl.CsarValidationUtils;
37 import org.openecomp.sdc.be.components.impl.GroupBusinessLogic;
38 import org.openecomp.sdc.be.components.impl.ImportUtils;
39 import org.openecomp.sdc.be.components.impl.ImportUtils.ResultStatusEnum;
40 import org.openecomp.sdc.be.components.impl.exceptions.ComponentException;
41 import org.openecomp.sdc.be.config.BeEcompErrorManager;
42 import org.openecomp.sdc.be.config.BeEcompErrorManager.ErrorSeverity;
43 import org.openecomp.sdc.be.config.Configuration.VfModuleProperty;
44 import org.openecomp.sdc.be.config.ConfigurationManager;
45 import org.openecomp.sdc.be.dao.api.ActionStatus;
46 import org.openecomp.sdc.be.datamodel.utils.ArtifactUtils;
47 import org.openecomp.sdc.be.datatypes.elements.PropertyDataDefinition;
48 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
49 import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
50 import org.openecomp.sdc.be.impl.ComponentsUtils;
51 import org.openecomp.sdc.be.info.ArtifactTemplateInfo;
52 import org.openecomp.sdc.be.info.MergedArtifactInfo;
53 import org.openecomp.sdc.be.model.ArtifactDefinition;
54 import org.openecomp.sdc.be.model.ComponentParametersView;
55 import org.openecomp.sdc.be.model.GroupDefinition;
56 import org.openecomp.sdc.be.model.GroupProperty;
57 import org.openecomp.sdc.be.model.GroupTypeDefinition;
58 import org.openecomp.sdc.be.model.HeatParameterDefinition;
59 import org.openecomp.sdc.be.model.Operation;
60 import org.openecomp.sdc.be.model.PropertyDefinition;
61 import org.openecomp.sdc.be.model.Resource;
62 import org.openecomp.sdc.be.model.User;
63 import org.openecomp.sdc.be.model.heat.HeatParameterType;
64 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.ArtifactsOperations;
65 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.InterfaceOperation;
66 import org.openecomp.sdc.be.model.operations.api.IElementOperation;
67 import org.openecomp.sdc.be.model.operations.api.IGroupInstanceOperation;
68 import org.openecomp.sdc.be.model.operations.api.IGroupOperation;
69 import org.openecomp.sdc.be.model.operations.api.IGroupTypeOperation;
70 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
71 import org.openecomp.sdc.be.model.operations.impl.InterfaceLifecycleOperation;
72 import org.openecomp.sdc.be.resources.data.auditing.AuditingActionEnum;
73 import org.openecomp.sdc.be.servlets.RepresentationUtils;
74 import org.openecomp.sdc.be.tosca.CsarUtils;
75 import org.openecomp.sdc.common.api.ArtifactGroupTypeEnum;
76 import org.openecomp.sdc.common.api.ArtifactTypeEnum;
77 import org.openecomp.sdc.common.api.Constants;
78 import org.openecomp.sdc.common.log.wrappers.Logger;
79 import org.openecomp.sdc.exception.ResponseFormat;
80 import org.springframework.beans.factory.annotation.Autowired;
82 import java.util.ArrayList;
83 import java.util.Collection;
84 import java.util.Collections;
85 import java.util.HashMap;
86 import java.util.HashSet;
87 import java.util.List;
89 import java.util.Map.Entry;
90 import java.util.Optional;
91 import java.util.OptionalInt;
92 import java.util.Scanner;
94 import java.util.regex.Matcher;
95 import java.util.regex.Pattern;
96 import java.util.stream.Collectors;
97 import java.util.stream.IntStream;
99 import static org.openecomp.sdc.be.components.impl.ArtifactsBusinessLogic.FAILED_UPLOAD_ARTIFACT_TO_COMPONENT;
100 import static org.openecomp.sdc.be.tosca.CsarUtils.ARTIFACTS_PATH;
103 @org.springframework.stereotype.Component("csarArtifactsAndGroupsBusinessLogic")
104 public class CsarArtifactsAndGroupsBusinessLogic extends BaseBusinessLogic {
106 private static final Logger log = Logger.getLogger(CsarArtifactsAndGroupsBusinessLogic.class.getName());
107 private static final String ARTIFACT_FILE_IS_NOT_IN_EXPECTED_FORMATR_FILE_NAME = "Artifact file is not in expected formatr, fileName {}";
108 private static final String ARTIFACT_FILE_IS_NOT_IN_EXPECTED_FORMAT_FILE_NAME = "Artifact file is not in expected format, fileName {}";
109 private static final String ARTIFACT_FILE_IS_NOT_IN_EXPECTED_FORMATR_FILE_NAME1 = "Artifact file is not in expected formatr, fileName ";
110 private static final String ARTIFACT_FILE_IS_NOT_IN_EXPECTED_FORMAT_FILE_NAME1 = "Artifact file is not in expected format, fileName ";
111 private static final String ARTIFACT_INTERNALS_ARE_INVALID = "Artifact internals are invalid";
112 private static final String ARTIFACT_WITH_NAME_AND_TYPE_ALREADY_EXIST_WITH_TYPE = "Artifact with name {} and type {} already exist with type {}";
113 private final Gson gson = new Gson();
114 private static final Pattern pattern = Pattern.compile("\\..(.*?)\\..");
115 private static final String LABEL_COUNTER_DELIMITER = "[^0-9]+";
116 protected final ArtifactsBusinessLogic artifactsBusinessLogic;
117 private final GroupBusinessLogic groupBusinessLogic;
120 public CsarArtifactsAndGroupsBusinessLogic(IElementOperation elementDao,
121 IGroupOperation groupOperation,
122 IGroupInstanceOperation groupInstanceOperation,
123 IGroupTypeOperation groupTypeOperation,
124 GroupBusinessLogic groupBusinessLogic,
125 InterfaceOperation interfaceOperation,
126 InterfaceLifecycleOperation interfaceLifecycleTypeOperation,
127 ArtifactsBusinessLogic artifactsBusinessLogic, ArtifactsOperations artifactToscaOperation) {
128 super(elementDao, groupOperation, groupInstanceOperation, groupTypeOperation,
129 interfaceOperation, interfaceLifecycleTypeOperation, artifactToscaOperation);
130 this.artifactsBusinessLogic = artifactsBusinessLogic;
131 this.groupBusinessLogic = groupBusinessLogic;
134 public Either<Resource, ResponseFormat> createResourceArtifactsFromCsar(CsarInfo csarInfo, Resource resource,
135 String artifactsMetaFile, String artifactsMetaFileName, List<ArtifactDefinition> createdArtifacts) {
137 log.debug("parseResourceArtifactsInfoFromFile start");
138 return parseResourceArtifactsInfoFromFile(resource, artifactsMetaFile, artifactsMetaFileName)
140 .bind( p-> createResourceArtifacts(csarInfo, resource, p, createdArtifacts))
142 .map(rf -> { componentsUtils.auditResource(rf, csarInfo.getModifier(), resource, AuditingActionEnum.IMPORT_RESOURCE); return rf;})
144 .bind(this::getResourcetFromGraph);
148 public Either<Resource, ResponseFormat> updateResourceArtifactsFromCsar(CsarInfo csarInfo, Resource resource,
149 String artifactsMetaFile, String artifactsMetaFileName, List<ArtifactDefinition> createdNewArtifacts,
150 boolean shouldLock, boolean inTransaction){
152 Resource updatedResource = resource;
154 Either<Map<String, List<ArtifactTemplateInfo>>, ResponseFormat> parseResourceInfoFromYamlEither = parseResourceArtifactsInfoFromFile(
155 updatedResource, artifactsMetaFile, artifactsMetaFileName);
156 if (parseResourceInfoFromYamlEither.isRight()) {
157 ResponseFormat responseFormat = parseResourceInfoFromYamlEither.right().value();
158 componentsUtils.auditResource(responseFormat, csarInfo.getModifier(), resource, AuditingActionEnum.IMPORT_RESOURCE);
159 return Either.right(responseFormat);
162 List<GroupDefinition> groups = updatedResource.getGroups();
163 Map<String, ArtifactDefinition> deploymentArtifact = updatedResource.getDeploymentArtifacts();
164 if (MapUtils.isEmpty(deploymentArtifact)) {
165 deleteGroupsByType(groups, Constants.DEFAULT_GROUP_VF_MODULE, updatedResource);
166 return createResourceArtifacts(csarInfo, updatedResource, parseResourceInfoFromYamlEither.left().value(),
167 createdNewArtifacts);
170 List<ArtifactDefinition> createdDeploymentArtifactsAfterDelete = deploymentArtifact.values().stream()
171 .collect(Collectors.toList());
173 int labelCounter = createdDeploymentArtifactsAfterDelete
175 .map(ArtifactDefinition::getArtifactLabel)
176 .filter(this::isLastCharacterInLabelADigit)
177 .map(this::getNextInt)
178 .flatMapToInt(this::toStream)
182 ////////////////////////////////////// create set parsed
183 ////////////////////////////////////// artifacts///////////////////////////////////////////
184 Map<String, List<ArtifactTemplateInfo>> parsedArtifactsMap = parseResourceInfoFromYamlEither.left().value();
186 List<ArtifactTemplateInfo> artifactsWithoutGroups = parsedArtifactsMap.remove(ArtifactTemplateInfo.CSAR_ARTIFACT);
187 Collection<List<ArtifactTemplateInfo>> parsedArifactsCollection = parsedArtifactsMap.values();
189 Either<Map<ArtifactTemplateInfo, Set<ArtifactTemplateInfo>>, ResponseFormat> parsedArtifactsPerGroupEither = createArtifactsTemplateCollection(csarInfo, updatedResource, createdNewArtifacts, shouldLock, inTransaction,
190 createdDeploymentArtifactsAfterDelete, labelCounter, parsedArifactsCollection);
191 if(parsedArtifactsPerGroupEither.isRight()){
192 log.error("Failed to parse artifacts. Status is {} ", parsedArtifactsPerGroupEither.right().value());
193 return Either.right(parsedArtifactsPerGroupEither.right().value());
196 Map<ArtifactTemplateInfo, Set<ArtifactTemplateInfo>> parsedGroup = parsedArtifactsPerGroupEither.left().value();
198 // find master in group
199 Map<GroupDefinition, Map<ArtifactDefinition, List<ArtifactDefinition>>> groupArtifact = findMasterArtifactInGroup(
200 groups, deploymentArtifact);
202 ///////////////////////////////// find artifacts to
203 ///////////////////////////////// delete////////////////////////////////////////////////////
206 Map<String, List<ArtifactDefinition>> groupToDelete = new HashMap<>();
207 Set<ArtifactDefinition> artifactsToDelete = findArtifactThatNotInGroupToDelete(parsedGroup, createdDeploymentArtifactsAfterDelete);
209 Set<ArtifactTemplateInfo> jsonMasterArtifacts = parsedGroup.keySet();
210 Map<GroupDefinition, MergedArtifactInfo> mergedgroup = mergeGroupInUpdateFlow(groupArtifact, parsedGroup,
211 artifactsToDelete, groupToDelete, jsonMasterArtifacts, createdDeploymentArtifactsAfterDelete);
213 List<ArtifactDefinition> deletedArtifacts = new ArrayList<>();
214 Either<Resource, ResponseFormat> deletedArtifactsEither = deleteArtifactsInUpdateCsarFlow(
215 updatedResource, csarInfo.getModifier(), shouldLock, inTransaction, artifactsToDelete, groupToDelete, deletedArtifacts);
216 if (deletedArtifactsEither.isRight()) {
217 log.debug("Failed to delete artifacts. Status is {} ", deletedArtifactsEither.right().value());
219 return Either.right(deletedArtifactsEither.right().value());
222 updatedResource = deletedArtifactsEither.left().value();
224 // need to update resource if we updated artifacts
225 excludeDeletedArtifacts(deletedArtifacts, createdDeploymentArtifactsAfterDelete);
227 ////////////// dissociate, associate or create
228 ////////////// artifacts////////////////////////////
229 Either<Resource, ResponseFormat> assDissotiateEither = associateAndDissociateArtifactsToGroup(csarInfo,
230 updatedResource, createdNewArtifacts, labelCounter,
231 createdDeploymentArtifactsAfterDelete, mergedgroup, deletedArtifacts);
232 groups = updatedResource.getGroups();
233 if (assDissotiateEither.isRight()) {
234 log.debug("Failed to delete artifacts. Status is {} ", assDissotiateEither.right().value());
235 return Either.right(assDissotiateEither.right().value());
238 updatedResource = assDissotiateEither.left().value();
239 deploymentArtifact = updatedResource.getDeploymentArtifacts();
241 createdDeploymentArtifactsAfterDelete = deploymentArtifact.values().stream()
242 .collect(Collectors.toList());
244 // update vfModule names
245 Set<GroupDefinition> groupForAssociateWithMembers = mergedgroup.keySet();
246 Either<Resource, ResponseFormat> validateUpdateVfGroupNamesRes = updateVfModuleNames(createdNewArtifacts,
247 updatedResource, groups, createdDeploymentArtifactsAfterDelete, groupForAssociateWithMembers);
248 if (validateUpdateVfGroupNamesRes != null) return validateUpdateVfGroupNamesRes;
250 //////////////// create new artifacts in update
251 //////////////// flow////////////////////////////
252 List<ArtifactTemplateInfo> newArtifactsGroup = createNewArtifcats(parsedGroup, groupArtifact);
253 Either<Resource, ResponseFormat> validateGroupNamesRes = handleArtifactsInGroup(csarInfo, createdNewArtifacts,
254 updatedResource, groups, createdDeploymentArtifactsAfterDelete, labelCounter, newArtifactsGroup);
255 if (validateGroupNamesRes != null) return validateGroupNamesRes;
258 Either<Resource, ResponseFormat> updateVersionEither = updateGroupVersion(updatedResource, groupForAssociateWithMembers);
259 if (updateVersionEither != null) return updateVersionEither;
260 if (!CollectionUtils.isEmpty(artifactsWithoutGroups)) {
261 for (ArtifactTemplateInfo t : artifactsWithoutGroups) {
262 List<ArtifactTemplateInfo> artifacts = new ArrayList<>();
264 Either<Resource, ResponseFormat> resStatus = createGroupDeploymentArtifactsFromCsar(csarInfo, updatedResource,
265 artifacts, createdNewArtifacts, createdDeploymentArtifactsAfterDelete, labelCounter);
266 if (checkResponse(resStatus)) return resStatus;
271 Either<Resource, StorageOperationStatus> eitherGetResource = toscaOperationFacade.getToscaElement(updatedResource.getUniqueId());
272 return mapResult(eitherGetResource, updatedResource);
275 private Either<Resource, ResponseFormat> handleArtifactsInGroup(CsarInfo csarInfo, List<ArtifactDefinition> createdNewArtifacts,
276 Resource updatedResource, List<GroupDefinition> groups,
277 List<ArtifactDefinition> createdDeploymentArtifactsAfterDelete,
278 int labelCounter, List<ArtifactTemplateInfo> newArtifactsGroup) {
279 if (!newArtifactsGroup.isEmpty()) {
280 Collections.sort(newArtifactsGroup, ArtifactTemplateInfo::compareByGroupName);
281 int startGroupCounter = groupBusinessLogic.getNextVfModuleNameCounter(groups);
282 Either<Boolean, ResponseFormat> validateGroupNamesRes = groupBusinessLogic
283 .validateGenerateVfModuleGroupNames(newArtifactsGroup, updatedResource.getSystemName(), startGroupCounter);
284 if (validateGroupNamesRes.isRight()) {
285 return Either.right(validateGroupNamesRes.right().value());
287 Either<Resource, ResponseFormat> resStatus = createGroupDeploymentArtifactsFromCsar(csarInfo, updatedResource,
288 newArtifactsGroup, createdNewArtifacts, createdDeploymentArtifactsAfterDelete, labelCounter);
289 checkResponse(resStatus);
294 private boolean checkResponse(Either<Resource, ResponseFormat> resStatus) {
295 return (resStatus.isRight());
298 private Either<Resource, ResponseFormat> updateVfModuleNames(List<ArtifactDefinition> createdNewArtifacts, Resource updatedResource, List<GroupDefinition> groups, List<ArtifactDefinition> createdDeploymentArtifactsAfterDelete, Set<GroupDefinition> groupForAssociateWithMembers) {
299 if (!CollectionUtils.isEmpty(groups)) {
300 Either<List<GroupDefinition>, ResponseFormat> validateUpdateVfGroupNamesRes = groupBusinessLogic
301 .validateUpdateVfGroupNamesOnGraph(groups, updatedResource);
302 if (validateUpdateVfGroupNamesRes.isRight()) {
303 return Either.right(validateUpdateVfGroupNamesRes.right().value());
305 updateGroupMemebers(groups, groupForAssociateWithMembers, createdNewArtifacts, createdDeploymentArtifactsAfterDelete);
310 private Either<Resource, ResponseFormat> updateGroupVersion(Resource updatedResource, Set<GroupDefinition> groupForAssociateWithMembers) {
311 if (!groupForAssociateWithMembers.isEmpty()) {
313 List<GroupDefinition> groupsId = groupForAssociateWithMembers.stream()
314 .collect(Collectors.toList());
316 Either<List<GroupDefinition>, ResponseFormat> updateVersionEither = groupBusinessLogic
317 .updateGroups(updatedResource, groupsId, true);
318 if (updateVersionEither.isRight()) {
319 log.debug("Failed to update groups version. Status is {} ", updateVersionEither.right().value());
321 return Either.right(updateVersionEither.right().value());
328 private IntStream toStream(OptionalInt optionalInt) {
329 if (optionalInt.isPresent()) {
330 return IntStream.of(optionalInt.getAsInt());
332 return IntStream.empty();
335 private OptionalInt getNextInt(String artifactLabel) {
336 try(Scanner scanner = new Scanner(artifactLabel).useDelimiter(LABEL_COUNTER_DELIMITER)) {
337 if (scanner.hasNextInt()) {
338 return OptionalInt.of(scanner.nextInt());
340 return OptionalInt.empty();
344 private boolean isLastCharacterInLabelADigit(String artifactLabel) {
345 return Character.isDigit(artifactLabel.charAt(artifactLabel.length()-1));
348 private Either<Resource, ResponseFormat> mapResult(Either<Resource, StorageOperationStatus> result, Resource resource) {
349 return result.right()
350 .map(status -> componentsUtils.getResponseFormatByResource(
351 componentsUtils.convertFromStorageResponse(status), resource));
355 private void updateGroupMemebers(List<GroupDefinition> groups, Set<GroupDefinition> groupForAssociateWithMembers, List<ArtifactDefinition> createdNewArtifacts, List<ArtifactDefinition> createdDeploymentArtifactsAfterDelete) {
356 List<GroupDefinition> heatGroups = collectGroupsWithMembers(groups);
358 for (GroupDefinition updatedGroupDef : groupForAssociateWithMembers) {
359 Map<String, String> members = new HashMap<>();
360 Set<String> artifactsGroup = new HashSet<>();
361 artifactsGroup.addAll(updatedGroupDef.getArtifacts());
362 associateMembersToArtifacts(createdNewArtifacts, createdDeploymentArtifactsAfterDelete, heatGroups,
363 artifactsGroup, members);
365 updatedGroupDef.setMembers(members);
374 private List<GroupDefinition> collectGroupsWithMembers(List<GroupDefinition> groups) {
375 return groups.stream()
376 .filter(e -> e.getMembers() != null)
377 .collect(Collectors.toList());
382 * Exclude deleted Artificats from Deployment Artifcats
383 * @param deletedArtifacts
384 * @param createdDeploymentArtifactsAfterDelete
386 private void excludeDeletedArtifacts(List<ArtifactDefinition> deletedArtifacts, List<ArtifactDefinition> createdDeploymentArtifactsAfterDelete) {
387 for (ArtifactDefinition deletedArtifact : deletedArtifacts) {
388 ArtifactDefinition artToRemove = null;
389 for (ArtifactDefinition artFromResource : createdDeploymentArtifactsAfterDelete) {
390 if (deletedArtifact.getUniqueId().equalsIgnoreCase(artFromResource.getUniqueId())) {
391 artToRemove = artFromResource;
395 if (artToRemove != null) {
396 createdDeploymentArtifactsAfterDelete.remove(artToRemove);
403 private void deleteGroupsByType(List<GroupDefinition> groups, String groupType, Resource resource) {
405 List<GroupDefinition> listToDelete = groups.stream()
406 .filter(g -> g.getType().equals(groupType))
407 .collect(Collectors.toList());
409 groupBusinessLogic.deleteGroups(resource, listToDelete);
414 private List<ArtifactTemplateInfo> createNewArtifcats(Map<ArtifactTemplateInfo, Set<ArtifactTemplateInfo>> parsedGroup, Map<GroupDefinition, Map<ArtifactDefinition, List<ArtifactDefinition>>> groupArtifact) {
415 List<ArtifactTemplateInfo> newArtifactsGroup = new ArrayList<>();
417 for (Entry<ArtifactTemplateInfo, Set<ArtifactTemplateInfo>> parsedGroupSetEntry : parsedGroup.entrySet()) {
418 ArtifactTemplateInfo parsedArtifactMaster = parsedGroupSetEntry.getKey();
419 boolean isNewGroup = true;
420 for (Entry<GroupDefinition, Map<ArtifactDefinition, List<ArtifactDefinition>>> groupListEntry : groupArtifact
422 Map<ArtifactDefinition, List<ArtifactDefinition>> groupArtifacts = groupListEntry.getValue();
423 Set<ArtifactDefinition> group = groupArtifacts.keySet();
424 for (ArtifactDefinition artifactInfo : group) {
425 if (parsedArtifactMaster.getFileName().equalsIgnoreCase(artifactInfo.getArtifactName())) {
426 parsedArtifactMaster.setGroupName(groupListEntry.getKey().getName());
432 newArtifactsGroup.add(parsedArtifactMaster);
436 return newArtifactsGroup;
439 private Set<ArtifactDefinition> findArtifactThatNotInGroupToDelete(
440 Map<ArtifactTemplateInfo, Set<ArtifactTemplateInfo>> parsedGroup,
441 List<ArtifactDefinition> createdDeploymentArtifactsAfterDelete) {
442 Set<ArtifactDefinition> artifactsToDelete = new HashSet<>();
443 for (Entry<ArtifactTemplateInfo, Set<ArtifactTemplateInfo>> parsedGroupSetEntry : parsedGroup.entrySet()) {
444 Set<ArtifactTemplateInfo> artifactsNames = parsedGroupSetEntry.getValue();
445 for (ArtifactTemplateInfo template : artifactsNames) {
446 if(template.getType().equals(ArtifactTypeEnum.HEAT_ARTIFACT.getType())){
447 Optional<ArtifactDefinition> op = createdDeploymentArtifactsAfterDelete.stream().filter(a -> a.getArtifactName().equalsIgnoreCase(template.getFileName())).findAny();
448 if (op.isPresent() && !op.get().getArtifactType().equalsIgnoreCase(template.getType())) {
449 artifactsToDelete.add(op.get());
455 return artifactsToDelete;
459 private Either<Resource, ResponseFormat> createResourceArtifacts(CsarInfo csarInfo, Resource resource,
460 Map<String, List<ArtifactTemplateInfo>> artifactsMap,
461 List<ArtifactDefinition> createdArtifacts) {
463 Either<Resource, ResponseFormat> resStatus = Either.left(resource);
465 Collection<List<ArtifactTemplateInfo>> arifactsCollection = artifactsMap.values();
467 for (List<ArtifactTemplateInfo> groupTemplateList : arifactsCollection) {
468 if (groupTemplateList != null) {
469 resStatus = createGroupDeploymentArtifactsFromCsar(csarInfo, resource, groupTemplateList,
470 createdArtifacts, 0);
471 if (resStatus.isRight()) {
482 private Either<Map<ArtifactTemplateInfo, Set<ArtifactTemplateInfo>>, ResponseFormat> createArtifactsTemplateCollection(CsarInfo csarInfo, Resource resource,
483 List<ArtifactDefinition> createdNewArtifacts, boolean shouldLock, boolean inTransaction,
484 List<ArtifactDefinition> createdDeploymentArtifactsAfterDelete, int labelCounter,
485 Collection<List<ArtifactTemplateInfo>> parsedArifactsCollection) {
487 Map<ArtifactTemplateInfo, Set<ArtifactTemplateInfo>> parsedGroup = new HashMap<>();
489 for (List<ArtifactTemplateInfo> parsedGroupTemplateList : parsedArifactsCollection) {
491 for (ArtifactTemplateInfo parsedGroupTemplate : parsedGroupTemplateList) {
492 if (parsedGroupTemplate.getGroupName() != null) {
493 parsedGroupTemplate.setGroupName("");
494 Set<ArtifactTemplateInfo> parsedArtifactsNames = new HashSet<>();
495 parsedArtifactsNames.add(parsedGroupTemplate);
496 List<ArtifactTemplateInfo> relatedGroupTemplateList = parsedGroupTemplate.getRelatedArtifactsInfo();
497 if (relatedGroupTemplateList != null && !relatedGroupTemplateList.isEmpty()) {
498 createArtifactsGroupSet(parsedGroupTemplateList, parsedArtifactsNames);
500 parsedGroup.put(parsedGroupTemplate, parsedArtifactsNames);
502 List<ArtifactTemplateInfo> arrtifacts = new ArrayList<>();
503 arrtifacts.add(parsedGroupTemplate);
504 Either<Resource, ResponseFormat> resStatus = createGroupDeploymentArtifactsFromCsar(csarInfo,
505 resource, arrtifacts, createdNewArtifacts, createdDeploymentArtifactsAfterDelete,
507 if (resStatus.isRight()) {
508 return Either.right(resStatus.right().value());
515 return Either.left(parsedGroup);
518 @SuppressWarnings({ "unchecked", "static-access" })
519 public Either<Map<String, List<ArtifactTemplateInfo>>, ResponseFormat> parseResourceArtifactsInfoFromFile(
520 Resource resource, String artifactsMetaFile, String artifactFileName) {
523 JsonObject jsonElement = new JsonObject();
524 jsonElement = gson.fromJson(artifactsMetaFile, jsonElement.getClass());
526 JsonElement importStructureElement = jsonElement.get(Constants.IMPORT_STRUCTURE);
527 if (importStructureElement == null || importStructureElement.isJsonNull()) {
528 log.debug(ARTIFACT_FILE_IS_NOT_IN_EXPECTED_FORMAT_FILE_NAME, artifactFileName);
529 BeEcompErrorManager.getInstance().logInternalDataError(
530 ARTIFACT_FILE_IS_NOT_IN_EXPECTED_FORMAT_FILE_NAME + artifactFileName,
531 ARTIFACT_INTERNALS_ARE_INVALID, ErrorSeverity.ERROR);
533 .right(componentsUtils.getResponseFormat(ActionStatus.CSAR_INVALID_FORMAT, artifactFileName));
536 Map<String, List<Map<String, Object>>> artifactTemplateMap;
537 artifactTemplateMap = ComponentsUtils.parseJsonToObject(importStructureElement.toString(), HashMap.class);
538 if (artifactTemplateMap.isEmpty()) {
539 log.debug(ARTIFACT_FILE_IS_NOT_IN_EXPECTED_FORMAT_FILE_NAME, artifactFileName);
540 BeEcompErrorManager.getInstance().logInternalDataError(
541 ARTIFACT_FILE_IS_NOT_IN_EXPECTED_FORMAT_FILE_NAME + artifactFileName,
542 ARTIFACT_INTERNALS_ARE_INVALID, ErrorSeverity.ERROR);
544 .right(componentsUtils.getResponseFormat(ActionStatus.CSAR_INVALID_FORMAT, artifactFileName));
547 Set<String> artifactsTypeKeys = artifactTemplateMap.keySet();
548 Map<String, List<ArtifactTemplateInfo>> artifactsMap = new HashMap<>();
549 List<ArtifactTemplateInfo> allGroups = new ArrayList<>();
550 for (String artifactsTypeKey : artifactsTypeKeys) {
552 Either <List<ArtifactTemplateInfo>, ResponseFormat> artifactTemplateInfoListEither = parseArtifactTemplateList(artifactFileName,
553 artifactTemplateMap, allGroups, artifactsTypeKey);
554 if(artifactTemplateInfoListEither.isRight()){
555 return Either.right(artifactTemplateInfoListEither.right().value());
557 artifactsMap.put(artifactsTypeKey, artifactTemplateInfoListEither.left().value());
559 int counter = groupBusinessLogic.getNextVfModuleNameCounter(resource.getGroups());
560 Either<Boolean, ResponseFormat> validateGroupNamesRes = groupBusinessLogic
561 .validateGenerateVfModuleGroupNames(allGroups, resource.getSystemName(), counter);
562 if (validateGroupNamesRes.isRight()) {
563 return Either.right(validateGroupNamesRes.right().value());
565 return Either.left(artifactsMap);
566 } catch (Exception e) {
567 log.debug(ARTIFACT_FILE_IS_NOT_IN_EXPECTED_FORMAT_FILE_NAME, artifactFileName);
568 log.debug("failed with exception.", e);
569 BeEcompErrorManager.getInstance().logInternalDataError(
570 ARTIFACT_FILE_IS_NOT_IN_EXPECTED_FORMAT_FILE_NAME + artifactFileName,
571 ARTIFACT_INTERNALS_ARE_INVALID, ErrorSeverity.ERROR);
572 return Either.right(componentsUtils.getResponseFormat(ActionStatus.CSAR_INVALID_FORMAT, artifactFileName));
577 private Either< List<ArtifactTemplateInfo>, ResponseFormat> parseArtifactTemplateList(String artifactFileName,
578 Map<String, List<Map<String, Object>>> artifactTemplateMap, List<ArtifactTemplateInfo> allGroups,
579 String artifactsTypeKey) {
580 List<Map<String, Object>> o = artifactTemplateMap.get(artifactsTypeKey);
581 Either<List<ArtifactTemplateInfo>, ResponseFormat> artifactTemplateInfoListPairStatus = createArtifactTemplateInfoModule(
582 artifactsTypeKey, o);
583 if (artifactTemplateInfoListPairStatus.isRight()) {
584 log.debug(ARTIFACT_FILE_IS_NOT_IN_EXPECTED_FORMAT_FILE_NAME, artifactFileName);
585 BeEcompErrorManager.getInstance().logInternalDataError(
586 ARTIFACT_FILE_IS_NOT_IN_EXPECTED_FORMAT_FILE_NAME + artifactFileName,
587 ARTIFACT_INTERNALS_ARE_INVALID, ErrorSeverity.ERROR);
588 return Either.right(artifactTemplateInfoListPairStatus.right().value());
590 List<ArtifactTemplateInfo> artifactTemplateInfoList = artifactTemplateInfoListPairStatus.left().value();
591 if (artifactTemplateInfoList == null) {
592 log.debug(ARTIFACT_FILE_IS_NOT_IN_EXPECTED_FORMAT_FILE_NAME, artifactFileName);
593 BeEcompErrorManager.getInstance().logInternalDataError(
594 ARTIFACT_FILE_IS_NOT_IN_EXPECTED_FORMAT_FILE_NAME + artifactFileName,
595 ARTIFACT_INTERNALS_ARE_INVALID, ErrorSeverity.ERROR);
597 componentsUtils.getResponseFormat(ActionStatus.CSAR_INVALID_FORMAT, artifactFileName));
600 if (!artifactsTypeKey.equalsIgnoreCase(ArtifactTemplateInfo.CSAR_ARTIFACT)) {
601 allGroups.addAll(artifactTemplateInfoList);
603 return Either.left(artifactTemplateInfoList);
606 private Either<List<ArtifactTemplateInfo>, ResponseFormat> createArtifactTemplateInfoModule(String artifactsTypeKey,
607 List<Map<String, Object>> jsonObject) {
608 List<ArtifactTemplateInfo> artifactTemplateInfoList = new ArrayList<>();
609 for (Map<String, Object> o : jsonObject) {
610 Either<ArtifactTemplateInfo, ResponseFormat> artifacttemplateInfoStatus = ArtifactTemplateInfo
611 .createArtifactTemplateInfoFromJson(componentsUtils, artifactsTypeKey, o, artifactTemplateInfoList,
613 if (artifacttemplateInfoStatus.isRight()) {
614 return Either.right(artifacttemplateInfoStatus.right().value());
617 ArtifactTemplateInfo artifacttemplateInfo = artifacttemplateInfoStatus.left().value();
618 if (artifacttemplateInfo != null) {
619 artifactTemplateInfoList.add(artifacttemplateInfo);
623 return Either.left(artifactTemplateInfoList);
628 private Either<Resource, ResponseFormat> createGroupDeploymentArtifactsFromCsar(CsarInfo csarInfo,
629 Resource resource, List<ArtifactTemplateInfo> artifactsTemplateList,
630 List<ArtifactDefinition> createdArtifacts, int labelCounter) {
631 List<GroupDefinition> createdGroups = resource.getGroups();
632 List<GroupDefinition> heatGroups = null;
633 if (!CollectionUtils.isEmpty(createdGroups)) {
634 heatGroups = collectGroupsWithMembers(createdGroups);
636 List<GroupDefinition> needToCreate = new ArrayList<>();
637 for (ArtifactTemplateInfo groupTemplateInfo : artifactsTemplateList) {
638 String groupName = groupTemplateInfo.getGroupName();
639 Set<String> artifactsGroup = new HashSet<>();
640 Set<String> artifactsUUIDGroup = new HashSet<>();
642 log.debug("createDeploymentArtifactsFromCsar start");
643 Either<Resource, ResponseFormat> resStatus = createDeploymentArtifactFromCsar(csarInfo, ARTIFACTS_PATH, resource, artifactsGroup,
644 artifactsUUIDGroup, groupTemplateInfo, createdArtifacts, labelCounter);
645 log.debug("createDeploymentArtifactsFromCsar end");
646 if (resStatus.isRight()) {
649 Map<String, ArtifactDefinition> createdArtifactsMap = createdArtifacts.stream().collect(Collectors.toMap(artifact -> artifact.getArtifactLabel(), artifact -> artifact));
650 resource.setDeploymentArtifacts(createdArtifactsMap);
651 if (groupName != null && !groupName.isEmpty()) {
653 Either<GroupDefinition, ResponseFormat> groupDefinitionEither = buildGroupDefinition(createdArtifacts, heatGroups, groupTemplateInfo,
654 groupName, artifactsGroup, artifactsUUIDGroup);
655 if (groupDefinitionEither.isRight()) {
656 return Either.right(groupDefinitionEither.right().value());
658 needToCreate.add(groupDefinitionEither.left().value());
661 Map<String, ArtifactDefinition> createdArtifactsMap = createdArtifacts.stream().collect(Collectors.toMap(artifact -> artifact.getArtifactLabel(), artifact -> artifact));
662 resource.setDeploymentArtifacts(createdArtifactsMap);
664 Either<List<GroupDefinition>, ResponseFormat> createGroups = groupBusinessLogic
665 .addGroups(resource, needToCreate, false);
666 if (createGroups.isRight()) {
667 return Either.right(createGroups.right().value());
670 return Either.left(resource);
673 private Either<GroupDefinition, ResponseFormat> buildGroupDefinition(List<ArtifactDefinition> createdArtifacts,
674 List<GroupDefinition> heatGroups, ArtifactTemplateInfo groupTemplateInfo, String groupName,
675 Set<String> artifactsGroup, Set<String> artifactsUUIDGroup) {
677 Map<String, String> members = new HashMap<>();
679 associateMembersToArtifacts(createdArtifacts, null, heatGroups, artifactsGroup, members);
681 List<String> artifactsList = new ArrayList<>(artifactsGroup);
682 List<String> artifactsUUIDList = new ArrayList<>(artifactsUUIDGroup);
684 GroupDefinition groupDefinition = new GroupDefinition();
685 groupDefinition.setName(groupName);
686 groupDefinition.setType(Constants.DEFAULT_GROUP_VF_MODULE);
687 groupDefinition.setArtifacts(artifactsList);
688 groupDefinition.setArtifactsUuid(artifactsUUIDList);
690 if (!members.isEmpty()) {
691 groupDefinition.setMembers(members);
693 List<GroupProperty> properties = new ArrayList<>();
694 GroupProperty prop = new GroupProperty();
695 prop.setName(Constants.IS_BASE);
696 prop.setValue(Boolean.toString(groupTemplateInfo.isBase()));
697 properties.add(prop);
698 Either<GroupTypeDefinition, StorageOperationStatus> getLatestGroupTypeRes = groupTypeOperation
699 .getLatestGroupTypeByType(Constants.DEFAULT_GROUP_VF_MODULE, true);
700 if (getLatestGroupTypeRes.isRight()) {
701 return Either.right(componentsUtils.getResponseFormat(
702 componentsUtils.convertFromStorageResponse(getLatestGroupTypeRes.right().value())));
704 properties = createVfModuleAdditionalProperties(groupTemplateInfo.isBase(), groupName, properties,
705 createdArtifacts, artifactsList, getLatestGroupTypeRes.left().value());
706 groupDefinition.convertFromGroupProperties(properties);
707 log.debug("createGroup start");
708 return Either.left(groupDefinition);
711 private Either<Resource, ResponseFormat> createDeploymentArtifactFromCsar(CsarInfo csarInfo, String artifactPath,
712 Resource resource, Set<String> artifactsGroup, Set<String> artifactsUUIDGroup,
713 ArtifactTemplateInfo artifactTemplateInfo, List<ArtifactDefinition> createdArtifacts, int labelCounter) {
714 Either<Resource, ResponseFormat> resStatus = Either.left(resource);
716 String artifactUid = "";
717 String artifactEnvUid = "";
718 String artifactUUID = "";
721 // check if artifacts already exist
722 Either<ArtifactDefinition, ResponseFormat> createdArtifactEther = checkIfArtifactAlreadyExist(artifactTemplateInfo, createdArtifacts);
723 if(createdArtifactEther.isRight()){
724 return Either.right(createdArtifactEther.right().value());
726 ArtifactDefinition createdArtifact = createdArtifactEther.left().value();
727 if(createdArtifact == null){
729 Either<ArtifactDefinition, ResponseFormat> newArtifactEither = createDeploymentArtifact(csarInfo, resource,
730 artifactPath, artifactTemplateInfo, createdArtifacts, labelCounter);
731 if (newArtifactEither.isRight()) {
732 resStatus = Either.right(newArtifactEither.right().value());
735 ArtifactDefinition newArtifact = newArtifactEither.left().value();
736 artifactUid = newArtifact.getUniqueId();
737 artifactUUID = newArtifact.getArtifactUUID();
739 final ArtifactTypeEnum artifactType = ArtifactTypeEnum.parse(newArtifact.getArtifactType());
740 if (artifactType == ArtifactTypeEnum.HEAT || artifactType == ArtifactTypeEnum.HEAT_NET
741 || artifactType == ArtifactTypeEnum.HEAT_VOL) {
742 ArtifactDefinition createHeatEnvPlaceHolder = artifactsBusinessLogic
743 .createHeatEnvPlaceHolder(createdArtifacts, newArtifact, ArtifactsBusinessLogic.HEAT_VF_ENV_NAME,
744 resource.getUniqueId(), NodeTypeEnum.Resource, resource.getName(),
745 csarInfo.getModifier(), resource, null);
746 artifactEnvUid = createHeatEnvPlaceHolder.getUniqueId();
749 artifactUid = createdArtifact.getUniqueId();
750 artifactUUID = createdArtifact.getArtifactUUID();
751 artifactEnvUid = checkAndGetHeatEnvId(createdArtifact);
753 artifactsGroup.add(artifactUid);
754 artifactsUUIDGroup.add(artifactUUID);
755 if (!artifactEnvUid.isEmpty()) {
756 artifactsGroup.add(artifactEnvUid);
759 List<ArtifactTemplateInfo> relatedArtifacts = artifactTemplateInfo.getRelatedArtifactsInfo();
760 if (relatedArtifacts != null) {
761 for (ArtifactTemplateInfo relatedArtifactTemplateInfo : relatedArtifacts) {
762 resStatus = createDeploymentArtifactFromCsar(csarInfo, artifactPath, resource, artifactsGroup,
763 artifactsUUIDGroup, relatedArtifactTemplateInfo, createdArtifacts, labelCounter);
764 if (resStatus.isRight()) {
772 private String checkAndGetHeatEnvId(ArtifactDefinition createdArtifact) {
773 String artifactEnvUid = "";
774 final ArtifactTypeEnum artifactType = ArtifactTypeEnum.parse(createdArtifact.getArtifactType());
775 if (artifactType == ArtifactTypeEnum.HEAT || artifactType == ArtifactTypeEnum.HEAT_NET
776 || artifactType == ArtifactTypeEnum.HEAT_VOL) {
777 artifactEnvUid = createdArtifact.getUniqueId() + ArtifactsBusinessLogic.HEAT_ENV_SUFFIX;
779 return artifactEnvUid;
782 private Either<ArtifactDefinition, ResponseFormat> checkIfArtifactAlreadyExist(ArtifactTemplateInfo artifactTemplateInfo, List<ArtifactDefinition> createdArtifacts){
784 ArtifactDefinition res = null;
785 String artifactFileName = artifactTemplateInfo.getFileName();
786 Optional<ArtifactDefinition> op = createdArtifacts.stream().filter(a -> a.getArtifactName().equals(artifactFileName)).findAny();
789 if (!res.getArtifactType().equalsIgnoreCase(artifactTemplateInfo.getType())) {
790 log.debug(ARTIFACT_WITH_NAME_AND_TYPE_ALREADY_EXIST_WITH_TYPE, artifactFileName,
791 artifactTemplateInfo.getType(), res.getArtifactType());
792 BeEcompErrorManager.getInstance().logInternalDataError(
793 ARTIFACT_FILE_IS_NOT_IN_EXPECTED_FORMAT_FILE_NAME + artifactFileName,
794 ARTIFACT_INTERNALS_ARE_INVALID, ErrorSeverity.ERROR);
795 return Either.right(componentsUtils.getResponseFormat(
796 ActionStatus.ARTIFACT_ALREADY_EXIST_IN_DIFFERENT_TYPE_IN_CSAR, artifactFileName,
797 artifactTemplateInfo.getType(), res.getArtifactType()));
800 return Either.left(res);
805 private Either<ArtifactDefinition, ResponseFormat> createDeploymentArtifact(CsarInfo csarInfo, Resource resource,
806 String artifactPath, ArtifactTemplateInfo artifactTemplateInfo, List<ArtifactDefinition> createdArtifacts,
808 int updatedlabel = label;
809 final String artifactFileName = artifactTemplateInfo.getFileName();
810 Either<ImmutablePair<String, byte[]>, ResponseFormat> artifactContentStatus = CsarValidationUtils
811 .getArtifactContent(csarInfo.getCsarUUID(), csarInfo.getCsar(), artifactPath + artifactFileName,
812 artifactFileName, componentsUtils);
813 if (artifactContentStatus.isRight()) {
814 return Either.right(artifactContentStatus.right().value());
816 updatedlabel += createdArtifacts.size();
818 Map<String, Object> json = ArtifactUtils.buildJsonForArtifact(artifactTemplateInfo,
819 artifactContentStatus.left().value().getValue(), updatedlabel, true);
821 Either<Either<ArtifactDefinition, Operation>, ResponseFormat> uploadArtifactToService = createOrUpdateCsarArtifactFromJson(
822 resource, csarInfo.getModifier(), json,
823 artifactsBusinessLogic.new ArtifactOperationInfo(false, false, ArtifactOperationEnum.CREATE));
825 if (uploadArtifactToService.isRight()) {
826 return Either.right(uploadArtifactToService.right().value());
829 ArtifactDefinition currentInfo = uploadArtifactToService.left().value().left().value();
830 if (currentInfo.getHeatParameters() != null) {
832 Either<ArtifactDefinition, ResponseFormat> updateEnvEither = updateHeatParamsFromCsar(resource, csarInfo,
833 artifactTemplateInfo, currentInfo, false);
834 if (updateEnvEither.isRight()) {
835 log.debug("failed to update parameters to artifact {}", artifactFileName);
836 return Either.right(updateEnvEither.right().value());
839 currentInfo = updateEnvEither.left().value();
843 createdArtifacts.add(currentInfo);
845 return Either.left(currentInfo);
851 private Either<ArtifactDefinition, ResponseFormat> updateHeatParamsFromCsar(Resource resource, CsarInfo csarInfo,
852 ArtifactTemplateInfo artifactTemplateInfo, ArtifactDefinition currentInfo, boolean isUpdateEnv) {
854 Resource updatedResource = resource;
855 Either<ArtifactDefinition, ResponseFormat> resStatus = Either.left(currentInfo);
856 if (artifactTemplateInfo.getEnv() != null && !artifactTemplateInfo.getEnv().isEmpty()) {
858 Either<ImmutablePair<String, byte[]>, ResponseFormat> artifactParamsStatus = CsarValidationUtils
859 .getArtifactContent(csarInfo.getCsarUUID(), csarInfo.getCsar(),
860 CsarUtils.ARTIFACTS_PATH + artifactTemplateInfo.getEnv(), artifactTemplateInfo.getEnv(),
862 if (artifactParamsStatus.isRight()) {
863 resStatus = Either.right(artifactParamsStatus.right().value());
866 Either<List<HeatParameterDefinition>, ResponseFormat> propsStatus = extractHeatParameters(
867 ArtifactTypeEnum.HEAT_ENV.getType(), artifactTemplateInfo.getEnv(),
868 artifactParamsStatus.left().value().getValue(), false);
870 if (propsStatus.isLeft()) {
871 List<HeatParameterDefinition> updatedHeatEnvParams = propsStatus.left().value();
872 resStatus = updateHeatParams(updatedResource, currentInfo, updatedHeatEnvParams);
873 if (resStatus.isRight()) {
880 Map<String, ArtifactDefinition> artifacts = updatedResource.getDeploymentArtifacts();
881 Optional<ArtifactDefinition> op = artifacts.values().stream().filter(
882 p -> p.getGeneratedFromId() != null && p.getGeneratedFromId().equals(currentInfo.getUniqueId()))
884 if (op.isPresent()) {
885 ArtifactDefinition artifactInfoHeatEnv = op.get();
886 artifactInfoHeatEnv.setHeatParamUpdated(true);
887 Either<ArtifactDefinition, StorageOperationStatus> updateArtifactOnResource = artifactToscaOperation
888 .updateArtifactOnResource(artifactInfoHeatEnv, updatedResource,
889 artifactInfoHeatEnv.getUniqueId(), null, null,true);
890 if (updateArtifactOnResource.isRight()) {
891 log.debug("Failed to update heat env on CSAR flow for component {} artifact {} label {}",
892 updatedResource.getUniqueId(), artifactInfoHeatEnv.getUniqueId(),
893 artifactInfoHeatEnv.getArtifactLabel());
894 return Either.right(componentsUtils.getResponseFormat(
895 componentsUtils.convertFromStorageResponse(updateArtifactOnResource.right().value())));
897 resource.getDeploymentArtifacts().put(updateArtifactOnResource.left().value().getArtifactLabel(), updateArtifactOnResource.left().value());
898 resStatus = Either.left(updateArtifactOnResource.left().value());
905 private Either<List<HeatParameterDefinition>, ResponseFormat> extractHeatParameters(String artifactType,
906 String fileName, byte[] content, boolean is64Encoded) {
907 // extract heat parameters
908 String heatDecodedPayload = is64Encoded ? new String(Base64.decodeBase64(content)) : new String(content);
909 Either<List<HeatParameterDefinition>, ResultStatusEnum> heatParameters = ImportUtils
910 .getHeatParamsWithoutImplicitTypes(heatDecodedPayload, artifactType);
911 if (heatParameters.isRight()) {
912 log.debug("File {} is not in expected key-value form in csar ", fileName);
913 BeEcompErrorManager.getInstance().logInternalDataError(
914 "File " + fileName + " is not in expected key-value form in csar ", "CSAR internals are invalid",
915 ErrorSeverity.ERROR);
917 .right(componentsUtils.getResponseFormat(ActionStatus.INVALID_DEPLOYMENT_ARTIFACT_HEAT, fileName));
920 return Either.left(heatParameters.left().value());
924 private Either<ArtifactDefinition, ResponseFormat> updateHeatParams(Resource resource,
925 ArtifactDefinition currentInfo, List<HeatParameterDefinition> updatedHeatEnvParams) {
927 Either<ArtifactDefinition, ResponseFormat> resStatus = Either.left(currentInfo);
928 List<HeatParameterDefinition> currentHeatEnvParams = currentInfo.getListHeatParameters();
930 if (updatedHeatEnvParams != null && !updatedHeatEnvParams.isEmpty() && currentHeatEnvParams != null
931 && !currentHeatEnvParams.isEmpty()) {
934 for (HeatParameterDefinition heatEnvParam : updatedHeatEnvParams) {
936 paramName = heatEnvParam.getName();
937 for (HeatParameterDefinition currHeatParam : currentHeatEnvParams) {
938 if (paramName.equalsIgnoreCase(currHeatParam.getName())) {
940 String updatedParamValue = heatEnvParam.getCurrentValue();
941 if (updatedParamValue == null) {
942 updatedParamValue = heatEnvParam.getDefaultValue();
944 HeatParameterType paramType = HeatParameterType.isValidType(currHeatParam.getType());
945 if (!paramType.getValidator().isValid(updatedParamValue, null)) {
946 ActionStatus status = ActionStatus.INVALID_HEAT_PARAMETER_VALUE;
947 ResponseFormat responseFormat = componentsUtils.getResponseFormat(status,
948 ArtifactTypeEnum.HEAT_ENV.getType(), paramType.getType(), paramName);
949 resStatus = Either.right(responseFormat);
952 currHeatParam.setCurrentValue(
953 paramType.getConverter().convert(updatedParamValue, null, null));
959 currentInfo.setListHeatParameters(currentHeatEnvParams);
960 Either<ArtifactDefinition, StorageOperationStatus> updateArtifactOnResource = artifactToscaOperation
961 .updateArtifactOnResource(currentInfo, resource, currentInfo.getUniqueId(),
963 if (updateArtifactOnResource.isRight()) {
965 "Failed to update heat parameters of heat on CSAR flow for component {} artifact {} label {}",
966 resource.getUniqueId(), currentInfo.getUniqueId(), currentInfo.getArtifactLabel());
967 return Either.right(componentsUtils.getResponseFormat(
968 componentsUtils.convertFromStorageResponse(updateArtifactOnResource.right().value())));
970 resource.getDeploymentArtifacts().put(currentInfo.getArtifactLabel(), currentInfo);
971 resStatus = Either.left(updateArtifactOnResource.left().value());
976 public Either<Either<ArtifactDefinition, Operation>, ResponseFormat> createOrUpdateCsarArtifactFromJson(
977 Resource resource, User user, Map<String, Object> json, ArtifactOperationInfo operation) {
979 String jsonStr = gson.toJson(json);
980 ArtifactDefinition artifactDefinitionFromJson = RepresentationUtils.convertJsonToArtifactDefinition(jsonStr,
981 ArtifactDefinition.class, false);
983 Either<ArtifactDefinition, Operation> result;
985 result = artifactsBusinessLogic.handleLoadedArtifact(
986 resource, user, operation, false, true, ComponentTypeEnum.RESOURCE, artifactDefinitionFromJson);
987 } catch (ComponentException e) {
988 log.debug(FAILED_UPLOAD_ARTIFACT_TO_COMPONENT, ComponentTypeEnum.RESOURCE, resource.getName());
989 return Either.right(componentsUtils.getResponseFormat(e));
990 } catch (Exception e) {
991 ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR);
992 log.debug("Exception occurred when createOrUpdateCsarArtifactFromJson, error is:{}", e.getMessage(), e);
993 return Either.right(responseFormat);
995 return Either.left(result);
998 private void associateMembersToArtifacts(List<ArtifactDefinition> createdArtifacts,
999 List<ArtifactDefinition> artifactsFromResource, List<GroupDefinition> heatGroups,
1000 Set<String> artifactsGroup, Map<String, String> members) {
1001 if (heatGroups != null && !heatGroups.isEmpty()) {
1002 for (GroupDefinition heatGroup : heatGroups) {
1003 List<GroupProperty> grpoupProps = heatGroup.convertToGroupProperties();
1004 if (grpoupProps != null) {
1005 associateMembersToVFgroups(createdArtifacts, artifactsFromResource, grpoupProps, artifactsGroup, heatGroup, members);
1011 private void associateMembersToVFgroups(List<ArtifactDefinition> createdArtifacts, List<ArtifactDefinition> artifactsFromResource, List<GroupProperty> grpoupProps, Set<String> artifactsGroup, GroupDefinition heatGroup, Map<String, String> members){
1012 Optional<GroupProperty> op = grpoupProps.stream()
1013 .filter(p -> p.getName().equals(Constants.HEAT_FILE_PROPS)).findAny();
1014 if (op.isPresent()) {
1015 GroupProperty prop = op.get();
1016 String heatFileNAme = prop.getValue();
1017 if (null == heatFileNAme || heatFileNAme.isEmpty()) {
1020 List<ArtifactDefinition> artifacts = new ArrayList<>();
1021 for (String artifactId : artifactsGroup) {
1022 Optional<ArtifactDefinition> opArt = createdArtifacts.stream()
1023 .filter(p -> p.getUniqueId().equals(artifactId)).findAny();
1024 opArt.ifPresent(artifacts::add);
1025 if (artifactsFromResource != null) {
1026 opArt = artifactsFromResource.stream().filter(p -> p.getUniqueId().equals(artifactId))
1028 opArt.ifPresent(artifacts::add);
1031 Optional<ArtifactDefinition> resOp = artifacts.stream()
1032 .filter(p -> heatFileNAme.contains(p.getArtifactName())).findAny();
1033 resOp.ifPresent(artifactDefinition -> members.putAll(heatGroup.getMembers()));
1037 public List<GroupProperty> createVfModuleAdditionalProperties(boolean isBase, String moduleName,
1038 List<GroupProperty> properties, List<ArtifactDefinition> deploymentArtifacts, List<String> artifactsInGroup,
1039 GroupTypeDefinition groupType) {
1040 Map<String, VfModuleProperty> vfModuleProperties = ConfigurationManager.getConfigurationManager()
1041 .getConfiguration().getVfModuleProperties();
1042 vfModuleProperties.entrySet().forEach(p -> {
1043 GroupProperty prop = new GroupProperty();
1044 prop.setName(p.getKey());
1046 prop.setValue(p.getValue().getForBaseModule());
1047 prop.setDefaultValue(p.getValue().getForBaseModule());
1049 prop.setValue(p.getValue().getForNonBaseModule());
1050 prop.setDefaultValue(p.getValue().getForNonBaseModule());
1052 properties.add(prop);
1055 GroupProperty proplabel = new GroupProperty();
1056 proplabel.setName("vf_module_label");
1058 Matcher matcher = pattern.matcher(moduleName);
1060 if (matcher.find()) {
1061 proplabel.setValue(matcher.group(1));
1062 proplabel.setDefaultValue(matcher.group(1));
1064 proplabel.setValue(moduleName);
1065 proplabel.setDefaultValue(moduleName);
1067 properties.add(proplabel);
1069 GroupProperty propvolume = new GroupProperty();
1070 propvolume.setName("volume_group");
1071 boolean isVolume = false;
1072 for (String artifactId : artifactsInGroup) {
1073 ArtifactDefinition artifactDef = null;
1074 artifactDef = ArtifactUtils.findArtifactInList(deploymentArtifacts, artifactId);
1075 if (artifactDef != null
1076 && artifactDef.getArtifactType().equalsIgnoreCase(ArtifactTypeEnum.HEAT_VOL.getType())) {
1081 propvolume.setValue(String.valueOf(isVolume));
1082 propvolume.setDefaultValue(String.valueOf(isVolume));
1083 properties.add(propvolume);
1084 mergeWithGroupTypeProperties(properties, groupType.getProperties());
1088 private void mergeWithGroupTypeProperties(List<GroupProperty> properties,
1089 List<PropertyDefinition> groupTypeProperties) {
1091 Map<String, GroupProperty> propertiesMap = properties.stream()
1092 .collect(Collectors.toMap(PropertyDataDefinition::getName, p -> p));
1093 for (PropertyDefinition groupTypeProperty : groupTypeProperties) {
1094 if (!propertiesMap.containsKey(groupTypeProperty.getName())) {
1095 properties.add(new GroupProperty(groupTypeProperty));
1100 private Map<GroupDefinition, MergedArtifactInfo> mergeGroupInUpdateFlow(
1101 Map<GroupDefinition, Map<ArtifactDefinition, List<ArtifactDefinition>>> groupArtifact,
1102 Map<ArtifactTemplateInfo, Set<ArtifactTemplateInfo>> parsedGroup, Set<ArtifactDefinition> artifactsToDelete,
1103 Map<String, List<ArtifactDefinition>> groupToDelete, Set<ArtifactTemplateInfo> jsonMasterArtifacts,
1104 List<ArtifactDefinition> createdDeploymentArtifacts) {
1105 Map<GroupDefinition, MergedArtifactInfo> mergedgroup = new HashMap<>();
1106 for (Entry<GroupDefinition, Map<ArtifactDefinition, List<ArtifactDefinition>>> groupListEntry : groupArtifact
1108 Map<ArtifactDefinition, List<ArtifactDefinition>> createdArtifactMap = groupListEntry.getValue();
1109 boolean isNeedToDeleteGroup = true;
1110 List<ArtifactDefinition> listToDelete = null;
1111 for (ArtifactDefinition maserArtifact : createdArtifactMap.keySet()) {
1112 listToDelete = prepareArtifactsToDelete(parsedGroup, artifactsToDelete, createdDeploymentArtifacts, createdArtifactMap, maserArtifact);
1113 if (artifactsToDelete != null && !artifactsToDelete.isEmpty()) {
1114 GroupDefinition group = groupListEntry.getKey();
1115 deleteArtifacts(artifactsToDelete, group);
1119 for (ArtifactTemplateInfo jsonMasterArtifact : jsonMasterArtifacts) {
1120 isNeedToDeleteGroup = isNeedToDeleteGroup(mergedgroup, groupListEntry, createdArtifactMap, isNeedToDeleteGroup, maserArtifact, jsonMasterArtifact);
1124 if (isNeedToDeleteGroup) {
1125 groupToDelete.put(groupListEntry.getKey().getUniqueId(), listToDelete);
1132 private boolean isNeedToDeleteGroup(Map<GroupDefinition, MergedArtifactInfo> mergedgroup, Entry<GroupDefinition, Map<ArtifactDefinition, List<ArtifactDefinition>>> groupListEntry, Map<ArtifactDefinition, List<ArtifactDefinition>> createdArtifactMap, boolean isNeedToDeleteGroup, ArtifactDefinition maserArtifact, ArtifactTemplateInfo jsonMasterArtifact) {
1133 if (maserArtifact.getArtifactName().equalsIgnoreCase(jsonMasterArtifact.getFileName())) {
1134 MergedArtifactInfo mergedGroup = new MergedArtifactInfo();
1135 mergedGroup.setJsonArtifactTemplate(jsonMasterArtifact);
1136 mergedGroup.setCreatedArtifact(createdArtifactMap.get(maserArtifact));
1137 mergedgroup.put(groupListEntry.getKey(), mergedGroup);
1138 isNeedToDeleteGroup = false;
1141 return isNeedToDeleteGroup;
1144 private List<ArtifactDefinition> prepareArtifactsToDelete(Map<ArtifactTemplateInfo, Set<ArtifactTemplateInfo>> parsedGroup, Set<ArtifactDefinition> artifactsToDelete, List<ArtifactDefinition> createdDeploymentArtifacts, Map<ArtifactDefinition, List<ArtifactDefinition>> createdArtifactMap, ArtifactDefinition maserArtifact) {
1145 List<ArtifactDefinition> listToDelete;
1146 listToDelete = createdArtifactMap.get(maserArtifact);
1147 for (ArtifactDefinition artToDelete : listToDelete) {
1148 findArtifactToDelete(parsedGroup, artifactsToDelete, artToDelete, createdDeploymentArtifacts);
1150 return listToDelete;
1153 private void deleteArtifacts(Set<ArtifactDefinition> artifactsToDelete, GroupDefinition group) {
1154 for (ArtifactDefinition artifactDefinition : artifactsToDelete) {
1155 if (CollectionUtils.isNotEmpty(group.getArtifacts())
1156 && group.getArtifacts().contains(artifactDefinition.getUniqueId())) {
1157 group.getArtifacts().remove(artifactDefinition.getUniqueId());
1160 if (CollectionUtils.isNotEmpty(group.getArtifactsUuid())
1161 && group.getArtifactsUuid().contains(artifactDefinition.getArtifactUUID())) {
1162 group.getArtifactsUuid().remove(artifactDefinition.getArtifactUUID());
1168 private void findArtifactToDelete(Map<ArtifactTemplateInfo, Set<ArtifactTemplateInfo>> parsedGroup,
1169 Set<ArtifactDefinition> artifactsToDelete, ArtifactDefinition artifact,
1170 List<ArtifactDefinition> createdDeploymentArtifacts) {
1171 boolean isNeedToDeleteArtifact = true;
1172 String artifactType = artifact.getArtifactType();
1173 ArtifactDefinition generatedFromArt = null;
1174 if (artifact.getGeneratedFromId() != null && !artifact.getGeneratedFromId().isEmpty()) {
1175 Optional<ArtifactDefinition> op = createdDeploymentArtifacts.stream()
1176 .filter(p -> p.getUniqueId().equals(artifact.getGeneratedFromId())).findAny();
1177 if (op.isPresent()) {
1178 generatedFromArt = op.get();
1183 isNeedToDeleteArtifact(parsedGroup, artifactsToDelete, artifact, isNeedToDeleteArtifact, artifactType, generatedFromArt);
1186 private void isNeedToDeleteArtifact(Map<ArtifactTemplateInfo, Set<ArtifactTemplateInfo>> parsedGroup, Set<ArtifactDefinition>
1187 artifactsToDelete, ArtifactDefinition artifact, boolean isNeedToDeleteArtifact, String artifactType, ArtifactDefinition generatedFromArt) {
1189 for (Entry<ArtifactTemplateInfo, Set<ArtifactTemplateInfo>> parsedGroupSetEntry : parsedGroup.entrySet()) {
1190 Set<ArtifactTemplateInfo> artifactsNames = parsedGroupSetEntry.getValue();
1191 for (ArtifactTemplateInfo template : artifactsNames) {
1192 if (artifact.getArtifactName().equalsIgnoreCase(template.getFileName())
1193 && artifactType.equalsIgnoreCase(template.getType())) {
1194 isNeedToDeleteArtifact = false;
1199 if (generatedFromArt != null) {
1200 if (generatedFromArt.getArtifactName().equalsIgnoreCase(template.getFileName())
1201 && generatedFromArt.getArtifactType().equalsIgnoreCase(template.getType())) {
1202 isNeedToDeleteArtifact = false;
1210 if (isNeedToDeleteArtifact) {
1211 artifactsToDelete.add(artifact);
1216 private Map<GroupDefinition, Map<ArtifactDefinition, List<ArtifactDefinition>>> findMasterArtifactInGroup(
1217 List<GroupDefinition> groups, Map<String, ArtifactDefinition> deploymentArtifact) {
1218 Map<GroupDefinition, Map<ArtifactDefinition, List<ArtifactDefinition>>> groupArtifact = new HashMap<>();
1220 for (GroupDefinition group : groups) {
1221 Map<ArtifactDefinition, List<ArtifactDefinition>> gupsMap = new HashMap<>();
1222 List<ArtifactDefinition> artifacts = new ArrayList<>();
1223 List<String> artifactsList = group.getArtifacts();
1224 if (artifactsList != null && !artifactsList.isEmpty()) {
1226 ArtifactDefinition masterArtifact = ArtifactUtils.findMasterArtifact(deploymentArtifact, artifacts,
1228 if (masterArtifact != null) {
1229 gupsMap.put(masterArtifact, artifacts);
1231 groupArtifact.put(group, gupsMap);
1235 return groupArtifact;
1238 private Either<Resource, ResponseFormat> deleteArtifactsInUpdateCsarFlow(Resource resource,
1239 User user, boolean shouldLock, boolean inTransaction, Set<ArtifactDefinition> artifactsToDelete,
1240 Map<String, List<ArtifactDefinition>> groupToDelete, List<ArtifactDefinition> deletedArtifacts) {
1242 Resource updatedResource = resource;
1244 String resourceId = updatedResource.getUniqueId();
1245 if (!artifactsToDelete.isEmpty()) {
1246 for (ArtifactDefinition artifact : artifactsToDelete) {
1247 String artifactType = artifact.getArtifactType();
1248 final ArtifactTypeEnum artifactTypeEnum = ArtifactTypeEnum.parse(artifactType);
1249 if (artifactTypeEnum != ArtifactTypeEnum.HEAT_ENV) {
1250 Either<Either<ArtifactDefinition, Operation>, ResponseFormat> handleDelete = artifactsBusinessLogic
1251 .handleDelete(resourceId, artifact.getUniqueId(), user, AuditingActionEnum.ARTIFACT_DELETE,
1252 ComponentTypeEnum.RESOURCE, updatedResource, shouldLock, inTransaction);
1253 if (handleDelete.isRight()) {
1254 return Either.right(handleDelete.right().value());
1257 deletedArtifacts.add(handleDelete.left().value().left().value());
1262 if (!groupToDelete.isEmpty()) {
1263 log.debug("try to delete group");
1264 List<GroupDefinition> groupDefinitionstoDelete = new ArrayList<>();
1265 List<GroupDefinition> groups = updatedResource.getGroups();
1266 for (Entry<String, List<ArtifactDefinition>> deleteGroup : groupToDelete.entrySet()) {
1267 Optional<GroupDefinition> op = groups.stream()
1268 .filter(gr -> gr.getUniqueId().equals(deleteGroup.getKey())).findAny();
1269 if (op.isPresent()) {
1270 groupDefinitionstoDelete.add(op.get());
1274 if (!groupDefinitionstoDelete.isEmpty()) {
1275 Either<List<GroupDefinition>, ResponseFormat> prepareGroups = groupBusinessLogic.deleteGroups(resource, groupDefinitionstoDelete);
1276 if (prepareGroups.isRight()) {
1277 return Either.right(prepareGroups.right().value());
1281 List<GroupDefinition> oldGroups = updatedResource.getGroups();
1282 Either<Resource, StorageOperationStatus> eitherGerResource = toscaOperationFacade
1283 .getToscaElement(updatedResource.getUniqueId());
1284 if (eitherGerResource.isRight()) {
1285 ResponseFormat responseFormat = componentsUtils.getResponseFormatByResource(
1286 componentsUtils.convertFromStorageResponse(eitherGerResource.right().value()), updatedResource);
1288 return Either.right(responseFormat);
1291 updatedResource = eitherGerResource.left().value();
1292 updatedResource.setGroups(oldGroups);
1293 return Either.left(updatedResource);
1296 private void createArtifactsGroupSet(List<ArtifactTemplateInfo> parsedGroupTemplateList,
1297 Set<ArtifactTemplateInfo> parsedArtifactsName) {
1299 for (ArtifactTemplateInfo parsedGroupTemplate : parsedGroupTemplateList) {
1300 parsedArtifactsName.add(parsedGroupTemplate);
1301 List<ArtifactTemplateInfo> relatedArtifacts = parsedGroupTemplate.getRelatedArtifactsInfo();
1302 if (relatedArtifacts != null && !relatedArtifacts.isEmpty()) {
1303 createArtifactsGroupSet(relatedArtifacts, parsedArtifactsName);
1308 private Either<Resource, ResponseFormat> createGroupDeploymentArtifactsFromCsar(CsarInfo csarInfo,
1309 Resource resource, List<ArtifactTemplateInfo> artifactsTemplateList,
1310 List<ArtifactDefinition> createdNewArtifacts, List<ArtifactDefinition> artifactsFromResource,
1313 Resource updatedResource = resource;
1315 Either<Resource, ResponseFormat> resStatus = Either.left(updatedResource);
1316 List<GroupDefinition> createdGroups = updatedResource.getGroups();
1317 List<GroupDefinition> heatGroups = null;
1318 if (createdGroups != null && !createdGroups.isEmpty()) {
1319 heatGroups = collectGroupsWithMembers(createdGroups);
1322 List<GroupDefinition> needToAdd = new ArrayList<>();
1323 for (ArtifactTemplateInfo groupTemplateInfo : artifactsTemplateList) {
1324 String groupName = groupTemplateInfo.getGroupName();
1325 Set<String> artifactsGroup = new HashSet<>();
1326 Set<String> artifactsUUIDGroup = new HashSet<>();
1328 resStatus = createDeploymentArtifactsFromCsar(csarInfo, updatedResource, artifactsGroup, artifactsUUIDGroup,
1329 groupTemplateInfo, createdNewArtifacts, artifactsFromResource, labelCounter);
1330 if (resStatus.isRight()) {
1333 if (!StringUtils.isEmpty(groupName)) {
1334 Map<String, String> members = new HashMap<>();
1335 associateMembersToArtifacts(createdNewArtifacts, artifactsFromResource, heatGroups, artifactsGroup,
1338 List<String> artifactsList = new ArrayList<>(artifactsGroup);
1339 List<String> artifactsUUIDList = new ArrayList<>(artifactsUUIDGroup);
1341 GroupDefinition groupDefinition = new GroupDefinition();
1342 groupDefinition.setName(groupName);
1343 groupDefinition.setType(Constants.DEFAULT_GROUP_VF_MODULE);
1344 groupDefinition.setArtifacts(artifactsList);
1345 groupDefinition.setArtifactsUuid(artifactsUUIDList);
1347 if (!members.isEmpty()) {
1348 groupDefinition.setMembers(members);
1351 List<GroupProperty> properties = new ArrayList<>();
1352 GroupProperty prop = new GroupProperty();
1353 prop.setName(Constants.IS_BASE);
1354 prop.setValue(Boolean.toString(groupTemplateInfo.isBase()));
1355 properties.add(prop);
1357 List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
1358 createdArtifacts.addAll(createdNewArtifacts);
1359 createdArtifacts.addAll(artifactsFromResource);
1360 Either<GroupTypeDefinition, StorageOperationStatus> getLatestGroupTypeRes = groupTypeOperation
1361 .getLatestGroupTypeByType(Constants.DEFAULT_GROUP_VF_MODULE, true);
1362 if (getLatestGroupTypeRes.isRight()) {
1363 return Either.right(componentsUtils.getResponseFormat(
1364 componentsUtils.convertFromStorageResponse(getLatestGroupTypeRes.right().value())));
1366 properties = createVfModuleAdditionalProperties(groupTemplateInfo.isBase(), groupName, properties,
1367 createdArtifacts, artifactsList, getLatestGroupTypeRes.left().value());
1368 groupDefinition.convertFromGroupProperties(properties);
1370 needToAdd.add(groupDefinition);
1373 ComponentParametersView componentParametersView = new ComponentParametersView();
1374 componentParametersView.disableAll();
1375 componentParametersView.setIgnoreArtifacts(false);
1376 componentParametersView.setIgnoreGroups(false);
1377 componentParametersView.setIgnoreComponentInstances(false);
1379 Either<Resource, StorageOperationStatus> component = toscaOperationFacade
1380 .getToscaElement(updatedResource.getUniqueId(), componentParametersView);
1381 if (component.isRight()) {
1382 return Either.right(componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR));
1384 updatedResource = component.left().value();
1386 Either<List<GroupDefinition>, ResponseFormat> addGroups = groupBusinessLogic.addGroups(updatedResource, needToAdd, false);
1387 if (addGroups.isRight()) {
1388 return Either.right(addGroups.right().value());
1394 private Either<Resource, ResponseFormat> createDeploymentArtifactsFromCsar(CsarInfo csarInfo, Resource resource,
1395 Set<String> artifactsGroup, Set<String> artifactsUUIDGroup, ArtifactTemplateInfo artifactTemplateInfo,
1396 List<ArtifactDefinition> createdArtifacts, List<ArtifactDefinition> artifactsFromResource, int labelCounter) {
1397 Either<Resource, ResponseFormat> resStatus = Either.left(resource);
1398 String artifactFileName = artifactTemplateInfo.getFileName();
1399 String artifactUid = "";
1400 String artifactUUID = "";
1401 String artifactEnvUid = "";
1402 boolean alreadyExist = false;
1404 // check if artifacts already exist
1405 if (artifactsFromResource != null && !artifactsFromResource.isEmpty()) {
1406 for (ArtifactDefinition artifactFromResource : artifactsFromResource) {
1407 if (artifactFromResource.getArtifactName().equals(artifactFileName)) {
1408 artifactUid = artifactFromResource.getUniqueId();
1409 artifactUUID = artifactFromResource.getArtifactUUID();
1410 if (!artifactFromResource.getArtifactType().equalsIgnoreCase(artifactTemplateInfo.getType())) {
1411 log.debug(ARTIFACT_WITH_NAME_AND_TYPE_ALREADY_EXIST_WITH_TYPE, artifactFileName,
1412 artifactTemplateInfo.getType(), artifactFromResource.getArtifactType());
1413 BeEcompErrorManager.getInstance().logInternalDataError(
1414 ARTIFACT_FILE_IS_NOT_IN_EXPECTED_FORMAT_FILE_NAME + artifactFileName,
1415 ARTIFACT_INTERNALS_ARE_INVALID, ErrorSeverity.ERROR);
1416 return Either.right(componentsUtils.getResponseFormat(
1417 ActionStatus.ARTIFACT_ALREADY_EXIST_IN_DIFFERENT_TYPE_IN_CSAR, artifactFileName,
1418 artifactTemplateInfo.getType(), artifactFromResource.getArtifactType()));
1420 alreadyExist = true;
1421 artifactEnvUid = checkAndGetHeatEnvId(artifactFromResource);
1428 if (!alreadyExist) {
1429 for (ArtifactDefinition createdArtifact : createdArtifacts) {
1430 if (createdArtifact.getArtifactName().equals(artifactFileName)) {
1431 artifactUid = createdArtifact.getUniqueId();
1432 artifactUUID = createdArtifact.getArtifactUUID();
1434 if (!createdArtifact.getArtifactType().equalsIgnoreCase(artifactTemplateInfo.getType())) {
1435 log.debug(ARTIFACT_WITH_NAME_AND_TYPE_ALREADY_EXIST_WITH_TYPE, artifactFileName,
1436 artifactTemplateInfo.getType(), createdArtifact.getArtifactType());
1437 BeEcompErrorManager.getInstance().logInternalDataError(
1438 ARTIFACT_FILE_IS_NOT_IN_EXPECTED_FORMAT_FILE_NAME + artifactFileName,
1439 ARTIFACT_INTERNALS_ARE_INVALID, ErrorSeverity.ERROR);
1440 return Either.right(componentsUtils.getResponseFormat(
1441 ActionStatus.ARTIFACT_ALREADY_EXIST_IN_DIFFERENT_TYPE_IN_CSAR, artifactFileName,
1442 artifactTemplateInfo.getType(), createdArtifact.getArtifactType()));
1444 alreadyExist = true;
1445 artifactEnvUid = checkAndGetHeatEnvId(createdArtifact);
1451 // if not exist need to create
1452 if (!alreadyExist) {
1454 Either<ArtifactDefinition, ResponseFormat> newArtifactEither = createDeploymentArtifact(csarInfo, resource,
1455 ARTIFACTS_PATH, artifactTemplateInfo, createdArtifacts, labelCounter);
1456 if (newArtifactEither.isRight()) {
1457 resStatus = Either.right(newArtifactEither.right().value());
1460 ArtifactDefinition newArtifact = newArtifactEither.left().value();
1461 artifactUid = newArtifact.getUniqueId();
1462 artifactUUID = newArtifact.getArtifactUUID();
1463 final ArtifactTypeEnum artifactType = ArtifactTypeEnum.parse(newArtifact.getArtifactType());
1464 if (artifactType == ArtifactTypeEnum.HEAT || artifactType == ArtifactTypeEnum.HEAT_NET
1465 || artifactType == ArtifactTypeEnum.HEAT_VOL) {
1466 ArtifactDefinition createHeatEnvPlaceHolder = artifactsBusinessLogic
1467 .createHeatEnvPlaceHolder(createdArtifacts, newArtifact, ArtifactsBusinessLogic.HEAT_VF_ENV_NAME,
1468 resource.getUniqueId(), NodeTypeEnum.Resource, resource.getName(),
1469 csarInfo.getModifier(), resource, null);
1470 artifactEnvUid = createHeatEnvPlaceHolder.getUniqueId();
1474 artifactsGroup.add(artifactUid);
1475 artifactsUUIDGroup.add(artifactUUID);
1476 if (!artifactEnvUid.isEmpty()) {
1477 artifactsGroup.add(artifactEnvUid);
1480 List<ArtifactTemplateInfo> relatedArtifacts = artifactTemplateInfo.getRelatedArtifactsInfo();
1481 if (relatedArtifacts != null) {
1482 for (ArtifactTemplateInfo relatedArtifactTemplateInfo : relatedArtifacts) {
1483 resStatus = createDeploymentArtifactsFromCsar(csarInfo, resource, artifactsGroup, artifactsUUIDGroup,
1484 relatedArtifactTemplateInfo, createdArtifacts, artifactsFromResource, labelCounter);
1485 if (resStatus.isRight()) {
1493 private Either<Resource, ResponseFormat> associateAndDissociateArtifactsToGroup(CsarInfo csarInfo,
1494 Resource resource, List<ArtifactDefinition> createdNewArtifacts, int labelCounter,
1495 List<ArtifactDefinition> createdDeploymentArtifactsAfterDelete,
1496 Map<GroupDefinition, MergedArtifactInfo> mergedgroup, List<ArtifactDefinition> deletedArtifacts) {
1497 Map<GroupDefinition, List<ArtifactTemplateInfo>> artifactsToAssotiate = new HashMap<>();
1498 Map<GroupDefinition, List<ImmutablePair<ArtifactDefinition, ArtifactTemplateInfo>>> artifactsToUpdateMap = new HashMap<>();
1499 Either<Resource, ResponseFormat> resEither;
1500 for (Entry<GroupDefinition, MergedArtifactInfo> entry : mergedgroup.entrySet()) {
1501 List<ArtifactDefinition> dissArtifactsInGroup = entry.getValue()
1502 .getListToDissotiateArtifactFromGroup(deletedArtifacts);
1503 GroupDefinition grDef = entry.getKey();
1504 if (dissArtifactsInGroup != null && !dissArtifactsInGroup.isEmpty()) {
1505 for (ArtifactDefinition art : dissArtifactsInGroup) {
1506 grDef.getArtifacts().remove(art.getUniqueId());
1507 grDef.getArtifactsUuid().remove(art.getArtifactUUID());
1511 List<ArtifactTemplateInfo> newArtifactsInGroup = entry.getValue().getListToAssociateArtifactToGroup();
1512 if (newArtifactsInGroup != null && !newArtifactsInGroup.isEmpty()) {
1513 artifactsToAssotiate.put(entry.getKey(), newArtifactsInGroup);
1516 List<ImmutablePair<ArtifactDefinition, ArtifactTemplateInfo>> artifactsToUpdate = entry.getValue()
1517 .getListToUpdateArtifactInGroup();
1518 if (artifactsToUpdate != null && !artifactsToUpdate.isEmpty()) {
1519 artifactsToUpdateMap.put(entry.getKey(), artifactsToUpdate);
1523 if (!artifactsToUpdateMap.isEmpty()) {
1524 List<ArtifactDefinition> updatedArtifacts = new ArrayList<>();
1525 for (Entry<GroupDefinition, List<ImmutablePair<ArtifactDefinition, ArtifactTemplateInfo>>> artifactsToUpdateEntry : artifactsToUpdateMap
1527 List<ImmutablePair<ArtifactDefinition, ArtifactTemplateInfo>> artifactsToUpdateList = artifactsToUpdateEntry
1529 GroupDefinition groupToUpdate = artifactsToUpdateEntry.getKey();
1531 for (ImmutablePair<ArtifactDefinition, ArtifactTemplateInfo> artifact : artifactsToUpdateList) {
1532 String prevUUID = artifact.getKey().getArtifactUUID();
1533 String prevId = artifact.getKey().getUniqueId();
1534 String prevHeatEnvId = checkAndGetHeatEnvId(artifact.getKey());
1535 Either<ArtifactDefinition, ResponseFormat> updateArtifactEither = updateDeploymentArtifactsFromCsar(
1536 csarInfo, resource, artifact.getKey(), artifact.getValue(), updatedArtifacts,
1537 artifact.getRight().getRelatedArtifactsInfo());
1538 if (updateArtifactEither.isRight()) {
1539 log.debug("failed to update artifacts. status is {}", updateArtifactEither.right().value());
1540 resEither = Either.right(updateArtifactEither.right().value());
1543 ArtifactDefinition artAfterUpdate = updateArtifactEither.left().value();
1544 if (!prevUUID.equals(artAfterUpdate.getArtifactUUID())
1545 || !prevId.equals(artAfterUpdate.getUniqueId())) {
1546 groupToUpdate.getArtifacts().remove(prevId);
1547 groupToUpdate.getArtifactsUuid().remove(prevUUID);
1548 groupToUpdate.getArtifacts().add(artAfterUpdate.getUniqueId());
1549 groupToUpdate.getArtifactsUuid().add(artAfterUpdate.getArtifactUUID());
1551 Optional<ArtifactDefinition> op = updatedArtifacts.stream()
1552 .filter(p -> p.getGeneratedFromId() != null
1553 && p.getGeneratedFromId().equals(artAfterUpdate.getUniqueId()))
1555 if (op.isPresent()) {
1556 ArtifactDefinition artifactInfoHeatEnv = op.get();
1557 groupToUpdate.getArtifacts().remove(prevHeatEnvId);
1558 groupToUpdate.getArtifacts().add(artifactInfoHeatEnv.getUniqueId());
1565 for (Entry<GroupDefinition, List<ArtifactTemplateInfo>> associateEntry : artifactsToAssotiate.entrySet()) {
1566 List<ArtifactTemplateInfo> associatedArtifact = associateEntry.getValue();
1567 Set<String> arifactsUids = new HashSet<>();
1568 Set<String> arifactsUuids = new HashSet<>();
1569 for (ArtifactTemplateInfo artifactTemplate : associatedArtifact) { // try
1575 boolean isCreate = true;
1576 for (ArtifactDefinition createdArtifact : createdDeploymentArtifactsAfterDelete) {
1577 if (artifactTemplate.getFileName().equalsIgnoreCase(createdArtifact.getArtifactName())) {
1578 arifactsUids.add(createdArtifact.getUniqueId());
1579 arifactsUuids.add(createdArtifact.getArtifactUUID());
1581 String heatEnvId = checkAndGetHeatEnvId(createdArtifact);
1582 if (!heatEnvId.isEmpty()) {
1583 arifactsUids.add(heatEnvId);
1584 Optional<ArtifactDefinition> op = createdDeploymentArtifactsAfterDelete.stream()
1585 .filter(p -> p.getUniqueId().equals(heatEnvId)).findAny();
1586 if (op.isPresent()) {
1587 this.artifactToscaOperation.updateHeatEnvPlaceholder(op.get(), resource,
1588 resource.getComponentType().getNodeType());
1597 if (isCreate) { // check if already created
1598 for (ArtifactDefinition createdNewArtifact : createdNewArtifacts) {
1599 if (artifactTemplate.getFileName().equalsIgnoreCase(createdNewArtifact.getArtifactName())) {
1600 arifactsUids.add(createdNewArtifact.getUniqueId());
1601 arifactsUuids.add(createdNewArtifact.getArtifactUUID());
1603 String heatEnvId = checkAndGetHeatEnvId(createdNewArtifact);
1604 if (!heatEnvId.isEmpty()) {
1605 arifactsUids.add(heatEnvId);
1613 Either<ArtifactDefinition, ResponseFormat> createArtifactEither = createDeploymentArtifact(csarInfo,
1614 resource, ARTIFACTS_PATH, artifactTemplate, createdNewArtifacts, labelCounter);
1615 if (createArtifactEither.isRight()) {
1616 resEither = Either.right(createArtifactEither.right().value());
1619 ArtifactDefinition createdArtifact = createArtifactEither.left().value();
1620 arifactsUids.add(createdArtifact.getUniqueId());
1621 arifactsUuids.add(createdArtifact.getArtifactUUID());
1622 final ArtifactTypeEnum artifactType = ArtifactTypeEnum.parse(createdArtifact.getArtifactType());
1623 if (artifactType == ArtifactTypeEnum.HEAT || artifactType == ArtifactTypeEnum.HEAT_NET
1624 || artifactType == ArtifactTypeEnum.HEAT_VOL) {
1625 ArtifactDefinition createHeatEnvPlaceHolder = artifactsBusinessLogic
1626 .createHeatEnvPlaceHolder(new ArrayList<>(), createdArtifact, ArtifactsBusinessLogic.HEAT_VF_ENV_NAME,
1627 resource.getUniqueId(), NodeTypeEnum.Resource, resource.getName(),
1628 csarInfo.getModifier(), resource, null);
1629 String heatEnvId = createHeatEnvPlaceHolder.getUniqueId();
1630 arifactsUids.add(heatEnvId);
1635 if (arifactsUids != null && !arifactsUids.isEmpty()) {
1636 List<String> artifactsToAssociate = new ArrayList<>();
1637 artifactsToAssociate.addAll(arifactsUids);
1638 GroupDefinition assotiateGroup = associateEntry.getKey();
1639 assotiateGroup.getArtifacts().addAll(arifactsUids);
1640 assotiateGroup.getArtifactsUuid().addAll(arifactsUuids);
1644 ComponentParametersView parametersView = new ComponentParametersView();
1645 parametersView.disableAll();
1646 parametersView.setIgnoreComponentInstances(false);
1647 parametersView.setIgnoreUsers(false);
1648 parametersView.setIgnoreArtifacts(false);
1649 parametersView.setIgnoreGroups(false);
1651 Either<Resource, StorageOperationStatus> eitherGerResource = toscaOperationFacade
1652 .getToscaElement(resource.getUniqueId(), parametersView);
1654 if (eitherGerResource.isRight()) {
1655 ResponseFormat responseFormat = componentsUtils.getResponseFormatByResource(
1656 componentsUtils.convertFromStorageResponse(eitherGerResource.right().value()), resource);
1658 resEither = Either.right(responseFormat);
1662 resEither = Either.left(eitherGerResource.left().value());
1666 private Either<ArtifactDefinition, ResponseFormat> updateDeploymentArtifactsFromCsar(CsarInfo csarInfo,
1667 Resource resource, ArtifactDefinition oldArtifact, ArtifactTemplateInfo artifactTemplateInfo,
1668 List<ArtifactDefinition> updatedArtifacts, List<ArtifactTemplateInfo> updatedRequiredArtifacts) {
1670 Either<ArtifactDefinition, ResponseFormat> resStatus = null;
1671 String artifactFileName = artifactTemplateInfo.getFileName();
1673 // check if artifacts already exist
1674 for (ArtifactDefinition updatedArtifact : updatedArtifacts) {
1675 if (updatedArtifact.getArtifactName().equals(artifactFileName)) {
1676 if (!updatedArtifact.getArtifactType().equalsIgnoreCase(artifactTemplateInfo.getType())) {
1677 log.debug("Artifact with name {} and type {} already updated with type {}", artifactFileName,
1678 artifactTemplateInfo.getType(), updatedArtifact.getArtifactType());
1679 BeEcompErrorManager.getInstance().logInternalDataError(
1680 ARTIFACT_FILE_IS_NOT_IN_EXPECTED_FORMAT_FILE_NAME + artifactFileName,
1681 ARTIFACT_INTERNALS_ARE_INVALID, ErrorSeverity.ERROR);
1682 resStatus = Either.right(componentsUtils.getResponseFormat(
1683 ActionStatus.ARTIFACT_ALREADY_EXIST_IN_DIFFERENT_TYPE_IN_CSAR, artifactFileName,
1684 artifactTemplateInfo.getType(), updatedArtifact.getArtifactType()));
1687 resStatus = Either.left(updatedArtifact);
1693 Either<ImmutablePair<String, byte[]>, ResponseFormat> artifactContententStatus = CsarValidationUtils
1694 .getArtifactContent(csarInfo.getCsarUUID(), csarInfo.getCsar(),
1695 CsarUtils.ARTIFACTS_PATH + artifactFileName, artifactFileName, componentsUtils);
1696 if (artifactContententStatus.isRight()) {
1697 resStatus = Either.right(artifactContententStatus.right().value());
1701 Map<String, Object> json = ArtifactUtils.buildJsonForUpdateArtifact(oldArtifact.getUniqueId(), artifactFileName,
1702 oldArtifact.getArtifactType(), ArtifactGroupTypeEnum.DEPLOYMENT, oldArtifact.getArtifactLabel(),
1703 oldArtifact.getArtifactDisplayName(), oldArtifact.getDescription(),
1704 artifactContententStatus.left().value().getRight(), updatedRequiredArtifacts, oldArtifact.getIsFromCsar());
1706 Either<Either<ArtifactDefinition, Operation>, ResponseFormat> uploadArtifactToService = createOrUpdateCsarArtifactFromJson(
1707 resource, csarInfo.getModifier(), json,
1708 artifactsBusinessLogic.new ArtifactOperationInfo(false, false, ArtifactOperationEnum.UPDATE));
1710 if (uploadArtifactToService.isRight()) {
1711 resStatus = Either.right(uploadArtifactToService.right().value());
1714 ArtifactDefinition previousInfo = uploadArtifactToService.left().value().left().value();
1715 ArtifactDefinition currentInfo = uploadArtifactToService.left().value().left().value();
1716 updatedArtifacts.add(currentInfo);
1718 Either<ArtifactDefinition, ResponseFormat> updateEnvEither = updateHeatParamsFromCsar(resource, csarInfo,
1719 artifactTemplateInfo, currentInfo, true);
1721 if (updateEnvEither.isRight()) {
1722 log.debug("failed to update parameters to artifact {}", artifactFileName);
1723 resStatus = Either.right(updateEnvEither.right().value());
1727 artifactsBusinessLogic.updateGroupForHeat(previousInfo, updateEnvEither.left().value(), resource);
1729 updatedArtifacts.add(updateEnvEither.left().value());
1730 resStatus = Either.left(currentInfo);
1734 public Either<Resource, ResponseFormat> deleteVFModules(Resource resource, CsarInfo csarInfo, boolean shouldLock, boolean inTransaction) {
1735 Resource updatedResource = resource;
1736 List<GroupDefinition> groupsToDelete = updatedResource.getGroups();
1737 if(groupsToDelete != null && !groupsToDelete.isEmpty()){
1738 List<GroupDefinition> vfGroupsToDelete = groupsToDelete.stream().filter(g -> g.getType().equals(Constants.DEFAULT_GROUP_VF_MODULE)).collect(Collectors.toList());
1739 if(!vfGroupsToDelete.isEmpty()){
1740 for(GroupDefinition gr : vfGroupsToDelete){
1741 List<String> artifacts = gr.getArtifacts();
1742 for (String artifactId : artifacts) {
1743 Either<Either<ArtifactDefinition, Operation>, ResponseFormat> handleDelete = artifactsBusinessLogic.handleDelete(updatedResource.getUniqueId(), artifactId, csarInfo.getModifier(), AuditingActionEnum.ARTIFACT_DELETE, ComponentTypeEnum.RESOURCE,
1744 updatedResource, shouldLock, inTransaction);
1745 if (handleDelete.isRight()) {
1746 log.debug("Couldn't delete artifact {}", artifactId);
1747 return Either.right(handleDelete.right().value());
1752 groupBusinessLogic.deleteGroups(updatedResource, vfGroupsToDelete);
1754 Either<Resource, StorageOperationStatus> eitherGetResource = toscaOperationFacade.getToscaElement(updatedResource.getUniqueId());
1755 if (eitherGetResource.isRight()) {
1756 ResponseFormat responseFormat = componentsUtils.getResponseFormatByResource(componentsUtils.convertFromStorageResponse(eitherGetResource.right().value()), updatedResource);
1758 return Either.right(responseFormat);
1761 updatedResource = eitherGetResource.left().value();
1764 return Either.left(updatedResource);
1767 private Either<Resource, ResponseFormat> getResourcetFromGraph(Resource component){
1768 log.debug("getResource start");
1769 return toscaOperationFacade.getToscaElement(component.getUniqueId())
1771 .map(rf -> componentsUtils.getResponseFormatByResource(componentsUtils.convertFromStorageResponse(rf), component))
1773 .map (c -> (Resource) c);