Updated flow capable models and affected code

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

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

    import ietf-inet-types {prefix inet;}
    import opendaylight-match-types {prefix match;}
    import ietf-yang-types {prefix yang;}
    import opendaylight-l2-types {prefix l2t;}

    revision "2013-10-26" {
        description "Initial revision of flow service";
    }
    
    
    typedef vlan-cfi {
           type int32;    
    }
    
    
    grouping action-list {
        list action {
            key "order";
            leaf order {
                type int32;
            }
            uses action;
        }
    }
    
    grouping address {
        choice address {
            case ipv4 {
                leaf ipv4-address {
                    type inet:ipv4-prefix;
                }
            }
            case ipv6 {
                leaf ipv6-address {
                    type inet:ipv6-prefix;
                }
            }
        }
    }    

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

    grouping instruction {
        choice instruction {
            case go-to-table {
                leaf table_id {
                    type uint8;
                }
            }
            
            case write-metadata {
                leaf metadata {
                    type uint64;
                }
                
                leaf metadata-mask {
                    type uint64;
                }
            }
            
            case write-actions {
                uses action-list;
            }
            
            case apply-actions {
                uses action-list;
            }
            
            case clear-actions {
                uses action-list;
            }
            
            case meter {
                leaf meter {
                    type string;
                }
            }   
        }
    }
    
    grouping action {
        choice action {
            case output-action {
                leaf-list output-node-connector {
                    type inet:uri;
                }
                
                leaf max-length {
                    type uint16 {
                        range "0..65294";
                    }
                }                
            }

            case controller-action {
                leaf max-length {
                    type uint16 {
                        range "0..65294";
                    }
                }
            }

            case set-queue-action {
                leaf queue {
                    type string; 
                }
            }

            case pop-mpls-action {
                leaf ethernet-type {
                    type uint16; // TODO: define ethertype type
                }
            }

            case set-mpls-ttl-action {
                leaf mpls-ttl {
                    type uint8;
                }
            }

            case set-nw-ttl-action {
                leaf nw-ttl {
                    type uint8;
                }
            }

            case push-pbb-action {
                leaf ethernet-type {
                    type uint16; // TODO: define ethertype type
                }
            }

            case pop-pbb-action {
                
            }
            
            case push-mpls-action {
                leaf ethernet-type {
                    type uint16; // TODO: define ethertype type
                }
            }
            
            case dec-mpls-ttl {
            }
            
            case dec-nw-ttl {
            }
            
            case drop-action {
            }
            
            case flood-action {
            }
            
            case flood-all-action {
            }
            
            case hw-path-action {
            }
            
            case loopback-action {
            }
            
            case pop-vlan-action {
            }
            
            case push-vlan-action {
                leaf tag {               // TPID - 16 bits
                    type int32;
                } 
                leaf pcp {               // PCP - 3 bits
                    type int32;
                }
                leaf cfi {               // CFI - 1 bit (drop eligible)
                    type vlan-cfi;
                }
                leaf vlan-id {           // VID - 12 bits
                    type l2t:vlan-id;
                }
//                leaf tci {               //TCI = [PCP + CFI + VID]
//                }
//                leaf header {            //header = [TPID + TCI] 
//                }
            }
            
            case copy-ttl-out {
            }
            
            case copy-ttl-in {
            }
            
            case set-dl-dst-action {
                leaf address {
                    type yang:mac-address;
                }
            }
            
            case set-dl-src-action {
                leaf address {
                    type yang:mac-address;
                }
            }
            case group-action {
                leaf group {
                    type string;
                }
            }
            
            case set-dl-type-action {
                leaf dl-type {
                    type l2t:ether-type;
                }
            }
            
            case set-next-hop-action {
                uses address;
            }
            
            case set-nw-dst-action {
                uses address;            
            }
            
            case set-nw-src-action{
                uses address;            
            }
            
            case set-nw-tos-action {
                leaf tos {
                    type int32;
                }
            }
            
            case set-tp-dst-action {
                leaf port {
                    type inet:port-number;
                }                
            }
            case set-tp-src-action {
                leaf port {
                    type inet:port-number;
                }                
            }
            case set-vlan-cfi-action {
                leaf vlan-cfi {
                    type vlan-cfi;
                }
            }
            
            case set-vlan-id-action {
                leaf vlan-id {
                    type l2t:vlan-id;
                } 
            }
            
            case set-vlan-pcp-action {
                leaf vlan-pcp {
                    type l2t:vlan-pcp;
                }            
            }
            
            case sw-path-action {            
            }  
        }
    }

    typedef flow-mod-flags {
        type bits {
            bit CHECK_OVERLAP;
            bit RESET_COUNTS;
            bit NO_PKT_COUNTS;
            bit NO_BYT_COUNTS;
        }
    }
    
    grouping flow {
        container match {
            uses match:match;
        }
        
        container instructions {
            uses instruction-list;
        }
                
        leaf priority {
            type uint16;
        }
        
        leaf idle-timeout {
            type uint16;
        }
        
        leaf hard-timeout {
            type uint16;
        }
        
        leaf cookie {
            type uint64;
        }
        
        leaf container-name {
            type string; 
        }
        
        leaf cookie_mask {
            type uint8;
        }
        
        leaf table_id {
            type uint8;
        }
        
        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;
        }
    }

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