openecomp-be/lib/openecomp-sdc-validation-lib/openecomp-sdc-validation-impl/src/main/java/org/openecomp/sdc/validation/impl/validators/SharedResourceGuideLineValidator.java

   1 package org.openecomp.sdc.validation.impl.validators;
   2
   3 import org.apache.commons.collections4.CollectionUtils;
   4 import org.openecomp.sdc.logging.api.Logger;
   5 import org.openecomp.sdc.logging.api.LoggerFactory;
   6 import org.openecomp.sdc.validation.Validator;
   7 import org.openecomp.core.validation.errors.ErrorMessagesFormatBuilder;
   8 import org.openecomp.core.validation.types.GlobalValidationContext;
   9 import org.openecomp.sdc.common.errors.Messages;
  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.HeatResourcesTypes;
  15 import org.openecomp.sdc.heat.datatypes.model.ResourceReferenceFunctions;
  16 import org.openecomp.sdc.heat.services.HeatStructureUtil;
  17 import org.openecomp.sdc.heat.services.manifest.ManifestUtil;
  18 import org.openecomp.sdc.logging.context.impl.MdcDataDebugMessage;
  19 import org.openecomp.sdc.logging.types.LoggerErrorDescription;
  20 import org.openecomp.sdc.logging.types.LoggerTragetServiceName;
  21 import org.openecomp.sdc.validation.util.ValidationUtil;
  22
  23 import java.util.HashSet;
  24 import java.util.Map;
  25 import java.util.Set;
  26
  27 /**
  28  * Created by TALIO on 2/15/2017.
  29  */
  30 public class SharedResourceGuideLineValidator implements Validator {
  31   public static final MdcDataDebugMessage mdcDataDebugMessage = new MdcDataDebugMessage();
  32   private final Logger log = (Logger) LoggerFactory.getLogger(this.getClass().getName());
  33
  34   @Override
  35   public void validate(GlobalValidationContext globalContext) {
  36     ManifestContent manifestContent;
  37     try {
  38       manifestContent = ValidationUtil.checkValidationPreCondition(globalContext);
  39     } catch (Exception exception) {
  40       log.debug("",exception);
  41       return;
  42     }
  43
  44     Set<String> baseFiles = ValidationUtil.validateManifest(manifestContent, globalContext);
  45
  46     Map<String, FileData.Type> fileTypeMap = ManifestUtil.getFileTypeMap(manifestContent);
  47     Map<String, FileData> fileEnvMap = ManifestUtil.getFileAndItsEnv(manifestContent);
  48     globalContext.getFiles().stream()
  49         .filter(fileName -> FileData
  50             .isHeatFile(fileTypeMap.get(fileName)))
  51         .forEach(fileName -> validate(fileName,
  52             fileEnvMap.get(fileName) != null ? fileEnvMap.get(fileName).getFile() : null,
  53             fileTypeMap, baseFiles, globalContext));
  54
  55
  56   }
  57
  58   private void validate(String fileName, String envFileName, Map<String, FileData.Type> fileTypeMap,
  59                         Set<String> baseFiles, GlobalValidationContext globalContext) {
  60     HeatOrchestrationTemplate
  61         heatOrchestrationTemplate = ValidationUtil.checkHeatOrchestrationPreCondition(fileName, globalContext);
  62     if (heatOrchestrationTemplate == null) {
  63       return;
  64     }
  65
  66     validateBaseFile(fileName, baseFiles, heatOrchestrationTemplate, globalContext);
  67     validateHeatVolumeFile(fileName, fileTypeMap, heatOrchestrationTemplate, globalContext);
  68   }
  69
  70
  71   private void validateBaseFile(String fileName, Set<String> baseFiles,
  72                                 HeatOrchestrationTemplate heatOrchestrationTemplate,
  73                                 GlobalValidationContext globalContext) {
  74
  75
  76     mdcDataDebugMessage.debugEntryMessage("file", fileName);
  77     //if not base return
  78     if (baseFiles == null || !baseFiles.contains(fileName)) {
  79       mdcDataDebugMessage.debugExitMessage("file", fileName);
  80       return;
  81     }
  82
  83     //if no resources exist return
  84     if (heatOrchestrationTemplate.getResources() == null
  85         || heatOrchestrationTemplate.getResources().size() == 0) {
  86       mdcDataDebugMessage.debugExitMessage("file", fileName);
  87       return;
  88     }
  89
  90     Set<String> expectedExposedResources = new HashSet<>();
  91     Set<String> actualExposedResources = new HashSet<>();
  92     heatOrchestrationTemplate.getResources()
  93         .entrySet()
  94         .stream()
  95         .filter(entry -> ValidationUtil.isExpectedToBeExposed(entry.getValue().getType()))
  96         .forEach(entry -> expectedExposedResources.add(entry.getKey()));
  97
  98     if (heatOrchestrationTemplate.getOutputs() != null) {
  99
 100       heatOrchestrationTemplate.getOutputs().entrySet()
 101           .stream()
 102           .filter(entry -> isPropertyValueGetResource(fileName, entry.getValue().getValue(),
 103               globalContext))
 104           .forEach(entry -> actualExposedResources.add(
 105               getResourceIdFromPropertyValue(fileName, entry.getValue().getValue(),
 106                   globalContext)));
 107     }
 108
 109     ValidationUtil.removeExposedResourcesCalledByGetResource(fileName, actualExposedResources,
 110         heatOrchestrationTemplate, globalContext);
 111
 112     actualExposedResources.forEach(expectedExposedResources::remove);
 113
 114     if (expectedExposedResources.size() > 0) {
 115       expectedExposedResources
 116           .stream()
 117           .forEach(name -> globalContext.addMessage(
 118               fileName,
 119               ErrorLevel.WARNING, ErrorMessagesFormatBuilder
 120                   .getErrorWithParameters(Messages.RESOURCE_NOT_DEFINED_IN_OUTPUT.getErrorMessage(),
 121                       name),
 122               LoggerTragetServiceName.VALIDATE_BASE_FILE,
 123               LoggerErrorDescription.RESOURCE_NOT_DEFINED_AS_OUTPUT));
 124     }
 125
 126     mdcDataDebugMessage.debugExitMessage("file", fileName);
 127   }
 128
 129   private void validateHeatVolumeFile(String fileName, Map<String, FileData.Type> fileTypeMap,
 130                                       HeatOrchestrationTemplate heatOrchestrationTemplate,
 131                                       GlobalValidationContext globalContext) {
 132
 133
 134     mdcDataDebugMessage.debugEntryMessage("file", fileName);
 135
 136     //if not heat volume return
 137     if (!fileTypeMap.get(fileName).equals(FileData.Type.HEAT_VOL)) {
 138       mdcDataDebugMessage.debugExitMessage("file", fileName);
 139       return;
 140     }
 141
 142     //if no resources exist return
 143     if (heatOrchestrationTemplate.getResources() == null
 144         || heatOrchestrationTemplate.getResources().size() == 0) {
 145       mdcDataDebugMessage.debugExitMessage("file", fileName);
 146       return;
 147     }
 148
 149     Set<String> expectedExposedResources = new HashSet<>();
 150     Set<String> actualExposedResources = new HashSet<>();
 151     heatOrchestrationTemplate.getResources()
 152         .entrySet()
 153         .stream()
 154         .filter(entry -> entry.getValue().getType()
 155             .equals(HeatResourcesTypes.CINDER_VOLUME_RESOURCE_TYPE.getHeatResource()))
 156         .forEach(entry -> expectedExposedResources.add(entry.getKey()));
 157
 158     if (heatOrchestrationTemplate.getOutputs() != null) {
 159
 160       heatOrchestrationTemplate.getOutputs().entrySet()
 161           .stream()
 162           .filter(entry -> isPropertyValueGetResource(fileName, entry.getValue().getValue(),
 163               globalContext))
 164           .forEach(entry -> actualExposedResources.add(
 165               getResourceIdFromPropertyValue(fileName, entry.getValue().getValue(),
 166                   globalContext)));
 167     }
 168
 169     actualExposedResources.forEach(expectedExposedResources::remove);
 170
 171     if (expectedExposedResources.size() > 0) {
 172       expectedExposedResources
 173           .stream()
 174           .forEach(name -> globalContext.addMessage(
 175               fileName,
 176               ErrorLevel.WARNING, ErrorMessagesFormatBuilder
 177                   .getErrorWithParameters(Messages.VOLUME_HEAT_NOT_EXPOSED.getErrorMessage(), name),
 178               LoggerTragetServiceName.VALIDATE_VOLUME_FILE,
 179               LoggerErrorDescription.VOLUME_FILE_NOT_EXPOSED));
 180     }
 181
 182     mdcDataDebugMessage.debugExitMessage("file", fileName);
 183   }
 184
 185
 186   private boolean isPropertyValueGetResource(String filename, Object value,
 187                                              GlobalValidationContext globalContext) {
 188     Set<String> referenceValues = HeatStructureUtil.getReferencedValuesByFunctionName(filename,
 189         ResourceReferenceFunctions.GET_RESOURCE.getFunction(), value, globalContext);
 190     return referenceValues != null && (referenceValues.size() > 0);
 191   }
 192
 193   private String getResourceIdFromPropertyValue(String filename, Object value,
 194                                                 GlobalValidationContext globalContext) {
 195     Set<String> referenceValues = HeatStructureUtil.getReferencedValuesByFunctionName(filename,
 196         ResourceReferenceFunctions.GET_RESOURCE.getFunction(), value, globalContext);
 197     if (referenceValues != null && CollectionUtils.isNotEmpty(referenceValues)) {
 198       return (String) referenceValues.toArray()[0];
 199     }
 200     return null;
 201   }
 202
 203 }