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