blueprints-processor/plugin/model-provider/src/main/java/org/onap/ccsdk/features/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.features.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.features.model.ConfigModelConstant;\r
  24 import org.onap.ccsdk.features.model.ConfigModelException;\r
  25 import org.onap.ccsdk.features.model.data.DataType;\r
  26 import org.onap.ccsdk.features.model.data.NodeTemplate;\r
  27 import org.onap.ccsdk.features.model.data.NodeType;\r
  28 import org.onap.ccsdk.features.model.data.PropertyDefinition;\r
  29 import org.onap.ccsdk.features.model.data.RequirementAssignment;\r
  30 import org.onap.ccsdk.features.model.data.ServiceTemplate;\r
  31 import org.onap.ccsdk.features.model.data.TopologyTemplate;\r
  32 \r
  33 import com.att.eelf.configuration.EELFLogger;\r
  34 import com.att.eelf.configuration.EELFManager;\r
  35 \r
  36 /**\r
  37  * TopologyTemplateValidator.java Purpose: Provide Configuration Generator TopologyTemplateValidator\r
  38  *\r
  39  * @version 1.0\r
  40  */\r
  41 public class TopologyTemplateValidator {\r
  42     private static EELFLogger logger = EELFManager.getInstance().getLogger(TopologyTemplateValidator.class);\r
  43     private StringBuilder message;\r
  44     private Map<String, DataType> stDataTypes;\r
  45     private Map<String, NodeType> stNodeTypes;\r
  46     private Map<String, NodeTemplate> stNodeTemplates;\r
  47     private ServiceTemplate serviceTemplate;\r
  48     private PropertyDefinitionValidator propertyDefinitionValidator;\r
  49 \r
  50     /**\r
  51      * This is a TopologyTemplateValidator\r
  52      *\r
  53      * @param serviceTemplate\r
  54      * @throws ConfigModelException\r
  55      */\r
  56     public TopologyTemplateValidator(ServiceTemplate serviceTemplate, StringBuilder message) {\r
  57         this.serviceTemplate = serviceTemplate;\r
  58         this.message = message;\r
  59         propertyDefinitionValidator = new PropertyDefinitionValidator(this.message);\r
  60         stDataTypes = new HashMap<>();\r
  61         stNodeTypes = new HashMap<>();\r
  62         stNodeTemplates = new HashMap<>();\r
  63         loadInitial();\r
  64     }\r
  65 \r
  66     private void loadInitial() {\r
  67         if (serviceTemplate != null) {\r
  68 \r
  69             if (serviceTemplate.getDataTypes() != null) {\r
  70                 serviceTemplate.getDataTypes().forEach((dataTypeKey, dataType) -> {\r
  71                     stDataTypes.put(dataTypeKey, dataType);\r
  72                     logger.trace("Data Type ({}) loaded successfully.", dataTypeKey);\r
  73                 });\r
  74             }\r
  75 \r
  76             if (serviceTemplate.getNodeTypes() != null) {\r
  77                 serviceTemplate.getNodeTypes().forEach((nodeTypeKey, nodeType) -> {\r
  78                     stNodeTypes.put(nodeTypeKey, nodeType);\r
  79                     logger.trace("Node Type ({}) loaded successfully.", nodeTypeKey);\r
  80                 });\r
  81             }\r
  82 \r
  83             if (serviceTemplate.getTopologyTemplate() != null) {\r
  84                 TopologyTemplate topologyTemplate = serviceTemplate.getTopologyTemplate();\r
  85 \r
  86                 if (topologyTemplate.getNodeTemplates() != null) {\r
  87                     topologyTemplate.getNodeTemplates().forEach((nodeTemplateKey, nodeTemplate) -> {\r
  88                         stNodeTemplates.put(nodeTemplateKey, nodeTemplate);\r
  89                         logger.trace("Node Template ({}) Type loaded successfully.", nodeTemplateKey);\r
  90                     });\r
  91                 }\r
  92             }\r
  93         }\r
  94 \r
  95     }\r
  96 \r
  97     /**\r
  98      * This is a validateTopologyTemplate to validate the Topology Template\r
  99      *\r
 100      * @return boolean\r
 101      * @throws ConfigModelException\r
 102      */\r
 103     public boolean validateTopologyTemplate() {\r
 104         if (serviceTemplate != null && serviceTemplate.getTopologyTemplate() != null) {\r
 105 \r
 106             checkValidInputProperties(serviceTemplate.getTopologyTemplate().getInputs());\r
 107 \r
 108             validateNodeTemplates(serviceTemplate.getTopologyTemplate().getNodeTemplates());\r
 109         }\r
 110         return true;\r
 111     }\r
 112 \r
 113     private boolean checkValidInputProperties(Map<String, PropertyDefinition> properties) {\r
 114         if (properties != null) {\r
 115             message.append("\n Validation topology template input properties :");\r
 116             propertyDefinitionValidator.validatePropertyDefinition(stDataTypes, properties);\r
 117         }\r
 118         return true;\r
 119     }\r
 120 \r
 121     @SuppressWarnings({"squid:S00112", "squid:S3776"})\r
 122     private boolean validateNodeTemplates(Map<String, NodeTemplate> nodeTemplates) {\r
 123         if (nodeTemplates != null) {\r
 124             nodeTemplates.forEach((nodeTemplateKey, nodeTemplate) -> {\r
 125                 if (nodeTemplate != null) {\r
 126                     message.append("\n ##### Validation Node Template  (" + nodeTemplateKey + "), of type ("\r
 127                             + nodeTemplate.getType() + ")");\r
 128 \r
 129                     String nodeTypeName = nodeTemplate.getType();\r
 130                     if (!stNodeTypes.containsKey(nodeTypeName)) {\r
 131                         throw new RuntimeException("Node Type (" + nodeTypeName + ")not Defined.");\r
 132                     }\r
 133 \r
 134                     if (nodeTemplate.getRequirements() != null) {\r
 135                         validateNodeTemplateRequirement(nodeTemplate.getRequirements());\r
 136                     }\r
 137 \r
 138                     // Validate Resource Assignments\r
 139                     NodeType nodeType = stNodeTypes.get(nodeTypeName);\r
 140                     if (nodeType != null\r
 141                             && ConfigModelConstant.MODEL_TYPE_NODE_ARTIFACT.equals(nodeType.getDerivedFrom())) {\r
 142                         logger.info("Validating Resource Assignment NodeTemplate ({}).", nodeTemplateKey);\r
 143                         ResourceAssignmentValidator resourceAssignmentValidator;\r
 144                         try {\r
 145                             resourceAssignmentValidator = new ResourceAssignmentValidator(nodeTemplate);\r
 146                             resourceAssignmentValidator.validateResourceAssignment();\r
 147                         } catch (ConfigModelException e) {\r
 148                             throw new RuntimeException(e);\r
 149                         }\r
 150 \r
 151                     }\r
 152                 }\r
 153             });\r
 154         }\r
 155         return true;\r
 156     }\r
 157 \r
 158     @SuppressWarnings("squid:S00112")\r
 159     private boolean validateNodeTemplateRequirement(Map<String, RequirementAssignment> requirements) {\r
 160         if (requirements != null) {\r
 161             requirements.forEach((requirementKey, requirement) -> {\r
 162                 if (requirement != null) {\r
 163                     String requirementnodeTypeName = requirement.getNode();\r
 164                     String capabilityName = requirement.getCapability();\r
 165                     try {\r
 166                         checkCapabilityPresentInNodeTemplate(requirementnodeTypeName, capabilityName);\r
 167                     } catch (ConfigModelException e) {\r
 168                         throw new RuntimeException(e);\r
 169                     }\r
 170                 }\r
 171             });\r
 172         }\r
 173         return true;\r
 174     }\r
 175 \r
 176     private boolean checkCapabilityPresentInNodeTemplate(String nodeTemplateName, String capabilityName)\r
 177             throws ConfigModelException {\r
 178         if (StringUtils.isNotBlank(nodeTemplateName) && StringUtils.isNotBlank(capabilityName)) {\r
 179 \r
 180             if (!stNodeTemplates.containsKey(nodeTemplateName)) {\r
 181                 throw new ConfigModelException(nodeTemplateName + " Node Template not Defined.");\r
 182             } else {\r
 183                 message.append("\n Node Template (" + nodeTemplateName + ") Defined.");\r
 184             }\r
 185 \r
 186             NodeTemplate relationalNodeType = stNodeTemplates.get(nodeTemplateName);\r
 187 \r
 188             if (relationalNodeType.getCapabilities() == null) {\r
 189                 throw new ConfigModelException(\r
 190                         "Node Template (" + nodeTemplateName + "), doesn't have Capability Definitions.");\r
 191             }\r
 192 \r
 193             if (!relationalNodeType.getCapabilities().containsKey(capabilityName)) {\r
 194                 throw new ConfigModelException("Node Type (" + nodeTemplateName + ") doesn't have  (" + capabilityName\r
 195                         + ") Capability Definitions.");\r
 196             } else {\r
 197                 message.append("\n Node Template (" + nodeTemplateName + ") has (" + capabilityName\r
 198                         + ") Capability Definitions.");\r
 199             }\r
 200 \r
 201         }\r
 202         return true;\r
 203     }\r
 204 }\r