dell-base-l2-mac.yang

module dell-base-l2-mac {

    namespace "http://www.dellemc.com/networking/os10/dell-base-l2-mac";
    prefix "base-mac";


    import dell-base-common {
        prefix "base-cmn";
    }

  import dell-base-interface-common { prefix "base-if"; }

    organization
        "Dell EMC";

    contact
        "http://www.dell.com/support";

    description
        "This module contains a collection of YANG definitions provided
         by OS10 base for managing MAC objects.This model is used to implement
         show/clear MAC address-table.

         Copyright(c) 2015-2018 by Dell EMC,
         All rights reserved.";

    revision "2018-11-19"{
        description "Add age-out-disable flag for MAC entry configuration." ;
        reference "Network Platform Abstraction";
    }
    revision "2018-09-12"{
        description "Add enum to support MAC address flush on a port
                     based on port and bridge.";
        reference "Network Platform Abstraction";
    }

    revision "2018-05-20" {
        description "Fixing pyang IETF errors and adding documentiation to the model.";
        reference "Network Platform Abstraction";
    }

    revision "2018-05-01"{
        description "Add enums to support MAC address flush for peer IP for all bridges and
                     port VLAN subport";
        reference "Network Platform Abstraction";
    }

    revision "2018-01-09" {
        description "Added endpoint-event container to publish an event when endpoint is
                     being added or deleted";
        reference "Network Platform Abstraction";
    }

    revision "2017-10-10" {
        description "Add forwarding table object. Add endpoint-ip, br-name attributes
                     to support MAC addresses learned from remote endpoint";
        reference "Network Platform Abstraction";
    }

    revision 2015-10-30 {
        description
            "Removed switch-id from key, updated some description";
        reference "Network Platform Abstraction";
    }

    revision 2015-05-13 {
        description
            "Updated key, added command request type, added source drop packet action";
        reference "Network Platform Abstraction";
    }

    revision 2014-12-31 {
        description
            "Initial revision";
        reference "Network Platform Abstraction";
    }
    typedef packet-action {

        type enumeration {
            enum DROP {
                value 1;
                description
                    "Do not forward, drop the packet if this entry is hit";
            }
            enum FORWARD {
                value 2;
                description
                    "Forward the packet if this entry is hit";
            }
            enum TRAP {
                value 3;
                description
                    "Copy the packet to CPU if this entry is hit";
            }
            enum LOG {
                value 4;
                description
                    "Forward the packet and copy to the CPU
                    if this entry is hit";
            }
            enum SOURCE_DROP {
                value 5;
                description
                    "Discard the packet if incoming source matches this entry";
            }
        }
        description "Enumeration of all possible actions to be performed on the matched packets";
    }

    typedef command-request-type {

        type enumeration {
            enum CMD_TYPE_VLAN {
                value 1;
                description
                    "vlan specific command request";
            }
            enum CMD_TYPE_ADDRESS {
                value 2;
                description
                    "mac address specific command request";
            }
            enum CMD_TYPE_INTERFACE {
                value 3;
                description
                    "interface specific command request";
            }
            enum CMD_TYPE_COUNT {
                value 4;
                description
                    "command request based on count option";
            }
            enum CMD_TYPE_ALL {
                value 5;
                description
                    "command request for all details";
            }
        }
        description "Enumeration of all possible request-type(s) to be used for 'show mac address-table'";
    }

     typedef mac-event-type {

        type enumeration {
            enum learnt {
                value 1;
                description
                    "MAC address entry was learnt in npu";
            }
            enum aged {
                value 2;
                description
                    "MAC address entry was aged out in npu";
            }
            enum flushed {
                value 3;
                description
                    "MAC address entry was deleted in npu";
            }
            enum moved {
            	value 4;
            	description
            		"MAC address entry was moved";
    		}
        }
        description "Enumeration of all possible states of an entry in the MAC address-table";
    }


    typedef mac-flush-type {

        type enumeration {
            enum port {
                value 1;
                description
                    "MAC address flush on the port";
            }
            enum vlan-port {
                value 2;
                description
                    "MAC address flush on the given vlan port combination.
                     This flush type is for port which is part of 1q VLAN";
            }
            enum vlan {
                value 3;
                description
                    "MAC address flush on the given vlan";
            }
            enum all {
            	value 4;
            	description
            		"MAC address flush on all vlan/ports";
    		}
    		
            enum bridge {
               value 5;
                description
                    "MAC address flush on the given bridge";
            }

            enum bridge-endpoint-ip {
                value 6;
                description
                    "MAC address flush on the given bridge and
                     endpoint ip address combination";
            }

            enum endpoint-ip {
                value 7;
                description
                    "MAC address flush on the given
                     endpoint ip address from all bridge where
                     given ip is an overlay endpoint for the bridge";
            }

            enum vlan-port-subport {
                value 8;
                description
                    "MAC address flush on the given subport which
                     is a combination of VLAN id and port. This
                     flush type is for port-vlan combination which is
                     a subport of VLAN unaware(1d) bridge";
            }

            enum bridge-port {
                value 9;
                description
                    "MAC address flush on the given port which
                     is a combination of bridge and port. This
                     flush type is for untagged port which is
                     a subport of VLAN unaware(1d) bridge";
            }
        }
        description "Enumeration of all possible ways to clear MAC address-table";
    }

    grouping entry {

        leaf switch-id {
            type base-cmn:logical-switch-id;
            status obsolete;
            description
                "Logical Switch to which this MAC entry belongs to";
        }

        leaf-list npu-id {
            type base-cmn:npu-id;
            description
                "Optional subset of NPUs on which this MAC entry needs to be programmed.
                If this attribute is not specified then the MAC entry will be created in all the NPUs
                in the Logical switch to which the Entry belongs.";
        }

        leaf vlan {
            type base-cmn:vlan-id;
            description
            	"VLAN ID to which MAC address entry belongs to in VLAN aware flooding domain.
            	 For VLAN unaware flooding domain it is the vlan id of tagged access port";
        }

        leaf ifindex {
            type base-cmn:logical-ifindex;
            description
                "System wide unique identifier of the interface
                associated with this MAC entry.  This will be the physical port or LAG ifindex";
        }

      	leaf ifname {
            type string;
            description
                "Interface name associated with this MAC entry";
        }

        leaf mac-address {
            type base-cmn:mac-address;
            description
                "MAC Address configured with this entry";
        }

        leaf static {
            type boolean;
            description
                "Whether the MAC entry is configured as static. It will not age out";
        }

        leaf age-out-disable {
            type boolean;
            default false;
            description
                "The MAC entry is configured with age out disabled in the kernel. MAC move is allowed.";
        }

        leaf actions {
            type packet-action;
            description
                "Action for packet when this MAC entry is hit";
        }

        leaf configure-os{
            type boolean;
            default false;
            description
                "If this entry needs to be configured in the OS";
        }

        leaf configure-npu{
            type boolean;
            default true;
            description
                "If this entry needs to be configured in the npu. Default behaviour is to
                 configure it in the NPU";
        }

        leaf event-type{
            type mac-event-type;
            config false;
            description
                "When entry is published it will be published with the event type like learnt, aged, flushed";
    	}

        leaf publish{
            type boolean;
            default false;
            description
                "When entry is programmed by application in npu, if entry needs to be published";
        }

        container endpoint-ip {
            uses base-cmn:ip;
            description
                "Endpoint IP address for MAC address entries learned on remote endpoints";
        }

        leaf br-name{
            type string;
            description
                "Bridge name where MAC address entry belongs.";
         }
        description "This list defines MAC entry";

    }

    list table {
            // QUALIFIER : Target
            key "vlan mac-address";

            uses entry;
            description
                "MAC address table list for VLAN aware flooding domain.
                 Each entry is uniquely identified by VLAN/MAC address combination within
                 a switch domain";
    }

    list forwarding-table {
            // QUALIFIER : Target
            key "br-name mac-address";

            uses entry;
            description
                "MAC address table for VLAN unaware flooding domain.
                 Each entry is uniquely identified by Bridge name/MAC address
                 combination within a switch domain";
    }

    list query {
            // QUALIFIER : Target
            key "vlan mac-address";

            uses entry;

            leaf request-type {
                type command-request-type;
                description
                    "Command request type for data retrieval";
            }

            leaf count {
                type uint32;
                description
                    "Count based on command request type";
            }
            description
                "MAC entry specific query list";
    }

    container flush-management{
        // QUALIFIER : Target

        leaf enable{
            type boolean;
            default true;
            description "To enable/disable auto flush of mac entries when
            interface state changes";
        }
        description "To manage mac flush when interface status changes";
    }

    container list{
        // QUALIFIER : Target
        list entries{
                key "br-name mac-address";
                uses entry;
                description "List of MAC entries to be published when event occurs in NPU.
                             This will be published as a list.";
        }
        description "This container holds the entries list.";
    }
	
    grouping flush{
        leaf vlan {
            type base-cmn:vlan-id;
            description "Vlan ID where mac flush is to be done";
        }

        leaf ifindex {
            type base-cmn:logical-ifindex;
            description
                  "System wide unique identifier of the interface
                       where MAC flush is to be done.";
        }

        leaf ifname {
            type string;
            description
                "Interface name associated with this MAC entry";
        }

        leaf br-name {
            type string;
            description
                "Bridge interface name to which MAC address entry belongs to";
        }	        	

        container endpoint-ip {
            uses base-cmn:ip;
            description
                "Endpoint IP address for MAC address entries learned on remote endpoints";
        }	

        leaf all {
            type boolean;
            default false;
            description
                "By default only dynamic entries will be flushed. It this
                 option is set then static and dynamic shall be flushed.";
        }

        leaf flush-type{
    		type mac-flush-type;
        	description
        		"Type of the mac flush";
		}
        description "This grouping is to define the mac flush attributes";
    }
		
		
    container flush-event{
     	config false;
        list filter{
        	uses flush;
        	
        	leaf-list member-ifindex{
                    type base-cmn:logical-ifindex;
                    description "leaf list of member interface indexes which were affected by the flush";
                }	
                description "List of MAC address-table flush events";
    	}
        description "MAC flush events to be published. This object is used only for publishing
                     events.";
        	
    }

    rpc flush {
    description "Flush the MAC addresses learned on flooding domain,interface,
                 flooding domain/interface, interface/remote ip ";

    // ATTRIBUTE PATH  : base-mac/flush
    // ==============
    //
    // QUALIFIER       : Target
    // =========
    //
    // INPUT           : base-mac/flush/input/fliter (filter parameters chosen from the group 'flush')
    // =====
    //
    // OUTPUT          : None
    // ======

    input {
        list filter {
                description "Flush input parameters which may include flooding domain name,
                         interface name, flooding domain/interface name,
                         interface/remote ip";
        	uses flush;	
            }
        }
    }

    container tunnel-endpoint-event{
        // QUALIFIER : Target

        container ip{
            uses base-cmn:ip;
            description
                "IP address of the endpoint tunnel being added or deleted.";
        }

        leaf interface-name{
            type string;
            description
                "Interface name of tunnel endpoint.";
        }

        leaf flooding-enable{
            type boolean;
            default false;
            description
                "Enable flooding to this tunnel endpoint.";
        }
        description "Event to be published when a new tunnel endpoint is being added or existing is
                     being deleted.";

    }
}