module xos-core {
  namespace "urn:onlab:xos:core";
  prefix xos;
  yang-version 1.1;

  organization
   "Open Networking Lab (XOS) / Corenova Technologies";

  contact
    "Larry Peterson <llp@onlab.us>
     Peter K. Lee <peter@corenova.com>";
  
  description
   "This module contains a collection of core models for XOS.

    Copyright (c) 2016 ON.LAB and the persons identified as authors of
    the code.  All rights reserved.

    Redistribution and use in source and binary forms, with or without
    modification, is permitted pursuant to, and subject to the license
    terms of the Apache License, Version 2.0 which accompanies this
    distribution, and is available at
    (http://www.apache.org/licenses/LICENSE-2.0).";
  
  revision 2016-07-14 {
    description "Initial revision.";
  }
  
  import ietf-yang-types { prefix yang; }
  import ietf-inet-types { prefix inet; }
  import xos-types { prefix xos; }

  feature synchronizer {
    description
      "Enables configuration synchronization to the distributed store.";
  }
  
  identity kind;
  identity generic { base kind; }
  identity service { base kind; }

  typedef unique-identifier {
    description "defines valid formats for external reference id";
    type union {
      type uint32 { range 1..max; }
      type yang:uuid;
      type inet:uri;
    }
  }
  typedef bandwidth {
    type uint32 {
      range 1000000..max; // should be at least 1 Mbps?  
    }
    units 'bps';
  }
  typedef vlan {
    type uint16 { range 0..4095; }
  }

  grouping attribute-pair {
    leaf name  { type string { length 0..128; } }
    leaf value { type string; }
    // don't need pointer back to service
  }

  grouping sync-record {
    description "Synchronizer-specific properties for model records";
    
    leaf created { type yang:date-and-time; }
    leaf updated { type yang:date-and-time; }
    leaf enacted { type yang:date-and-time; }
    leaf policed { type yang:date-and-time; }
        
    leaf writable { type boolean; default true; }
    leaf locked   { type boolean; default false; }
    leaf deleted  { type boolean; default false; }
      
    leaf dirty {
      config false;
      type boolean;
      default false;
    }
      
    container sync {
      anydata register {
        description "scratchpad used by the Observer";
      }
      leaf progress {
        type enumeration {
          enum provisioning {
            value 0;
            description "Provisioning in progress";
          }
        }
      }
      leaf disabled { type boolean; default false; }
      leaf enforced { type boolean; default true; }

      list policy {
        // TODO: how are policy defined/enforced?
      }
    }
      
    action diff {
      when "../dirty == true";
      description "retrieve diff of model state if dirty";
    }
    action save {
      description "trigger save into data store via synchronizer";
    }
  }
  
  grouping base-common {
    leaf id {
      type unique-identifier;
      mandatory true;
    }
    leaf name {
      type string {
        length 0..255;
      }
    }
    list attribute {
      uses attribute-pair;
      key name;
      status deprecated;
      reference "XOS: service-specific-attribute";
      description "backwards-compatible attribute association";
    }
    leaf service-specific-id {
      type unique-identifier;
      mandatory true;
      status deprecated;
    }
    container record {
      if-feature synchronizer;
      uses sync-record;
    }
  }

  grouping tenant-root {
    uses base-common {
      refine 'name' {
        description "Specify name of the TenantRoot";
      }
    }
    description
      "A Tenant Root is one of the things that can sit at the root of a chain
       of tenancy. This object represents a node.";

    list subscribed-tenant {
      config false;
      // not exactly clear how this is populated
    }
  }
  
  grouping subscriber {
    uses tenant-root {
      refine kind { default subscriber; }
    }
    // seems we should have interesting attributes specific to subscriber?
  }
  
  grouping provider {
    uses tenant-root {
      refine kind { default provider; }
    }
    // seems we should have interesting attributes specific to provider?
  }

  grouping service {
    uses base-common {
      refine 'name' {
        description "Name of the Service";
      }
    }
    leaf kind {
      type identityref {
        base kind;
      }
      default generic;
    }
    leaf description {
      type string {
        length 0..254;
      }
      description "Description of the Service";
    }
    leaf version {
      type string { length 0..30; }
      description "Version of Service Definition";
    }
    
    leaf enabled   { type boolean; default true; }
    leaf published { type boolean; default true; }

    container links {
      leaf view { type inet:uri; }
      leaf icon { type inet:uri; }
    }
    
    list keypair {
      description "collection of public/private key pair(s)";
      // should be a specific typedef for storing this content
      leaf public  { type string { length 0..1024; } }
      leaf private { type string { length 0..1024; } }
    }
    list provider {
      description
        "Each entry represents a provider of the service. Each unique service
         should augment this block with service specific attributes.";
      key id;
      uses xos:provider;
    }
    list subscriber {
      description
        "Each entry represents a subscriber of the service. Each unique service
         should augment this block with service specific attributes.";
      key id;
      uses xos:subscriber;
      notification subscriber-added;
      notification subscriber-deleted;
    }
    
    // TOOD: need to better understand relationship between Service and Slice
    action scale {
      description "Adjust scale for slice(s)";
    }

    // TODO: need to better understand relationship between Service and VTN
  }

  grouping tenancy {
    uses base-common;

    choice provider {
      description "only one type of provider node is valid.";
      case service { leaf provider-service { type instance-identifier; } }
    }
    
    choice subscriber {
      description "only one type of subscriber node is valid.";
      case service { leaf subscriber-service { type instance-identifier; } }
      case tenant  { leaf subscriber-tenant  { type instance-identifier; } }
      case user    { leaf subscriber-user    { type instance-identifier; } }
      case root    { leaf subscriber-root    { type instance-identifier; } }
      case network { leaf subscriber-network { type instance-identifier; } }
    }

    leaf connect-method {
      //when "../kind == 'static-tenant'";
      
      type enumeration {
        enum public { description "Public"; }
        enum private { description "Private"; }
        enum private-unidirectional { description "Private Uni-directional"; }
        enum na { description "Not Applicable"; }
      }
      default na;
    }

    // TODO: should be able to deal with TenantWithContainer here
    
  }

  grouping slice {
    description 
      "A slice is a logically centralized container for network and compute resources"

    uses base-common;

    leaf enabled {
       type boolean;
       default true;
    }

    leaf omf-friendly {
       type boolean;
       default false;
       status deprecated;
    }

    leaf slice-url {
       description "A URL describing the purpose of this slice";
       type xos.refs.url-field; 
       // blank true;
    }

    leaf max-instances {
       description "The maximum number of VMs that this slice is allowed to allocate";
       type uint32;
    } 

    leaf service {
       description "The service that runs in this slice";
       type xos.refs.service;
    }

    leaf network {
       description "The network that the slice uses to connect to other slices and to the Internet.";
       type string;
    }

    leaf exposed-ports {
       description "The ports to be exposed for other slices to connect to";
       type string;
    }

    leaf service-class {
       type xos.refs.service-class;
       status deprecated;
    }
   
    leaf creator {
       type xos.refs.user;
    }

    leaf default-flavor {
       type xos.refs.flavor;
    }

    leaf default-image {
       type xos.refs.image;
    }

    leaf default-node {
       type xos.refs.node;
    } 

    leaf mount-data-sets {
       type string;
       default "GenBank";
       length 0..256;
    } 

    leaf default_isolation {
       type string;
       default "vm";
       length 0..30;
    } 

    leaf-list tags {
        type leafref {
            path "/tag[id = current()/../id]/id";
        }
    }
  }


  grouping controller-images {
    uses xos-base;

    leaf image { 
      type xos:image; 
    }

    leaf controller { 
      type xos:controller; 
    }

    container synchronizer {
        if-feature synchronizer {
            leaf glance-image-id { 
              type string;
            }
        }
    }
  }

  grouping controller-site-privilege {
    uses xos-base;

    leaf controller { 
      type xos:controller; 
    }

    leaf site-privilege { 
      type xos:site-privilege; 
    }
    
   container synchronizer {
     if-feature synchronizer {

       leaf role-id { 
         type string;
       }
     }
   }

  grouping image {
    uses xos-base;

    
    leaf kind { 
      type string;
    }
    leaf disk-format { 
      type string;
    }
    leaf container-format { 
      type string;
    }
    leaf path { 
      type string;
    }
    leaf tag { 
      type string;
    }
  }

  grouping controller-network {
    uses xos-base;
    leaf network { 
      type xos:network; 
    }
    leaf controller { 
      type xos:controller; 
    }
    
    container synchronizer {
        if-feature synchronizer {
            leaf net-id { 
              type string;
            }
            leaf router-id { 
              type string;
            }
            leaf subnet-id { 
              type string;
            }
        }

    leaf subnet { 
      type string;
    }
   
  }

  grouping site {
    uses xos-base;
    
    leaf site-url { 
      type xos:url-field;
    }
    leaf enabled { 
      type boolean;
    }
    leaf hosts-nodes { 
      type boolean;
    }
    leaf hosts-users { 
      type boolean;
    }
    leaf location { 
      type xos:geoposition-field;
    }
    leaf longitude { 
      type decimal64;
    }
    leaf latitude { 
      type decimal64;
    }
    leaf login-base { 
      type string;
    }
    leaf is-public { 
      type boolean;
    }
    leaf abbreviated-name { 
      type string;
    }
  }

  grouping slice-role {
    uses xos-base;
    leaf role { 
      type string;
    }
  }

  grouping site-deployment {
    leaf site { 
      type xos:site; 
    }
    leaf deployment { 
      type xos:deployment; 
    }
    leaf controller { 
      type xos:controller; 
    }
    container synchronizer {
        if-feature synchronizer {

          leaf availability-zone { 
            type string;
          }
        }
    }
  }

  
  grouping user-credential {
    leaf user { 
      type xos:user; 
    }
    
    leaf key-id { 
      type string;
    }

    leaf enc-value { 
      type xos:encrypted-string;
    }
  }

  grouping invoice {
    leaf date { 
      type xos:datetime;
    }
    leaf account { 
      type xos:account; 
    }
  }

  grouping slice-privilege {
    leaf user { 
      type xos:user; 
    }
    leaf slice { 
      type xos:slice; 
    }
    leaf role { 
      type xos:role; 
    }
  }

  grouping flavor {
    
    leaf description { 
      type string;
    }
    leaf flavor { 
      type string;
    }
    leaf order { 
      type uint32;
    }
    leaf default { 
      type boolean;
    }
  }

  grouping port {
    leaf network { 
      type xos:network; 
    }
    leaf instance { 
      type xos:instance; 
    }
    container synchronizer {
        if-feature synchronizer {
            leaf ip { 
              type inet:ip-address;
            }
            leaf port-id { 
              type string;
            }
            leaf mac { 
              type string;
            }
        }
    }
    leaf xos-created { 
      type boolean;
    }
  }

  grouping service-role {
    leaf role { 
      type string;
    }
  }

  grouping controller-site {
    leaf site { 
      type xos:site; 
    }

    leaf controller { 
      type xos:controller; 
    }

    container synchronizer {
        if-feature synchronizer {

          leaf tenant-id { 
            type string;
          }
        }
    }
  }

  grouping controller-slice {
    leaf controller { 
      type xos:controller; 
    }
    leaf slice { 
      type xos:slice; 
    }
    
    container synchronizer {
        if-feature synchronizer {
          leaf tenant-id { 
            type string;
          }
        }
    }
  }

  grouping tenant-role {
    leaf role { 
      type string;
    }
  }

  grouping network {
    leaf template { 
      type xos:template; 
    }

    leaf subnet { 
      type string;
    }

    leaf ports { 
      type string;
    }

    leaf labels { 
      type string;
    }

    leaf owner { 
      type xos:owner; 
    }

    leaf guaranteed-bandwidth { 
      type uint32;
    }

    leaf permit-all-slices { 
      type boolean;
    }

    leaf topology-parameters { 
      type string;
    }

    leaf controller-url { 
      type string;
    }

    leaf controller-parameters { 
      type string;
    }

    container synchronizer {
        if-feature synchronizer {
            leaf network-id { 
              type string;
            }
            leaf router-id { 
              type string;
            }
            leaf subnet-id { 
              type string;
            }
        }
    }
    leaf autoconnect { 
      type boolean;
    }
  }

  grouping controller-role {
    leaf role { 
      type string;
    }
  }

  grouping diag {
    
  }

  grouping service-class {
    
    leaf description { 
      type string;
    }
    leaf commitment { 
      type uint32;
    }
    leaf membership-fee { 
      type uint32;
    }
    leaf membership-fee-months { 
      type uint32;
    }
    leaf upgrade-requires-approval { 
      type boolean;
    }
  }

  grouping site-role {
    leaf role { 
      type string;
    }
  }

  grouping instance {
    container synchronizer {
      if-feature synchronizer {
        leaf instance-id { 
          type string;
        }

        leaf instance-uuid { 
          type string;
        }
        
        leaf instance-name { 
          type string;
        }

        leaf ip { 
          type inet:ip-address;
        }
    }
    leaf image { 
      type xos:image; 
    }
    leaf creator { 
      type xos:creator; 
    }
    leaf slice { 
      type xos:slice; 
    }
    leaf deployment { 
      type xos:deployment; 
    }
    leaf node { 
      type xos:node; 
    }
    leaf number-cores { 
      type uint32;
    }
    leaf flavor { 
      type xos:flavor; 
    }
    leaf user-data { 
      type string;
    }
    leaf isolation { 
      type string;
    }
    leaf volumes { 
      type string;
    }
    leaf parent { 
      type xos:parent; 
    }
  }

  grouping charge {
    leaf account { 
      type xos:account; 
    }
    leaf slice { 
      type xos:slice; 
    }
    leaf kind { 
      type string;
    }
    leaf state { 
      type string;
    }
    leaf date { 
      type xos:datetime;
    }
    leaf object { 
      type xos:object; 
    }
    leaf amount { 
      type decimal64;
    }
    leaf core-hours { 
      type decimal64;
    }
    leaf invoice { 
      type xos:invoice; 
    }
  }

  grouping program {
    leaf description { 
      type string;
    }

    leaf kind { 
      type string;
    }

    leaf command { 
      type string;
    }

    leaf owner { 
      type xos:owner; 
    }

    leaf contents { 
      type string;
    }

    leaf output { 
      type string;
    }

    leaf messages { 
      type string;
    }

    leaf status { 
      type string;
    }
  }

  grouping role {
    leaf role-type { 
      type string;
    }
    leaf role { 
      type string;
    }
    leaf description { 
      type string;
    }
    leaf content-type { 
      type xos:content-type; 
    }
  }

  grouping usable-object {
    
  }

  grouping node-label {
    
  }

  grouping slice-credential {
    leaf slice { 
      type xos:slice; 
    }
    
    leaf key-id { 
      type string;
    }
    leaf enc-value { 
      type xos:encrypted-string;
    }
  }

  grouping node {
    
    leaf site-deployment { 
      type xos:site-deployment; 
    }
    leaf site { 
      type xos:site; 
    }
  }

  grouping address-pool {
    
    leaf addresses { 
      type string;
    }
    leaf gateway-ip { 
      type string;
    }
    leaf gateway-mac { 
      type string;
    }
    leaf cidr { 
      type string;
    }
    leaf inuse { 
      type string;
    }
    leaf service { 
      type xos:service; 
    }
  }

  grouping dashboard-view {
    
    leaf url { 
      type string;
    }
    leaf enabled { 
      type boolean;
    }
  }
  grouping network-parameter {
    leaf parameter { 
      type xos:parameter; 
    }
    leaf value { 
      type string;
    }
    leaf content-type { 
      type xos:content-type; 
    }
    leaf object-id { 
      type uint32;
    }
  }
  grouping image-deployments {
    leaf image { 
      type xos:image; 
    }
    leaf deployment { 
      type xos:deployment; 
    }
  }

  grouping controller-user {
    leaf user { 
      type xos:user; 
    }

    leaf controller { 
      type xos:controller; 
    }
    
    container synchronizer {
        if-feature synchronizer {
            leaf kuser-id { 
              type string;
            }
        }
      }
  }
  grouping reserved-resource {
    leaf instance { 
      type xos:instance; 
    }
    leaf resource { 
      type xos:resource; 
    }
    leaf quantity { 
      type uint32;
    }
    leaf reservationSet { 
      type xos:reservationSet; 
    }
  }
  grouping network-template {
    
    leaf description { 
      type string;
    }
    leaf guaranteed-bandwidth { 
      type uint32;
    }
    leaf visibility { 
      type string;
    }
    leaf translation { 
      type string;
    }
    leaf access { 
      type string;
    }
    leaf shared-network-name { 
      type string;
    }
    leaf shared-network-id { 
      type string;
    }
    leaf topology-kind { 
      type string;
    }
    leaf controller-kind { 
      type string;
    }
  }
  grouping controller-dashboard-view {
    leaf controller { 
      type xos:controller; 
    }
    leaf dashboardView { 
      type xos:dashboardView; 
    }
    leaf enabled { 
      type boolean;
    }
    leaf url { 
      type string;
    }
  }
  grouping user-dashboard-view {
    leaf user { 
      type xos:user; 
    }
    leaf dashboardView { 
      type xos:dashboardView; 
    }
    leaf order { 
      type uint32;
    }
  }
  grouping controller {
    
    leaf backend-type { 
      type string;
    }
    leaf version { 
      type string;
    }
    leaf auth-url { 
      type string;
    }
    leaf admin-user { 
      type string;
    }
    leaf admin-password { 
      type string;
    }
    leaf admin-tenant { 
      type string;
    }
    leaf domain { 
      type string;
    }
    leaf rabbit-host { 
      type string;
    }
    leaf rabbit-user { 
      type string;
    }
    leaf rabbit-password { 
      type string;
    }
    leaf deployment { 
      type xos:deployment; 
    }
  }
  grouping user {
    leaf password { 
      type string;
    }
    leaf last-login { 
      type xos:datetime;
    }
    leaf email { 
      type EmailField;
    }
    leaf username { 
      type string;
    }
    leaf firstname { 
      type string;
    }
    leaf lastname { 
      type string;
    }
    leaf phone { 
      type string;
    }
    leaf user-url { 
      type xos:url-field;
    }
    leaf site { 
      type xos:site; 
    }
    leaf public-key { 
      type string;
    }
    leaf is-active { 
      type boolean;
    }
    leaf is-admin { 
      type boolean;
    }
    leaf is-staff { 
      type boolean;
    }
    leaf is-readonly { 
      type boolean;
    }
    leaf is-registering { 
      type boolean;
    }
    leaf is-appuser { 
      type boolean;
    }
    leaf login-page { 
      type string;
    }
    leaf timezone { 
      type xos:time-zone-field;
    }
  }
  grouping deployment {
    
    leaf access-control { 
      type string;
    }
  }
  grouping reservation {
    leaf startTime { 
      type xos:datetime;
    }
    leaf slice { 
      type xos:slice; 
    }
    leaf duration { 
      type uint32;
    }
  }
  grouping site-privilege {
    leaf user { 
      type xos:user; 
    }
    leaf site { 
      type xos:site; 
    }
    leaf role { 
      type xos:role; 
    }
  }
  grouping payment {
    leaf account { 
      type xos:account; 
    }
    leaf amount { 
      type decimal64;
    }
    leaf date { 
      type xos:datetime;
    }
  }
  
  grouping network-slice {
    leaf network { 
      type xos:network; 
    }

    leaf slice { 
      type xos:slice; 
    }
  }

  grouping account {
    leaf site { 
      type xos:site; 
    }
  }

  grouping controller-slice-privilege {
    leaf controller { 
      type xos:controller; 
    }

    leaf slice-privilege { 
      type xos:slice-privilege; 
    }
    
    container synchronizer {
        if-feature synchronizer {
            leaf role-id { 
              type string;
            }
        }
    }
  }

  grouping site-credential {
    leaf site { 
      type xos:site; 
    }
    
    leaf key-id { 
      type string;
    }

    leaf enc-value { 
      type xos:encrypted-string;
    }
  }

  grouping deployment-privilege {
    leaf user { 
      type xos:user; 
    }

    leaf deployment { 
      type xos:deployment; 
    }

    leaf role { 
      type xos:role; 
    }
  }

  grouping network-parameter-type {
    leaf description { 
      type string;
    }
  }
  
  grouping deployment-role {
    leaf role { 
      type string;
    }
  }

  grouping project {
    
  }
  
  grouping slice-tag {
    leaf slice { 
      type xos:slice; 
    }
    
    leaf value { 
      type string;
    }
  }

  grouping router {
    leaf owner { 
      type xos:owner; 
    }
  }

  grouping service-resource {
    leaf service-class { 
      type xos:service-class; 
    }
    
    leaf max-units-deployment { 
      type uint32;
    }

    leaf max-units-node { 
      type uint32;
    }

    leaf max-duration { 
      type uint32;
    }

    leaf bucket-in-rate { 
      type uint32;
    }

    leaf bucket-max-size { 
      type uint32;
    }

    leaf cost { 
      type uint32;
    }

    leaf calendar-reservable { 
      type boolean;
    }
  }

  grouping service-privilege {
    leaf user { 
      type xos:user; 
    }
    leaf service { 
      type xos:service; 
    }
    leaf role { 
      type xos:role; 
    }
  }
  
  /*** main configuration tree for XOS ***/

  container api {
    description
      "The primary configuration interaction endpoint";
    
    container service {
      description
        "placeholder endpoint for services to augment";
    }
    container tenant {
      description
        "placeholder endpoint for tenants to augment";
    }
  }
  
}