summaryrefslogtreecommitdiffstats
path: root/catalog-be/src/main/java/org/openecomp/sdc/be/components/impl/GroupBusinessLogic.java
diff options
context:
space:
mode:
Diffstat (limited to 'catalog-be/src/main/java/org/openecomp/sdc/be/components/impl/GroupBusinessLogic.java')
-rw-r--r--catalog-be/src/main/java/org/openecomp/sdc/be/components/impl/GroupBusinessLogic.java616
1 files changed, 272 insertions, 344 deletions
diff --git a/catalog-be/src/main/java/org/openecomp/sdc/be/components/impl/GroupBusinessLogic.java b/catalog-be/src/main/java/org/openecomp/sdc/be/components/impl/GroupBusinessLogic.java
index fe9d44837b..fee80c65c1 100644
--- a/catalog-be/src/main/java/org/openecomp/sdc/be/components/impl/GroupBusinessLogic.java
+++ b/catalog-be/src/main/java/org/openecomp/sdc/be/components/impl/GroupBusinessLogic.java
@@ -19,10 +19,26 @@
* Modifications copyright (c) 2019 Nokia
* ================================================================================
*/
-
package org.openecomp.sdc.be.components.impl;
+import static java.util.stream.Collectors.toList;
+import static org.openecomp.sdc.be.model.jsonjanusgraph.utils.ModelConverter.extractCapabilitiesFromGroups;
+import static org.openecomp.sdc.be.model.jsonjanusgraph.utils.ModelConverter.extractCapabilityPropertiesFromGroups;
+
import fj.data.Either;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.EnumMap;
+import java.util.HashMap;
+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.Pattern;
+import java.util.stream.Collectors;
import org.apache.commons.collections.CollectionUtils;
import org.apache.commons.collections.MapUtils;
import org.apache.commons.io.FilenameUtils;
@@ -89,68 +105,47 @@ import org.openecomp.sdc.common.util.ValidationUtils;
import org.openecomp.sdc.exception.ResponseFormat;
import org.springframework.beans.factory.annotation.Autowired;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.EnumMap;
-import java.util.HashMap;
-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.Pattern;
-import java.util.stream.Collectors;
-
-import static java.util.stream.Collectors.toList;
-import static org.openecomp.sdc.be.model.jsonjanusgraph.utils.ModelConverter.extractCapabilitiesFromGroups;
-import static org.openecomp.sdc.be.model.jsonjanusgraph.utils.ModelConverter.extractCapabilityPropertiesFromGroups;
-
@org.springframework.stereotype.Component("groupBusinessLogic")
public class GroupBusinessLogic extends BaseBusinessLogic {
public static final String GROUP_DELIMITER_REGEX = "\\.\\.";
-
public static final String INITIAL_VERSION = "0.0";
-
private static final String ADDING_GROUP = "AddingGroup";
-
private static final String CREATE_GROUP = "CreateGroup";
-
private static final String UPDATE_GROUP = "UpdateGroup";
-
private static final String GET_GROUP = "GetGroup";
-
private static final String DELETE_GROUP = "DeleteGroup";
-
private static final Logger log = Logger.getLogger(GroupBusinessLogic.class);
-
private static final LoggerSupportability loggerSupportability = LoggerSupportability.getLogger(GroupBusinessLogic.class.getName());
-
private final AccessValidations accessValidations;
private final PolicyTargetsUpdateHandler policyTargetsUpdateHandler;
-
@javax.annotation.Resource
private final GroupsOperation groupsOperation;
-
@Autowired
- public GroupBusinessLogic(IElementOperation elementDao,
- IGroupOperation groupOperation,
- IGroupInstanceOperation groupInstanceOperation,
- IGroupTypeOperation groupTypeOperation,
- InterfaceOperation interfaceOperation,
- InterfaceLifecycleOperation interfaceLifecycleTypeOperation, AccessValidations accessValidations,
- GroupsOperation groupsOperation, PolicyTargetsUpdateHandler policyTargetsUpdateHandler,
- ArtifactsOperations artifactToscaOperation) {
- super(elementDao, groupOperation, groupInstanceOperation, groupTypeOperation,
- interfaceOperation, interfaceLifecycleTypeOperation, artifactToscaOperation);
+ public GroupBusinessLogic(IElementOperation elementDao, IGroupOperation groupOperation, IGroupInstanceOperation groupInstanceOperation,
+ IGroupTypeOperation groupTypeOperation, InterfaceOperation interfaceOperation,
+ InterfaceLifecycleOperation interfaceLifecycleTypeOperation, AccessValidations accessValidations,
+ GroupsOperation groupsOperation, PolicyTargetsUpdateHandler policyTargetsUpdateHandler,
+ ArtifactsOperations artifactToscaOperation) {
+ super(elementDao, groupOperation, groupInstanceOperation, groupTypeOperation, interfaceOperation, interfaceLifecycleTypeOperation,
+ artifactToscaOperation);
this.accessValidations = accessValidations;
this.groupsOperation = groupsOperation;
this.policyTargetsUpdateHandler = policyTargetsUpdateHandler;
}
+ private static boolean groupExistsInComponent(String groupDefinitionName, Component component) {
+ boolean found = false;
+ List<GroupDefinition> groups = component.getGroups();
+ if (CollectionUtils.isNotEmpty(groups)) {
+ found = groups.stream()
+ .filter(p -> (p.getName().equalsIgnoreCase(groupDefinitionName)) || p.getInvariantName().equalsIgnoreCase(groupDefinitionName))
+ .findFirst().orElse(null) != null;
+ }
+ return found;
+ }
+
private String getComponentTypeForResponse(org.openecomp.sdc.be.model.Component component) {
String componentTypeForResponse = "SERVICE";
if (component instanceof Resource) {
@@ -167,26 +162,23 @@ public class GroupBusinessLogic extends BaseBusinessLogic {
* @return
*/
private Either<Boolean, ResponseFormat> verifyArtifactsBelongsToComponent(Component component, List<String> artifacts, String context) {
-
if (CollectionUtils.isEmpty(artifacts)) {
return Either.left(true);
}
-
Map<String, ArtifactDefinition> deploymentArtifacts = component.getDeploymentArtifacts();
if (MapUtils.isEmpty(deploymentArtifacts)) {
- BeEcompErrorManager.getInstance().logInvalidInputError(context, "No deployment artifact found under component " + component.getNormalizedName(), ErrorSeverity.INFO);
+ BeEcompErrorManager.getInstance()
+ .logInvalidInputError(context, "No deployment artifact found under component " + component.getNormalizedName(), ErrorSeverity.INFO);
return Either.right(componentsUtils.getResponseFormat(ActionStatus.INVALID_CONTENT));
}
-
List<String> currentArtifacts = deploymentArtifacts.values().stream().map(ArtifactDefinition::getUniqueId).collect(toList());
log.debug("The deployment artifacts of component {} are {}", component.getNormalizedName(), deploymentArtifacts);
if (!currentArtifacts.containsAll(artifacts)) {
- BeEcompErrorManager.getInstance().logInvalidInputError(context, "Not all artifacts belongs to component " + component.getNormalizedName(), ErrorSeverity.INFO);
+ BeEcompErrorManager.getInstance()
+ .logInvalidInputError(context, "Not all artifacts belongs to component " + component.getNormalizedName(), ErrorSeverity.INFO);
return Either.right(componentsUtils.getResponseFormat(ActionStatus.INVALID_CONTENT));
}
-
return Either.left(true);
-
}
/**
@@ -197,43 +189,38 @@ public class GroupBusinessLogic extends BaseBusinessLogic {
* @param memberToscaTypes
* @return
*/
- private Either<Boolean, ResponseFormat> verifyComponentInstancesAreValidMembers(Component component, String groupName, Map<String, String> groupMembers, List<String> memberToscaTypes) {
-
+ private Either<Boolean, ResponseFormat> verifyComponentInstancesAreValidMembers(Component component, String groupName,
+ Map<String, String> groupMembers, List<String> memberToscaTypes) {
if (MapUtils.isEmpty(groupMembers)) {
return Either.left(true);
}
-
if (CollectionUtils.isEmpty(memberToscaTypes)) {
return Either.left(true);
}
-
List<ComponentInstance> componentInstances = component.getComponentInstances();
if (CollectionUtils.isNotEmpty(componentInstances)) {
- Map<String, ComponentInstance> compInstUidToCompInstMap = componentInstances.stream().collect(Collectors.toMap(ComponentInstance::getUniqueId, p -> p));
-
+ Map<String, ComponentInstance> compInstUidToCompInstMap = componentInstances.stream()
+ .collect(Collectors.toMap(ComponentInstance::getUniqueId, p -> p));
Set<String> allCompInstances = compInstUidToCompInstMap.keySet();
-
for (Entry<String, String> groupMember : groupMembers.entrySet()) {
String compName = groupMember.getKey();
String compUid = groupMember.getValue();
-
if (!allCompInstances.contains(compUid)) {
/*
* %1 - member name %2 - group name %3 - VF name %4 - component type [VF ]
*/
String componentTypeForResponse = getComponentTypeForResponse(component);
-
- BeEcompErrorManager.getInstance().logInvalidInputError(CREATE_GROUP, "Not all group members exists under the component", ErrorSeverity.INFO);
- return Either.right(componentsUtils.getResponseFormat(ActionStatus.GROUP_INVALID_COMPONENT_INSTANCE, compName, groupName, component.getNormalizedName(), componentTypeForResponse));
+ BeEcompErrorManager.getInstance()
+ .logInvalidInputError(CREATE_GROUP, "Not all group members exists under the component", ErrorSeverity.INFO);
+ return Either.right(componentsUtils
+ .getResponseFormat(ActionStatus.GROUP_INVALID_COMPONENT_INSTANCE, compName, groupName, component.getNormalizedName(),
+ componentTypeForResponse));
}
}
}
-
return Either.left(true);
}
-
-
/**
* Update GroupDefinition metadata
*
@@ -244,8 +231,9 @@ public class GroupBusinessLogic extends BaseBusinessLogic {
* @param inTransaction
* @return
*/
- public Either<GroupDefinition, ResponseFormat> validateAndUpdateGroupMetadata(String componentId, User user, ComponentTypeEnum componentType, GroupDefinition updatedGroup, boolean inTransaction , boolean shouldLock) {
-
+ public Either<GroupDefinition, ResponseFormat> validateAndUpdateGroupMetadata(String componentId, User user, ComponentTypeEnum componentType,
+ GroupDefinition updatedGroup, boolean inTransaction,
+ boolean shouldLock) {
Either<GroupDefinition, ResponseFormat> result = null;
boolean failed = false;
try {
@@ -257,35 +245,40 @@ public class GroupBusinessLogic extends BaseBusinessLogic {
validateCanWorkOnComponent(component, user.getUserId());
List<GroupDefinition> currentGroups = component.getGroups();
if (CollectionUtils.isEmpty(currentGroups)) {
- log.error("Failed to update the metadata of group {} on component {}. The status is {}. ", updatedGroup.getName(), component.getName(), ActionStatus.GROUP_IS_MISSING);
- result = Either.right(componentsUtils.getResponseFormat(ActionStatus.GROUP_IS_MISSING, updatedGroup.getName(), component.getName(), component.getComponentType().getValue()));
+ log.error("Failed to update the metadata of group {} on component {}. The status is {}. ", updatedGroup.getName(),
+ component.getName(), ActionStatus.GROUP_IS_MISSING);
+ result = Either.right(componentsUtils.getResponseFormat(ActionStatus.GROUP_IS_MISSING, updatedGroup.getName(), component.getName(),
+ component.getComponentType().getValue()));
return result;
}
// Validate groups exists in the component
- Optional<GroupDefinition> currentGroupOpt = currentGroups.stream().filter(g -> g.getUniqueId().equals(updatedGroup.getUniqueId())).findAny();
+ Optional<GroupDefinition> currentGroupOpt = currentGroups.stream().filter(g -> g.getUniqueId().equals(updatedGroup.getUniqueId()))
+ .findAny();
if (!currentGroupOpt.isPresent()) {
- log.error("Failed to update the metadata of group {} on component {}. The status is {}. ", updatedGroup.getName(), component.getName(), ActionStatus.GROUP_IS_MISSING);
- result = Either.right(componentsUtils.getResponseFormat(ActionStatus.GROUP_IS_MISSING, updatedGroup.getName(), component.getName(), component.getComponentType().getValue()));
+ log.error("Failed to update the metadata of group {} on component {}. The status is {}. ", updatedGroup.getName(),
+ component.getName(), ActionStatus.GROUP_IS_MISSING);
+ result = Either.right(componentsUtils.getResponseFormat(ActionStatus.GROUP_IS_MISSING, updatedGroup.getName(), component.getName(),
+ component.getComponentType().getValue()));
return result;
}
GroupDefinition currentGroup = currentGroupOpt.get();
- if ( shouldLock ){
+ if (shouldLock) {
lockComponent(componentId, component, "Update GroupDefinition Metadata");
}
// Validate group type is vfModule
if (currentGroup.getType().equals(Constants.GROUP_TOSCA_HEAT)) {
- log.error("Failed to update the metadata of group {}. Group type is {} and cannot be updated", currentGroup.getName(), currentGroup.getType());
+ log.error("Failed to update the metadata of group {}. Group type is {} and cannot be updated", currentGroup.getName(),
+ currentGroup.getType());
ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.GROUP_TYPE_IS_INVALID, updatedGroup.getType());
result = Either.right(responseFormat);
return result;
}
result = updateGroupMetadata(component, currentGroup, updatedGroup);
return result;
-
- }catch (ComponentException e){
+ } catch (ComponentException e) {
failed = true;
throw e;
- }finally {
+ } finally {
if (!failed) {
janusGraphDao.commit();
} else {
@@ -297,10 +290,10 @@ public class GroupBusinessLogic extends BaseBusinessLogic {
}
}
- private Either<GroupDefinition, ResponseFormat> updateGroupMetadata(Component component, GroupDefinition currentGroup, GroupDefinition updatedGroup) {
+ private Either<GroupDefinition, ResponseFormat> updateGroupMetadata(Component component, GroupDefinition currentGroup,
+ GroupDefinition updatedGroup) {
String currentGroupName = currentGroup.getName();
Either<GroupDefinition, ResponseFormat> result = validateAndUpdateGroupMetadata(currentGroup, updatedGroup);
-
if (result.isRight()) {
log.debug("Failed to validate a metadata of the group {} on component {}. ", updatedGroup.getName(), component.getName());
}
@@ -338,14 +331,12 @@ public class GroupBusinessLogic extends BaseBusinessLogic {
ResponseFormat errorResponse = response.right().value();
return Either.right(errorResponse);
}
-
// Do not allow to update GroupDefinition version directly.
String versionUpdated = groupUpdate.getVersion();
String versionCurrent = currentGroup.getVersion();
if (versionUpdated != null && !versionCurrent.equals(versionUpdated)) {
log.info("update Group: recived request to update version to {} the field is not updatable ignoring.", versionUpdated);
}
-
return Either.left(currentGroup);
}
@@ -360,7 +351,7 @@ public class GroupBusinessLogic extends BaseBusinessLogic {
String nameUpdated = groupUpdate.getName();
String nameCurrent = currentGroup.getName();
if (!nameCurrent.equals(nameUpdated)) {
- Either<Boolean, ResponseFormat> validatNameResponse = validateGroupName(currentGroup.getName(), groupUpdate.getName() ,true);
+ Either<Boolean, ResponseFormat> validatNameResponse = validateGroupName(currentGroup.getName(), groupUpdate.getName(), true);
if (validatNameResponse.isRight()) {
ResponseFormat errorRespons = validatNameResponse.right().value();
return Either.right(errorRespons);
@@ -371,44 +362,41 @@ public class GroupBusinessLogic extends BaseBusinessLogic {
}
/**
- * Validate that group name to update is valid (same as current group name except for middle part). For example: Current group name: MyResource..MyDesc..Module-1 Group to update: MyResource..MyDesc2..Module-1 Verify that only the second part
- * MyDesc was changed.
+ * Validate that group name to update is valid (same as current group name except for middle part). For example: Current group name:
+ * MyResource..MyDesc..Module-1 Group to update: MyResource..MyDesc2..Module-1 Verify that only the second part MyDesc was changed.
*
* @param currentGroupName
* @param groupUpdateName
* @return
*/
- private Either<Boolean, ResponseFormat> validateGroupName(String currentGroupName, String groupUpdateName , boolean isforceNameModification) {
+ private Either<Boolean, ResponseFormat> validateGroupName(String currentGroupName, String groupUpdateName, boolean isforceNameModification) {
try {
// Check if the group name is in old format.
if (Pattern.compile(Constants.MODULE_OLD_NAME_PATTERN).matcher(groupUpdateName).matches()) {
log.error("Group name {} is in old format", groupUpdateName);
return Either.right(componentsUtils.getResponseFormat(ActionStatus.INVALID_VF_MODULE_NAME, groupUpdateName));
}
-
// Check that name pats 1 and 3 did not changed (only the second
+
// part can be changed)
+
// But verify before that the current group format is the new one
if (!Pattern.compile(Constants.MODULE_OLD_NAME_PATTERN).matcher(currentGroupName).matches()) {
String[] split1 = currentGroupName.split(GROUP_DELIMITER_REGEX);
String currentResourceName = split1[0];
String currentCounter = split1[2];
-
String[] split2 = groupUpdateName.split(GROUP_DELIMITER_REGEX);
String groupUpdateResourceName = split2[0];
String groupUpdateCounter = split2[2];
- if (!isforceNameModification){ //if not forced ,allow name prefix&suffix validation [no changes]
+ if (!isforceNameModification) { //if not forced ,allow name prefix&suffix validation [no changes]
if (!currentResourceName.equals(groupUpdateResourceName)) {
return Either.right(componentsUtils.getResponseFormat(ActionStatus.INVALID_VF_MODULE_NAME_MODIFICATION, currentResourceName));
}
-
if (!currentCounter.equals(groupUpdateCounter)) {
return Either.right(componentsUtils.getResponseFormat(ActionStatus.INVALID_VF_MODULE_NAME_MODIFICATION, currentCounter));
}
}
-
}
-
return Either.left(true);
} catch (Exception e) {
log.error("Error valiadting group name", e);
@@ -416,7 +404,6 @@ public class GroupBusinessLogic extends BaseBusinessLogic {
}
}
-
/**
* associate artifacts to a given group
*
@@ -426,59 +413,54 @@ public class GroupBusinessLogic extends BaseBusinessLogic {
* @param inTransaction
* @return
*/
- public Either<GroupDefinitionInfo, ResponseFormat> getGroupWithArtifactsById(ComponentTypeEnum componentType, String componentId, String groupId, String userId, boolean inTransaction) {
-
+ public Either<GroupDefinitionInfo, ResponseFormat> getGroupWithArtifactsById(ComponentTypeEnum componentType, String componentId, String groupId,
+ String userId, boolean inTransaction) {
Either<GroupDefinitionInfo, ResponseFormat> result = null;
-
// Validate user exist
validateUserExists(userId);
// Validate component exist
org.openecomp.sdc.be.model.Component component = null;
-
try {
ComponentParametersView componentParametersView = new ComponentParametersView();
componentParametersView.disableAll();
componentParametersView.setIgnoreGroups(false);
componentParametersView.setIgnoreArtifacts(false);
componentParametersView.setIgnoreUsers(false);
-
component = validateComponentExists(componentId, componentType, componentParametersView);
-
Either<GroupDefinition, StorageOperationStatus> groupEither = findGroupOnComponent(component, groupId);
-
if (groupEither.isRight()) {
log.debug("Failed to find group {} under component {}", groupId, component.getUniqueId());
- BeEcompErrorManager.getInstance().logInvalidInputError(GET_GROUP, "group " + groupId + " not found under component " + component.getUniqueId(), ErrorSeverity.INFO);
+ BeEcompErrorManager.getInstance()
+ .logInvalidInputError(GET_GROUP, "group " + groupId + " not found under component " + component.getUniqueId(),
+ ErrorSeverity.INFO);
String componentTypeForResponse = getComponentTypeForResponse(component);
- result = Either.right(componentsUtils.getResponseFormat(ActionStatus.GROUP_IS_MISSING, groupId, component.getSystemName(), componentTypeForResponse));
+ result = Either.right(
+ componentsUtils.getResponseFormat(ActionStatus.GROUP_IS_MISSING, groupId, component.getSystemName(), componentTypeForResponse));
return result;
}
GroupDefinition group = groupEither.left().value();
-
List<GroupProperty> props = group.convertToGroupProperties();
Boolean isBase = isBaseProp(component, props);
-
List<ArtifactDefinitionInfo> artifacts = new ArrayList<>();
List<ArtifactDefinition> artifactsFromComponent = new ArrayList<>();
List<String> artifactsIds = group.getArtifacts();
-
Map<String, ArtifactDefinition> deploymentArtifacts = null;
if (MapUtils.isNotEmpty(component.getDeploymentArtifacts())) {
- deploymentArtifacts = component.getDeploymentArtifacts().values().stream().collect(Collectors.toMap(ArtifactDataDefinition::getUniqueId, a -> a));
+ deploymentArtifacts = component.getDeploymentArtifacts().values().stream()
+ .collect(Collectors.toMap(ArtifactDataDefinition::getUniqueId, a -> a));
}
-
if (artifactsIds != null && !artifactsIds.isEmpty()) {
for (String id : artifactsIds) {
if (deploymentArtifacts == null || !deploymentArtifacts.containsKey(id)) {
log.debug("Failed to get artifact {} . Status is {} ", id, StorageOperationStatus.NOT_FOUND);
- ResponseFormat responseFormat = componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(StorageOperationStatus.NOT_FOUND));
+ ResponseFormat responseFormat = componentsUtils
+ .getResponseFormat(componentsUtils.convertFromStorageResponse(StorageOperationStatus.NOT_FOUND));
result = Either.right(responseFormat);
return result;
}
artifactsFromComponent.add(deploymentArtifacts.get(id));
}
addArtifactsToList(artifacts, artifactsFromComponent);
-
}
GroupDefinitionInfo resultInfo = new GroupDefinitionInfo(group);
resultInfo.setIsBase(isBase);
@@ -486,17 +468,14 @@ public class GroupBusinessLogic extends BaseBusinessLogic {
resultInfo.setArtifacts(artifacts);
}
result = Either.left(resultInfo);
-
return result;
-
} finally {
closeTransaction(inTransaction, result);
}
-
}
private void addArtifactsToList(List<ArtifactDefinitionInfo> artifacts, List<ArtifactDefinition> artifactsFromComponent) {
- artifactsFromComponent.forEach(a-> artifacts.add(new ArtifactDefinitionInfo(a)));
+ artifactsFromComponent.forEach(a -> artifacts.add(new ArtifactDefinitionInfo(a)));
}
private Boolean isBaseProp(Component component, List<GroupProperty> props) {
@@ -506,16 +485,15 @@ public class GroupBusinessLogic extends BaseBusinessLogic {
if (isBasePropOp.isPresent()) {
GroupProperty propIsBase = isBasePropOp.get();
isBase = Boolean.parseBoolean(propIsBase.getValue());
-
} else {
- BeEcompErrorManager.getInstance().logInvalidInputError(GET_GROUP, "failed to find prop isBase " + component.getNormalizedName(), ErrorSeverity.INFO);
+ BeEcompErrorManager.getInstance()
+ .logInvalidInputError(GET_GROUP, "failed to find prop isBase " + component.getNormalizedName(), ErrorSeverity.INFO);
}
}
return isBase;
}
private Either<GroupDefinition, StorageOperationStatus> findGroupOnComponent(Component component, String groupId) {
-
Either<GroupDefinition, StorageOperationStatus> result = null;
if (CollectionUtils.isNotEmpty(component.getGroups())) {
Optional<GroupDefinition> foundGroup = component.getGroups().stream().filter(g -> g.getUniqueId().equals(groupId)).findFirst();
@@ -529,11 +507,13 @@ public class GroupBusinessLogic extends BaseBusinessLogic {
return result;
}
- public Either<Boolean, ResponseFormat> validateGenerateVfModuleGroupNames(List<ArtifactTemplateInfo> allGroups, String resourceSystemName, int startGroupCounter) {
+ public Either<Boolean, ResponseFormat> validateGenerateVfModuleGroupNames(List<ArtifactTemplateInfo> allGroups, String resourceSystemName,
+ int startGroupCounter) {
Either<Boolean, ResponseFormat> validateGenerateGroupNamesRes = Either.left(true);
Collections.sort(allGroups, ArtifactTemplateInfo::compareByGroupName);
for (ArtifactTemplateInfo group : allGroups) {
- Either<String, ResponseFormat> validateGenerateGroupNameRes = validateGenerateVfModuleGroupName(resourceSystemName, group.getDescription(), startGroupCounter++);
+ Either<String, ResponseFormat> validateGenerateGroupNameRes = validateGenerateVfModuleGroupName(resourceSystemName,
+ group.getDescription(), startGroupCounter++);
if (validateGenerateGroupNameRes.isRight()) {
validateGenerateGroupNamesRes = Either.right(validateGenerateGroupNameRes.right().value());
break;
@@ -555,7 +535,8 @@ public class GroupBusinessLogic extends BaseBusinessLogic {
Either<String, ResponseFormat> validateGenerateGroupNameRes;
if (resourceSystemName != null && description != null && Pattern.compile(Constants.MODULE_DESC_PATTERN).matcher(description).matches()) {
final String fileName = description.replaceAll(GROUP_DELIMITER_REGEX, "\\.");
- validateGenerateGroupNameRes = Either.left(String.format(Constants.MODULE_NAME_FORMAT, resourceSystemName, FilenameUtils.removeExtension(fileName), groupCounter));
+ validateGenerateGroupNameRes = Either
+ .left(String.format(Constants.MODULE_NAME_FORMAT, resourceSystemName, FilenameUtils.removeExtension(fileName), groupCounter));
} else {
validateGenerateGroupNameRes = Either.right(componentsUtils.getResponseFormat(ActionStatus.INVALID_VF_MODULE_NAME));
}
@@ -563,7 +544,6 @@ public class GroupBusinessLogic extends BaseBusinessLogic {
}
Either<Map<String, GroupDefinition>, ResponseFormat> validateUpdateVfGroupNames(Map<String, GroupDefinition> groups, String resourceSystemName) {
-
Map<String, GroupDefinition> updatedNamesGroups = new HashMap<>();
Either<Map<String, GroupDefinition>, ResponseFormat> result = Either.left(updatedNamesGroups);
for (Entry<String, GroupDefinition> groupEntry : groups.entrySet()) {
@@ -573,8 +553,8 @@ public class GroupBusinessLogic extends BaseBusinessLogic {
int counter;
String description;
Either<String, ResponseFormat> newGroupNameRes;
- if (groupType.equals(Constants.DEFAULT_GROUP_VF_MODULE) && !Pattern.compile(Constants.MODULE_NEW_NAME_PATTERN).matcher(groupName).matches()) {
-
+ if (groupType.equals(Constants.DEFAULT_GROUP_VF_MODULE) && !Pattern.compile(Constants.MODULE_NEW_NAME_PATTERN).matcher(groupName)
+ .matches()) {
if (Pattern.compile(Constants.MODULE_OLD_NAME_PATTERN).matcher(groupEntry.getKey()).matches()) {
counter = Integer.parseInt(groupEntry.getKey().split(Constants.MODULE_NAME_DELIMITER)[1]);
description = curGroup.getDescription();
@@ -585,7 +565,8 @@ public class GroupBusinessLogic extends BaseBusinessLogic {
newGroupNameRes = validateGenerateVfModuleGroupName(resourceSystemName, description, counter);
if (newGroupNameRes.isRight()) {
log.debug("Failed to generate new vf module group name. Status is {} ", newGroupNameRes.right().value());
- loggerSupportability.log(LogLevel.INFO,LoggerSupportabilityActions.CREATE_RESOURCE_FROM_YAML.getName(),StatusCode.ERROR.name(),"Failed to generate new vf module group name. Status is: "+newGroupNameRes.right().value());
+ loggerSupportability.log(LogLevel.INFO, LoggerSupportabilityActions.CREATE_RESOURCE_FROM_YAML.getName(), StatusCode.ERROR.name(),
+ "Failed to generate new vf module group name. Status is: " + newGroupNameRes.right().value());
result = Either.right(newGroupNameRes.right().value());
break;
}
@@ -608,8 +589,10 @@ public class GroupBusinessLogic extends BaseBusinessLogic {
public int getNextVfModuleNameCounter(Collection<GroupDefinition> groups) {
int counter = 0;
if (groups != null && !groups.isEmpty()) {
- List<Integer> counters = groups.stream().filter(group -> Pattern.compile(Constants.MODULE_NEW_NAME_PATTERN).matcher(group.getName()).matches() || Pattern.compile(Constants.MODULE_OLD_NAME_PATTERN).matcher(group.getName()).matches())
- .map(group -> Integer.parseInt(group.getName().split(Constants.MODULE_NAME_DELIMITER)[1])).collect(toList());
+ List<Integer> counters = groups.stream().filter(
+ group -> Pattern.compile(Constants.MODULE_NEW_NAME_PATTERN).matcher(group.getName()).matches() || Pattern
+ .compile(Constants.MODULE_OLD_NAME_PATTERN).matcher(group.getName()).matches())
+ .map(group -> Integer.parseInt(group.getName().split(Constants.MODULE_NAME_DELIMITER)[1])).collect(toList());
counter = (counters == null || counters.isEmpty()) ? 0 : counters.stream().max(Integer::compare).get() + 1;
}
return counter;
@@ -617,14 +600,14 @@ public class GroupBusinessLogic extends BaseBusinessLogic {
public Either<List<GroupDefinition>, ResponseFormat> validateUpdateVfGroupNamesOnGraph(List<GroupDefinition> groups, Component component) {
List<GroupDefinition> updatedGroups = new ArrayList<>();
-
for (GroupDefinition group : groups) {
String groupType = group.getType();
String oldGroupName = group.getName();
String newGroupName;
Either<String, ResponseFormat> newGroupNameRes;
int counter;
- if (groupType.equals(Constants.DEFAULT_GROUP_VF_MODULE) && Pattern.compile(Constants.MODULE_OLD_NAME_PATTERN).matcher(oldGroupName).matches()) {
+ if (groupType.equals(Constants.DEFAULT_GROUP_VF_MODULE) && Pattern.compile(Constants.MODULE_OLD_NAME_PATTERN).matcher(oldGroupName)
+ .matches()) {
counter = Integer.parseInt(group.getName().split(Constants.MODULE_NAME_DELIMITER)[1]);
newGroupNameRes = validateGenerateVfModuleGroupName(component.getSystemName(), group.getDescription(), counter);
if (newGroupNameRes.isRight()) {
@@ -633,54 +616,45 @@ public class GroupBusinessLogic extends BaseBusinessLogic {
}
newGroupName = newGroupNameRes.left().value();
group.setName(newGroupName);
-
}
updatedGroups.add(group);
-
}
-
return Either.left(updatedGroups);
}
-
- public Either<GroupDefinitionInfo, ResponseFormat> getGroupInstWithArtifactsById(ComponentTypeEnum componentType, String componentId, String componentInstanceId, String groupInstId, String userId, boolean inTransaction) {
+ public Either<GroupDefinitionInfo, ResponseFormat> getGroupInstWithArtifactsById(ComponentTypeEnum componentType, String componentId,
+ String componentInstanceId, String groupInstId, String userId,
+ boolean inTransaction) {
Either<GroupDefinitionInfo, ResponseFormat> result = null;
-
// Validate user exist
validateUserExists(userId);
// Validate component exist
org.openecomp.sdc.be.model.Component component;
-
try {
ComponentParametersView componentParametersView = new ComponentParametersView();
componentParametersView.disableAll();
componentParametersView.setIgnoreUsers(false);
componentParametersView.setIgnoreComponentInstances(false);
componentParametersView.setIgnoreArtifacts(false);
-
component = validateComponentExists(componentId, componentType, componentParametersView);
- Either<ImmutablePair<ComponentInstance, GroupInstance>, StorageOperationStatus> findComponentInstanceAndGroupInstanceRes = findComponentInstanceAndGroupInstanceOnComponent(component, componentInstanceId, groupInstId);
-
+ Either<ImmutablePair<ComponentInstance, GroupInstance>, StorageOperationStatus> findComponentInstanceAndGroupInstanceRes = findComponentInstanceAndGroupInstanceOnComponent(
+ component, componentInstanceId, groupInstId);
if (findComponentInstanceAndGroupInstanceRes.isRight()) {
log.debug("Failed to get group {} . Status is {} ", groupInstId, findComponentInstanceAndGroupInstanceRes.right().value());
- ResponseFormat responseFormat = componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(findComponentInstanceAndGroupInstanceRes.right().value()));
+ ResponseFormat responseFormat = componentsUtils
+ .getResponseFormat(componentsUtils.convertFromStorageResponse(findComponentInstanceAndGroupInstanceRes.right().value()));
result = Either.right(responseFormat);
return result;
}
-
GroupInstance group = findComponentInstanceAndGroupInstanceRes.left().value().getRight();
-
Boolean isBase = isBaseProperty(component, group);
-
List<ArtifactDefinitionInfo> artifacts = new ArrayList<>();
List<String> artifactsIds = group.getArtifacts();
if (artifactsIds != null && !artifactsIds.isEmpty()) {
-
List<ComponentInstance> instances = component.getComponentInstances();
if (instances != null) {
- instances.stream().filter(i -> i.getUniqueId().equals(componentInstanceId))
- .findFirst()
- .ifPresent(f->getFirstComponentInstance(group, artifacts, artifactsIds, f));
+ instances.stream().filter(i -> i.getUniqueId().equals(componentInstanceId)).findFirst()
+ .ifPresent(f -> getFirstComponentInstance(group, artifacts, artifactsIds, f));
}
}
GroupDefinitionInfo resultInfo = new GroupDefinitionInfo(group);
@@ -689,31 +663,23 @@ public class GroupBusinessLogic extends BaseBusinessLogic {
resultInfo.setArtifacts(artifacts);
}
result = Either.left(resultInfo);
-
return result;
-
} finally {
closeTransaction(inTransaction, result);
}
}
- private void getFirstComponentInstance(GroupInstance group, List<ArtifactDefinitionInfo> artifacts, List<String> artifactsIds, ComponentInstance ci) {
+ private void getFirstComponentInstance(GroupInstance group, List<ArtifactDefinitionInfo> artifacts, List<String> artifactsIds,
+ ComponentInstance ci) {
Map<String, ArtifactDefinition> deploymentArtifacts = ci.getDeploymentArtifacts();
- artifactsIds.forEach(id -> deploymentArtifacts.values().stream()
- .filter(a -> a.getUniqueId().equals(id))
- .findFirst()
- .ifPresent(g -> artifacts.add(new ArtifactDefinitionInfo(g))));
-
+ artifactsIds.forEach(id -> deploymentArtifacts.values().stream().filter(a -> a.getUniqueId().equals(id)).findFirst()
+ .ifPresent(g -> artifacts.add(new ArtifactDefinitionInfo(g))));
List<String> instArtifactsIds = group.getGroupInstanceArtifacts();
- instArtifactsIds.forEach(id -> deploymentArtifacts.values()
- .stream()
- .filter(a -> a.getUniqueId().equals(id))
- .findFirst()
- .ifPresent(g -> artifacts.add(new ArtifactDefinitionInfo(g))));
- }
+ instArtifactsIds.forEach(id -> deploymentArtifacts.values().stream().filter(a -> a.getUniqueId().equals(id)).findFirst()
+ .ifPresent(g -> artifacts.add(new ArtifactDefinitionInfo(g))));
+ }
private Boolean isBaseProperty(Component component, GroupInstance group) {
-
Boolean isBase = null;
List<? extends GroupProperty> props = group.convertToGroupInstancesProperties();
if (props != null && !props.isEmpty()) {
@@ -721,9 +687,9 @@ public class GroupBusinessLogic extends BaseBusinessLogic {
if (isBasePropOp.isPresent()) {
GroupProperty propIsBase = isBasePropOp.get();
isBase = Boolean.parseBoolean(propIsBase.getValue());
-
} else {
- BeEcompErrorManager.getInstance().logInvalidInputError(GET_GROUP, "failed to find prop isBase " + component.getNormalizedName(), ErrorSeverity.INFO);
+ BeEcompErrorManager.getInstance()
+ .logInvalidInputError(GET_GROUP, "failed to find prop isBase " + component.getNormalizedName(), ErrorSeverity.INFO);
}
}
return isBase;
@@ -733,20 +699,21 @@ public class GroupBusinessLogic extends BaseBusinessLogic {
if (!inTransaction) {
if (result == null || result.isRight()) {
log.debug("Going to execute rollback on create group.");
- janusGraphDao.rollback();
+ janusGraphDao.rollback();
} else {
log.debug("Going to execute commit on create group.");
- janusGraphDao.commit();
+ janusGraphDao.commit();
}
}
}
- private Either<ImmutablePair<ComponentInstance, GroupInstance>, StorageOperationStatus> findComponentInstanceAndGroupInstanceOnComponent(Component component, String componentInstanceId, String groupInstId) {
-
+ private Either<ImmutablePair<ComponentInstance, GroupInstance>, StorageOperationStatus> findComponentInstanceAndGroupInstanceOnComponent(
+ Component component, String componentInstanceId, String groupInstId) {
Either<ImmutablePair<ComponentInstance, GroupInstance>, StorageOperationStatus> result = null;
if (CollectionUtils.isNotEmpty(component.getComponentInstances())) {
Optional<GroupInstance> foundGroup;
- Optional<ComponentInstance> foundComponent = component.getComponentInstances().stream().filter(ci -> ci.getUniqueId().equals(componentInstanceId)).findFirst();
+ Optional<ComponentInstance> foundComponent = component.getComponentInstances().stream()
+ .filter(ci -> ci.getUniqueId().equals(componentInstanceId)).findFirst();
if (foundComponent.isPresent() && CollectionUtils.isNotEmpty(foundComponent.get().getGroupInstances())) {
foundGroup = foundComponent.get().getGroupInstances().stream().filter(gi -> gi.getUniqueId().equals(groupInstId)).findFirst();
if (foundGroup.isPresent()) {
@@ -760,39 +727,44 @@ public class GroupBusinessLogic extends BaseBusinessLogic {
return result;
}
- private Boolean validateMinMaxAndInitialCountPropertyLogic(Map<PropertyNames, String> newValues, Map<PropertyNames, String> currValues, Map<PropertyNames, String> parentValues) {
-
+ private Boolean validateMinMaxAndInitialCountPropertyLogic(Map<PropertyNames, String> newValues, Map<PropertyNames, String> currValues,
+ Map<PropertyNames, String> parentValues) {
for (Entry<PropertyNames, String> entry : newValues.entrySet()) {
PropertyNames currPropertyName = entry.getKey();
if (currPropertyName == PropertyNames.MIN_INSTANCES) {
String minValue = parentValues.get(PropertyNames.MIN_INSTANCES);
String maxValue = getMaxValue(newValues, currValues);
- validateValueInRange(new ImmutablePair<>(currPropertyName, entry.getValue()), new ImmutablePair<>(PropertyNames.MIN_INSTANCES, minValue),
- new ImmutablePair<>(PropertyNames.MAX_INSTANCES, maxValue));
+ validateValueInRange(new ImmutablePair<>(currPropertyName, entry.getValue()),
+ new ImmutablePair<>(PropertyNames.MIN_INSTANCES, minValue), new ImmutablePair<>(PropertyNames.MAX_INSTANCES, maxValue));
} else if (currPropertyName == PropertyNames.INITIAL_COUNT) {
- String minValue = newValues.containsKey(PropertyNames.MIN_INSTANCES) ? newValues.get(PropertyNames.MIN_INSTANCES) : currValues.get(PropertyNames.MIN_INSTANCES);
- String maxValue = newValues.containsKey(PropertyNames.MAX_INSTANCES) ? newValues.get(PropertyNames.MAX_INSTANCES) : currValues.get(PropertyNames.MAX_INSTANCES);
- validateValueInRange(new ImmutablePair<>(currPropertyName, entry.getValue()), new ImmutablePair<>(PropertyNames.MIN_INSTANCES, minValue),
- new ImmutablePair<>(PropertyNames.MAX_INSTANCES, maxValue));
+ String minValue = newValues.containsKey(PropertyNames.MIN_INSTANCES) ? newValues.get(PropertyNames.MIN_INSTANCES)
+ : currValues.get(PropertyNames.MIN_INSTANCES);
+ String maxValue = newValues.containsKey(PropertyNames.MAX_INSTANCES) ? newValues.get(PropertyNames.MAX_INSTANCES)
+ : currValues.get(PropertyNames.MAX_INSTANCES);
+ validateValueInRange(new ImmutablePair<>(currPropertyName, entry.getValue()),
+ new ImmutablePair<>(PropertyNames.MIN_INSTANCES, minValue), new ImmutablePair<>(PropertyNames.MAX_INSTANCES, maxValue));
} else if (currPropertyName == PropertyNames.MAX_INSTANCES) {
String minValue = getMinValue(newValues, currValues);
String maxValue = parentValues.get(PropertyNames.MAX_INSTANCES);
- validateValueInRange(new ImmutablePair<>(currPropertyName, entry.getValue()), new ImmutablePair<>(PropertyNames.MIN_INSTANCES, minValue),
- new ImmutablePair<>(PropertyNames.MAX_INSTANCES, maxValue));
+ validateValueInRange(new ImmutablePair<>(currPropertyName, entry.getValue()),
+ new ImmutablePair<>(PropertyNames.MIN_INSTANCES, minValue), new ImmutablePair<>(PropertyNames.MAX_INSTANCES, maxValue));
}
}
return true;
}
private String getMaxValue(Map<PropertyNames, String> newValues, Map<PropertyNames, String> currValues) {
- return newValues.containsKey(PropertyNames.INITIAL_COUNT) ? newValues.get(PropertyNames.MAX_INSTANCES) : currValues.get(PropertyNames.INITIAL_COUNT);
+ return newValues.containsKey(PropertyNames.INITIAL_COUNT) ? newValues.get(PropertyNames.MAX_INSTANCES)
+ : currValues.get(PropertyNames.INITIAL_COUNT);
}
private String getMinValue(Map<PropertyNames, String> newValues, Map<PropertyNames, String> currValues) {
- return newValues.containsKey(PropertyNames.INITIAL_COUNT) ? newValues.get(PropertyNames.MIN_INSTANCES) : currValues.get(PropertyNames.INITIAL_COUNT);
+ return newValues.containsKey(PropertyNames.INITIAL_COUNT) ? newValues.get(PropertyNames.MIN_INSTANCES)
+ : currValues.get(PropertyNames.INITIAL_COUNT);
}
- private Boolean validateValueInRange(ImmutablePair<PropertyNames, String> newValue, ImmutablePair<PropertyNames, String> min, ImmutablePair<PropertyNames, String> max) {
+ private Boolean validateValueInRange(ImmutablePair<PropertyNames, String> newValue, ImmutablePair<PropertyNames, String> min,
+ ImmutablePair<PropertyNames, String> max) {
final String warnMessage = "Failed to validate {} as property value of {}. It must be not higher than {}, and not lower than {}.";
int newValueInt = parseIntValue(newValue.getValue(), newValue.getKey());
int minInt = parseIntValue(min.getValue(), min.getKey());
@@ -801,8 +773,8 @@ public class GroupBusinessLogic extends BaseBusinessLogic {
throw new ByActionStatusComponentException(ActionStatus.INVALID_PROPERTY);
} else if (newValueInt < minInt || newValueInt > maxInt) {
log.debug(warnMessage, newValue.getValue(), newValue.getKey().getPropertyName(), min.getValue(), max.getValue());
- throw new ByActionStatusComponentException(ActionStatus.INVALID_GROUP_MIN_MAX_INSTANCES_PROPERTY_VALUE, newValue.getKey().getPropertyName(),
- maxInt == Integer.MAX_VALUE ? Constants.UNBOUNDED : max.getValue(), min.getValue());
+ throw new ByActionStatusComponentException(ActionStatus.INVALID_GROUP_MIN_MAX_INSTANCES_PROPERTY_VALUE,
+ newValue.getKey().getPropertyName(), maxInt == Integer.MAX_VALUE ? Constants.UNBOUNDED : max.getValue(), min.getValue());
}
return true;
}
@@ -826,17 +798,20 @@ public class GroupBusinessLogic extends BaseBusinessLogic {
* @param newProperties
* @return
*/
- public Either<GroupInstance, ResponseFormat> validateAndUpdateGroupInstancePropertyValues(String componentId, String instanceId, GroupInstance oldGroupInstance, List<GroupInstanceProperty> newProperties) {
-
+ public Either<GroupInstance, ResponseFormat> validateAndUpdateGroupInstancePropertyValues(String componentId, String instanceId,
+ GroupInstance oldGroupInstance,
+ List<GroupInstanceProperty> newProperties) {
Either<GroupInstance, ResponseFormat> actionResult = null;
Either<GroupInstance, StorageOperationStatus> updateGroupInstanceResult = null;
List<GroupInstanceProperty> validateRes = validateReduceGroupInstancePropertiesBeforeUpdate(oldGroupInstance, newProperties);
if (actionResult == null) {
List<GroupInstanceProperty> validatedReducedNewProperties = validateRes;
- updateGroupInstanceResult = groupsOperation.updateGroupInstancePropertyValuesOnGraph(componentId, instanceId, oldGroupInstance, validatedReducedNewProperties);
+ updateGroupInstanceResult = groupsOperation
+ .updateGroupInstancePropertyValuesOnGraph(componentId, instanceId, oldGroupInstance, validatedReducedNewProperties);
if (updateGroupInstanceResult.isRight()) {
log.debug("Failed to update group instance {} property values. ", oldGroupInstance.getName());
- actionResult = Either.right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(updateGroupInstanceResult.right().value())));
+ actionResult = Either
+ .right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(updateGroupInstanceResult.right().value())));
}
}
if (actionResult == null) {
@@ -845,11 +820,12 @@ public class GroupBusinessLogic extends BaseBusinessLogic {
return actionResult;
}
- private List<GroupInstanceProperty> validateReduceGroupInstancePropertiesBeforeUpdate(GroupInstance oldGroupInstance, List<GroupInstanceProperty> newProperties) {
-
+ private List<GroupInstanceProperty> validateReduceGroupInstancePropertiesBeforeUpdate(GroupInstance oldGroupInstance,
+ List<GroupInstanceProperty> newProperties) {
Boolean validationRes = null;
List<GroupInstanceProperty> actionResult = null;
- Map<String, GroupInstanceProperty> existingProperties = oldGroupInstance.convertToGroupInstancesProperties().stream().collect(Collectors.toMap(PropertyDataDefinition::getName, p -> p));
+ Map<String, GroupInstanceProperty> existingProperties = oldGroupInstance.convertToGroupInstancesProperties().stream()
+ .collect(Collectors.toMap(PropertyDataDefinition::getName, p -> p));
Map<PropertyNames, String> newPropertyValues = new EnumMap<>(PropertyNames.class);
List<GroupInstanceProperty> reducedProperties = new ArrayList<>();
String currPropertyName;
@@ -874,7 +850,9 @@ public class GroupBusinessLogic extends BaseBusinessLogic {
return actionResult;
}
- private void fillValuesAndParentValuesFromExistingProperties(Map<String, GroupInstanceProperty> existingProperties, Map<PropertyNames, String> propertyValues, Map<PropertyNames, String> parentPropertyValues) {
+ private void fillValuesAndParentValuesFromExistingProperties(Map<String, GroupInstanceProperty> existingProperties,
+ Map<PropertyNames, String> propertyValues,
+ Map<PropertyNames, String> parentPropertyValues) {
PropertyNames[] allPropertyNames = PropertyNames.values();
for (PropertyNames name : allPropertyNames) {
if (isUpdatable(name)) {
@@ -884,8 +862,8 @@ public class GroupBusinessLogic extends BaseBusinessLogic {
}
}
- private Boolean handleAndAddProperty(List<GroupInstanceProperty> reducedProperties, Map<PropertyNames, String> newPropertyValues, GroupInstanceProperty currNewProperty, GroupInstanceProperty currExistingProperty) {
-
+ private Boolean handleAndAddProperty(List<GroupInstanceProperty> reducedProperties, Map<PropertyNames, String> newPropertyValues,
+ GroupInstanceProperty currNewProperty, GroupInstanceProperty currExistingProperty) {
Boolean validationRes = null;
String currPropertyName = currNewProperty.getName();
PropertyNames propertyName = PropertyNames.findName(currPropertyName);
@@ -908,11 +886,14 @@ public class GroupBusinessLogic extends BaseBusinessLogic {
}
private boolean isUpdatable(PropertyNames updatablePropertyName) {
- return updatablePropertyName != null && updatablePropertyName.getUpdateBehavior().getLevelNumber() >= GroupInstancePropertyValueUpdateBehavior.UPDATABLE_ON_SERVICE_LEVEL.getLevelNumber();
+ return updatablePropertyName != null
+ && updatablePropertyName.getUpdateBehavior().getLevelNumber() >= GroupInstancePropertyValueUpdateBehavior.UPDATABLE_ON_SERVICE_LEVEL
+ .getLevelNumber();
}
- private void addPropertyUpdatedValues(List<GroupInstanceProperty> reducedProperties, PropertyNames propertyName, Map<PropertyNames, String> newPropertyValues, GroupInstanceProperty newProperty, GroupInstanceProperty existingProperty) {
-
+ private void addPropertyUpdatedValues(List<GroupInstanceProperty> reducedProperties, PropertyNames propertyName,
+ Map<PropertyNames, String> newPropertyValues, GroupInstanceProperty newProperty,
+ GroupInstanceProperty existingProperty) {
String newValue = newProperty.getValue();
if (!newValue.equals(String.valueOf(existingProperty.getValue()))) {
newProperty.setValueUniqueUid(existingProperty.getValueUniqueUid());
@@ -932,7 +913,6 @@ public class GroupBusinessLogic extends BaseBusinessLogic {
}
private int convertIfUnboundMax(String value) {
-
int result;
if (!NumberUtils.isNumber(value)) {
result = Integer.MAX_VALUE;
@@ -943,9 +923,7 @@ public class GroupBusinessLogic extends BaseBusinessLogic {
}
private Boolean validateAndUpdatePropertyValue(GroupInstanceProperty newProperty, GroupInstanceProperty existingProperty) {
-
String parentValue = existingProperty.getParentValue();
-
newProperty.setParentValue(parentValue);
if (StringUtils.isEmpty(newProperty.getValue())) {
newProperty.setValue(parentValue);
@@ -955,34 +933,30 @@ public class GroupBusinessLogic extends BaseBusinessLogic {
}
StorageOperationStatus status = groupOperation.validateAndUpdatePropertyValue(newProperty);
if (status != StorageOperationStatus.OK) {
- log.debug("Failed to validate property value {} of property with name {}. Status is {}. ", newProperty.getValue(), newProperty.getName(), status);
+ log.debug("Failed to validate property value {} of property with name {}. Status is {}. ", newProperty.getValue(), newProperty.getName(),
+ status);
throw new ByActionStatusComponentException(componentsUtils.convertFromStorageResponse(status));
}
return true;
}
private void validateImmutableProperty(GroupProperty oldProperty, GroupProperty newProperty) {
- if (oldProperty.getValue() == null && newProperty.getValue() != null || oldProperty.getValue() != null && !oldProperty.getValue().equals(newProperty.getValue())) {
- log.warn("The value of property with the name {} cannot be updated on service level. Going to ignore new property value {}. ", oldProperty.getName(), newProperty.getValue());
+ if (oldProperty.getValue() == null && newProperty.getValue() != null || oldProperty.getValue() != null && !oldProperty.getValue()
+ .equals(newProperty.getValue())) {
+ log.warn("The value of property with the name {} cannot be updated on service level. Going to ignore new property value {}. ",
+ oldProperty.getName(), newProperty.getValue());
}
}
@LockingTransactional
- public GroupDefinition createGroup(String componentId, ComponentTypeEnum componentTypeEnum, String groupType,
- String userId) {
-
+ public GroupDefinition createGroup(String componentId, ComponentTypeEnum componentTypeEnum, String groupType, String userId) {
Component component = accessValidations.validateUserCanWorkOnComponent(componentId, componentTypeEnum, userId, CREATE_GROUP);
-
validateGroupTypePerComponent(groupType, component);
-
- GroupTypeDefinition groupTypeDefinition = groupTypeOperation.getLatestGroupTypeByType(groupType, false)
- .left()
- .on(se -> onGroupTypeNotFound(component));
-
+ GroupTypeDefinition groupTypeDefinition = groupTypeOperation.getLatestGroupTypeByType(groupType, false).left()
+ .on(se -> onGroupTypeNotFound(component));
boolean hasExistingGroups = CollectionUtils.isNotEmpty(component.getGroups());
GroupDefinition groupDefinition = new GroupDefinition();
groupDefinition.setType(groupType);
-
//find next valid counter
int nextCounter = 0;
if (hasExistingGroups) {
@@ -993,26 +967,17 @@ public class GroupBusinessLogic extends BaseBusinessLogic {
groupDefinition.setDescription(groupTypeDefinition.getDescription());
groupDefinition.setInvariantName(name);
groupDefinition.setCreatedFrom(CreatedFrom.UI);
-
//Add default type properties
List<PropertyDefinition> groupTypeProperties = groupTypeDefinition.getProperties();
- List<GroupProperty> properties = groupTypeProperties.stream()
- .map(GroupProperty::new)
- .collect(toList());
+ List<GroupProperty> properties = groupTypeProperties.stream().map(GroupProperty::new).collect(toList());
groupDefinition.convertFromGroupProperties(properties);
-
groupDefinition.convertCapabilityDefinitions(groupTypeDefinition.getCapabilities());
-
List<GroupDefinition> gdList;
if (toscaOperationFacade.canAddGroups(componentId)) {
- gdList = addGroups(component, Arrays.asList(groupDefinition), false)
- .left()
- .on(this::onFailedGroupDBOperation);
+ gdList = addGroups(component, Arrays.asList(groupDefinition), false).left().on(this::onFailedGroupDBOperation);
} else {
//createGroups also creates an edge and vertex to store group data
- gdList = createGroups(component, Arrays.asList(groupDefinition), false)
- .left()
- .on(this::onFailedGroupDBOperation);
+ gdList = createGroups(component, Arrays.asList(groupDefinition), false).left().on(this::onFailedGroupDBOperation);
}
return gdList.get(0);
}
@@ -1020,51 +985,35 @@ public class GroupBusinessLogic extends BaseBusinessLogic {
private void validateGroupTypePerComponent(String groupType, Component component) {
String specificType = component.getComponentMetadataDefinition().getMetadataDataDefinition().getActualComponentType();
if (!component.isTopologyTemplate()) {
- throw new ByActionStatusComponentException(ActionStatus.GROUP_TYPE_ILLEGAL_PER_COMPONENT, groupType,
- specificType);
+ throw new ByActionStatusComponentException(ActionStatus.GROUP_TYPE_ILLEGAL_PER_COMPONENT, groupType, specificType);
}
Map<String, Set<String>> excludedGroupTypesMap = ConfigurationManager.getConfigurationManager().getConfiguration()
- .getExcludedGroupTypesMapping();
-
+ .getExcludedGroupTypesMapping();
if (MapUtils.isNotEmpty(excludedGroupTypesMap) && StringUtils.isNotEmpty(specificType)) {
Set<String> excludedGroupTypesPerComponent = excludedGroupTypesMap.get(specificType);
- if (excludedGroupTypesPerComponent!=null && excludedGroupTypesPerComponent.contains(groupType)) {
+ if (excludedGroupTypesPerComponent != null && excludedGroupTypesPerComponent.contains(groupType)) {
throw new ByActionStatusComponentException(ActionStatus.GROUP_TYPE_ILLEGAL_PER_COMPONENT, groupType, specificType);
}
}
}
private int getNewGroupCounter(Component component) {
- List<String> existingNames = component.getGroups()
- .stream()
- .map(GroupDataDefinition::getInvariantName)
- .collect(toList());
- List<String> existingIds = component.getGroups()
- .stream()
- .map(GroupDataDefinition::getUniqueId)
- .collect(toList());
+ List<String> existingNames = component.getGroups().stream().map(GroupDataDefinition::getInvariantName).collect(toList());
+ List<String> existingIds = component.getGroups().stream().map(GroupDataDefinition::getUniqueId).collect(toList());
existingIds.addAll(existingNames);
-
return Utils.getNextCounter(existingIds);
}
@LockingTransactional
- public GroupDefinition updateGroup(String componentId, ComponentTypeEnum componentTypeEnum, String groupId,
- String userId, GroupDefinition updatedGroup) {
+ public GroupDefinition updateGroup(String componentId, ComponentTypeEnum componentTypeEnum, String groupId, String userId,
+ GroupDefinition updatedGroup) {
Component component = accessValidations.validateUserCanWorkOnComponent(componentId, componentTypeEnum, userId, UPDATE_GROUP);
-
- GroupDefinition existingGroup = findGroupOnComponent(component, groupId)
- .left()
- .on(se -> onGroupNotFoundInComponentError(component, groupId));
-
+ GroupDefinition existingGroup = findGroupOnComponent(component, groupId).left().on(se -> onGroupNotFoundInComponentError(component, groupId));
String existingGroupName = existingGroup.getName();
String updatedGroupName = updatedGroup.getName();
assertNewNameIsValidAndUnique(existingGroupName, updatedGroupName, component);
existingGroup.setName(updatedGroupName);
-
- return updateGroup(component, existingGroup, existingGroupName)
- .left()
- .on(this::onFailedUpdateGroupDBOperation);
+ return updateGroup(component, existingGroup, existingGroupName).left().on(this::onFailedUpdateGroupDBOperation);
}
private void assertNewNameIsValidAndUnique(String currentGroupName, String updatedGroupName, Component component) {
@@ -1080,18 +1029,11 @@ public class GroupBusinessLogic extends BaseBusinessLogic {
}
@LockingTransactional
- public GroupDefinition deleteGroup(String componentId, ComponentTypeEnum componentTypeEnum, String groupId,
- String userId) {
+ public GroupDefinition deleteGroup(String componentId, ComponentTypeEnum componentTypeEnum, String groupId, String userId) {
Component component = accessValidations.validateUserCanWorkOnComponent(componentId, componentTypeEnum, userId, DELETE_GROUP);
-
- GroupDefinition groupDefinition = findGroupOnComponent(component, groupId)
- .left()
- .on(se -> onGroupNotFoundInComponentError(component, groupId));
-
- List<GroupDefinition> gdList = deleteGroups(component, java.util.Arrays.asList(groupDefinition))
- .left()
- .on(this::onFailedGroupDBOperation);
-
+ GroupDefinition groupDefinition = findGroupOnComponent(component, groupId).left()
+ .on(se -> onGroupNotFoundInComponentError(component, groupId));
+ List<GroupDefinition> gdList = deleteGroups(component, java.util.Arrays.asList(groupDefinition)).left().on(this::onFailedGroupDBOperation);
updatePolicyTargetReferencingDeletedGroup(groupId, component);
return gdList.get(0);
}
@@ -1107,17 +1049,18 @@ public class GroupBusinessLogic extends BaseBusinessLogic {
}
private GroupDefinition onGroupNotFoundInComponentError(Component component, String groupId) {
- throw new ByActionStatusComponentException(ActionStatus.GROUP_IS_MISSING, groupId,
- component.getSystemName(), getComponentTypeForResponse(component));
+ throw new ByActionStatusComponentException(ActionStatus.GROUP_IS_MISSING, groupId, component.getSystemName(),
+ getComponentTypeForResponse(component));
}
private GroupTypeDefinition onGroupTypeNotFound(Component component) {
throw new ByActionStatusComponentException(ActionStatus.GROUP_TYPE_IS_INVALID, component.getSystemName(),
- component.getComponentType().toString());
+ component.getComponentType().toString());
}
private void updatePolicyTargetReferencingDeletedGroup(String groupId, Component component) {
- log.debug("#updatePolicyTargetReferencingDeletedGroup - removing all component {} policy targets referencing group {}", component.getUniqueId(), groupId);
+ log.debug("#updatePolicyTargetReferencingDeletedGroup - removing all component {} policy targets referencing group {}",
+ component.getUniqueId(), groupId);
ActionStatus actionStatus = policyTargetsUpdateHandler.removePoliciesTargets(component, groupId, PolicyTargetType.GROUPS);
if (ActionStatus.OK != actionStatus) {
janusGraphDao.rollback();
@@ -1125,20 +1068,19 @@ public class GroupBusinessLogic extends BaseBusinessLogic {
}
}
-
- public Either<List<GroupDefinition>, ResponseFormat> createGroups(Component component, final List<GroupDefinition> groupDefinitions, boolean fromCsar) {
-
+ public Either<List<GroupDefinition>, ResponseFormat> createGroups(Component component, final List<GroupDefinition> groupDefinitions,
+ boolean fromCsar) {
Map<String, GroupDataDefinition> groups = new HashMap<>();
Either<List<GroupDefinition>, ResponseFormat> result = null;
Either<List<GroupDefinition>, StorageOperationStatus> createGroupsResult = null;
Either<Map<String, DataTypeDefinition>, JanusGraphOperationStatus> allDataTypes = dataTypeCache.getAll();
if (allDataTypes.isRight()) {
JanusGraphOperationStatus status = allDataTypes.right().value();
- BeEcompErrorManager.getInstance().logInternalFlowError("AddPropertyToGroup", "Failed to add property to group. Status is " + status, ErrorSeverity.ERROR);
- return Either.right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status))));
-
+ BeEcompErrorManager.getInstance()
+ .logInternalFlowError("AddPropertyToGroup", "Failed to add property to group. Status is " + status, ErrorSeverity.ERROR);
+ return Either.right(componentsUtils
+ .getResponseFormat(componentsUtils.convertFromStorageResponse(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status))));
}
-
// handle groups and convert to tosca data
if (groupDefinitions != null && !groupDefinitions.isEmpty()) {
for (GroupDefinition groupDefinition : groupDefinitions) {
@@ -1149,13 +1091,13 @@ public class GroupBusinessLogic extends BaseBusinessLogic {
}
GroupDefinition handledGroup = handleGroupRes.left().value();
groups.put(handledGroup.getInvariantName(), new GroupDataDefinition(handledGroup));
-
}
}
if (result == null) {
createGroupsResult = groupsOperation.createGroups(component, groups);
if (createGroupsResult.isRight()) {
- result = Either.right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(createGroupsResult.right().value())));
+ result = Either
+ .right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(createGroupsResult.right().value())));
}
}
if (result == null) {
@@ -1168,26 +1110,27 @@ public class GroupBusinessLogic extends BaseBusinessLogic {
return result;
}
- private void updateCalculatedCapabilitiesWithPropertiesOnComponent(Component component, final List<GroupDefinition> groupDefinitions, boolean fromCsar) {
+ private void updateCalculatedCapabilitiesWithPropertiesOnComponent(Component component, final List<GroupDefinition> groupDefinitions,
+ boolean fromCsar) {
groupDefinitions.forEach(GroupDefinition::updateEmptyCapabilitiesOwnerFields);
- StorageOperationStatus status = groupsOperation.updateCalculatedCapabilitiesWithProperties(component.getUniqueId(),
- extractCapabilitiesFromGroups(groupDefinitions), extractCapabilityPropertiesFromGroups(groupDefinitions, fromCsar));
- if(status != StorageOperationStatus.OK){
- log.error("#updateCalculatedCapabilitiesWithPropertiesOnComponent - failed to update the groups' calculated capabilities with the properties on the component {}. ", component.getUniqueId());
+ StorageOperationStatus status = groupsOperation
+ .updateCalculatedCapabilitiesWithProperties(component.getUniqueId(), extractCapabilitiesFromGroups(groupDefinitions),
+ extractCapabilityPropertiesFromGroups(groupDefinitions, fromCsar));
+ if (status != StorageOperationStatus.OK) {
+ log.error(
+ "#updateCalculatedCapabilitiesWithPropertiesOnComponent - failed to update the groups' calculated capabilities with the properties on the component {}. ",
+ component.getUniqueId());
rollbackWithException(componentsUtils.convertFromStorageResponse(status));
}
}
- private void addCalculatedCapabilitiesWithPropertiesToComponent(Component component,
- final List<GroupDefinition> groupDefinitions, boolean fromCsar) {
- final List<GroupDefinition> nonNullGroupDefinitions =
- (groupDefinitions == null) ? Collections.emptyList() : groupDefinitions;
-
+ private void addCalculatedCapabilitiesWithPropertiesToComponent(Component component, final List<GroupDefinition> groupDefinitions,
+ boolean fromCsar) {
+ final List<GroupDefinition> nonNullGroupDefinitions = (groupDefinitions == null) ? Collections.emptyList() : groupDefinitions;
nonNullGroupDefinitions.forEach(GroupDefinition::updateEmptyCapabilitiesOwnerFields);
- StorageOperationStatus status = groupsOperation.addCalculatedCapabilitiesWithProperties(
- component.getUniqueId(),
- extractCapabilitiesFromGroups(nonNullGroupDefinitions),
- extractCapabilityPropertiesFromGroups(nonNullGroupDefinitions, fromCsar));
+ StorageOperationStatus status = groupsOperation
+ .addCalculatedCapabilitiesWithProperties(component.getUniqueId(), extractCapabilitiesFromGroups(nonNullGroupDefinitions),
+ extractCapabilityPropertiesFromGroups(nonNullGroupDefinitions, fromCsar));
if (status != StorageOperationStatus.OK) {
log.error(
"#addCalculatedCapabilitiesWithPropertiesToComponent - failed to add the groups' calculated capabilities with the properties to the component {}. ",
@@ -1198,26 +1141,27 @@ public class GroupBusinessLogic extends BaseBusinessLogic {
private void deleteCalculatedCapabilitiesWithPropertiesFromComponent(Component component, final List<GroupDefinition> groupDefinitions) {
StorageOperationStatus status = groupsOperation.deleteCalculatedCapabilitiesWithProperties(component.getUniqueId(), groupDefinitions);
- if(status != StorageOperationStatus.OK){
- log.error("#deleteCalculatedCapabilitiesWithPropertiesFromComponent - failed to remove the groups' calculated capabilities with the properties from the component {}. ", component.getUniqueId());
+ if (status != StorageOperationStatus.OK) {
+ log.error(
+ "#deleteCalculatedCapabilitiesWithPropertiesFromComponent - failed to remove the groups' calculated capabilities with the properties from the component {}. ",
+ component.getUniqueId());
rollbackWithException(componentsUtils.convertFromStorageResponse(status));
}
}
- public Either<List<GroupDefinition>, ResponseFormat> addGroups(Component component, final List<GroupDefinition> groupDefinitions, boolean fromCsar) {
-
+ public Either<List<GroupDefinition>, ResponseFormat> addGroups(Component component, final List<GroupDefinition> groupDefinitions,
+ boolean fromCsar) {
Either<List<GroupDefinition>, ResponseFormat> result = null;
Either<List<GroupDefinition>, StorageOperationStatus> createGroupsResult = null;
List<GroupDataDefinition> groups = new ArrayList<>();
-
Either<Map<String, DataTypeDefinition>, JanusGraphOperationStatus> allDataTypes = dataTypeCache.getAll();
if (allDataTypes.isRight()) {
JanusGraphOperationStatus status = allDataTypes.right().value();
- BeEcompErrorManager.getInstance().logInternalFlowError("AddPropertyToGroup", "Failed to add property to group. Status is " + status, ErrorSeverity.ERROR);
- return Either.right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status))));
-
+ BeEcompErrorManager.getInstance()
+ .logInternalFlowError("AddPropertyToGroup", "Failed to add property to group. Status is " + status, ErrorSeverity.ERROR);
+ return Either.right(componentsUtils
+ .getResponseFormat(componentsUtils.convertFromStorageResponse(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status))));
}
-
// handle groups and convert to tosca data
if (groupDefinitions != null && !groupDefinitions.isEmpty()) {
for (GroupDefinition groupDefinition : groupDefinitions) {
@@ -1233,7 +1177,8 @@ public class GroupBusinessLogic extends BaseBusinessLogic {
if (result == null) {
createGroupsResult = groupsOperation.addGroups(component, groups);
if (createGroupsResult.isRight()) {
- result = Either.right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(createGroupsResult.right().value())));
+ result = Either
+ .right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(createGroupsResult.right().value())));
}
component.addGroups(createGroupsResult.left().value());
}
@@ -1247,16 +1192,14 @@ public class GroupBusinessLogic extends BaseBusinessLogic {
}
public Either<List<GroupDefinition>, ResponseFormat> deleteGroups(Component component, List<GroupDefinition> groupDefinitions) {
-
Either<List<GroupDefinition>, StorageOperationStatus> deleteGroupsResult;
-
deleteGroupsResult = groupsOperation.deleteGroups(component, groupDefinitions.stream().map(GroupDataDefinition::new).collect(toList()));
if (deleteGroupsResult.isRight()) {
return Either.right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(deleteGroupsResult.right().value())));
} else {
deleteCalculatedCapabilitiesWithPropertiesFromComponent(component, groupDefinitions);
}
- if (component.getGroups()!=null) {
+ if (component.getGroups() != null) {
component.getGroups().removeAll(deleteGroupsResult.left().value());
}
return Either.left(deleteGroupsResult.left().value());
@@ -1264,15 +1207,14 @@ public class GroupBusinessLogic extends BaseBusinessLogic {
/**
* Update specific group version
- * @param fromCsar TODO
*
+ * @param fromCsar TODO
*/
public Either<List<GroupDefinition>, ResponseFormat> updateGroups(Component component, List<GroupDefinition> groupDefinitions, boolean fromCsar) {
-
Either<List<GroupDefinition>, ResponseFormat> result = null;
Either<List<GroupDefinition>, StorageOperationStatus> createGroupsResult;
-
- createGroupsResult = groupsOperation.updateGroups(component, groupDefinitions.stream().map(GroupDataDefinition::new).collect(toList()), PromoteVersionEnum.MINOR);
+ createGroupsResult = groupsOperation
+ .updateGroups(component, groupDefinitions.stream().map(GroupDataDefinition::new).collect(toList()), PromoteVersionEnum.MINOR);
if (createGroupsResult.isRight()) {
result = Either.right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(createGroupsResult.right().value())));
}
@@ -1285,15 +1227,17 @@ public class GroupBusinessLogic extends BaseBusinessLogic {
return result;
}
- private Either<GroupDefinition, ResponseFormat> handleGroup(Component component, GroupDefinition groupDefinition, Map<String, DataTypeDefinition> allDAtaTypes) {
-
+ private Either<GroupDefinition, ResponseFormat> handleGroup(Component component, GroupDefinition groupDefinition,
+ Map<String, DataTypeDefinition> allDAtaTypes) {
log.trace("Going to create group {}", groupDefinition);
- loggerSupportability.log(LoggerSupportabilityActions.CREATE_GROUP_POLICY,component.getComponentMetadataForSupportLog(),StatusCode.STARTED,"Start to create group: {}",groupDefinition.getName()+ " for component " + component.getName());
+ loggerSupportability.log(LoggerSupportabilityActions.CREATE_GROUP_POLICY, component.getComponentMetadataForSupportLog(), StatusCode.STARTED,
+ "Start to create group: {}", groupDefinition.getName() + " for component " + component.getName());
// 3. verify group not already exist
String groupDefinitionName = groupDefinition.getName();
if (groupExistsInComponent(groupDefinitionName, component)) {
String componentTypeForResponse = getComponentTypeForResponse(component);
- return Either.right(componentsUtils.getResponseFormat(ActionStatus.GROUP_ALREADY_EXIST, groupDefinitionName, component.getNormalizedName(), componentTypeForResponse));
+ return Either.right(componentsUtils
+ .getResponseFormat(ActionStatus.GROUP_ALREADY_EXIST, groupDefinitionName, component.getNormalizedName(), componentTypeForResponse));
}
// 4. verify type of group exist
String groupType = groupDefinition.getType();
@@ -1304,56 +1248,60 @@ public class GroupBusinessLogic extends BaseBusinessLogic {
if (getGroupType.isRight()) {
StorageOperationStatus status = getGroupType.right().value();
if (status == StorageOperationStatus.NOT_FOUND) {
- loggerSupportability.log(LoggerSupportabilityActions.CREATE_GROUP_POLICY,component.getComponentMetadataForSupportLog(), StatusCode.ERROR,"group {} cannot be found",groupDefinition.getName());
- BeEcompErrorManager.getInstance().logInvalidInputError(CREATE_GROUP, "group type " + groupType + " cannot be found", ErrorSeverity.INFO);
+ loggerSupportability
+ .log(LoggerSupportabilityActions.CREATE_GROUP_POLICY, component.getComponentMetadataForSupportLog(), StatusCode.ERROR,
+ "group {} cannot be found", groupDefinition.getName());
+ BeEcompErrorManager.getInstance()
+ .logInvalidInputError(CREATE_GROUP, "group type " + groupType + " cannot be found", ErrorSeverity.INFO);
return Either.right(componentsUtils.getResponseFormat(ActionStatus.GROUP_TYPE_IS_INVALID, groupType));
} else {
return Either.right(componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR));
}
}
// 6. verify the component instances type are allowed according to
+
// the member types in the group type
GroupTypeDefinition groupTypeDefinition = getGroupType.left().value();
-
- Either<Boolean, ResponseFormat> areValidMembers = verifyComponentInstancesAreValidMembers(component, groupDefinitionName, groupDefinition.getMembers(), groupTypeDefinition.getMembers());
-
+ Either<Boolean, ResponseFormat> areValidMembers = verifyComponentInstancesAreValidMembers(component, groupDefinitionName,
+ groupDefinition.getMembers(), groupTypeDefinition.getMembers());
if (areValidMembers.isRight()) {
ResponseFormat responseFormat = areValidMembers.right().value();
return Either.right(responseFormat);
}
// 7. verify the artifacts belongs to the component
- Either<Boolean, ResponseFormat> areValidArtifacts = verifyArtifactsBelongsToComponent(component, groupDefinition.getArtifacts(), CREATE_GROUP);
+ Either<Boolean, ResponseFormat> areValidArtifacts = verifyArtifactsBelongsToComponent(component, groupDefinition.getArtifacts(),
+ CREATE_GROUP);
if (areValidArtifacts.isRight()) {
ResponseFormat responseFormat = areValidArtifacts.right().value();
return Either.right(responseFormat);
}
List<PropertyDefinition> groupTypeProperties = groupTypeDefinition.getProperties();
-
List<GroupProperty> properties = groupDefinition.convertToGroupProperties();
List<GroupProperty> updatedGroupTypeProperties = new ArrayList<>();
if (CollectionUtils.isNotEmpty(properties)) {
if (CollectionUtils.isEmpty(groupTypeProperties)) {
BeEcompErrorManager.getInstance().logInvalidInputError(ADDING_GROUP, "group type does not have properties", ErrorSeverity.INFO);
- loggerSupportability.log(LoggerSupportabilityActions.CREATE_GROUP_POLICY,component.getComponentMetadataForSupportLog(), StatusCode.ERROR,"group {} does not have properties ",groupDefinition.getName());
- return Either.right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(JanusGraphOperationStatus.MATCH_NOT_FOUND))));
+ loggerSupportability
+ .log(LoggerSupportabilityActions.CREATE_GROUP_POLICY, component.getComponentMetadataForSupportLog(), StatusCode.ERROR,
+ "group {} does not have properties ", groupDefinition.getName());
+ return Either.right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(
+ DaoStatusConverter.convertJanusGraphStatusToStorageStatus(JanusGraphOperationStatus.MATCH_NOT_FOUND))));
}
-
- Map<String, PropertyDefinition> groupTypePropertiesMap = groupTypeProperties.stream().collect(Collectors.toMap(PropertyDefinition::getName, p -> p));
-
+ Map<String, PropertyDefinition> groupTypePropertiesMap = groupTypeProperties.stream()
+ .collect(Collectors.toMap(PropertyDefinition::getName, p -> p));
Either<GroupProperty, JanusGraphOperationStatus> addPropertyResult;
int i = 1;
for (GroupProperty prop : properties) {
addPropertyResult = handleProperty(prop, groupTypePropertiesMap.get(prop.getName()), i, allDAtaTypes, groupType);
if (addPropertyResult.isRight()) {
BeEcompErrorManager.getInstance().logInvalidInputError(ADDING_GROUP, "failed to validate property", ErrorSeverity.INFO);
- return Either.right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(addPropertyResult.right().value()))));
+ return Either.right(componentsUtils.getResponseFormat(componentsUtils
+ .convertFromStorageResponse(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(addPropertyResult.right().value()))));
}
updatedGroupTypeProperties.add(addPropertyResult.left().value());
-
i++;
}
}
-
if (groupDefinition.getUniqueId() == null) {
String uid = UniqueIdBuilder.buildGroupingUid(component.getUniqueId(), groupDefinitionName);
groupDefinition.setUniqueId(uid);
@@ -1363,42 +1311,27 @@ public class GroupBusinessLogic extends BaseBusinessLogic {
groupDefinition.setGroupUUID(UniqueIdBuilder.generateUUID());
groupDefinition.setVersion(INITIAL_VERSION);
groupDefinition.setTypeUid(groupTypeDefinition.getUniqueId());
- loggerSupportability.log(LoggerSupportabilityActions.CREATE_GROUP_POLICY,component.getComponentMetadataForSupportLog(), StatusCode.COMPLETE,"group {} has been created ",groupDefinition.getName());
+ loggerSupportability.log(LoggerSupportabilityActions.CREATE_GROUP_POLICY, component.getComponentMetadataForSupportLog(), StatusCode.COMPLETE,
+ "group {} has been created ", groupDefinition.getName());
return Either.left(groupDefinition);
}
- private static boolean groupExistsInComponent(String groupDefinitionName, Component component) {
- boolean found = false;
- List<GroupDefinition> groups = component.getGroups();
- if (CollectionUtils.isNotEmpty(groups)) {
- found = groups.stream().filter(p -> (p.getName().equalsIgnoreCase(groupDefinitionName))
- || p.getInvariantName().equalsIgnoreCase(groupDefinitionName))
- .findFirst().orElse(null) != null;
- }
- return found;
- }
-
- private Either<GroupProperty, JanusGraphOperationStatus> handleProperty(GroupProperty groupProperty, PropertyDefinition prop, Integer index, Map<String, DataTypeDefinition> allDataTypes, String groupType) {
-
+ private Either<GroupProperty, JanusGraphOperationStatus> handleProperty(GroupProperty groupProperty, PropertyDefinition prop, Integer index,
+ Map<String, DataTypeDefinition> allDataTypes, String groupType) {
if (prop == null) {
return Either.right(JanusGraphOperationStatus.ILLEGAL_ARGUMENT);
}
-
String propertyType = prop.getType();
String value = groupProperty.getValue();
-
Either<String, JanusGraphOperationStatus> checkInnerType = propertyOperation.checkInnerType(prop);
if (checkInnerType.isRight()) {
JanusGraphOperationStatus status = checkInnerType.right().value();
return Either.right(status);
}
-
String innerType = checkInnerType.left().value();
-
log.debug("Before validateAndUpdatePropertyValue");
Either<Object, Boolean> isValid = propertyOperation.validateAndUpdatePropertyValue(propertyType, value, innerType, allDataTypes);
log.debug("After validateAndUpdatePropertyValue. isValid = {}", isValid);
-
String newValue = value;
if (isValid.isRight()) {
Boolean res = isValid.right().value();
@@ -1411,10 +1344,8 @@ public class GroupBusinessLogic extends BaseBusinessLogic {
newValue = object.toString();
}
}
-
- String uniqueId = shouldReconstructUniqueId(groupType) ? UniqueIdBuilder.buildGroupPropertyValueUid(prop.getUniqueId(), index)
- : prop.getUniqueId();
-
+ String uniqueId =
+ shouldReconstructUniqueId(groupType) ? UniqueIdBuilder.buildGroupPropertyValueUid(prop.getUniqueId(), index) : prop.getUniqueId();
groupProperty.setUniqueId(uniqueId);
groupProperty.setValue(newValue);
groupProperty.setType(prop.getType());
@@ -1423,16 +1354,13 @@ public class GroupBusinessLogic extends BaseBusinessLogic {
groupProperty.setSchema(prop.getSchema());
groupProperty.setPassword(prop.isPassword());
groupProperty.setParentUniqueId(prop.getUniqueId());
-
log.debug("Before adding property value to graph {}", groupProperty);
-
return Either.left(groupProperty);
}
-
// For old groups we want to leave indexing of property
+
// For new groups we just need the types
private boolean shouldReconstructUniqueId(String groupType) {
return Constants.GROUP_TOSCA_HEAT.equals(groupType) || Constants.DEFAULT_GROUP_VF_MODULE.equals(groupType);
}
-
}