gerrit.onap Code Review - ccsdk/cds.git/blob

   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 @file:Suppress("unused")\r
  17 \r
  18 package org.onap.ccsdk.apps.controllerblueprints.core.service\r
  19 \r
  20 import com.att.eelf.configuration.EELFLogger\r
  21 import com.att.eelf.configuration.EELFManager\r
  22 import com.fasterxml.jackson.databind.JsonNode\r
  23 import org.onap.ccsdk.apps.controllerblueprints.core.BluePrintConstants\r
  24 import org.onap.ccsdk.apps.controllerblueprints.core.BluePrintException\r
  25 import org.onap.ccsdk.apps.controllerblueprints.core.data.*\r
  26 import org.onap.ccsdk.apps.controllerblueprints.core.utils.JacksonUtils\r
  27 \r
  28 /**\r
  29  *\r
  30  *\r
  31  * @author Brinda Santh\r
  32  */\r
  33 class BluePrintContext(val serviceTemplate: ServiceTemplate) {\r
  34 \r
  35     private val log: EELFLogger = EELFManager.getInstance().getLogger(this::class.toString())\r
  36 \r
  37     /**\r
  38      * Blueprint CBA extracted file location\r
  39      */\r
  40     var rootPath = "."\r
  41     /**\r
  42      * Root Definition file path\r
  43      */\r
  44     var entryDefinition = ""\r
  45 \r
  46     val imports: List<ImportDefinition>? = serviceTemplate.imports\r
  47 \r
  48     val metadata: MutableMap<String, String>? = serviceTemplate.metadata\r
  49 \r
  50     val dataTypes: MutableMap<String, DataType>? = serviceTemplate.dataTypes\r
  51 \r
  52     val inputs: MutableMap<String, PropertyDefinition>? = serviceTemplate.topologyTemplate?.inputs\r
  53 \r
  54     fun blueprintJson(pretty: Boolean = false): String = print("json", pretty)\r
  55 \r
  56     private fun print(type: String? = "json", pretty: Boolean = false): String {\r
  57         return JacksonUtils.getJson(serviceTemplate, pretty)\r
  58     }\r
  59 \r
  60     fun name(): String = metadata?.get(BluePrintConstants.METADATA_TEMPLATE_NAME)\r
  61             ?: throw BluePrintException("could't get template name from meta data")\r
  62 \r
  63     fun version(): String = metadata?.get(BluePrintConstants.METADATA_TEMPLATE_VERSION)\r
  64             ?: throw BluePrintException("could't get template version from meta data")\r
  65 \r
  66     fun author(): String = metadata?.get(BluePrintConstants.METADATA_TEMPLATE_AUTHOR)\r
  67             ?: throw BluePrintException("could't get template author from meta data")\r
  68 \r
  69     // Workflow\r
  70     val workflows: MutableMap<String, Workflow>? = serviceTemplate.topologyTemplate?.workflows\r
  71 \r
  72     fun workflowByName(workFlowName: String): Workflow = workflows?.get(workFlowName)\r
  73             ?: throw BluePrintException("could't get workflow($workFlowName)")\r
  74 \r
  75     fun workflowInputs(workFlowName: String) = workflowByName(workFlowName).inputs\r
  76 \r
  77     fun workflowStepByName(workFlowName: String, stepName: String): Step {\r
  78         return workflowByName(workFlowName).steps?.get(stepName)\r
  79                 ?: throw BluePrintException("could't get step($stepName) for workflow($workFlowName)")\r
  80     }\r
  81 \r
  82     fun workflowStepNodeTemplate(workFlowName: String, stepName: String): String {\r
  83         return workflowStepByName(workFlowName, stepName).target\r
  84                 ?: throw BluePrintException("could't get node template name for workflow($workFlowName)'s step($stepName)")\r
  85     }\r
  86 \r
  87     fun workflowFirstStepNodeTemplate(workFlowName: String): String {\r
  88         val firstStepName = workflowByName(workFlowName).steps?.keys?.first()\r
  89                 ?: throw BluePrintException("could't get first step for workflow($workFlowName)")\r
  90         return workflowStepNodeTemplate(workFlowName, firstStepName)\r
  91     }\r
  92 \r
  93     fun workflowStepFirstCallOperation(workFlowName: String, stepName: String): String {\r
  94         return workflowStepByName(workFlowName, stepName).activities?.filter { it.callOperation != null }?.single()?.callOperation\r
  95                 ?: throw BluePrintException("could't get first callOperation for WorkFlow($workFlowName) ")\r
  96     }\r
  97 \r
  98     // Data Type\r
  99     fun dataTypeByName(name: String): DataType? = dataTypes?.get(name)\r
 100 \r
 101     // Artifact Type\r
 102     val artifactTypes: MutableMap<String, ArtifactType>? = serviceTemplate.artifactTypes\r
 103 \r
 104     // Policy Types\r
 105     val policyTypes: MutableMap<String, PolicyType>? = serviceTemplate.policyTypes\r
 106 \r
 107     fun policyTypeByName(policyName: String) = policyTypes?.get(policyName)\r
 108             ?: throw BluePrintException("could't get policy type for the name($policyName)")\r
 109 \r
 110     fun policyTypesDerivedFrom(name: String): MutableMap<String, PolicyType>? {\r
 111         return policyTypes?.filterValues { policyType -> policyType.derivedFrom == name }?.toMutableMap()\r
 112     }\r
 113 \r
 114     fun policyTypesTarget(target: String): MutableMap<String, PolicyType>? {\r
 115         return policyTypes?.filterValues { it.targets.contains(target) }?.toMutableMap()\r
 116     }\r
 117 \r
 118     fun policyTypesTargetNDerivedFrom(target: String, derivedFrom: String): MutableMap<String, PolicyType>? {\r
 119         return policyTypesDerivedFrom(derivedFrom)?.filterValues {\r
 120             it.targets.contains(target)\r
 121         }?.toMutableMap()\r
 122     }\r
 123 \r
 124     // Node Type Methods\r
 125     val nodeTypes: MutableMap<String, NodeType>? = serviceTemplate.nodeTypes\r
 126 \r
 127     fun nodeTypeByName(name: String): NodeType =\r
 128             nodeTypes?.get(name)\r
 129                     ?: throw BluePrintException("could't get node type for the name($name)")\r
 130 \r
 131     fun nodeTypeDerivedFrom(name: String): MutableMap<String, NodeType>? {\r
 132         return nodeTypes?.filterValues { nodeType -> nodeType.derivedFrom == name }?.toMutableMap()\r
 133     }\r
 134 \r
 135     fun nodeTypeInterface(nodeTypeName: String, interfaceName: String): InterfaceDefinition {\r
 136         return nodeTypeByName(nodeTypeName).interfaces?.get(interfaceName)\r
 137                 ?: throw BluePrintException("could't get node type($nodeTypeName)'s interface definition($interfaceName)")\r
 138     }\r
 139 \r
 140     fun nodeTypeInterfaceOperation(nodeTypeName: String, interfaceName: String, operationName: String): OperationDefinition {\r
 141         return nodeTypeInterface(nodeTypeName, interfaceName).operations?.get(operationName)\r
 142                 ?: throw BluePrintException("could't get node type($nodeTypeName)'s interface definition($interfaceName) operation definition($operationName)")\r
 143     }\r
 144 \r
 145     fun interfaceNameForNodeType(nodeTypeName: String): String {\r
 146         return nodeTypeByName(nodeTypeName).interfaces?.keys?.first()\r
 147                 ?: throw BluePrintException("could't get NodeType($nodeTypeName)'s first InterfaceDefinition name")\r
 148     }\r
 149 \r
 150     fun nodeTypeInterfaceOperationInputs(nodeTypeName: String, interfaceName: String, operationName: String): MutableMap<String, PropertyDefinition>? {\r
 151         return nodeTypeInterfaceOperation(nodeTypeName, interfaceName, operationName).inputs\r
 152     }\r
 153 \r
 154     fun nodeTypeInterfaceOperationOutputs(nodeTypeName: String, interfaceName: String, operationName: String): MutableMap<String, PropertyDefinition>? {\r
 155         return nodeTypeInterfaceOperation(nodeTypeName, interfaceName, operationName).outputs\r
 156     }\r
 157 \r
 158     // Node Template Methods\r
 159     val nodeTemplates: MutableMap<String, NodeTemplate>? = serviceTemplate.topologyTemplate?.nodeTemplates\r
 160 \r
 161     fun nodeTemplateByName(name: String): NodeTemplate =\r
 162             nodeTemplates?.get(name) ?: throw BluePrintException("could't get node template for the name($name)")\r
 163 \r
 164     fun nodeTemplateForNodeType(name: String): MutableMap<String, NodeTemplate>? {\r
 165         return nodeTemplates?.filterValues { nodeTemplate -> nodeTemplate.type == name }?.toMutableMap()\r
 166     }\r
 167 \r
 168     fun nodeTemplateNodeType(nodeTemplateName: String): NodeType {\r
 169         val nodeTemplateType: String = nodeTemplateByName(nodeTemplateName).type\r
 170         return nodeTypeByName(nodeTemplateType)\r
 171     }\r
 172 \r
 173     fun nodeTemplateProperty(nodeTemplateName: String, propertyName: String): Any? {\r
 174         return nodeTemplateByName(nodeTemplateName).properties?.get(propertyName)\r
 175     }\r
 176 \r
 177     fun nodeTemplateArtifacts(nodeTemplateName: String): MutableMap<String, ArtifactDefinition>? {\r
 178         return nodeTemplateByName(nodeTemplateName).artifacts\r
 179     }\r
 180 \r
 181     fun nodeTemplateArtifact(nodeTemplateName: String, artifactName: String): ArtifactDefinition {\r
 182         return nodeTemplateArtifacts(nodeTemplateName)?.get(artifactName)\r
 183                 ?: throw BluePrintException("could't get NodeTemplate($nodeTemplateName)'s ArtifactDefinition($artifactName)")\r
 184     }\r
 185 \r
 186     fun nodeTemplateArtifactForArtifactType(nodeTemplateName: String, artifactType: String): ArtifactDefinition {\r
 187         return nodeTemplateArtifacts(nodeTemplateName)?.filter { it.value.type == artifactType }?.map { it.value }?.get(0)\r
 188                 ?: throw BluePrintException("could't get NodeTemplate($nodeTemplateName)'s Artifact Type($artifactType)")\r
 189     }\r
 190 \r
 191     fun nodeTemplateFirstInterface(nodeTemplateName: String): InterfaceAssignment {\r
 192         return nodeTemplateByName(nodeTemplateName).interfaces?.values?.first()\r
 193                 ?: throw BluePrintException("could't get NodeTemplate($nodeTemplateName)'s first InterfaceAssignment")\r
 194     }\r
 195 \r
 196     fun nodeTemplateFirstInterfaceName(nodeTemplateName: String): String {\r
 197         return nodeTemplateByName(nodeTemplateName).interfaces?.keys?.first()\r
 198                 ?: throw BluePrintException("could't get NodeTemplate($nodeTemplateName)'s first InterfaceAssignment name")\r
 199     }\r
 200 \r
 201     fun nodeTemplateFirstInterfaceFirstOperationName(nodeTemplateName: String): String {\r
 202         return nodeTemplateFirstInterface(nodeTemplateName).operations?.keys?.first()\r
 203                 ?: throw BluePrintException("could't get NodeTemplate($nodeTemplateName)'s first InterfaceAssignment's first OperationAssignment name")\r
 204     }\r
 205 \r
 206     fun nodeTemplateInterfaceOperationInputs(nodeTemplateName: String, interfaceName: String, operationName: String): MutableMap<String, JsonNode>? {\r
 207         return nodeTemplateInterfaceOperation(nodeTemplateName, interfaceName, operationName).inputs\r
 208     }\r
 209 \r
 210     fun nodeTemplateInterfaceOperationOutputs(nodeTemplateName: String, interfaceName: String, operationName: String): MutableMap<String, JsonNode>? {\r
 211         return nodeTemplateInterfaceOperation(nodeTemplateName, interfaceName, operationName).outputs\r
 212     }\r
 213 \r
 214     fun nodeTemplateInterface(nodeTemplateName: String, interfaceName: String): InterfaceAssignment {\r
 215         return nodeTemplateByName(nodeTemplateName).interfaces?.get(interfaceName)\r
 216                 ?: throw BluePrintException("could't get NodeTemplate($nodeTemplateName)'s InterfaceAssignment($interfaceName)")\r
 217     }\r
 218 \r
 219     fun nodeTemplateInterfaceOperation(nodeTemplateName: String, interfaceName: String, operationName: String): OperationAssignment {\r
 220         return nodeTemplateInterface(nodeTemplateName, interfaceName).operations?.get(operationName)\r
 221                 ?: throw BluePrintException("could't get NodeTemplate($nodeTemplateName)'s InterfaceAssignment($interfaceName) OperationAssignment($operationName)")\r
 222     }\r
 223 \r
 224     fun nodeTemplateCapability(nodeTemplateName: String, capabilityName: String): CapabilityAssignment {\r
 225         return nodeTemplateByName(nodeTemplateName).capabilities?.get(capabilityName)\r
 226                 ?: throw BluePrintException("could't get NodeTemplate($nodeTemplateName)'s CapabilityAssignment($capabilityName)")\r
 227     }\r
 228 \r
 229     fun nodeTemplateRequirement(nodeTemplateName: String, requirementName: String): RequirementAssignment {\r
 230         return nodeTemplateByName(nodeTemplateName).requirements?.get(requirementName)\r
 231                 ?: throw BluePrintException("could't get NodeTemplate($nodeTemplateName)'s first RequirementAssignment($requirementName)")\r
 232     }\r
 233 \r
 234     fun nodeTemplateRequirementNode(nodeTemplateName: String, requirementName: String): NodeTemplate {\r
 235         val filteredNodeTemplateName: String = nodeTemplateByName(nodeTemplateName).requirements?.get(requirementName)?.node\r
 236                 ?: throw BluePrintException("could't NodeTemplate for NodeTemplate's($nodeTemplateName) requirement's ($requirementName) ")\r
 237         return nodeTemplateByName(filteredNodeTemplateName)\r
 238     }\r
 239 \r
 240     fun nodeTemplateCapabilityProperty(nodeTemplateName: String, capabilityName: String, propertyName: String): Any? {\r
 241         return nodeTemplateCapability(nodeTemplateName, capabilityName).properties?.get(propertyName)\r
 242     }\r
 243 \r
 244     // Chained Functions\r
 245 \r
 246     fun nodeTypeChained(nodeTypeName: String): NodeType {\r
 247         return BluePrintChainedService(this).nodeTypeChained(nodeTypeName)\r
 248     }\r
 249 \r
 250     fun nodeTypeChainedProperties(nodeTypeName: String): MutableMap<String, PropertyDefinition>? {\r
 251         return BluePrintChainedService(this).nodeTypeChainedProperties(nodeTypeName)\r
 252     }\r
 253 \r
 254 }