gerrit.onap Code Review - sdc.git/blob

   1 package org.openecomp.sdc.validation.impl.validators;
   2
   3 import org.apache.commons.collections4.MapUtils;
   4 import org.openecomp.core.validation.errors.ErrorMessagesFormatBuilder;
   5 import org.openecomp.core.validation.types.GlobalValidationContext;
   6 import org.openecomp.sdc.common.errors.Messages;
   7 import org.openecomp.sdc.datatypes.error.ErrorLevel;
   8 import org.openecomp.sdc.heat.datatypes.manifest.FileData;
   9 import org.openecomp.sdc.heat.datatypes.manifest.ManifestContent;
  10 import org.openecomp.sdc.heat.datatypes.model.HeatOrchestrationTemplate;
  11 import org.openecomp.sdc.heat.datatypes.model.Resource;
  12 import org.openecomp.sdc.heat.services.manifest.ManifestUtil;
  13 import org.openecomp.sdc.logging.api.Logger;
  14 import org.openecomp.sdc.logging.api.LoggerFactory;
  15 import org.openecomp.sdc.logging.context.impl.MdcDataDebugMessage;
  16 import org.openecomp.sdc.logging.types.LoggerErrorDescription;
  17 import org.openecomp.sdc.logging.types.LoggerTragetServiceName;
  18 import org.openecomp.sdc.validation.Validator;
  19 import org.openecomp.sdc.validation.util.ValidationUtil;
  20
  21 import java.util.HashSet;
  22 import java.util.Map;
  23 import java.util.Objects;
  24 import java.util.Set;
  25
  26 /**
  27  * Created by TALIO on 2/15/2017.
  28  */
  29 public class ForbiddenResourceGuideLineValidator implements Validator {
  30   private static MdcDataDebugMessage mdcDataDebugMessage = new MdcDataDebugMessage();
  31   private static Set<String> forbiddenResources = new HashSet<>();
  32
  33   private final Logger log = (Logger) LoggerFactory.getLogger(this.getClass().getName());
  34
  35   @Override
  36   public void init(Map<String, Object> properties) {
  37     Map<String, Map<String, Object>> forbiddenResourcesMap =
  38         (Map<String, Map<String, Object>>) properties.get("forbiddenResourceTypes");
  39
  40     forbiddenResourcesMap.entrySet().stream()
  41         .filter(entry -> isResourceEnabled(entry.getValue().get("enable")))
  42         .forEach(entry -> forbiddenResources.add(entry.getKey()));
  43
  44
  45
  46
  47   }
  48
  49   private boolean isResourceEnabled(Object enableValue){
  50     if(Objects.isNull(enableValue)){
  51       return true;
  52     }
  53
  54     if(enableValue instanceof Boolean){
  55       return (Boolean)enableValue;
  56     }
  57
  58     return Boolean.valueOf((String) enableValue);
  59   }
  60
  61
  62   @Override
  63   public void validate(GlobalValidationContext globalContext) {
  64     ManifestContent manifestContent;
  65     try {
  66       manifestContent = ValidationUtil.checkValidationPreCondition(globalContext);
  67     } catch (Exception exception) {
  68       log.debug("",exception);
  69       return;
  70     }
  71
  72     Map<String, FileData.Type> fileTypeMap = ManifestUtil.getFileTypeMap(manifestContent);
  73
  74     globalContext.getFiles().stream()
  75         .filter(fileName -> FileData
  76             .isHeatFile(fileTypeMap.get(fileName)))
  77         .forEach(fileName -> validate(fileName, globalContext));
  78   }
  79
  80   private void validate(String fileName, GlobalValidationContext globalContext) {
  81     HeatOrchestrationTemplate
  82         heatOrchestrationTemplate = ValidationUtil.checkHeatOrchestrationPreCondition(fileName, globalContext);
  83     if (heatOrchestrationTemplate == null) {
  84       return;
  85     }
  86
  87     validateResourceTypeIsForbidden(fileName, heatOrchestrationTemplate, globalContext);
  88   }
  89
  90   private void validateResourceTypeIsForbidden(String fileName,
  91                                                HeatOrchestrationTemplate heatOrchestrationTemplate,
  92                                                GlobalValidationContext globalContext) {
  93
  94     mdcDataDebugMessage.debugEntryMessage("file", fileName);
  95
  96     Map<String, Resource> resourcesMap = heatOrchestrationTemplate.getResources();
  97     if (MapUtils.isEmpty(resourcesMap)) {
  98       mdcDataDebugMessage.debugExitMessage("file", fileName);
  99       return;
 100     }
 101
 102     for (Map.Entry<String, Resource> resourceEntry : resourcesMap.entrySet()) {
 103       String resourceType = resourceEntry.getValue().getType();
 104       if (Objects.isNull(resourceType)) {
 105         globalContext.addMessage(fileName, ErrorLevel.WARNING, ErrorMessagesFormatBuilder
 106                 .getErrorWithParameters(Messages.INVALID_RESOURCE_TYPE.getErrorMessage(), "null",
 107                     resourceEntry.getKey()), LoggerTragetServiceName.VALIDATE_RESOURCE_TYPE,
 108             LoggerErrorDescription.INVALID_RESOURCE_TYPE);
 109       } else {
 110         if(isResourceForbidden(resourceType)){
 111           globalContext.addMessage(
 112               fileName,
 113               ErrorLevel.WARNING,
 114               ErrorMessagesFormatBuilder
 115                   .getErrorWithParameters(Messages.FORBIDDEN_RESOURCE_IN_USE.getErrorMessage(),
 116                       resourceType,
 117                       resourceEntry.getKey()),
 118               LoggerTragetServiceName.VALIDATE_FORBIDDEN_RESOURCE,
 119               LoggerErrorDescription.FLOATING_IP_IN_USE);
 120         }
 121       }
 122     }
 123     mdcDataDebugMessage.debugExitMessage("file", fileName);
 124   }
 125
 126   private boolean isResourceForbidden(String resourceType){
 127     return forbiddenResources.contains(resourceType);
 128   }
 129 }