path: root/vnfapi/model/src/main/yang/VNF-API.yang

module VNF-API {

    yang-version 1;

    namespace "org:openecomp:sdnctl:vnf";

    prefix vnfapi;

    import ietf-inet-types { prefix "ietf"; revision-date "2010-09-24"; }

    include "vnfsubmodule";

    organization "OpenECOMP";

    contact
	"Network Controller <sdnc@lists.openecomp.org>";

    description
        "Defines API interface for VNF Orchestration";

    revision "2015-07-20" {
        description
            "Initial draft";
    }
    // Last updated on 8-17-2016
    grouping sdnc-request-header { 
        container sdnc-request-header { 
            leaf svc-request-id { 
                type string; 
            } 
            leaf svc-action { 
                type enumeration { 
                    enum "reserve";
                    enum "assign";
                    enum "activate";  // equal to commit
                    enum "delete";    // equal to commit
                    enum "changeassign";
                    enum "changedelete";
                    enum "rollback";
                } 
            } 
            leaf svc-notification-url { 
                type string; 
            } 
        } 
    } 

    grouping request-information { 
        container request-information { 
            leaf request-id { 
                type string; 
            } 
            leaf request-action { 
                type enumeration { 
                    enum "PreloadNetworkRequest";
                    enum "DeletePreloadNetworkRequest";
                    enum "NetworkActivateRequest";
                    enum "DisconnectNetworkRequest";
                    enum "PreloadVNFRequest";
                    enum "DeletePreloadVNFRequest";
                    enum "VNFActivateRequest";
                    enum "ChangeVNFActivateRequest";
                    enum "DisconnectVNFRequest";
                    enum "PreloadVnfInstanceRequest";
                    enum "DeletePreloadVnfInstanceRequest";
                    enum "VnfInstanceActivateRequest";
                    enum "ChangeVnfInstanceActivateRequest";
                    enum "DisconnectVnfInstanceRequest";
                    enum "PreloadVfModuleRequest";
                    enum "DeletePreloadVfModuleRequest";
                    enum "VfModuleActivateRequest";
                    enum "ChangeVfModuleActivateRequest";
                    enum "DisconnectVfModuleRequest";
                } 
            } 
            leaf request-sub-action { 
                type enumeration { 
                    enum "SUPP";
                    enum "CANCEL";
                } 
            } 
            leaf source { 
                type string; 
            } 
            leaf notification-url { 
                type string; 
            } 
            leaf order-number { 
                type string; 
            } 
            leaf order-version { 
                type string; 
            } 
        } 
    } 

    grouping service-information { 
        container service-information { 
            // 1610 use for AnAI subscription-service-type
            leaf service-type { 
                type string;
                description "AnAI subscription-service-type";
            } 
            leaf service-id { 
                type string;
            } 
            leaf service-instance-id { 
                type string; 
                description "A service instance that a VNF or a l3-network is associated with";
            } 
            // 1610 use for global-customer-id
            leaf subscriber-name { 
                type string; 
                description "AnAI global-customer-id";
            } 
        } 
    } 


    grouping vnf-request-information { 
        container vnf-request-information { 
            leaf vnf-request-version {
                type string; 
            }
            leaf vnf-id {
                type string; 
                description "vf-module-id";
            }
            leaf vnf-type { 
                type string; 
                description "vf-module-type";
            } 
            leaf vnf-name { 
                type string; 
                description "vf-module-name";
            } 
            leaf generic-vnf-id {
                type string; 
                description "generic vnf-id";
            }
            leaf generic-vnf-type { 
                type string; 
                description "generic vnf type";
            } 
            leaf generic-vnf-name { 
                type string; 
                description "generic vnf name";
            } 
            leaf tenant { 
                type string; 
            } 
            leaf aic-clli { 
                type string; 
            } 
            leaf aic-cloud-region { 
                type string; 
                description "The AIC cloud region which maps to contrail versions";
            } 
            list vnf-networks {
                key network-role;
                uses vnf-network;
                description "Network List";
            }
        }
    } 

    grouping network-request-information { 
        container network-request-information { 
            leaf network-id {
                type string; 
            }
            leaf network-type { 
                type string; 
            } 
            leaf network-name { 
                type string; 
            } 
            leaf tenant { 
                type string; 
            } 
            leaf aic-clli { 
                type string; 
            } 
            leaf aic-cloud-region { 
                type string; 
                description "The AIC cloud region which maps to contrail versions";
            } 
        }
    } 

    /***********************************************************/
    /*               PRELOAD DATA                                 */
    /***********************************************************/

    container preload-vnfs {
        uses preload-model-information; 
    } 
    grouping preload-model-information { 
        list vnf-preload-list { 
            key "vnf-name vnf-type"; 
            leaf vnf-name { 
                type string; 
                description "vf-module-name";
            } 
            leaf vnf-type { 
                type string; 
                description "vf-module-type";
            } 
            uses preload-data; 
        } 
    } 

    // For preload networks it will have network-topology-information
    // For preload vnfs, it will have vnf-topology-information
    grouping preload-data { 
        container preload-data { 
            uses vnf-topology-information; 
            uses network-topology-information; 
            uses oper-status; 
        }
    } 


    grouping vnf-topology-information { 
        container vnf-topology-information { 
            uses vnf-topology-identifier;
            uses vnf-assignments; 
            uses vnf-parameters; 
        }
    } 

    grouping vnf-topology-identifier { 
        container vnf-topology-identifier { 
            leaf service-type { 
                type string;
            } 
            leaf service-id { 
                type string;
            } 
            leaf vnf-name { 
                type string; 
                description "vf-module-name";
            } 
            leaf vnf-type { 
                type string; 
                description "vf-module-type";
            } 
            leaf generic-vnf-name { 
                type string; 
            } 
            leaf generic-vnf-type { 
                type string; 
            } 
            leaf generic-vnf-id { 
                type string; 
            } 
        } 
    } 

    grouping vnf-assignments {
        container vnf-assignments { 
            leaf vnf-status {
                type string;
                description "Orchestration Status from AAI - to be set by SDNC";
            }
            list availability-zones {
                ordered-by  user;
                leaf availability-zone {
                    type string;
                    description "Openstack availability zone name or UUID";
                }
            }
            list vnf-networks {
                key network-role;
                uses vnf-network;
                // 1610
                uses sriov-vlan-filter-list;
                description "Network List";
            }
            uses vm-topology;
        }
    } 

    grouping vm-topology {
        list vnf-vms {
            key vm-type;
            leaf vm-type { 
                type string; 
            } 
            leaf vm-count { 
                type uint8; 
            } 
            list vm-names {
                ordered-by user;
                leaf vm-name{ 
                    type string; 
                } 
            }
            //leaf-list vm-names {
            //    type string; 
            //    ordered-by user;
            //}
            list vm-networks {
                key network-role;
                uses vm-network;
                description "Network List";
            }
        }
    }

    grouping vnf-network {
        leaf network-role { 
            type string; 
            description "A Network Role to which a VNF must connect";
        } 
        leaf network-name { 
            type string; 
            description "Unique Neutron UUID of an instance of the network role ";
        } 
        leaf neutron-id { 
            type string; 
            description "Unique Neutron UUID of an instance of the network role ";
        } 
        leaf network-id { 
            type string; 
            description "Unique Neutron UUID of an instance of the network role ";
        } 
        leaf subnet-id { 
            type string; 
            description "ipv4 subnet UUID to be passed into the HEAT template for DHCP assignment";
        }
        leaf contrail-network-fqdn {
            type string;
            description "contrail network policy object";
        }
        // 1610
        leaf ipv6-subnet-id { 
            type string; 
            description "ipv6 subnet UUID to be passed into the HEAT template for DHCP assignment";
        }
        leaf ipv6-subnet-name { 
            type string; 
            description "ipv6 subnet-name that corresponds to the ipv6 subnet-id";
        }
        leaf subnet-name { 
            type string; 
            description "ipv4 subnet-name that corresponds to the ipv4 subnet-id";
        }
    }

    // 1610
    grouping sriov-vlan-filter-list {
        list sriov-vlan-filter-list {
            leaf sriov-vlan-filter {
                type string;
            }
        }
    }

    grouping vm-network {
        leaf network-role {
            type string;
            description "network (identified by role) that this VM connects to.  Should also be included in the vnf-networks for the containing VNF";
    
        }
        leaf use-dhcp {
            type enumeration { 
                  enum "Y";
                  enum "N";
            } 
            description "Indicator to use DHCP on this network for this VM";
        }
        leaf ip-count {
            type uint8;
            description "The number of ip addresses to be assigned per vm for this network role";
        }
        list network-ips {
            ordered-by user;
            leaf ip-address {
                //type string;
                type ietf:ip-address;
                description "List of assigned ipv4 addresses on a network";
            }
        }
        list network-ips-v6 {
            ordered-by user;
            leaf ip-address-ipv6 {
                //type string;
                type ietf:ipv6-address;
                description "List of assigned ipv6 addresses on a network";
            }
        }
        list network-macs {
            ordered-by user;
            leaf mac-address {
                type string;
                description "List of network assignments for this VM (one per network)";
            }
        }
        leaf floating-ip {
            //type string;
            type ietf:ip-address;
            description "Floating ipv4 for VMs of a given type on this network";
        }
        leaf floating-ip-v6 {
            //type string;
            type ietf:ipv6-address;
            description "Floating ipv6 for VMs of a given type on this network";
        }
        list interface-route-prefixes {
            ordered-by user;
            leaf interface-route-prefix {
                type ietf:ip-address;
                description "OBSOLETE, route prefixes (CIDRs) to be provided to MSO in vnf-topology as a list of static routes";
            }
            leaf interface-route-prefix-cidr {
                type string;
                description "route prefixes (CIDRs) in ip/cidr format to be provided to MSO in vnf-topology as a list of static routes";
            }
        }
    }

    grouping vnf-parameters {
        list vnf-parameters {
            key vnf-parameter-name;
            leaf vnf-parameter-name { 
                type string; 
                description "The name of an arbitrary instance-specific vnf-parameters";
            } 
            leaf vnf-parameter-value { 
                type string; 
                description "The value of an arbitrary instance-specific vnf-parameters ";
            } 
        }
    }

    grouping network-topology-information { 
        container network-topology-information { 
            uses network-topology-identifier;
            uses subnets; 
            uses vpn-bindings; 
            uses network-policy;
            uses route-table-reference;
            uses provider-network-information;
        }
    } 

    grouping network-topology-identifier { 
        container network-topology-identifier { 
            leaf service-type { 
                type string;
            } 
            leaf network-name { 
                type string; 
            } 
            leaf network-role { 
                type string; 
            } 
            leaf network-type { 
                type string; 
            } 
            leaf network-technology{ 
                type string; 
            } 
        } 
    } 
    grouping subnets {
        list subnets {
            key start-address;
            leaf start-address{
                type ietf:ip-address;
                //type string;
            }
            leaf gateway-address{
                //type string;
                type ietf:ip-address;
            }
            leaf cidr-mask{
                type string;
            }
            leaf ip-version {
                type string;
            }
            leaf dhcp-enabled {
                type enumeration {
                    enum "Y";
                    enum "N";
                }
            }
            leaf dhcp-start-address {
                type string;
            }
            leaf dhcp-end-address {
                type string;
            }
            // 1610
            leaf subnet-name {
                type string;
            }
            
        }
    } 

    grouping vpn-bindings {
        list vpn-bindings {
            key vpn-binding-id;
            leaf vpn-binding-id {
                type string;
            }
            leaf global-route-target {
                type string;
            }
        }
    } 

    grouping network-policy {
        list network-policy {
            key network-policy-fqdn;
            leaf network-policy-fqdn {
                type string;
            }
            leaf network-policy-id {
                type string;
            }
        }
    } 

    //1610
    grouping route-table-reference {
        list route-table-reference {
            leaf route-table-reference-id {
                type string;
            }
            leaf route-table-reference-fqdn {
                type string;
            }
        }
    }

    // 1610
    grouping provider-network-information {
        container provider-network-information {
	        leaf physical-network-name {
	            type string;
	        }
	        leaf is-provider-network {
	            type boolean;
	        }
	        leaf is-shared-network {
	            type boolean;
	        }
	        leaf is-external-network {
                type boolean;
            }
        }
    }

    /***********************************************************/
    /*               SERVICE_DATA                                */
    /***********************************************************/
    container vnfs {
        uses vnf-model-infrastructure; 
    } 
    grouping vnf-model-infrastructure { 
        list vnf-list { 
            key vnf-id; 
            leaf vnf-id { 
                type string; 
                mandatory true; 
                description "vf-module-id";
            } 
            uses service-data; 
            uses service-status; 
        } 
    } 
    grouping service-data { 
        container service-data { 
            uses vnf-configuration-information; 
            uses oper-status; 
        } 
    } 
    grouping service-status { 
        container service-status { 
            leaf response-code { 
                type string; 
            } 
            leaf response-message { 
                type string; 
            } 
            leaf final-indicator { 
                type string; 
            } 
            leaf request-status { 
                type enumeration { 
                    enum "synccomplete";
                    enum "asynccomplete";
                    enum "notifycomplete";
                } 
            } 
            leaf vnfsdn-action { 
                type enumeration { 
                    enum "PreloadNetworkRequest";
                    enum "DeletePreloadNetworkRequest";
                    enum "NetworkActivateRequest";
                    enum "DisconnectNetworkRequest";
                    enum "PreloadVNFRequest";
                    enum "DeletePreloadVNFRequest";
                    enum "VNFActivateRequest";
                    enum "ChangeVNFActivateRequest";
                    enum "DisconnectVNFRequest";
                    enum "PreloadVnfInstanceRequest";
                    enum "DeletePreloadVnfInstanceRequest";
                    enum "VnfInstanceActivateRequest";
                    enum "ChangeVnfInstanceActivateRequest";
                    enum "DisconnectVnfInstanceRequest";
                    enum "PreloadVfModuleRequest";
                    enum "DeletePreloadVfModuleRequest";
                    enum "VfModuleActivateRequest";
                    enum "ChangeVfModuleActivateRequest";
                    enum "DisconnectVfModuleRequest";
                } 
            } 
            leaf vnfsdn-subaction { 
                type enumeration { 
                    enum "SUPP";
                    enum "CANCEL";
                } 
            }
            leaf rpc-name { 
                type enumeration { 
                    enum "vnf-topology-operation";
                    enum "preload-vnf-topology-operation";
                    enum "vnf-instance-topology-operation";
                    enum "preload-vnf-instance-topology-operation";
                    enum "vf-module-topology-operation";
                    enum "preload-vf-module-topology-operation";
                } 
            } 
            leaf rpc-action { 
                type enumeration { 
                    enum "reserve";
                    enum "assign";
                    enum "activate";  // equal to commit
                    enum "delete";      // equal to commit
                    enum "changeassign";
                    enum "changedelete";
                    enum "rollback";
                } 
            } 
            leaf response-timestamp { 
                type string; 
            } 
        } 
    } 
    grouping vnf-configuration-information { 
        uses sdnc-request-header; 
        uses request-information; 
        uses service-information;
        uses vnf-request-information;
        uses vnf-topology; 
    } 
    grouping vnf-topology-response-body { 
        leaf svc-request-id { 
            type string; 
        } 
        leaf response-code { 
            type string; 
        } 
        leaf response-message { 
            type string; 
        } 
        leaf ack-final-indicator { 
            type string; 
        } 
    } 

    grouping vnf-information { 
        container vnf-information { 
            leaf vnf-service-type { 
                type string;
            } 
            leaf vnf-id { 
                type string; 
                description "vf-module-id";
            } 
        } 
    } 

    grouping network-information { 
        container network-information { 
            leaf network-service-type { 
                type string;
            } 
            leaf network-id { 
                type string; 
            } 
        } 
    } 


    // Carried over from l3sdn and potentially not needed
    grouping oper-status { 
        container oper-status { 
            leaf order-status { 
                type enumeration { 
                    enum "Active";
                    enum "PendingAssignment";
                    enum "PendingCreate";
                    enum "PendingUpdate";
                    enum "PendingDelete";
                    enum "Deleted";
                    
                } 
            }
            leaf last-action { 
                type enumeration { 
                    enum "VNFActivateRequest";
                    enum "ChangeVNFActivateRequest";
                    enum "VnfInstanceActivateRequest";
                    enum "ChangeVnfInstanceActivateRequest";
                    enum "VfModuleActivateRequest";
                    enum "ChangeVfModuleActivateRequest";
                    enum "DisconnectVNFRequest";
                    enum "DisconnectVnfInstanceRequest";
                    enum "DisconnectVfModuleRequest";
                    enum "PreloadVNFRequest";
                    enum "DeletePreloadVNFRequest";
                    enum "PreloadVnfInstanceRequest";
                    enum "DeletePreloadVnfInstanceRequest";
                    enum "PreloadVfModuleRequest";
                    enum "DeletePreloadVfModuleRequest";
                } 
            } 
            leaf last-svc-request-id { 
                type string; 
            } 
            leaf last-order-status { 
                type enumeration { 
                    enum "Active";
                    enum "PendingAssignment";
                    enum "PendingCreate";
                    enum "PendingUpdate";
                    enum "PendingDelete";
                    enum "Deleted";
                } 
            } 
            leaf create-timestamp { 
                type string; 
            } 
            leaf modify-timestamp { 
                type string; 
            } 
            leaf maintenance-indicator { 
                type enumeration { 
                    enum "Y";
                    enum "N";
                } 
            } 
        } 
    } 
    grouping vnf-topology { 
        leaf vnf-id {
            type string; 
            description "vf-module-id";
        }
        uses vnf-topology-information; 
    } 
    
    
    rpc vnf-topology-operation {
        input { 
            uses sdnc-request-header; 
            uses request-information; 
            uses service-information;
            uses vnf-request-information; 
        } 
        output { 
            uses vnf-topology-response-body; 
            uses vnf-information;
            uses service-information;
        } 
    } 

    rpc network-topology-operation {
        input { 
            uses sdnc-request-header; 
            uses request-information; 
            uses service-information;
            uses network-request-information; 
        } 
        output { 
            uses vnf-topology-response-body; 
            uses network-information;
            uses service-information;
        } 
    } 

    rpc preload-vnf-topology-operation {
        input { 
            uses sdnc-request-header; 
            uses request-information; 
            uses vnf-topology-information;
        } 
        output { 
            uses vnf-topology-response-body; 
        } 
    }

    rpc preload-network-topology-operation {
        input { 
            uses sdnc-request-header; 
            uses request-information; 
            uses network-topology-information;
        } 
        output { 
            uses vnf-topology-response-body; 
        } 
    }
}