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  * @author Brinda Santh\r
  29  */\r
  30 class BluePrintContext(serviceTemplate: ServiceTemplate) {\r
  31 \r
  32     private val log: EELFLogger = EELFManager.getInstance().getLogger(this::class.toString())\r
  33 \r
  34     val serviceTemplate: ServiceTemplate = serviceTemplate\r
  35 \r
  36     val imports: List<ImportDefinition>? = serviceTemplate.imports\r
  37 \r
  38     val metadata: MutableMap<String, String>? = serviceTemplate.metadata\r
  39 \r
  40     val dataTypes: MutableMap<String, DataType>? = serviceTemplate.dataTypes\r
  41 \r
  42     val inputs: MutableMap<String, PropertyDefinition>? = serviceTemplate.topologyTemplate?.inputs\r
  43 \r
  44     val workflows: MutableMap<String, Workflow>? = serviceTemplate.topologyTemplate?.workflows\r
  45 \r
  46     fun blueprintJson(pretty: Boolean = false): String = print("json", pretty)\r
  47 \r
  48     fun blueprintYaml(pretty: Boolean = false): String = print("yaml", pretty)\r
  49 \r
  50     private fun print(type: String? = "json", pretty: Boolean = false): String {\r
  51         return JacksonUtils.getJson(serviceTemplate, pretty)\r
  52     }\r
  53 \r
  54     // Workflow\r
  55     fun workflowByName(name: String): Workflow? = workflows?.get(name)\r
  56 \r
  57     // Data Type\r
  58     fun dataTypeByName(name: String): DataType? = dataTypes?.get(name)\r
  59 \r
  60     // Artifact Type\r
  61     val artifactTypes: MutableMap<String, ArtifactType>? = serviceTemplate.artifactTypes\r
  62 \r
  63     // Node Type Methods\r
  64     val nodeTypes: MutableMap<String, NodeType>? = serviceTemplate.nodeTypes\r
  65 \r
  66     fun nodeTypeByName(name: String): NodeType =\r
  67             nodeTypes?.get(name) ?: throw BluePrintException(String.format("Failed to get node type for the name : %s", name))\r
  68 \r
  69     fun nodeTypeDerivedFrom(name: String): MutableMap<String, NodeType>? {\r
  70         return nodeTypes?.filterValues { nodeType -> nodeType.derivedFrom == name }?.toMutableMap()\r
  71     }\r
  72 \r
  73     fun nodeTypeInterface(nodeTypeName: String, interfaceName: String): InterfaceDefinition? {\r
  74         return nodeTypeByName(nodeTypeName).interfaces?.values?.first()\r
  75     }\r
  76 \r
  77     fun nodeTypeInterfaceOperation(nodeTypeName: String, interfaceName: String, operationName: String): OperationDefinition? {\r
  78         return nodeTypeInterface(nodeTypeName, interfaceName)?.operations?.get(operationName)\r
  79     }\r
  80 \r
  81     fun interfaceNameForNodeType(nodeTypeName: String): String? {\r
  82         return nodeTypeByName(nodeTypeName).interfaces?.keys?.first()\r
  83     }\r
  84 \r
  85     fun nodeTypeInterfaceOperationInputs(nodeTypeName: String, interfaceName: String, operationName: String): MutableMap<String, PropertyDefinition>? {\r
  86         return nodeTypeInterfaceOperation(nodeTypeName, interfaceName, operationName)?.inputs\r
  87     }\r
  88 \r
  89     fun nodeTypeInterfaceOperationOutputs(nodeTypeName: String, interfaceName: String, operationName: String): MutableMap<String, PropertyDefinition>? {\r
  90         return nodeTypeInterfaceOperation(nodeTypeName, interfaceName, operationName)?.outputs\r
  91     }\r
  92 \r
  93     // Node Template Methods\r
  94     val nodeTemplates: MutableMap<String, NodeTemplate>? = serviceTemplate.topologyTemplate?.nodeTemplates\r
  95 \r
  96     fun nodeTemplateByName(name: String): NodeTemplate =\r
  97             nodeTemplates?.get(name) ?: throw BluePrintException("Failed to get node template for the name " + name)\r
  98 \r
  99     fun nodeTemplateForNodeType(name: String): MutableMap<String, NodeTemplate>? {\r
 100         return nodeTemplates?.filterValues { nodeTemplate -> nodeTemplate.type == name }?.toMutableMap()\r
 101     }\r
 102 \r
 103     fun nodeTemplateNodeType(nodeTemplateName: String): NodeType {\r
 104         val nodeTemplateType: String = nodeTemplateByName(nodeTemplateName).type\r
 105         return nodeTypeByName(nodeTemplateType)\r
 106     }\r
 107 \r
 108     fun nodeTemplateProperty(nodeTemplateName: String, propertyName: String): Any? {\r
 109         return nodeTemplateByName(nodeTemplateName).properties?.get(propertyName)\r
 110     }\r
 111 \r
 112     fun nodeTemplateArtifacts(nodeTemplateName: String): MutableMap<String, ArtifactDefinition>? {\r
 113         return nodeTemplateByName(nodeTemplateName).artifacts\r
 114     }\r
 115 \r
 116     fun nodeTemplateArtifact(nodeTemplateName: String, artifactName: String): ArtifactDefinition? {\r
 117         return nodeTemplateArtifacts(nodeTemplateName)?.get(artifactName)\r
 118     }\r
 119 \r
 120     fun nodeTemplateFirstInterface(nodeTemplateName: String): InterfaceAssignment? {\r
 121         return nodeTemplateByName(nodeTemplateName).interfaces?.values?.first()\r
 122     }\r
 123 \r
 124     fun nodeTemplateFirstInterfaceName(nodeTemplateName: String): String? {\r
 125         return nodeTemplateByName(nodeTemplateName).interfaces?.keys?.first()\r
 126     }\r
 127 \r
 128     fun nodeTemplateFirstInterfaceFirstOperationName(nodeTemplateName: String): String? {\r
 129         return nodeTemplateFirstInterface(nodeTemplateName)?.operations?.keys?.first()\r
 130     }\r
 131 \r
 132     fun nodeTemplateInterfaceOperationInputs(nodeTemplateName: String, interfaceName: String, operationName: String): MutableMap<String, JsonNode>? {\r
 133         return nodeTemplateByName(nodeTemplateName).interfaces?.get(interfaceName)?.operations?.get(operationName)?.inputs\r
 134     }\r
 135 \r
 136     fun nodeTemplateInterfaceOperationOutputs(nodeTemplateName: String, interfaceName: String, operationName: String): MutableMap<String, JsonNode>? {\r
 137         return nodeTemplateByName(nodeTemplateName).interfaces?.get(interfaceName)?.operations?.get(operationName)?.outputs\r
 138     }\r
 139 \r
 140     fun nodeTemplateInterface(nodeTemplateName: String, interfaceName: String): InterfaceAssignment? {\r
 141         return nodeTemplateByName(nodeTemplateName).interfaces?.get(interfaceName)\r
 142     }\r
 143 \r
 144 \r
 145     fun nodeTemplateInterfaceOperation(nodeTemplateName: String, interfaceName: String, operationName: String): OperationAssignment? {\r
 146         return nodeTemplateInterface(nodeTemplateName, interfaceName)?.operations?.get(operationName)\r
 147     }\r
 148 \r
 149     fun nodeTemplateCapability(nodeTemplateName: String, capabilityName: String): CapabilityAssignment? {\r
 150         return nodeTemplateByName(nodeTemplateName).capabilities?.get(capabilityName)\r
 151     }\r
 152 \r
 153     fun nodeTemplateRequirement(nodeTemplateName: String, requirementName: String): RequirementAssignment? {\r
 154         return nodeTemplateByName(nodeTemplateName).requirements?.get(requirementName)\r
 155     }\r
 156 \r
 157     fun nodeTemplateRequirementNode(nodeTemplateName: String, requirementName: String): NodeTemplate {\r
 158         val nodeTemplateName: String = nodeTemplateByName(nodeTemplateName).requirements?.get(requirementName)?.node\r
 159                 ?: throw BluePrintException(String.format("failed to get node name for node template's (%s) requirement's (%s) " + nodeTemplateName, requirementName))\r
 160         return nodeTemplateByName(nodeTemplateName)\r
 161     }\r
 162 \r
 163     fun nodeTemplateCapabilityProperty(nodeTemplateName: String, capabilityName: String, propertyName: String): Any? {\r
 164         return nodeTemplateCapability(nodeTemplateName, capabilityName)?.properties?.get(propertyName)\r
 165     }\r
 166 \r
 167     // Chained Functions\r
 168 \r
 169     fun nodeTypeChained(nodeTypeName: String): NodeType {\r
 170         return BluePrintChainedService(this).nodeTypeChained(nodeTypeName)\r
 171     }\r
 172 \r
 173     fun nodeTypeChainedProperties(nodeTypeName: String): MutableMap<String, PropertyDefinition>? {\r
 174         return BluePrintChainedService(this).nodeTypeChainedProperties(nodeTypeName)\r
 175     }\r
 176 \r
 177 }