Upgrade Vulnerable Direct Dependencies [snakeyaml]
[sdc.git] / openecomp-be / lib / openecomp-sdc-validation-lib / openecomp-sdc-validation-impl / src / main / java / org / openecomp / sdc / validation / impl / validators / namingconvention / NeutronPortNamingConventionValidator.java
index b3d3461..760c73a 100644 (file)
@@ -30,146 +30,114 @@ import org.openecomp.sdc.validation.ValidationContext;
 import org.openecomp.sdc.validation.type.NamingConventionValidationContext;
 import org.openecomp.sdc.validation.util.ValidationUtil;
 
+import java.util.Arrays;
 import java.util.List;
 import java.util.Map;
 
 import static java.util.Objects.nonNull;
 
 public class NeutronPortNamingConventionValidator implements ResourceValidator {
-  private static final ErrorMessageCode ERROR_CODE_NNP1 = new ErrorMessageCode("NNP1");
-  private static final ErrorMessageCode ERROR_CODE_NNP2 = new ErrorMessageCode("NNP2");
-  private static final ErrorMessageCode ERROR_CODE_NNP3 = new ErrorMessageCode("NNP3");
-
-  @Override
-  public void validate(String fileName, Map.Entry<String, Resource> resourceEntry,
-                       GlobalValidationContext globalContext, ValidationContext validationContext) {
-
-    NamingConventionValidationContext namingConventionValidationContext =
-            (NamingConventionValidationContext)validationContext;
-    validatePortNetworkNamingConvention(fileName, namingConventionValidationContext.getHeatOrchestrationTemplate(),
-            globalContext);
-    validateFixedIpsNamingConvention(fileName, namingConventionValidationContext.getHeatOrchestrationTemplate(),
-            globalContext);
-  }
-
-  private void validatePortNetworkNamingConvention(String fileName,
-                                                   HeatOrchestrationTemplate heatOrchestrationTemplate,
-                                                   GlobalValidationContext globalContext) {
-    if (MapUtils.isEmpty(heatOrchestrationTemplate.getResources())) {
-      return;
+    private static final ErrorMessageCode ERROR_CODE_NNP1 = new ErrorMessageCode("NNP1");
+    private static final ErrorMessageCode ERROR_CODE_NNP2 = new ErrorMessageCode("NNP2");
+    private static final ErrorMessageCode ERROR_CODE_NNP3 = new ErrorMessageCode("NNP3");
+
+    @Override
+    public void validate(String fileName, Map.Entry<String, Resource> resourceEntry,
+                         GlobalValidationContext globalContext, ValidationContext validationContext) {
+        NamingConventionValidationContext namingConventionValidationContext = (NamingConventionValidationContext) validationContext;
+        validatePortNetworkNamingConvention(fileName, namingConventionValidationContext.getHeatOrchestrationTemplate(), globalContext);
+        validateFixedIpsNamingConvention(fileName, namingConventionValidationContext.getHeatOrchestrationTemplate(), globalContext);
     }
-    String[] regexList = {".*_net_id", ".*_net_name", ".*_net_fqdn"};
-
-    heatOrchestrationTemplate
-            .getResources()
-            .entrySet()
-            .stream()
-            .filter(entry -> entry.getValue().getType()
-                    .equals(HeatResourcesTypes.NEUTRON_PORT_RESOURCE_TYPE.getHeatResource()))
-            .forEach(entry -> entry.getValue()
-                    .getProperties()
-                    .entrySet()
-                    .stream()
-                    .filter(propertyEntry ->
-                            ("network").equalsIgnoreCase(propertyEntry.getKey())
-                                    || ("network_id").equals(propertyEntry.getKey()))
-                    .forEach(propertyEntry -> validateParamNamingConvention(fileName, entry.getKey(),
-                            propertyEntry.getValue(),  regexList,
-                            Messages.PARAMETER_NAME_NOT_ALIGNED_WITH_GUIDELINES, globalContext)));
-  }
 
-  private void validateFixedIpsNamingConvention(String fileName,
-                                                HeatOrchestrationTemplate heatOrchestrationTemplate,
-                                                GlobalValidationContext globalContext) {
-    if (MapUtils.isEmpty(heatOrchestrationTemplate.getResources())) {
-      return;
+    private void validatePortNetworkNamingConvention(String fileName,
+                                                     HeatOrchestrationTemplate heatOrchestrationTemplate,
+                                                     GlobalValidationContext globalContext) {
+        if (MapUtils.isEmpty(heatOrchestrationTemplate.getResources())) {
+            return;
+        }
+        String[] regexList = {".*_net_id", ".*_net_name", ".*_net_fqdn"};
+
+        heatOrchestrationTemplate
+                .getResources()
+                .entrySet()
+                .stream()
+                .filter(entry -> entry.getValue().getType().equals(HeatResourcesTypes.NEUTRON_PORT_RESOURCE_TYPE.getHeatResource()))
+                .forEach(entry -> entry.getValue()
+                        .getProperties()
+                        .entrySet()
+                        .stream()
+                        .filter(propertyEntry -> ("network").equalsIgnoreCase(propertyEntry.getKey()) || ("network_id").equals(propertyEntry.getKey()))
+                        .forEach(propertyEntry -> validateParamNamingConvention(fileName, entry.getKey(),
+                                propertyEntry.getValue(), regexList,
+                                Messages.PARAMETER_NAME_NOT_ALIGNED_WITH_GUIDELINES, globalContext)));
     }
 
-    heatOrchestrationTemplate.getResources()
-            .entrySet()
-            .stream()
-            .filter(entry -> HeatResourcesTypes.findByHeatResource(entry.getValue().getType()) != null)
-            .filter(entry -> HeatResourcesTypes.findByHeatResource(entry.getValue().getType())
-                    .equals(HeatResourcesTypes.NEUTRON_PORT_RESOURCE_TYPE))
-            .forEach(entry -> checkNeutronPortFixedIpsName(fileName, entry, globalContext));
-  }
-
-  private void checkNeutronPortFixedIpsName(String fileName,
-                                            Map.Entry<String, Resource> resourceEntry,
-                                            GlobalValidationContext globalContext) {
-    String[] regexList = {"[^_]+_[^_]+_ips", "[^_]+_[^_]+_v6_ips", "[^_]+_[^_]+_ip_(\\d+)",
-                    "[^_]+_[^_]+_v6_ip_(\\d+)", "[^_]+_[^_]+_[^_]+_ips", "[^_]+_[^_]+_[^_]+_v6_ips",
-                    "[^_]+_[^_]+_[^_]+_ip_(\\d+)", "[^_]+_[^_]+_[^_]+_v6_ip_(\\d+)"};
+    private void validateFixedIpsNamingConvention(String fileName,
+                                                  HeatOrchestrationTemplate heatOrchestrationTemplate,
+                                                  GlobalValidationContext globalContext) {
+        if (MapUtils.isEmpty(heatOrchestrationTemplate.getResources())) {
+            return;
+        }
 
-    if (MapUtils.isEmpty(resourceEntry.getValue().getProperties())) {
-      return;
+        heatOrchestrationTemplate.getResources()
+                .entrySet()
+                .stream()
+                .filter(entry -> HeatResourcesTypes.findByHeatResource(entry.getValue().getType()) != null)
+                .filter(entry -> HeatResourcesTypes.findByHeatResource(entry.getValue().getType())
+                        .equals(HeatResourcesTypes.NEUTRON_PORT_RESOURCE_TYPE))
+                .forEach(entry -> checkNeutronPortFixedIpsName(fileName, entry, globalContext));
     }
 
-    Map<String, Object> propertiesMap = resourceEntry.getValue().getProperties();
-    Object fixedIps = propertiesMap.get("fixed_ips");
-    if (nonNull(fixedIps) && fixedIps instanceof List) {
-      List<Object> fixedIpsList = (List<Object>) fixedIps;
-      for (Object fixedIpsObject : fixedIpsList) {
-        Map.Entry<String, Object> fixedIpsEntry =
-                ((Map<String, Object>) fixedIpsObject).entrySet().iterator().next();
-
-        validateFixedIpsName(fileName, resourceEntry, globalContext, regexList, fixedIpsEntry);
+    private void checkNeutronPortFixedIpsName(String fileName,
+                                              Map.Entry<String, Resource> resourceEntry,
+                                              GlobalValidationContext globalContext) {
+        String[] regexList = {"[^_]+_[^_]+_ips", "[^_]+_[^_]+_v6_ips", "[^_]+_[^_]+_ip_(\\d+)",
+                "[^_]+_[^_]+_v6_ip_(\\d+)", "[^_]+_[^_]+_[^_]+_ips", "[^_]+_[^_]+_[^_]+_v6_ips",
+                "[^_]+_[^_]+_[^_]+_ip_(\\d+)", "[^_]+_[^_]+_[^_]+_v6_ip_(\\d+)"};
 
+        if (MapUtils.isEmpty(resourceEntry.getValue().getProperties())) {
+            return;
+        }
 
-      }
+        Map<String, Object> propertiesMap = resourceEntry.getValue().getProperties();
+        Object fixedIps = propertiesMap.get("fixed_ips");
+        if (nonNull(fixedIps) && fixedIps instanceof List) {
+            List<Object> fixedIpsList = (List<Object>) fixedIps;
+            for (Object fixedIpsObject : fixedIpsList) {
+                Map.Entry<String, Object> fixedIpsEntry = ((Map<String, Object>) fixedIpsObject).entrySet().iterator().next();
+                validateFixedIpsName(fileName, resourceEntry, globalContext, regexList, fixedIpsEntry);
+            }
+        }
     }
-  }
-
-  private void validateFixedIpsName(String fileName, Map.Entry<String, Resource> resourceEntry,
-                                    GlobalValidationContext globalContext,
-                                    String[] regexList, Map.Entry<String, Object> fixedIpsEntry) {
-    if (nonNull(fixedIpsEntry)) {
-      if (fixedIpsEntry.getValue() instanceof Map) {
-
-        String fixedIpsName = ValidationUtil
-                .getWantedNameFromPropertyValueGetParam(fixedIpsEntry.getValue());
 
-          if (nonNull(fixedIpsName) && !ValidationUtil.evalPattern(fixedIpsName, regexList)) {
-            globalContext.addMessage(fileName, ErrorLevel.WARNING, ErrorMessagesFormatBuilder.getErrorWithParameters(ERROR_CODE_NNP1, Messages.PARAMETER_NAME_NOT_ALIGNED_WITH_GUIDELINES.getErrorMessage(),
-                            "Port", "Fixed_IPS", fixedIpsName, resourceEntry.getKey()));
-          }
-
-
-      } else {
-        globalContext.addMessage(
-                fileName,
-                ErrorLevel.WARNING, ErrorMessagesFormatBuilder
-                        .getErrorWithParameters(
-                                ERROR_CODE_NNP2, Messages.MISSING_GET_PARAM.getErrorMessage(),
-                                "fixed_ips", resourceEntry.getKey()));
-      }
+    private void validateFixedIpsName(String fileName, Map.Entry<String, Resource> resourceEntry, GlobalValidationContext globalContext,
+                                      String[] regexList, Map.Entry<String, Object> fixedIpsEntry) {
+        if (nonNull(fixedIpsEntry)) {
+            if (fixedIpsEntry.getValue() instanceof Map) {
+                String fixedIpsName = ValidationUtil.getWantedNameFromPropertyValueGetParam(fixedIpsEntry.getValue());
+                if (nonNull(fixedIpsName) && !ValidationUtil.evalPattern(fixedIpsName, regexList)) {
+                    globalContext.addMessage(fileName, ErrorLevel.WARNING, ErrorMessagesFormatBuilder
+                            .getErrorWithParameters(ERROR_CODE_NNP1, Messages.PARAMETER_NAME_NOT_ALIGNED_WITH_GUIDELINES.getErrorMessage(),
+                                    "Port", "Fixed_IPS", fixedIpsName, resourceEntry.getKey()));
+                }
+            } else {
+                globalContext.addMessage(fileName, ErrorLevel.WARNING, ErrorMessagesFormatBuilder.
+                        getErrorWithParameters(ERROR_CODE_NNP2, Messages.MISSING_GET_PARAM.getErrorMessage(), "fixed_ips", resourceEntry.getKey()));
+            }
+        }
     }
-  }
 
-  private void validateParamNamingConvention(String fileName, String resourceId,
-                                             Object propertyValue,
-                                              String[] regexList,
-                                             Messages message,
-                                             GlobalValidationContext globalContext) {
-    Object paramName;
-    if (propertyValue instanceof Map) {
-      paramName = ((Map) propertyValue).get("get_param");
-        if (paramName instanceof String && !ValidationUtil.evalPattern(paramName, regexList)) {
-          globalContext.addMessage(
-                  fileName,
-                  ErrorLevel.WARNING, ErrorMessagesFormatBuilder
-                          .getErrorWithParameters(ERROR_CODE_NNP3, message.getErrorMessage(), "Port",
-                                  "Network", (String) paramName, resourceId));
+    private void validateParamNamingConvention(String fileName, String resourceId, Object propertyValue, String[] regexList,
+                                               Messages message, GlobalValidationContext globalContext) {
+        if (propertyValue instanceof Map) {
+            Object paramName = ((Map) propertyValue).get("get_param");
+            if (paramName instanceof String && !ValidationUtil.evalPattern(paramName, regexList)) {
+                globalContext.addMessage(fileName, ErrorLevel.WARNING, ErrorMessagesFormatBuilder
+                        .getErrorWithParameters(ERROR_CODE_NNP3, message.getErrorMessage(), "Port", "Network", (String) paramName, resourceId));
+            }
+        } else {
+            globalContext.addMessage(fileName, ErrorLevel.WARNING, ErrorMessagesFormatBuilder
+                    .getErrorWithParameters(ERROR_CODE_NNP2, Messages.MISSING_GET_PARAM.getErrorMessage(), "network or network_id", resourceId));
         }
-
-    } else {
-      globalContext.addMessage(
-              fileName,
-              ErrorLevel.WARNING,
-              ErrorMessagesFormatBuilder
-                      .getErrorWithParameters(
-                              ERROR_CODE_NNP2, Messages.MISSING_GET_PARAM.getErrorMessage(),
-                              "network or network_id", resourceId));
     }
-  }
 }