Value will be pass as input.

{
    "tags": "unit-number",
    "name": "unit-number",
    "property": {
      "description": "unit-number",
      "type": "string"
    },
    "updated-by": "adetalhouet",
    "sources": {
      "input": {
        "type": "source-input"
      }
    }
  }

Value will be defaulted.

{
  "tags": "prefix-id",
  "name": "prefix-id",
  "property" :{
    "description": "prefix-id",
    "type": "integer"
  },
  "updated-by": "adetalhouet",
  "sources": {
    "default": {
      "type": "source-default"
    }
  }
}

Value will be resolved through REST.

Modeling reference: Modeling Concepts#rest

{
    "id": 4,
    "address": "192.168.10.2/32",
    "vrf": null,
    "tenant": null,
    "status": 1,
    "role": null,
    "interface": null,
    "description": "",
    "nat_inside": null,
    "created": "2018-08-30",
    "last_updated": "2018-08-30T14:59:05.277820Z"
}

{
    "tags" : "oam-local-ipv4-address",
    "name" : "create_netbox_ip",
    "property" : {
      "description" : "netbox ip",
      "type" : "string"
    },
    "updated-by" : "adetalhouet",
    "sources" : {
      "primary-config-data" : {
        "type" : "source-rest",
        "properties" : {
          "type" : "JSON",
          "verb" : "POST",
          "endpoint-selector" : "ipam-1",
          "url-path" : "/api/ipam/prefixes/$prefixId/available-ips/",
          "path" : "/address",
          "input-key-mapping" : {
            "prefixId" : "prefix-id"
          },
          "output-key-mapping" : {
            "address" : "address"
          },
          "key-dependencies" : [ "prefix-id" ]
        }
      }
    }
  }

Value will be resolved through a database.

Modeling reference: Modeling Concepts#sql

In this example, we're making a SQL to the primary database.

Some ingredients are required to perform the query, in this case, $vfmoudleid. Hence It is provided as an input-key-mapping and defined as a key-dependencies. Please refer to the modeling guideline for more in depth understanding.

As part of this request, the expected response will be as put in value. In the output-key-mapping section, that value will be mapped to the expected resource name to resolve.

{
  "name": "vf-module-type",
  "tags": "vf-module-type",
  "property": {
    "description": "vf-module-type",
    "type": "string"
  },
  "updated-by": "adetalhouet",
  "sources": {
    "primary-db": {
      "type": "source-db",
      "properties": {
        "type": "SQL",
        "query": "select sdnctl.demo.value as value from sdnctl.demo where sdnctl.demo.id=:vfmoduleid",
        "input-key-mapping": {
          "vfmoduleid": "vf-module-number"
        },
        "output-key-mapping": {
          "vf-module-type": "value"
        },
        "key-dependencies": [
          "vf-module-number"
        ]
      }
    }
  }
}

Value will be resolved through the execution of a script.

Modeling reference: Modeling Concepts#Capability

In this example, we're making use of a Python script.

Some ingredients are required to perform the query, in this case, $vf-module-type. Hence It is provided as a key-dependencies. Please refer to the modeling guideline for more in depth understanding.

As part of this request, the expected response will set within the script itself.

{
  "tags": "interface-description",
  "name": "interface-description",
  "property": {
    "description": "interface-description",
    "type": "string"
  },
  "updated-by": "adetalhouet",
  "sources": {
    "capability": {
      "type": "source-capability",
      "properties": {
        "script-type": "jython",
        "script-class-reference": "Scripts/python/DescriptionExample.py",       
        "key-dependencies": [
          "vf-module-type"
        ]
      }
    }
  }
}

The script itself is as bellow.

The key is to have the script class derived from the framework standards.

In the case of resource resolution, the class to derive from is AbstractRAProcessor

It will give the required methods to implement: process and recover, along with some utility functions, such as set_resource_data_value or addError.

These functions either come from the AbstractRAProcessor class, or from the class it derived from.

If the resolution fail, the recover method will get called with the exception as parameter.

#  Copyright (c) 2019 Bell Canada.
#
#  Licensed under the Apache License, Version 2.0 (the "License");
#  you may not use this file except in compliance with the License.
#  You may obtain a copy of the License at
#
#      http://www.apache.org/licenses/LICENSE-2.0
#
#  Unless required by applicable law or agreed to in writing, software
#  distributed under the License is distributed on an "AS IS" BASIS,
#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
#  See the License for the specific language governing permissions and
#  limitations under the License.

from abstract_ra_processor import AbstractRAProcessor
from blueprint_constants import *
from java.lang import Exception as JavaException

class DescriptionExample(AbstractRAProcessor):

    def process(self, resource_assignment):
        try:
            # get key-dependencies value
            value = self.raRuntimeService.getStringFromResolutionStore("vf-module-type")
            
            # logic based on key-dependency outcome
            result = ""
            if value == "vfw":
                result = "This is the Virtual Firewall entity"
            elif value == "vsn":
                result = "This is the Virtual Sink entity"
            elif value == "vpg":
                result = "This is the Virtual Packet Generator"

            # set the value of resource getting currently resolved
            self.set_resource_data_value(resource_assignment, result)

        except JavaException, err:
          log.error("Java Exception in the script {}", err)
        except Exception, err:
          log.error("Python Exception in the script {}", err)
        return None

    def recover(self, runtime_exception, resource_assignment):
        print self.addError(runtime_exception.getMessage())
        return None

Value will be resolved through REST., and output will be a complex type.

Modeling reference: Modeling Concepts#rest

In this example, we're making a POST request to an IPAM system with no payload.

Some ingredients are required to perform the query, in this case, $prefixId. Hence It is provided as an input-key-mapping and defined as a key-dependencies. Please refer to the modeling guideline for more in depth understanding.

As part of this request, the expected response will be as bellow.

{
    "id": 4,
    "address": "192.168.10.2/32",
    "vrf": null,
    "tenant": null,
    "status": 1,
    "role": null,
    "interface": null,
    "description": "",
    "nat_inside": null,
    "created": "2018-08-30",
    "last_updated": "2018-08-30T14:59:05.277820Z"
}

What is of interest is the address and id fields. For the process to return these two values, we need to create a custom data-type, as bellow

{
  "version": "1.0.0",
  "description": "This is Netbox IP Data Type",
  "properties": {
    "address": {
      "required": true,
      "type": "string"
    },
    "id": {
      "required": true,
      "type": "integer"
    }
  },
  "derived_from": "tosca.datatypes.Root"
}

The type of the data dictionary will be dt-netbox-ip.

To tell the resolution framework what is of interest in the response, the output-key-mapping section is used. The process will map the output-key-mapping to the defined data-type.

{
    "tags" : "oam-local-ipv4-address",
    "name" : "create_netbox_ip",
    "property" : {
      "description" : "netbox ip",
      "type" : "dt-netbox-ip"
    },
    "updated-by" : "adetalhouet",
    "sources" : {
      "primary-config-data" : {
        "type" : "source-rest",
        "properties" : {
          "type" : "JSON",
          "verb" : "POST",
          "endpoint-selector" : "ipam-1",
          "url-path" : "/api/ipam/prefixes/$prefixId/available-ips/",
          "path" : "",
          "input-key-mapping" : {
            "prefixId" : "prefix-id"
          },
          "output-key-mapping" : {
			"address" : "address",
            "id" : "id"
          },
          "key-dependencies" : [ "prefix-id" ]
        }
      }
    }
  }

resource-assignment

This action is meant to assign resources needed to instantiate the service, e.g. to resolve all the cloud parameters.

Also, this action has the ability to perform a dry-run, meaning that result from the resolution will be made visible to the user.

• Context
• Templates
  
  • resource-accumulator-resolved-data
  • capability-data
  • Required templates
  • Mapping
• Required Inputs
• Output
• Component
• Example
• Add a new capability
• Understand overall SDNC DG flow logic

Context

This action is triggered by Generic-Resource-API (GR-API) within SDNC as part of the AssignBB orchestrated by SO.

It will be triggered for each VNF(s) and VF-Module(s) (referred as entity bellow).

See SO Building blocks Assignment.

Templates

Understand resource accumulator templates

These templates are specific to the instantiation scenario, and relies on GR-API within SDNC.

The resource accumulator template is composed of the following sections:

resource-accumulator-resolved-data

Defines all the resources that can be resolved directly from the context. It expresses a direct mapping between the name of the resource and its value.

  "resource-accumulator-resolved-data": [
    {
      "param-name": "service-instance-id",
      "param-value": "${service-instance-id}"
    },
    {
      "param-name": "vnf_id",
      "param-value": "${vnf-id}"
    }
  ]

capability-data

Defines the logic to use to create a specific resource, along with the ingredients required to invoke the capability and the output mapping. See the ingredients as function parameters, and output mapping as returned value.

The logic to resolve the resource is a DG, hence DG development is required to support a new capability.

Currently the following capabilities exist:

• Netbox: netbox-ip-assign


  Example Expand source

      {
        "capability-name": "netbox-ip-assign",
        "key-mapping": [
          {
            "payload": [
              {
                "param-name": "service-instance-id",
                "param-value": "${service-instance-id}"
              },
              {
                "param-name": "prefix-id",
                "param-value": "${private-prefix-id}"
              },
              {
                "param-name": "vf-module-id",
                "param-value": "${vf-module-id}"
              },
              {
                "param-name": "external_key",
                "param-value": "${vf-module-id}-vpg_private_ip_1"
              }
            ],
            "output-key-mapping": [
              {
                "resource-name": "vpg_private_ip_1",
                "resource-value": "${vpg_private_ip_1}"
              }
            ]
          }
        ]
      }

• Name generation: generate-name
  

  Example Expand source

      {
        "capability-name": "generate-name",
        "key-mapping": [
          {
            "payload": [
              {
                "param-name": "resource-name",
                "param-value": "vnf_name"
              },
              {
                "param-name": "resource-value",
                "param-value": "${vnf_name}"
              },
              {
                "param-name": "external-key",
                "param-value": "${vnf-id}_vnf_name"
              },
              {
                "param-name": "policy-instance-name",
                "param-value": "${vf-naming-policy}"
              },
              {
                "param-name": "nf-role",
                "param-value": "${nf-role}"
              },
              {
                "param-name": "naming-type",
                "param-value": "VNF"
              },
              {
                "param-name": "AIC_CLOUD_REGION",
                "param-value": "${aic-cloud-region}"
              }
            ],
            "output-key-mapping": [
              {
                "resource-name": "vnf_name",
                "resource-value": "${vnf_name}"
              }
            ]
          }
        ]
      }

Required templates

See Modeling Concepts#template

The name of the templates is very important, and can't be random. Bellow are the requirements

VNF

The VNF Resource Accumulator Template prefix name can be anything, but what is very important is that when integrating with SDC the sdnc_artifact_name property of the VF or PNF needs to be the same; see here.

VF-Modules

Each vf-module will have its own resource accumulator template, and its prefix name must be the vf-module-label, which is nothing but the name of the HEAT file defining the OS::Nova::Server

Example:

If the file is name vfw.yaml, the vf-module-label will be vfw

For instance, with the vFW service HEAT definition, you will see in the VSP within SDC the following screen, showing you the label of each vf-module

In this case, we will have 4 resource accumulator templates, following the template convention, hence ending with -template

• base_template-template.vtl
• vfw-template.vtl
• vsn-template.vtl
• vpg-template.vtl

Mapping

Each template requires its associated mapping file, see Modeling Concepts#ArtifactMappingResource

Example:

Taking the same vFW example, we would have 4 mapping template following the convention, hence ending with -mapping:

• base_template-mapping.vtl
• vfw-mapping.vtl
• vsn-mapping.vtl
• vpg-mapping.vtl

Required Inputs

"template-prefix" : {
   "required" : true,
   "type" : "list",
   "entry_schema" : {
      "type" : "string"
   }

Output

It is necessary to provide the resolved template as output. To do so, we will use the Modeling Concepts#getAttribute expression.

Also, as mentioned here Modeling Concepts#resourceResolution, the resource resolution component node will populate an attribute named assignment-params with the result.

Finally, the name of the ouput has to be meshed-template so SDNC GR-API knows how to properly parse the response.

Component

This action requires a node_template of type component-resource-resolution

The name of the node_template is important, as it will be used within the Workflow definition (see step.target property Modeling Concepts#workflowProperties)

Finally, you can see the component has a list of artifacts, being the template/mapping defined before.

Example:

Taking the same vFW example, we have a node_template name resource-assignment:

    "node_templates": {
      "resource-assignment" : {
        "type" : "component-resource-resolution",
        "interfaces" : {
          "ResourceResolutionComponent" : {
            "operations" : {
              "process" : {
                "inputs" : {
                  "artifact-prefix-names" : {
                    "get_input" : "template-prefix"
                  }
                }
              }
            }
          }
        },
        "artifacts": {
          "base-template": {
            "type": "artifact-template-velocity",
            "file": "Templates/base-template.vtl"
          },
          "base-mapping": {
            "type": "artifact-mapping-resource",
            "file": "Templates/base-mapping.json"
          },
          "vfw-template": {
            "type": "artifact-template-velocity",
            "file": "Templates/vfw-template.vtl"
          },
          "vfw-mapping": {
            "type": "artifact-mapping-resource",
            "file": "Templates/vfw-mapping.json"
          },
          "vfw-vnf-template": {
            "type": "artifact-template-velocity",
            "file": "Templates/vfw-vnf-template.vtl"
          },
          "vfw-vnf-mapping": {
            "type": "artifact-mapping-resource",
            "file": "Templates/vfw-vnf-mapping.json"
          },
          "vpg-template": {
            "type": "artifact-template-velocity",
            "file": "Templates/vpg-template.vtl"
          },
          "vpg-mapping": {
            "type": "artifact-mapping-resource",
            "file": "Templates/vpg-mapping.json"
          },
          "vsn-template": {
            "type": "artifact-template-velocity",
            "file": "Templates/vsn-template.vtl"
          },
          "vsn-mapping": {
            "type": "artifact-mapping-resource",
            "file": "Templates/vsn-mapping.json"
          }
        }
      }
    }
  }

Overall workflow example w/ component and artifact

{
  "metadata": {
    "template_author": "Alexis de Talhouët",
    "author-email": "adetalhouet89@gmail.com",
    "user-groups": "ADMIN, OPERATION",
    "template_name": "vFW_spinup",
    "template_version": "1.0.0",
    "template_tags": "vFW"
  },
  "topology_template": {
    "workflows": {
      "resource-assignment": {
        "steps": {
          "resource-assignment": {
            "description": "Resource Assign Workflow",
            "target": "resource-assignment"
          }
        },
        "inputs" : {
          "template-prefix" : {
            "required" : true,
            "type" : "list",
            "entry_schema" : {
              "type" : "string"
            }
          }
        },
        "outputs": {
          "meshed-template": {
            "type": "json",
            "value": {
              "get_attribute": [
                "resource-assignment",
                "assignment-params"
              ]
            }
          }
        }
      }
    },
    "node_templates": {
      "resource-assignment" : {
        "type" : "component-resource-resolution",
        "interfaces" : {
          "ResourceResolutionComponent" : {
            "operations" : {
              "process" : {
                "inputs" : {
                  "artifact-prefix-names" : {
                    "get_input" : "template-prefix"
                  }
                }
              }
            }
          }
        },
        "artifacts": {
          "base-template": {
            "type": "artifact-template-velocity",
            "file": "Templates/base-template.vtl"
          },
          "base-mapping": {
            "type": "artifact-mapping-resource",
            "file": "Templates/base-mapping.json"
          },
          "vfw-template": {
            "type": "artifact-template-velocity",
            "file": "Templates/vfw-template.vtl"
          },
          "vfw-mapping": {
            "type": "artifact-mapping-resource",
            "file": "Templates/vfw-mapping.json"
          },
          "vfw-vnf-template": {
            "type": "artifact-template-velocity",
            "file": "Templates/vfw-vnf-template.vtl"
          },
          "vfw-vnf-mapping": {
            "type": "artifact-mapping-resource",
            "file": "Templates/vfw-vnf-mapping.json"
          },
          "vpg-template": {
            "type": "artifact-template-velocity",
            "file": "Templates/vpg-template.vtl"
          },
          "vpg-mapping": {
            "type": "artifact-mapping-resource",
            "file": "Templates/vpg-mapping.json"
          },
          "vsn-template": {
            "type": "artifact-template-velocity",
            "file": "Templates/vsn-template.vtl"
          },
          "vsn-mapping": {
            "type": "artifact-mapping-resource",
            "file": "Templates/vsn-mapping.json"
          }
        }
      }
    }
  }
}

Add a new capability

When adding a capability, consider whether it should be available both at VNF and VF-Module level. This is important for its implementation.

Here is the

You need to do the following:

1. Create the DG that will handle the logic to resolve the resource

2. Load the DG within SDNC

   Example of script to automate deployment of DG Expand source

   #!/bin/sh
   
   # This script takes care of loading the DG into the runtime of SDNC.
   # The DG file name has to follow this pattern:
   # GENERIC-RESOURCE-API_{rpc_name}_{version}
   
   usage() {
     echo "./load-dg.sh <dg>"
     exit
   }
   
   if [[ -z $1 ]]
   then
       usage
   fi
   
   rpc_name=`echo "$1" | cut -d'_' -f2 | cut -d'.' -f1`
   version=`echo "$1" | cut -d'_' -f3`
   content=`cat $1`
   ip=$2
   
   data="$(curl -s -o /dev/null -w %{url_effective} --get --data-urlencode "$content" "")"
   dg_xml_escaped="${data##/?}"
   
   echo -e "module=GENERIC-RESOURCE-API&rpc=$rpc_name&flowXml=$dg_xml_escaped" > payload
   
   echo -e "    Installing $rpc_name version ${version%.*}"
   curl -X  POST \
     http://$ip:$SDNC_NODE_PORT/uploadxml \
     -H 'Authorization: Basic ZGd1c2VyOnRlc3QxMjM=' \
     -H 'Content-Type: application/x-www-form-urlencoded' \
     -d @payload
   
   rm payload
   
   echo -e "    Activating $rpc_name version ${version%.*}"
   activate_uri="activateDG?module=GENERIC-RESOURCE-API&rpc=$rpc_name&mode=sync&version=${version%.*}&displayOnlyCurrent=true"
   curl -X GET \
     -H 'Accept: application/json' \
     -H 'Authorization: Basic ZGd1c2VyOnRlc3QxMjM=' \
     -H 'Content-Type: application/json' \
     http://$ip:$SDNC_NODE_PORT/$activate_uri
   
   

3. Add the capability in the self-serve-vnf-assign DG and/or self-serve-vf-module-assign in the node named set ss.capability.execution-order[] then upload the updated version of this DG.
   When doing so, make sure to increment the last parameter ss.capability.execution-order_length

    Example

   

Understand overall SDNC DG flow logic

Logic for vnf and vf-module assignement is pretty much the same.

This is the general DG logic of the VNF assign flow and sub-flows:

1. call vnf-topology-operation
   1. call vnf-topology-operation-assign
      1. call self-serve-vnf-assign
         1. set capability.execution-order
         2. call self-serve-vnf-ra-assignment
            1. execute REST call to CDS blueprint processor
            2. put resource-accumulator-resolved-data in MDSAL GR-API/services/service/$serviceInstanceId/vnfs/vnf/$vnfId
         3. call self-serve- + capability-name
         4. put vnf information in AAI (including the selflink)
      2. call naming-policy-generate-name
      3. put generic-vnf relationship in AAI

This is the general logic of the vf-module assign flow and sub-flows:

1. call vf-module-topology-operation
   1. call vf-module-topology-operation-assign
      1. set service-data based on SO request (userParams / cloudParams)
      2. call self-serve-vf-module-assign
         1. set capability.execution-order
         2. call self-serve-vfmodule-ra-assignment
            1. execute REST call to CDS blueprint processor
               1. put resource-accumulator-resolved-data in MDSAL GR-API/services/service/$serviceInstanceId/vnfs/vnf/$vnfId/vf-modules/vf-module
         3. call self-serve- + capability-name
      3. put vf-module information in AAI
      4. put vnfc information in AAI

config-assign

This action is meant to assign all the resources and mesh the templates needed for the configuration to apply during post-instantiation (day0 config).

If user is fine with the result, he can proceed, else, (TDB) he will have opportunity to re-trigger the resolution.

Context

This action is triggered by SO after the AssignBB has been executed for Service, VNF and VF-Module. It corresponds to the ConfigAssignBB.

See SO Building blocks Assignment.

Steps

This is a single action type of workflow, hence the target will refer to a node_template of type component-resource-resolution

Inputs

Output

In order to perform dry-run, it is necessary to provide the meshed resolved template as output. To do so, the use of Modeling Concepts#getAttribute expression is required.

Also, as mentioned here Modeling Concepts#resourceResolution, the resource resolution component node will populate an attribute named assignment-params with the result.

Example

Here is an example of the config-assign workflow:

{
  "workflows": {
    "config-assign": {
      "steps": {
        "config-assign-process": {
          "description": "Config Assign Workflow",
          "target": "config-assign-process"
        }
      },
      "inputs": {
        "resolution-key": {
          "required": true,
          "type": "string"
        },
        "config-assign-properties": {
          "description": "Dynamic PropertyDefinition for workflow(config-assign).",
          "required": true,
          "type": "dt-config-assign-properties"
        }
      },
      "outputs": {
        "dry-run": {
          "type": "json",
          "value": {
            "get_attribute": [
              "SELF",
              "assignment-params"
            ]
          }
        }
      }
    }
  }
}

config-deploy

This action is meant to push the configuration templates defined during the config-assign step for the post-instantiation.

This action is triggered by SO during after the CreateBB has been executed for all the VF-Modules.

Context

This action is triggered by SO after the CreateVnfBB has been executed. It corresponds to the ConfigDeployBB.

See SO Building blocks Assignment.

Steps

This is a single action type of workflow, hence the target will refer to a node_template of type component-netconf-executor or component-jython-executor or component-restconf-executor.

Inputs

Output

SUCCESS or FAILURE

Example

Here is an example of the config-deploy workflow:

{
  "workflow": {
    "config-deploy": {
      "steps": {
        "config-deploy": {
          "description": "Config Deploy using Python (Netconf) script",
          "target": "config-deploy-process"
        }
      },
      "inputs": {
        "resolution-key": {
          "required": true,
          "type": "string"
        },
        "config-deploy-properties": {
          "description": "Dynamic PropertyDefinition for workflow(config-deploy).",
          "required": true,
          "type": "dt-config-deploy-properties"
        }
      }
    }
  }
}

resource-assignment-process

config-assign-process

config-deploy-process