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