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

   1 /*
   2  * Copyright © 2016-2017 European Support Limited
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 package org.openecomp.sdc.validation.impl.validators;
  18
  19 import org.apache.commons.collections4.CollectionUtils;
  20 import org.apache.commons.collections4.MapUtils;
  21 import org.openecomp.core.validation.ErrorMessageCode;
  22 import org.openecomp.core.validation.errors.ErrorMessagesFormatBuilder;
  23 import org.openecomp.core.validation.types.GlobalValidationContext;
  24 import org.openecomp.sdc.common.errors.Messages;
  25 import org.openecomp.sdc.datatypes.error.ErrorLevel;
  26 import org.openecomp.sdc.heat.datatypes.DefinedHeatParameterTypes;
  27 import org.openecomp.sdc.heat.datatypes.manifest.FileData;
  28 import org.openecomp.sdc.heat.datatypes.manifest.ManifestContent;
  29 import org.openecomp.sdc.heat.datatypes.model.Environment;
  30 import org.openecomp.sdc.heat.datatypes.model.HeatOrchestrationTemplate;
  31 import org.openecomp.sdc.heat.datatypes.model.HeatPseudoParameters;
  32 import org.openecomp.sdc.heat.datatypes.model.HeatResourcesTypes;
  33 import org.openecomp.sdc.heat.datatypes.model.Output;
  34 import org.openecomp.sdc.heat.datatypes.model.Parameter;
  35 import org.openecomp.sdc.heat.datatypes.model.Resource;
  36 import org.openecomp.sdc.heat.datatypes.model.ResourceReferenceFunctions;
  37 import org.openecomp.sdc.heat.services.HeatStructureUtil;
  38 import org.openecomp.sdc.heat.services.manifest.ManifestUtil;
  39 import org.openecomp.sdc.logging.api.Logger;
  40 import org.openecomp.sdc.logging.api.LoggerFactory;
  41 import org.onap.sdc.tosca.services.YamlUtil;
  42 import org.openecomp.sdc.validation.Validator;
  43 import org.openecomp.sdc.validation.impl.util.HeatValidationService;
  44 import org.openecomp.sdc.validation.util.ValidationUtil;
  45
  46 import java.io.InputStream;
  47 import java.util.Collection;
  48 import java.util.HashSet;
  49 import java.util.List;
  50 import java.util.Map;
  51 import java.util.Objects;
  52 import java.util.Optional;
  53 import java.util.Set;
  54
  55 public class HeatValidator implements Validator {
  56   private static final Logger LOGGER = LoggerFactory.getLogger(HeatValidator.class);
  57   private static final ErrorMessageCode ERROR_CODE_HOT_1 = new ErrorMessageCode("HOT1");
  58   private static final ErrorMessageCode ERROR_CODE_HOT_2 = new ErrorMessageCode("HOT2");
  59   private static final ErrorMessageCode ERROR_CODE_HOT_3 = new ErrorMessageCode("HOT3");
  60   private static final ErrorMessageCode ERROR_CODE_HOT_4 = new ErrorMessageCode("HOT4");
  61   private static final ErrorMessageCode ERROR_CODE_HOT_5 = new ErrorMessageCode("HOT5");
  62   private static final ErrorMessageCode ERROR_CODE_HOT_6 = new ErrorMessageCode("HOT6");
  63   private static final ErrorMessageCode ERROR_CODE_HOT_7 = new ErrorMessageCode("HOT7");
  64   private static final ErrorMessageCode ERROR_CODE_HOT_8 = new ErrorMessageCode("HOT8");
  65   private static final ErrorMessageCode ERROR_CODE_HOT_9 = new ErrorMessageCode("HOT9");
  66   private static final ErrorMessageCode ERROR_CODE_HOT_10 = new ErrorMessageCode("HOT10");
  67   private static final ErrorMessageCode ERROR_CODE_HOT_11 = new ErrorMessageCode("HOT11");
  68   private static final ErrorMessageCode ERROR_CODE_HOT_12 = new ErrorMessageCode("HOT12");
  69   private static final ErrorMessageCode ERROR_CODE_HOT_13 = new ErrorMessageCode("HOT13");
  70   private static final ErrorMessageCode ERROR_CODE_HOT_14 = new ErrorMessageCode("HOT14");
  71   private static final ErrorMessageCode ERROR_CODE_HOT_15 = new ErrorMessageCode("HOT15");
  72   private static final ErrorMessageCode ERROR_CODE_HOT_16 = new ErrorMessageCode("HOT16");
  73   private static final ErrorMessageCode ERROR_CODE_HOT_17 = new ErrorMessageCode("HOT17");
  74
  75   private static void validateAllRequiredArtifactsExist(String fileName,
  76                                                         HeatOrchestrationTemplate
  77                                                             heatOrchestrationTemplate,
  78                                                         Set<String> artifacts,
  79                                                         GlobalValidationContext globalContext) {
  80     Collection<Resource> resourcesValues = heatOrchestrationTemplate.getResources() == null ? null
  81         : heatOrchestrationTemplate.getResources().values();
  82
  83     if (CollectionUtils.isNotEmpty(resourcesValues)) {
  84       for (Resource resource : resourcesValues) {
  85         Collection<Object> properties =
  86             resource.getProperties() == null ? null : resource.getProperties().values();
  87         validatePropertiesForAllRequiredArtifactsExist(properties, fileName,
  88                 artifacts, globalContext);
  89       }
  90     }
  91   }
  92
  93   private static void validatePropertiesForAllRequiredArtifactsExist(Collection<Object> properties,
  94                                                  String fileName,
  95                                                  Set<String> artifacts,
  96                                                  GlobalValidationContext globalContext) {
  97       if (CollectionUtils.isNotEmpty(properties)) {
  98           for (Object property : properties) {
  99               if (property instanceof Map) {
 100                   globalContext.setMessageCode(ERROR_CODE_HOT_14);
 101                   Set<String> artifactNames = HeatStructureUtil
 102                           .getReferencedValuesByFunctionName(fileName,
 103                                   ResourceReferenceFunctions.GET_FILE.getFunction(), property, globalContext);
 104                   artifacts.addAll(artifactNames);
 105                   globalContext.setMessageCode(ERROR_CODE_HOT_15);
 106                   HeatValidationService.checkArtifactsExistence(fileName, artifactNames,
 107                           globalContext);
 108               }
 109           }
 110       }
 111   }
 112   /* validation 14 */
 113
 114   private static void validateAllResourceReferencesExist(String fileName,
 115                                                          HeatOrchestrationTemplate
 116                                                              heatOrchestrationTemplate,
 117                                                          GlobalValidationContext globalContext) {
 118     Set<String> resourcesNames = heatOrchestrationTemplate.getResources() == null ? null
 119         : heatOrchestrationTemplate.getResources().keySet();
 120     Collection<Resource> resourcesValues = heatOrchestrationTemplate.getResources() == null ? null
 121         : heatOrchestrationTemplate.getResources().values();
 122     Collection<Output> outputsValues = heatOrchestrationTemplate.getOutputs() == null ? null
 123         : heatOrchestrationTemplate.getOutputs().values();
 124     checkResourceExistenceFromResourcesMap(fileName, resourcesNames, resourcesValues,
 125         globalContext);
 126     checkResourceExistenceFromResourcesMap(fileName, resourcesNames, outputsValues,
 127         globalContext);
 128   }
 129
 130   private static void checkResourceExistenceFromResourcesMap(String fileName,
 131                                       Set<String> resourcesNames,
 132                                       Collection<?> valuesToSearchIn,
 133                                       GlobalValidationContext globalContext) {
 134     if (CollectionUtils.isNotEmpty(valuesToSearchIn)) {
 135       for (Object value : valuesToSearchIn) {
 136         if (value instanceof Resource) {
 137                   extractResourceProperty(fileName, resourcesNames, globalContext,
 138                           (Resource) value);
 139         } else if (value instanceof Output) {
 140           Output output = (Output) value;
 141           Object outputsValue = output.getValue();
 142           handleReferencedResources(fileName, outputsValue, resourcesNames,
 143               globalContext);
 144         }
 145       }
 146     }
 147   }
 148
 149   private static void extractResourceProperty(String fileName, Set<String> resourcesNames,
 150                                               GlobalValidationContext globalContext,
 151                                               Resource value) {
 152       Collection<Object> resourcePropertiesValues =
 153         value.getProperties() == null ? null : value.getProperties()
 154             .values();
 155     if (CollectionUtils.isNotEmpty(resourcePropertiesValues)) {
 156       for (Object propertyValue : resourcePropertiesValues) {
 157         handleReferencedResources(fileName, propertyValue, resourcesNames,
 158             globalContext);
 159       }
 160     }
 161   }
 162
 163   private static void handleReferencedResources(String fileName, Object valueToSearchReferencesIn,
 164                                                 Set<String> resourcesNames,
 165                                                 GlobalValidationContext globalContext) {
 166     globalContext.setMessageCode(ERROR_CODE_HOT_13);
 167     Set<String> referencedResourcesNames = HeatStructureUtil
 168         .getReferencedValuesByFunctionName(fileName,
 169             ResourceReferenceFunctions.GET_RESOURCE.getFunction(),
 170             valueToSearchReferencesIn, globalContext);
 171     if (CollectionUtils.isNotEmpty(referencedResourcesNames)) {
 172       checkIfResourceReferenceExist(fileName, resourcesNames, referencedResourcesNames,
 173           globalContext);
 174     }
 175   }
 176
 177   private static void checkIfResourceReferenceExist(String fileName,
 178                                                     Set<String> referencedResourcesNames,
 179                                                     Set<String> referencedResources,
 180                                                     GlobalValidationContext globalContext) {
 181     referencedResources.stream()
 182                 .filter(referencedResource -> !referencedResourcesNames
 183                 .contains(referencedResource))
 184                 .forEach(referencedResource ->
 185           globalContext.addMessage(fileName,
 186               ErrorLevel.ERROR, ErrorMessagesFormatBuilder
 187                   .getErrorWithParameters(ERROR_CODE_HOT_16,Messages
 188                       .REFERENCED_RESOURCE_NOT_FOUND.getErrorMessage(), referencedResource)));
 189   }
 190
 191   /* validation 16 */
 192
 193   private static void validateGetParamPointToParameter(String fileName,
 194                                                        HeatOrchestrationTemplate
 195                                                            heatOrchestrationTemplate,
 196                                                        GlobalValidationContext globalContext) {
 197     Set<String> parametersNames = heatOrchestrationTemplate.getParameters() == null ? null
 198         : heatOrchestrationTemplate.getParameters().keySet();
 199     Map<String, Resource> resourcesMap = heatOrchestrationTemplate.getResources();
 200
 201     if (CollectionUtils.isNotEmpty(parametersNames) && MapUtils.isNotEmpty(resourcesMap)) {
 202       for (Map.Entry<String, Resource> resourceEntry : resourcesMap.entrySet()) {
 203         Resource resource = resourceEntry.getValue();
 204         Map<String, Object> properties = resource.getProperties();
 205           validatePropertiesForGetParamPointToParameter(properties, fileName, parametersNames,
 206                   resourceEntry, globalContext);
 207       }
 208     }
 209   }
 210
 211   private static void validatePropertiesForGetParamPointToParameter(Map<String,
 212                                             Object> properties,
 213                                             String fileName, Set<String> parametersNames,
 214                                             Map.Entry<String, Resource> resourceEntry,
 215                                             GlobalValidationContext globalContext) {
 216       if (MapUtils.isNotEmpty(properties)) {
 217           Collection<Object> propertiesValues = properties.values();
 218           if (CollectionUtils.isNotEmpty(propertiesValues)) {
 219               for (Object propertyObject : propertiesValues) {
 220                   Set<String> referencedParameterNames = HeatStructureUtil
 221                           .getReferencedValuesByFunctionName(fileName, "get_param", propertyObject,
 222                                   globalContext);
 223
 224                   validateReferenceParams(fileName, resourceEntry.getKey(), parametersNames,
 225                           referencedParameterNames, globalContext);
 226               }
 227           }
 228       }
 229   }
 230
 231   private static void validateReferenceParams(String fileName, String resourceName,
 232                                               Set<String> parametersNamesFromFile,
 233                                               Set<String> referencedParametersNames,
 234                                               GlobalValidationContext globalContext) {
 235     for (String parameterName : referencedParametersNames) {
 236       if (!isHeatPseudoParameter(parameterName)
 237           && !parametersNamesFromFile.contains(parameterName)) {
 238         globalContext.addMessage(fileName, ErrorLevel.ERROR, ErrorMessagesFormatBuilder
 239                         .getErrorWithParameters(ERROR_CODE_HOT_1,Messages
 240                         .REFERENCED_PARAMETER_NOT_FOUND.getErrorMessage(),
 241                     parameterName, resourceName));
 242       }
 243     }
 244   }
 245
 246   private static boolean isHeatPseudoParameter(String parameterName) {
 247     return HeatPseudoParameters.getPseudoParameterNames().contains(parameterName);
 248   }
 249
 250   /* validation 18*/
 251
 252   private static void validateGetAttr(String fileName,
 253                                       HeatOrchestrationTemplate heatOrchestrationTemplate,
 254                                       GlobalValidationContext globalContext) {
 255     Map<String, Output> outputMap;
 256     outputMap = heatOrchestrationTemplate.getOutputs();
 257
 258     if (MapUtils.isNotEmpty(outputMap)) {
 259       loopOverOutputMapAndValidateGetAttrFromNested(fileName, outputMap,
 260           heatOrchestrationTemplate, globalContext);
 261     }
 262   }
 263
 264   private static void loopOverOutputMapAndValidateGetAttrFromNested(String fileName,
 265                                              Map<String, Output> outputMap,
 266                                              HeatOrchestrationTemplate
 267                                              heatOrchestrationTemplate,
 268                                              GlobalValidationContext
 269                                              globalContext) {
 270     for (Output output : outputMap.values()) {
 271       Object outputValue = output.getValue();
 272       if (outputValue != null && outputValue instanceof Map) {
 273         Map<String, Object> outputValueMap = (Map<String, Object>) outputValue;
 274         List<String> getAttrValue =
 275             (List<String>) outputValueMap.get(
 276                 ResourceReferenceFunctions.GET_ATTR.getFunction());
 277                 handleGetAttrValueList(getAttrValue, fileName, heatOrchestrationTemplate,
 278                         globalContext);
 279
 280             }
 281         }
 282     }
 283
 284     private static void handleGetAttrValueList(List<String> getAttrValue, String fileName,
 285                                                HeatOrchestrationTemplate heatOrchestrationTemplate,
 286                                                GlobalValidationContext globalContext) {
 287         if (!CollectionUtils.isEmpty(getAttrValue)) {
 288             String resourceName = getAttrValue.get(0);
 289             String attNameObject = getAttrValue.get(1);
 290             if (attNameObject == null) {
 291                 return;
 292             }
 293             String attName = getAttrValue.get(1);
 294             String resourceType =
 295                     getResourceTypeFromResourcesMap(resourceName, heatOrchestrationTemplate);
 296
 297             if (Objects.nonNull(resourceType)
 298                     && HeatValidationService.isNestedResource(resourceType)) {
 299                 handleGetAttrNestedResource(fileName, globalContext, resourceName, attName,
 300                         resourceType);
 301             }
 302         }
 303     }
 304   private static void handleGetAttrNestedResource(String fileName,
 305                                                   GlobalValidationContext globalContext,
 306                                                   String resourceName, String attName,
 307                                                   String resourceType) {
 308     Map<String, Output> nestedOutputMap;
 309     HeatOrchestrationTemplate nestedHeatOrchestrationTemplate;
 310     try {
 311       Optional<InputStream> fileContent = globalContext.getFileContent(resourceType);
 312       if (fileContent.isPresent()) {
 313         nestedHeatOrchestrationTemplate =
 314             new YamlUtil().yamlToObject(fileContent.get(), HeatOrchestrationTemplate.class);
 315       } else {
 316         throw new Exception("The file '" + resourceType + "' has no content");
 317       }
 318     } catch (Exception exception) {
 319             LOGGER.debug("",exception);
 320       return;
 321     }
 322     nestedOutputMap = nestedHeatOrchestrationTemplate.getOutputs();
 323
 324     if (MapUtils.isEmpty(nestedOutputMap) || !nestedOutputMap.containsKey(attName)) {
 325       globalContext.addMessage(fileName, ErrorLevel.ERROR, ErrorMessagesFormatBuilder
 326                             .getErrorWithParameters(ERROR_CODE_HOT_17,Messages
 327                             .GET_ATTR_NOT_FOUND.getErrorMessage(),
 328                             attName, resourceName));
 329     }
 330   }
 331
 332   private static String getResourceTypeFromResourcesMap(String resourceName,
 333                                                         HeatOrchestrationTemplate
 334                                                             heatOrchestrationTemplate) {
 335       Resource resource = heatOrchestrationTemplate.getResources().get(resourceName);
 336       if (Objects.nonNull(resource)) {
 337           return resource.getType();
 338       } else {
 339           return null;
 340       }
 341   }
 342
 343   /* validation 17 + */
 344   private static void validateEnvFile(String fileName, String envFileName,
 345                                       HeatOrchestrationTemplate heatOrchestrationTemplate,
 346                                       GlobalValidationContext globalContext) {
 347     Environment envContent;
 348
 349     if (!envFileName.contains(".env")) {
 350       globalContext.addMessage(envFileName, ErrorLevel.ERROR, ErrorMessagesFormatBuilder
 351               .getErrorWithParameters(ERROR_CODE_HOT_2,Messages
 352                   .WRONG_ENV_FILE_EXTENSION.getErrorMessage(), envFileName));
 353     }
 354
 355     envContent = HeatValidationService.validateEnvContent(fileName, envFileName, globalContext);
 356     if (envContent != null) {
 357       validateEnvContentIsSubSetOfHeatParameters(envFileName, envContent, globalContext,
 358           heatOrchestrationTemplate);
 359       validateEnvParametersMatchDefinedHeatParameterTypes(envFileName, envContent, globalContext,
 360           heatOrchestrationTemplate);
 361     }
 362   }
 363
 364   private static void validateEnvContentIsSubSetOfHeatParameters(String envFile,
 365                                                                  Environment envContent,
 366                                                                  GlobalValidationContext
 367                                                                      globalContext,
 368                                                                  HeatOrchestrationTemplate
 369                                                                      heatOrchestrationTemplate) {
 370     Set<String> parametersNames = heatOrchestrationTemplate.getParameters() == null ? null
 371         : heatOrchestrationTemplate.getParameters().keySet();
 372
 373     if (MapUtils.isNotEmpty(envContent.getParameters())) {
 374       if (CollectionUtils.isNotEmpty(parametersNames)) {
 375         for (Map.Entry<String, Object> envEntry : envContent.getParameters().entrySet()) {
 376
 377
 378             validateEnvEntryForvalidateEnvContentIsSubSetOfHeatParameters(envEntry,
 379                     parametersNames, envFile, globalContext);
 380         }
 381       } else {
 382         for (Map.Entry<String, Object> envEntry : envContent.getParameters().entrySet()) {
 383           globalContext.addMessage(envFile, ErrorLevel.ERROR, ErrorMessagesFormatBuilder
 384                   .getErrorWithParameters(ERROR_CODE_HOT_3,Messages
 385                           .ENV_INCLUDES_PARAMETER_NOT_IN_HEAT.getErrorMessage(),
 386                       envFile, envEntry.getKey()));
 387         }
 388       }
 389     }
 390   }
 391
 392    private static void validateEnvEntryForvalidateEnvContentIsSubSetOfHeatParameters(
 393                         Map.Entry<String, Object> envEntry,
 394                         Set<String> parametersNames,
 395                         String envFile,
 396                         GlobalValidationContext globalContext) {
 397     String envParameter = envEntry.getKey();
 398     if (parametersNames != null && !parametersNames.contains(envParameter)) {
 399         globalContext.addMessage(envFile, ErrorLevel.ERROR, ErrorMessagesFormatBuilder
 400                         .getErrorWithParameters(
 401                                 ERROR_CODE_HOT_3,Messages
 402                                 .ENV_INCLUDES_PARAMETER_NOT_IN_HEAT.getErrorMessage(), envFile,
 403                                 envParameter));
 404     }
 405 }
 406   private static void validateParameterDefaultTypeAlignWithType(String fileName,
 407                                                                 HeatOrchestrationTemplate
 408                                                                     heatOrchestrationTemplate,
 409                                                                 GlobalValidationContext
 410                                                                     globalContext) {
 411     Map<String, Parameter> parametersMap = heatOrchestrationTemplate.getParameters();
 412
 413     if (parametersMap != null && MapUtils.isNotEmpty(parametersMap)) {
 414       for (Map.Entry<String, Parameter> parameterEntry : parametersMap.entrySet()) {
 415           validateParameterEntryForParameterDefaultTypeAlignWithType(parameterEntry,
 416                         fileName, globalContext);
 417       }
 418     }
 419   }
 420     private static void validateParameterEntryForParameterDefaultTypeAlignWithType(
 421                             Map.Entry<String, Parameter> parameterEntry,
 422                             String fileName, GlobalValidationContext globalContext){
 423         Parameter parameter = parameterEntry.getValue();
 424         String parameterType = parameter.getType();
 425         Object parameterDefault = parameter.get_default();
 426         if (parameterDefault != null && parameterType != null) {
 427             boolean isValueMatchDefault =
 428                     DefinedHeatParameterTypes.isValueIsFromGivenType(parameterDefault,
 429                             parameterType);
 430             if (!isValueMatchDefault) {
 431                 globalContext.addMessage(fileName, ErrorLevel.ERROR, ErrorMessagesFormatBuilder
 432                                 .getErrorWithParameters(
 433                                 ERROR_CODE_HOT_4,Messages
 434                                 .PARAMETER_DEFAULT_VALUE_NOT_ALIGN_WITH_TYPE.getErrorMessage(),
 435                                 parameterEntry.getKey(), parameterType));
 436             }
 437         }
 438     }
 439
 440   private static void validateEnvParametersMatchDefinedHeatParameterTypes(String envFile,
 441                                                  Environment envContent,
 442                                                  GlobalValidationContext globalContext,
 443                                                  HeatOrchestrationTemplate heatOrchestrationTemplate) {
 444     Map<String, Parameter> heatParameters = heatOrchestrationTemplate.getParameters();
 445
 446     if (MapUtils.isNotEmpty(heatParameters) && MapUtils.isNotEmpty(envContent.getParameters())) {
 447         validateEnvEntryForEnvParametersMatchDefinedHeatParameterTypes(envContent,
 448                         heatParameters, envFile, globalContext);
 449
 450
 451     }
 452   }
 453
 454   private static void validateEnvEntryForEnvParametersMatchDefinedHeatParameterTypes(
 455                                                           Environment envContent,
 456                                                           Map<String, Parameter> heatParameters,
 457                                                           String envFile,
 458                                                           GlobalValidationContext globalContext) {
 459       for (Map.Entry<String, Object> envEntry : envContent.getParameters().entrySet()) {
 460           String parameterName = envEntry.getKey();
 461           Object parameterEnvValue = envEntry.getValue();
 462           Parameter parameterFromHeatFile = heatParameters.get(parameterName);
 463           if (parameterFromHeatFile != null) {
 464               String parameterType = parameterFromHeatFile.getType();
 465               if (!DefinedHeatParameterTypes.isEmptyValueInEnv(parameterEnvValue)
 466                       && !DefinedHeatParameterTypes
 467                       .isValueIsFromGivenType(parameterEnvValue, parameterType)) {
 468                   globalContext.addMessage(envFile, ErrorLevel.ERROR, ErrorMessagesFormatBuilder
 469                                   .getErrorWithParameters(
 470                                   ERROR_CODE_HOT_5,Messages
 471                                   .PARAMETER_ENV_VALUE_NOT_ALIGN_WITH_TYPE.getErrorMessage(),
 472                                   parameterName));
 473               }
 474           }
 475       }
 476   }
 477
 478   @Override
 479   public void validate(GlobalValidationContext globalContext) {
 480     ManifestContent manifestContent;
 481     try {
 482       manifestContent = ValidationUtil.validateManifest(globalContext);
 483     } catch (Exception exception) {
 484       LOGGER.debug("",exception);
 485       return;
 486     }
 487     Map<String, FileData.Type> fileTypeMap = ManifestUtil.getFileTypeMap(manifestContent);
 488     Map<String, FileData> fileEnvMap = ManifestUtil.getFileAndItsEnv(manifestContent);
 489     Set<String> artifacts = new HashSet<>();
 490
 491     globalContext.getFiles().stream()
 492         .filter(fileName -> FileData.isHeatFile(fileTypeMap.get(fileName))).forEach(
 493         fileName -> validate(fileName, fileEnvMap.get(fileName) == null ? null : fileEnvMap.get(
 494             fileName).getFile(), artifacts,
 495              globalContext));
 496
 497
 498     Set<String> manifestArtifacts = ManifestUtil.getArtifacts(manifestContent);
 499
 500     globalContext.getFiles().stream()
 501         .filter(fileName -> isManifestArtifact(manifestArtifacts, fileName)
 502         && isNotArtifact(artifacts, fileName))
 503         .forEach(fileName -> globalContext.addMessage(fileName, ErrorLevel.WARNING,
 504             ErrorMessagesFormatBuilder
 505                 .getErrorWithParameters(ERROR_CODE_HOT_11,
 506                     Messages.ARTIFACT_FILE_NOT_REFERENCED.getErrorMessage())));
 507   }
 508
 509   private boolean isManifestArtifact(Set<String> manifestArtifacts, String fileName) {
 510     return manifestArtifacts.contains(fileName);
 511   }
 512
 513   private boolean isNotArtifact(Set<String> artifacts, String fileName) {
 514     return !artifacts.contains(fileName);
 515   }
 516
 517   private void validate(String fileName, String envFileName,
 518                         Set<String> artifacts,
 519                         GlobalValidationContext globalContext) {
 520     globalContext.setMessageCode(ERROR_CODE_HOT_12);
 521     HeatOrchestrationTemplate
 522         heatOrchestrationTemplate = ValidationUtil.checkHeatOrchestrationPreCondition(
 523         fileName, globalContext);
 524
 525
 526     if (heatOrchestrationTemplate != null) {
 527       if (!(fileName.contains(".yaml") || fileName.contains(".yml"))) {
 528         globalContext.addMessage(fileName, ErrorLevel.ERROR, ErrorMessagesFormatBuilder
 529                 .getErrorWithParameters(ERROR_CODE_HOT_6,Messages
 530                     .WRONG_HEAT_FILE_EXTENSION.getErrorMessage(), fileName));
 531       }
 532
 533       validateHeatBaseStructure(fileName, heatOrchestrationTemplate, globalContext);
 534       validateParameterDefaultTypeAlignWithType(fileName, heatOrchestrationTemplate, globalContext);
 535       validateAllResourceReferencesExist(fileName, heatOrchestrationTemplate, globalContext);
 536       validateResourceDependsOn(fileName, heatOrchestrationTemplate, globalContext);
 537       validateGetParamPointToParameter(fileName, heatOrchestrationTemplate, globalContext);
 538       validateGetAttr(fileName, heatOrchestrationTemplate, globalContext);
 539       validateAllRequiredArtifactsExist(fileName, heatOrchestrationTemplate, artifacts,
 540           globalContext);
 541
 542       if (envFileName != null) {
 543         validateEnvFile(fileName, envFileName, heatOrchestrationTemplate, globalContext);
 544       }
 545     }
 546   }
 547
 548   private void validateResourceDependsOn(String fileName,
 549                                          HeatOrchestrationTemplate heatOrchestrationTemplate,
 550                                          GlobalValidationContext globalContext) {
 551     Map<String, Resource> resourcesMap = heatOrchestrationTemplate.getResources();
 552     if(MapUtils.isEmpty(resourcesMap)) {
 553       return;
 554     }
 555
 556     Set<String> resourcesNames = resourcesMap.keySet();
 557
 558     resourcesMap.entrySet().stream()
 559         .forEach(entry -> checkResourceDependsOn(fileName, entry.getValue(),
 560             resourcesNames, globalContext));
 561   }
 562
 563   @SuppressWarnings("unchecked")
 564   private static void checkResourceDependsOn(String fileName, Resource resource,
 565                                              Set<String> resourcesNames,
 566                                              GlobalValidationContext globalContext) {
 567     Object dependencies = resource.getDepends_on();
 568     if (dependencies instanceof Collection) {
 569       ((Collection<String>) dependencies)
 570           .stream()
 571           .filter(resourceId -> !resourcesNames.contains(resourceId))
 572           .forEach(resourceId -> globalContext.addMessage(fileName, ErrorLevel.ERROR,
 573               ErrorMessagesFormatBuilder
 574                   .getErrorWithParameters(ERROR_CODE_HOT_7,
 575                           Messages.MISSING_RESOURCE_IN_DEPENDS_ON.getErrorMessage(), resourceId)));
 576     } else if (dependencies instanceof String && !resourcesNames.contains(dependencies)) {
 577         globalContext.addMessage(fileName, ErrorLevel.ERROR, ErrorMessagesFormatBuilder
 578                 .getErrorWithParameters(ERROR_CODE_HOT_8,
 579                         Messages.MISSING_RESOURCE_IN_DEPENDS_ON.getErrorMessage(), String.valueOf(dependencies)));
 580       }
 581   }
 582
 583
 584   private void validateHeatBaseStructure(String fileName,
 585                                          HeatOrchestrationTemplate heatOrchestrationTemplate,
 586                                          GlobalValidationContext globalContext) {
 587     if (heatOrchestrationTemplate.getHeat_template_version() == null) {
 588       globalContext.addMessage(fileName, ErrorLevel.ERROR, ErrorMessagesFormatBuilder
 589               .getErrorWithParameters(ERROR_CODE_HOT_9,
 590                       Messages.INVALID_HEAT_FORMAT_REASON.getErrorMessage(),
 591                   "missing template version"));
 592     }
 593     if (heatOrchestrationTemplate.getResources() == null
 594         || heatOrchestrationTemplate.getResources().size() == 0) {
 595       globalContext.addMessage(fileName, ErrorLevel.WARNING, ErrorMessagesFormatBuilder
 596               .getErrorWithParameters(ERROR_CODE_HOT_10,
 597                       Messages.INVALID_HEAT_FORMAT_REASON.getErrorMessage(),
 598                "The heat file does not contain any resources"));
 599     }
 600   }
 601
 602
 603   @SuppressWarnings("unchecked")
 604   private void getSecurityGroupsReferencedResourcesFromOutputs(
 605       Set<String> securityGroupsNamesFromOutputsMap, Map<String, Output> outputMap,
 606       Map<String, Resource> resourceMap) {
 607     if (MapUtils.isNotEmpty(outputMap)) {
 608       for (Map.Entry<String, Output> outputEntry : outputMap.entrySet()) {
 609
 610           validateOutputEntryForGetSecurityGroupsReferencedResourcesFromOutputs(outputEntry,
 611                   resourceMap, securityGroupsNamesFromOutputsMap);
 612
 613       }
 614     }
 615   }
 616     private void validateOutputEntryForGetSecurityGroupsReferencedResourcesFromOutputs(
 617             Map.Entry<String, Output> outputEntry,
 618             Map<String, Resource> resourceMap, Set<String> securityGroupsNamesFromOutputsMap){
 619         Object outputValue = outputEntry.getValue().getValue();
 620         if (Objects.nonNull(outputValue) && outputValue instanceof Map) {
 621             String resourceName = (String) ((Map) outputValue)
 622                     .get(ResourceReferenceFunctions.GET_RESOURCE.getFunction());
 623             if (Objects.nonNull(resourceName)) {
 624                 Resource resource = resourceMap.get(resourceName);
 625                 if (Objects.nonNull(resource) && resource.getType().equals(
 626                         HeatResourcesTypes.NEUTRON_SECURITY_GROUP_RESOURCE_TYPE.getHeatResource())) {
 627                     securityGroupsNamesFromOutputsMap.add(outputEntry.getKey());
 628                 }
 629             }
 630         }
 631     }
 632
 633 }