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;
        }
      }
    }
  }
}