components/core/src/main/kotlin/org/onap/ccsdk/apps/controllerblueprints/core/service/BluePrintContext.kt

   1 /*\r
   2  * Copyright © 2017-2018 AT&T Intellectual Property.\r
   3  *\r
   4  * Licensed under the Apache License, Version 2.0 (the "License");\r
   5  * you may not use this file except in compliance with the License.\r
   6  * You may obtain a copy of the License at\r
   7  *\r
   8  *     http://www.apache.org/licenses/LICENSE-2.0\r
   9  *\r
  10  * Unless required by applicable law or agreed to in writing, software\r
  11  * distributed under the License is distributed on an "AS IS" BASIS,\r
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
  13  * See the License for the specific language governing permissions and\r
  14  * limitations under the License.\r
  15  */\r
  16 \r
  17 package org.onap.ccsdk.apps.controllerblueprints.core.service\r
  18 \r
  19 import com.att.eelf.configuration.EELFLogger\r
  20 import com.att.eelf.configuration.EELFManager\r
  21 import com.fasterxml.jackson.databind.JsonNode\r
  22 import org.onap.ccsdk.apps.controllerblueprints.core.BluePrintException\r
  23 import org.onap.ccsdk.apps.controllerblueprints.core.data.*\r
  24 import org.onap.ccsdk.apps.controllerblueprints.core.utils.JacksonUtils\r
  25 \r
  26 /**\r
  27  *\r
  28  *\r
  29  * @author Brinda Santh\r
  30  */\r
  31 class BluePrintContext(val serviceTemplate: ServiceTemplate) {\r
  32 \r
  33     private val log: EELFLogger = EELFManager.getInstance().getLogger(this::class.toString())\r
  34 \r
  35     val imports: List<ImportDefinition>? = serviceTemplate.imports\r
  36 \r
  37     val metadata: MutableMap<String, String>? = serviceTemplate.metadata\r
  38 \r
  39     val dataTypes: MutableMap<String, DataType>? = serviceTemplate.dataTypes\r
  40 \r
  41     val inputs: MutableMap<String, PropertyDefinition>? = serviceTemplate.topologyTemplate?.inputs\r
  42 \r
  43     fun blueprintJson(pretty: Boolean = false): String = print("json", pretty)\r
  44 \r
  45     private fun print(type: String? = "json", pretty: Boolean = false): String {\r
  46         return JacksonUtils.getJson(serviceTemplate, pretty)\r
  47     }\r
  48 \r
  49     // Workflow\r
  50     val workflows: MutableMap<String, Workflow>? = serviceTemplate.topologyTemplate?.workflows\r
  51 \r
  52     fun workflowByName(workFlowName: String): Workflow = workflows?.get(workFlowName)\r
  53             ?: throw BluePrintException("could't get workflow($workFlowName)")\r
  54 \r
  55     fun workflowStepByName(workFlowName: String, stepName: String): Step {\r
  56         return workflowByName(workFlowName).steps?.get(stepName)\r
  57                 ?: throw BluePrintException("could't get step($stepName) for workflow($workFlowName)")\r
  58     }\r
  59 \r
  60     fun workflowStepNodeTemplate(workFlowName: String, stepName: String): String {\r
  61         return workflowStepByName(workFlowName, stepName).target\r
  62                 ?: throw BluePrintException("could't get node template name for workflow($workFlowName)'s step($stepName)")\r
  63     }\r
  64 \r
  65     fun workflowFirstStepNodeTemplate(workFlowName: String): String {\r
  66         val firstStepName = workflowByName(workFlowName).steps?.keys?.first()\r
  67                 ?: throw BluePrintException("could't get first step for workflow($workFlowName)")\r
  68         return workflowStepNodeTemplate(workFlowName, firstStepName)\r
  69     }\r
  70 \r
  71     fun workflowStepFirstCallOperation(workFlowName: String, stepName: String): String {\r
  72         return workflowStepByName(workFlowName, stepName).activities?.filter { it.callOperation != null }?.single()?.callOperation\r
  73                 ?: throw BluePrintException("could't get first callOperation for WorkFlow($workFlowName) ")\r
  74     }\r
  75 \r
  76     // Data Type\r
  77     fun dataTypeByName(name: String): DataType? = dataTypes?.get(name)\r
  78 \r
  79     // Artifact Type\r
  80     val artifactTypes: MutableMap<String, ArtifactType>? = serviceTemplate.artifactTypes\r
  81 \r
  82     // Policy Types\r
  83     val policyTypes: MutableMap<String, PolicyType>? = serviceTemplate.policyTypes\r
  84 \r
  85     fun policyTypeByName(policyName: String) = policyTypes?.get(policyName)\r
  86             ?: throw BluePrintException("could't get policy type for the name($policyName)")\r
  87 \r
  88     fun policyTypesDerivedFrom(name: String): MutableMap<String, PolicyType>? {\r
  89         return policyTypes?.filterValues { policyType -> policyType.derivedFrom == name }?.toMutableMap()\r
  90     }\r
  91 \r
  92     fun policyTypesTarget(target: String): MutableMap<String, PolicyType>? {\r
  93         return policyTypes?.filterValues { it.targets.contains(target) }?.toMutableMap()\r
  94     }\r
  95 \r
  96     fun policyTypesTargetNDerivedFrom(target: String, derivedFrom: String): MutableMap<String, PolicyType>? {\r
  97         return policyTypesDerivedFrom(derivedFrom)?.filterValues {\r
  98             it.targets.contains(target)\r
  99         }?.toMutableMap()\r
 100     }\r
 101 \r
 102     // Node Type Methods\r
 103     val nodeTypes: MutableMap<String, NodeType>? = serviceTemplate.nodeTypes\r
 104 \r
 105     fun nodeTypeByName(name: String): NodeType =\r
 106             nodeTypes?.get(name)\r
 107                     ?: throw BluePrintException("could't get node type for the name($name)")\r
 108 \r
 109     fun nodeTypeDerivedFrom(name: String): MutableMap<String, NodeType>? {\r
 110         return nodeTypes?.filterValues { nodeType -> nodeType.derivedFrom == name }?.toMutableMap()\r
 111     }\r
 112 \r
 113     fun nodeTypeInterface(nodeTypeName: String, interfaceName: String): InterfaceDefinition {\r
 114         return nodeTypeByName(nodeTypeName).interfaces?.get(interfaceName)\r
 115                 ?: throw BluePrintException("could't get node type($nodeTypeName)'s interface definition($interfaceName)")\r
 116     }\r
 117 \r
 118     fun nodeTypeInterfaceOperation(nodeTypeName: String, interfaceName: String, operationName: String): OperationDefinition {\r
 119         return nodeTypeInterface(nodeTypeName, interfaceName).operations?.get(operationName)\r
 120                 ?: throw BluePrintException("could't get node type($nodeTypeName)'s interface definition($interfaceName) operation definition($operationName)")\r
 121     }\r
 122 \r
 123     fun interfaceNameForNodeType(nodeTypeName: String): String {\r
 124         return nodeTypeByName(nodeTypeName).interfaces?.keys?.first()\r
 125                 ?: throw BluePrintException("could't get NodeType($nodeTypeName)'s first InterfaceDefinition name")\r
 126     }\r
 127 \r
 128     fun nodeTypeInterfaceOperationInputs(nodeTypeName: String, interfaceName: String, operationName: String): MutableMap<String, PropertyDefinition>? {\r
 129         return nodeTypeInterfaceOperation(nodeTypeName, interfaceName, operationName).inputs\r
 130     }\r
 131 \r
 132     fun nodeTypeInterfaceOperationOutputs(nodeTypeName: String, interfaceName: String, operationName: String): MutableMap<String, PropertyDefinition>? {\r
 133         return nodeTypeInterfaceOperation(nodeTypeName, interfaceName, operationName).outputs\r
 134     }\r
 135 \r
 136     // Node Template Methods\r
 137     val nodeTemplates: MutableMap<String, NodeTemplate>? = serviceTemplate.topologyTemplate?.nodeTemplates\r
 138 \r
 139     fun nodeTemplateByName(name: String): NodeTemplate =\r
 140             nodeTemplates?.get(name) ?: throw BluePrintException("could't get node template for the name($name) ")\r
 141 \r
 142     fun nodeTemplateForNodeType(name: String): MutableMap<String, NodeTemplate>? {\r
 143         return nodeTemplates?.filterValues { nodeTemplate -> nodeTemplate.type == name }?.toMutableMap()\r
 144     }\r
 145 \r
 146     fun nodeTemplateNodeType(nodeTemplateName: String): NodeType {\r
 147         val nodeTemplateType: String = nodeTemplateByName(nodeTemplateName).type\r
 148         return nodeTypeByName(nodeTemplateType)\r
 149     }\r
 150 \r
 151     fun nodeTemplateProperty(nodeTemplateName: String, propertyName: String): Any? {\r
 152         return nodeTemplateByName(nodeTemplateName).properties?.get(propertyName)\r
 153     }\r
 154 \r
 155     fun nodeTemplateArtifacts(nodeTemplateName: String): MutableMap<String, ArtifactDefinition>? {\r
 156         return nodeTemplateByName(nodeTemplateName).artifacts\r
 157     }\r
 158 \r
 159     fun nodeTemplateArtifact(nodeTemplateName: String, artifactName: String): ArtifactDefinition {\r
 160         return nodeTemplateArtifacts(nodeTemplateName)?.get(artifactName)\r
 161                 ?: throw BluePrintException("could't get NodeTemplate($nodeTemplateName)'s ArtifactDefinition($artifactName)")\r
 162     }\r
 163 \r
 164     fun nodeTemplateArtifactForArtifactType(nodeTemplateName: String, artifactType: String): ArtifactDefinition {\r
 165         return nodeTemplateArtifacts(nodeTemplateName)?.filter { it.value.type == artifactType }?.map { it.value }?.get(0)\r
 166                 ?: throw BluePrintException("could't get NodeTemplate($nodeTemplateName)'s Artifact Type($artifactType)")\r
 167     }\r
 168 \r
 169     fun nodeTemplateFirstInterface(nodeTemplateName: String): InterfaceAssignment {\r
 170         return nodeTemplateByName(nodeTemplateName).interfaces?.values?.first()\r
 171                 ?: throw BluePrintException("could't get NodeTemplate($nodeTemplateName)'s first InterfaceAssignment")\r
 172     }\r
 173 \r
 174     fun nodeTemplateFirstInterfaceName(nodeTemplateName: String): String {\r
 175         return nodeTemplateByName(nodeTemplateName).interfaces?.keys?.first()\r
 176                 ?: throw BluePrintException("could't get NodeTemplate($nodeTemplateName)'s first InterfaceAssignment name")\r
 177     }\r
 178 \r
 179     fun nodeTemplateFirstInterfaceFirstOperationName(nodeTemplateName: String): String {\r
 180         return nodeTemplateFirstInterface(nodeTemplateName).operations?.keys?.first()\r
 181                 ?: throw BluePrintException("could't get NodeTemplate($nodeTemplateName)'s first InterfaceAssignment's first OperationAssignment name")\r
 182     }\r
 183 \r
 184     fun nodeTemplateInterfaceOperationInputs(nodeTemplateName: String, interfaceName: String, operationName: String): MutableMap<String, JsonNode>? {\r
 185         return nodeTemplateInterfaceOperation(nodeTemplateName, interfaceName, operationName).inputs\r
 186     }\r
 187 \r
 188     fun nodeTemplateInterfaceOperationOutputs(nodeTemplateName: String, interfaceName: String, operationName: String): MutableMap<String, JsonNode>? {\r
 189         return nodeTemplateInterfaceOperation(nodeTemplateName, interfaceName, operationName).outputs\r
 190     }\r
 191 \r
 192     fun nodeTemplateInterface(nodeTemplateName: String, interfaceName: String): InterfaceAssignment {\r
 193         return nodeTemplateByName(nodeTemplateName).interfaces?.get(interfaceName)\r
 194                 ?: throw BluePrintException("could't get NodeTemplate($nodeTemplateName)'s InterfaceAssignment($interfaceName)")\r
 195     }\r
 196 \r
 197     fun nodeTemplateInterfaceOperation(nodeTemplateName: String, interfaceName: String, operationName: String): OperationAssignment {\r
 198         return nodeTemplateInterface(nodeTemplateName, interfaceName).operations?.get(operationName)\r
 199                 ?: throw BluePrintException("could't get NodeTemplate($nodeTemplateName)'s InterfaceAssignment($interfaceName) OperationAssignment($operationName)")\r
 200     }\r
 201 \r
 202     fun nodeTemplateCapability(nodeTemplateName: String, capabilityName: String): CapabilityAssignment {\r
 203         return nodeTemplateByName(nodeTemplateName).capabilities?.get(capabilityName)\r
 204                 ?: throw BluePrintException("could't get NodeTemplate($nodeTemplateName)'s CapabilityAssignment($capabilityName)")\r
 205     }\r
 206 \r
 207     fun nodeTemplateRequirement(nodeTemplateName: String, requirementName: String): RequirementAssignment {\r
 208         return nodeTemplateByName(nodeTemplateName).requirements?.get(requirementName)\r
 209                 ?: throw BluePrintException("could't get NodeTemplate($nodeTemplateName)'s first RequirementAssignment($requirementName)")\r
 210     }\r
 211 \r
 212     fun nodeTemplateRequirementNode(nodeTemplateName: String, requirementName: String): NodeTemplate {\r
 213         val filteredNodeTemplateName: String = nodeTemplateByName(nodeTemplateName).requirements?.get(requirementName)?.node\r
 214                 ?: throw BluePrintException("could't NodeTemplate for NodeTemplate's($nodeTemplateName) requirement's ($requirementName) ")\r
 215         return nodeTemplateByName(filteredNodeTemplateName)\r
 216     }\r
 217 \r
 218     fun nodeTemplateCapabilityProperty(nodeTemplateName: String, capabilityName: String, propertyName: String): Any? {\r
 219         return nodeTemplateCapability(nodeTemplateName, capabilityName).properties?.get(propertyName)\r
 220     }\r
 221 \r
 222     // Chained Functions\r
 223 \r
 224     fun nodeTypeChained(nodeTypeName: String): NodeType {\r
 225         return BluePrintChainedService(this).nodeTypeChained(nodeTypeName)\r
 226     }\r
 227 \r
 228     fun nodeTypeChainedProperties(nodeTypeName: String): MutableMap<String, PropertyDefinition>? {\r
 229         return BluePrintChainedService(this).nodeTypeChainedProperties(nodeTypeName)\r
 230     }\r
 231 \r
 232 }