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