catalog-be/src/main/java/org/openecomp/sdc/be/components/validation/PolicyUtils.java

   1 package org.openecomp.sdc.be.components.validation;
   2
   3 import fj.data.Either;
   4 import org.openecomp.sdc.be.config.ConfigurationManager;
   5 import org.openecomp.sdc.be.dao.api.ActionStatus;
   6 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
   7 import org.openecomp.sdc.be.datatypes.enums.JsonPresentationFields;
   8 import org.openecomp.sdc.be.model.Component;
   9 import org.openecomp.sdc.be.model.PolicyDefinition;
  10 import org.openecomp.sdc.be.model.Resource;
  11 import org.openecomp.sdc.common.api.Constants;
  12 import org.openecomp.sdc.common.log.wrappers.Logger;
  13 import org.openecomp.sdc.common.util.ValidationUtils;
  14
  15 import java.util.Collections;
  16 import java.util.Map;
  17 import java.util.Optional;
  18 import java.util.Set;
  19
  20 import static org.apache.commons.collections.MapUtils.isEmpty;
  21 import static org.apache.commons.collections.MapUtils.isNotEmpty;
  22 import static org.apache.commons.lang3.StringUtils.isEmpty;
  23 import static org.apache.commons.lang3.StringUtils.isNotEmpty;
  24 import static org.openecomp.sdc.common.api.Constants.GROUP_POLICY_NAME_DELIMETER;
  25
  26 /**
  27  * Provides specific functionality for policy
  28  */
  29 public class PolicyUtils {
  30
  31     private static final Logger log = Logger.getLogger(PolicyUtils.class);
  32
  33     private PolicyUtils() {
  34         // No instances allowed
  35     }
  36
  37     /**
  38      * Calculates the next integer counter according to the found max counter existing in the provided policies map
  39      *
  40      * @param policies the map of the policies
  41      * @return the integer counter
  42      */
  43     public static int getNextPolicyCounter(Map<String, PolicyDefinition> policies) {
  44         int nextCounter = 0;
  45         if (isNotEmpty(policies)) {
  46             int nextCounterFromIds = policies.values()
  47                                              .stream()
  48                                              .map(p -> extractNextPolicyCounterFromUniqueId(p.getUniqueId()))
  49                                              .max(Integer::compareTo)
  50                                              .orElse(0);
  51             int nextCounterFromNames = policies.values()
  52                                                .stream()
  53                                                .map(p -> extractNextPolicyCounterFromName(p.getName()))
  54                                                .max(Integer::compareTo)
  55                                                .orElse(0);
  56             nextCounter = nextCounterFromIds > nextCounterFromNames ? nextCounterFromIds : nextCounterFromNames;
  57         }
  58         return nextCounter;
  59     }
  60
  61     /**
  62      * Validates policy fields on policy update. Updates mutable fields
  63      *
  64      * @param recievedPolicy the policy parsed from the HTTP request
  65      * @param validPolicy    the copy of the existing policy found on the component
  66      * @param policies       all the polices related to the component
  67      * @return validated and updated policy or an error as action status
  68      */
  69     public static Either<PolicyDefinition, ActionStatus> validatePolicyFields(PolicyDefinition recievedPolicy, PolicyDefinition validPolicy, Map<String, PolicyDefinition> policies) {
  70         validateImmutablePolicyFields(recievedPolicy, validPolicy);
  71         return validateUpdateMutablePolicyFields(recievedPolicy, validPolicy, policies);
  72     }
  73
  74     /**
  75      * Retrieves the set of the excluded policy types for the specified component
  76      *
  77      * @return the set of the policies
  78      */
  79     public static Set<String> getExcludedPolicyTypesByComponent(Component component) {
  80         if (isEmpty(ConfigurationManager.getConfigurationManager()
  81                                         .getConfiguration()
  82                                         .getExcludedPolicyTypesMapping())) {
  83             return Collections.emptySet();
  84         }
  85         if (component.getComponentType() == ComponentTypeEnum.SERVICE) {
  86             return ConfigurationManager.getConfigurationManager()
  87                                        .getConfiguration()
  88                                        .getExcludedPolicyTypesMapping()
  89                                        .get(component.getComponentType().name());
  90         }
  91         return ConfigurationManager.getConfigurationManager()
  92                                    .getConfiguration()
  93                                    .getExcludedPolicyTypesMapping()
  94                                    .get(((Resource) component).getResourceType().getValue());
  95     }
  96
  97     private static int extractNextPolicyCounterFromUniqueId(String uniqueId) {
  98         int counter = 0;
  99         if (isNotEmpty(uniqueId)) {
 100             counter = extractNextPolicyCounter(uniqueId, uniqueId.lastIndexOf(Constants.POLICY_UID_POSTFIX));
 101         }
 102         return counter;
 103     }
 104
 105     private static int extractNextPolicyCounterFromName(String policyName) {
 106         int counter = 0;
 107         if (isNotEmpty(policyName)) {
 108             counter = extractNextPolicyCounter(policyName, policyName.length());
 109         }
 110         return counter;
 111     }
 112
 113     private static int extractNextPolicyCounter(String policyName, int endIndex) {
 114         int counter = 0;
 115         try {
 116             int beginIndex = policyName.lastIndexOf(GROUP_POLICY_NAME_DELIMETER) + GROUP_POLICY_NAME_DELIMETER.length();
 117             String counterStr = policyName.substring(beginIndex, endIndex);
 118             counter = Integer.valueOf(counterStr) + 1;
 119         }
 120         catch (NumberFormatException | IndexOutOfBoundsException e) {
 121             log.error("#extractNextPolicyCounter - An error occurred when attempting to extract counter from policy name [{}]. ", policyName, e);
 122         }
 123         return counter;
 124     }
 125
 126     private static Either<PolicyDefinition, ActionStatus> validateUpdateMutablePolicyFields(PolicyDefinition recievedPolicy, PolicyDefinition validPolicy, Map<String, PolicyDefinition> policies) {
 127         return validateUpdatePolicyName(recievedPolicy, validPolicy, policies);
 128     }
 129
 130     private static void validateImmutablePolicyFields(PolicyDefinition receivedPolicy, PolicyDefinition validPolicy) {
 131         logImmutableFieldUpdateWarning(receivedPolicy.getUniqueId(), validPolicy.getUniqueId(), JsonPresentationFields.UNIQUE_ID);
 132         logImmutableFieldUpdateWarning(receivedPolicy.getComponentName(), validPolicy.getComponentName(), JsonPresentationFields.CI_COMPONENT_NAME);
 133         logImmutableFieldUpdateWarning(receivedPolicy.getDerivedFrom(), validPolicy.getDerivedFrom(), JsonPresentationFields.DERIVED_FROM);
 134         logImmutableFieldUpdateWarning(receivedPolicy.getDescription(), validPolicy.getDescription(), JsonPresentationFields.DESCRIPTION);
 135         logImmutableFieldUpdateWarning(receivedPolicy.getInvariantName(), validPolicy.getInvariantName(), JsonPresentationFields.CI_INVARIANT_NAME);
 136         logImmutableFieldUpdateWarning(receivedPolicy.getInvariantUUID(), validPolicy.getInvariantUUID(), JsonPresentationFields.INVARIANT_UUID);
 137         logImmutableFieldUpdateWarning(receivedPolicy.getPolicyTypeName(), validPolicy.getPolicyTypeName(), JsonPresentationFields.TYPE);
 138         logImmutableFieldUpdateWarning(receivedPolicy.getPolicyTypeUid(), validPolicy.getPolicyTypeUid(), JsonPresentationFields.TYPE_UNIQUE_ID);
 139         logImmutableFieldUpdateWarning(receivedPolicy.getPolicyUUID(), validPolicy.getPolicyUUID(), JsonPresentationFields.UUID);
 140         logImmutableFieldUpdateWarning(receivedPolicy.getVersion(), validPolicy.getVersion(), JsonPresentationFields.VERSION);
 141         logImmutableFieldUpdateWarning(receivedPolicy.getIsFromCsar().toString(), validPolicy.getIsFromCsar().toString(), JsonPresentationFields.IS_FROM_CSAR);
 142     }
 143
 144     private static boolean isUpdatedField(String oldField, String newField) {
 145         boolean isUpdatedField = false;
 146         if (isEmpty(oldField) && isNotEmpty(newField)) {
 147             isUpdatedField = true;
 148         }
 149         else if (isNotEmpty(oldField) && isNotEmpty(newField) && !oldField.equals(newField)) {
 150             isUpdatedField = true;
 151         }
 152         return isUpdatedField;
 153     }
 154
 155     private static void logImmutableFieldUpdateWarning(String oldValue, String newValue, JsonPresentationFields field) {
 156         if (isUpdatedField(oldValue, newValue)) {
 157             log.warn("#logImmutableFieldUpdateWarning - Update of the field {} of a policy not allowed. The change will be ignored. The old value is {} , the new value is {}. ", field, oldValue, newValue);
 158         }
 159     }
 160
 161     private static Either<PolicyDefinition, ActionStatus> validateUpdatePolicyName(PolicyDefinition receivedPolicy, PolicyDefinition validPolicy, Map<String, PolicyDefinition> policies) {
 162         Either<PolicyDefinition, ActionStatus> result = null;
 163         Optional<PolicyDefinition> sameNamePolicy = Optional.empty();
 164         if (isEmpty(receivedPolicy.getName()) || !ValidationUtils.POLICY_NAME_PATTERN.matcher(receivedPolicy
 165                 .getName()).matches()) {
 166             log.error("#validateUpdatePolicyName - Failed to validate the name {} of the policy {}. ", receivedPolicy.getName(), receivedPolicy.getUniqueId());
 167             result = Either.right(ActionStatus.INVALID_POLICY_NAME);
 168         }
 169         if (result == null && isNotEmpty(policies)) {
 170             sameNamePolicy = policies.values()
 171                                      .stream()
 172                                      .filter(p -> p.getName().equals(receivedPolicy.getName()))
 173                                      .findFirst();
 174         }
 175         if (sameNamePolicy.isPresent()) {
 176             log.error("#validateUpdatePolicyName - Failed to validate the name {} of the policy {}. The policy {} with the same name already exists. ", receivedPolicy
 177                     .getName(), receivedPolicy.getUniqueId(), sameNamePolicy.get().getUniqueId());
 178             result = Either.right(ActionStatus.POLICY_NAME_ALREADY_EXIST);
 179         }
 180         if (result == null) {
 181             validPolicy.setName(receivedPolicy.getName());
 182             result = Either.left(validPolicy);
 183         }
 184         return result;
 185     }
 186 }