gerrit.onap Code Review - sdc.git/blob

   1 package org.openecomp.sdc.validation.base;
   2
   3 import org.apache.commons.collections4.MapUtils;
   4 import org.openecomp.core.utilities.CommonMethods;
   5 import org.openecomp.core.validation.errors.ErrorMessagesFormatBuilder;
   6 import org.openecomp.sdc.common.errors.Messages;
   7 import org.openecomp.sdc.datatypes.error.ErrorLevel;
   8 import org.openecomp.sdc.heat.datatypes.manifest.FileData;
   9 import org.openecomp.sdc.heat.datatypes.manifest.ManifestContent;
  10 import org.openecomp.sdc.heat.datatypes.model.HeatOrchestrationTemplate;
  11 import org.openecomp.sdc.heat.datatypes.model.Resource;
  12 import org.openecomp.sdc.heat.services.HeatStructureUtil;
  13 import org.openecomp.sdc.heat.services.manifest.ManifestUtil;
  14 import org.openecomp.sdc.logging.types.LoggerErrorDescription;
  15 import org.openecomp.sdc.logging.types.LoggerTragetServiceName;
  16 import org.openecomp.sdc.validation.ResourceValidator;
  17 import org.openecomp.sdc.validation.ValidationContext;
  18 import org.openecomp.sdc.validation.Validator;
  19 import org.openecomp.core.validation.types.GlobalValidationContext;
  20 import org.openecomp.sdc.datatypes.configuration.ImplementationConfiguration;
  21 import org.openecomp.sdc.logging.api.Logger;
  22 import org.openecomp.sdc.logging.api.LoggerFactory;
  23 import org.openecomp.sdc.validation.type.ConfigConstants;
  24 import org.openecomp.sdc.validation.util.ValidationUtil;
  25
  26 import java.util.HashMap;
  27 import java.util.Map;
  28 import java.util.Objects;
  29
  30 /**
  31  * Created by TALIO on 2/16/2017.
  32  */
  33 public class ResourceBaseValidator implements Validator {
  34
  35   protected Map<String, ImplementationConfiguration> resourceTypeToImpl = new HashMap<>();
  36   private static Logger logger = (Logger) LoggerFactory.getLogger(ResourceBaseValidator.class);
  37
  38
  39   public void init(Map<String, Object> properties) {
  40     if (MapUtils.isEmpty(properties)) {
  41       return;
  42     }
  43
  44     properties.entrySet().stream()
  45         .filter(entry -> getImplementationConfigurationFromProperties(entry.getValue()) != null).
  46         forEach(entry -> resourceTypeToImpl
  47             .put(entry.getKey(), getImplementationConfigurationFromProperties(entry.getValue())));
  48   }
  49
  50   @Override
  51   public void validate(GlobalValidationContext globalContext) {
  52     ManifestContent manifestContent;
  53     try {
  54       manifestContent = ValidationUtil.checkValidationPreCondition(globalContext);
  55     } catch (Exception exception) {
  56       logger.debug("",exception);
  57       return;
  58     }
  59
  60     Map<String, FileData.Type> fileTypeMap = ManifestUtil.getFileTypeMap(manifestContent);
  61     Map<String, FileData> fileEnvMap = ManifestUtil.getFileAndItsEnv(manifestContent);
  62     globalContext.getFiles().stream()
  63         .filter(fileName -> FileData
  64             .isHeatFile(fileTypeMap.get(fileName)))
  65         .forEach(fileName -> validate(fileName,
  66             fileEnvMap.get(fileName) != null ? fileEnvMap.get(fileName).getFile() : null,
  67             globalContext));
  68   }
  69
  70   private void validate(String fileName, String envFileName,
  71                         GlobalValidationContext globalContext) {
  72     HeatOrchestrationTemplate heatOrchestrationTemplate =
  73         ValidationUtil.checkHeatOrchestrationPreCondition(fileName, globalContext);
  74     if (heatOrchestrationTemplate == null) {
  75       return;
  76     }
  77
  78     ValidationContext validationContext =
  79         createValidationContext(fileName, envFileName, heatOrchestrationTemplate, globalContext);
  80
  81     Map<String, Resource> resourcesMap = heatOrchestrationTemplate.getResources();
  82     if (MapUtils.isEmpty(resourcesMap)) {
  83       return;
  84     }
  85
  86     for (Map.Entry<String, Resource> resourceEntry : resourcesMap.entrySet()) {
  87       String resourceType = resourceEntry.getValue().getType();
  88
  89       if (Objects.isNull(resourceType)) {
  90         globalContext.addMessage(fileName, ErrorLevel.WARNING, ErrorMessagesFormatBuilder
  91                 .getErrorWithParameters(Messages.INVALID_RESOURCE_TYPE.getErrorMessage(), "null",
  92                     resourceEntry.getKey()), LoggerTragetServiceName.VALIDATE_RESOURCE_TYPE,
  93             LoggerErrorDescription.INVALID_RESOURCE_TYPE);
  94       } else {
  95         ResourceValidator
  96             resourceValidatorImpl = getResourceValidatorInstance(resourceType, resourceTypeToImpl);
  97         if (Objects.nonNull(resourceValidatorImpl)) {
  98           resourceValidatorImpl.validate(fileName, resourceEntry, globalContext,
  99               validationContext);
 100         }
 101       }
 102     }
 103   }
 104
 105   public ValidationContext createValidationContext(String fileName,
 106                                                       String envFileName,
 107                                                       HeatOrchestrationTemplate heatOrchestrationTemplate,
 108                                                       GlobalValidationContext globalContext) {
 109     return null;
 110   }
 111
 112   private static boolean isSupportedResourceType(String resourceType,
 113                                                  Map<String, ImplementationConfiguration> resourceTypeToImpl) {
 114     return resourceTypeToImpl.containsKey(resourceType) && resourceTypeToImpl.get(resourceType)
 115         .isEnable();
 116
 117   }
 118
 119   private static ResourceValidator getResourceValidatorInstance(String resourceType,
 120                                                                 Map<String, ImplementationConfiguration> resourceTypeToImpl) {
 121     ResourceValidator resourceBaseValidator = null;
 122     if (isSupportedResourceType(resourceType, resourceTypeToImpl)) {
 123       return getValidatorImpl(resourceType, resourceTypeToImpl);
 124     }
 125     if (HeatStructureUtil.isNestedResource(resourceType)) {
 126       return getValidatorImpl("nestedResource", resourceTypeToImpl);
 127     }
 128     return resourceBaseValidator;
 129   }
 130
 131   private static ResourceValidator getValidatorImpl(String resourceType,
 132                                                     Map<String, ImplementationConfiguration> resourceTypeToImpl) {
 133     String implementationClass = resourceTypeToImpl.get(resourceType) != null ?
 134         resourceTypeToImpl.get(resourceType).getImplementationClass() : null;
 135     return implementationClass == null ? null : CommonMethods
 136         .newInstance(implementationClass, ResourceValidator.class);
 137   }
 138
 139   private ImplementationConfiguration getImplementationConfigurationFromProperties(Object value) {
 140     ImplementationConfiguration implementationConfiguration = new ImplementationConfiguration();
 141
 142     if (!(value instanceof Map)) {
 143       return null;
 144     }
 145
 146     Map<String, Object> valueAsMap = (Map<String, Object>) value;
 147     if (!(valueAsMap.containsKey(ConfigConstants.Impl_Class))) {
 148       return null;
 149     }
 150
 151     implementationConfiguration.setImplementationClass(
 152         valueAsMap.get(ConfigConstants.Impl_Class).toString());
 153     if (valueAsMap.containsKey(ConfigConstants.Enable)) {
 154       implementationConfiguration.setEnable((Boolean.
 155           valueOf(valueAsMap.get(ConfigConstants.Enable).toString())));
 156     }
 157
 158     return implementationConfiguration;
 159   }
 160 }