diff options
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.java | 1681 |
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); + + + } + +} |