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

   1 package org.openecomp.sdc.validation.impl.validators.namingconvention;
   2
   3 import org.apache.commons.collections4.MapUtils;
   4 import org.apache.commons.lang3.tuple.ImmutablePair;
   5 import org.apache.commons.lang3.tuple.Pair;
   6 import org.openecomp.core.validation.ErrorMessageCode;
   7 import org.openecomp.core.validation.errors.ErrorMessagesFormatBuilder;
   8 import org.openecomp.core.validation.types.GlobalValidationContext;
   9 import org.openecomp.sdc.common.errors.Messages;
  10 import org.openecomp.sdc.datatypes.error.ErrorLevel;
  11 import org.openecomp.sdc.heat.datatypes.DefinedHeatParameterTypes;
  12 import org.openecomp.sdc.heat.datatypes.model.Environment;
  13 import org.openecomp.sdc.heat.datatypes.model.HeatOrchestrationTemplate;
  14 import org.openecomp.sdc.heat.datatypes.model.HeatResourcesTypes;
  15 import org.openecomp.sdc.heat.datatypes.model.Resource;
  16 import org.openecomp.sdc.heat.datatypes.model.ResourceReferenceFunctions;
  17 import org.openecomp.sdc.heat.services.HeatStructureUtil;
  18 import org.openecomp.sdc.logging.context.impl.MdcDataDebugMessage;
  19 import org.openecomp.sdc.logging.types.LoggerErrorDescription;
  20 import org.openecomp.sdc.logging.types.LoggerTragetServiceName;
  21 import org.openecomp.sdc.validation.ResourceValidator;
  22 import org.openecomp.sdc.validation.ValidationContext;
  23 import org.openecomp.sdc.validation.type.NamingConventionValidationContext;
  24 import org.openecomp.sdc.validation.util.ValidationUtil;
  25
  26 import java.util.ArrayList;
  27 import java.util.Arrays;
  28 import java.util.Collection;
  29 import java.util.Comparator;
  30 import java.util.HashMap;
  31 import java.util.LinkedList;
  32 import java.util.List;
  33 import java.util.Map;
  34 import java.util.Objects;
  35 import java.util.TreeMap;
  36
  37 import static java.util.Objects.nonNull;
  38
  39 public class NovaServerNamingConventionGuideLineValidator implements ResourceValidator {
  40   private static MdcDataDebugMessage mdcDataDebugMessage = new MdcDataDebugMessage();
  41   private static final ErrorMessageCode ERROR_CODE_NNS1 = new ErrorMessageCode("NNS1");
  42   private static final ErrorMessageCode ERROR_CODE_NNS2 = new ErrorMessageCode("NNS2");
  43   private static final ErrorMessageCode ERROR_CODE_NNS3 = new ErrorMessageCode("NNS3");
  44   private static final ErrorMessageCode ERROR_CODE_NNS4 = new ErrorMessageCode("NNS4");
  45   private static final ErrorMessageCode ERROR_CODE_NNS5 = new ErrorMessageCode("NNS5");
  46   private static final ErrorMessageCode ERROR_CODE_NNS6 = new ErrorMessageCode("NNS6");
  47   private static final ErrorMessageCode ERROR_CODE_NNS7 = new ErrorMessageCode("NNS7");
  48   private static final ErrorMessageCode ERROR_CODE_NNS8 = new ErrorMessageCode("NNS8");
  49   private static final ErrorMessageCode ERROR_CODE_NNS9 = new ErrorMessageCode("NNS9");
  50   private static final ErrorMessageCode ERROR_CODE_NNS10 = new ErrorMessageCode("NNS10");
  51   private static final ErrorMessageCode ERROR_CODE_NNS11 = new ErrorMessageCode("NNS11");
  52   private static final ErrorMessageCode ERROR_CODE_NNS12 = new ErrorMessageCode("NNS12");
  53   private static final ErrorMessageCode ERROR_CODE_NNS13 = new ErrorMessageCode("NNS13");
  54   private static final ErrorMessageCode ERROR_CODE_NNS14 = new ErrorMessageCode("NNS14");
  55
  56   @Override
  57   public void validate(String fileName, Map.Entry<String, Resource> resourceEntry,
  58                        GlobalValidationContext globalContext, ValidationContext validationContext) {
  59
  60     NamingConventionValidationContext namingConventionValidationContext =
  61             (NamingConventionValidationContext)validationContext;
  62     validateHeatNovaResource(fileName, namingConventionValidationContext.getEnvFileName(),
  63             namingConventionValidationContext.getHeatOrchestrationTemplate(),
  64             globalContext);
  65   }
  66
  67   private void validateHeatNovaResource(String fileName, String envFileName,
  68                                         HeatOrchestrationTemplate heatOrchestrationTemplate,
  69                                         GlobalValidationContext globalContext) {
  70
  71
  72     mdcDataDebugMessage.debugEntryMessage("file", fileName);
  73
  74     Map<String, String> uniqueResourcePortNetworkRole = new HashMap<>();
  75     //if no resources exist return
  76     if (MapUtils.isEmpty(heatOrchestrationTemplate.getResources())) {
  77       return;
  78     }
  79
  80     heatOrchestrationTemplate
  81             .getResources()
  82             .entrySet()
  83             .stream()
  84             .filter(entry -> entry.getValue().getType()
  85                     .equals(HeatResourcesTypes.NOVA_SERVER_RESOURCE_TYPE.getHeatResource()))
  86             .forEach( entry -> validateNovaServerResourceType(entry.getKey(), fileName, envFileName,
  87                     entry, uniqueResourcePortNetworkRole, heatOrchestrationTemplate, globalContext));
  88
  89     mdcDataDebugMessage.debugExitMessage("file", fileName);
  90   }
  91
  92   private void validateNovaServerResourceType(String resourceId, String fileName,
  93                                               String envFileName,
  94                                               Map.Entry<String, Resource> resourceEntry,
  95                                               Map<String, String> uniqueResourcePortNetworkRole,
  96                                               HeatOrchestrationTemplate heatOrchestrationTemplate,
  97                                               GlobalValidationContext globalContext) {
  98
  99     mdcDataDebugMessage.debugEntryMessage("file", fileName);
 100
 101     validateNovaServerResourceMetaData(fileName, resourceId,
 102             heatOrchestrationTemplate.getResources().get(resourceId), globalContext);
 103     validateNovaServerResourceNetworkUniqueRole(fileName, resourceId, uniqueResourcePortNetworkRole,
 104             heatOrchestrationTemplate, globalContext);
 105     validateAvailabilityZoneName(fileName, resourceEntry, globalContext);
 106     validateNovaServerNameImageAndFlavor(fileName, envFileName, resourceEntry, globalContext);
 107
 108     mdcDataDebugMessage.debugExitMessage("file", fileName);
 109   }
 110
 111   @SuppressWarnings("unchecked")
 112   private void validateNovaServerResourceMetaData(String fileName, String resourceId,
 113                                                   Resource resource,
 114                                                   GlobalValidationContext globalValidationContext) {
 115
 116     mdcDataDebugMessage.debugEntryMessage("file", fileName);
 117
 118     Map<String, Object> novaServerProp = resource.getProperties();
 119     Object novaServerPropMetadata;
 120     if (MapUtils.isNotEmpty(novaServerProp)) {
 121       novaServerPropMetadata = novaServerProp.get("metadata");
 122       if (novaServerPropMetadata == null) {
 123         globalValidationContext.addMessage(
 124                 fileName,
 125                 ErrorLevel.WARNING,
 126                 ErrorMessagesFormatBuilder
 127                         .getErrorWithParameters(
 128                                 ERROR_CODE_NNS1, Messages.MISSING_NOVA_SERVER_METADATA.getErrorMessage(),
 129                                 resourceId),
 130                 LoggerTragetServiceName.VALIDATE_NOVA_META_DATA_NAME,
 131                 LoggerErrorDescription.MISSING_NOVA_PROPERTIES);
 132       } else if (novaServerPropMetadata instanceof Map) {
 133         TreeMap<String, Object> propertyMap = new TreeMap(new Comparator<String>() {
 134
 135           @Override
 136           public int compare(String o1, String o2) {
 137             return o1.compareToIgnoreCase(o2);
 138           }
 139
 140           @Override
 141           public boolean equals(Object obj) {
 142             return false;
 143           }
 144
 145           @Override
 146           public int hashCode() {
 147             return super.hashCode();
 148           }
 149         });
 150         propertyMap.putAll((Map) novaServerPropMetadata);
 151         if (!propertyMap.containsKey("vf_module_id")) {
 152           globalValidationContext.addMessage(
 153                   fileName,
 154                   ErrorLevel.WARNING,
 155                   ErrorMessagesFormatBuilder.getErrorWithParameters(
 156                           ERROR_CODE_NNS2, Messages.MISSING_NOVA_SERVER_VF_MODULE_ID.getErrorMessage(),
 157                           resourceId),
 158                   LoggerTragetServiceName.VALIDATE_NOVA_META_DATA_NAME,
 159                   LoggerErrorDescription.MISSING_NOVA_PROPERTIES);
 160         }
 161         if (!propertyMap.containsKey("vnf_id")) {
 162           globalValidationContext.addMessage(
 163                   fileName, ErrorLevel.WARNING,
 164                   ErrorMessagesFormatBuilder
 165                           .getErrorWithParameters(
 166                                   ERROR_CODE_NNS3, Messages.MISSING_NOVA_SERVER_VNF_ID.getErrorMessage(),
 167                                   resourceId),
 168                   LoggerTragetServiceName.VALIDATE_NOVA_META_DATA_NAME,
 169                   LoggerErrorDescription.MISSING_NOVA_PROPERTIES);
 170         }
 171       }
 172     }
 173
 174     mdcDataDebugMessage.debugExitMessage("file", fileName);
 175   }
 176
 177   private void validateNovaServerResourceNetworkUniqueRole(String fileName, String resourceId,
 178                                                            Map<String, String> uniqueResourcePortNetworkRole,
 179                                                            HeatOrchestrationTemplate heatOrchestrationTemplate,
 180                                                            GlobalValidationContext globalValidationContext) {
 181
 182
 183     mdcDataDebugMessage.debugEntryMessage("file", fileName);
 184
 185     Object network;
 186     String role = null;
 187
 188     Object propertyNetworkValue =
 189             heatOrchestrationTemplate.getResources().get(resourceId).getProperties().get("networks");
 190     if (propertyNetworkValue != null && propertyNetworkValue instanceof List) {
 191       List<String> portResourceIdList =
 192               getNovaNetworkPortResourceList(fileName, (List) propertyNetworkValue,
 193                       globalValidationContext);
 194       for (String portResourceId : portResourceIdList) {
 195         Resource portResource = heatOrchestrationTemplate.getResources().get(portResourceId);
 196         if (portResource != null && portResource.getType()
 197                 .equals(HeatResourcesTypes.NEUTRON_PORT_RESOURCE_TYPE.getHeatResource())) {
 198           Map portNetwork =
 199                   getPortNetwork(fileName, resourceId, portResource, globalValidationContext);
 200           if (Objects.nonNull(portNetwork)) {
 201             network = portNetwork.get("get_param");
 202             if (Objects.nonNull(network)) {
 203               if (network instanceof String ){
 204                 role = getNetworkRole((String)network);
 205               }else if (network instanceof List){
 206                 role = getNetworkRole((String)((List) network).get(0));
 207               }
 208               if (role != null && uniqueResourcePortNetworkRole.containsKey(role)) {
 209                 globalValidationContext.addMessage(
 210                         fileName,
 211                         ErrorLevel.WARNING,
 212                         ErrorMessagesFormatBuilder.getErrorWithParameters(
 213                                 ERROR_CODE_NNS12, Messages.RESOURCE_CONNECTED_TO_TWO_EXTERNAL_NETWORKS_WITH_SAME_ROLE
 214                                         .getErrorMessage(), resourceId, role),
 215                         LoggerTragetServiceName.VALIDATE_RESOURCE_NETWORK_UNIQUE_ROLW,
 216                         LoggerErrorDescription.RESOURCE_UNIQUE_NETWORK_ROLE);
 217               } else {
 218                 uniqueResourcePortNetworkRole.put(role, portResourceId);
 219               }
 220             }
 221           }
 222         }
 223       }
 224     }
 225
 226     mdcDataDebugMessage.debugExitMessage("file", fileName);
 227   }
 228
 229   private List<String> getNovaNetworkPortResourceList(String filename, List propertyNetworkValue,
 230                                                       GlobalValidationContext globalContext) {
 231     globalContext.setMessageCode(ERROR_CODE_NNS14);
 232     List<String> portResourceIdList = new ArrayList<>();
 233     for (Object propValue : propertyNetworkValue) {
 234       Object portPropValue = ((Map) propValue).get("port");
 235       Collection<String> portResourceIds = HeatStructureUtil
 236               .getReferencedValuesByFunctionName(filename, "get_resource", portPropValue,
 237                       globalContext);
 238       if (portResourceIds != null) {
 239         portResourceIdList.addAll(portResourceIds);
 240       }
 241     }
 242
 243     return portResourceIdList;
 244   }
 245
 246   private String getNetworkRole(String network) {
 247     if (network == null) {
 248       return null;
 249     }
 250     if (network.contains("_net_id")) {
 251       return network.substring(0, network.indexOf("_net_id"));
 252     } else if (network.contains("_net_name")) {
 253       return network.substring(0, network.indexOf("_net_name"));
 254     } else if (network.contains("_net_fqdn")) {
 255       return network.substring(0, network.indexOf("_net_fqdn"));
 256     }
 257     return null;
 258   }
 259
 260   private Map getPortNetwork(String fileName, String resourceId, Resource portResource,
 261                              GlobalValidationContext globalValidationContext) {
 262     Object portNetwork = portResource.getProperties().get("network_id");
 263     if (portNetwork == null) {
 264       portNetwork = portResource.getProperties().get("network");
 265     }
 266     if (!(portNetwork instanceof Map)) {
 267       globalValidationContext.addMessage(
 268               fileName,
 269               ErrorLevel.WARNING,
 270               ErrorMessagesFormatBuilder
 271                       .getErrorWithParameters(
 272                               ERROR_CODE_NNS4, Messages.MISSING_GET_PARAM.getErrorMessage(),
 273                               "network or network_id", resourceId),
 274               LoggerTragetServiceName.VALIDATE_RESOURCE_NETWORK_UNIQUE_ROLW,
 275               LoggerErrorDescription.MISSING_GET_PARAM);
 276       return null;
 277     }
 278     return (Map) portNetwork;
 279   }
 280
 281   private void validateAvailabilityZoneName(String fileName,
 282                                             Map.Entry<String, Resource> resourceEntry,
 283                                             GlobalValidationContext globalContext) {
 284
 285
 286     mdcDataDebugMessage.debugEntryMessage("file", fileName);
 287
 288     String[] regexList = new String[]{"availability_zone_(\\d+)"};
 289
 290     if (MapUtils.isEmpty(resourceEntry.getValue().getProperties())) {
 291       mdcDataDebugMessage.debugExitMessage("file", fileName);
 292       return;
 293     }
 294
 295     Object availabilityZoneMap =
 296             resourceEntry.getValue().getProperties().containsKey("availability_zone") ? resourceEntry
 297                     .getValue().getProperties().get("availability_zone") : null;
 298
 299     if (nonNull(availabilityZoneMap)) {
 300       if (availabilityZoneMap instanceof Map) {
 301         String availabilityZoneName = ValidationUtil.getWantedNameFromPropertyValueGetParam
 302                 (availabilityZoneMap);
 303
 304         if (availabilityZoneName != null) {
 305           if (!ValidationUtil.evalPattern(availabilityZoneName, regexList)) {
 306             globalContext.addMessage(
 307                     fileName,
 308                     ErrorLevel.WARNING, ErrorMessagesFormatBuilder.getErrorWithParameters(
 309                             ERROR_CODE_NNS5, Messages.PARAMETER_NAME_NOT_ALIGNED_WITH_GUIDELINES.getErrorMessage(),
 310                             ValidationUtil.getMessagePartAccordingToResourceType(resourceEntry),
 311                             "Availability Zone", availabilityZoneName, resourceEntry.getKey()),
 312                     LoggerTragetServiceName.VALIDATE_AVAILABILITY_ZONE_NAME,
 313                     LoggerErrorDescription.NAME_NOT_ALIGNED_WITH_GUIDELINES);
 314           }
 315         }
 316       } else {
 317         globalContext.addMessage(
 318                 fileName,
 319                 ErrorLevel.WARNING, ErrorMessagesFormatBuilder
 320                         .getErrorWithParameters(
 321                                 ERROR_CODE_NNS6, Messages.MISSING_GET_PARAM.getErrorMessage(),
 322                                 "availability_zone", resourceEntry.getKey()),
 323                 LoggerTragetServiceName.VALIDATE_AVAILABILITY_ZONE_NAME,
 324                 LoggerErrorDescription.MISSING_GET_PARAM);
 325       }
 326     }
 327     mdcDataDebugMessage.debugExitMessage("file", fileName);
 328   }
 329
 330   private void validateNovaServerNameImageAndFlavor(String fileName, String envFileName,
 331                                                     Map.Entry<String, Resource> resourceEntry,
 332                                                     GlobalValidationContext globalContext) {
 333
 334     mdcDataDebugMessage.debugEntryMessage("file", fileName);
 335
 336     String novaName =
 337             validateNovaServerNamingConvention(fileName, envFileName, resourceEntry, globalContext);
 338     Map<String, String> legalNovaNamingConventionMap =
 339             validateImageAndFlavorFromNovaServer(fileName, resourceEntry, globalContext);
 340
 341     if (Objects.nonNull(novaName)) {
 342       legalNovaNamingConventionMap.put("name", novaName);
 343     }
 344
 345     if (legalNovaNamingConventionMap.keySet().size() > 1) {
 346       validateNovaServerNameImageAndFlavorSync(fileName, resourceEntry,
 347               legalNovaNamingConventionMap, globalContext);
 348     }
 349
 350     mdcDataDebugMessage.debugExitMessage("file", fileName);
 351   }
 352
 353   private String validateNovaServerNamingConvention(String fileName, String envFileName,
 354                                                     Map.Entry<String, Resource> resourceEntry,
 355                                                     GlobalValidationContext globalContext) {
 356
 357     mdcDataDebugMessage.debugEntryMessage("file", fileName);
 358
 359     if (MapUtils.isEmpty(resourceEntry.getValue().getProperties())) {
 360       mdcDataDebugMessage.debugExitMessage("file", fileName);
 361       return null;
 362     }
 363
 364     mdcDataDebugMessage.debugExitMessage("file", fileName);
 365     return checkIfNovaNameByGuidelines(fileName, envFileName, resourceEntry, globalContext);
 366   }
 367
 368   private Map<String, String> validateImageAndFlavorFromNovaServer(String fileName,
 369                                                                    Map.Entry<String, Resource> resourceEntry,
 370                                                                    GlobalValidationContext globalContext) {
 371
 372     mdcDataDebugMessage.debugEntryMessage("file", fileName);
 373
 374     if (MapUtils.isEmpty(resourceEntry.getValue().getProperties())) {
 375       mdcDataDebugMessage.debugExitMessage("file", fileName);
 376       return null;
 377     }
 378
 379     Pair<String, String> imagePair = new ImmutablePair<>("image", ".*_image_name");
 380     Pair<String, String> flavorPair = new ImmutablePair<>("flavor", ".*_flavor_name");
 381     List<Pair<String, String>> imageFlavorPairs = Arrays.asList(imagePair, flavorPair);
 382     Map<String, Object> propertiesMap = resourceEntry.getValue().getProperties();
 383     Map<String, String> imageAndFlavorLegalNames = new HashMap<>();
 384
 385     for (Pair<String, String> imageOrFlavor : imageFlavorPairs) {
 386       boolean isErrorInImageOrFlavor =
 387               isErrorExistWhenValidatingImageOrFlavorNames(fileName, imageOrFlavor, resourceEntry,
 388                       propertiesMap, globalContext);
 389       if (!isErrorInImageOrFlavor) {
 390         Object nameValue = propertiesMap.get(imageOrFlavor.getKey()) == null ? null
 391                 : propertiesMap.get(imageOrFlavor.getKey());
 392         String imageOrFlavorName = ValidationUtil.getWantedNameFromPropertyValueGetParam
 393                 (nameValue);
 394         imageAndFlavorLegalNames.put(imageOrFlavor.getKey(), imageOrFlavorName);
 395       }
 396     }
 397
 398     mdcDataDebugMessage.debugExitMessage("file", fileName);
 399     return imageAndFlavorLegalNames;
 400   }
 401
 402   private String checkIfNovaNameByGuidelines(String fileName, String envFileName,
 403                                              Map.Entry<String, Resource> resourceEntry,
 404                                              GlobalValidationContext globalContext) {
 405     if (MapUtils.isEmpty(resourceEntry.getValue().getProperties())) {
 406       return null;
 407     }
 408     Object novaNameGetParam = getNovaServerName(resourceEntry);
 409     String novaName = null;
 410     if (nonNull(novaNameGetParam)) {
 411       novaName =
 412               checkNovaNameGetParamValueMap(fileName, novaNameGetParam, resourceEntry, globalContext);
 413       checkIfNovaNameParameterInEnvIsStringOrList(fileName, envFileName, novaName, resourceEntry,
 414               globalContext);
 415     } else {
 416       globalContext.addMessage(
 417               fileName,
 418               ErrorLevel.WARNING, ErrorMessagesFormatBuilder
 419                       .getErrorWithParameters(
 420                               ERROR_CODE_NNS7, Messages.MISSING_GET_PARAM.getErrorMessage(),
 421                               "nova server name", resourceEntry.getKey()),
 422               LoggerTragetServiceName.VALIDATE_NOVA_SERVER_NAME,
 423               LoggerErrorDescription.MISSING_GET_PARAM);
 424     }
 425
 426     return novaName;
 427   }
 428
 429   private boolean isErrorExistWhenValidatingImageOrFlavorNames(String fileName,
 430                                                                Pair<String, String> propertyNameAndRegex,
 431                                                                Map.Entry<String, Resource> resourceEntry,
 432                                                                Map<String, Object> propertiesMap,
 433                                                                GlobalValidationContext globalContext) {
 434     String propertyName = propertyNameAndRegex.getKey();
 435     Object nameValue =
 436             propertiesMap.get(propertyName) == null ? null : propertiesMap.get(propertyName);
 437     String[] regexList = new String[]{propertyNameAndRegex.getValue()};
 438
 439
 440     if (nonNull(nameValue)) {
 441       if (nameValue instanceof Map) {
 442         globalContext.setMessageCode(ERROR_CODE_NNS13);
 443         if (ValidationUtil.validateMapPropertyValue(fileName, resourceEntry, globalContext,
 444                 propertyName,
 445                 nameValue, regexList)) {
 446           return true;
 447         }
 448       } else {
 449         globalContext.addMessage(
 450                 fileName,
 451                 ErrorLevel.WARNING, ErrorMessagesFormatBuilder
 452                         .getErrorWithParameters(
 453                                 ERROR_CODE_NNS8, Messages.MISSING_GET_PARAM.getErrorMessage(),
 454                                 propertyName, resourceEntry.getKey()),
 455                 LoggerTragetServiceName.VALIDATE_IMAGE_AND_FLAVOR_NAME,
 456                 LoggerErrorDescription.MISSING_GET_PARAM);
 457         return true;
 458       }
 459
 460       return false;
 461     }
 462     return false;
 463   }
 464
 465   private Object getNovaServerName(Map.Entry<String, Resource> resourceEntry) {
 466     Object novaServerName = resourceEntry.getValue().getProperties().get("name");
 467     Map novaNameMap;
 468     if (nonNull(novaServerName)) {
 469       if (novaServerName instanceof Map) {
 470         novaNameMap = (Map) novaServerName;
 471         return novaNameMap.get(ResourceReferenceFunctions.GET_PARAM.getFunction()) == null ? null
 472                 : novaNameMap.get(ResourceReferenceFunctions.GET_PARAM.getFunction());
 473       }
 474     }
 475     return null;
 476   }
 477
 478   @SuppressWarnings("unchecked")
 479   private String checkNovaNameGetParamValueMap(String fileName, Object getParamValue,
 480                                                Map.Entry<String, Resource> resourceEntry,
 481                                                GlobalValidationContext globalContext) {
 482     if (getParamValue instanceof List) {
 483       List<Object> getParamNameList = (List) getParamValue;
 484       String[] regexName = new String[]{".*_names"};
 485       return isNovaNameAsListLegal(fileName, regexName, getParamNameList, resourceEntry,
 486               globalContext);
 487     } else if (getParamValue instanceof String) {
 488       String[] regexName = new String[]{".*_name_(\\d+)"};
 489       return isNovaNameAsStringLegal(fileName, (String) getParamValue, regexName, resourceEntry,
 490               globalContext);
 491     }
 492
 493     return null;
 494   }
 495
 496   private void checkIfNovaNameParameterInEnvIsStringOrList(String fileName,
 497                                                            String envFileName,
 498                                                            String novaServerName,
 499                                                            Map.Entry<String, Resource> resourceEntry,
 500                                                            GlobalValidationContext globalContext) {
 501     if (nonNull(envFileName)) {
 502       Environment environment = ValidationUtil.validateEnvContent(envFileName, globalContext);
 503
 504       if (environment != null && MapUtils.isNotEmpty(environment.getParameters())) {
 505         Object novaServerNameEnvValue =
 506                 environment.getParameters().containsKey(novaServerName) ? environment.getParameters()
 507                         .get(novaServerName) : null;
 508         if (Objects.nonNull(novaServerNameEnvValue)) {
 509           if (!DefinedHeatParameterTypes
 510                   .isNovaServerEnvValueIsFromRightType(novaServerNameEnvValue)) {
 511             globalContext.addMessage(
 512                     fileName,
 513                     ErrorLevel.WARNING, ErrorMessagesFormatBuilder.getErrorWithParameters(
 514                             ERROR_CODE_NNS9, Messages.PARAMETER_NAME_NOT_ALIGNED_WITH_GUIDELINES.getErrorMessage(),
 515                             "Server", "Name",
 516                             novaServerNameEnvValue.toString(), resourceEntry.getKey()),
 517                     LoggerTragetServiceName.VALIDATE_NOVA_SERVER_NAME,
 518                     LoggerErrorDescription.NAME_NOT_ALIGNED_WITH_GUIDELINES);
 519           }
 520         }
 521       }
 522     }
 523   }
 524
 525   private String isNovaNameAsListLegal(String fileName,
 526                                        String[] regexName,
 527                                        List<Object> getParamNameList,
 528                                        Map.Entry<String, Resource> resourceEntry,
 529                                        GlobalValidationContext globalContext) {
 530
 531     if (getParamNameList.size() != 2 || !ValidationUtil.evalPattern(getParamNameList.get(0),
 532             regexName)) {
 533       globalContext.addMessage(
 534               fileName,
 535               ErrorLevel.WARNING,
 536               ErrorMessagesFormatBuilder.getErrorWithParameters(
 537                       ERROR_CODE_NNS10, Messages.PARAMETER_NAME_NOT_ALIGNED_WITH_GUIDELINES.getErrorMessage(),
 538                       "Server",
 539                       "name", getParamNameList.toString(), resourceEntry.getKey()),
 540               LoggerTragetServiceName.VALIDATE_NOVA_SERVER_NAME,
 541               LoggerErrorDescription.NAME_NOT_ALIGNED_WITH_GUIDELINES);
 542       return null;
 543     }
 544
 545     return (String) getParamNameList.get(0);
 546   }
 547
 548   private String isNovaNameAsStringLegal(String fileName,
 549                                          String novaName,
 550                                          String[] regexName,
 551                                          Map.Entry<String, Resource> resourceEntry,
 552                                          GlobalValidationContext globalContext) {
 553     if (!ValidationUtil.evalPattern(novaName, regexName)) {
 554       globalContext.addMessage(
 555               fileName,
 556               ErrorLevel.WARNING,
 557               ErrorMessagesFormatBuilder.getErrorWithParameters(
 558                       ERROR_CODE_NNS10, Messages.PARAMETER_NAME_NOT_ALIGNED_WITH_GUIDELINES.getErrorMessage(),
 559                       "Server",
 560                       "name", novaName, resourceEntry.getKey()),
 561               LoggerTragetServiceName.VALIDATE_NOVA_SERVER_NAME,
 562               LoggerErrorDescription.NAME_NOT_ALIGNED_WITH_GUIDELINES);
 563       return null;
 564     }
 565     return novaName;
 566   }
 567
 568   private void validateNovaServerNameImageAndFlavorSync(String fileName,
 569                                                         Map.Entry<String, Resource> resourceEntry,
 570                                                         Map<String, String> legalNovaNamingConventionNames,
 571                                                         GlobalValidationContext globalContext) {
 572
 573     mdcDataDebugMessage.debugEntryMessage("file", fileName);
 574
 575     List<String> vmNames = new LinkedList<>();
 576
 577     for (Map.Entry<String, String> nameEntry : legalNovaNamingConventionNames.entrySet()) {
 578       vmNames.add(getVmName(nameEntry.getValue(), nameEntry.getKey()));
 579     }
 580
 581     vmNames.removeIf(VMName -> VMName == null);
 582
 583     if (!isVmNameSync(vmNames)) {
 584       globalContext.addMessage(
 585               fileName,
 586               ErrorLevel.WARNING,
 587               ErrorMessagesFormatBuilder.getErrorWithParameters(
 588                       ERROR_CODE_NNS11, Messages.NOVA_NAME_IMAGE_FLAVOR_NOT_CONSISTENT.getErrorMessage(),
 589                       resourceEntry.getKey()),
 590               LoggerTragetServiceName.VALIDATE_IMAGE_AND_FLAVOR_NAME,
 591               LoggerErrorDescription.NAME_NOT_ALIGNED_WITH_GUIDELINES);
 592     }
 593     mdcDataDebugMessage.debugExitMessage("file", fileName);
 594   }
 595
 596   private String getVmName(String nameToGetVmNameFrom, String stringToGetIndexOf) {
 597     int vmIndex =
 598             nameToGetVmNameFrom == null ? -1 : nameToGetVmNameFrom.indexOf(stringToGetIndexOf);
 599     String vmName = null;
 600     if (nameToGetVmNameFrom != null) {
 601       vmName = vmIndex < 0 ? null
 602               : trimNonAlphaNumericCharactersFromEndOfString(nameToGetVmNameFrom.substring(0, vmIndex));
 603     }
 604     return vmName;
 605   }
 606
 607   private boolean isVmNameSync(List<String> namesToCompare) {
 608     int size = namesToCompare.size();
 609     for (int i = 0; i < size - 1; i++) {
 610       if (!namesToCompare.get(i).equals(namesToCompare.get(i + 1))) {
 611         return false;
 612       }
 613     }
 614     return true;
 615   }
 616
 617   private String trimNonAlphaNumericCharactersFromEndOfString(String toTrim) {
 618     int stringSize = toTrim.length();
 619     int stringLength = stringSize - 1;
 620     String[] regexList = new String[]{"[^a-zA-Z0-9]"};
 621
 622     while (stringLength >= 0) {
 623       if (!ValidationUtil.evalPattern(String.valueOf(toTrim.charAt(stringLength)), regexList)) {
 624         break;
 625       }
 626       stringLength--;
 627     }
 628
 629     return toTrim.substring(0, stringLength + 1);
 630   }
 631 }