aboutsummaryrefslogtreecommitdiffstats
path: root/catalog-be/src/main/java/org/openecomp/sdc/be/components/csar/CsarArtifactsAndGroupsBusinessLogic.java
diff options
context:
space:
mode:
Diffstat (limited to 'catalog-be/src/main/java/org/openecomp/sdc/be/components/csar/CsarArtifactsAndGroupsBusinessLogic.java')
-rw-r--r--catalog-be/src/main/java/org/openecomp/sdc/be/components/csar/CsarArtifactsAndGroupsBusinessLogic.java1681
1 files changed, 1681 insertions, 0 deletions
diff --git a/catalog-be/src/main/java/org/openecomp/sdc/be/components/csar/CsarArtifactsAndGroupsBusinessLogic.java b/catalog-be/src/main/java/org/openecomp/sdc/be/components/csar/CsarArtifactsAndGroupsBusinessLogic.java
new file mode 100644
index 0000000000..0ee2dabf08
--- /dev/null
+++ b/catalog-be/src/main/java/org/openecomp/sdc/be/components/csar/CsarArtifactsAndGroupsBusinessLogic.java
@@ -0,0 +1,1681 @@
+package org.openecomp.sdc.be.components.csar;
+
+import com.google.gson.Gson;
+import com.google.gson.JsonElement;
+import com.google.gson.JsonObject;
+import fj.data.Either;
+import org.apache.commons.codec.binary.Base64;
+import org.apache.commons.collections.CollectionUtils;
+import org.apache.commons.lang3.tuple.ImmutablePair;
+import org.openecomp.sdc.be.components.impl.ArtifactsBusinessLogic;
+import org.openecomp.sdc.be.components.impl.ArtifactsBusinessLogic.ArtifactOperationEnum;
+import org.openecomp.sdc.be.components.impl.ArtifactsBusinessLogic.ArtifactOperationInfo;
+import org.openecomp.sdc.be.components.impl.BaseBusinessLogic;
+import org.openecomp.sdc.be.components.impl.CsarValidationUtils;
+import org.openecomp.sdc.be.components.impl.ImportUtils;
+import org.openecomp.sdc.be.components.impl.ImportUtils.ResultStatusEnum;
+import org.openecomp.sdc.be.config.BeEcompErrorManager;
+import org.openecomp.sdc.be.config.BeEcompErrorManager.ErrorSeverity;
+import org.openecomp.sdc.be.config.Configuration.VfModuleProperty;
+import org.openecomp.sdc.be.config.ConfigurationManager;
+import org.openecomp.sdc.be.dao.api.ActionStatus;
+import org.openecomp.sdc.be.datamodel.utils.ArtifactUtils;
+import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
+import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
+import org.openecomp.sdc.be.impl.ComponentsUtils;
+import org.openecomp.sdc.be.info.ArtifactTemplateInfo;
+import org.openecomp.sdc.be.info.MergedArtifactInfo;
+import org.openecomp.sdc.be.model.*;
+import org.openecomp.sdc.be.model.heat.HeatParameterType;
+import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
+import org.openecomp.sdc.be.resources.data.auditing.AuditingActionEnum;
+import org.openecomp.sdc.be.servlets.RepresentationUtils;
+import org.openecomp.sdc.be.tosca.CsarUtils;
+import org.openecomp.sdc.common.api.ArtifactGroupTypeEnum;
+import org.openecomp.sdc.common.api.ArtifactTypeEnum;
+import org.openecomp.sdc.common.api.Constants;
+import org.openecomp.sdc.common.util.GeneralUtility;
+import org.openecomp.sdc.exception.ResponseFormat;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Optional;
+import java.util.Set;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+import java.util.stream.Collectors;
+
+import static org.openecomp.sdc.be.tosca.CsarUtils.ARTIFACTS_PATH;
+
+
+@org.springframework.stereotype.Component("csarArtifactsAndGroupsBusinessLogic")
+public class CsarArtifactsAndGroupsBusinessLogic extends BaseBusinessLogic {
+
+ private static final Logger log = LoggerFactory.getLogger(CsarArtifactsAndGroupsBusinessLogic.class);
+ private final Gson gson = new Gson();
+ private static final Pattern pattern = Pattern.compile("\\..(.*?)\\..");
+ @Autowired
+ protected ArtifactsBusinessLogic artifactsBusinessLogic;
+
+ public Either<Resource, ResponseFormat> createResourceArtifactsFromCsar(CsarInfo csarInfo, Resource resource,
+ String artifactsMetaFile, String artifactsMetaFileName, List<ArtifactDefinition> createdArtifacts,
+ boolean shouldLock, boolean inTransaction) {
+
+ log.debug("parseResourceArtifactsInfoFromFile start");
+ return parseResourceArtifactsInfoFromFile(resource, artifactsMetaFile, artifactsMetaFileName, csarInfo.getModifier())
+ .left()
+ .bind( p-> createResourceArtifacts(csarInfo, resource, p, createdArtifacts,shouldLock, inTransaction))
+ .right()
+ .map(rf -> { componentsUtils.auditResource(rf, csarInfo.getModifier(), resource, AuditingActionEnum.IMPORT_RESOURCE); return rf;})
+ .left()
+ .bind( c -> getResourcetFromGraph(c));
+ }
+
+
+ public Either<Resource, ResponseFormat> updateResourceArtifactsFromCsar(CsarInfo csarInfo, Resource resource,
+ String artifactsMetaFile, String artifactsMetaFileName, List<ArtifactDefinition> createdNewArtifacts,
+ boolean shouldLock, boolean inTransaction){
+
+ Resource updatedResource = resource;
+
+ Either<Map<String, List<ArtifactTemplateInfo>>, ResponseFormat> parseResourceInfoFromYamlEither = parseResourceArtifactsInfoFromFile(
+ updatedResource, artifactsMetaFile, artifactsMetaFileName, csarInfo.getModifier());
+ if (parseResourceInfoFromYamlEither.isRight()) {
+ ResponseFormat responseFormat = parseResourceInfoFromYamlEither.right().value();
+ componentsUtils.auditResource(responseFormat, csarInfo.getModifier(), resource, AuditingActionEnum.IMPORT_RESOURCE);
+ return Either.right(responseFormat);
+ }
+
+ List<GroupDefinition> groups = updatedResource.getGroups();
+ Map<String, ArtifactDefinition> deplymentArtifact = updatedResource.getDeploymentArtifacts();
+ if (deplymentArtifact == null || deplymentArtifact.isEmpty()) {
+ if(groups != null){
+ List<GroupDefinition> listToDelete = groups.stream().filter(g -> g.getType().equals(Constants.DEFAULT_GROUP_VF_MODULE)).collect(Collectors.toList());
+ groupBusinessLogic.deleteGroups(updatedResource, listToDelete);
+ }
+ return createResourceArtifacts(csarInfo, updatedResource, parseResourceInfoFromYamlEither.left().value(),
+ createdNewArtifacts, shouldLock, inTransaction);
+ }
+
+ List<ArtifactDefinition> createdDeplymentArtifactsAfterDelete = deplymentArtifact.values().stream().collect(Collectors.toList());
+
+ int labelCounter = createdDeplymentArtifactsAfterDelete.size();
+
+
+ ////////////////////////////////////// create set parsed
+ ////////////////////////////////////// artifacts///////////////////////////////////////////
+ Map<String, List<ArtifactTemplateInfo>> parsedArtifactsMap = parseResourceInfoFromYamlEither.left().value();
+
+
+ List<ArtifactTemplateInfo> artifactsWithoutGroups = null;
+ if (parsedArtifactsMap.containsKey(ArtifactTemplateInfo.CSAR_ARTIFACT)) {
+ artifactsWithoutGroups = parsedArtifactsMap.get(ArtifactTemplateInfo.CSAR_ARTIFACT);
+ parsedArtifactsMap.remove(ArtifactTemplateInfo.CSAR_ARTIFACT);
+ }
+ Collection<List<ArtifactTemplateInfo>> parsedArifactsCollection = parsedArtifactsMap.values();
+
+ Either<Map<ArtifactTemplateInfo, Set<ArtifactTemplateInfo>>, ResponseFormat> parsedArtifactsPerGroupEither = createArtifactsTemplateCollection(csarInfo, updatedResource, createdNewArtifacts, shouldLock, inTransaction,
+ createdDeplymentArtifactsAfterDelete, labelCounter, parsedArifactsCollection);
+ if(parsedArtifactsPerGroupEither.isRight()){
+ log.error("Failed to parse artifacts. Status is {} ", parsedArtifactsPerGroupEither.right().value());
+ return Either.right(parsedArtifactsPerGroupEither.right().value());
+ }
+
+ Map<ArtifactTemplateInfo, Set<ArtifactTemplateInfo>> parsedGroup = parsedArtifactsPerGroupEither.left().value();
+
+ // find master in group
+ Map<GroupDefinition, Map<ArtifactDefinition, List<ArtifactDefinition>>> groupArtifact = findMasterArtifactInGroup(
+ groups, deplymentArtifact);
+
+ ///////////////////////////////// find artifacts to
+ ///////////////////////////////// delete////////////////////////////////////////////////////
+
+
+ Map<String, List<ArtifactDefinition>> groupToDelete = new HashMap<>();
+ Set<ArtifactDefinition> artifactsToDelete = findArtifactThatNotInGroupToDelete(parsedGroup, createdDeplymentArtifactsAfterDelete);
+
+ Set<ArtifactTemplateInfo> jsonMasterArtifacts = parsedGroup.keySet();
+ Map<GroupDefinition, MergedArtifactInfo> mergedgroup = mergeGroupInUpdateFlow(groupArtifact, parsedGroup,
+ artifactsToDelete, groupToDelete, jsonMasterArtifacts, createdDeplymentArtifactsAfterDelete);
+
+ List<ArtifactDefinition> deletedArtifacts = new ArrayList<>();;
+ Either<Resource, ResponseFormat> deletedArtifactsEither = deleteArtifactsInUpdateCsarFlow(
+ updatedResource, csarInfo.getModifier(), shouldLock, inTransaction, artifactsToDelete, groupToDelete, deletedArtifacts);
+ if (deletedArtifactsEither.isRight()) {
+ log.debug("Failed to delete artifacts. Status is {} ", deletedArtifactsEither.right().value());
+
+ return Either.right(deletedArtifactsEither.right().value());
+
+ }
+ updatedResource = deletedArtifactsEither.left().value();
+
+ // need to update resource if we updated artifacts
+ if (!deletedArtifacts.isEmpty()) {
+ for (ArtifactDefinition deletedArtifact : deletedArtifacts) {
+ ArtifactDefinition artToRemove = null;
+ for (ArtifactDefinition artFromResource : createdDeplymentArtifactsAfterDelete) {
+ if (deletedArtifact.getUniqueId().equalsIgnoreCase(artFromResource.getUniqueId())) {
+ artToRemove = artFromResource;
+ break;
+ }
+ }
+ if (artToRemove != null) {
+ createdDeplymentArtifactsAfterDelete.remove(artToRemove);
+ }
+
+ }
+ }
+
+ ////////////// dissociate, associate or create
+ ////////////// artifacts////////////////////////////
+ Either<Resource, ResponseFormat> assDissotiateEither = associateAndDissociateArtifactsToGroup(csarInfo,
+ updatedResource, createdNewArtifacts, labelCounter, shouldLock, inTransaction,
+ createdDeplymentArtifactsAfterDelete, mergedgroup, deletedArtifacts);
+ groups = updatedResource.getGroups();
+ if (assDissotiateEither.isRight()) {
+ log.debug("Failed to delete artifacts. Status is {} ", assDissotiateEither.right().value());
+
+ return Either.right(assDissotiateEither.right().value());
+
+ }
+ updatedResource = assDissotiateEither.left().value();
+ deplymentArtifact = updatedResource.getDeploymentArtifacts();
+ createdDeplymentArtifactsAfterDelete.clear();
+ if (deplymentArtifact != null && !deplymentArtifact.isEmpty()) {
+ for (Entry<String, ArtifactDefinition> entry : deplymentArtifact.entrySet()) {
+ createdDeplymentArtifactsAfterDelete.add(entry.getValue());
+ }
+ }
+
+ // update vfModule names
+ Set<GroupDefinition> groupForAssociateWithMembers = mergedgroup.keySet();
+ if (groups != null && !groups.isEmpty()) {
+ Either<List<GroupDefinition>, ResponseFormat> validateUpdateVfGroupNamesRes = groupBusinessLogic
+ .validateUpdateVfGroupNamesOnGraph(groups, updatedResource, inTransaction);
+ if (validateUpdateVfGroupNamesRes.isRight()) {
+ return Either.right(validateUpdateVfGroupNamesRes.right().value());
+ }
+ List<GroupDefinition> heatGroups = null;
+
+ heatGroups = groups.stream().filter(e -> e.getMembers() != null).collect(Collectors.toList());
+
+ for (GroupDefinition updatedGroupDef : groupForAssociateWithMembers) {
+
+ if (updatedGroupDef.getMembers() != null && !updatedGroupDef.getMembers().isEmpty()) {
+ updatedGroupDef.getMembers().clear();
+ }
+ Map<String, String> members = new HashMap<>();
+ Set<String> artifactsGroup = new HashSet<>();
+ artifactsGroup.addAll(updatedGroupDef.getArtifacts());
+ associateMembersToArtifacts(createdNewArtifacts, createdDeplymentArtifactsAfterDelete, heatGroups,
+ artifactsGroup, members);
+ if (!members.isEmpty()) {
+ updatedGroupDef.setMembers(members);
+
+ }
+
+ }
+
+ }
+
+ //////////////// create new artifacts in update
+ //////////////// flow////////////////////////////
+ List<ArtifactTemplateInfo> newArtifactsGroup = new ArrayList<>();
+
+ for (Entry<ArtifactTemplateInfo, Set<ArtifactTemplateInfo>> parsedGroupSetEntry : parsedGroup.entrySet()) {
+ ArtifactTemplateInfo parsedArtifactMaster = parsedGroupSetEntry.getKey();
+ boolean isNewGroup = true;
+ for (Entry<GroupDefinition, Map<ArtifactDefinition, List<ArtifactDefinition>>> groupListEntry : groupArtifact
+ .entrySet()) {
+ Map<ArtifactDefinition, List<ArtifactDefinition>> groupArtifacts = groupListEntry.getValue();
+ Set<ArtifactDefinition> group = groupArtifacts.keySet();
+ for (ArtifactDefinition artifactInfo : group) {
+ if (parsedArtifactMaster.getFileName().equalsIgnoreCase(artifactInfo.getArtifactName())) {
+ parsedArtifactMaster.setGroupName(groupListEntry.getKey().getName());
+ isNewGroup = false;
+ }
+ }
+ }
+ if (isNewGroup) {
+ newArtifactsGroup.add(parsedArtifactMaster);
+ }
+
+ }
+ if (!newArtifactsGroup.isEmpty()) {
+ Collections.sort(newArtifactsGroup, (art1, art2) -> ArtifactTemplateInfo.compareByGroupName(art1, art2));
+ int startGroupCounter = groupBusinessLogic.getNextVfModuleNameCounter(groups);
+ Either<Boolean, ResponseFormat> validateGroupNamesRes = groupBusinessLogic
+ .validateGenerateVfModuleGroupNames(newArtifactsGroup, updatedResource.getSystemName(), startGroupCounter);
+ if (validateGroupNamesRes.isRight()) {
+ return Either.right(validateGroupNamesRes.right().value());
+ }
+ Either<Resource, ResponseFormat> resStatus = createGroupDeploymentArtifactsFromCsar(csarInfo, updatedResource,
+ newArtifactsGroup, createdNewArtifacts, createdDeplymentArtifactsAfterDelete, labelCounter,
+ shouldLock, inTransaction);
+ if (resStatus.isRight()) {
+ return resStatus;
+ }
+ }
+
+ // updatedGroup
+ if (!groupForAssociateWithMembers.isEmpty()) {
+
+ List<GroupDefinition> groupsId = groupForAssociateWithMembers.stream().map(e -> e)
+ .collect(Collectors.toList());
+
+ Either<List<GroupDefinition>, ResponseFormat> updateVersionEither = groupBusinessLogic
+ .updateGroups(updatedResource, groupsId);
+ if (updateVersionEither.isRight()) {
+ log.debug("Failed to update groups version. Status is {} ", updateVersionEither.right().value());
+
+ return Either.right(updateVersionEither.right().value());
+
+ }
+ }
+ if (artifactsWithoutGroups != null && !artifactsWithoutGroups.isEmpty()) {
+ for (ArtifactTemplateInfo t : artifactsWithoutGroups) {
+ List<ArtifactTemplateInfo> arrtifacts = new ArrayList<ArtifactTemplateInfo>();
+ arrtifacts.add(t);
+ Either<Resource, ResponseFormat> resStatus = createGroupDeploymentArtifactsFromCsar(csarInfo, updatedResource,
+ arrtifacts, createdNewArtifacts, createdDeplymentArtifactsAfterDelete, labelCounter, shouldLock,
+ inTransaction);
+ if (resStatus.isRight()) {
+ return resStatus;
+ }
+ }
+
+ }
+
+ Either<Resource, StorageOperationStatus> eitherGerResource = toscaOperationFacade
+ .getToscaElement(updatedResource.getUniqueId());
+ if (eitherGerResource.isRight()) {
+ ResponseFormat responseFormat = componentsUtils.getResponseFormatByResource(
+ componentsUtils.convertFromStorageResponse(eitherGerResource.right().value()), updatedResource);
+
+ return Either.right(responseFormat);
+
+ }
+ return Either.left(eitherGerResource.left().value());
+ }
+
+ private Set<ArtifactDefinition> findArtifactThatNotInGroupToDelete(
+ Map<ArtifactTemplateInfo, Set<ArtifactTemplateInfo>> parsedGroup,
+ List<ArtifactDefinition> createdDeplymentArtifactsAfterDelete) {
+ Set<ArtifactDefinition> artifactsToDelete = new HashSet<>();
+ for (Entry<ArtifactTemplateInfo, Set<ArtifactTemplateInfo>> parsedGroupSetEntry : parsedGroup.entrySet()) {
+ Set<ArtifactTemplateInfo> artifactsNames = parsedGroupSetEntry.getValue();
+ for (ArtifactTemplateInfo template : artifactsNames) {
+ if(template.getType().equals(ArtifactTypeEnum.HEAT_ARTIFACT.getType())){
+ Optional<ArtifactDefinition> op = createdDeplymentArtifactsAfterDelete.stream().filter(a -> a.getArtifactName().equalsIgnoreCase(template.getFileName())).findAny();
+ if(op.isPresent()){
+ if(!op.get().getArtifactType().equalsIgnoreCase(template.getType())){
+ artifactsToDelete.add(op.get());
+ }
+
+ }
+ }
+ }
+ }
+
+ return artifactsToDelete;
+ }
+
+
+ private Either<Resource, ResponseFormat> createResourceArtifacts(CsarInfo csarInfo, Resource resource,
+ Map<String, List<ArtifactTemplateInfo>> artifactsMap,
+ List<ArtifactDefinition> createdArtifacts, boolean shouldLock, boolean inTransaction) {
+
+ Either<Resource, ResponseFormat> resStatus = Either.left(resource);
+
+ Collection<List<ArtifactTemplateInfo>> arifactsCollection = artifactsMap.values();
+
+ for (List<ArtifactTemplateInfo> groupTemplateList : arifactsCollection) {
+ if (groupTemplateList != null) {
+ resStatus = createGroupDeploymentArtifactsFromCsar(csarInfo, resource, groupTemplateList,
+ createdArtifacts, 0, shouldLock, inTransaction);
+ if (resStatus.isRight()) {
+ return resStatus;
+ }
+ }
+ }
+
+ return resStatus;
+
+ }
+
+
+ private Either<Map<ArtifactTemplateInfo, Set<ArtifactTemplateInfo>>, ResponseFormat> createArtifactsTemplateCollection(CsarInfo csarInfo, Resource resource,
+ List<ArtifactDefinition> createdNewArtifacts, boolean shouldLock, boolean inTransaction,
+ List<ArtifactDefinition> createdDeplymentArtifactsAfterDelete, int labelCounter,
+ Collection<List<ArtifactTemplateInfo>> parsedArifactsCollection) {
+
+ Map<ArtifactTemplateInfo, Set<ArtifactTemplateInfo>> parsedGroup = new HashMap<>();
+
+ for (List<ArtifactTemplateInfo> parsedGroupTemplateList : parsedArifactsCollection) {
+
+ for (ArtifactTemplateInfo parsedGroupTemplate : parsedGroupTemplateList) {
+ if (parsedGroupTemplate.getGroupName() != null) {
+ parsedGroupTemplate.setGroupName("");
+ Set<ArtifactTemplateInfo> parsedArtifactsNames = new HashSet<>();
+ parsedArtifactsNames.add(parsedGroupTemplate);
+ List<ArtifactTemplateInfo> relatedGroupTemplateList = parsedGroupTemplate.getRelatedArtifactsInfo();
+ if (relatedGroupTemplateList != null && !relatedGroupTemplateList.isEmpty()) {
+ createArtifactsGroupSet(parsedGroupTemplateList, parsedArtifactsNames);
+ }
+ parsedGroup.put(parsedGroupTemplate, parsedArtifactsNames);
+ } else {
+ List<ArtifactTemplateInfo> arrtifacts = new ArrayList<>();
+ arrtifacts.add(parsedGroupTemplate);
+ Either<Resource, ResponseFormat> resStatus = createGroupDeploymentArtifactsFromCsar(csarInfo,
+ resource, arrtifacts, createdNewArtifacts, createdDeplymentArtifactsAfterDelete,
+ labelCounter, shouldLock, inTransaction);
+ if (resStatus.isRight()) {
+ return Either.right(resStatus.right().value());
+ }
+
+ }
+ }
+
+ }
+ return Either.left(parsedGroup);
+ }
+
+ @SuppressWarnings({ "unchecked", "static-access" })
+ public Either<Map<String, List<ArtifactTemplateInfo>>, ResponseFormat> parseResourceArtifactsInfoFromFile(
+ Resource resource, String artifactsMetaFile, String artifactFileName, User user) {
+
+ try {
+ JsonObject jsonElement = new JsonObject();
+ jsonElement = gson.fromJson(artifactsMetaFile, jsonElement.getClass());
+
+ JsonElement importStructureElement = jsonElement.get(Constants.IMPORT_STRUCTURE);
+ if (importStructureElement == null || importStructureElement.isJsonNull()) {
+ log.debug("Artifact file is not in expected formatr, fileName {}", artifactFileName);
+ BeEcompErrorManager.getInstance().logInternalDataError(
+ "Artifact file is not in expected formatr, fileName " + artifactFileName,
+ "Artifact internals are invalid", ErrorSeverity.ERROR);
+ return Either
+ .right(componentsUtils.getResponseFormat(ActionStatus.CSAR_INVALID_FORMAT, artifactFileName));
+ }
+
+ Map<String, List<Map<String, Object>>> artifactTemplateMap = new HashMap<>();
+ artifactTemplateMap = ComponentsUtils.parseJsonToObject(importStructureElement.toString(), HashMap.class);
+ if (artifactTemplateMap.isEmpty()) {
+ log.debug("Artifact file is not in expected formatr, fileName {}", artifactFileName);
+ BeEcompErrorManager.getInstance().logInternalDataError(
+ "Artifact file is not in expected formatr, fileName " + artifactFileName,
+ "Artifact internals are invalid", ErrorSeverity.ERROR);
+ return Either
+ .right(componentsUtils.getResponseFormat(ActionStatus.CSAR_INVALID_FORMAT, artifactFileName));
+ }
+
+ Set<String> artifactsTypeKeys = artifactTemplateMap.keySet();
+ Map<String, List<ArtifactTemplateInfo>> artifactsMap = new HashMap<>();
+ List<ArtifactTemplateInfo> allGroups = new ArrayList<>();
+ for (String artifactsTypeKey : artifactsTypeKeys) {
+
+ Either <List<ArtifactTemplateInfo>, ResponseFormat> artifactTemplateInfoListEither = parseArtifactTemplateList(artifactFileName,
+ artifactTemplateMap, allGroups, artifactsTypeKey);
+ if(artifactTemplateInfoListEither.isRight()){
+ return Either.right(artifactTemplateInfoListEither.right().value());
+ }
+ artifactsMap.put(artifactsTypeKey, artifactTemplateInfoListEither.left().value());
+ }
+ int counter = groupBusinessLogic.getNextVfModuleNameCounter(resource.getGroups());
+ Either<Boolean, ResponseFormat> validateGroupNamesRes = groupBusinessLogic
+ .validateGenerateVfModuleGroupNames(allGroups, resource.getSystemName(), counter);
+ if (validateGroupNamesRes.isRight()) {
+ return Either.right(validateGroupNamesRes.right().value());
+ }
+ return Either.left(artifactsMap);
+ } catch (Exception e) {
+ log.debug("Artifact file is not in expected format, fileName {}", artifactFileName);
+ log.debug("failed with exception.", e);
+ BeEcompErrorManager.getInstance().logInternalDataError(
+ "Artifact file is not in expected format, fileName " + artifactFileName,
+ "Artifact internals are invalid", ErrorSeverity.ERROR);
+ return Either.right(componentsUtils.getResponseFormat(ActionStatus.CSAR_INVALID_FORMAT, artifactFileName));
+ }
+
+ }
+
+ private Either< List<ArtifactTemplateInfo>, ResponseFormat> parseArtifactTemplateList(String artifactFileName,
+ Map<String, List<Map<String, Object>>> artifactTemplateMap, List<ArtifactTemplateInfo> allGroups,
+ String artifactsTypeKey) {
+ List<Map<String, Object>> o = artifactTemplateMap.get(artifactsTypeKey);
+ Either<List<ArtifactTemplateInfo>, ResponseFormat> artifactTemplateInfoListPairStatus = createArtifactTemplateInfoModule(
+ artifactsTypeKey, o);
+ if (artifactTemplateInfoListPairStatus.isRight()) {
+ log.debug("Artifact file is not in expected formatr, fileName {}", artifactFileName);
+ BeEcompErrorManager.getInstance().logInternalDataError(
+ "Artifact file is not in expected format, fileName " + artifactFileName,
+ "Artifact internals are invalid", ErrorSeverity.ERROR);
+ return Either.right(artifactTemplateInfoListPairStatus.right().value());
+ }
+ List<ArtifactTemplateInfo> artifactTemplateInfoList = artifactTemplateInfoListPairStatus.left().value();
+ if (artifactTemplateInfoList == null) {
+ log.debug("Artifact file is not in expected formatr, fileName {}", artifactFileName);
+ BeEcompErrorManager.getInstance().logInternalDataError(
+ "Artifact file is not in expected format, fileName " + artifactFileName,
+ "Artifact internals are invalid", ErrorSeverity.ERROR);
+ return Either.right(
+ componentsUtils.getResponseFormat(ActionStatus.CSAR_INVALID_FORMAT, artifactFileName));
+
+ }
+ if (!artifactsTypeKey.equalsIgnoreCase(ArtifactTemplateInfo.CSAR_ARTIFACT)) {
+ allGroups.addAll(artifactTemplateInfoList);
+ }
+ return Either.left(artifactTemplateInfoList);
+ }
+
+ private Either<List<ArtifactTemplateInfo>, ResponseFormat> createArtifactTemplateInfoModule(String artifactsTypeKey,
+ List<Map<String, Object>> jsonObject) {
+ List<ArtifactTemplateInfo> artifactTemplateInfoList = new ArrayList<>();
+ for (Map<String, Object> o : jsonObject) {
+ Either<ArtifactTemplateInfo, ResponseFormat> artifacttemplateInfoStatus = ArtifactTemplateInfo
+ .createArtifactTemplateInfoFromJson(componentsUtils, artifactsTypeKey, o, artifactTemplateInfoList,
+ null);
+ if (artifacttemplateInfoStatus.isRight()) {
+ return Either.right(artifacttemplateInfoStatus.right().value());
+ }
+
+ ArtifactTemplateInfo artifacttemplateInfo = artifacttemplateInfoStatus.left().value();
+ if (artifacttemplateInfo != null) {
+ artifactTemplateInfoList.add(artifacttemplateInfo);
+ }
+
+ }
+ return Either.left(artifactTemplateInfoList);
+ }
+
+
+
+ private Either<Resource, ResponseFormat> createGroupDeploymentArtifactsFromCsar(CsarInfo csarInfo,
+ Resource resource, List<ArtifactTemplateInfo> artifactsTemplateList,
+ List<ArtifactDefinition> createdArtifacts, int labelCounter, boolean shouldLock, boolean inTransaction) {
+ Either<Resource, ResponseFormat> resStatus = Either.left(resource);
+ List<GroupDefinition> createdGroups = resource.getGroups();
+ List<GroupDefinition> heatGroups = null;
+ if (createdGroups != null && !createdGroups.isEmpty()) {
+
+ heatGroups = createdGroups.stream().filter(e -> e.getMembers() != null).collect(Collectors.toList());
+
+ }
+ List<GroupDefinition> needToCreate = new ArrayList<>();
+ for (ArtifactTemplateInfo groupTemplateInfo : artifactsTemplateList) {
+ String groupName = groupTemplateInfo.getGroupName();
+ Set<String> artifactsGroup = new HashSet<>();
+ Set<String> artifactsUUIDGroup = new HashSet<>();
+
+ log.debug("createDeploymentArtifactsFromCsar start");
+ resStatus = createDeploymentArtifactFromCsar(csarInfo, ARTIFACTS_PATH, resource, artifactsGroup,
+ artifactsUUIDGroup, groupTemplateInfo, createdArtifacts, labelCounter, shouldLock, inTransaction);
+ log.debug("createDeploymentArtifactsFromCsar end");
+ if (resStatus.isRight()) {
+ return resStatus;
+ }
+ if (groupName != null && !groupName.isEmpty()) {
+
+ Either<GroupDefinition, ResponseFormat> groupDefinitionEither = buildGroupDefinition(createdArtifacts, heatGroups, groupTemplateInfo,
+ groupName, artifactsGroup, artifactsUUIDGroup);
+ if (groupDefinitionEither.isRight()) {
+ return Either.right(groupDefinitionEither.right().value());
+ }
+ needToCreate.add(groupDefinitionEither.left().value());
+ }
+ }
+
+ ComponentParametersView componentParametersView = new ComponentParametersView();
+ componentParametersView.disableAll();
+ componentParametersView.setIgnoreUsers(false);
+ componentParametersView.setIgnoreArtifacts(false);
+ componentParametersView.setIgnoreGroups(false);
+
+ componentParametersView.setIgnoreComponentInstances(false);
+
+ Either<Resource, StorageOperationStatus> component = toscaOperationFacade
+ .getToscaElement(resource.getUniqueId(), componentParametersView);
+
+ if (component.isRight()) {
+ return Either.right(componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR));
+ }
+
+ Either<List<GroupDefinition>, ResponseFormat> createGroups = groupBusinessLogic
+ .addGroups(component.left().value(), needToCreate);
+ if (createGroups.isRight()) {
+ return Either.right(createGroups.right().value());
+ }
+
+ return Either.left(component.left().value());
+ }
+
+ private Either<GroupDefinition, ResponseFormat> buildGroupDefinition(List<ArtifactDefinition> createdArtifacts,
+ List<GroupDefinition> heatGroups, ArtifactTemplateInfo groupTemplateInfo, String groupName,
+ Set<String> artifactsGroup, Set<String> artifactsUUIDGroup) {
+
+ Map<String, String> members = new HashMap<>();
+
+ associateMembersToArtifacts(createdArtifacts, null, heatGroups, artifactsGroup, members);
+
+ List<String> artifactsList = new ArrayList<>(artifactsGroup);
+ List<String> artifactsUUIDList = new ArrayList<>(artifactsUUIDGroup);
+
+ GroupDefinition groupDefinition = new GroupDefinition();
+ groupDefinition.setName(groupName);
+ groupDefinition.setType(Constants.DEFAULT_GROUP_VF_MODULE);
+ groupDefinition.setArtifacts(artifactsList);
+ groupDefinition.setArtifactsUuid(artifactsUUIDList);
+
+ if (!members.isEmpty()) {
+ groupDefinition.setMembers(members);
+ }
+ List<GroupProperty> properties = new ArrayList<>();
+ GroupProperty prop = new GroupProperty();
+ prop.setName(Constants.IS_BASE);
+ prop.setValue(Boolean.toString(groupTemplateInfo.isBase()));
+ properties.add(prop);
+ Either<GroupTypeDefinition, StorageOperationStatus> getLatestGroupTypeRes = groupTypeOperation
+ .getLatestGroupTypeByType(Constants.DEFAULT_GROUP_VF_MODULE, true);
+ if (getLatestGroupTypeRes.isRight()) {
+ return Either.right(componentsUtils.getResponseFormat(
+ componentsUtils.convertFromStorageResponse(getLatestGroupTypeRes.right().value())));
+ }
+ properties = createVfModuleAdditionalProperties(groupTemplateInfo.isBase(), groupName, properties,
+ createdArtifacts, artifactsList, getLatestGroupTypeRes.left().value());
+ groupDefinition.convertFromGroupProperties(properties);
+ log.debug("createGroup start");
+ return Either.left(groupDefinition);
+ }
+
+ private Either<Resource, ResponseFormat> createDeploymentArtifactFromCsar(CsarInfo csarInfo, String artifactPath,
+ Resource resource, Set<String> artifactsGroup, Set<String> artifactsUUIDGroup,
+ ArtifactTemplateInfo artifactTemplateInfo, List<ArtifactDefinition> createdArtifacts, int labelCounter,
+ boolean shoudLock, boolean inTransaction) {
+ Either<Resource, ResponseFormat> resStatus = Either.left(resource);
+
+ String artifactUid = "";
+ String artifactEnvUid = "";
+ String artifactUUID = "";
+
+
+ // check if artifacts already exist
+ Either<ArtifactDefinition, ResponseFormat> createdArtifactEther = checkIfArtifactAlreadyExist(artifactTemplateInfo, createdArtifacts);
+ if(createdArtifactEther.isRight()){
+ return Either.right(createdArtifactEther.right().value());
+ }
+ ArtifactDefinition createdArtifact = createdArtifactEther.left().value();
+ if(createdArtifact == null){
+
+ Either<ArtifactDefinition, ResponseFormat> newArtifactEither = createDeploymentArtifact(csarInfo, resource,
+ artifactPath, artifactTemplateInfo, createdArtifacts, labelCounter, inTransaction);
+ if (newArtifactEither.isRight()) {
+ resStatus = Either.right(newArtifactEither.right().value());
+ return resStatus;
+ }
+ ArtifactDefinition newArtifact = newArtifactEither.left().value();
+ artifactUid = newArtifact.getUniqueId();
+ artifactUUID = newArtifact.getArtifactUUID();
+
+ ArtifactTypeEnum artifactType = ArtifactTypeEnum.findType(newArtifact.getArtifactType());
+ if (artifactType == ArtifactTypeEnum.HEAT || artifactType == ArtifactTypeEnum.HEAT_NET
+ || artifactType == ArtifactTypeEnum.HEAT_VOL) {
+ Either<ArtifactDefinition, ResponseFormat> createHeatEnvPlaceHolder = artifactsBusinessLogic
+ .createHeatEnvPlaceHolder(newArtifact, ArtifactsBusinessLogic.HEAT_VF_ENV_NAME,
+ resource.getUniqueId(), NodeTypeEnum.Resource, resource.getName(),
+ csarInfo.getModifier(), resource, null);
+ if (createHeatEnvPlaceHolder.isRight()) {
+ return Either.right(createHeatEnvPlaceHolder.right().value());
+ }
+ artifactEnvUid = createHeatEnvPlaceHolder.left().value().getUniqueId();
+ }
+ }else{
+ artifactUid = createdArtifact.getUniqueId();
+ artifactUUID = createdArtifact.getArtifactUUID();
+ artifactEnvUid = checkAndGetHeatEnvId(createdArtifact);
+ }
+ artifactsGroup.add(artifactUid);
+ artifactsUUIDGroup.add(artifactUUID);
+ if (!artifactEnvUid.isEmpty()) {
+ artifactsGroup.add(artifactEnvUid);
+ }
+
+ List<ArtifactTemplateInfo> relatedArtifacts = artifactTemplateInfo.getRelatedArtifactsInfo();
+ if (relatedArtifacts != null) {
+ for (ArtifactTemplateInfo relatedArtifactTemplateInfo : relatedArtifacts) {
+ resStatus = createDeploymentArtifactFromCsar(csarInfo, artifactPath, resource, artifactsGroup,
+ artifactsUUIDGroup, relatedArtifactTemplateInfo, createdArtifacts, labelCounter, shoudLock,
+ inTransaction);
+ if (resStatus.isRight()) {
+ return resStatus;
+ }
+ }
+ }
+ return resStatus;
+ }
+
+ private String checkAndGetHeatEnvId(ArtifactDefinition createdArtifact) {
+ String artifactEnvUid = "";
+ ArtifactTypeEnum artifactType = ArtifactTypeEnum.findType(createdArtifact.getArtifactType());
+ if (artifactType == ArtifactTypeEnum.HEAT || artifactType == ArtifactTypeEnum.HEAT_NET
+ || artifactType == ArtifactTypeEnum.HEAT_VOL) {
+ artifactEnvUid = createdArtifact.getUniqueId() + ArtifactsBusinessLogic.HEAT_ENV_SUFFIX;
+ }
+ return artifactEnvUid;
+ }
+
+ private Either<ArtifactDefinition, ResponseFormat> checkIfArtifactAlreadyExist(ArtifactTemplateInfo artifactTemplateInfo, List<ArtifactDefinition> createdArtifacts){
+
+ ArtifactDefinition res = null;
+ String artifactFileName = artifactTemplateInfo.getFileName();
+ Optional<ArtifactDefinition> op = createdArtifacts.stream().filter(a -> a.getArtifactName().equals(artifactFileName)).findAny();
+ if(op.isPresent()){
+ res = op.get();
+ if (!res.getArtifactType().equalsIgnoreCase(artifactTemplateInfo.getType())) {
+ log.debug("Artifact with name {} and type {} already exist with type {}", artifactFileName,
+ artifactTemplateInfo.getType(), res.getArtifactType());
+ BeEcompErrorManager.getInstance().logInternalDataError(
+ "Artifact file is not in expected formatr, fileName " + artifactFileName,
+ "Artifact internals are invalid", ErrorSeverity.ERROR);
+ return Either.right(componentsUtils.getResponseFormat(
+ ActionStatus.ARTIFACT_ALRADY_EXIST_IN_DIFFERENT_TYPE_IN_CSAR, artifactFileName,
+ artifactTemplateInfo.getType(), res.getArtifactType()));
+ }
+ }
+ return Either.left(res);
+
+
+ }
+
+ private Either<ArtifactDefinition, ResponseFormat> createDeploymentArtifact(CsarInfo csarInfo, Resource resource,
+ String artifactPath, ArtifactTemplateInfo artifactTemplateInfo, List<ArtifactDefinition> createdArtifacts,
+ int label, boolean inTransaction) {
+ int updatedlabel = label;
+ final String artifactFileName = artifactTemplateInfo.getFileName();
+ Either<ImmutablePair<String, byte[]>, ResponseFormat> artifactContententStatus = CsarValidationUtils
+ .getArtifactsContent(csarInfo.getCsarUUID(), csarInfo.getCsar(), artifactPath + artifactFileName,
+ artifactFileName, componentsUtils);
+ if (artifactContententStatus.isRight()) {
+ return Either.right(artifactContententStatus.right().value());
+ }
+ updatedlabel += createdArtifacts.size();
+
+ Map<String, Object> json = ArtifactUtils.buildJsonForArtifact(artifactTemplateInfo,
+ artifactContententStatus.left().value().getValue(), updatedlabel);
+
+ Either<Either<ArtifactDefinition, Operation>, ResponseFormat> uploadArtifactToService = createOrUpdateCsarArtifactFromJson(
+ resource, csarInfo.getModifier(), json,
+ artifactsBusinessLogic.new ArtifactOperationInfo(false, false, ArtifactOperationEnum.CREATE));
+
+ if (uploadArtifactToService.isRight()) {
+ return Either.right(uploadArtifactToService.right().value());
+ }
+
+ ArtifactDefinition currentInfo = uploadArtifactToService.left().value().left().value();
+ if (currentInfo.getHeatParameters() != null) {
+
+ Either<ArtifactDefinition, ResponseFormat> updateEnvEither = updateHeatParamsFromCsar(resource, csarInfo,
+ artifactTemplateInfo, currentInfo, false);
+ if (updateEnvEither.isRight()) {
+ log.debug("failed to update parameters to artifact {}", artifactFileName);
+ return Either.right(updateEnvEither.right().value());
+
+ }
+ currentInfo = updateEnvEither.left().value();
+
+ }
+
+ createdArtifacts.add(currentInfo);
+
+ return Either.left(currentInfo);
+
+ }
+
+
+
+ private Either<ArtifactDefinition, ResponseFormat> updateHeatParamsFromCsar(Resource resource, CsarInfo csarInfo,
+ ArtifactTemplateInfo artifactTemplateInfo, ArtifactDefinition currentInfo, boolean isUpdateEnv) {
+
+ Resource updatedResource = resource;
+ Either<ArtifactDefinition, ResponseFormat> resStatus = Either.left(currentInfo);
+ if (artifactTemplateInfo.getEnv() != null && !artifactTemplateInfo.getEnv().isEmpty()) {
+
+ Either<ImmutablePair<String, byte[]>, ResponseFormat> artifactparamsStatus = CsarValidationUtils
+ .getArtifactsContent(csarInfo.getCsarUUID(), csarInfo.getCsar(),
+ CsarUtils.ARTIFACTS_PATH + artifactTemplateInfo.getEnv(), artifactTemplateInfo.getEnv(),
+ componentsUtils);
+ if (artifactparamsStatus.isRight()) {
+ resStatus = Either.right(artifactparamsStatus.right().value());
+ return resStatus;
+ }
+ Either<List<HeatParameterDefinition>, ResponseFormat> propsStatus = extractHeatParameters(
+ ArtifactTypeEnum.HEAT_ENV.getType(), artifactTemplateInfo.getEnv(),
+ artifactparamsStatus.left().value().getValue(), false);
+
+ if (propsStatus.isLeft()) {
+ List<HeatParameterDefinition> updatedHeatEnvParams = propsStatus.left().value();
+ resStatus = updateHeatParams(updatedResource, currentInfo, updatedHeatEnvParams);
+ if (resStatus.isRight()) {
+ return resStatus;
+ }
+
+ }
+ }
+ if (isUpdateEnv) {
+ ComponentParametersView parametersView = new ComponentParametersView();
+ parametersView.disableAll();
+ parametersView.setIgnoreComponentInstances(false);
+ parametersView.setIgnoreUsers(false);
+ parametersView.setIgnoreArtifacts(false);
+ parametersView.setIgnoreGroups(false);
+
+ Either<Resource, StorageOperationStatus> eitherGerResource = toscaOperationFacade
+ .getToscaElement(updatedResource.getUniqueId(), parametersView);
+
+ if (eitherGerResource.isRight()) {
+ ResponseFormat responseFormat = componentsUtils.getResponseFormatByResource(
+ componentsUtils.convertFromStorageResponse(eitherGerResource.right().value()), updatedResource);
+
+ resStatus = Either.right(responseFormat);
+ return resStatus;
+
+ }
+
+ updatedResource = eitherGerResource.left().value();
+ Map<String, ArtifactDefinition> artifacts = updatedResource.getDeploymentArtifacts();
+ Optional<ArtifactDefinition> op = artifacts.values().stream().filter(
+ p -> p.getGeneratedFromId() != null && p.getGeneratedFromId().equals(currentInfo.getUniqueId()))
+ .findAny();
+ if (op.isPresent()) {
+ ArtifactDefinition artifactInfoHeatEnv = op.get();
+ Either<ArtifactDefinition, StorageOperationStatus> updateArifactOnResource = artifactToscaOperation
+ .updateArifactOnResource(artifactInfoHeatEnv, updatedResource.getUniqueId(),
+ artifactInfoHeatEnv.getUniqueId(), null, null);
+ if (updateArifactOnResource.isRight()) {
+ log.debug("Failed to update heat env on CSAR flow for component {} artifact {} label {}",
+ updatedResource.getUniqueId(), artifactInfoHeatEnv.getUniqueId(),
+ artifactInfoHeatEnv.getArtifactLabel());
+ return Either.right(componentsUtils.getResponseFormat(
+ componentsUtils.convertFromStorageResponse(updateArifactOnResource.right().value())));
+ }
+ resStatus = Either.left(updateArifactOnResource.left().value());
+ }
+ }
+ return resStatus;
+ }
+
+ private Either<List<HeatParameterDefinition>, ResponseFormat> extractHeatParameters(String artifactType,
+ String fileName, byte[] content, boolean is64Encoded) {
+ // extract heat parameters
+ String heatDecodedPayload = is64Encoded ? new String(Base64.decodeBase64(content)) : new String(content);
+ Either<List<HeatParameterDefinition>, ResultStatusEnum> heatParameters = ImportUtils
+ .getHeatParamsWithoutImplicitTypes(heatDecodedPayload, artifactType);
+ if (heatParameters.isRight()) {
+ log.debug("File {} is not in expected key-value form in csar ", fileName);
+ BeEcompErrorManager.getInstance().logInternalDataError(
+ "File " + fileName + " is not in expected key-value form in csar ", "CSAR internals are invalid",
+ ErrorSeverity.ERROR);
+ return Either
+ .right(componentsUtils.getResponseFormat(ActionStatus.INVALID_DEPLOYMENT_ARTIFACT_HEAT, fileName));
+
+ }
+ return Either.left(heatParameters.left().value());
+
+ }
+
+ private Either<ArtifactDefinition, ResponseFormat> updateHeatParams(Resource resource,
+ ArtifactDefinition currentInfo, List<HeatParameterDefinition> updatedHeatEnvParams) {
+
+ Either<ArtifactDefinition, ResponseFormat> resStatus = Either.left(currentInfo);
+ List<HeatParameterDefinition> currentHeatEnvParams = currentInfo.getListHeatParameters();
+
+ if (updatedHeatEnvParams != null && !updatedHeatEnvParams.isEmpty() && currentHeatEnvParams != null
+ && !currentHeatEnvParams.isEmpty()) {
+
+ String paramName;
+ for (HeatParameterDefinition heatEnvParam : updatedHeatEnvParams) {
+
+ paramName = heatEnvParam.getName();
+ for (HeatParameterDefinition currHeatParam : currentHeatEnvParams) {
+ if (paramName.equalsIgnoreCase(currHeatParam.getName())) {
+
+ String updatedParamValue = heatEnvParam.getCurrentValue();
+ if (updatedParamValue == null) {
+ updatedParamValue = heatEnvParam.getDefaultValue();
+ }
+ HeatParameterType paramType = HeatParameterType.isValidType(currHeatParam.getType());
+ if (!paramType.getValidator().isValid(updatedParamValue, null)) {
+ ActionStatus status = ActionStatus.INVALID_HEAT_PARAMETER_VALUE;
+ ResponseFormat responseFormat = componentsUtils.getResponseFormat(status,
+ ArtifactTypeEnum.HEAT_ENV.getType(), paramType.getType(), paramName);
+ resStatus = Either.right(responseFormat);
+ return resStatus;
+ }
+ currHeatParam.setCurrentValue(
+ paramType.getConverter().convert(updatedParamValue, null, null));
+
+ break;
+ }
+ }
+ }
+ currentInfo.setListHeatParameters(currentHeatEnvParams);
+ Either<ArtifactDefinition, StorageOperationStatus> updateArifactOnResource = artifactToscaOperation
+ .updateArifactOnResource(currentInfo, resource.getUniqueId(), currentInfo.getUniqueId(),
+ null, null);
+ if (updateArifactOnResource.isRight()) {
+ log.debug(
+ "Failed to update heat paratemers of heat on CSAR flow for component {} artifact {} label {}",
+ resource.getUniqueId(), currentInfo.getUniqueId(), currentInfo.getArtifactLabel());
+ return Either.right(componentsUtils.getResponseFormat(
+ componentsUtils.convertFromStorageResponse(updateArifactOnResource.right().value())));
+ }
+ resStatus = Either.left(updateArifactOnResource.left().value());
+ }
+ return resStatus;
+ }
+
+
+
+
+ public Either<Either<ArtifactDefinition, Operation>, ResponseFormat> createOrUpdateCsarArtifactFromJson(
+ Resource resource, User user, Map<String, Object> json, ArtifactOperationInfo operation) {
+
+ String jsonStr = gson.toJson(json);
+
+ String origMd5 = GeneralUtility.calculateMD5Base64EncodedByString(jsonStr);
+ ArtifactDefinition artifactDefinitionFromJson = RepresentationUtils.convertJsonToArtifactDefinition(jsonStr,
+ ArtifactDefinition.class);
+ String artifactUniqueId = artifactDefinitionFromJson == null ? null : artifactDefinitionFromJson.getUniqueId();
+ Either<Either<ArtifactDefinition, Operation>, ResponseFormat> uploadArtifactToService = artifactsBusinessLogic
+ .validateAndHandleArtifact(resource.getUniqueId(), ComponentTypeEnum.RESOURCE, operation,
+ artifactUniqueId, artifactDefinitionFromJson, origMd5, jsonStr, null, null, user,
+ resource, false, true, false);
+ if (uploadArtifactToService.isRight()) {
+ return Either.right(uploadArtifactToService.right().value());
+ }
+
+ return Either.left(uploadArtifactToService.left().value());
+ }
+
+ private void associateMembersToArtifacts(List<ArtifactDefinition> createdArtifacts,
+ List<ArtifactDefinition> artifactsFromResource, List<GroupDefinition> heatGroups,
+ Set<String> artifactsGroup, Map<String, String> members) {
+ if (heatGroups != null && !heatGroups.isEmpty()) {
+ for (GroupDefinition heatGroup : heatGroups) {
+ List<GroupProperty> grpoupProps = heatGroup.convertToGroupProperties();
+ if (grpoupProps != null) {
+ associatemembersToVFgroups(createdArtifacts, artifactsFromResource, grpoupProps, artifactsGroup, heatGroup, members);
+ }
+ }
+
+ }
+ }
+
+ private void associatemembersToVFgroups(List<ArtifactDefinition> createdArtifacts,List<ArtifactDefinition> artifactsFromResource, List<GroupProperty> grpoupProps, Set<String> artifactsGroup, GroupDefinition heatGroup, Map<String, String> members){
+ Optional<GroupProperty> op = grpoupProps.stream()
+ .filter(p -> p.getName().equals(Constants.HEAT_FILE_PROPS)).findAny();
+ if (op.isPresent()) {
+ GroupProperty prop = op.get();
+ String heatFileNAme = prop.getValue();
+ if (null == heatFileNAme || heatFileNAme.isEmpty()) {
+ return;
+ }
+ List<ArtifactDefinition> artifacts = new ArrayList<>();
+ for (String artifactId : artifactsGroup) {
+ Optional<ArtifactDefinition> opArt = createdArtifacts.stream()
+ .filter(p -> p.getUniqueId().equals(artifactId)).findAny();
+ if (opArt.isPresent()) {
+ artifacts.add(opArt.get());
+ }
+ if (artifactsFromResource != null) {
+ opArt = artifactsFromResource.stream().filter(p -> p.getUniqueId().equals(artifactId))
+ .findAny();
+ if (opArt.isPresent()) {
+ artifacts.add(opArt.get());
+ }
+ }
+ }
+ Optional<ArtifactDefinition> resOp = artifacts.stream()
+ .filter(p -> heatFileNAme.contains(p.getArtifactName())).findAny();
+ if (resOp.isPresent()) {
+ members.putAll(heatGroup.getMembers());
+ }
+ }
+ }
+
+ public List<GroupProperty> createVfModuleAdditionalProperties(boolean isBase, String moduleName,
+ List<GroupProperty> properties, List<ArtifactDefinition> deploymentArtifacts, List<String> artifactsInGroup,
+ GroupTypeDefinition groupType) {
+ Map<String, VfModuleProperty> vfModuleProperties = ConfigurationManager.getConfigurationManager()
+ .getConfiguration().getVfModuleProperties();
+ vfModuleProperties.entrySet().forEach(p -> {
+ GroupProperty prop = new GroupProperty();
+ prop.setName(p.getKey());
+ if (isBase) {
+ prop.setValue(p.getValue().getForBaseModule());
+ prop.setDefaultValue(p.getValue().getForBaseModule());
+ } else {
+ prop.setValue(p.getValue().getForNonBaseModule());
+ prop.setDefaultValue(p.getValue().getForNonBaseModule());
+ }
+ properties.add(prop);
+
+ });
+ GroupProperty proplabel = new GroupProperty();
+ proplabel.setName("vf_module_label");
+
+ Matcher matcher = pattern.matcher(moduleName);
+
+ if (matcher.find()) {
+ proplabel.setValue(matcher.group(1));
+ proplabel.setDefaultValue(matcher.group(1));
+ } else {
+ proplabel.setValue(moduleName);
+ proplabel.setDefaultValue(moduleName);
+ }
+ properties.add(proplabel);
+
+ GroupProperty propvolume = new GroupProperty();
+ propvolume.setName("volume_group");
+ boolean isVolume = false;
+ for (String artifactId : artifactsInGroup) {
+ ArtifactDefinition artifactDef = null;
+ artifactDef = ArtifactUtils.findArtifactInList(deploymentArtifacts, artifactId);
+ if (artifactDef != null
+ && artifactDef.getArtifactType().equalsIgnoreCase(ArtifactTypeEnum.HEAT_VOL.getType())) {
+ isVolume = true;
+ break;
+ }
+ }
+ propvolume.setValue(String.valueOf(isVolume));
+ propvolume.setDefaultValue(String.valueOf(isVolume));
+ properties.add(propvolume);
+ mergeWithGroupTypeProperties(properties, groupType.getProperties());
+ return properties;
+ }
+
+ private void mergeWithGroupTypeProperties(List<GroupProperty> properties,
+ List<PropertyDefinition> groupTypeProperties) {
+
+ Map<String, GroupProperty> propertiesMap = properties.stream()
+ .collect(Collectors.toMap(p -> p.getName(), p -> p));
+ for (PropertyDefinition groupTypeProperty : groupTypeProperties) {
+ if (!propertiesMap.containsKey(groupTypeProperty.getName())) {
+ properties.add(new GroupProperty(groupTypeProperty));
+ }
+ }
+ }
+
+ private Map<GroupDefinition, MergedArtifactInfo> mergeGroupInUpdateFlow(
+ Map<GroupDefinition, Map<ArtifactDefinition, List<ArtifactDefinition>>> groupArtifact,
+ Map<ArtifactTemplateInfo, Set<ArtifactTemplateInfo>> parsedGroup, Set<ArtifactDefinition> artifactsToDelete,
+ Map<String, List<ArtifactDefinition>> groupToDelete, Set<ArtifactTemplateInfo> jsonMasterArtifacts,
+ List<ArtifactDefinition> createdDeplymentArtifacts) {
+ Map<GroupDefinition, MergedArtifactInfo> mergedgroup = new HashMap<>();
+ for (Entry<GroupDefinition, Map<ArtifactDefinition, List<ArtifactDefinition>>> groupListEntry : groupArtifact
+ .entrySet()) {
+ Map<ArtifactDefinition, List<ArtifactDefinition>> createdArtifactMap = groupListEntry.getValue();
+ boolean isNeedToDeleteGroup = true;
+ List<ArtifactDefinition> listToDelete = null;
+ for (ArtifactDefinition maserArtifact : createdArtifactMap.keySet()) {
+ listToDelete = createdArtifactMap.get(maserArtifact);
+ for (ArtifactDefinition artToDelete : listToDelete) {
+ findArtifactToDelete(parsedGroup, artifactsToDelete, artToDelete, createdDeplymentArtifacts);
+ }
+ if (artifactsToDelete != null && !artifactsToDelete.isEmpty()) {
+ GroupDefinition group = groupListEntry.getKey();
+ for (ArtifactDefinition artifactDefinition : artifactsToDelete) {
+ if (CollectionUtils.isNotEmpty(group.getArtifacts())
+ && group.getArtifacts().contains(artifactDefinition.getUniqueId())) {
+ group.getArtifacts().remove(artifactDefinition.getUniqueId());
+
+ }
+ if (CollectionUtils.isNotEmpty(group.getArtifactsUuid())
+ && group.getArtifactsUuid().contains(artifactDefinition.getArtifactUUID())) {
+ group.getArtifactsUuid().remove(artifactDefinition.getArtifactUUID());
+
+ }
+ }
+
+ }
+
+ for (ArtifactTemplateInfo jsonMasterArtifact : jsonMasterArtifacts) {
+ if (maserArtifact.getArtifactName().equalsIgnoreCase(jsonMasterArtifact.getFileName())) {
+ MergedArtifactInfo mergedGroup = new MergedArtifactInfo();
+ mergedGroup.setJsonArtifactTemplate(jsonMasterArtifact);
+ mergedGroup.setCreatedArtifact(createdArtifactMap.get(maserArtifact));
+ mergedgroup.put(groupListEntry.getKey(), mergedGroup);
+ isNeedToDeleteGroup = false;
+
+ }
+ }
+
+ }
+ if (isNeedToDeleteGroup) {
+ groupToDelete.put(groupListEntry.getKey().getUniqueId(), listToDelete);
+ }
+
+ }
+ return mergedgroup;
+ }
+
+ private void findArtifactToDelete(Map<ArtifactTemplateInfo, Set<ArtifactTemplateInfo>> parsedGroup,
+ Set<ArtifactDefinition> artifactsToDelete, ArtifactDefinition artifact,
+ List<ArtifactDefinition> createdDeplymentArtifacts) {
+ boolean isNeedToDeleteArtifact = true;
+ String artifactType = artifact.getArtifactType();
+ ArtifactDefinition generatedFromArt = null;
+ if (artifact.getGeneratedFromId() != null && !artifact.getGeneratedFromId().isEmpty()) {
+ Optional<ArtifactDefinition> op = createdDeplymentArtifacts.stream()
+ .filter(p -> p.getUniqueId().equals(artifact.getGeneratedFromId())).findAny();
+ if (op.isPresent()) {
+ generatedFromArt = op.get();
+ }
+
+ }
+
+ for (Entry<ArtifactTemplateInfo, Set<ArtifactTemplateInfo>> parsedGroupSetEntry : parsedGroup.entrySet()) {
+ Set<ArtifactTemplateInfo> artifactsNames = parsedGroupSetEntry.getValue();
+ for (ArtifactTemplateInfo template : artifactsNames) {
+ if (artifact.getArtifactName().equalsIgnoreCase(template.getFileName())
+ && artifactType.equalsIgnoreCase(template.getType())) {
+ isNeedToDeleteArtifact = false;
+ break;
+
+ } else {
+
+ if (generatedFromArt != null) {
+ if (generatedFromArt.getArtifactName().equalsIgnoreCase(template.getFileName())
+ && generatedFromArt.getArtifactType().equalsIgnoreCase(template.getType())) {
+ isNeedToDeleteArtifact = false;
+ break;
+ }
+ }
+ }
+ }
+
+ }
+ if (isNeedToDeleteArtifact) {
+ artifactsToDelete.add(artifact);
+
+ }
+ }
+
+ private Map<GroupDefinition, Map<ArtifactDefinition, List<ArtifactDefinition>>> findMasterArtifactInGroup(
+ List<GroupDefinition> groups, Map<String, ArtifactDefinition> deplymentArtifact) {
+ Map<GroupDefinition, Map<ArtifactDefinition, List<ArtifactDefinition>>> groupArtifact = new HashMap<>();
+
+ for (GroupDefinition group : groups) {
+ Map<ArtifactDefinition, List<ArtifactDefinition>> gupsMap = new HashMap<>();
+ List<ArtifactDefinition> artifacts = new ArrayList<>();
+ List<String> artifactsList = group.getArtifacts();
+ if (artifactsList != null && !artifactsList.isEmpty()) {
+
+ ArtifactDefinition masterArtifact = ArtifactUtils.findMasterArtifact(deplymentArtifact, artifacts,
+ artifactsList);
+ if (masterArtifact != null) {
+ gupsMap.put(masterArtifact, artifacts);
+ }
+ groupArtifact.put(group, gupsMap);
+
+ }
+ }
+ return groupArtifact;
+ }
+
+ private Either<Resource, ResponseFormat> deleteArtifactsInUpdateCsarFlow(Resource resource,
+ User user, boolean shouldLock, boolean inTransaction, Set<ArtifactDefinition> artifactsToDelete,
+ Map<String, List<ArtifactDefinition>> groupToDelete, List<ArtifactDefinition> deletedArtifacts) {
+
+ Resource updatedResource = resource;
+
+ String resourceId = updatedResource.getUniqueId();
+ if (!artifactsToDelete.isEmpty()) {
+ for (ArtifactDefinition artifact : artifactsToDelete) {
+ String artifactType = artifact.getArtifactType();
+ ArtifactTypeEnum artifactTypeEnum = ArtifactTypeEnum.findType(artifactType);
+ if (artifactTypeEnum != ArtifactTypeEnum.HEAT_ENV) {
+ Either<Either<ArtifactDefinition, Operation>, ResponseFormat> handleDelete = artifactsBusinessLogic
+ .handleDelete(resourceId, artifact.getUniqueId(), user, AuditingActionEnum.ARTIFACT_DELETE,
+ ComponentTypeEnum.RESOURCE, updatedResource, shouldLock, inTransaction);
+ if (handleDelete.isRight()) {
+ return Either.right(handleDelete.right().value());
+ }
+
+ deletedArtifacts.add(handleDelete.left().value().left().value());
+ }
+
+ }
+ }
+ if (!groupToDelete.isEmpty()) {
+ log.debug("try to delete group");
+ List<GroupDefinition> groupDefinitionstoDelete = new ArrayList<>();
+ List<GroupDefinition> groups = updatedResource.getGroups();
+ for (Entry<String, List<ArtifactDefinition>> deleteGroup : groupToDelete.entrySet()) {
+ Optional<GroupDefinition> op = groups.stream()
+ .filter(gr -> gr.getUniqueId().equals(deleteGroup.getKey())).findAny();
+ if (op.isPresent()) {
+ groupDefinitionstoDelete.add(op.get());
+ }
+
+ }
+ if (!groupDefinitionstoDelete.isEmpty()) {
+ Either<List<GroupDefinition>, ResponseFormat> prepareGroups = groupBusinessLogic.deleteGroups(resource, groupDefinitionstoDelete);
+ if (prepareGroups.isRight()) {
+ return Either.right(prepareGroups.right().value());
+ }
+ }
+ }
+ List<GroupDefinition> oldGroups = updatedResource.getGroups();
+ Either<Resource, StorageOperationStatus> eitherGerResource = toscaOperationFacade
+ .getToscaElement(updatedResource.getUniqueId());
+ if (eitherGerResource.isRight()) {
+ ResponseFormat responseFormat = componentsUtils.getResponseFormatByResource(
+ componentsUtils.convertFromStorageResponse(eitherGerResource.right().value()), updatedResource);
+
+ return Either.right(responseFormat);
+
+ }
+ updatedResource = eitherGerResource.left().value();
+ updatedResource.setGroups(oldGroups);
+ return Either.left(updatedResource);
+ }
+
+ private void createArtifactsGroupSet(List<ArtifactTemplateInfo> parsedGroupTemplateList,
+ Set<ArtifactTemplateInfo> parsedArtifactsName) {
+
+ for (ArtifactTemplateInfo parsedGroupTemplate : parsedGroupTemplateList) {
+ parsedArtifactsName.add(parsedGroupTemplate);
+ List<ArtifactTemplateInfo> relatedArtifacts = parsedGroupTemplate.getRelatedArtifactsInfo();
+ if (relatedArtifacts != null && !relatedArtifacts.isEmpty()) {
+ createArtifactsGroupSet(relatedArtifacts, parsedArtifactsName);
+ }
+ }
+ }
+
+ private Either<Resource, ResponseFormat> createGroupDeploymentArtifactsFromCsar(CsarInfo csarInfo,
+ Resource resource, List<ArtifactTemplateInfo> artifactsTemplateList,
+ List<ArtifactDefinition> createdNewArtifacts, List<ArtifactDefinition> artifactsFromResource,
+ int labelCounter, boolean shouldLock, boolean inTransaction) {
+
+ Resource updatedResource = resource;
+
+ Either<Resource, ResponseFormat> resStatus = Either.left(updatedResource);
+ List<GroupDefinition> createdGroups = updatedResource.getGroups();
+ List<GroupDefinition> heatGroups = null;
+ if (createdGroups != null && !createdGroups.isEmpty()) {
+ heatGroups = createdGroups.stream().filter(e -> e.getMembers() != null).collect(Collectors.toList());
+ }
+
+ List<GroupDefinition> needToAdd = new ArrayList<>();
+ for (ArtifactTemplateInfo groupTemplateInfo : artifactsTemplateList) {
+ String groupName = groupTemplateInfo.getGroupName();
+ Set<String> artifactsGroup = new HashSet<>();
+ Set<String> artifactsUUIDGroup = new HashSet<>();
+
+ resStatus = createDeploymentArtifactsFromCsar(csarInfo, updatedResource, artifactsGroup, artifactsUUIDGroup,
+ groupTemplateInfo, createdNewArtifacts, artifactsFromResource, labelCounter, shouldLock,
+ inTransaction);
+ if (resStatus.isRight()) {
+ return resStatus;
+ }
+ if (groupName != null && !groupName.isEmpty()) {
+ Map<String, String> members = new HashMap<>();
+ associateMembersToArtifacts(createdNewArtifacts, artifactsFromResource, heatGroups, artifactsGroup,
+ members);
+
+ List<String> artifactsList = new ArrayList<>(artifactsGroup);
+ List<String> artifactsUUIDList = new ArrayList<>(artifactsUUIDGroup);
+
+ GroupDefinition groupDefinition = new GroupDefinition();
+ groupDefinition.setName(groupName);
+ groupDefinition.setType(Constants.DEFAULT_GROUP_VF_MODULE);
+ groupDefinition.setArtifacts(artifactsList);
+ groupDefinition.setArtifactsUuid(artifactsUUIDList);
+
+ if (!members.isEmpty()) {
+ groupDefinition.setMembers(members);
+ }
+
+ List<GroupProperty> properties = new ArrayList<>();
+ GroupProperty prop = new GroupProperty();
+ prop.setName(Constants.IS_BASE);
+ prop.setValue(Boolean.toString(groupTemplateInfo.isBase()));
+ properties.add(prop);
+
+ List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
+ createdArtifacts.addAll(createdNewArtifacts);
+ createdArtifacts.addAll(artifactsFromResource);
+ Either<GroupTypeDefinition, StorageOperationStatus> getLatestGroupTypeRes = groupTypeOperation
+ .getLatestGroupTypeByType(Constants.DEFAULT_GROUP_VF_MODULE, true);
+ if (getLatestGroupTypeRes.isRight()) {
+ return Either.right(componentsUtils.getResponseFormat(
+ componentsUtils.convertFromStorageResponse(getLatestGroupTypeRes.right().value())));
+ }
+ properties = createVfModuleAdditionalProperties(groupTemplateInfo.isBase(), groupName, properties,
+ createdArtifacts, artifactsList, getLatestGroupTypeRes.left().value());
+ groupDefinition.convertFromGroupProperties(properties);
+
+ needToAdd.add(groupDefinition);
+ }
+ }
+ ComponentParametersView componentParametersView = new ComponentParametersView();
+ componentParametersView.disableAll();
+ componentParametersView.setIgnoreArtifacts(false);
+ componentParametersView.setIgnoreGroups(false);
+ componentParametersView.setIgnoreComponentInstances(false);
+
+ Either<Resource, StorageOperationStatus> component = toscaOperationFacade
+ .getToscaElement(updatedResource.getUniqueId(), componentParametersView);
+ if (component.isRight()) {
+ return Either.right(componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR));
+ }
+ updatedResource = component.left().value();
+
+ Either<List<GroupDefinition>, ResponseFormat> addGroups = groupBusinessLogic.addGroups(updatedResource, needToAdd);
+ if (addGroups.isRight()) {
+ return Either.right(addGroups.right().value());
+ }
+
+ return resStatus;
+ }
+
+ private Either<Resource, ResponseFormat> createDeploymentArtifactsFromCsar(CsarInfo csarInfo, Resource resource,
+ Set<String> artifactsGroup, Set<String> artifactsUUIDGroup, ArtifactTemplateInfo artifactTemplateInfo,
+ List<ArtifactDefinition> createdArtifacts, List<ArtifactDefinition> artifactsFromResource, int labelCounter,
+ boolean shoudLock, boolean inTransaction) {
+ Either<Resource, ResponseFormat> resStatus = Either.left(resource);
+ String artifactFileName = artifactTemplateInfo.getFileName();
+ String artifactUid = "";
+ String artifactUUID = "";
+ String artifactEnvUid = "";
+ boolean alreadyExist = false;
+
+ // check if artifacts already exist
+ if (artifactsFromResource != null && !artifactsFromResource.isEmpty()) {
+ for (ArtifactDefinition artifactFromResource : artifactsFromResource) {
+ if (artifactFromResource.getArtifactName().equals(artifactFileName)) {
+ artifactUid = artifactFromResource.getUniqueId();
+ artifactUUID = artifactFromResource.getArtifactUUID();
+ if (!artifactFromResource.getArtifactType().equalsIgnoreCase(artifactTemplateInfo.getType())) {
+ log.debug("Artifact with name {} and type {} already exist with type {}", artifactFileName,
+ artifactTemplateInfo.getType(), artifactFromResource.getArtifactType());
+ BeEcompErrorManager.getInstance().logInternalDataError(
+ "Artifact file is not in expected formatr, fileName " + artifactFileName,
+ "Artifact internals are invalid", ErrorSeverity.ERROR);
+ return Either.right(componentsUtils.getResponseFormat(
+ ActionStatus.ARTIFACT_ALRADY_EXIST_IN_DIFFERENT_TYPE_IN_CSAR, artifactFileName,
+ artifactTemplateInfo.getType(), artifactFromResource.getArtifactType()));
+ }
+ alreadyExist = true;
+ artifactEnvUid = checkAndGetHeatEnvId(artifactFromResource);
+ break;
+ }
+
+ }
+
+ }
+ if (!alreadyExist) {
+ for (ArtifactDefinition createdArtifact : createdArtifacts) {
+ if (createdArtifact.getArtifactName().equals(artifactFileName)) {
+ artifactUid = createdArtifact.getUniqueId();
+ artifactUUID = createdArtifact.getArtifactUUID();
+
+ if (!createdArtifact.getArtifactType().equalsIgnoreCase(artifactTemplateInfo.getType())) {
+ log.debug("Artifact with name {} and type {} already exist with type {}", artifactFileName,
+ artifactTemplateInfo.getType(), createdArtifact.getArtifactType());
+ BeEcompErrorManager.getInstance().logInternalDataError(
+ "Artifact file is not in expected formatr, fileName " + artifactFileName,
+ "Artifact internals are invalid", ErrorSeverity.ERROR);
+ return Either.right(componentsUtils.getResponseFormat(
+ ActionStatus.ARTIFACT_ALRADY_EXIST_IN_DIFFERENT_TYPE_IN_CSAR, artifactFileName,
+ artifactTemplateInfo.getType(), createdArtifact.getArtifactType()));
+ }
+ alreadyExist = true;
+ artifactEnvUid = checkAndGetHeatEnvId(createdArtifact);
+ break;
+ }
+
+ }
+ }
+ // if not exist need to create
+ if (!alreadyExist) {
+
+ Either<ArtifactDefinition, ResponseFormat> newArtifactEither = createDeploymentArtifact(csarInfo, resource,
+ ARTIFACTS_PATH, artifactTemplateInfo, createdArtifacts, labelCounter, inTransaction);
+ if (newArtifactEither.isRight()) {
+ resStatus = Either.right(newArtifactEither.right().value());
+ return resStatus;
+ }
+ ArtifactDefinition newArtifact = newArtifactEither.left().value();
+ artifactUid = newArtifact.getUniqueId();
+ artifactUUID = newArtifact.getArtifactUUID();
+ ArtifactTypeEnum artifactType = ArtifactTypeEnum.findType(newArtifact.getArtifactType());
+ if (artifactType == ArtifactTypeEnum.HEAT || artifactType == ArtifactTypeEnum.HEAT_NET
+ || artifactType == ArtifactTypeEnum.HEAT_VOL) {
+ Either<ArtifactDefinition, ResponseFormat> createHeatEnvPlaceHolder = artifactsBusinessLogic
+ .createHeatEnvPlaceHolder(newArtifact, ArtifactsBusinessLogic.HEAT_VF_ENV_NAME,
+ resource.getUniqueId(), NodeTypeEnum.Resource, resource.getName(),
+ csarInfo.getModifier(), resource, null);
+ if (createHeatEnvPlaceHolder.isRight()) {
+ return Either.right(createHeatEnvPlaceHolder.right().value());
+ }
+ artifactEnvUid = createHeatEnvPlaceHolder.left().value().getUniqueId();
+ }
+ }
+
+ artifactsGroup.add(artifactUid);
+ artifactsUUIDGroup.add(artifactUUID);
+ if (!artifactEnvUid.isEmpty()) {
+ artifactsGroup.add(artifactEnvUid);
+ }
+
+ List<ArtifactTemplateInfo> relatedArtifacts = artifactTemplateInfo.getRelatedArtifactsInfo();
+ if (relatedArtifacts != null) {
+ for (ArtifactTemplateInfo relatedArtifactTemplateInfo : relatedArtifacts) {
+ resStatus = createDeploymentArtifactsFromCsar(csarInfo, resource, artifactsGroup, artifactsUUIDGroup,
+ relatedArtifactTemplateInfo, createdArtifacts, artifactsFromResource, labelCounter, shoudLock,
+ inTransaction);
+ if (resStatus.isRight()) {
+ return resStatus;
+ }
+ }
+ }
+ return resStatus;
+ }
+
+ private Either<Resource, ResponseFormat> associateAndDissociateArtifactsToGroup(CsarInfo csarInfo,
+ Resource resource, List<ArtifactDefinition> createdNewArtifacts, int labelCounter, boolean shouldLock,
+ boolean inTransaction, List<ArtifactDefinition> createdDeplymentArtifactsAfterDelete,
+ Map<GroupDefinition, MergedArtifactInfo> mergedgroup, List<ArtifactDefinition> deletedArtifacts) {
+ Map<GroupDefinition, List<ArtifactTemplateInfo>> artifactsToAssotiate = new HashMap<>();
+ Map<GroupDefinition, List<ImmutablePair<ArtifactDefinition, ArtifactTemplateInfo>>> artifactsToUpdateMap = new HashMap<>();
+ Either<Resource, ResponseFormat> resEither = Either.left(resource);
+ for (Entry<GroupDefinition, MergedArtifactInfo> entry : mergedgroup.entrySet()) {
+ List<ArtifactDefinition> dissArtifactsInGroup = entry.getValue()
+ .getListToDissotiateArtifactFromGroup(deletedArtifacts);
+ GroupDefinition grDef = entry.getKey();
+ if (dissArtifactsInGroup != null && !dissArtifactsInGroup.isEmpty()) {
+ for (ArtifactDefinition art : dissArtifactsInGroup) {
+ grDef.getArtifacts().remove(art.getUniqueId());
+ grDef.getArtifactsUuid().remove(art.getArtifactUUID());
+ }
+ }
+
+ List<ArtifactTemplateInfo> newArtifactsInGroup = entry.getValue().getListToAssociateArtifactToGroup();
+ if (newArtifactsInGroup != null && !newArtifactsInGroup.isEmpty()) {
+ artifactsToAssotiate.put(entry.getKey(), newArtifactsInGroup);
+ }
+
+ List<ImmutablePair<ArtifactDefinition, ArtifactTemplateInfo>> artifactsToUpdate = entry.getValue()
+ .getListToUpdateArtifactInGroup();
+ if (artifactsToUpdate != null && !artifactsToUpdate.isEmpty()) {
+ artifactsToUpdateMap.put(entry.getKey(), artifactsToUpdate);
+ }
+ }
+
+ if (!artifactsToUpdateMap.isEmpty()) {
+ List<ArtifactDefinition> updatedArtifacts = new ArrayList<>();
+ for (Entry<GroupDefinition, List<ImmutablePair<ArtifactDefinition, ArtifactTemplateInfo>>> artifactsToUpdateEntry : artifactsToUpdateMap
+ .entrySet()) {
+ List<ImmutablePair<ArtifactDefinition, ArtifactTemplateInfo>> artifactsToUpdateList = artifactsToUpdateEntry
+ .getValue();
+ GroupDefinition groupToUpdate = artifactsToUpdateEntry.getKey();
+
+ for (ImmutablePair<ArtifactDefinition, ArtifactTemplateInfo> artifact : artifactsToUpdateList) {
+ String prevUUID = artifact.getKey().getArtifactUUID();
+ String prevId = artifact.getKey().getUniqueId();
+ String prevHeatEnvId = checkAndGetHeatEnvId(artifact.getKey());
+ Either<ArtifactDefinition, ResponseFormat> updateArtifactEither = updateDeploymentArtifactsFromCsar(
+ csarInfo, resource, artifact.getKey(), artifact.getValue(), updatedArtifacts,
+ artifact.getRight().getRelatedArtifactsInfo());
+ if (updateArtifactEither.isRight()) {
+ log.debug("failed to update artifacts. status is {}", updateArtifactEither.right().value());
+ resEither = Either.right(updateArtifactEither.right().value());
+ return resEither;
+ }
+ ArtifactDefinition artAfterUpdate = updateArtifactEither.left().value();
+ if (!prevUUID.equals(artAfterUpdate.getArtifactUUID())
+ || !prevId.equals(artAfterUpdate.getUniqueId())) {
+ groupToUpdate.getArtifacts().remove(prevId);
+ groupToUpdate.getArtifactsUuid().remove(prevUUID);
+ groupToUpdate.getArtifacts().add(artAfterUpdate.getUniqueId());
+ groupToUpdate.getArtifactsUuid().add(artAfterUpdate.getArtifactUUID());
+ }
+ Optional<ArtifactDefinition> op = updatedArtifacts.stream()
+ .filter(p -> p.getGeneratedFromId() != null
+ && p.getGeneratedFromId().equals(artAfterUpdate.getUniqueId()))
+ .findAny();
+ if (op.isPresent()) {
+ ArtifactDefinition artifactInfoHeatEnv = op.get();
+ groupToUpdate.getArtifacts().remove(prevHeatEnvId);
+ groupToUpdate.getArtifacts().add(artifactInfoHeatEnv.getUniqueId());
+ }
+
+ }
+ }
+ }
+
+ for (Entry<GroupDefinition, List<ArtifactTemplateInfo>> associateEntry : artifactsToAssotiate.entrySet()) {
+ List<ArtifactTemplateInfo> associatedArtifact = associateEntry.getValue();
+ Set<String> arifactsUids = new HashSet<>();
+ Set<String> arifactsUuids = new HashSet<>();
+ for (ArtifactTemplateInfo artifactTemplate : associatedArtifact) { // try
+ // to
+ // find
+ // artifact
+ // in
+ // resource
+ boolean isCreate = true;
+ for (ArtifactDefinition createdArtifact : createdDeplymentArtifactsAfterDelete) {
+ if (artifactTemplate.getFileName().equalsIgnoreCase(createdArtifact.getArtifactName())) {
+ arifactsUids.add(createdArtifact.getUniqueId());
+ arifactsUuids.add(createdArtifact.getArtifactUUID());
+ isCreate = false;
+ String heatEnvId = checkAndGetHeatEnvId(createdArtifact);
+ if (!heatEnvId.isEmpty()) {
+ arifactsUids.add(heatEnvId);
+ Optional<ArtifactDefinition> op = createdDeplymentArtifactsAfterDelete.stream()
+ .filter(p -> p.getUniqueId().equals(heatEnvId)).findAny();
+ if (op.isPresent()) {
+ this.artifactToscaOperation.updateHeatEnvPlaceholder(op.get(), resource.getUniqueId(),
+ resource.getComponentType().getNodeType());
+
+ }
+ }
+
+ break;
+ }
+
+ }
+ if (isCreate) { // check if already created
+ for (ArtifactDefinition createdNewArtifact : createdNewArtifacts) {
+ if (artifactTemplate.getFileName().equalsIgnoreCase(createdNewArtifact.getArtifactName())) {
+ arifactsUids.add(createdNewArtifact.getUniqueId());
+ arifactsUuids.add(createdNewArtifact.getArtifactUUID());
+ isCreate = false;
+ String heatEnvId = checkAndGetHeatEnvId(createdNewArtifact);
+ if (!heatEnvId.isEmpty()) {
+ arifactsUids.add(heatEnvId);
+ }
+ break;
+ }
+ }
+ }
+
+ if (isCreate) {
+ Either<ArtifactDefinition, ResponseFormat> createArtifactEither = createDeploymentArtifact(csarInfo,
+ resource, ARTIFACTS_PATH, artifactTemplate, createdNewArtifacts, labelCounter, inTransaction);
+ if (createArtifactEither.isRight()) {
+ resEither = Either.right(createArtifactEither.right().value());
+ return resEither;
+ }
+ ArtifactDefinition createdArtifact = createArtifactEither.left().value();
+ arifactsUids.add(createdArtifact.getUniqueId());
+ arifactsUuids.add(createdArtifact.getArtifactUUID());
+ ArtifactTypeEnum artifactType = ArtifactTypeEnum.findType(createdArtifact.getArtifactType());
+ if (artifactType == ArtifactTypeEnum.HEAT || artifactType == ArtifactTypeEnum.HEAT_NET
+ || artifactType == ArtifactTypeEnum.HEAT_VOL) {
+ Either<ArtifactDefinition, ResponseFormat> createHeatEnvPlaceHolder = artifactsBusinessLogic
+ .createHeatEnvPlaceHolder(createdArtifact, ArtifactsBusinessLogic.HEAT_VF_ENV_NAME,
+ resource.getUniqueId(), NodeTypeEnum.Resource, resource.getName(),
+ csarInfo.getModifier(), resource, null);
+ if (createHeatEnvPlaceHolder.isRight()) {
+ return Either.right(createHeatEnvPlaceHolder.right().value());
+ }
+ String heatEnvId = createHeatEnvPlaceHolder.left().value().getUniqueId();
+ arifactsUids.add(heatEnvId);
+ }
+ }
+
+ }
+ if (arifactsUids != null && !arifactsUids.isEmpty()) {
+ List<String> artifactsToAssociate = new ArrayList<>();
+ artifactsToAssociate.addAll(arifactsUids);
+ GroupDefinition assotiateGroup = associateEntry.getKey();
+ assotiateGroup.getArtifacts().addAll(arifactsUids);
+ assotiateGroup.getArtifactsUuid().addAll(arifactsUuids);
+ }
+ }
+
+ ComponentParametersView parametersView = new ComponentParametersView();
+ parametersView.disableAll();
+ parametersView.setIgnoreComponentInstances(false);
+ parametersView.setIgnoreUsers(false);
+ parametersView.setIgnoreArtifacts(false);
+ parametersView.setIgnoreGroups(false);
+
+ Either<Resource, StorageOperationStatus> eitherGerResource = toscaOperationFacade
+ .getToscaElement(resource.getUniqueId(), parametersView);
+
+ if (eitherGerResource.isRight()) {
+ ResponseFormat responseFormat = componentsUtils.getResponseFormatByResource(
+ componentsUtils.convertFromStorageResponse(eitherGerResource.right().value()), resource);
+
+ resEither = Either.right(responseFormat);
+ return resEither;
+
+ }
+ resEither = Either.left(eitherGerResource.left().value());
+ return resEither;
+ }
+
+ private Either<ArtifactDefinition, ResponseFormat> updateDeploymentArtifactsFromCsar(CsarInfo csarInfo,
+ Resource resource, ArtifactDefinition oldArtifact, ArtifactTemplateInfo artifactTemplateInfo,
+ List<ArtifactDefinition> updatedArtifacts, List<ArtifactTemplateInfo> updatedRequiredArtifacts) {
+
+ Either<ArtifactDefinition, ResponseFormat> resStatus = null;
+ String artifactFileName = artifactTemplateInfo.getFileName();
+
+ // check if artifacts already exist
+ for (ArtifactDefinition updatedArtifact : updatedArtifacts) {
+ if (updatedArtifact.getArtifactName().equals(artifactFileName)) {
+ if (!updatedArtifact.getArtifactType().equalsIgnoreCase(artifactTemplateInfo.getType())) {
+ log.debug("Artifact with name {} and type {} already updated with type {}", artifactFileName,
+ artifactTemplateInfo.getType(), updatedArtifact.getArtifactType());
+ BeEcompErrorManager.getInstance().logInternalDataError(
+ "Artifact file is not in expected formatr, fileName " + artifactFileName,
+ "Artifact internals are invalid", ErrorSeverity.ERROR);
+ resStatus = Either.right(componentsUtils.getResponseFormat(
+ ActionStatus.ARTIFACT_ALRADY_EXIST_IN_DIFFERENT_TYPE_IN_CSAR, artifactFileName,
+ artifactTemplateInfo.getType(), updatedArtifact.getArtifactType()));
+ return resStatus;
+ }
+ resStatus = Either.left(updatedArtifact);
+ return resStatus;
+ }
+
+ }
+
+ Either<ImmutablePair<String, byte[]>, ResponseFormat> artifactContententStatus = CsarValidationUtils
+ .getArtifactsContent(csarInfo.getCsarUUID(), csarInfo.getCsar(),
+ CsarUtils.ARTIFACTS_PATH + artifactFileName, artifactFileName, componentsUtils);
+ if (artifactContententStatus.isRight()) {
+ resStatus = Either.right(artifactContententStatus.right().value());
+ return resStatus;
+ }
+
+ Map<String, Object> json = ArtifactUtils.buildJsonForUpdateArtifact(oldArtifact.getUniqueId(), artifactFileName,
+ oldArtifact.getArtifactType(), ArtifactGroupTypeEnum.DEPLOYMENT, oldArtifact.getArtifactLabel(),
+ oldArtifact.getArtifactDisplayName(), oldArtifact.getDescription(),
+ artifactContententStatus.left().value().getRight(), updatedRequiredArtifacts, oldArtifact.getIsFromCsar());
+
+ Either<Either<ArtifactDefinition, Operation>, ResponseFormat> uploadArtifactToService = createOrUpdateCsarArtifactFromJson(
+ resource, csarInfo.getModifier(), json,
+ artifactsBusinessLogic.new ArtifactOperationInfo(false, false, ArtifactOperationEnum.UPDATE));
+
+ if (uploadArtifactToService.isRight()) {
+ resStatus = Either.right(uploadArtifactToService.right().value());
+ return resStatus;
+ }
+ ArtifactDefinition currentInfo = uploadArtifactToService.left().value().left().value();
+ updatedArtifacts.add(currentInfo);
+
+ Either<ArtifactDefinition, ResponseFormat> updateEnvEither = updateHeatParamsFromCsar(resource, csarInfo,
+ artifactTemplateInfo, currentInfo, true);
+ if (updateEnvEither.isRight()) {
+ log.debug("failed to update parameters to artifact {}", artifactFileName);
+ resStatus = Either.right(updateEnvEither.right().value());
+ return resStatus;
+ }
+
+ updatedArtifacts.add(updateEnvEither.left().value());
+ resStatus = Either.left(currentInfo);
+
+ return resStatus;
+
+ }
+
+ public Either<Resource, ResponseFormat> deleteVFModules(Resource resource, CsarInfo csarInfo, boolean shouldLock, boolean inTransaction) {
+ Resource updatedResource = resource;
+ List<GroupDefinition> groupsToDelete = updatedResource.getGroups();
+ if(groupsToDelete != null && !groupsToDelete.isEmpty()){
+ List<GroupDefinition> vfGroupsToDelete = groupsToDelete.stream().filter(g -> g.getType().equals(Constants.DEFAULT_GROUP_VF_MODULE)).collect(Collectors.toList());
+ if(vfGroupsToDelete != null && !vfGroupsToDelete.isEmpty()){
+ for(GroupDefinition gr : vfGroupsToDelete){
+ List<String> artifacts = gr.getArtifacts();
+ for (String artifactId : artifacts) {
+ Either<Either<ArtifactDefinition, Operation>, ResponseFormat> handleDelete = artifactsBusinessLogic.handleDelete(updatedResource.getUniqueId(), artifactId, csarInfo.getModifier(), AuditingActionEnum.ARTIFACT_DELETE, ComponentTypeEnum.RESOURCE,
+ updatedResource, shouldLock, inTransaction);
+ if (handleDelete.isRight()) {
+ log.debug("Couldn't delete artifact {}", artifactId);
+ return Either.right(handleDelete.right().value());
+ }
+ }
+
+ }
+ groupBusinessLogic.deleteGroups(updatedResource, vfGroupsToDelete);
+
+ Either<Resource, StorageOperationStatus> eitherGetResource = toscaOperationFacade.getToscaElement(updatedResource.getUniqueId());
+ if (eitherGetResource.isRight()) {
+ ResponseFormat responseFormat = componentsUtils.getResponseFormatByResource(componentsUtils.convertFromStorageResponse(eitherGetResource.right().value()), updatedResource);
+
+ return Either.right(responseFormat);
+
+ }
+ updatedResource = eitherGetResource.left().value();
+ }
+ }
+ return Either.left(updatedResource);
+ }
+
+ private Either<Resource, ResponseFormat> getResourcetFromGraph(Resource component){
+ log.debug("getResource start");
+ return toscaOperationFacade.getToscaElement(component.getUniqueId())
+ .right()
+ .map(rf -> componentsUtils.getResponseFormatByResource(componentsUtils.convertFromStorageResponse(rf), component))
+ .left()
+ .map (c -> (Resource) c);
+
+
+ }
+
+}