module ietf-coms-core {
yang-version 1.1;
namespace "urn:ietf:params:xml:ns:yang:ietf-coms-core";
prefix netslice;

import ietf-yang-types { prefix "yang"; }
import ietf-inet-types { prefix inet; }
import ietf-network { prefix nd;  }
import ietf-network-topology { prefix lnk;  }

organization
  "IETF";

contact
  "Editors:    X. de Foy, Cristina QIANG
              <mailto:>";

description
  "This module contains a collection of YANG definitions for COMS.

  Copyright (c) 2016 IETF Trust 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 contained in, the Simplified BSD License
  set forth in Section 4.c of the IETF Trust's Legal Provisions
  Relating to IETF Documents
  (http://trustee.ietf.org/license-info).
  This version of this YANG module is part of
  draft-...;
  see the RFC itself for full legal notices.";

revision "2017-10-27" {
  description
    "Initial revision of COMS topology.";
  reference
    "draft-qiang-coms-netslicing-information-model-02";
}

/*
  Types
*/

typedef read-write-mode-type {
  type enumeration {
    enum read-write {
      description "R/W";
    }
    enum read-only {
      description "R/O";
    }
  }
  description "Indicates if entity is read-write,
  read-only, etc.";
}

typedef isolation-mode-type {
  type enumeration {
    enum isolation-mode-shared {
      description "Underlying compute or storage can be
      shared with other instances";
    }
    enum isolation-mode-dedicated {
      description "Underlying compute or storage is not
      shared with other instances";
    }
  }
  description "Isolation mode";
}

typedef lifecycle-status-type {
  type enumeration {
    enum construction {
      description "construction";
    }
    enum modification {
      description "modification";
    }
    enum activation  {
      description "activation";
    }
    enum deletion {
      description "deletion";
    }
  }
  description "Lifecycle status";
}

typedef resource-reservation-level-type {
  type enumeration {
    enum none {
      description "No specific reliability requirement";
    }
    enum shared-non-preemptive {
      description "Each path has a backup path";
    }
    enum shared-preemptive  {
      description "Each node/link has a backup node/link";
    }
    enum exclusive {
      description "Each node/link has a backup node/link,
      mapped to different physical devices/paths";
    }
  }
  description "Resource reservation level";
}

typedef reliability-level-type {
  type enumeration {
    enum none {
      description "No specific reliability requirement";
    }
    enum path-backup {
      description "Each path has a backup path";
    }
    enum logical-backup  {
      description "Each node/link has a backup node/link";
    }
    enum physical-backup {
      description "Each node/link has a backup node/link,
      mapped to different physical devices/paths";
    }
  }
  description "Reliability level";
}

typedef redundancy-type {
  type enumeration {
    enum none {
      description "no redundancy";
    }
    enum n+1 {
      description "n storage units with one extra backup";
    }
    enum 2n {
      description "each storage unit has one backup";
    }
    enum 2n+1 {
      description "n storage units with n+1 extra backup";
    }
  }
  description "Redundancy type";
}

typedef node-ref {
  type instance-identifier;
  description "A reference to a node";
}

typedef link-ref {
  type instance-identifier;
  description "A reference to a link";
}

typedef compute-unit-ref {
  type instance-identifier;
  description "A reference to a compute unit";
}

typedef storage-unit-ref {
  type instance-identifier;
  description "A reference to a storage unit";
}

typedef service-instance-ref {
  type instance-identifier;
  description "A reference to a service instance";
}

grouping rule {
  description "Access Control Rule";
  leaf match{
    type string;
    description "Match";
  }
  leaf action{
    type string;
    description "Action";
  }
  leaf priority{
    type string;
    description "Priority";
  }
  leaf counter{
    type int64;
    description "Counter";
  }
}

grouping port-config {
  description "Configuration of a port/connection point";
  leaf packet-rate {
    type int64;
    description "Data rate in packets per seconds";
  }
  leaf packet-loss-probability {
    type int64;
    description "Packet loss probability (actual type is TBD)";
  }
  leaf packet-loss-threshold {
    type int64;
    description "Packet loss probability threshold to alert
    management system (actual type is TBD)";
  }
}

grouping port-stats {
  description "Statistics of a port/connection point";
  leaf received-packets {
    type int64;
    description "Total number of packets received";
  }
  leaf sent-packets {
    type int64;
    description "Total number of packets sent";
  }
}

grouping storage-unit-specs {
  description "Storage unit specs";
  leaf size {
    type int64;
    description "storage size in M";
  }
  leaf isolation-mode {
    type isolation-mode-type;
    description "isolation mode";
  }
  leaf read-write-mode-type {
    type read-write-mode-type;
    description "Read and write mode";
  }
  leaf redundancy-type {
    type redundancy-type;
    description "Redundancy type";
  }
}

grouping storage-unit-desc {
  description "Storage unit description";
  leaf storage-unit-id {
    type inet:uri;
    description "storage-unit ID";
  }
  uses storage-unit-specs;
  leaf location {
    type string;
    description "Location hint";
  }
}

grouping compute-unit-specs {
  description "Compute unit specs";
  leaf num-cores {
    type int8;
    description "Number of CPU Cores";
  }
  leaf ram {
    type int64;
    description "RAM in bytes";
  }
  leaf isolation-mode {
    type isolation-mode-type;
    description "isolation mode";
  }
}

grouping compute-unit-desc {
  description "Compute unit description";
  leaf compute-unit-id {
    type inet:uri;
    description "storage-unit ID";
  }
  uses compute-unit-specs;
  leaf location {
    type string;
    description "Location hint";
  }
}

grouping path-restrictions {
  description "Physical path restriction type: nodes and
  links of underlying networks
  that must or must not be traversed by a link";
  list mandatory-node {
    key "node-ref";
    description "List of mandatory nodes";
    leaf node-ref {
      type node-ref;
      description "Node";
    }
  }
  list mandatory-link {
    key "link-ref";
    description "List of mandatory links";
    leaf link-ref {
      type link-ref;
      description "Link";
    }
  }
  list excluded-node {
    key "node-ref";
    description "List of excluded nodes";
    leaf node-ref {
      type node-ref;
      description "Node";
    }
  }
  list excluded-link {
    key "link-ref";
    description "List of excluded links";
    leaf link-ref {
      type link-ref;
      description "Link";
    }
  }
}

grouping link-qos-desc {
  description "QoS associated with a link";
  leaf link-bandwidth-agreement {
    type int64;
    description "Link bandwidth agreement";
  }
  leaf link-throughput {
    type int64;
    description "Link throughput";
  }
  leaf link-throughput-threshold {
    type int64;
    description "Link throughput threshold";
  }
  leaf link-latency-agreement {
    type int64;
    description "Link latency agreement";
  }
  leaf link-latency {
    type int64;
    description "Link latency";
  }
  leaf link-jitter-agreement {
    type int64;
    description "Link jitter agreement";
  }
  leaf link-jitter {
    type int64;
    description "Link jitter";
  }
  leaf link-jitter-threshold {
    type int64;
    description "Link jitter threshold";
  }
  uses path-restrictions;
}

grouping slice-level-attributes {
  description "network slice level attributes";
  leaf service-time-start {
    type yang:date-and-time;
    description "Start of service";
  }
  leaf service-time-end {
    type yang:date-and-time;
    description "End of service";
  }
  leaf lifecycle-status {
    type lifecycle-status-type;
    description "Step in the slice lifecycle";
  }
  container access-control {
    uses rule;
    description "Control of access to operations per role";
  }
  leaf reliability-level {
    type reliability-level-type;
    description "Reliability level";
  }
  leaf resource-reservation-level {
    type resource-reservation-level-type;
    description "Resource reservation level";
  }
  leaf availability {
    type int64;
    description "Measure of probability to work with
    expected SLA (TBD: type should be expanded)";
  }
  leaf availability-threshold {
    type string;
    description "Availability threshold to actively
    notify the management system";
  }
}

grouping generalized-function-block {
  description "generalized function blocks that can be
  used to create an instance (more funcution blocks TBD)";

  container domain-agent {
    description "a network slice agent to receive manager request";
    leaf agent-name {
      type string;
      description "agent name";
    }
    leaf ip-address {
      type string;
      description "IP Address of the server (type TBD)";
    }
    leaf port {
      type string;
      description "Port of the server (type TBD)";
    }
  }
  container load-balancer {
    description "load balancer (type TBD)";
    leaf LB-name {
      type string;
      description "load balancer name";
    }
    leaf ip-address {
      type string;
      description "IP Address of the load balancer (type TBD)";
    }
    leaf port {
      type string;
      description "Port of the load balancer (type TBD)";
    }
  }

}

grouping service-instance-desc {
  description "Service instance description. An instance
  is based on a predefined function block";
  leaf service-instance-id {
    type inet:uri;
    description "service instance ID";
  }
  uses generalized-function-block;
}

/*
  Model
*/

augment "/nd:networks/nd:network" {
  description "Augment network nodes with slice information.";
  list compute-unit {
    key "compute-unit-id";
    description "Compute units";
    uses compute-unit-desc;
  }
  list storage-unit {
    key "storage-unit-id";
    description "Storage units";
    uses storage-unit-desc;
  }
  list service-instance {
    key "service-instance-id";
    description "Service instance";
    uses service-instance-desc;
  }
  container slice-level-attributes {
    description "Attributes that apply to a whole network slice";
    uses slice-level-attributes;
  }
}

augment "/nd:networks/nd:network/nd:node" {
  description "Augment network nodes with slice information.";
  list compute-unit {
    key "compute-unit-ref";
    description "List of compute units present in node";
    leaf compute-unit-ref {
      type compute-unit-ref;
      description "Compute unit present in node";
    }
  }
  list storage-unit {
    key "storage-unit-ref";
    description "List of storage units present in node";
    leaf storage-unit-ref {
      type storage-unit-ref;
      description "Storage unit present in node";
    }
  }
  list service-instance {
    key "service-instance-ref";
    description "an instance of a service provided by the node";
    leaf service-instance-ref {
      type service-instance-ref;
      description "Service instance present in node";
    }
  }
}

augment "/nd:networks/nd:network/nd:node/lnk:termination-point" {
  description "Augment network nodes termination points with
  port information.";
  uses port-config;
  uses port-stats;
}

augment "/nd:networks/nd:network/lnk:link" {
  description "Augment network links with slice information.";
  container link-qos {
    description "QoS specifications for this link";
    uses link-qos-desc;
  }
}
}