gerrit.onap Code Review - sdc.git/blob

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