Proposal to remove deprecated shim-layer implementation

Change-Id: I8ef21e0c349c0b3b62f3598bab4d90edfa801e7b
Signed-off-by: Bertrand Souville <souville@docomolab-euro.com>

7 files changed, 0 insertions, 1435 deletions

diff --git a/deprecated/source/schema/access-control-models.yang b/deprecated/source/schema/access-control-models.yang
deleted file mode 100644
index 7b4684c..0000000
--- a/deprecated/source/schema/access-control-models.yang
+++ /dev/null
@@ -1,92 +0,0 @@
-module access-control-models {
-  prefix acm;
-  namespace "urn:opnfv:promise:acm";
-
-  import complex-types { prefix ct; }
-  import ietf-yang-types { prefix yang; }
-  import ietf-inet-types { prefix inet; }
-
-  typedef password {
-    type string {
-      length 1..255;
-    }
-  }
-
-  grouping access-credentials {
-    leaf strategy {
-      type enumeration {
-        enum oauth;
-        enum keystone;
-      }
-      default oauth;
-    }
-    leaf endpoint {
-      type inet:uri;
-      description "The target endpoint for authentication";
-      mandatory true;
-    }
-    leaf username {
-      type string;
-      mandatory true;
-    }
-    leaf password {
-      type acm:password;
-      mandatory true;
-    }
-  }
-  
-  /*********************************************
-   * Identity Models
-   *********************************************/
-
-  ct:complex-type Identity {
-    ct:abstract true;
-    description "Identity represents an administrative access model entity";
-
-    key "id";
-    leaf id { type yang:uuid; mandatory true; }
-    leaf name { type string; mandatory true; }
-    leaf description { type string; }
-    leaf enabled { type boolean; default true; }
-  }
-
-  ct:complex-type User {
-    ct:extends Identity;
-
-    leaf credential {
-      //type instance-identifier { ct:instance-type IdentityCredential; }
-      type string;
-      mandatory true;
-    }
-    
-    container contact {
-      leaf fullName { type string; }
-      leaf email { type string; }
-    }
-
-    leaf-list groups { type instance-identifer { ct:instance-type Group; } }
-    leaf domain { type instance-identifier { ct:instance-type Domain; } }
-  }
-
-  ct:complex-type Group {
-    ct:extends Identity;
-    
-    leaf-list users { type instance-identifier { ct:instance-type User; } }
-    leaf domain { type instance-identifier { ct:instance-type Domain; } }
-  }
-
-  ct:complex-type Domain {
-    ct:extends Identity;
-    description
-      "Domain represent a distinct administrative domain across
-       collection of users and groups.";
-
-    ct:instance-list users { ct:instance-type User; }
-    ct:instance-list groups { ct:instance-type Group; }
-  }
-
-  rpc create-user;
-  rpc remove-user;
-  rpc create-group;
-  rpc remove-group;
-}
diff --git a/deprecated/source/schema/nfv-infrastructure.yang b/deprecated/source/schema/nfv-infrastructure.yang
deleted file mode 100644
index ccad269..0000000
--- a/deprecated/source/schema/nfv-infrastructure.yang
+++ /dev/null
@@ -1,322 +0,0 @@
-module nfv-infrastructure {
-  namespace "urn:opnfv:promise:nfv:infrastructure";
-  prefix nfvi;
-
-  import access-control-models { prefix acm; }
-  import ietf-inet-types { prefix inet; }
-  import ietf-yang-types { prefix yang; }
-  import complex-types { prefix ct; }
-
-  description
-    "NFV Infrastructure Data Models with complex types and typed instance
-     identifiers representing the various ResourceElements available
-     in the infrastructure across compute, network, and storage.";
-
-  revision 2015-10-13 {
-    description
-      "Introduce capacity and element collection into NFVI models";
-  }
-  
-  revision 2015-08-07 {
-    description
-      "This YANG module is modeled using 'yangforge' which natively provides
-       complex types and typed instance identifiers.  This module
-       provides various collections of resource management data models
-       for instance based management";
-  }
-
-  identity manager {
-    description "used by specific modules implementing manager role for NFVI";
-  }
-  
-  grouping compute-capacity {
-    leaf cores     { type int16; default 0; }
-    leaf ram       { type int32; default 0; units 'MB'; }
-    leaf instances { type int16; default 0; }
-  }
-
-  grouping network-capacity {
-    leaf networks  { type int16; default 0; }
-    leaf ports     { type int16; default 0; }
-    leaf routers   { type int16; default 0; }
-    leaf subnets   { type int16; default 0; }
-    leaf addresses { type int32; default 0; }
-  }
-
-  grouping storage-capacity {
-    leaf gigabytes { type int32; default 0; units 'GB'; }
-    leaf snapshots { type int16; default 0; }
-    leaf volumes   { type int16; default 0; }
-  }
-
-  grouping resource-capacity {
-    uses compute-capacity;
-    uses network-capacity;
-    uses storage-capacity;
-  }
-  
-  grouping resource-collection {
-    description
-      "Information model capturing parameters for describing a collection of
-       resource capacity and resource elements";
-    
-    container capacity { uses resource-capacity; }
-    leaf-list elements {
-      type instance-identifier {
-        ct:instance-type nfvi:ResourceElement;
-        require-instance true;
-      }
-    }
-  }
-
-  grouping resource-stack {
-    description
-      "Information model describing a NFVI resource stack comprising of
-       various resource elements across compute, network, and storage";
-    
-    ct:instance-list hosts { ct:instance-type nfvi:PhysicalHost; }
-    ct:instance-list hypervisors { ct:instance-type nfvi:Hypervisor; }
-
-    container compute {
-      description "Contains compute related resources";
-
-      ct:instance-list servers { ct:instance-type nfvi:ServerInstance; }
-      ct:instance-list images { ct:instance-type nfvi:VirtualMachineImage; }
-      ct:instance-list flavors { ct:instance-type nfvi:ComputeFlavor; }
-    }
-
-    container network {
-      description "Contains networking related resources";
-        
-      ct:instance-list networks { ct:instance-type nfvi:Network; }
-      ct:instance-list subnets { ct:instance-type nfvi:SubNetwork; }
-      ct:instance-list ports { ct:instance-type nfvi:SwitchPort; }
-      //ct:instance-list routers { ct:instance-type Router; }
-    }
-  }
-  
-  /*********************************************
-   * Abstract Models (top-level)
-   *********************************************/
-
-  ct:complex-type ResourceElement {
-    ct:abstract true;
-
-    key "id";
-    leaf id { type yang:uuid; mandatory true; }
-    leaf name { type string; }
-    leaf enabled { type boolean; default true; }
-    leaf protected { type boolean; default false; }
-    leaf owner { type instance-identifier { ct:instance-type acm:Identity; } }
-    leaf visibility {
-      description "Specify visibility level available from the perspective of 'owner'";
-      type enumeration {
-        enum public;
-        enum domain;
-        enum project;
-        enum group;
-        enum user;
-      }
-      default user;
-    }
-    leaf-list tags { type string; }
-    
-    leaf-list members {
-      description "Optionally share with explicit list of members of AccessIdentity complex-type";
-      type instance-identifier {
-        ct:instance-type acm:Identity;
-      }
-    }
-  }
-
-  ct:complex-type ResourceInstance {
-    ct:extends ResourceElement;
-    ct:abstract true;
-
-    leaf status {
-      type enumeration {
-        enum active;
-        enum inactive;
-        enum pending;
-      }
-    }
-    leaf progress {
-      type uint8 { range 0..100; }
-      default 0;
-    }
-  }
-
-  ct:complex-type ResourceContainer {
-    ct:extends ResourceInstance;
-    ct:abstract true;
-
-    description
-      "An abstract resource instance which contains a collection of capacity
-       and elements.";
-
-    uses resource-collection;
-  }
-
-  /*********************************************
-   * Compute Models
-   *********************************************/
-
-  ct:complex-type AvailabilityZone {
-    ct:extends ResourceElement;
-  }
-  
-  ct:complex-type PhysicalHost {
-    ct:extends ResourceElement;
-
-    leaf type { type string; }
-    leaf version { type string; }
-
-    leaf cpu { type uint8; }
-    leaf workload { type uint8; default 0; }
-    leaf uptime { type string; }
-
-    container ram {
-      leaf total { type uint32; units 'MB'; }
-      leaf used { type uint32; units 'MB'; }
-      leaf free { type uint32; units 'MB'; }
-    }
-    container disk {
-      leaf total { type uint32; units 'GB'; }
-      leaf used { type uint32; units 'GB'; }
-      leaf free { type uint32; units 'GB'; }
-    }
-
-    leaf-list hypervisors { type instance-identifier { ct:instance-type Hypervisor; } }
-  }
-  
-  ct:complex-type Hypervisor {
-    ct:extends PhysicalHost;
-
-    leaf host {
-      type instance-identifier { ct:instance-type PhysicalHost; }
-      mandatory true;
-    }
-    container vcpu {
-      leaf total { type uint16; }
-      leaf used { type uint16; }
-      leaf free { type uint16; }
-    }
-    leaf-list servers { type instance-identifier { ct:instance-type ServerInstance; } }
-  }
-
-  ct:complex-type ComputeElement {
-    ct:extends ResourceElement;
-    ct:abstract true;
-
-    container constraint {
-      leaf disk { type uint32; units 'GB'; default 0; }
-      leaf ram { type uint32; units 'MB'; default 0; }
-      leaf vcpu { type uint16; default 0; }
-    }
-
-    leaf-list instances {
-      description "State info about instances currently using this resource element";
-      type instance-identifier {
-        ct:instance-type ResourceInstance;
-      }
-      config false;
-    }
-  }
-
-  ct:complex-type VirtualMachineImage {
-    ct:extends ComputeElement;
-
-    container data {
-      leaf checksum { type string; mandatory true; }
-      leaf size { type uint32; units 'Bytes'; mandatory true; }
-      
-      container format {
-        leaf container {
-          type enumeration { enum ami; enum ari; enum aki; enum bare; enum ovf; }
-          default bare;
-        }
-        leaf disk {
-          type enumeration { enum ami; enum ari; enum aki; enum vhd; enum vmdk; enum raw; enum qcow2; enum vdi; enum iso; }
-        }
-      }
-      leaf content {
-        description "should be a 'private' property so only direct access retrieves content";
-        type binary;
-      }
-    }
-  }
-
-  ct:complex-type ComputeFlavor {
-    ct:extends ResourceElement;
-
-    leaf disk  { type uint32; units 'GB'; default 0; }
-    leaf ram   { type uint32; units 'MB'; default 0; }
-    leaf vcpus { type uint16; default 0; }
-  }
-
-  ct:complex-type ServerInstance {
-    ct:extends ResourceInstance;
-
-    leaf flavor {
-      type instance-identifier { ct:instance-type ComputeFlavor; }
-      mandatory true;
-    }
-    leaf image {
-      type instance-identifier { ct:instance-type VirtualMachineImage; }
-      mandatory true;
-    }
-    
-    //ct:instance metadata { ct:instance-type MetaData; }
-
-    leaf host {
-      type instance-identifier { ct:instance-type PhysicalHost; }
-    }
-
-    leaf-list connections {
-      description
-        "References to collection of NetworkingElement class objects such as
-         Network, Subnet, Port, Router that this ServerInstance is
-         connected with.";
-      type instance-identifier { ct:instance-type NetworkElement; }
-    }
-  }
-
-  /*********************************************
-   * Network Models (Work-in-Progress)
-   *********************************************/
-
-  ct:complex-type NetworkElement {
-    ct:extends ResourceElement;
-    ct:abstract true;
-  }
-
-  ct:complex-type Network {
-    ct:extends NetworkElement;
-
-    leaf-list subnets {
-      type instance-identifier { ct:instance-type SubNetwork; }
-    }
-  }
-
-  ct:complex-type SubNetwork {
-    ct:extends NetworkElement;
-
-    leaf network { type instance-identifier { ct:instance-type Network; } }
-
-    leaf-list nameservers { type string; }
-    
-    container dhcp {
-      leaf enabled { type boolean; }
-      list pools {
-        leaf start { type inet:ip-address; }
-        leaf end   { type inet:ip-address; }
-      }
-    }
-  }
-
-  ct:complex-type SwitchPort {
-    ct:extends NetworkElement;
-
-    leaf subnet { type instance-identifier { ct:instance-type SubNetwork; } }
-  }
-}
diff --git a/deprecated/source/schema/nfv-mano.yang b/deprecated/source/schema/nfv-mano.yang
deleted file mode 100644
index 0e3bbbe..0000000
--- a/deprecated/source/schema/nfv-mano.yang
+++ /dev/null
@@ -1,149 +0,0 @@
-module nfv-mano {
-  namespace "urn:opnfv:promise:nfv:mano";
-  prefix mano;
-
-  import access-control-models { prefix acm; }
-  import nfv-infrastructure { prefix nfvi; }
-  import complex-types { prefix ct; }
-  import ietf-inet-types { prefix inet; }
-  import iana-crypt-hash { prefix ianach; }
-
-  description
-    "NFV Management and Orchestration Data Models with complex types and typed
-     instance identifiers representing the NFVO, VNFM, and the VIM.";
-  
-  revision 2015-09-03 {
-    description
-      "This YANG module is modeled using 'yangforge' which natively provides
-       complex types and typed instance identifiers.  This module
-       provides various collections of infrastructure management data
-       models for instance based management";
-  }
-
-  grouping provider-credentials {
-    leaf endpoint {
-      type inet:uri;
-      description "The target URL endpoint for the resource provider";
-      mandatory true;
-    }
-    leaf username {
-      type string;
-      mandatory true;
-    }
-    leaf password {
-      type acm:password;
-      mandatory true;
-    }
-    leaf region {
-      type string;
-      description "Optional specified region for the provider";
-    }
-  }
-
-  ct:complex-type ServiceOrchestrator {
-    ct:extends acm:Domain;
-    ct:abstract true;
-    // TBD
-  }
-
-  ct:complex-type ResourceOrchestrator {
-    ct:extends acm:Domain;
-    ct:abstract true;
-    // TBD
-  }
-
-  ct:complex-type VirtualNetworkFunctionManager {
-    ct:extends acm:Domain;
-    ct:abstract true;
-    // TBD
-  }
-  
-  ct:complex-type VirtualInfrastructureManager {
-    ct:extends acm:Domain;
-    ct:abstract true;
-    
-    leaf name { type string; mandatory true; }
-
-    container auth {
-      description 'Conceptual container that will be extended by explicit provider';
-      // ct:instance-list credentials { ct:instance-type AccessCredential; }
-      // ct:instance-list roles { ct:instance-type AccessRole; }
-      // ct:instance-list policies { ct:instance-type AccessPolicy; }
-    }
-
-    ct:instance-list hosts { ct:instance-type nfvi:PhysicalHost; }
-    ct:instance-list hypervisors { ct:instance-type nfvi:Hypervisor; }
-
-    container compute {
-      if-feature has-compute;
-      description "Contains compute related resources";
-
-      ct:instance-list servers { ct:instance-type nfvi:ServerInstance; }
-      ct:instance-list images { ct:instance-type nfvi:VirtualMachineImage; }
-      ct:instance-list flavors { ct:instance-type nfvi:ComputeFlavor; }
-    }
-
-    container network {
-      if-feature has-networking;
-      description "Contains networking related resources";
-        
-      ct:instance-list networks { ct:instance-type nfvi:Network; }
-      ct:instance-list subnets { ct:instance-type nfvi:SubNetwork; }
-      ct:instance-list ports { ct:instance-type nfvi:SwitchPort; }
-      //ct:instance-list routers { ct:instance-type Router; }
-    }
-  }
-
-  container stack {
-    container nfvo {
-      ct:instance service  { ct:instance-type ServiceOrchestrator; }
-      ct:instance resource { ct:instance-type ResourceOrchestrator; }
-    }
-    container vnfm {
-      ct:instance-list managers { ct:instance-type VirtualNetworkFunctionManager; }
-    }
-    container vim {
-      ct:instance-list managers { ct:instance-type VirtualInfrastructureManager; }
-    }
-  }
-
-  rpc add-vim {
-    description "This operation allows you to add a new VirtualInfrastructureManager into the NFVI stack";
-    input {
-      uses provider-credentials;
-      
-      leaf provider {
-        description "Select a specific resource provider";
-        mandatory true;
-        type enumeration {
-          enum openstack;
-          enum hp;
-          enum rackspace;
-          enum amazon {
-            status planned;
-          }
-          enum joyent {
-            status planned;
-          }
-          enum azure {
-            status planned;
-          }
-        }
-      }
-    }
-    output {
-      leaf id {
-        description "Unique identifier for the newly added provider found in /promise/providers";
-        type instance-identifier {
-          ct:instance-type VirtualInfrastructureManager;
-        }
-      }
-      leaf result {
-        type enumeration {
-          enum success;
-          enum error;
-        }
-      }
-    }
-  }
-}
diff --git a/deprecated/source/schema/openstack-compute.yang b/deprecated/source/schema/openstack-compute.yang
deleted file mode 100644
index c3e790c..0000000
--- a/deprecated/source/schema/openstack-compute.yang
+++ /dev/null
@@ -1,72 +0,0 @@
-module openstack-compute {
-  prefix os-com;
-
-  import nfv-infrastructure { prefix nfvi; }
-  import complex-types { prefix ct; }
-
-  identity nova { base nvfi:compute; }
-  
-  feature availability-zone {
-    description "Specifies whether availability zone functionality is available.";
-  }
-  feature extended-status {
-    description "Specifies whether extended status functionality is available.";
-  }
-  feature security-groups {
-    description "Specifies whether security groups functionality is available.";
-  }
-
-  ct:complex-type ServerInstance {
-    ct:extends nfvi:ServerInstance;
-
-    leaf zone {
-      if-feature availability-zone;
-      type string;
-    }
-
-    leaf project {
-      type instance-identifier { ct:instance-type nfvi:ResourceProject; }
-      mandatory true;
-    }
-
-    container extended-status {
-      if-feature extended-status;
-      leaf locked-by;
-      leaf power;
-      leaf task;
-      leaf vm;
-    }
-
-    leaf-list security-groups {
-      if-feature security-groups;
-      type instance-identifier { ct:instance-type SecurityGroup; }
-    }
-
-  }
-
-  choice version {
-    case v2.1 {
-      ct:instance-list servers { ct:instance-type ServerInstance; }
-    }
-  }
-
-  // OpenStack Nova specific RPC calls
-  rpc resize {
-    input {
-      leaf server { type instance-type { ct:instance-type ServerInstance; } }
-      // other params for resize
-    }
-  }
-  rpc backup;
-  rpc migrate;
-  rpc restore;
-  rpc evacuate;
-  rpc lock;
-  rpc unlock;
-  rpc suspend;
-  rpc resume;
-  rpc pause;
-  rpc unpause;
-  rpc inject-network;
-  rpc reset-network;
-}
diff --git a/deprecated/source/schema/openstack-identity.yang b/deprecated/source/schema/openstack-identity.yang
deleted file mode 100644
index 4b92957..0000000
--- a/deprecated/source/schema/openstack-identity.yang
+++ /dev/null
@@ -1,84 +0,0 @@
-module openstack-identity {
-  namespace "urn:opnfv:promise:openstack:identity";
-  prefix os-id;
-  
-  import access-control-models { prefix acm; }
-  import nfv-infrastructure { prefix nfvi; }
-  import complex-types { prefix ct; }
-  import ietf-yang-types { prefix yang; }
-
-  description
-    "OpenStack Identity Data Models with complex types and typed instance
-     identifiers represent the various Access Control Models available
-     within OpenStack.";
-  
-  revision 2015-09-03 {
-    description
-      "This YANG module is modeled using 'yangforge' which natively provides
-       complex types and typed instance identifiers.  This module
-       provides various collections of resource management data models
-       for instance based management";
-  }
-
-  /*********************************************
-   * OpenStack Identity Models
-   *********************************************/
-
-  ct:complex-type Project {
-    ct:extends acm:Group;
-    description
-      "OpenStack Project represent a distinct resource consumption space across
-       collection of users and groups that can reserve and allocate
-       resources.";
-    
-    leaf-list groups { type instance-identifer { ct:instance-type acm:Group; } }
-
-    container resource {
-      leaf-list images {
-        if-feature vm-images;
-        type instance-identifier { ct:instance-type nfvi:VirtualMachineImage; }
-      }
-
-      leaf-list flavors {
-        if-feature compute-flavors;
-        type instance-identifier { ct:instance-type nfvi:VirtualMachineFlavor; }
-      }
-    }
-  }
-
-  ct:complex-type User {
-    ct:extends acm:User;
-    
-    description
-      "OpenStack User can also belong to multiple projects.";
-    
-    leaf-list projects { type instance-identifier { ct:instance-type Project; } }
-  }
-
-  ct:complex-type Group {
-    ct:extends acm:Group;
-
-    description
-      "OpenStack Group can also belong to multiple projects.";
-
-    leaf-list projects { type instance-identifier { ct:instance-type Project; } }
-  }
-
-  ct:complex-type Domain {
-    ct:extends acm:Domain;
-    
-    description
-      "OpenStack Domain represent a distinct administrative domain including projects.";
-    
-    ct:instance-list projects { ct:instance-type Project; }
-  }
-
-  ct:complex-type Token {
-    leaf key { type yang:uuid; }
-    leaf identity { type instance-identifier { ct:instance-type Identity; } }
-  }
-
-
-  rpc create-project;
-  rpc remove-project;
-}
diff --git a/deprecated/source/schema/openstack.yang b/deprecated/source/schema/openstack.yang
deleted file mode 100644
index 6878f7e..0000000
--- a/deprecated/source/schema/openstack.yang
+++ /dev/null
@@ -1,74 +0,0 @@
-module openstack {
-  prefix os;
-
-  import nfv-infrastructure { prefix nfvi; }
-  import access-control-models { prefix acm; }
-  import ietf-yang-types { prefix yang; }
-  import ietf-inet-types { prefix inet; }
-  import complex-types { prefix ct; }
-
-  description
-    "OpenStack controller module";
-
-  revision 2016-01-19 {
-    description "Basic coverage of limited intents needed for Promise";
-  }
-  
-  identity openstack { base nfvi:manager; }
-  identity release { base openstack; }
-  identity distro { base openstack; }
-
-  feature os-system-admin {
-    description "OpenStack system administration capability";
-  }
-  
-  grouping os-credentials {
-    uses acm:access-credentials {
-      refine strategy {
-        default keystone;
-      }
-      refine endpoint {
-        default "http://localhost:5000/v2.0";
-      }
-    }
-    container tenant {
-      leaf id { type string; }
-      leaf name { type string; }
-    }
-  }
-  
-  // OpenStack infrastructure platform (PLACEHOLDER)
-  container platform {
-    uses nfvi:resource-stack;
-    
-    leaf release { type identityref { base release; } }
-    leaf distro  { type identityref { base distro; } }
-    
-    //ct:instance-list services { ct:instance-type OpenStackService; }
-    //ct:instance-list endpoints { ct:instance-type ServiceEndpoint; }
-  }
-
-  // OpenStack system administrator configuration tree
-  container admin {
-    if-feature os-system-admin;
-    container auth {
-      uses os-credentials;
-      leaf token { type yang:uuid; }
-    }
-  }
-
-  rpc authenticate {
-    if-feature os-system-admin;
-    input {
-      uses os-credentials;
-    }
-    output {
-      leaf token { type yang:uuid; }
-    }
-  }
-
-  rpc create-tenant {
-    if-feature os-system-admin;
-    
-  }
-}
diff --git a/deprecated/source/schema/opnfv-promise.yang b/deprecated/source/schema/opnfv-promise.yang
deleted file mode 100644
index 9ee7564..0000000
--- a/deprecated/source/schema/opnfv-promise.yang
+++ /dev/null
@@ -1,642 +0,0 @@
-module opnfv-promise {
-  namespace "urn:opnfv:promise";
-  prefix promise;
-
-  import complex-types { prefix ct; }
-  import ietf-yang-types { prefix yang; }
-  import ietf-inet-types { prefix inet; }
-  import access-control-models { prefix acm; }
-  import nfv-infrastructure { prefix nfvi; }
-
-  description
-    "OPNFV Promise Resource Reservation/Allocation controller module";
-
-  revision 2015-10-05 {
-    description "Complete coverage of reservation related intents";
-  }
-  
-  revision 2015-08-06 {
-    description "Updated to incorporate YangForge framework";
-  }
-
-  revision 2015-04-16 {
-    description "Initial revision.";
-  }
-
-  feature reservation-service {
-    description "When enabled, provides resource reservation service";
-  }
-
-  feature multi-provider {
-    description "When enabled, provides resource management across multiple providers";
-  }
-
-  typedef reference-identifier {
-    description "defines valid formats for external reference id";
-    type union {
-      type yang:uuid;
-      type inet:uri;
-      type uint32;
-    }
-  }
-  
-  grouping resource-utilization {
-    container capacity {
-      container total     { description 'Conceptual container that should be extended'; }
-      container reserved  { description 'Conceptual container that should be extended'; config false; }
-      container usage     { description 'Conceptual container that should be extended'; config false; }
-      container available { description 'Conceptual container that should be extended'; config false; }
-    }
-  }
-
-  grouping temporal-resource-collection {
-    description
-      "Information model capturing resource-collection with start/end time window";
-    
-    leaf start { type yang:date-and-time; }
-    leaf end   { type yang:date-and-time; }
-    
-    uses nfvi:resource-collection;
-  }
-  
-  grouping resource-usage-request {
-    description
-      "Information model capturing available parameters to make a resource
-       usage request.";
-    reference "OPNFV-PROMISE, Section 3.4.1";
-
-    uses temporal-resource-collection {
-      refine elements {
-        description
-          "Reference to a list of 'pre-existing' resource elements that are
-         required for fulfillment of the resource-usage-request.
-
-         It can contain any instance derived from ResourceElement,
-         such as ServerInstances or even other
-         ResourceReservations. If the resource-usage-request is
-         accepted, the ResourceElement(s) listed here will be placed
-         into 'protected' mode as to prevent accidental removal.
-
-         If any of these resource elements become 'unavailable' due to
-         environmental or administrative activity, a notification will
-         be issued informing of the issue.";
-      }
-    }
-    
-    leaf zone {
-      description "Optional identifier to an Availability Zone";
-      type instance-identifier { ct:instance-type nfvi:AvailabilityZone; }
-    }
-  }
-
-  grouping query-start-end-window {
-    container window {
-      description "Matches entries that are within the specified start/end time window";
-      leaf start { type yang:date-and-time; }
-      leaf end   { type yang:date-and-time; }
-      leaf scope {
-        type enumeration {
-          enum "exclusive" {
-            description "Matches entries that start AND end within the window";
-          }
-          enum "inclusive" {
-            description "Matches entries that start OR end within the window";
-          }
-        }
-        default "inclusive";
-      }
-    }
-  }
-
-  grouping query-resource-collection {
-    uses query-start-end-window {
-      description "Match for ResourceCollection(s) that are within the specified start/end time window";
-    }
-    leaf-list without {
-      description "Excludes specified collection identifiers from the result";
-      type instance-identifier { ct:instance-type ResourceCollection; }
-    }
-    leaf show-utilization { type boolean; default true; }
-    container elements {
-      leaf-list some {
-        description "Query for ResourceCollection(s) that contain some or more of these element(s)";
-        type instance-identifier { ct:instance-type nfvi:ResourceElement; }
-      }
-      leaf-list every {
-        description "Query for ResourceCollection(s) that contain all of these element(s)";
-        type instance-identifier { ct:instance-type nfvi:ResourceElement; }
-      }
-    }
-  }
-
-  grouping common-intent-output {
-    leaf result {
-      type enumeration {
-        enum "ok";
-        enum "conflict";
-        enum "error";
-      }
-    }
-    leaf message { type string; }
-  }
-  
-  grouping utilization-output {
-    list utilization {
-      key 'timestamp';
-      leaf timestamp { type yang:date-and-time; }
-      leaf count { type int16; }
-      container capacity { uses nfvi:resource-capacity; }
-    }
-  }
-
-  ct:complex-type ResourceCollection {
-    ct:extends nfvi:ResourceContainer;
-    ct:abstract true;
-
-    description
-      "Describes an abstract ResourceCollection data model, which represents
-       a grouping of capacity and elements available during a given
-       window in time which must be extended by other resource
-       collection related models";
-
-    leaf start { type yang:date-and-time; }
-    leaf end   { type yang:date-and-time; }
-    
-    leaf active {
-      config false;
-      description
-        "Provides current state of this record whether it is enabled and within
-         specified start/end time";
-      type boolean;
-    }
-  }
-
-  ct:complex-type ResourcePool {
-    ct:extends ResourceCollection;
-
-    description
-      "Describes an instance of an active ResourcePool record, which
-       represents total available capacity and elements from a given
-       source.";
-
-    leaf source {
-      type instance-identifier {
-        ct:instance-type nfvi:ResourceContainer;
-        require-instance true;
-      }
-      mandatory true;
-    }
-
-    refine elements {
-      // following 'must' statement applies to each element
-      // NOTE: just a non-working example for now...
-      must "boolean(/source/elements/*[@id=id])" {
-        error-message "One or more of the ResourceElement(s) does not exist in the provider to be reserved";
-      }
-    }
-  }
-
-  ct:complex-type ResourceReservation {
-    ct:extends ResourceCollection;
-    
-    description
-      "Describes an instance of an accepted resource reservation request,
-       created usually as a result of 'create-reservation' request.
-
-       A ResourceReservation is a derived instance of a generic
-       ResourceCollection which has additional parameters to map the
-       pool(s) that were referenced to accept this reservation as well
-       as to track allocations made referencing this reservation.
-
-       Contains the capacities of various resource attributes being
-       reserved along with any resource elements that are needed to be
-       available at the time of allocation(s).";
-    
-    reference "OPNFV-PROMISE, Section 3.4.1";
-
-    leaf created-on  { type yang:date-and-time; config false; }
-    leaf modified-on { type yang:date-and-time; config false; }
-
-    leaf-list pools {
-      config false;
-      description
-        "Provides list of one or more pools that were referenced for providing
-         the requested resources for this reservation.  This is an
-         important parameter for informing how/where allocation
-         requests can be issued using this reservation since it is
-         likely that the total reserved resource capacity/elements are
-         made availble from multiple sources.";
-      type instance-identifier {
-        ct:instance-type ResourcePool;
-        require-instance true;
-      }
-    }
-    
-    container remaining {
-      config false;
-      description
-        "Provides visibility into total remaining capacity for this
-         reservation based on allocations that took effect utilizing
-         this reservation ID as a reference.";
-
-      uses nfvi:resource-capacity;
-    }
-    
-    leaf-list allocations {
-      config false;
-      description
-        "Reference to a collection of consumed allocations referencing
-         this reservation.";
-      type instance-identifier {
-        ct:instance-type ResourceAllocation;
-        require-instance true;
-      }
-    }
-  }
-
-  ct:complex-type ResourceAllocation {
-    ct:extends ResourceCollection;
-
-    description
-      "A ResourceAllocation record denotes consumption of resources from a
-       referenced ResourcePool.
-
-       It does not reflect an accepted request but is created to
-       represent the actual state about the ResourcePool. It is
-       created once the allocation(s) have successfully taken effect
-       on the 'source' of the ResourcePool.
-       
-       The 'priority' state indicates the classification for dealing
-       with resource starvation scenarios. Lower priority allocations
-       will be forcefully terminated to allow for higher priority
-       allocations to be fulfilled.
-
-       Allocations without reference to an existing reservation will
-       receive the lowest priority.";
-    
-    reference "OPNFV-PROMISE, Section 3.4.3";
-
-    leaf reservation {
-      description "Reference to an existing reservation identifier (optional)";
-      
-      type instance-identifier {
-        ct:instance-type ResourceReservation;
-        require-instance true;
-      }
-    }
-
-    leaf pool {
-      description "Reference to an existing resource pool from which allocation is drawn";
-      
-      type instance-identifier {
-        ct:instance-type ResourcePool;
-        require-instance true;
-      }
-    }
-
-    container instance-ref {
-      config false;
-      description
-        "Reference to actual instance identifier of the provider/server for this allocation";
-      leaf provider {
-        type instance-identifier { ct:instance-type ResourceProvider; }
-      }
-      leaf server { type yang:uuid; }
-    }
-
-    leaf priority {
-      config false;
-      description
-        "Reflects current priority level of the allocation according to classification rules";
-      type enumeration {
-        enum "high"   { value 1; }
-        enum "normal" { value 2; }
-        enum "low"    { value 3; }
-      }
-      default "normal";
-    }
-  }
-
-  ct:complex-type ResourceFlavor {
-    description "currently NOT an extension of ResourceElement.";
-    key "id";
-    leaf id    { type string; }
-    leaf name  { type string; }
-    leaf disk  { type uint32; units 'GB'; default 0; }
-    leaf ram   { type uint32; units 'MB'; default 0; }
-    leaf vcpus { type uint16; default 0; }
-  }
-  
-  ct:complex-type ResourceProvider {
-    ct:extends nfvi:ResourceContainer;
-
-    key "name";
-    leaf token { type string; mandatory true; }
-    
-    container services { // read-only
-      config false;
-      container compute {
-        leaf endpoint { type inet:uri; }
-        ct:instance-list flavors { ct:instance-type ResourceFlavor; }
-      }
-    }
-    
-    leaf-list pools {
-      config false;
-      description
-        "Provides list of one or more pools that are referencing this provider.";
-      
-      type instance-identifier {
-        ct:instance-type ResourcePool;
-        require-instance true;
-      }
-    }
-  }
-  
-  // MAIN CONTAINER
-  container promise {
-    
-    uses resource-utilization {
-      description "Describes current state info about capacity utilization info";
-      
-      augment "capacity/total"     { uses nfvi:resource-capacity; }
-      augment "capacity/reserved"  { uses nfvi:resource-capacity; }
-      augment "capacity/usage"     { uses nfvi:resource-capacity; }
-      augment "capacity/available" { uses nfvi:resource-capacity; }
-    }
-
-    ct:instance-list providers {
-      if-feature multi-provider;
-      description "Aggregate collection of all registered ResourceProvider instances for Promise resource management service";
-      ct:instance-type ResourceProvider;
-    }
-
-    ct:instance-list pools {
-      if-feature reservation-service;
-      description "Aggregate collection of all ResourcePool instances";
-      ct:instance-type ResourcePool;
-    }
-    
-    ct:instance-list reservations {
-      if-feature reservation-service;
-      description "Aggregate collection of all ResourceReservation instances";
-      ct:instance-type ResourceReservation;
-    }
-
-    ct:instance-list allocations {
-      description "Aggregate collection of all ResourceAllocation instances";
-      ct:instance-type ResourceAllocation;
-    }
-
-    container policy {
-      container reservation {
-        leaf max-future-start-range {
-          description
-            "Enforce reservation request 'start' time is within allowed range from now";
-          type uint16 { range 0..365; }
-          units "days";
-        }
-        leaf max-future-end-range {
-          description
-            "Enforce reservation request 'end' time is within allowed range from now";
-          type uint16 { range 0..365; }
-          units "days";
-        }
-        leaf max-duration {
-          description
-            "Enforce reservation duration (end-start) does not exceed specified threshold";
-          type uint16;
-          units "hours";
-          default 8760; // for now cap it at max one year as default
-        }
-        leaf expiry {
-          description
-            "Duration in minutes from start when unallocated reserved resources
-             will be released back into the pool";
-          type uint32;
-          units "minutes";
-        }
-      }
-    }
-  }
-
-  //-------------------
-  // INTENT INTERFACE
-  //-------------------
-
-  // RESERVATION INTENTS
-  rpc create-reservation {
-    if-feature reservation-service;
-    description "Make a request to the reservation system to reserve resources";
-    input {
-      uses resource-usage-request;
-    }
-    output {
-      uses common-intent-output;
-      leaf reservation-id {
-        type instance-identifier { ct:instance-type ResourceReservation; }
-      }
-    }
-  }
-  
-  rpc update-reservation {
-    description "Update reservation details for an existing reservation";
-    input {
-      leaf reservation-id {
-        type instance-identifier {
-          ct:instance-type ResourceReservation;
-          require-instance true;
-        }
-        mandatory true;
-      }
-      uses resource-usage-request;
-    }
-    output {
-      uses common-intent-output;
-    }
-  }
-  
-  rpc cancel-reservation {
-    description "Cancel the reservation and be a good steward";
-    input {
-      leaf reservation-id {
-        type instance-identifier { ct:instance-type ResourceReservation; }
-        mandatory true;
-      }
-    }
-    output {
-      uses common-intent-output;
-    }
-  }
-
-  rpc query-reservation {
-    if-feature reservation-service;
-    description "Query the reservation system to return matching reservation(s)";
-    input {
-      leaf zone { type instance-identifier { ct:instance-type nfvi:AvailabilityZone; } }
-      uses query-resource-collection;
-    }
-    output {
-      leaf-list reservations { type instance-identifier { ct:instance-type ResourceReservation; } }
-      uses utilization-output;
-    }
-  }
-  
-  // CAPACITY INTENTS
-  rpc increase-capacity {
-    description "Increase total capacity for the reservation system between a window in time";
-    input {
-      uses temporal-resource-collection;
-      leaf source {
-        type instance-identifier {
-          ct:instance-type nfvi:ResourceContainer;
-        }
-      }
-    }
-    output {
-      uses common-intent-output;
-      leaf pool-id {
-        type instance-identifier { ct:instance-type ResourcePool; }
-      }
-    }
-  }
-
-  rpc decrease-capacity {
-    description "Decrease total capacity for the reservation system between a window in time";
-    input {
-      uses temporal-resource-collection;
-      leaf source {
-        type instance-identifier {
-          ct:instance-type nfvi:ResourceContainer;
-        }
-      }
-    }
-    output {
-      uses common-intent-output;
-      leaf pool-id {
-        type instance-identifier { ct:instance-type ResourcePool; }
-      }
-    }
-  }
-
-  rpc query-capacity {
-    description "Check available capacity information about a specified resource collection";
-    input {
-      leaf capacity {
-        type enumeration {
-          enum 'total';
-          enum 'reserved';
-          enum 'usage';
-          enum 'available';
-        }
-        default 'available';
-      }
-      leaf zone { type instance-identifier { ct:instance-type nfvi:AvailabilityZone; } }
-      uses query-resource-collection;
-      // TBD: additional parameters for query-capacity
-    }
-    output {
-      leaf-list collections { type instance-identifier { ct:instance-type ResourceCollection; } }
-      uses utilization-output;
-    }
-  }
-
-  // ALLOCATION INTENTS (should go into VIM module in the future)
-  rpc create-instance {
-    description "Create an instance of specified resource(s) utilizing capacity from the pool";
-    input {
-      leaf provider-id {
-        if-feature multi-provider;
-        type instance-identifier { ct:instance-type ResourceProvider; require-instance true; }
-      }
-      leaf name   { type string; mandatory true; }
-      leaf image  {
-        type reference-identifier;
-        mandatory true;
-      }
-      leaf flavor {
-        type reference-identifier;
-        mandatory true;
-      }
-      leaf-list networks {
-        type reference-identifier;
-        description "optional, will assign default network if not provided";
-      }
-      
-      // TODO: consider supporting a template-id (such as HEAT) for more complex instantiation
-      
-      leaf reservation-id {
-        type instance-identifier { ct:instance-type ResourceReservation; require-instance true; }
-      }
-    }
-    output {
-      uses common-intent-output;
-      leaf instance-id {
-        type instance-identifier { ct:instance-type ResourceAllocation; }
-      }
-    }
-  }
-
-  rpc destroy-instance {
-    description "Destroy an instance of resource utilization and release it back to the pool";
-    input {
-      leaf instance-id {
-        type instance-identifier { ct:instance-type ResourceAllocation; require-instance true; }
-      }
-    }
-    output {
-      uses common-intent-output;
-    }
-  }
-
-  // PROVIDER INTENTS (should go into VIM module in the future)
-  rpc add-provider {
-    description "Register a new resource provider into reservation system";
-    input {
-      leaf provider-type {
-        description "Select a specific resource provider type";
-        mandatory true;
-        type enumeration {
-          enum openstack;
-          enum hp;
-          enum rackspace;
-          enum amazon {
-            status planned;
-          }
-          enum joyent {
-            status planned;
-          }
-          enum azure {
-            status planned;
-          }
-        }
-        default openstack;
-      }
-      uses acm:access-credentials {
-        refine strategy {
-          default keystone;
-        }
-        refine endpoint {
-          default "http://localhost:5000/v2.0";
-        }
-      }
-      leaf user-domain-name { type string; }
-      container project {
-        leaf id { type string; }
-        leaf name { type string; }
-        leaf domain-name { type string; }
-      }
-    }
-    output {
-      uses common-intent-output;
-      leaf provider-id {
-        type instance-identifier { ct:instance-type ResourceProvider; }
-      }
-    }
-  }
-  
-  // TODO...
-  notification reservation-event;
-  notification capacity-event;
-  notification allocation-event;
-}