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