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