Proposal to move Promise shim-layer code to a new deprecated folder

Promise test cases have been disabled in Functest

Promise shim-layer has been marked as DEPRECATED in Euphrates

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

7 files changed, 1435 insertions, 0 deletions

diff --git a/deprecated/source/schema/access-control-models.yang b/deprecated/source/schema/access-control-models.yang
new file mode 100644
index 0000000..7b4684c
--- /dev/null
+++ b/deprecated/source/schema/access-control-models.yang
@@ -0,0 +1,92 @@
+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
new file mode 100644
index 0000000..ccad269
--- /dev/null
+++ b/deprecated/source/schema/nfv-infrastructure.yang
@@ -0,0 +1,322 @@
+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
new file mode 100644
index 0000000..0e3bbbe
--- /dev/null
+++ b/deprecated/source/schema/nfv-mano.yang
@@ -0,0 +1,149 @@
+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
new file mode 100644
index 0000000..c3e790c
--- /dev/null
+++ b/deprecated/source/schema/openstack-compute.yang
@@ -0,0 +1,72 @@
+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
new file mode 100644
index 0000000..4b92957
--- /dev/null
+++ b/deprecated/source/schema/openstack-identity.yang
@@ -0,0 +1,84 @@
+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
new file mode 100644
index 0000000..6878f7e
--- /dev/null
+++ b/deprecated/source/schema/openstack.yang
@@ -0,0 +1,74 @@
+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
new file mode 100644
index 0000000..9ee7564
--- /dev/null
+++ b/deprecated/source/schema/opnfv-promise.yang
@@ -0,0 +1,642 @@
+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;
+}