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     Map<String, String> uniqueResourcePortNetworkRole = new HashMap<>();
  85     //if no resources exist return
  86     if (MapUtils.isEmpty(heatOrchestrationTemplate.getResources())) {
  87       return;
  88     }
  89
  90     heatOrchestrationTemplate
  91             .getResources()
  92             .entrySet()
  93             .stream()
  94             .filter(entry -> entry.getValue().getType()
  95                     .equals(HeatResourcesTypes.NOVA_SERVER_RESOURCE_TYPE.getHeatResource()))
  96             .forEach( entry -> validateNovaServerResourceType(entry.getKey(), fileName, envFileName,
  97                     entry, uniqueResourcePortNetworkRole, heatOrchestrationTemplate, globalContext));
  98   }
  99
 100   private void validateNovaServerResourceType(String resourceId, String fileName,
 101                                               String envFileName,
 102                                               Map.Entry<String, Resource> resourceEntry,
 103                                               Map<String, String> uniqueResourcePortNetworkRole,
 104                                               HeatOrchestrationTemplate heatOrchestrationTemplate,
 105                                               GlobalValidationContext globalContext) {
 106     validateNovaServerResourceMetaData(fileName, resourceId,
 107             heatOrchestrationTemplate.getResources().get(resourceId), globalContext);
 108     validateNovaServerResourceNetworkUniqueRole(fileName, resourceId, uniqueResourcePortNetworkRole,
 109             heatOrchestrationTemplate, globalContext);
 110     validateAvailabilityZoneName(fileName, resourceEntry, globalContext);
 111     validateNovaServerNameImageAndFlavor(fileName, envFileName, resourceEntry, globalContext);
 112   }
 113
 114   @SuppressWarnings("unchecked")
 115   private void validateNovaServerResourceMetaData(String fileName, String resourceId,
 116                                                   Resource resource,
 117                                                   GlobalValidationContext globalValidationContext) {
 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       } else if (novaServerPropMetadata instanceof Map) {
 131         TreeMap<String, Object> propertyMap = new TreeMap((Comparator<String>) String::compareToIgnoreCase);
 132         propertyMap.putAll((Map) novaServerPropMetadata);
 133         if (!propertyMap.containsKey("vf_module_id")) {
 134           globalValidationContext.addMessage(
 135                   fileName,
 136                   ErrorLevel.WARNING,
 137                   ErrorMessagesFormatBuilder.getErrorWithParameters(
 138                           ERROR_CODE_NNS2, Messages.MISSING_NOVA_SERVER_VF_MODULE_ID.getErrorMessage(),
 139                           resourceId));
 140         }
 141         if (!propertyMap.containsKey("vnf_id")) {
 142           globalValidationContext.addMessage(
 143                   fileName, ErrorLevel.WARNING,
 144                   ErrorMessagesFormatBuilder
 145                           .getErrorWithParameters(
 146                                   ERROR_CODE_NNS3, Messages.MISSING_NOVA_SERVER_VNF_ID.getErrorMessage(),
 147                                   resourceId));
 148         }
 149       }
 150     }
 151   }
 152
 153   private void validateNovaServerResourceNetworkUniqueRole(String fileName, String resourceId,
 154                                                            Map<String, String> uniqueResourcePortNetworkRole,
 155                                                            HeatOrchestrationTemplate heatOrchestrationTemplate,
 156                                                            GlobalValidationContext globalValidationContext) {
 157     Object propertyNetworkValue =
 158             heatOrchestrationTemplate.getResources().get(resourceId).getProperties().get("networks");
 159     if (propertyNetworkValue != null && propertyNetworkValue instanceof List) {
 160       List<String> portResourceIdList =
 161               getNovaNetworkPortResourceList(fileName, (List) propertyNetworkValue,
 162                       globalValidationContext);
 163       for (String portResourceId : portResourceIdList) {
 164         Resource portResource = heatOrchestrationTemplate.getResources().get(portResourceId);
 165
 166         if (portResource != null && portResource.getType()
 167                 .equals(HeatResourcesTypes.NEUTRON_PORT_RESOURCE_TYPE.getHeatResource())) {
 168           validateUniqueResourcePortNetworkRole(fileName, resourceId,
 169                   uniqueResourcePortNetworkRole, globalValidationContext,
 170                   portResourceId, portResource);
 171         }
 172       }
 173     }
 174   }
 175
 176   private void validateUniqueResourcePortNetworkRole(String fileName, String resourceId,
 177                                       Map<String, String> uniqueResourcePortNetworkRole,
 178                                       GlobalValidationContext globalValidationContext,
 179                                       String portResourceId, Resource portResource) {
 180     String role = null;
 181     Object network;
 182     Map portNetwork =
 183             getPortNetwork(fileName, resourceId, portResource, globalValidationContext);
 184     if (Objects.nonNull(portNetwork)) {
 185       network = portNetwork.get("get_param");
 186       if (Objects.nonNull(network)) {
 187         if (network instanceof String ){
 188           role = getNetworkRole((String)network);
 189         }else if (network instanceof List){
 190           role = getNetworkRole((String)((List) network).get(0));
 191         }
 192         if (role != null && uniqueResourcePortNetworkRole.containsKey(role)) {
 193           globalValidationContext.addMessage(
 194                   fileName,
 195                   ErrorLevel.WARNING,
 196                   ErrorMessagesFormatBuilder.getErrorWithParameters(
 197                           ERROR_CODE_NNS12, Messages.RESOURCE_CONNECTED_TO_TWO_EXTERNAL_NETWORKS_WITH_SAME_ROLE
 198                                   .getErrorMessage(), resourceId, role));
 199         } else {
 200           uniqueResourcePortNetworkRole.put(role, portResourceId);
 201         }
 202       }
 203     }
 204   }
 205
 206   private List<String> getNovaNetworkPortResourceList(String filename, List propertyNetworkValue,
 207                                                       GlobalValidationContext globalContext) {
 208     globalContext.setMessageCode(ERROR_CODE_NNS14);
 209     List<String> portResourceIdList = new ArrayList<>();
 210     for (Object propValue : propertyNetworkValue) {
 211       Object portPropValue = ((Map) propValue).get("port");
 212       Collection<String> portResourceIds = HeatStructureUtil
 213               .getReferencedValuesByFunctionName(filename, "get_resource", portPropValue,
 214                       globalContext);
 215       if (portResourceIds != null) {
 216         portResourceIdList.addAll(portResourceIds);
 217       }
 218     }
 219
 220     return portResourceIdList;
 221   }
 222
 223   private String getNetworkRole(String network) {
 224     if (network == null) {
 225       return null;
 226     }
 227     if (network.contains("_net_id")) {
 228       return network.substring(0, network.indexOf("_net_id"));
 229     } else if (network.contains("_net_name")) {
 230       return network.substring(0, network.indexOf("_net_name"));
 231     } else if (network.contains("_net_fqdn")) {
 232       return network.substring(0, network.indexOf("_net_fqdn"));
 233     }
 234     return null;
 235   }
 236
 237   private Map getPortNetwork(String fileName, String resourceId, Resource portResource,
 238                              GlobalValidationContext globalValidationContext) {
 239     Object portNetwork = portResource.getProperties().get("network_id");
 240     if (portNetwork == null) {
 241       portNetwork = portResource.getProperties().get("network");
 242     }
 243     if (!(portNetwork instanceof Map)) {
 244       globalValidationContext.addMessage(
 245               fileName,
 246               ErrorLevel.WARNING,
 247               ErrorMessagesFormatBuilder
 248                       .getErrorWithParameters(
 249                               ERROR_CODE_NNS4, Messages.MISSING_GET_PARAM.getErrorMessage(),
 250                               "network or network_id", resourceId));
 251       return null;
 252     }
 253     return (Map) portNetwork;
 254   }
 255
 256   private void validateAvailabilityZoneName(String fileName,
 257                                             Map.Entry<String, Resource> resourceEntry,
 258                                             GlobalValidationContext globalContext) {
 259     String[] regexList = new String[]{"availability_zone_(\\d+)"};
 260
 261     if (MapUtils.isEmpty(resourceEntry.getValue().getProperties())) {
 262       return;
 263     }
 264
 265     Object availabilityZoneMap =  resourceEntry.getValue().getProperties()
 266             .get(AVAILABILITY_ZONE);
 267
 268     if (nonNull(availabilityZoneMap)) {
 269       if (availabilityZoneMap instanceof Map) {
 270         String availabilityZoneName = ValidationUtil.getWantedNameFromPropertyValueGetParam
 271                 (availabilityZoneMap);
 272
 273           if (availabilityZoneName != null && !ValidationUtil
 274                   .evalPattern(availabilityZoneName, regexList)) {
 275             globalContext.addMessage(
 276                     fileName,
 277                     ErrorLevel.WARNING, ErrorMessagesFormatBuilder.getErrorWithParameters(
 278                             ERROR_CODE_NNS5, Messages.PARAMETER_NAME_NOT_ALIGNED_WITH_GUIDELINES.getErrorMessage(),
 279                             ValidationUtil.getMessagePartAccordingToResourceType(resourceEntry),
 280                             "Availability Zone", availabilityZoneName, resourceEntry.getKey()));
 281           }
 282       } else {
 283         globalContext.addMessage(
 284                 fileName,
 285                 ErrorLevel.WARNING, ErrorMessagesFormatBuilder
 286                         .getErrorWithParameters(
 287                                 ERROR_CODE_NNS6, Messages.MISSING_GET_PARAM.getErrorMessage(),
 288                                 AVAILABILITY_ZONE, resourceEntry.getKey()));
 289       }
 290     }
 291   }
 292
 293   private void validateNovaServerNameImageAndFlavor(String fileName, String envFileName,
 294                                                     Map.Entry<String, Resource> resourceEntry,
 295                                                     GlobalValidationContext globalContext) {
 296     String novaName =
 297             validateNovaServerNamingConvention(fileName, envFileName, resourceEntry, globalContext);
 298     Map<String, String> legalNovaNamingConventionMap =
 299             validateImageAndFlavorFromNovaServer(fileName, resourceEntry, globalContext);
 300
 301     if (Objects.nonNull(novaName)) {
 302       legalNovaNamingConventionMap.put("name", novaName);
 303     }
 304
 305     if (legalNovaNamingConventionMap.keySet().size() > 1) {
 306       validateNovaServerNameImageAndFlavorSync(fileName, resourceEntry,
 307               legalNovaNamingConventionMap, globalContext);
 308     }
 309   }
 310
 311   private String validateNovaServerNamingConvention(String fileName, String envFileName,
 312                                                     Map.Entry<String, Resource> resourceEntry,
 313                                                     GlobalValidationContext globalContext) {
 314     if (MapUtils.isEmpty(resourceEntry.getValue().getProperties())) {
 315       return null;
 316     }
 317     return checkIfNovaNameByGuidelines(fileName, envFileName, resourceEntry, globalContext);
 318   }
 319
 320   private Map<String, String> validateImageAndFlavorFromNovaServer(String fileName,
 321                                                                    Map.Entry<String, Resource> resourceEntry,
 322                                                                    GlobalValidationContext globalContext) {
 323     if (MapUtils.isEmpty(resourceEntry.getValue().getProperties())) {
 324       return null;
 325     }
 326
 327     Pair<String, String> imagePair = new ImmutablePair<>("image", ".*_image_name");
 328     Pair<String, String> flavorPair = new ImmutablePair<>("flavor", ".*_flavor_name");
 329     List<Pair<String, String>> imageFlavorPairs = Arrays.asList(imagePair, flavorPair);
 330     Map<String, Object> propertiesMap = resourceEntry.getValue().getProperties();
 331     Map<String, String> imageAndFlavorLegalNames = new HashMap<>();
 332
 333     for (Pair<String, String> imageOrFlavor : imageFlavorPairs) {
 334       boolean isErrorInImageOrFlavor =
 335               isErrorExistWhenValidatingImageOrFlavorNames(fileName, imageOrFlavor, resourceEntry,
 336                       propertiesMap, globalContext);
 337       if (!isErrorInImageOrFlavor) {
 338         Object nameValue = propertiesMap.get(imageOrFlavor.getKey());
 339         String imageOrFlavorName = ValidationUtil.getWantedNameFromPropertyValueGetParam
 340                 (nameValue);
 341         imageAndFlavorLegalNames.put(imageOrFlavor.getKey(), imageOrFlavorName);
 342       }
 343     }
 344     return imageAndFlavorLegalNames;
 345   }
 346
 347   private String checkIfNovaNameByGuidelines(String fileName, String envFileName,
 348                                              Map.Entry<String, Resource> resourceEntry,
 349                                              GlobalValidationContext globalContext) {
 350     if (MapUtils.isEmpty(resourceEntry.getValue().getProperties())) {
 351       return null;
 352     }
 353     Object novaNameGetParam = getNovaServerName(resourceEntry);
 354     String novaName = null;
 355     if (nonNull(novaNameGetParam)) {
 356       novaName =
 357               checkNovaNameGetParamValueMap(fileName, novaNameGetParam, resourceEntry, globalContext);
 358       checkIfNovaNameParameterInEnvIsStringOrList(fileName, envFileName, novaName, resourceEntry,
 359               globalContext);
 360     } else {
 361       globalContext.addMessage(
 362               fileName,
 363               ErrorLevel.WARNING, ErrorMessagesFormatBuilder
 364                       .getErrorWithParameters(
 365                               ERROR_CODE_NNS7, Messages.MISSING_GET_PARAM.getErrorMessage(),
 366                               "nova server name", resourceEntry.getKey()));
 367     }
 368
 369     return novaName;
 370   }
 371
 372   private boolean isErrorExistWhenValidatingImageOrFlavorNames(String fileName,
 373                                                                Pair<String, String> propertyNameAndRegex,
 374                                                                Map.Entry<String, Resource> resourceEntry,
 375                                                                Map<String, Object> propertiesMap,
 376                                                                GlobalValidationContext globalContext) {
 377     String propertyName = propertyNameAndRegex.getKey();
 378     Object nameValue = propertiesMap.get(propertyName);
 379     String[] regexList = new String[]{propertyNameAndRegex.getValue()};
 380
 381
 382     if (nonNull(nameValue)) {
 383       if (nameValue instanceof Map) {
 384         globalContext.setMessageCode(ERROR_CODE_NNS13);
 385         if (ValidationUtil.validateMapPropertyValue(fileName, resourceEntry, globalContext,
 386                 propertyName,
 387                 nameValue, regexList)) {
 388           return true;
 389         }
 390       } else {
 391         globalContext.addMessage(
 392                 fileName,
 393                 ErrorLevel.WARNING, ErrorMessagesFormatBuilder
 394                         .getErrorWithParameters(
 395                                 ERROR_CODE_NNS8, Messages.MISSING_GET_PARAM.getErrorMessage(),
 396                                 propertyName, resourceEntry.getKey()));
 397         return true;
 398       }
 399
 400       return false;
 401     }
 402     return false;
 403   }
 404
 405   private Object getNovaServerName(Map.Entry<String, Resource> resourceEntry) {
 406     Object novaServerName = resourceEntry.getValue().getProperties().get("name");
 407     Map novaNameMap;
 408       if (nonNull(novaServerName) && novaServerName instanceof Map) {
 409         novaNameMap = (Map) novaServerName;
 410         return novaNameMap.get(ResourceReferenceFunctions.GET_PARAM.getFunction());
 411       }
 412
 413     return null;
 414   }
 415
 416   @SuppressWarnings("unchecked")
 417   private String checkNovaNameGetParamValueMap(String fileName, Object getParamValue,
 418                                                Map.Entry<String, Resource> resourceEntry,
 419                                                GlobalValidationContext globalContext) {
 420     if (getParamValue instanceof List) {
 421       List<Object> getParamNameList = (List) getParamValue;
 422       String[] regexName = new String[]{".*_names"};
 423       return isNovaNameAsListLegal(fileName, regexName, getParamNameList, resourceEntry,
 424               globalContext);
 425     } else if (getParamValue instanceof String) {
 426       String[] regexName = new String[]{".*_name_(\\d+)"};
 427       return isNovaNameAsStringLegal(fileName, (String) getParamValue, regexName, resourceEntry,
 428               globalContext);
 429     }
 430
 431     return null;
 432   }
 433
 434   private void checkIfNovaNameParameterInEnvIsStringOrList(String fileName,
 435                                                            String envFileName,
 436                                                            String novaServerName,
 437                                                            Map.Entry<String, Resource> resourceEntry,
 438                                                            GlobalValidationContext globalContext) {
 439     if (nonNull(envFileName)) {
 440       Environment environment = ValidationUtil.validateEnvContent(envFileName, globalContext);
 441
 442       if (environment != null && MapUtils.isNotEmpty(environment.getParameters())) {
 443         Object novaServerNameEnvValue = environment.getParameters()
 444                         .get(novaServerName);
 445           if (Objects.nonNull(novaServerNameEnvValue) && !DefinedHeatParameterTypes
 446                   .isNovaServerEnvValueIsFromRightType(novaServerNameEnvValue)) {
 447             globalContext.addMessage(
 448                     fileName,
 449                     ErrorLevel.WARNING, ErrorMessagesFormatBuilder.getErrorWithParameters(
 450                             ERROR_CODE_NNS9, Messages.PARAMETER_NAME_NOT_ALIGNED_WITH_GUIDELINES.getErrorMessage(),
 451                             SERVER, "Name",
 452                             novaServerNameEnvValue.toString(), resourceEntry.getKey()));
 453           }
 454       }
 455     }
 456   }
 457
 458   private String isNovaNameAsListLegal(String fileName,
 459                                        String[] regexName,
 460                                        List<Object> getParamNameList,
 461                                        Map.Entry<String, Resource> resourceEntry,
 462                                        GlobalValidationContext globalContext) {
 463
 464     if (getParamNameList.size() != 2 || !ValidationUtil.evalPattern(getParamNameList.get(0),
 465             regexName)) {
 466       globalContext.addMessage(
 467               fileName,
 468               ErrorLevel.WARNING,
 469               ErrorMessagesFormatBuilder.getErrorWithParameters(
 470                       ERROR_CODE_NNS10, Messages.PARAMETER_NAME_NOT_ALIGNED_WITH_GUIDELINES.getErrorMessage(),
 471                       SERVER,
 472                       "name", getParamNameList.toString(), resourceEntry.getKey()));
 473       return null;
 474     }
 475
 476     return (String) getParamNameList.get(0);
 477   }
 478
 479   private String isNovaNameAsStringLegal(String fileName,
 480                                          String novaName,
 481                                          String[] regexName,
 482                                          Map.Entry<String, Resource> resourceEntry,
 483                                          GlobalValidationContext globalContext) {
 484     if (!ValidationUtil.evalPattern(novaName, regexName)) {
 485       globalContext.addMessage(
 486               fileName,
 487               ErrorLevel.WARNING,
 488               ErrorMessagesFormatBuilder.getErrorWithParameters(
 489                       ERROR_CODE_NNS10, Messages.PARAMETER_NAME_NOT_ALIGNED_WITH_GUIDELINES.getErrorMessage(),
 490                       SERVER,
 491                       "name", novaName, resourceEntry.getKey()));
 492       return null;
 493     }
 494     return novaName;
 495   }
 496
 497   private void validateNovaServerNameImageAndFlavorSync(String fileName,
 498                                                         Map.Entry<String, Resource> resourceEntry,
 499                                                         Map<String, String> legalNovaNamingConventionNames,
 500                                                         GlobalValidationContext globalContext) {
 501     List<String> vmNames = new LinkedList<>();
 502
 503     for (Map.Entry<String, String> nameEntry : legalNovaNamingConventionNames.entrySet()) {
 504       vmNames.add(getVmName(nameEntry.getValue(), nameEntry.getKey()));
 505     }
 506
 507     vmNames.removeIf(Objects::isNull);
 508
 509     if (!isVmNameSync(vmNames)) {
 510       globalContext.addMessage(
 511               fileName,
 512               ErrorLevel.WARNING,
 513               ErrorMessagesFormatBuilder.getErrorWithParameters(
 514                       ERROR_CODE_NNS11, Messages.NOVA_NAME_IMAGE_FLAVOR_NOT_CONSISTENT.getErrorMessage(),
 515                       resourceEntry.getKey()));
 516     }
 517   }
 518
 519   private String getVmName(String nameToGetVmNameFrom, String stringToGetIndexOf) {
 520     int vmIndex =
 521             nameToGetVmNameFrom == null ? -1 : nameToGetVmNameFrom.indexOf(stringToGetIndexOf);
 522     String vmName = null;
 523     if (nameToGetVmNameFrom != null) {
 524       vmName = vmIndex < 0 ? null
 525               : trimNonAlphaNumericCharactersFromEndOfString(nameToGetVmNameFrom.substring(0, vmIndex));
 526     }
 527     return vmName;
 528   }
 529
 530   private boolean isVmNameSync(List<String> namesToCompare) {
 531     int size = namesToCompare.size();
 532     for (int i = 0; i < size - 1; i++) {
 533       if (!namesToCompare.get(i).equals(namesToCompare.get(i + 1))) {
 534         return false;
 535       }
 536     }
 537     return true;
 538   }
 539
 540   private String trimNonAlphaNumericCharactersFromEndOfString(String toTrim) {
 541     int stringSize = toTrim.length();
 542     int stringLength = stringSize - 1;
 543     String[] regexList = new String[]{"[^a-zA-Z0-9]"};
 544
 545     while (stringLength >= 0) {
 546       if (!ValidationUtil.evalPattern(String.valueOf(toTrim.charAt(stringLength)), regexList)) {
 547         break;
 548       }
 549       stringLength--;
 550     }
 551
 552     return toTrim.substring(0, stringLength + 1);
 553   }
 554 }