opendaylight/sal/yang-prototype/sal/model/model-flow-base/src/main/yang/group-types.yang

   1 module opendaylight-group-types {
   2     namespace "urn:opendaylight:group:types";
   3     prefix group;
   4
   5     import ietf-inet-types {prefix inet;}
   6     import ietf-yang-types {prefix yang;}
   7         import opendaylight-flow-types {prefix flow-types;}
   8
   9     revision "2013-09-17" {
  10         description "Initial revision of group service";
  11     }
  12
  13         typedef group-ref {
  14                 type instance-identifier;
  15         }
  16
  17         grouping group-types {
  18                 leaf group-type {
  19                         type enumeration {
  20                                 enum group-all;
  21                                 enum group_select;
  22                                 enum group_indirect;
  23                                 enum group_ff;
  24                         }
  25                 }
  26         }
  27
  28         grouping group {
  29
  30         uses group-types;
  31
  32                 leaf group-id {
  33             type group-ref;
  34         }
  35
  36                 container buckets {
  37                         list bucket {
  38                                 key "order";
  39                                 leaf order {
  40                                         type int32;
  41                                 }
  42
  43                                 leaf weight {
  44                                         type uint16;
  45                                 }
  46
  47                                 leaf watch_port {
  48                                         type uint32;
  49                                 }
  50
  51                                 leaf watch_group {
  52                                         type uint32;
  53                                 }
  54
  55                                 container actions {
  56                                         list action {
  57                                                 key "action-order";
  58                                                 leaf action-order {
  59                                                         type int32;
  60                                                 }
  61
  62                                                 uses flow-types:action;
  63                                         }
  64                                 }
  65                         }
  66                 }
  67     }
  68
  69         grouping group-statistics-request {
  70                 list group-stats {
  71                         key "group-id";
  72
  73                         leaf group-id {
  74                                 type int32;
  75                         }
  76                 }
  77         }
  78
  79         grouping group-statistics {
  80
  81                 leaf group-id {
  82             type int32;
  83                 }
  84
  85             leaf ref-count {
  86             type yang:counter32;
  87                 }
  88
  89                 leaf packet-count {
  90             type yang:counter64;
  91         }
  92
  93         leaf byte-count {
  94             type yang:counter64;
  95         }
  96
  97         container duration {
  98             leaf second {
  99                 type yang:counter32;
 100             }
 101             leaf nanosecond {
 102                 type yang:counter32;
 103             }
 104         }
 105
 106                 container buckets {
 107                         list bucket-counter {
 108                                 key "order";
 109                                 leaf order {
 110                                         type int32;
 111                                 }
 112
 113                                 leaf packet-count {
 114                                         type yang:counter64;
 115                                 }
 116
 117                                 leaf byte-count {
 118                                         type yang:counter64;
 119                                 }
 120                         }
 121                 }
 122     }
 123
 124         grouping group-statistics-reply {
 125                 list group-stats {
 126                         key "group-stats-order";
 127                         leaf group-stats-order {
 128                                 type int32;
 129                         }
 130
 131                         uses group-statistics;
 132                 }
 133         }
 134
 135         grouping group-desc-stats {
 136                 list group-desc-stats {
 137                         key "order-id";
 138
 139                         leaf order-id {
 140                                 type int32;
 141                         }
 142
 143                         uses group;
 144                 }
 145         }
 146
 147     grouping group-features {
 148                 list group-features {
 149                         key "order";
 150                         leaf order {
 151                                 type int32;
 152                         }
 153
 154                         uses group-types;
 155                         type capabilities {
 156                                 enum select-weight;
 157                                 enum select-liveness;
 158                                 enum chaining;
 159                                 enum chaining-checks;
 160                         }
 161
 162                         leaf-list max-groups {
 163                                 type uint32;
 164                                 description "Maximum number of groups for each type";
 165                                 max-elements 4;
 166                         }
 167
 168                         leaf-list actions {
 169                                 type uint32;
 170                                 description "Bitmap number OFPAT_* that are supported";
 171                                 max-elements 4;
 172                         }
 173                 }
 174         }
 175 }