openecomp-be/lib/openecomp-sdc-validation-lib/openecomp-sdc-validation-sdk/src/main/java/org/openecomp/sdc/validation/base/ResourceBaseValidator.java

   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       return;
  57     }
  58
  59     Map<String, FileData.Type> fileTypeMap = ManifestUtil.getFileTypeMap(manifestContent);
  60     Map<String, FileData> fileEnvMap = ManifestUtil.getFileAndItsEnv(manifestContent);
  61     globalContext.getFiles().stream()
  62         .filter(fileName -> FileData
  63             .isHeatFile(fileTypeMap.get(fileName)))
  64         .forEach(fileName -> validate(fileName,
  65             fileEnvMap.get(fileName) != null ? fileEnvMap.get(fileName).getFile() : null,
  66             globalContext));
  67   }
  68
  69   private void validate(String fileName, String envFileName,
  70                         GlobalValidationContext globalContext) {
  71     HeatOrchestrationTemplate heatOrchestrationTemplate =
  72         ValidationUtil.checkHeatOrchestrationPreCondition(fileName, globalContext);
  73     if (heatOrchestrationTemplate == null) {
  74       return;
  75     }
  76
  77     ValidationContext validationContext =
  78         createValidationContext(fileName, envFileName, heatOrchestrationTemplate, globalContext);
  79
  80     Map<String, Resource> resourcesMap = heatOrchestrationTemplate.getResources();
  81     if (MapUtils.isEmpty(resourcesMap)) {
  82       return;
  83     }
  84
  85     for (Map.Entry<String, Resource> resourceEntry : resourcesMap.entrySet()) {
  86       String resourceType = resourceEntry.getValue().getType();
  87
  88       if (Objects.isNull(resourceType)) {
  89         globalContext.addMessage(fileName, ErrorLevel.WARNING, ErrorMessagesFormatBuilder
  90                 .getErrorWithParameters(Messages.INVALID_RESOURCE_TYPE.getErrorMessage(), "null",
  91                     resourceEntry.getKey()), LoggerTragetServiceName.VALIDATE_RESOURCE_TYPE,
  92             LoggerErrorDescription.INVALID_RESOURCE_TYPE);
  93       } else {
  94         ResourceValidator
  95             resourceValidatorImpl = getResourceValidatorInstance(resourceType, resourceTypeToImpl);
  96         if (Objects.nonNull(resourceValidatorImpl)) {
  97           resourceValidatorImpl.validate(fileName, resourceEntry, globalContext,
  98               validationContext);
  99         }
 100       }
 101     }
 102   }
 103
 104   public ValidationContext createValidationContext(String fileName,
 105                                                       String envFileName,
 106                                                       HeatOrchestrationTemplate heatOrchestrationTemplate,
 107                                                       GlobalValidationContext globalContext) {
 108     return null;
 109   }
 110
 111   private static boolean isSupportedResourceType(String resourceType,
 112                                                  Map<String, ImplementationConfiguration> resourceTypeToImpl) {
 113     return resourceTypeToImpl.containsKey(resourceType) && resourceTypeToImpl.get(resourceType)
 114         .isEnable();
 115
 116   }
 117
 118   private static ResourceValidator getResourceValidatorInstance(String resourceType,
 119                                                                 Map<String, ImplementationConfiguration> resourceTypeToImpl) {
 120     ResourceValidator resourceBaseValidator = null;
 121     if (isSupportedResourceType(resourceType, resourceTypeToImpl)) {
 122       return getValidatorImpl(resourceType, resourceTypeToImpl);
 123     }
 124     if (HeatStructureUtil.isNestedResource(resourceType)) {
 125       return getValidatorImpl("nestedResource", resourceTypeToImpl);
 126     }
 127     return resourceBaseValidator;
 128   }
 129
 130   private static ResourceValidator getValidatorImpl(String resourceType,
 131                                                     Map<String, ImplementationConfiguration> resourceTypeToImpl) {
 132     String implementationClass = resourceTypeToImpl.get(resourceType) != null ?
 133         resourceTypeToImpl.get(resourceType).getImplementationClass() : null;
 134     return implementationClass == null ? null : CommonMethods
 135         .newInstance(implementationClass, ResourceValidator.class);
 136   }
 137
 138   private ImplementationConfiguration getImplementationConfigurationFromProperties(Object value) {
 139     ImplementationConfiguration implementationConfiguration = new ImplementationConfiguration();
 140
 141     if (!(value instanceof Map)) {
 142       return null;
 143     }
 144
 145     Map<String, Object> valueAsMap = (Map<String, Object>) value;
 146     if (!(valueAsMap.containsKey(ConfigConstants.Impl_Class))) {
 147       return null;
 148     }
 149
 150     implementationConfiguration.setImplementationClass(
 151         valueAsMap.get(ConfigConstants.Impl_Class).toString());
 152     if (valueAsMap.containsKey(ConfigConstants.Enable)) {
 153       implementationConfiguration.setEnable((Boolean.
 154           valueOf(valueAsMap.get(ConfigConstants.Enable).toString())));
 155     }
 156
 157     return implementationConfiguration;
 158   }
 159 }