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

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