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