Adding Enum for Output -Port Values

[controller.git] / opendaylight / md-sal / model / model-flow-base / src / main / yang / opendaylight-flow-types.yang

module opendaylight-flow-types {
    namespace "urn:opendaylight:flow:types";
    prefix flow;

    import ietf-inet-types {prefix inet; revision-date "2010-09-24";}
    import ietf-yang-types {prefix yang; revision-date "2010-09-24";}    
    import opendaylight-match-types {prefix match; revision-date "2013-10-26";}
    import opendaylight-action-types {prefix action;}
    import opendaylight-meter-types {prefix meter; revision-date "2013-09-18";}

    revision "2013-10-26" {
        description "Initial revision of flow service";
    }
    
    typedef table-id {
        type uint8;
    }
    typedef output-port-values {
        type enumeration {
            enum MAX {
                value 1;
            }
            enum IN_PORT {
                value 2;
            }
            enum TABLE {
                value 3;
            }
            enum NORMAL {
                value 4;
            }
            enum FLOOD {
                value 5;
            }
            enum ALL {
                value 6;
            }
            enum CONTROLLER {
                value 7;
            }
            enum LOCAL {
                value 8;
            }
            enum ANY {
                value 9;
            }
             enum NONE {
                value 10;
            }

        }
    }
    grouping instruction-list {
        list instruction {
            key "order";
            leaf order {
                type int32;
            }
            uses instruction;
        }
    }

     grouping instruction {
         choice instruction {
            case go-to-table-case {
                container go-to-table {
                 leaf table_id {
                     type uint8;
                 }
             }
            }
             
            case write-metadata-case {
                container write-metadata {
                 leaf metadata {
                     type uint64;
                 }
                 
                 leaf metadata-mask {
                     type uint64;
                 }
             }
            }
             
            case write-actions-case {
                container write-actions {
                 uses action:action-list;
             }
            }
             
            case apply-actions-case {
                container apply-actions {
                 uses action:action-list;
             }
            }
             
            case clear-actions-case {
                container clear-actions {
                 uses action:action-list;
             }
            }
             
            case meter-case {
                container meter {
                     leaf meter-id {
                        type meter:meter-id;
                     } 
                 }
             }
         }
    }
    
    typedef flow-mod-flags {
        type bits {
            bit CHECK_OVERLAP;
            bit RESET_COUNTS;
            bit NO_PKT_COUNTS;
            bit NO_BYT_COUNTS;
            bit SEND_FLOW_REM;
        }
    }

    typedef removed_reason_flags {
        type bits {
            bit IDLE_TIMEOUT;
            bit HARD_TIMEOUT;
            bit DELETE;
            bit GROUP_DELETE;
        }
    }
    
    grouping generic_flow_attributes {
        leaf priority {
            type uint16;
        }
        
        leaf idle-timeout {
            type uint16;
        }
        
        leaf hard-timeout {
            type uint16;
        }
        
        leaf cookie {
            type uint64;
        }
        
        leaf table_id {
            type uint8;
        }
    }
    
    grouping flow {
        container match {
            uses match:match;
        }
        
        container instructions {
            uses instruction-list;
        }          
         
        uses generic_flow_attributes;
        
        leaf container-name {
            type string; 
        }
        
        leaf cookie_mask {
            type uint64;
        }
        
        leaf buffer_id {
            type uint32;
        }
        
        leaf out_port {
            type uint64;
        }
        
        leaf out_group {
            type uint32;
        }
        
        leaf flags {
            type flow-mod-flags;
        }
        
        leaf flow-name {
            type string;
        }
        
        leaf installHw {
            type boolean;
        }

        leaf barrier {
            type boolean;
        }

        leaf strict {
            type boolean;
            default "false";
        }

    }

    grouping flow-statistics {
        leaf packet-count {
            type yang:counter64;
        }

        leaf byte-count {
            type yang:counter64;
        }

        container duration {
            leaf second {
                type yang:counter64;
            }
            leaf nanosecond {
                type yang:counter64;
            }
        }
    }

    grouping flow-table-statistics {
        leaf active {
            type yang:counter64;
        } 

        leaf lookup {
            type yang:counter64;
        }

        leaf matched {
            type yang:counter64;   
        }
    }
    
    grouping flow-mod-removed {
        uses generic_flow_attributes;
        
        leaf removed_reason {
            type removed_reason_flags;
        }

        leaf duration_nsec {
            type uint32;
        }
        
        leaf duration_sec {
            type uint32;
        }

        leaf packet_count {
            type uint64;
        }

        leaf byte_count {
            type uint64;
        }
                
        container match {
            uses match:match;
        }
    }
}