netconfcentral logo

ietf-coms-core

HTML

ietf-coms-core@2017-10-27



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

    }


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

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

    typedef lifecycle-status-type {
      type enumeration {
        enum "construction" {
          value 0;
          description "construction";
        }
        enum "modification" {
          value 1;
          description "modification";
        }
        enum "activation" {
          value 2;
          description "activation";
        }
        enum "deletion" {
          value 3;
          description "deletion";
        }
      }
      description "Lifecycle status";
    }

    typedef resource-reservation-level-type {
      type enumeration {
        enum "none" {
          value 0;
          description
            "No specific reliability requirement";
        }
        enum "shared-non-preemptive" {
          value 1;
          description
            "Each path has a backup path";
        }
        enum "shared-preemptive" {
          value 2;
          description
            "Each node/link has a backup node/link";
        }
        enum "exclusive" {
          value 3;
          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" {
          value 0;
          description
            "No specific reliability requirement";
        }
        enum "path-backup" {
          value 1;
          description
            "Each path has a backup path";
        }
        enum "logical-backup" {
          value 2;
          description
            "Each node/link has a backup node/link";
        }
        enum "physical-backup" {
          value 3;
          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" {
          value 0;
          description "no redundancy";
        }
        enum "n+1" {
          value 1;
          description
            "n storage units with one extra backup";
        }
        enum "2n" {
          value 2;
          description
            "each storage unit has one backup";
        }
        enum "2n+1" {
          value 3;
          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 rule

    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-config

    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 port-stats

    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-specs

    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 storage-unit-desc

    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-specs

    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 compute-unit-desc

    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-node

      list mandatory-link {
        key "link-ref";
        description
          "List of mandatory links";
        leaf link-ref {
          type link-ref;
          description "Link";
        }
      }  // list mandatory-link

      list excluded-node {
        key "node-ref";
        description "List of excluded nodes";
        leaf node-ref {
          type node-ref;
          description "Node";
        }
      }  // list excluded-node

      list excluded-link {
        key "link-ref";
        description "List of excluded links";
        leaf link-ref {
          type link-ref;
          description "Link";
        }
      }  // list excluded-link
    }  // grouping path-restrictions

    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 link-qos-desc

    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 {
        description
          "Control of access to operations per role";
        uses rule;
      }  // container access-control

      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 slice-level-attributes

    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 domain-agent

      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)";
        }
      }  // container load-balancer
    }  // grouping generalized-function-block

    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;
    }  // grouping service-instance-desc

    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 compute-unit

      list storage-unit {
        key "storage-unit-id";
        description "Storage units";
        uses storage-unit-desc;
      }  // list storage-unit

      list service-instance {
        key "service-instance-id";
        description "Service instance";
        uses service-instance-desc;
      }  // list service-instance

      container slice-level-attributes {
        description
          "Attributes that apply to a whole network slice";
        uses slice-level-attributes;
      }  // container 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 compute-unit

      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 storage-unit

      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";
        }
      }  // list service-instance
    }

    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;
      }  // container link-qos
    }
  }  // module ietf-coms-core

Summary

  
  
Organization IETF
  
Module ietf-coms-core
Version 2017-10-27
File ietf-coms-core@2017-10-27.yang
  
Prefix netslice
Namespace urn:ietf:params:xml:ns:yang:ietf-coms-core
  
Cooked /cookedmodules/ietf-coms-core/2017-10-27
YANG /src/ietf-coms-core@2017-10-27.yang
XSD /xsd/ietf-coms-core@2017-10-27.xsd
  
Abstract This module contains a collection of YANG definitions for COMS. Copyright (c) 2016 IETF Trust and the persons identified as aut...
  
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.

Typedefs

Typedef Base type Abstract
compute-unit-ref instance-identifier A reference to a compute unit
isolation-mode-type enumeration Isolation mode
lifecycle-status-type enumeration Lifecycle status
link-ref instance-identifier A reference to a link
node-ref instance-identifier A reference to a node
read-write-mode-type enumeration Indicates if entity is read-write, read-only, etc.
redundancy-type enumeration Redundancy type
reliability-level-type enumeration Reliability level
resource-reservation-level-type enumeration Resource reservation level
service-instance-ref instance-identifier A reference to a service instance
storage-unit-ref instance-identifier A reference to a storage unit

Groupings

Grouping Objects Abstract
compute-unit-desc compute-unit-id num-cores ram isolation-modelocation Compute unit description
compute-unit-specs num-cores ram isolation-mode Compute unit specs
generalized-function-block domain-agent load-balancer generalized function blocks that can be used to create an instance (more funcution blocks TBD)
link-qos-desc link-bandwidth-agreement link-throughput link-throughput-threshold link-latency-agreement link-latency link-jitter-agreement link-jitter link-jitter-threshold mandatory-node mandatory-link excluded-node excluded-link QoS associated with a link
path-restrictions mandatory-node mandatory-link excluded-node excluded-link Physical path restriction type: nodes and links of underlying networks that must or must not be traversed by a link
port-config packet-rate packet-loss-probability packet-loss-threshold Configuration of a port/connection point
port-stats received-packets sent-packets Statistics of a port/connection point
rule match action priority counter Access Control Rule
service-instance-desc service-instance-id domain-agent load-balancer Service instance description. An instance is based on a predefined function block
slice-level-attributes service-time-start service-time-end lifecycle-status access-control reliability-level resource-reservation-level availability availability-threshold network slice level attributes
storage-unit-desc storage-unit-id size isolation-mode read-write-mode-type redundancy-typelocation Storage unit description
storage-unit-specs size isolation-mode read-write-mode-type redundancy-type Storage unit specs