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";
  }
  import vpp-classifier {
    prefix "vpp-classifier";
  }
  import ietf-access-control-list {
    prefix "acl";
  }

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

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

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

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

  identity tap {
    base if:interface-type;
  }

  identity l2-fib-action {
    description "Base identity for l2-fib actions";
  }

  identity l2-fib-forward {
    base l2-fib-action;
    description
      "Forwards packet with configured mac address";
  }

  identity l2-fib-filter {
    base l2-fib-action;
    description
      "Drops packet with configured mac address";
  }

  typedef l2-fib-action {
    type identityref {
      base "l2-fib-action";
    }
    description "Identifies a specific L2 FIB action";
  }

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

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

  typedef vxlan-gpe-vni {
    description "VNI used in a VXLAN-GPE tunnel";
    type uint32 {
      range "0..16777215";
    }
  }

  typedef vxlan-gpe-next-protocol {
    type enumeration {
      enum "ipv4" {
        value 1;
      }
      enum "ipv6" {
        value 2;
      }
      enum "ethernet" {
        value 3;
      }
      enum "nsh" {
        value 4;
      }
    }
  }

  typedef interface-mode {
    type enumeration {
      enum "l2";
      enum "l3";
    }
  }

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

    container arp-termination-table {
      when "../v3po:arp-termination = 'true'";

      // TODO(HONEYCOMB-133): add support for read (after VPP-230 is done)
      list arp-termination-table-entry {
        key "ip-address phys-address";
        leaf ip-address {
          // FIXME: change to ip-address-no-zone after https://bugs.opendaylight.org/show_bug.cgi?id=6413 is resolved
          type inet:ip-address;
        }
        leaf phys-address {
          type yang:phys-address;
        }
      }
    }
  }

  // TODO express constraints for L2 FIB entries in YANG if possible
  grouping l2-fib-attributes {
    container l2-fib-table {
      list l2-fib-entry {
        key "phys-address";

        leaf phys-address {
          type yang:phys-address;
        }

        leaf outgoing-interface {
          type string;
          // mandatory true;
          // mandatory for forward action
          // FIXME VPP's CLI does not require to set iface id for filter action
          // VPP's binary api in constrast to CLI does some checks on the iface id value,
          // so currently it has to be set for all actions
          description
            "One of interfaces assigned to the FIB table's bridge-domain.";
        }
        leaf static-config {
          type boolean;
          default false;
          description
            "Static entries cannot be overridden by mac learning.";
        }
        leaf action {
          type l2-fib-action;
          mandatory true;
          description
            "L2 FIB action. For filter action, entry must be configured as static.";
        }
        leaf bridged-virtual-interface {
          when "../action = 'forward'";
          type boolean;
          config false; // FIXME setting bvi is currently not supported by VPP's binary api
        }
      }
    }
  }

  grouping tap-interface-base-attributes {
    leaf tap-name {
      type string{
        pattern "[a-zA-Z0-9\-;.+@$#^&*!_()=\[\]]*";
      }
    }
  }

  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 ethernet-base-attributes {
    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.";
    }
  }

  grouping ethernet-state-attributes {
    leaf manufacturer-description {
      type string;
      config false;
    }
    leaf duplex {
      type enumeration {
        enum "half";
        enum "full";
      }
      config false;
    }
  }

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

  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 vxlan-base-attributes {
    // FIXME: this should be in an vxlan-specific extension
    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;
    }
  }

  grouping gre-base-attributes {
    leaf src {
      /*mandatory true;*/
      type inet:ip-address;
    }
    leaf dst {
      /*mandatory true;*/
      type inet:ip-address;
    }
    leaf outer-fib-id {
      type uint32;
    }
  }

  grouping vxlan-gpe-base-attributes {
    leaf local {
      /*mandatory true;*/
      type inet:ip-address;
    }
    leaf remote {
      /*mandatory true;*/
      type inet:ip-address;
    }
    leaf vni {
      /*mandatory true;*/
      type vxlan-gpe-vni;
    }
    leaf next-protocol {
      type vxlan-gpe-next-protocol;
    }
    leaf encap-vrf-id {
      type uint32;
    }
    leaf decap-vrf-id {
      type uint32;
    }
  }

  grouping l2-base-attributes {
      description
      "Parameters for configuring Layer2 features on interfaces.";

      choice interconnection {
        case xconnect-based {
          leaf xconnect-outgoing-interface {
            /* Don't allow selection of this interface */
            must "../../if:name != current()";
            type if:interface-ref; // todo use interface-state-ref for operational data?
            description
              "L2 xconnect mode";
          }
        }
        case bridge-based {
          leaf bridge-domain {
            type bridge-domain-ref;
            mandatory true;
            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; //no split horizon group
            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.";
          }
        }
      }
  }

  grouping proxy-arp-attributes {
        description
        "Parameters for configuring Proxy ARP on interfaces.";

      leaf vrf-id {
        type uint32;
        default 0;
      }
      leaf low-addr {
          type inet:ipv4-address;
      }
      leaf high-addr {
          type inet:ipv4-address;
      }
  }

  grouping acl-base-attributes {
    description
      "Defines references to classify tables.
       At least one table reference should be specified.";
    container l2-acl {
      leaf classify-table {
        type vpp-classifier:classify-table-ref;
        description
          "An L2 ACL table";
      }
    }
    container ip4-acl {
      leaf classify-table {
        type vpp-classifier:classify-table-ref;
        description
          "An IPv4 ACL table";
      }
    }
    container ip6-acl {
      leaf classify-table {
        type vpp-classifier:classify-table-ref;
        description
          "An IPv6 ACL table";
      }
    }
  }

  grouping ietf-acl-base-attributes {
    description
      "Provides limited support for ietf-acl model.";

    container access-lists {
      description
        "Defines references to ietf-acl lists. Before assignment to interface,
        ACL lists are merged into 3 type of acls (eth0, ip4 and ip6) that are supported by vpp.
        Then corresponding tables and sessions are created and assigned to the interface.

        All ACEs for all assigned ACLs have to use the same packet-handling action (either deny or parmit).

        Assignment update/delete removes all created tables and sessions and repeats process described above.
        Update/delete of ACL lists referenced here is not permitted (assignment needs to be removed first).

        Read is supported only for acls that were created and assigned by Honeycomb agent
        (corresponding metadata are present).

        Limitations (due to vpp limitations):
        - egress rules are currently ignored (HONEYCOMB-234)
        - L4 rules are currently not supported (limited support will by provided by HONEYCOMB-218)
        - mixing L2/L3/L4 rules is currently not supported (limited support will by provided by HONEYCOMB-233)
        - L2 only rules on L3 interfaces are not supported (not allowed by vpp,
          in the future defining L2/L3 pairs should be partially supported)
        - vlan tags are supported only for sub-interfaces defined as exact-match";
      list acl {
        key "type name";

        leaf type {
          type acl:acl-type;
        }

        leaf name {
          type acl:access-control-list-ref;
        }
      }

      leaf mode {
        type interface-mode;
        default l3;
        description
          "The way ACLs are translated depends on the interface mode.
           In case of L2 interfaces (bridge/interconnection)
           classify tables are assigned as l2_table using input_acl_set_interface (ether type matching is automatically
           added in case of L3 rules).
           In case of L3 interfaces, classify tables are assigned as ip4/ip6 tables.

           It is the user responsibility to choose mode that matches target interface.
           ";
      }
    }
  }

  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
    // 3. The ietf-interfaces model does not define groupings which makes types reuse difficult

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

    container ethernet {
      when "../if:type = 'ianaift:ethernetCsmacd'";
      uses ethernet-base-attributes;
    }

    container routing {
      leaf vrf-id { // todo no routing info for oper, is it possible to get it from the vpp?
        type uint32;
        default 0;
      }
    }

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

    container vxlan {
      when "../if:type = 'v3po:vxlan-tunnel'";
      uses vxlan-base-attributes;
    }

    container gre {
      when "../if:type = 'v3po:gre-tunnel'";
      uses gre-base-attributes;
    }

    container l2 {
      must "(not (../if:ipv4[if:enabled = 'true']/if:address/if:ip) and " +
      "not (../if:ipv6[if:enabled = 'true']/if:address/if:ip))";

      uses l2-base-attributes;
    }

    container vxlan-gpe {
      when "../if:type = 'v3po:vxlan-gpe-tunnel'";

      uses vxlan-gpe-base-attributes;
    }

    container proxy-arp {
      uses proxy-arp-attributes;
    }

    container acl {
      container ingress {
        uses acl-base-attributes;
      }
      container egress {
        uses acl-base-attributes;
      }
    }

    container ietf-acl {
      container ingress {
        uses ietf-acl-base-attributes;
      }
      container egress {
        uses ietf-acl-base-attributes;
      }
    }
  }

  container vpp {
    description
    "VPP config data";

    container bridge-domains {
      list bridge-domain {
        key "name";

        leaf name {
          type string;
        }

        uses bridge-domain-attributes;
        uses l2-fib-attributes;

        description
          "bridge-domain configuration";
      }
    }
  }

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

    leaf description {
      type string;
    }

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

    container ethernet {
      when "../if:type = 'ianaift:ethernetCsmacd'";
      uses ethernet-base-attributes;
      uses ethernet-state-attributes;
    }

    container vhost-user {
      when "../if:type = 'v3po:vhost-user'";
      uses vhost-user-interface-base-attributes;
      uses vhost-user-interface-state-attributes;
    }

    container vxlan {
      when "../if:type = 'v3po:vxlan-tunnel'";
      uses vxlan-base-attributes;
    }
    container vxlan-gpe {
      when "../if:type = 'v3po:vxlan-gpe-tunnel'";

      uses vxlan-gpe-base-attributes;
    }

    container gre {
      when "../if:type = 'gre-tunnel'";
      uses gre-base-attributes;
    }

    container l2 {
      must "(not (../if:ipv4[if:enabled = 'true']/if:address/if:ip) and " +
      "not (../if:ipv6[if:enabled = 'true']/if:address/if:ip))";

      uses l2-base-attributes;
    }

    container proxy-arp {
      uses proxy-arp-attributes;
    }

    container acl {
      container ingress {
        uses acl-base-attributes;
      }
      container egress {
        uses acl-base-attributes;
      }
    }

    container ietf-acl {
      container ingress {
        uses ietf-acl-base-attributes;
      }
      container egress {
        uses ietf-acl-base-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;
        uses l2-fib-attributes;

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

  // VPP Notifications

  typedef interface-status {
    type enumeration {
      enum up {
        value 1;
      }
      enum down {
        value 0;
      }
    }
  }

  typedef interface-name-or-index {
    type union {
      type string;
      type uint32;
    }
  }

  notification interface-state-change {
    leaf name {
        type interface-name-or-index;
    }

    leaf admin-status {
        type interface-status;
    }

    leaf oper-status {
        type interface-status;
    }
  }

  notification interface-deleted {
    leaf name {
        type interface-name-or-index;
    }
  }
}