[groupbasedpolicy.git] / renderers / vpp / src / main / yang / vbd / v3po@2015-01-05.yang

module v3po {
  yang-version 1;
  namespace "urn:opendaylight:params:xml:ns:yang:v3po";
  prefix "v3po";

  revision "2015-01-05" {
    description "Initial revision of v3po model";
  }

  import iana-if-type {
    prefix "ianaift";
  }
  import ietf-interfaces {
    prefix "if";
  }
  import ietf-yang-types {
    prefix "yang";
  }
  import ietf-inet-types {
    prefix "inet";
  }
  import ietf-ip {
    prefix "ip";
  }
  import yang-ext {
    prefix "ext";
  }

  typedef bridge-domain-ref {
    type leafref {
      path "/vpp/bridge-domains/bridge-domain/name";
    }
    description
      "This type is used by to reference a bridge domain table";
  }

  typedef bridged-virtual-interface-ref {
    type leafref {
      path "/if:interfaces/if:interface/l2/bridged-virtual-interface";
    }
    description
      "This type is used by to reference a bridged virtual interface";
  }

  typedef vlan-type {
    type enumeration {
      enum 802dot1q;
      enum 802dot1ad;
    }
  }

  typedef tag-rewrite-operation {
    type enumeration {
      enum disabled;
      enum push-1;
      enum push-2;
      enum pop-1;
      enum pop-2;
      enum translate-1-to-1;
      enum translate-1-to-2;
      enum translate-2-to-1;
      enum translate-2-to-2;
    }
  }

  typedef vlan-tag {
    type uint16 {
      range "1..4094";
    }
  }

  identity vxlan-tunnel {
    base if:interface-type;
  }

  identity vhost-user {
    base if:interface-type;
  }

  identity tap {
    base if:interface-type;
  }

  identity sub-interface {
    base if:interface-type;
  }

  typedef vxlan-vni {
    // FIXME: should be in a vxlan-specific model
    description "VNI used in a VXLAN tunnel";
    type uint32 {
      range "0..16777215";
    }
  }

  typedef vhost-user-role {
    type enumeration {
      enum "server";
      enum "client";
    }
  }

  grouping bridge-domain-attributes {
    leaf flood {
      type boolean;
      default true;
      description
      "Enable/disable L2 flooding.";
    }
    leaf forward {
      type boolean;
      default true;
      description
      "Enable/disable L2 forwarding.";
    }
    leaf learn {
      type boolean;
      default true;
      description
      "Enable/disable L2 learning.";
    }
    leaf unknown-unicast-flood {
      type boolean;
      default true;
    }
    leaf arp-termination {
      type boolean;
      default false;
    }
  }

  grouping sub-interface-base-attributes {
    leaf identifier {
      type uint32;
    }
    leaf vlan-type {
      type vlan-type;
      default '802dot1q';
    }
    leaf number-of-tags {
      type uint8 {
        range "0..2";
      }
      default 1;
    }
    leaf outer-id {
      type vlan-tag;
    }
    leaf inner-id {
      type vlan-tag;
    }
    leaf match-any-outer-id {
      type empty;
    }
    leaf match-any-inner-id {
      type empty;
    }
    leaf exact-match {
      type empty;
    }
    leaf default-subif {
      type empty;
    }
  }

  grouping tap-interface-base-attributes {
    leaf tap-name {
      type string;
    }
  }

  grouping tap-interface-config-attributes {
    leaf mac {
      type yang:phys-address;
      mandatory false;
      description "Mac address to be set for the tap interface. Random will be used if not configured";
    }

    leaf device-instance {
      type uint32;
      mandatory false;
      description "Custom device instance. Autogenerated will be used if not configured";
    }
  }

  grouping vhost-user-interface-base-attributes {
    leaf socket {
      type string {
        length 1..255;
      }
    }
    leaf role {
      type vhost-user-role;
      default "server";
    }
  }

  grouping vhost-user-interface-state-attributes {
      leaf features {
        type uint64;
        config false;
      }
      leaf virtio-net-hdr-size {
        type uint32;
        config false;
      }
      leaf num-memory-regions {
        type uint32;
        config false;
      }
      leaf connect-error {
        type string;
        config false;
      }
  }

  grouping vlan-tag-rewrite-attributes {
    leaf rewrite-operation {
      type tag-rewrite-operation;
      default 'disabled';
    }
    leaf first-pushed {
      type vlan-type;
      default '802dot1q';
    }
    leaf tag1 {
      type vlan-tag;
    }
    leaf tag2 {
      type vlan-tag;
    }
  }

  augment /if:interfaces/if:interface {
    ext:augment-identifier "vpp-interface-augmentation";

    // FIXME using ietf-interfaces model for vpp interfaces makes it hard to implement because:
    // 1. The link between interface type and this augmentation is unclear
    // 2. Only this augmentation with combination of ifc type is trigger to do something for vpp, what if user only configures base interface stuff ? + We need to get leaves defined by ietf-interfaces when we are processing this augment

    container sub-interface {
      when "../if:type = 'v3po:sub-interface'";
      leaf super-interface {
        type if:interface-ref;
      }
      uses sub-interface-base-attributes;
    }

    container tap {
      when "../if:type = 'v3po:tap'";
      uses tap-interface-base-attributes;
      uses tap-interface-config-attributes;
    }

    container ethernet {
      when "../if:type = 'ianaift:ethernetCsmacd'";
      leaf mtu {
        type uint16 {
          range "64..9216";
        }
        units "octets";
        default 9216;
        description
        "The size, in octets, of the largest packet that the
         hardware interface will send and receive.";
      }
    }
    container routing {
      leaf vrf-id {
        type uint32;
        default 0;
      }
    }
    container vhost-user {
      when "../if:type = 'v3po:vhost-user'";
      uses vhost-user-interface-base-attributes;
      description "vhost-user settings";
    }
    container vxlan {
      // FIXME: this should be in an vxlan-specific extension
      when "../if:type = 'v3po:vxlan-tunnel'";

      leaf src {
        /*mandatory true;*/
        type inet:ip-address;
      }
      leaf dst {
        /*mandatory true;*/
        type inet:ip-address;
      }
      leaf vni {
        /*mandatory true;*/
        type vxlan-vni;
      }
      leaf encap-vrf-id {
        type uint32;
      }
    }
    container l2 {
      description
      "Parameters for configuring Layer2 features on interfaces.";
      must "(not (../if:ipv4[if:enabled = 'true']/if:address/if:ip) and " +
      "not (../if:ipv6[if:enabled = 'true']/if:address/if:ip))";

      choice interconnection {
        case xconnect-based {
          leaf xconnect-outgoing-interface {
            /* Don't allow selection of this interface */
            must "../../if:name != current()";
            type if:interface-ref;
            description
              "L2 xconnect mode";
          }
        }
        case bridge-based {
          leaf bridge-domain {
            type bridge-domain-ref;
            description
              "Interfaces in a bridge-domain forward packets to other
               interfaces in the same bridge-domain based on
               destination mac address.";
          }
          leaf split-horizon-group {
            when "../bridge-domain";
            type uint8 {
              range "0..255";
            }
            default 0;
            description
              "Interface's split-horizon group. Interfaces in the same
               bridge-domain and split-horizon group can not forward
               packets between each other. ";
          }
          leaf bridged-virtual-interface {
            when "../bridge-domain";
            type boolean;
            default false;
            description
              "Interface forward packets in the bridge-domain
               associated with the BVI.";
          }
        }
      }
      container vlan-tag-rewrite {
        uses vlan-tag-rewrite-attributes;
      }
    }
  }

  container vpp {
    description
    "VPP config data";

    container bridge-domains {
      list bridge-domain {
        key "name";
        // TODO: where does this come from?
        max-elements 1024;

        leaf name {
          type string;
        }

        uses bridge-domain-attributes;

        list l2-fib {
          key "phys-address";

          leaf phys-address {
            type yang:phys-address;
          }
          leaf action {
            type enumeration {
              enum "forward";
              enum "filter";
            }
            mandatory true;
          }
          leaf outgoing-interface {
            type if:interface-ref;
          }
        }
      }
    }
  }

  augment /if:interfaces-state/if:interface {
    ext:augment-identifier "vpp-interface-state-augmentation";

    leaf description {
      type string;
    }

    container sub-interface {
      when "../if:type = 'v3po:sub-interface'";
      leaf super-interface {
        type if:interface-state-ref;
      }
      uses sub-interface-base-attributes;
    }

    container tap {
      when "../if:type = 'v3po:tap'";
      uses tap-interface-base-attributes {
        refine tap-name {
            config false;
        }
      }
    }

    container ethernet {
      when "../if:type = 'ianaift:ethernetCsmacd'";
      leaf mtu {
        type uint16;
      }
      leaf manufacturer-description {
        type string;
      }
      leaf duplex {
        type enumeration {
          enum "half";
          enum "full";
        }
      }
    }
    container vhost-user {
      when "../if:type = 'v3po:vhost-user'";
      uses vhost-user-interface-base-attributes {
        refine socket {
            config false;
        }
        refine role {
            config false;
        }
      }
      uses vhost-user-interface-state-attributes;
    }
    container vxlan {
      when "../if:type = 'v3po:vxlan-tunnel'";

      leaf src {
        type inet:ip-address;
      }
      leaf dst {
        type inet:ip-address;
      }

      leaf vni {
        type uint32;
      }
      leaf encap-vrf-id {
        type uint32;
      }
    }
    container l2 {
      choice interconnection {
        case xconnect-based {
          leaf xconnect-outgoing-interface {
            type if:interface-ref;
          }
        }
        case bridge-based {
          leaf bridge-domain {
            type bridge-domain-ref;
          }
          leaf split-horizon-group {
            type uint8;
          }
          leaf bridged-virtual-interface {
            type boolean;
          }
        }
      }
      container vlan-tag-rewrite {
        uses vlan-tag-rewrite-attributes;
      }
    }
  }

  augment /if:interfaces-state/if:interface/if:statistics {
    ext:augment-identifier "vpp-interface-statistics-augmentation";
    leaf in-errors-no-buf {
      type yang:counter64;
    }
    leaf in-errors-miss {
      type yang:counter64;
    }
    leaf out-discards-fifo-full {
      type yang:counter64;
    }
  }

  container vpp-state {
    config false;

    description
      "VPP operational data";

    container bridge-domains {
      // FIXME: Should this live in bridge-domain.yang in a modular fashion ?
      list bridge-domain {

        key "name";
        leaf name {
          type string;
        }

        uses bridge-domain-attributes;

        list interface {
          key "name";

          leaf name {
            type if:interface-state-ref;
          }

          leaf split-horizon-group {
            type uint8;
          }

          leaf bridged-virtual-interface {
            type boolean;
          }
        }

        list l2-fib {
          key "phys-address";

          leaf phys-address {
            type yang:phys-address;
          }
          leaf static-config {
            type boolean;
          }
          leaf outgoing-interface {
            when "../v3po:action = 'forward'";
            type if:interface-state-ref;
          }
          leaf action {
            type enumeration {
              enum "forward";
              enum "filter";
            }
            mandatory true;
          }
          leaf bridged-virtual-interface {
            when "../v3po:action = 'forward'";
            type boolean;
          }
        }
        description
          "bridge-domain operational data";
      }
    }

    container version {
      leaf name {
        type string;
      }
      leaf build-directory {
        type string;
      }
      leaf build-date {
        type string;
      }
      leaf branch {
        type string;
      }
      description
      "vlib version info";
    }
  }
}