blueprints-processor/plugin/model-provider/src/main/java/org/onap/ccsdk/config/model/validator/TopologyTemplateValidator.java

   1 /*\r
   2  * Copyright © 2017-2018 AT&T Intellectual Property.\r
   3  * Modifications Copyright © 2018 IBM.\r
   4  * \r
   5  * Licensed under the Apache License, Version 2.0 (the "License");\r
   6  * you may not use this file except in compliance with the License.\r
   7  * You may obtain a copy of the License at\r
   8  * \r
   9  * http://www.apache.org/licenses/LICENSE-2.0\r
  10  * \r
  11  * Unless required by applicable law or agreed to in writing, software\r
  12  * distributed under the License is distributed on an "AS IS" BASIS,\r
  13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
  14  * See the License for the specific language governing permissions and\r
  15  * limitations under the License.\r
  16  */\r
  17 \r
  18 package org.onap.ccsdk.config.model.validator;\r
  19 \r
  20 import java.util.HashMap;\r
  21 import java.util.Map;\r
  22 import org.apache.commons.lang3.StringUtils;\r
  23 import org.onap.ccsdk.config.model.ConfigModelConstant;\r
  24 import org.onap.ccsdk.config.model.ConfigModelException;\r
  25 import org.onap.ccsdk.config.model.data.DataType;\r
  26 import org.onap.ccsdk.config.model.data.NodeTemplate;\r
  27 import org.onap.ccsdk.config.model.data.NodeType;\r
  28 import org.onap.ccsdk.config.model.data.PropertyDefinition;\r
  29 import org.onap.ccsdk.config.model.data.RequirementAssignment;\r
  30 import org.onap.ccsdk.config.model.data.ServiceTemplate;\r
  31 import org.onap.ccsdk.config.model.data.TopologyTemplate;\r
  32 import com.att.eelf.configuration.EELFLogger;\r
  33 import com.att.eelf.configuration.EELFManager;\r
  34 \r
  35 /**\r
  36  * TopologyTemplateValidator.java Purpose: Provide Configuration Generator TopologyTemplateValidator\r
  37  *\r
  38  * @version 1.0\r
  39  */\r
  40 public class TopologyTemplateValidator {\r
  41     private static EELFLogger logger = EELFManager.getInstance().getLogger(TopologyTemplateValidator.class);\r
  42     private StringBuilder message;\r
  43     private Map<String, DataType> stDataTypes;\r
  44     private Map<String, NodeType> stNodeTypes;\r
  45     private Map<String, NodeTemplate> stNodeTemplates;\r
  46     private ServiceTemplate serviceTemplate;\r
  47     private PropertyDefinitionValidator propertyDefinitionValidator;\r
  48 \r
  49     /**\r
  50      * This is a TopologyTemplateValidator\r
  51      *\r
  52      * @param serviceTemplate\r
  53      * @throws ConfigModelException\r
  54      */\r
  55     public TopologyTemplateValidator(ServiceTemplate serviceTemplate, StringBuilder message) {\r
  56         this.serviceTemplate = serviceTemplate;\r
  57         this.message = message;\r
  58         propertyDefinitionValidator = new PropertyDefinitionValidator(this.message);\r
  59         stDataTypes = new HashMap<>();\r
  60         stNodeTypes = new HashMap<>();\r
  61         stNodeTemplates = new HashMap<>();\r
  62         loadInitial();\r
  63     }\r
  64 \r
  65     private void loadInitial() {\r
  66         if (serviceTemplate != null) {\r
  67 \r
  68             if (serviceTemplate.getDataTypes() != null) {\r
  69                 serviceTemplate.getDataTypes().forEach((dataTypeKey, dataType) -> {\r
  70                     stDataTypes.put(dataTypeKey, dataType);\r
  71                     logger.trace("Data Type ({}) loaded successfully.", dataTypeKey);\r
  72                 });\r
  73             }\r
  74 \r
  75             if (serviceTemplate.getNodeTypes() != null) {\r
  76                 serviceTemplate.getNodeTypes().forEach((nodeTypeKey, nodeType) -> {\r
  77                     stNodeTypes.put(nodeTypeKey, nodeType);\r
  78                     logger.trace("Node Type ({}) loaded successfully.", nodeTypeKey);\r
  79                 });\r
  80             }\r
  81 \r
  82             if (serviceTemplate.getTopologyTemplate() != null) {\r
  83                 TopologyTemplate topologyTemplate = serviceTemplate.getTopologyTemplate();\r
  84 \r
  85                 if (topologyTemplate.getNodeTemplates() != null) {\r
  86                     topologyTemplate.getNodeTemplates().forEach((nodeTemplateKey, nodeTemplate) -> {\r
  87                         stNodeTemplates.put(nodeTemplateKey, nodeTemplate);\r
  88                         logger.trace("Node Template ({}) Type loaded successfully.", nodeTemplateKey);\r
  89                     });\r
  90                 }\r
  91             }\r
  92         }\r
  93 \r
  94     }\r
  95 \r
  96     /**\r
  97      * This is a validateTopologyTemplate to validate the Topology Template\r
  98      *\r
  99      * @return boolean\r
 100      * @throws ConfigModelException\r
 101      */\r
 102     public boolean validateTopologyTemplate() {\r
 103         if (serviceTemplate != null && serviceTemplate.getTopologyTemplate() != null) {\r
 104 \r
 105             checkValidInputProperties(serviceTemplate.getTopologyTemplate().getInputs());\r
 106 \r
 107             validateNodeTemplates(serviceTemplate.getTopologyTemplate().getNodeTemplates());\r
 108         }\r
 109         return true;\r
 110     }\r
 111 \r
 112     private boolean checkValidInputProperties(Map<String, PropertyDefinition> properties) {\r
 113         if (properties != null) {\r
 114             message.append("\n Validation topology template input properties :");\r
 115             propertyDefinitionValidator.validatePropertyDefinition(stDataTypes, properties);\r
 116         }\r
 117         return true;\r
 118     }\r
 119 \r
 120     @SuppressWarnings({"squid:S00112", "squid:S3776"})\r
 121     private boolean validateNodeTemplates(Map<String, NodeTemplate> nodeTemplates) {\r
 122         if (nodeTemplates != null) {\r
 123             nodeTemplates.forEach((nodeTemplateKey, nodeTemplate) -> {\r
 124                 if (nodeTemplate != null) {\r
 125                     message.append("\n ##### Validation Node Template  (" + nodeTemplateKey + "), of type ("\r
 126                             + nodeTemplate.getType() + ")");\r
 127 \r
 128                     String nodeTypeName = nodeTemplate.getType();\r
 129                     if (!stNodeTypes.containsKey(nodeTypeName)) {\r
 130                         throw new RuntimeException("Node Type (" + nodeTypeName + ")not Defined.");\r
 131                     }\r
 132 \r
 133                     if (nodeTemplate.getRequirements() != null) {\r
 134                         validateNodeTemplateRequirement(nodeTemplate.getRequirements());\r
 135                     }\r
 136 \r
 137                     // Validate Resource Assignments\r
 138                     NodeType nodeType = stNodeTypes.get(nodeTypeName);\r
 139                     if (nodeType != null\r
 140                             && ConfigModelConstant.MODEL_TYPE_NODE_ARTIFACT.equals(nodeType.getDerivedFrom())) {\r
 141                         logger.info("Validating Resource Assignment NodeTemplate ({}).", nodeTemplateKey);\r
 142                         ResourceAssignmentValidator resourceAssignmentValidator;\r
 143                         try {\r
 144                             resourceAssignmentValidator = new ResourceAssignmentValidator(nodeTemplate);\r
 145                             resourceAssignmentValidator.validateResourceAssignment();\r
 146                         } catch (ConfigModelException e) {\r
 147                             throw new RuntimeException(e);\r
 148                         }\r
 149 \r
 150                     }\r
 151                 }\r
 152             });\r
 153         }\r
 154         return true;\r
 155     }\r
 156 \r
 157     @SuppressWarnings("squid:S00112")\r
 158     private boolean validateNodeTemplateRequirement(Map<String, RequirementAssignment> requirements) {\r
 159         if (requirements != null) {\r
 160             requirements.forEach((requirementKey, requirement) -> {\r
 161                 if (requirement != null) {\r
 162                     String requirementnodeTypeName = requirement.getNode();\r
 163                     String capabilityName = requirement.getCapability();\r
 164                     try {\r
 165                         checkCapabilityPresentInNodeTemplate(requirementnodeTypeName, capabilityName);\r
 166                     } catch (ConfigModelException e) {\r
 167                         throw new RuntimeException(e);\r
 168                     }\r
 169                 }\r
 170             });\r
 171         }\r
 172         return true;\r
 173     }\r
 174 \r
 175     private boolean checkCapabilityPresentInNodeTemplate(String nodeTemplateName, String capabilityName)\r
 176             throws ConfigModelException {\r
 177         if (StringUtils.isNotBlank(nodeTemplateName) && StringUtils.isNotBlank(capabilityName)) {\r
 178 \r
 179             if (!stNodeTemplates.containsKey(nodeTemplateName)) {\r
 180                 throw new ConfigModelException(nodeTemplateName + " Node Template not Defined.");\r
 181             } else {\r
 182                 message.append("\n Node Template (" + nodeTemplateName + ") Defined.");\r
 183             }\r
 184 \r
 185             NodeTemplate relationalNodeType = stNodeTemplates.get(nodeTemplateName);\r
 186 \r
 187             if (relationalNodeType.getCapabilities() == null) {\r
 188                 throw new ConfigModelException(\r
 189                         "Node Template (" + nodeTemplateName + "), doesn't have Capability Definitions.");\r
 190             }\r
 191 \r
 192             if (!relationalNodeType.getCapabilities().containsKey(capabilityName)) {\r
 193                 throw new ConfigModelException("Node Type (" + nodeTemplateName + ") doesn't have  (" + capabilityName\r
 194                         + ") Capability Definitions.");\r
 195             } else {\r
 196                 message.append("\n Node Template (" + nodeTemplateName + ") has (" + capabilityName\r
 197                         + ") Capability Definitions.");\r
 198             }\r
 199 \r
 200         }\r
 201         return true;\r
 202     }\r
 203 }\r