ms/controllerblueprints/modules/blueprint-core/src/main/kotlin/org/onap/ccsdk/cds/controllerblueprints/core/dsl/BluePrintTemplateDSLBuilder.kt

   1 /*
   2  *  Copyright © 2019 IBM.
   3  *
   4  *  Licensed under the Apache License, Version 2.0 (the "License");
   5  *  you may not use this file except in compliance with the License.
   6  *  You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  *  Unless required by applicable law or agreed to in writing, software
  11  *  distributed under the License is distributed on an "AS IS" BASIS,
  12  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  *  See the License for the specific language governing permissions and
  14  *  limitations under the License.
  15  */
  16
  17 package org.onap.ccsdk.cds.controllerblueprints.core.dsl
  18
  19 import com.fasterxml.jackson.databind.JsonNode
  20 import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintConstants
  21 import org.onap.ccsdk.cds.controllerblueprints.core.asJsonType
  22 import org.onap.ccsdk.cds.controllerblueprints.core.data.ArtifactDefinition
  23 import org.onap.ccsdk.cds.controllerblueprints.core.data.CapabilityAssignment
  24 import org.onap.ccsdk.cds.controllerblueprints.core.data.Implementation
  25 import org.onap.ccsdk.cds.controllerblueprints.core.data.InterfaceAssignment
  26 import org.onap.ccsdk.cds.controllerblueprints.core.data.NodeTemplate
  27 import org.onap.ccsdk.cds.controllerblueprints.core.data.OperationAssignment
  28 import org.onap.ccsdk.cds.controllerblueprints.core.data.RequirementAssignment
  29 import org.onap.ccsdk.cds.controllerblueprints.core.data.TopologyTemplate
  30 import org.onap.ccsdk.cds.controllerblueprints.core.data.Workflow
  31 import kotlin.reflect.KClass
  32 import kotlin.reflect.full.createInstance
  33 import kotlin.reflect.jvm.reflect
  34
  35 class TopologyTemplateBuilder {
  36     private var topologyTemplate = TopologyTemplate()
  37     private var nodeTemplates: MutableMap<String, NodeTemplate>? = null
  38     private var workflows: MutableMap<String, Workflow>? = null
  39
  40     fun nodeTemplate(id: String, type: String, description: String, block: NodeTemplateBuilder.() -> Unit) {
  41         if (nodeTemplates == null)
  42             nodeTemplates = hashMapOf()
  43         nodeTemplates!![id] = NodeTemplateBuilder(id, type, description).apply(block).build()
  44     }
  45
  46     fun nodeTemplate(nodeTemplate: NodeTemplate) {
  47         if (nodeTemplates == null)
  48             nodeTemplates = hashMapOf()
  49         nodeTemplates!![nodeTemplate.id!!] = nodeTemplate
  50     }
  51
  52     fun nodeTemplateOperation(
  53         nodeTemplateName: String,
  54         type: String,
  55         interfaceName: String,
  56         description: String,
  57         operationBlock: OperationAssignmentBuilder<PropertiesAssignmentBuilder,
  58                 PropertiesAssignmentBuilder>.() -> Unit
  59     ) {
  60         if (nodeTemplates == null)
  61             nodeTemplates = hashMapOf()
  62
  63         val nodeTemplateBuilder = NodeTemplateBuilder(nodeTemplateName, type, description)
  64         nodeTemplateBuilder.operation(interfaceName, "$description operation", operationBlock)
  65         nodeTemplates!![nodeTemplateName] = nodeTemplateBuilder.build()
  66     }
  67
  68     fun workflow(id: String, description: String, block: WorkflowBuilder.() -> Unit) {
  69         if (workflows == null)
  70             workflows = hashMapOf()
  71         workflows!![id] = WorkflowBuilder(id, description).apply(block).build()
  72     }
  73
  74     fun workflow(workflow: Workflow) {
  75         if (workflows == null)
  76             workflows = hashMapOf()
  77         workflows!![workflow.id!!] = workflow
  78     }
  79
  80     // TODO("populate inputs, outputs")
  81     fun workflowNodeTemplate(
  82         actionName: String,
  83         nodeTemplateType: String,
  84         description: String,
  85         block: NodeTemplateBuilder.() -> Unit
  86     ) {
  87         if (nodeTemplates == null)
  88             nodeTemplates = hashMapOf()
  89
  90         if (workflows == null)
  91             workflows = hashMapOf()
  92
  93         val workflowBuilder = WorkflowBuilder(actionName, description)
  94         workflowBuilder.nodeTemplateStep(actionName, description)
  95         // Workflow name is NodeTemplate name
  96         workflows!![actionName] = workflowBuilder.build()
  97
  98         nodeTemplates!![actionName] = NodeTemplateBuilder(actionName, nodeTemplateType, description).apply(block).build()
  99     }
 100
 101     fun build(): TopologyTemplate {
 102         topologyTemplate.nodeTemplates = nodeTemplates
 103         topologyTemplate.workflows = workflows
 104         return topologyTemplate
 105     }
 106 }
 107
 108 open class NodeTemplateBuilder(
 109     private val id: String,
 110     private val type: String,
 111     private val description: String? = ""
 112 ) {
 113
 114     private var nodeTemplate: NodeTemplate = NodeTemplate()
 115     private var properties: MutableMap<String, JsonNode>? = null
 116     private var interfaces: MutableMap<String, InterfaceAssignment>? = null
 117     private var artifacts: MutableMap<String, ArtifactDefinition>? = null
 118     private var capabilities: MutableMap<String, CapabilityAssignment>? = null
 119     private var requirements: MutableMap<String, RequirementAssignment>? = null
 120
 121     fun properties(properties: MutableMap<String, JsonNode>?) {
 122         this.properties = properties
 123     }
 124
 125     fun properties(block: PropertiesAssignmentBuilder.() -> Unit) {
 126         if (properties == null)
 127             properties = hashMapOf()
 128         properties = PropertiesAssignmentBuilder().apply(block).build()
 129     }
 130
 131     open fun <Prop : PropertiesAssignmentBuilder> typedProperties(block: Prop.() -> Unit) {
 132         if (properties == null)
 133             properties = hashMapOf()
 134         val instance: Prop = (block.reflect()?.parameters?.get(0)?.type?.classifier as KClass<Prop>).createInstance()
 135         properties = instance.apply(block).build()
 136     }
 137
 138     open fun <In : PropertiesAssignmentBuilder, Out : PropertiesAssignmentBuilder> typedOperation(
 139         interfaceName: String,
 140         description: String = "",
 141         block: OperationAssignmentBuilder<In, Out>.() -> Unit
 142     ) {
 143         if (interfaces == null)
 144             interfaces = hashMapOf()
 145
 146         val interfaceAssignment = InterfaceAssignment()
 147         val defaultOperationName = BluePrintConstants.DEFAULT_STEP_OPERATION
 148         interfaceAssignment.operations = hashMapOf()
 149         interfaceAssignment.operations!![defaultOperationName] =
 150             OperationAssignmentBuilder<In, Out>(defaultOperationName, description).apply(block).build()
 151         interfaces!![interfaceName] = interfaceAssignment
 152     }
 153
 154     fun operation(
 155         interfaceName: String,
 156         description: String,
 157         block: OperationAssignmentBuilder<PropertiesAssignmentBuilder, PropertiesAssignmentBuilder>.() -> Unit
 158     ) {
 159         typedOperation<PropertiesAssignmentBuilder, PropertiesAssignmentBuilder>(interfaceName, description, block)
 160     }
 161
 162     fun artifact(id: String, type: String, file: String) {
 163         if (artifacts == null)
 164             artifacts = hashMapOf()
 165         artifacts!![id] = ArtifactDefinitionBuilder(id, type, file).build()
 166     }
 167
 168     fun artifact(id: String, type: String, file: String, block: ArtifactDefinitionBuilder.() -> Unit) {
 169         if (artifacts == null)
 170             artifacts = hashMapOf()
 171         artifacts!![id] = ArtifactDefinitionBuilder(id, type, file).apply(block).build()
 172     }
 173
 174     fun artifacts(artifacts: MutableMap<String, ArtifactDefinition>?) {
 175         this.artifacts = artifacts
 176     }
 177
 178     fun capability(id: String, block: CapabilityAssignmentBuilder.() -> Unit) {
 179         if (capabilities == null)
 180             capabilities = hashMapOf()
 181         capabilities!![id] = CapabilityAssignmentBuilder(id).apply(block).build()
 182     }
 183
 184     fun capabilities(capabilities: MutableMap<String, CapabilityAssignment>?) {
 185         this.capabilities = capabilities
 186     }
 187
 188     fun requirement(id: String, capability: String, node: String, relationship: String) {
 189         if (requirements == null)
 190             requirements = hashMapOf()
 191         requirements!![id] = RequirementAssignmentBuilder(id, capability, node, relationship).build()
 192     }
 193
 194     fun requirements(requirements: MutableMap<String, RequirementAssignment>?) {
 195         this.requirements = requirements
 196     }
 197
 198     fun build(): NodeTemplate {
 199         nodeTemplate.id = id
 200         nodeTemplate.type = type
 201         nodeTemplate.description = description
 202         nodeTemplate.properties = properties
 203         nodeTemplate.interfaces = interfaces
 204         nodeTemplate.artifacts = artifacts
 205         nodeTemplate.capabilities = capabilities
 206         nodeTemplate.requirements = requirements
 207         return nodeTemplate
 208     }
 209 }
 210
 211 class ArtifactDefinitionBuilder(private val id: String, private val type: String, private val file: String) {
 212
 213     private var artifactDefinition: ArtifactDefinition = ArtifactDefinition()
 214     private var properties: MutableMap<String, JsonNode>? = null
 215
 216     fun repository(repository: String) {
 217         artifactDefinition.repository = repository
 218     }
 219
 220     fun deployPath(deployPath: String) {
 221         artifactDefinition.deployPath = deployPath
 222     }
 223
 224     fun properties(block: PropertiesAssignmentBuilder.() -> Unit) {
 225         if (properties == null)
 226             properties = hashMapOf()
 227         properties = PropertiesAssignmentBuilder().apply(block).build()
 228     }
 229
 230     fun build(): ArtifactDefinition {
 231         artifactDefinition.id = id
 232         artifactDefinition.type = type
 233         artifactDefinition.file = file
 234         artifactDefinition.properties = properties
 235         return artifactDefinition
 236     }
 237 }
 238
 239 open class CapabilityAssignmentBuilder(private val id: String) {
 240     var capabilityAssignment: CapabilityAssignment = CapabilityAssignment()
 241     var attributes: MutableMap<String, JsonNode>? = null
 242     var properties: MutableMap<String, JsonNode>? = null
 243
 244     fun attributes(block: AttributesAssignmentBuilder.() -> Unit) {
 245         if (attributes == null)
 246             attributes = hashMapOf()
 247         attributes = AttributesAssignmentBuilder().apply(block).build()
 248     }
 249
 250     fun properties(block: PropertiesAssignmentBuilder.() -> Unit) {
 251         if (properties == null)
 252             properties = hashMapOf()
 253         properties = PropertiesAssignmentBuilder().apply(block).build()
 254     }
 255
 256     fun build(): CapabilityAssignment {
 257         capabilityAssignment.properties = properties
 258         capabilityAssignment.attributes = attributes
 259         return capabilityAssignment
 260     }
 261 }
 262
 263 open class RequirementAssignmentBuilder(
 264     private val id: String,
 265     private val capability: String,
 266     private val node: String,
 267     private val relationship: String
 268 ) {
 269
 270     private var requirementAssignment: RequirementAssignment = RequirementAssignment()
 271
 272     fun build(): RequirementAssignment {
 273         requirementAssignment.id = id
 274         requirementAssignment.capability = capability
 275         requirementAssignment.node = node
 276         requirementAssignment.relationship = relationship
 277         return requirementAssignment
 278     }
 279 }
 280
 281 class InterfaceAssignmentBuilder(private val id: String) {
 282
 283     private var interfaceAssignment: InterfaceAssignment = InterfaceAssignment()
 284     private var operations: MutableMap<String, OperationAssignment>? = null
 285
 286     fun operation(
 287         id: String,
 288         description: String? = "",
 289         block: OperationAssignmentBuilder<PropertiesAssignmentBuilder, PropertiesAssignmentBuilder>.() -> Unit
 290     ) {
 291         if (operations == null)
 292             operations = hashMapOf()
 293         operations!![id] = OperationAssignmentBuilder<PropertiesAssignmentBuilder, PropertiesAssignmentBuilder>(
 294             id, description
 295         ).apply(block).build()
 296     }
 297
 298     fun build(): InterfaceAssignment {
 299         interfaceAssignment.id = id
 300         interfaceAssignment.operations = operations
 301         return interfaceAssignment
 302     }
 303 }
 304
 305 class OperationAssignmentBuilder<In : PropertiesAssignmentBuilder, Out : PropertiesAssignmentBuilder>(
 306     private val id: String,
 307     private val description: String? = ""
 308 ) {
 309
 310     private var operationAssignment: OperationAssignment = OperationAssignment()
 311
 312     fun implementation(implementation: Implementation?) {
 313         operationAssignment.implementation = implementation
 314     }
 315
 316     fun implementation(timeout: Int, operationHost: String? = BluePrintConstants.PROPERTY_SELF) {
 317         operationAssignment.implementation = Implementation().apply {
 318             this.operationHost = operationHost!!
 319             this.timeout = timeout
 320         }
 321     }
 322
 323     fun implementation(
 324         timeout: Int,
 325         operationHost: String? = BluePrintConstants.PROPERTY_SELF,
 326         block: ImplementationBuilder.() -> Unit
 327     ) {
 328         operationAssignment.implementation = ImplementationBuilder(timeout, operationHost!!).apply(block).build()
 329     }
 330
 331     fun inputs(inputs: MutableMap<String, JsonNode>?) {
 332         operationAssignment.inputs = inputs
 333     }
 334
 335     fun inputs(block: In.() -> Unit) {
 336         val instance: In = (block.reflect()?.parameters?.get(0)?.type?.classifier as KClass<In>).createInstance()
 337         operationAssignment.inputs = instance.apply(block).build()
 338     }
 339
 340     fun outputs(outputs: MutableMap<String, JsonNode>?) {
 341         operationAssignment.outputs = outputs
 342     }
 343
 344     fun outputs(block: Out.() -> Unit) {
 345         val instance: Out = (block.reflect()?.parameters?.get(0)?.type?.classifier as KClass<Out>).createInstance()
 346         operationAssignment.outputs = instance.apply(block).build()
 347     }
 348
 349     fun build(): OperationAssignment {
 350         operationAssignment.id = id
 351         operationAssignment.description = description
 352         return operationAssignment
 353     }
 354 }
 355
 356 class ImplementationBuilder(private val timeout: Int, private val operationHost: String) {
 357     private val implementation = Implementation()
 358
 359     fun primary(primary: String) {
 360         implementation.primary = primary
 361     }
 362
 363     fun dependencies(vararg dependencies: String) {
 364         if (implementation.dependencies == null)
 365             implementation.dependencies = arrayListOf()
 366         dependencies.forEach {
 367             implementation.dependencies!!.add(it)
 368         }
 369     }
 370
 371     fun build(): Implementation {
 372         implementation.timeout = timeout
 373         implementation.operationHost = operationHost
 374         return implementation
 375     }
 376 }
 377
 378 open class PropertiesAssignmentBuilder {
 379     var properties: MutableMap<String, JsonNode> = hashMapOf()
 380
 381     fun property(id: String, value: Any) {
 382         property(id, value.asJsonType())
 383     }
 384
 385     fun property(id: String, value: JsonNode) {
 386         properties[id] = value
 387     }
 388
 389     open fun build(): MutableMap<String, JsonNode> {
 390         return properties
 391     }
 392 }
 393
 394 open class AttributesAssignmentBuilder {
 395     var attributes: MutableMap<String, JsonNode> = hashMapOf()
 396
 397     fun attribute(id: String, value: String) {
 398         attribute(id, value.asJsonType())
 399     }
 400
 401     fun attribute(id: String, value: JsonNode) {
 402         attributes[id] = value
 403     }
 404
 405     fun build(): MutableMap<String, JsonNode> {
 406         return attributes
 407     }
 408 }