OpenFlow v1.3 Messages and Structures

Controller-to-Switch Messages

Handshake

class ryu.ofproto.ofproto_v1_3_parser.OFPFeaturesRequest(datapath)

Features request message

The controller sends a feature request to the switch upon session establishment.

This message is handled by the Ryu framework, so the Ryu application do not need to process this typically.

Example:

def send_features_request(self, datapath):
    ofp_parser = datapath.ofproto_parser

    req = ofp_parser.OFPFeaturesRequest(datapath)
    datapath.send_msg(req)

JSON Example:

{
   "OFPFeaturesRequest": {}
}
class ryu.ofproto.ofproto_v1_3_parser.OFPSwitchFeatures(datapath, datapath_id=None, n_buffers=None, n_tables=None, auxiliary_id=None, capabilities=None)

Features reply message

The switch responds with a features reply message to a features request.

This message is handled by the Ryu framework, so the Ryu application do not need to process this typically.

Example:

@set_ev_cls(ofp_event.EventOFPSwitchFeatures, CONFIG_DISPATCHER)
def switch_features_handler(self, ev):
    msg = ev.msg

    self.logger.debug('OFPSwitchFeatures received: '
                      'datapath_id=0x%016x n_buffers=%d '
                      'n_tables=%d auxiliary_id=%d '
                      'capabilities=0x%08x',
                      msg.datapath_id, msg.n_buffers, msg.n_tables,
                      msg.auxiliary_id, msg.capabilities)

JSON Example:

{
   "OFPSwitchFeatures": {
      "auxiliary_id": 99, 
      "capabilities": 79, 
      "datapath_id": 9210263729383, 
      "n_buffers": 0, 
      "n_tables": 255
   }
}

Switch Configuration

class ryu.ofproto.ofproto_v1_3_parser.OFPSetConfig(datapath, flags=0, miss_send_len=0)

Set config request message

The controller sends a set config request message to set configuraion parameters.

Attribute Description
flags

Bitmap of the following flags.

OFPC_FRAG_NORMAL
OFPC_FRAG_DROP
OFPC_FRAG_REASM
miss_send_len Max bytes of new flow that datapath should send to the controller

Example:

def send_set_config(self, datapath):
    ofp = datapath.ofproto
    ofp_parser = datapath.ofproto_parser

    req = ofp_parser.OFPSetConfig(datapath, ofp.OFPC_FRAG_NORMAL, 256)
    datapath.send_msg(req)

JSON Example:

{
   "OFPSetConfig": {
      "flags": 0, 
      "miss_send_len": 128
   }
}
class ryu.ofproto.ofproto_v1_3_parser.OFPGetConfigRequest(datapath)

Get config request message

The controller sends a get config request to query configuration parameters in the switch.

Example:

def send_get_config_request(self, datapath):
    ofp_parser = datapath.ofproto_parser

    req = ofp_parser.OFPGetConfigRequest(datapath)
    datapath.send_msg(req)

JSON Example:

{
   "OFPGetConfigRequest": {}
}
class ryu.ofproto.ofproto_v1_3_parser.OFPGetConfigReply(datapath, flags=None, miss_send_len=None)

Get config reply message

The switch responds to a configuration request with a get config reply message.

Attribute Description
flags

Bitmap of the following flags.

OFPC_FRAG_NORMAL
OFPC_FRAG_DROP
OFPC_FRAG_REASM
OFPC_FRAG_MASK
miss_send_len Max bytes of new flow that datapath should send to the controller

Example:

@set_ev_cls(ofp_event.EventOFPGetConfigReply, MAIN_DISPATCHER)
def get_config_reply_handler(self, ev):
    msg = ev.msg
    dp = msg.datapath
    ofp = dp.ofproto
    flags = []

    if msg.flags & ofp.OFPC_FRAG_NORMAL:
        flags.append('NORMAL')
    if msg.flags & ofp.OFPC_FRAG_DROP:
        flags.append('DROP')
    if msg.flags & ofp.OFPC_FRAG_REASM:
        flags.append('REASM')
    self.logger.debug('OFPGetConfigReply received: '
                      'flags=%s miss_send_len=%d',
                      ','.join(flags), msg.miss_send_len)

JSON Example:

{
   "OFPGetConfigReply": {
      "flags": 0, 
      "miss_send_len": 128
   }
}

Flow Table Configuration

class ryu.ofproto.ofproto_v1_3_parser.OFPTableMod(datapath, table_id, config)

Flow table configuration message

The controller sends this message to configure table state.

Attribute Description
table_id ID of the table (OFPTT_ALL indicates all tables)
config Bitmap of the following flags. OFPTC_DEPRECATED_MASK (3)

Example:

def send_table_mod(self, datapath):
    ofp_parser = datapath.ofproto_parser

    req = ofp_parser.OFPTableMod(datapath, 1, 3)
    datapath.send_msg(req)

JSON Example:

{
   "OFPTableMod": {
      "config": 0, 
      "table_id": 255
   }
}

Modify State Messages

class ryu.ofproto.ofproto_v1_3_parser.OFPFlowMod(datapath, cookie=0, cookie_mask=0, table_id=0, command=0, idle_timeout=0, hard_timeout=0, priority=32768, buffer_id=4294967295, out_port=0, out_group=0, flags=0, match=None, instructions=None)

Modify Flow entry message

The controller sends this message to modify the flow table.

Attribute Description
cookie Opaque controller-issued identifier
cookie_mask Mask used to restrict the cookie bits that must match when the command is OPFFC_MODIFY* or OFPFC_DELETE*
table_id ID of the table to put the flow in
command

One of the following values.

OFPFC_ADD
OFPFC_MODIFY
OFPFC_MODIFY_STRICT
OFPFC_DELETE
OFPFC_DELETE_STRICT
idle_timeout Idle time before discarding (seconds)
hard_timeout Max time before discarding (seconds)
priority Priority level of flow entry
buffer_id Buffered packet to apply to (or OFP_NO_BUFFER)
out_port For OFPFC_DELETE* commands, require matching entries to include this as an output port
out_group For OFPFC_DELETE* commands, require matching entries to include this as an output group
flags

Bitmap of the following flags.

OFPFF_SEND_FLOW_REM
OFPFF_CHECK_OVERLAP
OFPFF_RESET_COUNTS
OFPFF_NO_PKT_COUNTS
OFPFF_NO_BYT_COUNTS
match Instance of OFPMatch
instructions list of OFPInstruction* instance

Example:

def send_flow_mod(self, datapath):
    ofp = datapath.ofproto
    ofp_parser = datapath.ofproto_parser

    cookie = cookie_mask = 0
    table_id = 0
    idle_timeout = hard_timeout = 0
    priority = 32768
    buffer_id = ofp.OFP_NO_BUFFER
    match = ofp_parser.OFPMatch(in_port=1, eth_dst='ff:ff:ff:ff:ff:ff')
    actions = [ofp_parser.OFPActionOutput(ofp.OFPP_NORMAL, 0)]
    inst = [ofp_parser.OFPInstructionActions(ofp.OFPIT_APPLY_ACTIONS,
                                             actions)]
    req = ofp_parser.OFPFlowMod(datapath, cookie, cookie_mask,
                                table_id, ofp.OFPFC_ADD,
                                idle_timeout, hard_timeout,
                                priority, buffer_id,
                                ofp.OFPP_ANY, ofp.OFPG_ANY,
                                ofp.OFPFF_SEND_FLOW_REM,
                                match, inst)
    datapath.send_msg(req)

JSON Example:

{
   "OFPFlowMod": {
      "buffer_id": 65535, 
      "command": 0, 
      "cookie": 0, 
      "cookie_mask": 0, 
      "flags": 0, 
      "hard_timeout": 0, 
      "idle_timeout": 0, 
      "instructions": [
         {
            "OFPInstructionActions": {
               "actions": [
                  {
                     "OFPActionSetField": {
                        "field": {
                           "OXMTlv": {
                              "field": "vlan_vid", 
                              "mask": null, 
                              "value": 258
                           }
                        },
                        "len": 16,
                        "type": 25
                     }
                  }, 
                  {
                     "OFPActionCopyTtlOut": {
                        "len": 8, 
                        "type": 11
                     }
                  }, 
                  {
                     "OFPActionCopyTtlIn": {
                        "len": 8, 
                        "type": 12
                     }
                  }, 
                  {
                     "OFPActionCopyTtlIn": {
                        "len": 8, 
                        "type": 12
                     }
                  }, 
                  {
                     "OFPActionPopPbb": {
                        "len": 8, 
                        "type": 27
                     }
                  }, 
                  {
                     "OFPActionPushPbb": {
                        "ethertype": 4660, 
                        "len": 8, 
                        "type": 26
                     }
                  }, 
                  {
                     "OFPActionPopMpls": {
                        "ethertype": 39030, 
                        "len": 8, 
                        "type": 20
                     }
                  }, 
                  {
                     "OFPActionPushMpls": {
                        "ethertype": 34887, 
                        "len": 8, 
                        "type": 19
                     }
                  }, 
                  {
                     "OFPActionPopVlan": {
                        "len": 8, 
                        "type": 18
                     }
                  }, 
                  {
                     "OFPActionPushVlan": {
                        "ethertype": 33024, 
                        "len": 8, 
                        "type": 17
                     }
                  }, 
                  {
                     "OFPActionDecMplsTtl": {
                        "len": 8, 
                        "type": 16
                     }
                  }, 
                  {
                     "OFPActionSetMplsTtl": {
                        "len": 8, 
                        "mpls_ttl": 10, 
                        "type": 15
                     }
                  }, 
                  {
                     "OFPActionDecNwTtl": {
                        "len": 8, 
                        "type": 24
                     }
                  }, 
                  {
                     "OFPActionSetNwTtl": {
                        "len": 8, 
                        "nw_ttl": 10, 
                        "type": 23
                     }
                  },
                  {
                     "OFPActionExperimenterUnknown": {
                        "data": "AAECAwQFBgc=",
                        "experimenter": 101,
                        "len": 16,
                        "type": 65535
                     }
                  },
                  {
                     "OFPActionSetQueue": {
                        "len": 8, 
                        "queue_id": 3, 
                        "type": 21
                     }
                  }, 
                  {
                     "OFPActionGroup": {
                        "group_id": 99, 
                        "len": 8, 
                        "type": 22
                     }
                  }, 
                  {
                     "OFPActionOutput": {
                        "len": 16, 
                        "max_len": 65535, 
                        "port": 6, 
                        "type": 0
                     }
                  }
               ],
               "len": 176,
               "type": 3
            }
         }, 
         {
            "OFPInstructionActions": {
               "actions": [
                  {
                     "OFPActionSetField": {
                        "field": {
                           "OXMTlv": {
                              "field": "eth_src", 
                              "mask": null, 
                              "value": "01:02:03:04:05:06"
                           }
                        },
                        "len": 16,
                        "type": 25
                     }
                  }, 
                  {
                     "OFPActionSetField": {
                        "field": {
                           "OXMTlv": {
                              "field": "pbb_uca", 
                              "mask": null, 
                              "value": 1
                           }
                        },
                        "len": 16,
                        "type": 25
                     }
                  }
               ], 
               "len": 40, 
               "type": 4
            }
         }
      ], 
      "match": {
         "OFPMatch": {
            "length": 14, 
            "oxm_fields": [
               {
                  "OXMTlv": {
                     "field": "eth_dst", 
                     "mask": null, 
                     "value": "f2:0b:a4:7d:f8:ea"
                  }
               }
            ], 
            "type": 1
         }
      }, 
      "out_group": 4294967295, 
      "out_port": 4294967295, 
      "priority": 123, 
      "table_id": 1
   }
}
{
   "OFPFlowMod": {
      "buffer_id": 65535, 
      "command": 0, 
      "cookie": 0, 
      "cookie_mask": 0, 
      "flags": 0, 
      "hard_timeout": 0, 
      "idle_timeout": 0, 
      "instructions": [
         {
            "OFPInstructionGotoTable": {
               "len": 8, 
               "table_id": 1, 
               "type": 1
            }
         }
      ], 
      "match": {
         "OFPMatch": {
            "length": 22, 
            "oxm_fields": [
               {
                  "OXMTlv": {
                     "field": "in_port", 
                     "mask": null, 
                     "value": 6
                  }
               }, 
               {
                  "OXMTlv": {
                     "field": "eth_src", 
                     "mask": null, 
                     "value": "f2:0b:a4:7d:f8:ea"
                  }
               }
            ], 
            "type": 1
         }
      }, 
      "out_group": 4294967295, 
      "out_port": 4294967295, 
      "priority": 123, 
      "table_id": 0
   }
}
{
   "OFPFlowMod": {
      "buffer_id": 65535, 
      "command": 0, 
      "cookie": 0, 
      "cookie_mask": 0, 
      "flags": 0, 
      "hard_timeout": 0, 
      "idle_timeout": 0, 
      "instructions": [
         {
            "OFPInstructionMeter": {
               "len": 8, 
               "meter_id": 1, 
               "type": 6
            }
         }, 
         {
            "OFPInstructionActions": {
               "actions": [
                  {
                     "OFPActionOutput": {
                        "len": 16, 
                        "max_len": 65535, 
                        "port": 6, 
                        "type": 0
                     }
                  }
               ], 
               "len": 24, 
               "type": 3
            }
         }
      ], 
      "match": {
         "OFPMatch": {
            "length": 14, 
            "oxm_fields": [
               {
                  "OXMTlv": {
                     "field": "eth_dst", 
                     "mask": null, 
                     "value": "f2:0b:a4:7d:f8:ea"
                  }
               }
            ], 
            "type": 1
         }
      }, 
      "out_group": 4294967295, 
      "out_port": 4294967295, 
      "priority": 123, 
      "table_id": 1
   }
}
class ryu.ofproto.ofproto_v1_3_parser.OFPGroupMod(datapath, command=0, type_=0, group_id=0, buckets=None)

Modify group entry message

The controller sends this message to modify the group table.

Attribute Description
command

One of the following values.

OFPGC_ADD
OFPGC_MODIFY
OFPGC_DELETE
type

One of the following values.

OFPGT_ALL
OFPGT_SELECT
OFPGT_INDIRECT
OFPGT_FF
group_id Group identifier
buckets list of OFPBucket

type attribute corresponds to type_ parameter of __init__.

Example:

def send_group_mod(self, datapath):
    ofp = datapath.ofproto
    ofp_parser = datapath.ofproto_parser

    port = 1
    max_len = 2000
    actions = [ofp_parser.OFPActionOutput(port, max_len)]

    weight = 100
    watch_port = 0
    watch_group = 0
    buckets = [ofp_parser.OFPBucket(weight, watch_port, watch_group,
                                    actions)]

    group_id = 1
    req = ofp_parser.OFPGroupMod(datapath, ofp.OFPGC_ADD,
                                 ofp.OFPGT_SELECT, group_id, buckets)
    datapath.send_msg(req)

JSON Example:

{
   "OFPGroupMod": {
      "buckets": [
         {
            "OFPBucket": {
               "actions": [
                  {
                     "OFPActionOutput": {
                        "len": 16, 
                        "max_len": 65535, 
                        "port": 2, 
                        "type": 0
                     }
                  }
               ], 
               "len": 32, 
               "watch_group": 1, 
               "watch_port": 1, 
               "weight": 1
            }
         }
      ], 
      "command": 0, 
      "group_id": 1, 
      "type": 0
   }
}
class ryu.ofproto.ofproto_v1_3_parser.OFPPortMod(datapath, port_no=0, hw_addr='00:00:00:00:00:00', config=0, mask=0, advertise=0)

Port modification message

The controller sneds this message to modify the behavior of the port.

Attribute Description
port_no Port number to modify
hw_addr The hardware address that must be the same as hw_addr of OFPPort of OFPSwitchFeatures
config

Bitmap of configuration flags.

OFPPC_PORT_DOWN
OFPPC_NO_RECV
OFPPC_NO_FWD
OFPPC_NO_PACKET_IN
mask Bitmap of configuration flags above to be changed
advertise

Bitmap of the following flags.

OFPPF_10MB_HD
OFPPF_10MB_FD
OFPPF_100MB_HD
OFPPF_100MB_FD
OFPPF_1GB_HD
OFPPF_1GB_FD
OFPPF_10GB_FD
OFPPF_40GB_FD
OFPPF_100GB_FD
OFPPF_1TB_FD
OFPPF_OTHER
OFPPF_COPPER
OFPPF_FIBER
OFPPF_AUTONEG
OFPPF_PAUSE
OFPPF_PAUSE_ASYM

Example:

def send_port_mod(self, datapath):
    ofp = datapath.ofproto
    ofp_parser = datapath.ofproto_parser

    port_no = 3
    hw_addr = 'fa:c8:e8:76:1d:7e'
    config = 0
    mask = (ofp.OFPPC_PORT_DOWN | ofp.OFPPC_NO_RECV |
            ofp.OFPPC_NO_FWD | ofp.OFPPC_NO_PACKET_IN)
    advertise = (ofp.OFPPF_10MB_HD | ofp.OFPPF_100MB_FD |
                 ofp.OFPPF_1GB_FD | ofp.OFPPF_COPPER |
                 ofp.OFPPF_AUTONEG | ofp.OFPPF_PAUSE |
                 ofp.OFPPF_PAUSE_ASYM)
    req = ofp_parser.OFPPortMod(datapath, port_no, hw_addr, config,
                                mask, advertise)
    datapath.send_msg(req)

JSON Example:

{
   "OFPPortMod": {
      "advertise": 4096, 
      "config": 0, 
      "hw_addr": "00:11:00:00:11:11", 
      "mask": 0, 
      "port_no": 1
   }
}
class ryu.ofproto.ofproto_v1_3_parser.OFPMeterMod(datapath, command=0, flags=1, meter_id=1, bands=None)

Meter modification message

The controller sends this message to modify the meter.

Attribute Description
command

One of the following values.

OFPMC_ADD
OFPMC_MODIFY
OFPMC_DELETE
flags

Bitmap of the following flags.

OFPMF_KBPS
OFPMF_PKTPS
OFPMF_BURST
OFPMF_STATS
meter_id Meter instance
bands

list of the following class instance.

OFPMeterBandDrop
OFPMeterBandDscpRemark
OFPMeterBandExperimenter

JSON Example:

{
   "OFPMeterMod": {
      "bands": [
         {
            "OFPMeterBandDrop": {
               "burst_size": 10, 
               "len": 16, 
               "rate": 1000, 
               "type": 1
            }
         }, 
         {
            "OFPMeterBandDscpRemark": {
               "burst_size": 10, 
               "len": 16, 
               "prec_level": 1, 
               "rate": 1000, 
               "type": 2
            }
         }, 
         {
            "OFPMeterBandExperimenter": {
               "burst_size": 10, 
               "experimenter": 999, 
               "len": 16, 
               "rate": 1000, 
               "type": 65535
            }
         }
      ], 
      "command": 0, 
      "flags": 14, 
      "meter_id": 100
   }
}

Multipart Messages

class ryu.ofproto.ofproto_v1_3_parser.OFPDescStatsRequest(datapath, flags=0, type_=None)

Description statistics request message

The controller uses this message to query description of the switch.

Attribute Description
flags Zero or OFPMPF_REQ_MORE

Example:

def send_desc_stats_request(self, datapath):
    ofp_parser = datapath.ofproto_parser

    req = ofp_parser.OFPDescStatsRequest(datapath, 0)
    datapath.send_msg(req)

JSON Example:

{
   "OFPDescStatsRequest": {
      "flags": 0, 
      "type": 0
   }
}
class ryu.ofproto.ofproto_v1_3_parser.OFPDescStatsReply(datapath, type_=None, **kwargs)

Description statistics reply message

The switch responds with this message to a description statistics request.

Attribute Description
body Instance of OFPDescStats

Example:

@set_ev_cls(ofp_event.EventOFPDescStatsReply, MAIN_DISPATCHER)
def desc_stats_reply_handler(self, ev):
    body = ev.msg.body

    self.logger.debug('DescStats: mfr_desc=%s hw_desc=%s sw_desc=%s '
                      'serial_num=%s dp_desc=%s',
                      body.mfr_desc, body.hw_desc, body.sw_desc,
                      body.serial_num, body.dp_desc)

JSON Example:

{
   "OFPDescStatsReply": {
      "body": {
         "OFPDescStats": {
            "dp_desc": "dp", 
            "hw_desc": "hw", 
            "mfr_desc": "mfr", 
            "serial_num": "serial", 
            "sw_desc": "sw"
         }
      }, 
      "flags": 0, 
      "type": 0
   }
}
class ryu.ofproto.ofproto_v1_3_parser.OFPFlowStatsRequest(datapath, flags=0, table_id=255, out_port=4294967295, out_group=4294967295, cookie=0, cookie_mask=0, match=None, type_=None)

Individual flow statistics request message

The controller uses this message to query individual flow statistics.

Attribute Description
flags Zero or OFPMPF_REQ_MORE
table_id ID of table to read
out_port Require matching entries to include this as an output port
out_group Require matching entries to include this as an output group
cookie Require matching entries to contain this cookie value
cookie_mask Mask used to restrict the cookie bits that must match
match Instance of OFPMatch

Example:

def send_flow_stats_request(self, datapath):
    ofp = datapath.ofproto
    ofp_parser = datapath.ofproto_parser

    cookie = cookie_mask = 0
    match = ofp_parser.OFPMatch(in_port=1)
    req = ofp_parser.OFPFlowStatsRequest(datapath, 0,
                                         ofp.OFPTT_ALL,
                                         ofp.OFPP_ANY, ofp.OFPG_ANY,
                                         cookie, cookie_mask,
                                         match)
    datapath.send_msg(req)

JSON Example:

{
   "OFPFlowStatsRequest": {
      "cookie": 0, 
      "cookie_mask": 0, 
      "flags": 0, 
      "match": {
         "OFPMatch": {
            "length": 4, 
            "oxm_fields": [], 
            "type": 1
         }
      }, 
      "out_group": 4294967295, 
      "out_port": 4294967295, 
      "table_id": 0, 
      "type": 1
   }
}
class ryu.ofproto.ofproto_v1_3_parser.OFPFlowStatsReply(datapath, type_=None, **kwargs)

Individual flow statistics reply message

The switch responds with this message to an individual flow statistics request.

Attribute Description
body List of OFPFlowStats instance

Example:

@set_ev_cls(ofp_event.EventOFPFlowStatsReply, MAIN_DISPATCHER)
def flow_stats_reply_handler(self, ev):
    flows = []
    for stat in ev.msg.body:
        flows.append('table_id=%s '
                     'duration_sec=%d duration_nsec=%d '
                     'priority=%d '
                     'idle_timeout=%d hard_timeout=%d flags=0x%04x '
                     'cookie=%d packet_count=%d byte_count=%d '
                     'match=%s instructions=%s' %
                     (stat.table_id,
                      stat.duration_sec, stat.duration_nsec,
                      stat.priority,
                      stat.idle_timeout, stat.hard_timeout, stat.flags,
                      stat.cookie, stat.packet_count, stat.byte_count,
                      stat.match, stat.instructions))
    self.logger.debug('FlowStats: %s', flows)

JSON Example:

{
   "OFPFlowStatsReply": {
      "body": [
         {
            "OFPFlowStats": {
               "byte_count": 0, 
               "cookie": 0, 
               "duration_nsec": 115277000, 
               "duration_sec": 358, 
               "flags": 0, 
               "hard_timeout": 0, 
               "idle_timeout": 0, 
               "instructions": [], 
               "length": 56, 
               "match": {
                  "OFPMatch": {
                     "length": 4, 
                     "oxm_fields": [], 
                     "type": 1
                  }
               }, 
               "packet_count": 0, 
               "priority": 65535, 
               "table_id": 0
            }
         }, 
         {
            "OFPFlowStats": {
               "byte_count": 0, 
               "cookie": 0, 
               "duration_nsec": 115055000, 
               "duration_sec": 358, 
               "flags": 0, 
               "hard_timeout": 0, 
               "idle_timeout": 0, 
               "instructions": [
                  {
                     "OFPInstructionActions": {
                        "actions": [
                           {
                              "OFPActionOutput": {
                                 "len": 16, 
                                 "max_len": 0, 
                                 "port": 4294967290, 
                                 "type": 0
                              }
                           }
                        ], 
                        "len": 24, 
                        "type": 4
                     }
                  }
               ], 
               "length": 88, 
               "match": {
                  "OFPMatch": {
                     "length": 10, 
                     "oxm_fields": [
                        {
                           "OXMTlv": {
                              "field": "eth_type", 
                              "mask": null, 
                              "value": 2054
                           }
                        }
                     ], 
                     "type": 1
                  }
               }, 
               "packet_count": 0, 
               "priority": 65534, 
               "table_id": 0
            }
         }, 
         {
            "OFPFlowStats": {
               "byte_count": 238, 
               "cookie": 0, 
               "duration_nsec": 511582000, 
               "duration_sec": 316220, 
               "flags": 0, 
               "hard_timeout": 0, 
               "idle_timeout": 0, 
               "instructions": [
                  {
                     "OFPInstructionGotoTable": {
                        "len": 8, 
                        "table_id": 1, 
                        "type": 1
                     }
                  }
               ], 
               "length": 80, 
               "match": {
                  "OFPMatch": {
                     "length": 22, 
                     "oxm_fields": [
                        {
                           "OXMTlv": {
                              "field": "in_port", 
                              "mask": null, 
                              "value": 6
                           }
                        }, 
                        {
                           "OXMTlv": {
                              "field": "eth_src", 
                              "mask": null, 
                              "value": "f2:0b:a4:7d:f8:ea"
                           }
                        }
                     ], 
                     "type": 1
                  }
               }, 
               "packet_count": 3, 
               "priority": 123, 
               "table_id": 0
            }
         }, 
         {
            "OFPFlowStats": {
               "byte_count": 98, 
               "cookie": 0, 
               "duration_nsec": 980901000, 
               "duration_sec": 313499, 
               "flags": 0, 
               "hard_timeout": 0, 
               "idle_timeout": 0, 
               "instructions": [
                  {
                     "OFPInstructionActions": {
                        "actions": [
                           {
                              "OFPActionSetField": {
                                 "field": {
                                    "OXMTlv": {
                                       "field": "vlan_vid", 
                                       "mask": null, 
                                       "value": 258
                                    }
                                 },
                                 "len": 16,
                                 "type": 25
                              }
                           }, 
                           {
                              "OFPActionCopyTtlOut": {
                                 "len": 8, 
                                 "type": 11
                              }
                           }, 
                           {
                              "OFPActionCopyTtlIn": {
                                 "len": 8, 
                                 "type": 12
                              }
                           }, 
                           {
                              "OFPActionCopyTtlIn": {
                                 "len": 8, 
                                 "type": 12
                              }
                           }, 
                           {
                              "OFPActionPopPbb": {
                                 "len": 8, 
                                 "type": 27
                              }
                           }, 
                           {
                              "OFPActionPushPbb": {
                                 "ethertype": 4660, 
                                 "len": 8, 
                                 "type": 26
                              }
                           }, 
                           {
                              "OFPActionPopMpls": {
                                 "ethertype": 39030, 
                                 "len": 8, 
                                 "type": 20
                              }
                           }, 
                           {
                              "OFPActionPushMpls": {
                                 "ethertype": 34887, 
                                 "len": 8, 
                                 "type": 19
                              }
                           }, 
                           {
                              "OFPActionPopVlan": {
                                 "len": 8, 
                                 "type": 18
                              }
                           }, 
                           {
                              "OFPActionPushVlan": {
                                 "ethertype": 33024, 
                                 "len": 8, 
                                 "type": 17
                              }
                           }, 
                           {
                              "OFPActionDecMplsTtl": {
                                 "len": 8, 
                                 "type": 16
                              }
                           }, 
                           {
                              "OFPActionSetMplsTtl": {
                                 "len": 8, 
                                 "mpls_ttl": 10, 
                                 "type": 15
                              }
                           }, 
                           {
                              "OFPActionDecNwTtl": {
                                 "len": 8, 
                                 "type": 24
                              }
                           }, 
                           {
                              "OFPActionSetNwTtl": {
                                 "len": 8, 
                                 "nw_ttl": 10, 
                                 "type": 23
                              }
                           }, 
                           {
                              "OFPActionSetQueue": {
                                 "len": 8, 
                                 "queue_id": 3, 
                                 "type": 21
                              }
                           }, 
                           {
                              "OFPActionGroup": {
                                 "group_id": 99, 
                                 "len": 8, 
                                 "type": 22
                              }
                           }, 
                           {
                              "OFPActionOutput": {
                                 "len": 16, 
                                 "max_len": 65535, 
                                 "port": 6, 
                                 "type": 0
                              }
                           },
                           {
                              "OFPActionExperimenterUnknown": {
                                 "len": 16,
                                 "data": "ZXhwX2RhdGE=",
                                 "experimenter": 98765432,
                                 "type": 65535
                              }
                           },
                           {
                              "NXActionUnknown": {
                                 "len": 16,
                                 "data": "cF9kYXRh",
                                 "experimenter": 8992,
                                 "type": 65535,
                                 "subtype": 25976
                              }
                           }
                        ], 
                        "len": 192,
                        "type": 3
                     }
                  }, 
                  {
                     "OFPInstructionActions": {
                        "actions": [
                           {
                              "OFPActionSetField": {
                                 "field": {
                                    "OXMTlv": {
                                       "field": "eth_src", 
                                       "mask": null, 
                                       "value": "01:02:03:04:05:06"
                                    }
                                 },
                                 "len": 16,
                                 "type": 25
                              }
                           }, 
                           {
                              "OFPActionSetField": {
                                 "field": {
                                    "OXMTlv": {
                                       "field": "pbb_uca", 
                                       "mask": null, 
                                       "value": 1
                                    }
                                 },
                                 "len": 16,
                                 "type": 25
                              }
                           }
                        ], 
                        "len": 40, 
                        "type": 4
                     }
                  }, 
                  {
                     "OFPInstructionActions": {
                        "actions": [
                           {
                              "OFPActionOutput": {
                                 "len": 16, 
                                 "max_len": 65535, 
                                 "port": 4294967293, 
                                 "type": 0
                              }
                           }
                        ], 
                        "len": 24, 
                        "type": 3
                     }
                  }
               ], 
               "length": 312,
               "match": {
                  "OFPMatch": {
                     "length": 4, 
                     "oxm_fields": [], 
                     "type": 1
                  }
               }, 
               "packet_count": 1, 
               "priority": 0, 
               "table_id": 0
            }
         }
      ], 
      "flags": 0, 
      "type": 1
   }
}
class ryu.ofproto.ofproto_v1_3_parser.OFPAggregateStatsRequest(datapath, flags, table_id, out_port, out_group, cookie, cookie_mask, match, type_=None)

Aggregate flow statistics request message

The controller uses this message to query aggregate flow statictics.

Attribute Description
flags Zero or OFPMPF_REQ_MORE
table_id ID of table to read
out_port Require matching entries to include this as an output port
out_group Require matching entries to include this as an output group
cookie Require matching entries to contain this cookie value
cookie_mask Mask used to restrict the cookie bits that must match
match Instance of OFPMatch

Example:

def send_aggregate_stats_request(self, datapath):
    ofp = datapath.ofproto
    ofp_parser = datapath.ofproto_parser

    cookie = cookie_mask = 0
    match = ofp_parser.OFPMatch(in_port=1)
    req = ofp_parser.OFPAggregateStatsRequest(datapath, 0,
                                              ofp.OFPTT_ALL,
                                              ofp.OFPP_ANY,
                                              ofp.OFPG_ANY,
                                              cookie, cookie_mask,
                                              match)
    datapath.send_msg(req)

JSON Example:

{
   "OFPAggregateStatsRequest": {
      "cookie": 0, 
      "cookie_mask": 0, 
      "flags": 0, 
      "match": {
         "OFPMatch": {
            "length": 4, 
            "oxm_fields": [], 
            "type": 1
         }
      }, 
      "out_group": 4294967295, 
      "out_port": 4294967295, 
      "table_id": 255, 
      "type": 2
   }
}
class ryu.ofproto.ofproto_v1_3_parser.OFPAggregateStatsReply(datapath, type_=None, **kwargs)

Aggregate flow statistics reply message

The switch responds with this message to an aggregate flow statistics request.

Attribute Description
body Instance of OFPAggregateStats

Example:

@set_ev_cls(ofp_event.EventOFPAggregateStatsReply, MAIN_DISPATCHER)
def aggregate_stats_reply_handler(self, ev):
    body = ev.msg.body

    self.logger.debug('AggregateStats: packet_count=%d byte_count=%d '
                      'flow_count=%d',
                      body.packet_count, body.byte_count,
                      body.flow_count)

JSON Example:

{
   "OFPAggregateStatsReply": {
      "body": {
         "OFPAggregateStats": {
            "byte_count": 574, 
            "flow_count": 6, 
            "packet_count": 7
         }
      }, 
      "flags": 0, 
      "type": 2
   }
}
class ryu.ofproto.ofproto_v1_3_parser.OFPTableStatsRequest(datapath, flags=0, type_=None)

Table statistics request message

The controller uses this message to query flow table statictics.

Attribute Description
flags Zero or OFPMPF_REQ_MORE

Example:

def send_table_stats_request(self, datapath):
    ofp_parser = datapath.ofproto_parser

    req = ofp_parser.OFPTableStatsRequest(datapath, 0)
    datapath.send_msg(req)

JSON Example:

{
   "OFPTableStatsRequest": {
      "flags": 0, 
      "type": 3
   }
}
class ryu.ofproto.ofproto_v1_3_parser.OFPTableStatsReply(datapath, type_=None, **kwargs)

Table statistics reply message

The switch responds with this message to a table statistics request.

Attribute Description
body List of OFPTableStats instance

Example:

@set_ev_cls(ofp_event.EventOFPTableStatsReply, MAIN_DISPATCHER)
def table_stats_reply_handler(self, ev):
    tables = []
    for stat in ev.msg.body:
        tables.append('table_id=%d active_count=%d lookup_count=%d '
                      ' matched_count=%d' %
                      (stat.table_id, stat.active_count,
                       stat.lookup_count, stat.matched_count))
    self.logger.debug('TableStats: %s', tables)

JSON Example:

{
   "OFPTableStatsReply": {
      "body": [
         {
            "OFPTableStats": {
               "active_count": 4, 
               "lookup_count": 4, 
               "matched_count": 4, 
               "table_id": 0
            }
         }, 
         {
            "OFPTableStats": {
               "active_count": 4, 
               "lookup_count": 4, 
               "matched_count": 4, 
               "table_id": 1
            }
         }
      ], 
      "flags": 0, 
      "type": 3
   }
}
class ryu.ofproto.ofproto_v1_3_parser.OFPPortStatsRequest(datapath, flags=0, port_no=4294967295, type_=None)

Port statistics request message

The controller uses this message to query information about ports statistics.

Attribute Description
flags Zero or OFPMPF_REQ_MORE
port_no Port number to read (OFPP_ANY to all ports)

Example:

def send_port_stats_request(self, datapath):
    ofp = datapath.ofproto
    ofp_parser = datapath.ofproto_parser

    req = ofp_parser.OFPPortStatsRequest(datapath, 0, ofp.OFPP_ANY)
    datapath.send_msg(req)

JSON Example:

{
   "OFPPortStatsRequest": {
      "flags": 0, 
      "port_no": 4294967295, 
      "type": 4
   }
}
class ryu.ofproto.ofproto_v1_3_parser.OFPPortStatsReply(datapath, type_=None, **kwargs)

Port statistics reply message

The switch responds with this message to a port statistics request.

Attribute Description
body List of OFPPortStats instance

Example:

@set_ev_cls(ofp_event.EventOFPPortStatsReply, MAIN_DISPATCHER)
def port_stats_reply_handler(self, ev):
    ports = []
    for stat in ev.msg.body:
        ports.append('port_no=%d '
                     'rx_packets=%d tx_packets=%d '
                     'rx_bytes=%d tx_bytes=%d '
                     'rx_dropped=%d tx_dropped=%d '
                     'rx_errors=%d tx_errors=%d '
                     'rx_frame_err=%d rx_over_err=%d rx_crc_err=%d '
                     'collisions=%d duration_sec=%d duration_nsec=%d' %
                     (stat.port_no,
                      stat.rx_packets, stat.tx_packets,
                      stat.rx_bytes, stat.tx_bytes,
                      stat.rx_dropped, stat.tx_dropped,
                      stat.rx_errors, stat.tx_errors,
                      stat.rx_frame_err, stat.rx_over_err,
                      stat.rx_crc_err, stat.collisions,
                      stat.duration_sec, stat.duration_nsec))
    self.logger.debug('PortStats: %s', ports)

JSON Example:

{
   "OFPPortStatsReply": {
      "body": [
         {
            "OFPPortStats": {
               "collisions": 0, 
               "duration_nsec": 0, 
               "duration_sec": 0, 
               "port_no": 7, 
               "rx_bytes": 0, 
               "rx_crc_err": 0, 
               "rx_dropped": 0, 
               "rx_errors": 0, 
               "rx_frame_err": 0, 
               "rx_over_err": 0, 
               "rx_packets": 0, 
               "tx_bytes": 336, 
               "tx_dropped": 0, 
               "tx_errors": 0, 
               "tx_packets": 4
            }
         }, 
         {
            "OFPPortStats": {
               "collisions": 0, 
               "duration_nsec": 0, 
               "duration_sec": 0, 
               "port_no": 6, 
               "rx_bytes": 336, 
               "rx_crc_err": 0, 
               "rx_dropped": 0, 
               "rx_errors": 0, 
               "rx_frame_err": 0, 
               "rx_over_err": 0, 
               "rx_packets": 4, 
               "tx_bytes": 336, 
               "tx_dropped": 0, 
               "tx_errors": 0, 
               "tx_packets": 4
            }
         }
      ], 
      "flags": 0, 
      "type": 4
   }
}
class ryu.ofproto.ofproto_v1_3_parser.OFPPortDescStatsRequest(datapath, flags=0, type_=None)

Port description request message

The controller uses this message to query description of all the ports.

Attribute Description
flags Zero or OFPMPF_REQ_MORE

Example:

def send_port_desc_stats_request(self, datapath):
    ofp_parser = datapath.ofproto_parser

    req = ofp_parser.OFPPortDescStatsRequest(datapath, 0)
    datapath.send_msg(req)

JSON Example:

{
   "OFPPortDescStatsRequest": {
      "flags": 0, 
      "type": 13
   }
}
class ryu.ofproto.ofproto_v1_3_parser.OFPPortDescStatsReply(datapath, type_=None, **kwargs)

Port description reply message

The switch responds with this message to a port description request.

Attribute Description
body List of OFPPort instance

Example:

@set_ev_cls(ofp_event.EventOFPPortDescStatsReply, MAIN_DISPATCHER)
def port_desc_stats_reply_handler(self, ev):
    ports = []
    for p in ev.msg.body:
        ports.append('port_no=%d hw_addr=%s name=%s config=0x%08x '
                     'state=0x%08x curr=0x%08x advertised=0x%08x '
                     'supported=0x%08x peer=0x%08x curr_speed=%d '
                     'max_speed=%d' %
                     (p.port_no, p.hw_addr,
                      p.name, p.config,
                      p.state, p.curr, p.advertised,
                      p.supported, p.peer, p.curr_speed,
                      p.max_speed))
    self.logger.debug('OFPPortDescStatsReply received: %s', ports)

JSON Example:

{
   "OFPPortDescStatsReply": {
      "body": [
         {
            "OFPPort": {
               "advertised": 10240, 
               "config": 0, 
               "curr": 10248, 
               "curr_speed": 5000, 
               "hw_addr": "f2:0b:a4:d0:3f:70", 
               "max_speed": 5000, 
               "name": "Port7", 
               "peer": 10248, 
               "port_no": 7, 
               "state": 4, 
               "supported": 10248
            }
         }, 
         {
            "OFPPort": {
               "advertised": 10240, 
               "config": 0, 
               "curr": 10248, 
               "curr_speed": 5000, 
               "hw_addr": "f2:0b:a4:7d:f8:ea", 
               "max_speed": 5000, 
               "name": "Port6", 
               "peer": 10248, 
               "port_no": 6, 
               "state": 4, 
               "supported": 10248
            }
         }
      ], 
      "flags": 0, 
      "type": 13
   }
}
class ryu.ofproto.ofproto_v1_3_parser.OFPQueueStatsRequest(datapath, flags=0, port_no=4294967295, queue_id=4294967295, type_=None)

Queue statistics request message

The controller uses this message to query queue statictics.

Attribute Description
flags Zero or OFPMPF_REQ_MORE
port_no Port number to read
queue_id ID of queue to read

Example:

def send_queue_stats_request(self, datapath):
    ofp = datapath.ofproto
    ofp_parser = datapath.ofproto_parser

    req = ofp_parser.OFPQueueStatsRequest(datapath, 0, ofp.OFPP_ANY,
                                          ofp.OFPQ_ALL)
    datapath.send_msg(req)

JSON Example:

{
   "OFPQueueStatsRequest": {
      "flags": 0, 
      "port_no": 4294967295, 
      "queue_id": 4294967295, 
      "type": 5
   }
}
class ryu.ofproto.ofproto_v1_3_parser.OFPQueueStatsReply(datapath, type_=None, **kwargs)

Queue statistics reply message

The switch responds with this message to an aggregate flow statistics request.

Attribute Description
body List of OFPQueueStats instance

Example:

@set_ev_cls(ofp_event.EventOFPQueueStatsReply, MAIN_DISPATCHER)
def queue_stats_reply_handler(self, ev):
    queues = []
    for stat in ev.msg.body:
        queues.append('port_no=%d queue_id=%d '
                      'tx_bytes=%d tx_packets=%d tx_errors=%d '
                      'duration_sec=%d duration_nsec=%d' %
                      (stat.port_no, stat.queue_id,
                       stat.tx_bytes, stat.tx_packets, stat.tx_errors,
                       stat.duration_sec, stat.duration_nsec))
    self.logger.debug('QueueStats: %s', queues)

JSON Example:

{
   "OFPQueueStatsReply": {
      "body": [
         {
            "OFPQueueStats": {
               "duration_nsec": 0, 
               "duration_sec": 0, 
               "port_no": 7, 
               "queue_id": 1, 
               "tx_bytes": 0, 
               "tx_errors": 0, 
               "tx_packets": 0
            }
         }, 
         {
            "OFPQueueStats": {
               "duration_nsec": 0, 
               "duration_sec": 0, 
               "port_no": 6, 
               "queue_id": 1, 
               "tx_bytes": 0, 
               "tx_errors": 0, 
               "tx_packets": 0
            }
         }, 
         {
            "OFPQueueStats": {
               "duration_nsec": 0, 
               "duration_sec": 0, 
               "port_no": 7, 
               "queue_id": 2, 
               "tx_bytes": 0, 
               "tx_errors": 0, 
               "tx_packets": 0
            }
         }
      ], 
      "flags": 0, 
      "type": 5
   }
}
class ryu.ofproto.ofproto_v1_3_parser.OFPGroupStatsRequest(datapath, flags=0, group_id=4294967292, type_=None)

Group statistics request message

The controller uses this message to query statistics of one or more groups.

Attribute Description
flags Zero or OFPMPF_REQ_MORE
group_id ID of group to read (OFPG_ALL to all groups)

Example:

def send_group_stats_request(self, datapath):
    ofp = datapath.ofproto
    ofp_parser = datapath.ofproto_parser

    req = ofp_parser.OFPGroupStatsRequest(datapath, 0, ofp.OFPG_ALL)
    datapath.send_msg(req)
class ryu.ofproto.ofproto_v1_3_parser.OFPGroupStatsReply(datapath, type_=None, **kwargs)

Group statistics reply message

The switch responds with this message to a group statistics request.

Attribute Description
body List of OFPGroupStats instance

Example:

@set_ev_cls(ofp_event.EventOFPGroupStatsReply, MAIN_DISPATCHER)
def group_stats_reply_handler(self, ev):
    groups = []
    for stat in ev.msg.body:
        groups.append('length=%d group_id=%d '
                      'ref_count=%d packet_count=%d byte_count=%d '
                      'duration_sec=%d duration_nsec=%d' %
                      (stat.length, stat.group_id,
                       stat.ref_count, stat.packet_count,
                       stat.byte_count, stat.duration_sec,
                       stat.duration_nsec))
    self.logger.debug('GroupStats: %s', groups)
class ryu.ofproto.ofproto_v1_3_parser.OFPGroupDescStatsRequest(datapath, flags=0, type_=None)

Group description request message

The controller uses this message to list the set of groups on a switch.

Attribute Description
flags Zero or OFPMPF_REQ_MORE

Example:

def send_group_desc_stats_request(self, datapath):
    ofp_parser = datapath.ofproto_parser

    req = ofp_parser.OFPGroupDescStatsRequest(datapath, 0)
    datapath.send_msg(req)

JSON Example:

{
   "OFPGroupDescStatsRequest": {
      "flags": 0, 
      "type": 7
   }
}
class ryu.ofproto.ofproto_v1_3_parser.OFPGroupDescStatsReply(datapath, type_=None, **kwargs)

Group description reply message

The switch responds with this message to a group description request.

Attribute Description
body List of OFPGroupDescStats instance

Example:

@set_ev_cls(ofp_event.EventOFPGroupDescStatsReply, MAIN_DISPATCHER)
def group_desc_stats_reply_handler(self, ev):
    descs = []
    for stat in ev.msg.body:
        descs.append('length=%d type=%d group_id=%d '
                     'buckets=%s' %
                     (stat.length, stat.type, stat.group_id,
                      stat.bucket))
    self.logger.debug('GroupDescStats: %s', descs)

JSON Example:

{
   "OFPGroupDescStatsReply": {
      "body": [
         {
            "OFPGroupDescStats": {
               "buckets": [
                  {
                     "OFPBucket": {
                        "actions": [
                           {
                              "OFPActionOutput": {
                                 "len": 16, 
                                 "max_len": 65535, 
                                 "port": 2, 
                                 "type": 0
                              }
                           }
                        ], 
                        "len": 32, 
                        "watch_group": 1, 
                        "watch_port": 1, 
                        "weight": 1
                     }
                  }
               ], 
               "group_id": 1, 
               "length": 40, 
               "type": 0
            }
         }
      ], 
      "flags": 0, 
      "type": 7
   }
}
class ryu.ofproto.ofproto_v1_3_parser.OFPGroupFeaturesStatsRequest(datapath, flags=0, type_=None)

Group features request message

The controller uses this message to list the capabilities of groups on a switch.

Attribute Description
flags Zero or OFPMPF_REQ_MORE

Example:

def send_group_features_stats_request(self, datapath):
    ofp_parser = datapath.ofproto_parser

    req = ofp_parser.OFPGroupFeaturesStatsRequest(datapath, 0)
    datapath.send_msg(req)

JSON Example:

{
   "OFPGroupFeaturesStatsRequest": {
      "flags": 0, 
      "type": 8
   }
}
class ryu.ofproto.ofproto_v1_3_parser.OFPGroupFeaturesStatsReply(datapath, type_=None, **kwargs)

Group features reply message

The switch responds with this message to a group features request.

Attribute Description
body Instance of OFPGroupFeaturesStats

Example:

@set_ev_cls(ofp_event.EventOFPGroupFeaturesStatsReply, MAIN_DISPATCHER)
def group_features_stats_reply_handler(self, ev):
    body = ev.msg.body

    self.logger.debug('GroupFeaturesStats: types=%d '
                      'capabilities=0x%08x max_groups=%s '
                      'actions=%s',
                      body.types, body.capabilities,
                      body.max_groups, body.actions)

JSON Example:

{
   "OFPGroupFeaturesStatsReply": {
      "body": {
         "OFPGroupFeaturesStats": {
            "actions": [
               67082241, 
               67082241, 
               67082241, 
               67082241
            ], 
            "capabilities": 5, 
            "max_groups": [
               16777216, 
               16777216, 
               16777216, 
               16777216
            ], 
            "types": 15
         }
      }, 
      "flags": 0, 
      "type": 8
   }
}
class ryu.ofproto.ofproto_v1_3_parser.OFPMeterStatsRequest(datapath, flags=0, meter_id=4294967295, type_=None)

Meter statistics request message

The controller uses this message to query statistics for one or more meters.

Attribute Description
flags Zero or OFPMPF_REQ_MORE
meter_id ID of meter to read (OFPM_ALL to all meters)

Example:

def send_meter_stats_request(self, datapath):
    ofp = datapath.ofproto
    ofp_parser = datapath.ofproto_parser

    req = ofp_parser.OFPMeterStatsRequest(datapath, 0, ofp.OFPM_ALL)
    datapath.send_msg(req)

JSON Example:

{
   "OFPMeterStatsRequest": {
      "flags": 0, 
      "meter_id": 4294967295, 
      "type": 9
   }
}
class ryu.ofproto.ofproto_v1_3_parser.OFPMeterStatsReply(datapath, type_=None, **kwargs)

Meter statistics reply message

The switch responds with this message to a meter statistics request.

Attribute Description
body List of OFPMeterStats instance

Example:

@set_ev_cls(ofp_event.EventOFPMeterStatsReply, MAIN_DISPATCHER)
def meter_stats_reply_handler(self, ev):
    meters = []
    for stat in ev.msg.body:
        meters.append('meter_id=0x%08x len=%d flow_count=%d '
                      'packet_in_count=%d byte_in_count=%d '
                      'duration_sec=%d duration_nsec=%d '
                      'band_stats=%s' %
                      (stat.meter_id, stat.len, stat.flow_count,
                       stat.packet_in_count, stat.byte_in_count,
                       stat.duration_sec, stat.duration_nsec,
                       stat.band_stats))
    self.logger.debug('MeterStats: %s', meters)

JSON Example:

{
   "OFPMeterStatsReply": {
      "body": [
         {
            "OFPMeterStats": {
               "band_stats": [
                  {
                     "OFPMeterBandStats": {
                        "byte_band_count": 0, 
                        "packet_band_count": 0
                     }
                  }
               ], 
               "byte_in_count": 0, 
               "duration_nsec": 480000, 
               "duration_sec": 0, 
               "flow_count": 0, 
               "len": 56, 
               "meter_id": 100, 
               "packet_in_count": 0
            }
         }
      ], 
      "flags": 0, 
      "type": 9
   }
}
class ryu.ofproto.ofproto_v1_3_parser.OFPMeterConfigStatsRequest(datapath, flags=0, meter_id=4294967295, type_=None)

Meter configuration statistics request message

The controller uses this message to query configuration for one or more meters.

Attribute Description
flags Zero or OFPMPF_REQ_MORE
meter_id ID of meter to read (OFPM_ALL to all meters)

Example:

def send_meter_config_stats_request(self, datapath):
    ofp = datapath.ofproto
    ofp_parser = datapath.ofproto_parser

    req = ofp_parser.OFPMeterConfigStatsRequest(datapath, 0,
                                                ofp.OFPM_ALL)
    datapath.send_msg(req)

JSON Example:

{
   "OFPMeterConfigStatsRequest": {
      "flags": 0, 
      "meter_id": 4294967295, 
      "type": 10
   }
}
class ryu.ofproto.ofproto_v1_3_parser.OFPMeterConfigStatsReply(datapath, type_=None, **kwargs)

Meter configuration statistics reply message

The switch responds with this message to a meter configuration statistics request.

Attribute Description
body List of OFPMeterConfigStats instance

Example:

@set_ev_cls(ofp_event.EventOFPMeterConfigStatsReply, MAIN_DISPATCHER)
def meter_config_stats_reply_handler(self, ev):
    configs = []
    for stat in ev.msg.body:
        configs.append('length=%d flags=0x%04x meter_id=0x%08x '
                       'bands=%s' %
                       (stat.length, stat.flags, stat.meter_id,
                        stat.bands))
    self.logger.debug('MeterConfigStats: %s', configs)

JSON Example:

{
   "OFPMeterConfigStatsReply": {
      "body": [
         {
            "OFPMeterConfigStats": {
               "bands": [
                  {
                     "OFPMeterBandDrop": {
                        "burst_size": 10, 
                        "len": 16, 
                        "rate": 1000, 
                        "type": 1
                     }
                  }
               ], 
               "flags": 14, 
               "length": 24, 
               "meter_id": 100
            }
         }
      ], 
      "flags": 0, 
      "type": 10
   }
}
class ryu.ofproto.ofproto_v1_3_parser.OFPMeterFeaturesStatsRequest(datapath, flags=0, type_=None)

Meter features statistics request message

The controller uses this message to query the set of features of the metering subsystem.

Attribute Description
flags Zero or OFPMPF_REQ_MORE

Example:

def send_meter_features_stats_request(self, datapath):
    ofp_parser = datapath.ofproto_parser

    req = ofp_parser.OFPMeterFeaturesStatsRequest(datapath, 0)
    datapath.send_msg(req)

JSON Example:

{
   "OFPMeterFeaturesStatsRequest": {
      "flags": 0, 
      "type": 11
   }
}
class ryu.ofproto.ofproto_v1_3_parser.OFPMeterFeaturesStatsReply(datapath, type_=None, **kwargs)

Meter features statistics reply message

The switch responds with this message to a meter features statistics request.

Attribute Description
body List of OFPMeterFeaturesStats instance

Example:

@set_ev_cls(ofp_event.EventOFPMeterFeaturesStatsReply, MAIN_DISPATCHER)
def meter_features_stats_reply_handler(self, ev):
    features = []
    for stat in ev.msg.body:
        features.append('max_meter=%d band_types=0x%08x '
                        'capabilities=0x%08x max_bands=%d '
                        'max_color=%d' %
                        (stat.max_meter, stat.band_types,
                         stat.capabilities, stat.max_bands,
                         stat.max_color))
    self.logger.debug('MeterFeaturesStats: %s', features)

JSON Example:

{
   "OFPMeterFeaturesStatsReply": {
      "body": [
         {
            "OFPMeterFeaturesStats": {
               "band_types": 2147483654, 
               "capabilities": 15, 
               "max_bands": 255, 
               "max_color": 0, 
               "max_meter": 16777216
            }
         }
      ], 
      "flags": 0, 
      "type": 11
   }
}
class ryu.ofproto.ofproto_v1_3_parser.OFPTableFeaturesStatsRequest(datapath, flags=0, body=None, type_=None)

Table features statistics request message

The controller uses this message to query table features.

Attribute Description
body List of OFPTableFeaturesStats instances. The default is [].
class ryu.ofproto.ofproto_v1_3_parser.OFPTableFeaturesStatsReply(datapath, type_=None, **kwargs)

Table features statistics reply message

The switch responds with this message to a table features statistics request.

Attribute Description
body List of OFPTableFeaturesStats instance

JSON Example:

See an example in:

ryu/tests/unit/ofproto/json/of13/4-56-ofp_table_features_reply.packet.json

Queue Configuration Messages

class ryu.ofproto.ofproto_v1_3_parser.OFPQueueGetConfigRequest(datapath, port)

Queue configuration request message

Attribute Description
port Port to be queried (OFPP_ANY to all configured queues)

Example:

def send_queue_get_config_request(self, datapath):
    ofp = datapath.ofproto
    ofp_parser = datapath.ofproto_parser

    req = ofp_parser.OFPQueueGetConfigRequest(datapath, ofp.OFPP_ANY)
    datapath.send_msg(req)

JSON Example:

{
   "OFPQueueGetConfigRequest": {
      "port": 4294967295
   }
}
class ryu.ofproto.ofproto_v1_3_parser.OFPQueueGetConfigReply(datapath, queues=None, port=None)

Queue configuration reply message

The switch responds with this message to a queue configuration request.

Attribute Description
queues list of OFPPacketQueue instance
port Port which was queried

Example:

@set_ev_cls(ofp_event.EventOFPQueueGetConfigReply, MAIN_DISPATCHER)
def queue_get_config_reply_handler(self, ev):
    msg = ev.msg

    self.logger.debug('OFPQueueGetConfigReply received: '
                      'port=%s queues=%s',
                      msg.port, msg.queues)

JSON Example:

{
   "OFPQueueGetConfigReply": {
      "port": 4294967295, 
      "queues": [
         {
            "OFPPacketQueue": {
               "len": 64, 
               "port": 77, 
               "properties": [
                  {
                     "OFPQueuePropMinRate": {
                        "len": 16, 
                        "property": 1, 
                        "rate": 10
                     }
                  }, 
                  {
                     "OFPQueuePropMaxRate": {
                        "len": 16, 
                        "property": 2, 
                        "rate": 900
                     }
                  },
                  {
                     "OFPQueuePropExperimenter": {
                        "data": [], 
                        "experimenter": 999, 
                        "len": 16, 
                        "property": 65535
                     }
                  }
               ], 
               "queue_id": 99
            }
         }, 
         {
            "OFPPacketQueue": {
               "len": 65, 
               "port": 77, 
               "properties": [
                  {
                     "OFPQueuePropMinRate": {
                        "len": 16, 
                        "property": 1, 
                        "rate": 100
                     }
                  }, 
                  {
                     "OFPQueuePropMaxRate": {
                        "len": 16, 
                        "property": 2, 
                        "rate": 200
                     }
                  },
                  {
                     "OFPQueuePropExperimenter": {
                        "experimenter": 999, 
                        "data": [
                           1
                        ], 
                        "len": 17, 
                        "property": 65535
                     }
                  }
               ], 
               "queue_id": 88
            }
         },
         {
            "OFPPacketQueue": {
               "len": 66, 
               "port": 77, 
               "properties": [
                  {
                     "OFPQueuePropMinRate": {
                        "len": 16, 
                        "property": 1, 
                        "rate": 200
                     }
                  }, 
                  {
                     "OFPQueuePropMaxRate": {
                        "len": 16, 
                        "property": 2, 
                        "rate": 400
                     }
                  },
                  {
                     "OFPQueuePropExperimenter": {
                        "experimenter": 999, 
                        "data": [
                           1, 
                           2
                        ], 
                        "len": 18, 
                        "property": 65535
                     }
                  }
               ], 
               "queue_id": 77
            }
         }
      ]
   }
}

Packet-Out Message

class ryu.ofproto.ofproto_v1_3_parser.OFPPacketOut(datapath, buffer_id=None, in_port=None, actions=None, data=None, actions_len=None)

Packet-Out message

The controller uses this message to send a packet out throught the switch.

Attribute Description
buffer_id ID assigned by datapath (OFP_NO_BUFFER if none)
in_port Packet’s input port or OFPP_CONTROLLER
actions list of OpenFlow action class
data Packet data of a binary type value or an instances of packet.Packet.

Example:

def send_packet_out(self, datapath, buffer_id, in_port):
    ofp = datapath.ofproto
    ofp_parser = datapath.ofproto_parser

    actions = [ofp_parser.OFPActionOutput(ofp.OFPP_FLOOD, 0)]
    req = ofp_parser.OFPPacketOut(datapath, buffer_id,
                                  in_port, actions)
    datapath.send_msg(req)

JSON Example:

{
   "OFPPacketOut": {
      "actions": [
         {
            "OFPActionOutput": {
               "len": 16, 
               "max_len": 65535, 
               "port": 4294967292, 
               "type": 0
            }
         }
      ], 
      "actions_len": 16, 
      "buffer_id": 4294967295, 
      "data": "8guk0D9w8gukffjqCABFAABU+BoAAP8Br4sKAAABCgAAAggAAgj3YAAAMdYCAAAAAACrjS0xAAAAABAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vAAAAAAAAAAA=", 
      "in_port": 4294967293
   }
}

Barrier Message

class ryu.ofproto.ofproto_v1_3_parser.OFPBarrierRequest(datapath)

Barrier request message

The controller sends this message to ensure message dependencies have been met or receive notifications for completed operations.

Example:

def send_barrier_request(self, datapath):
    ofp_parser = datapath.ofproto_parser

    req = ofp_parser.OFPBarrierRequest(datapath)
    datapath.send_msg(req)

JSON Example:

{
   "OFPBarrierRequest": {}
}
class ryu.ofproto.ofproto_v1_3_parser.OFPBarrierReply(datapath)

Barrier reply message

The switch responds with this message to a barrier request.

Example:

@set_ev_cls(ofp_event.EventOFPBarrierReply, MAIN_DISPATCHER)
def barrier_reply_handler(self, ev):
    self.logger.debug('OFPBarrierReply received')

JSON Example:

{
   "OFPBarrierReply": {}
}

Role Request Message

class ryu.ofproto.ofproto_v1_3_parser.OFPRoleRequest(datapath, role=None, generation_id=None)

Role request message

The controller uses this message to change its role.

Attribute Description
role

One of the following values.

OFPCR_ROLE_NOCHANGE
OFPCR_ROLE_EQUAL
OFPCR_ROLE_MASTER
OFPCR_ROLE_SLAVE
generation_id Master Election Generation ID

Example:

def send_role_request(self, datapath):
    ofp = datapath.ofproto
    ofp_parser = datapath.ofproto_parser

    req = ofp_parser.OFPRoleRequest(datapath, ofp.OFPCR_ROLE_EQUAL, 0)
    datapath.send_msg(req)

JSON Example:

{
   "OFPRoleRequest": {
      "generation_id": 17294086455919964160, 
      "role": 2
   }
}
class ryu.ofproto.ofproto_v1_3_parser.OFPRoleReply(datapath, role=None, generation_id=None)

Role reply message

The switch responds with this message to a role request.

Attribute Description
role

One of the following values.

OFPCR_ROLE_NOCHANGE
OFPCR_ROLE_EQUAL
OFPCR_ROLE_MASTER
OFPCR_ROLE_SLAVE
generation_id Master Election Generation ID

Example:

@set_ev_cls(ofp_event.EventOFPRoleReply, MAIN_DISPATCHER)
def role_reply_handler(self, ev):
    msg = ev.msg
    dp = msg.datapath
    ofp = dp.ofproto

    if msg.role == ofp.OFPCR_ROLE_NOCHANGE:
        role = 'NOCHANGE'
    elif msg.role == ofp.OFPCR_ROLE_EQUAL:
        role = 'EQUAL'
    elif msg.role == ofp.OFPCR_ROLE_MASTER:
        role = 'MASTER'
    elif msg.role == ofp.OFPCR_ROLE_SLAVE:
        role = 'SLAVE'
    else:
        role = 'unknown'

    self.logger.debug('OFPRoleReply received: '
                      'role=%s generation_id=%d',
                      role, msg.generation_id)

JSON Example:

{
   "OFPRoleReply": {
      "generation_id": 17294086455919964160, 
      "role": 3
   }
}

Set Asynchronous Configuration Message

class ryu.ofproto.ofproto_v1_3_parser.OFPSetAsync(datapath, packet_in_mask, port_status_mask, flow_removed_mask)

Set asynchronous configuration message

The controller sends this message to set the asynchronous messages that it wants to receive on a given OpneFlow channel.

Attribute Description
packet_in_mask

2-element array: element 0, when the controller has a OFPCR_ROLE_EQUAL or OFPCR_ROLE_MASTER role. element 1, OFPCR_ROLE_SLAVE role controller. Bitmasks of following values.

OFPR_NO_MATCH
OFPR_ACTION
OFPR_INVALID_TTL
port_status_mask

2-element array. Bitmasks of following values.

OFPPR_ADD
OFPPR_DELETE
OFPPR_MODIFY
flow_removed_mask

2-element array. Bitmasks of following values.

OFPRR_IDLE_TIMEOUT
OFPRR_HARD_TIMEOUT
OFPRR_DELETE
OFPRR_GROUP_DELETE

Example:

def send_set_async(self, datapath):
    ofp = datapath.ofproto
    ofp_parser = datapath.ofproto_parser

    packet_in_mask = 1 << ofp.OFPR_ACTION | 1 << ofp.OFPR_INVALID_TTL
    port_status_mask = (1 << ofp.OFPPR_ADD
                        | 1 << ofp.OFPPR_DELETE
                        | 1 << ofp.OFPPR_MODIFY)
    flow_removed_mask = (1 << ofp.OFPRR_IDLE_TIMEOUT
                         | 1 << ofp.OFPRR_HARD_TIMEOUT
                         | 1 << ofp.OFPRR_DELETE)
    req = ofp_parser.OFPSetAsync(datapath,
                                 [packet_in_mask, 0],
                                 [port_status_mask, 0],
                                 [flow_removed_mask, 0])
    datapath.send_msg(req)

JSON Example:

{
   "OFPSetAsync": {
      "flow_removed_mask": [
         15, 
         3
      ], 
      "packet_in_mask": [
         5, 
         1
      ], 
      "port_status_mask": [
         7, 
         3
      ]
   }
}
class ryu.ofproto.ofproto_v1_3_parser.OFPGetAsyncRequest(datapath)

Get asynchronous configuration request message

The controller uses this message to query the asynchronous message.

Example:

def send_get_async_request(self, datapath):
    ofp_parser = datapath.ofproto_parser

    req = ofp_parser.OFPGetAsyncRequest(datapath)
    datapath.send_msg(req)

JSON Example:

{
   "OFPGetAsyncRequest": {}
}
class ryu.ofproto.ofproto_v1_3_parser.OFPGetAsyncReply(datapath, packet_in_mask=None, port_status_mask=None, flow_removed_mask=None)

Get asynchronous configuration reply message

The switch responds with this message to a get asynchronous configuration request.

Attribute Description
packet_in_mask

2-element array: element 0, when the controller has a OFPCR_ROLE_EQUAL or OFPCR_ROLE_MASTER role. element 1, OFPCR_ROLE_SLAVE role controller. Bitmasks of following values.

OFPR_NO_MATCH
OFPR_ACTION
OFPR_INVALID_TTL
port_status_mask

2-element array. Bitmasks of following values.

OFPPR_ADD
OFPPR_DELETE
OFPPR_MODIFY
flow_removed_mask

2-element array. Bitmasks of following values.

OFPRR_IDLE_TIMEOUT
OFPRR_HARD_TIMEOUT
OFPRR_DELETE
OFPRR_GROUP_DELETE

Example:

@set_ev_cls(ofp_event.EventOFPGetAsyncReply, MAIN_DISPATCHER)
def get_async_reply_handler(self, ev):
    msg = ev.msg

    self.logger.debug('OFPGetAsyncReply received: '
                      'packet_in_mask=0x%08x:0x%08x '
                      'port_status_mask=0x%08x:0x%08x '
                      'flow_removed_mask=0x%08x:0x%08x',
                      msg.packet_in_mask[0],
                      msg.packet_in_mask[1],
                      msg.port_status_mask[0],
                      msg.port_status_mask[1],
                      msg.flow_removed_mask[0],
                      msg.flow_removed_mask[1])

JSON Example:

{
   "OFPGetAsyncReply": {
      "flow_removed_mask": [
         15, 
         3
      ], 
      "packet_in_mask": [
         5, 
         1
      ], 
      "port_status_mask": [
         7, 
         3
      ]
   }
}

Asynchronous Messages

Packet-In Message

class ryu.ofproto.ofproto_v1_3_parser.OFPPacketIn(datapath, buffer_id=None, total_len=None, reason=None, table_id=None, cookie=None, match=None, data=None)

Packet-In message

The switch sends the packet that received to the controller by this message.

Attribute Description
buffer_id ID assigned by datapath
total_len Full length of frame
reason

Reason packet is being sent.

OFPR_NO_MATCH
OFPR_ACTION
OFPR_INVALID_TTL
table_id ID of the table that was looked up
cookie Cookie of the flow entry that was looked up
match Instance of OFPMatch
data Ethernet frame

Example:

@set_ev_cls(ofp_event.EventOFPPacketIn, MAIN_DISPATCHER)
def packet_in_handler(self, ev):
    msg = ev.msg
    dp = msg.datapath
    ofp = dp.ofproto

    if msg.reason == ofp.OFPR_NO_MATCH:
        reason = 'NO MATCH'
    elif msg.reason == ofp.OFPR_ACTION:
        reason = 'ACTION'
    elif msg.reason == ofp.OFPR_INVALID_TTL:
        reason = 'INVALID TTL'
    else:
        reason = 'unknown'

    self.logger.debug('OFPPacketIn received: '
                      'buffer_id=%x total_len=%d reason=%s '
                      'table_id=%d cookie=%d match=%s data=%s',
                      msg.buffer_id, msg.total_len, reason,
                      msg.table_id, msg.cookie, msg.match,
                      utils.hex_array(msg.data))

JSON Example:

{
   "OFPPacketIn": {
      "buffer_id": 2, 
      "cookie": 283686884868096, 
      "data": "////////8gukffjqCAYAAQgABgQAAfILpH346goAAAEAAAAAAAAKAAAD", 
      "match": {
         "OFPMatch": {
            "length": 80, 
            "oxm_fields": [
               {
                  "OXMTlv": {
                     "field": "in_port", 
                     "mask": null, 
                     "value": 6
                  }
               }, 
               {
                  "OXMTlv": {
                     "field": "eth_type", 
                     "mask": null, 
                     "value": 2054
                  }
               }, 
               {
                  "OXMTlv": {
                     "field": "eth_dst", 
                     "mask": null, 
                     "value": "ff:ff:ff:ff:ff:ff"
                  }
               }, 
               {
                  "OXMTlv": {
                     "field": "eth_src", 
                     "mask": null, 
                     "value": "f2:0b:a4:7d:f8:ea"
                  }
               }, 
               {
                  "OXMTlv": {
                     "field": "arp_op", 
                     "mask": null, 
                     "value": 1
                  }
               }, 
               {
                  "OXMTlv": {
                     "field": "arp_spa", 
                     "mask": null, 
                     "value": "10.0.0.1"
                  }
               }, 
               {
                  "OXMTlv": {
                     "field": "arp_tpa", 
                     "mask": null, 
                     "value": "10.0.0.3"
                  }
               }, 
               {
                  "OXMTlv": {
                     "field": "arp_sha", 
                     "mask": null, 
                     "value": "f2:0b:a4:7d:f8:ea"
                  }
               }, 
               {
                  "OXMTlv": {
                     "field": "arp_tha", 
                     "mask": null, 
                     "value": "00:00:00:00:00:00"
                  }
               }
            ], 
            "type": 1
         }
      }, 
      "reason": 1, 
      "table_id": 1, 
      "total_len": 42
   }
}

Flow Removed Message

class ryu.ofproto.ofproto_v1_3_parser.OFPFlowRemoved(datapath, cookie=None, priority=None, reason=None, table_id=None, duration_sec=None, duration_nsec=None, idle_timeout=None, hard_timeout=None, packet_count=None, byte_count=None, match=None)

Flow removed message

When flow entries time out or are deleted, the switch notifies controller with this message.

Attribute Description
cookie Opaque controller-issued identifier
priority Priority level of flow entry
reason

One of the following values.

OFPRR_IDLE_TIMEOUT
OFPRR_HARD_TIMEOUT
OFPRR_DELETE
OFPRR_GROUP_DELETE
table_id ID of the table
duration_sec Time flow was alive in seconds
duration_nsec Time flow was alive in nanoseconds beyond duration_sec
idle_timeout Idle timeout from original flow mod
hard_timeout Hard timeout from original flow mod
packet_count Number of packets that was associated with the flow
byte_count Number of bytes that was associated with the flow
match Instance of OFPMatch

Example:

@set_ev_cls(ofp_event.EventOFPFlowRemoved, MAIN_DISPATCHER)
def flow_removed_handler(self, ev):
    msg = ev.msg
    dp = msg.datapath
    ofp = dp.ofproto

    if msg.reason == ofp.OFPRR_IDLE_TIMEOUT:
        reason = 'IDLE TIMEOUT'
    elif msg.reason == ofp.OFPRR_HARD_TIMEOUT:
        reason = 'HARD TIMEOUT'
    elif msg.reason == ofp.OFPRR_DELETE:
        reason = 'DELETE'
    elif msg.reason == ofp.OFPRR_GROUP_DELETE:
        reason = 'GROUP DELETE'
    else:
        reason = 'unknown'

    self.logger.debug('OFPFlowRemoved received: '
                      'cookie=%d priority=%d reason=%s table_id=%d '
                      'duration_sec=%d duration_nsec=%d '
                      'idle_timeout=%d hard_timeout=%d '
                      'packet_count=%d byte_count=%d match.fields=%s',
                      msg.cookie, msg.priority, reason, msg.table_id,
                      msg.duration_sec, msg.duration_nsec,
                      msg.idle_timeout, msg.hard_timeout,
                      msg.packet_count, msg.byte_count, msg.match)

JSON Example:

{
   "OFPFlowRemoved": {
      "byte_count": 86, 
      "cookie": 0, 
      "duration_nsec": 48825000, 
      "duration_sec": 3, 
      "hard_timeout": 0, 
      "idle_timeout": 3, 
      "match": {
         "OFPMatch": {
            "length": 14, 
            "oxm_fields": [
               {
                  "OXMTlv": {
                     "field": "eth_dst", 
                     "mask": null, 
                     "value": "f2:0b:a4:7d:f8:ea"
                  }
               }
            ], 
            "type": 1
         }
      }, 
      "packet_count": 1, 
      "priority": 65535, 
      "reason": 0, 
      "table_id": 0
   }
}

Port Status Message

class ryu.ofproto.ofproto_v1_3_parser.OFPPortStatus(datapath, reason=None, desc=None)

Port status message

The switch notifies controller of change of ports.

Attribute Description
reason

One of the following values.

OFPPR_ADD
OFPPR_DELETE
OFPPR_MODIFY
desc instance of OFPPort

Example:

@set_ev_cls(ofp_event.EventOFPPortStatus, MAIN_DISPATCHER)
def port_status_handler(self, ev):
    msg = ev.msg
    dp = msg.datapath
    ofp = dp.ofproto

    if msg.reason == ofp.OFPPR_ADD:
        reason = 'ADD'
    elif msg.reason == ofp.OFPPR_DELETE:
        reason = 'DELETE'
    elif msg.reason == ofp.OFPPR_MODIFY:
        reason = 'MODIFY'
    else:
        reason = 'unknown'

    self.logger.debug('OFPPortStatus received: reason=%s desc=%s',
                      reason, msg.desc)

JSON Example:

{
   "OFPPortStatus": {
      "desc": {
         "OFPPort": {
            "advertised": 10240, 
            "config": 0, 
            "curr": 10248, 
            "curr_speed": 5000, 
            "hw_addr": "f2:0b:a4:d0:3f:70", 
            "max_speed": 5000, 
            "name": "\u79c1\u306e\u30dd\u30fc\u30c8", 
            "peer": 10248, 
            "port_no": 7, 
            "state": 4, 
            "supported": 10248
         }
      }, 
      "reason": 0
   }
}

Error Message

class ryu.ofproto.ofproto_v1_3_parser.OFPErrorMsg(datapath, type_=None, code=None, data=None, **kwargs)

Error message

The switch notifies controller of problems by this message.

Attribute Description
type High level type of error
code Details depending on the type
data Variable length data depending on the type and code

type attribute corresponds to type_ parameter of __init__.

Types and codes are defined in ryu.ofproto.ofproto.

Type Code
OFPET_HELLO_FAILED OFPHFC_*
OFPET_BAD_REQUEST OFPBRC_*
OFPET_BAD_ACTION OFPBAC_*
OFPET_BAD_INSTRUCTION OFPBIC_*
OFPET_BAD_MATCH OFPBMC_*
OFPET_FLOW_MOD_FAILED OFPFMFC_*
OFPET_GROUP_MOD_FAILED OFPGMFC_*
OFPET_PORT_MOD_FAILED OFPPMFC_*
OFPET_TABLE_MOD_FAILED OFPTMFC_*
OFPET_QUEUE_OP_FAILED OFPQOFC_*
OFPET_SWITCH_CONFIG_FAILED OFPSCFC_*
OFPET_ROLE_REQUEST_FAILED OFPRRFC_*
OFPET_METER_MOD_FAILED OFPMMFC_*
OFPET_TABLE_FEATURES_FAILED OFPTFFC_*
OFPET_EXPERIMENTER N/A

If type == OFPET_EXPERIMENTER, this message has also the following attributes.

Attribute Description
exp_type Experimenter defined type
experimenter Experimenter ID

Example:

@set_ev_cls(ofp_event.EventOFPErrorMsg,
            [HANDSHAKE_DISPATCHER, CONFIG_DISPATCHER, MAIN_DISPATCHER])
def error_msg_handler(self, ev):
    msg = ev.msg

    self.logger.debug('OFPErrorMsg received: type=0x%02x code=0x%02x '
                      'message=%s',
                      msg.type, msg.code, utils.hex_array(msg.data))

JSON Example:

{
   "OFPErrorMsg": {
      "code": 11, 
      "data": "ZnVnYWZ1Z2E=", 
      "type": 2
   }
}

Symmetric Messages

Hello

class ryu.ofproto.ofproto_v1_3_parser.OFPHello(datapath, elements=None)

Hello message

When connection is started, the hello message is exchanged between a switch and a controller.

This message is handled by the Ryu framework, so the Ryu application do not need to process this typically.

Attribute Description
elements list of OFPHelloElemVersionBitmap instance

JSON Example:

{
   "OFPHello": {
      "elements": [
         {
            "OFPHelloElemVersionBitmap": {
               "length": 8, 
               "type": 1, 
               "versions": [
                  1, 
                  2, 
                  3, 
                  9, 
                  10, 
                  30
               ]
            }
         }
      ]
   }
}
class ryu.ofproto.ofproto_v1_3_parser.OFPHelloElemVersionBitmap(versions, type_=None, length=None)

Version bitmap Hello Element

Attribute Description
versions list of versions of OpenFlow protocol a device supports

Echo Request

class ryu.ofproto.ofproto_v1_3_parser.OFPEchoRequest(datapath, data=None)

Echo request message

This message is handled by the Ryu framework, so the Ryu application do not need to process this typically.

Attribute Description
data An arbitrary length data

Example:

def send_echo_request(self, datapath, data):
    ofp_parser = datapath.ofproto_parser

    req = ofp_parser.OFPEchoRequest(datapath, data)
    datapath.send_msg(req)

@set_ev_cls(ofp_event.EventOFPEchoRequest,
            [HANDSHAKE_DISPATCHER, CONFIG_DISPATCHER, MAIN_DISPATCHER])
def echo_request_handler(self, ev):
    self.logger.debug('OFPEchoRequest received: data=%s',
                      utils.hex_array(ev.msg.data))

JSON Example:

{
   "OFPEchoRequest": {
      "data": "aG9nZQ=="
   }
}

Echo Reply

class ryu.ofproto.ofproto_v1_3_parser.OFPEchoReply(datapath, data=None)

Echo reply message

This message is handled by the Ryu framework, so the Ryu application do not need to process this typically.

Attribute Description
data An arbitrary length data

Example:

def send_echo_reply(self, datapath, data):
    ofp_parser = datapath.ofproto_parser

    reply = ofp_parser.OFPEchoReply(datapath, data)
    datapath.send_msg(reply)

@set_ev_cls(ofp_event.EventOFPEchoReply,
            [HANDSHAKE_DISPATCHER, CONFIG_DISPATCHER, MAIN_DISPATCHER])
def echo_reply_handler(self, ev):
    self.logger.debug('OFPEchoReply received: data=%s',
                      utils.hex_array(ev.msg.data))

JSON Example:

{
   "OFPEchoReply": {
      "data": "aG9nZQ=="
   }
}

Experimenter

class ryu.ofproto.ofproto_v1_3_parser.OFPExperimenter(datapath, experimenter=None, exp_type=None, data=None)

Experimenter extension message

Attribute Description
experimenter Experimenter ID
exp_type Experimenter defined
data Experimenter defined arbitrary additional data

JSON Example:

{
   "OFPExperimenter": {
      "data": "bmF6bw==", 
      "exp_type": 123456789, 
      "experimenter": 98765432
   }
}

Port Structures

class ryu.ofproto.ofproto_v1_3_parser.OFPPort

Description of a port

Attribute Description
port_no Port number and it uniquely identifies a port within a switch.
hw_addr MAC address for the port.
name Null-terminated string containing a human-readable name for the interface.
config

Bitmap of port configration flags.

OFPPC_PORT_DOWN
OFPPC_NO_RECV
OFPPC_NO_FWD
OFPPC_NO_PACKET_IN
state

Bitmap of port state flags.

OFPPS_LINK_DOWN
OFPPS_BLOCKED
OFPPS_LIVE
curr Current features.
advertised Features being advertised by the port.
supported Features supported by the port.
peer Features advertised by peer.
curr_speed Current port bitrate in kbps.
max_speed Max port bitrate in kbps.

Flow Match Structure

class ryu.ofproto.ofproto_v1_3_parser.OFPMatch(type_=None, length=None, _ordered_fields=None, **kwargs)

Flow Match Structure

This class is implementation of the flow match structure having compose/query API. There are new API and old API for compatibility. the old API is supposed to be removed later.

You can define the flow match by the keyword arguments. The following arguments are available.

Argument Value Description
in_port Integer 32bit Switch input port
in_phy_port Integer 32bit Switch physical input port
metadata Integer 64bit Metadata passed between tables
eth_dst MAC address Ethernet destination address
eth_src MAC address Ethernet source address
eth_type Integer 16bit Ethernet frame type
vlan_vid Integer 16bit VLAN id
vlan_pcp Integer 8bit VLAN priority
ip_dscp Integer 8bit IP DSCP (6 bits in ToS field)
ip_ecn Integer 8bit IP ECN (2 bits in ToS field)
ip_proto Integer 8bit IP protocol
ipv4_src IPv4 address IPv4 source address
ipv4_dst IPv4 address IPv4 destination address
tcp_src Integer 16bit TCP source port
tcp_dst Integer 16bit TCP destination port
udp_src Integer 16bit UDP source port
udp_dst Integer 16bit UDP destination port
sctp_src Integer 16bit SCTP source port
sctp_dst Integer 16bit SCTP destination port
icmpv4_type Integer 8bit ICMP type
icmpv4_code Integer 8bit ICMP code
arp_op Integer 16bit ARP opcode
arp_spa IPv4 address ARP source IPv4 address
arp_tpa IPv4 address ARP target IPv4 address
arp_sha MAC address ARP source hardware address
arp_tha MAC address ARP target hardware address
ipv6_src IPv6 address IPv6 source address
ipv6_dst IPv6 address IPv6 destination address
ipv6_flabel Integer 32bit IPv6 Flow Label
icmpv6_type Integer 8bit ICMPv6 type
icmpv6_code Integer 8bit ICMPv6 code
ipv6_nd_target IPv6 address Target address for ND
ipv6_nd_sll MAC address Source link-layer for ND
ipv6_nd_tll MAC address Target link-layer for ND
mpls_label Integer 32bit MPLS label
mpls_tc Integer 8bit MPLS TC
mpls_bos Integer 8bit MPLS BoS bit
pbb_isid Integer 24bit PBB I-SID
tunnel_id Integer 64bit Logical Port Metadata
ipv6_exthdr Integer 16bit IPv6 Extension Header pseudo-field
pbb_uca Integer 8bit PBB UCA header field (EXT-256 Old version of ONF Extension)
tcp_flags Integer 16bit TCP flags (EXT-109 ONF Extension)
actset_output Integer 32bit Output port from action set metadata (EXT-233 ONF Extension)

Example:

>>> # compose
>>> match = parser.OFPMatch(
...     in_port=1,
...     eth_type=0x86dd,
...     ipv6_src=('2001:db8:bd05:1d2:288a:1fc0:1:10ee',
...               'ffff:ffff:ffff:ffff::'),
...     ipv6_dst='2001:db8:bd05:1d2:288a:1fc0:1:10ee')
>>> # query
>>> if 'ipv6_src' in match:
...     print match['ipv6_src']
...
('2001:db8:bd05:1d2:288a:1fc0:1:10ee', 'ffff:ffff:ffff:ffff::')

Note

For the list of the supported Nicira experimenter matches, please refer to ryu.ofproto.nx_match.

Note

For VLAN id match field, special values are defined in OpenFlow Spec.

  1. Packets with and without a VLAN tag

    • Example:

      match = parser.OFPMatch()
      
    • Packet Matching

      non-VLAN-tagged MATCH
      VLAN-tagged(vlan_id=3) MATCH
      VLAN-tagged(vlan_id=5) MATCH
  2. Only packets without a VLAN tag

    • Example:

      match = parser.OFPMatch(vlan_vid=0x0000)
      
    • Packet Matching

      non-VLAN-tagged MATCH
      VLAN-tagged(vlan_id=3) x
      VLAN-tagged(vlan_id=5) x
  3. Only packets with a VLAN tag regardless of its value

    • Example:

      match = parser.OFPMatch(vlan_vid=(0x1000, 0x1000))
      
    • Packet Matching

      non-VLAN-tagged x
      VLAN-tagged(vlan_id=3) MATCH
      VLAN-tagged(vlan_id=5) MATCH
  4. Only packets with VLAN tag and VID equal

    • Example:

      match = parser.OFPMatch(vlan_vid=(0x1000 | 3))
      
    • Packet Matching

      non-VLAN-tagged x
      VLAN-tagged(vlan_id=3) MATCH
      VLAN-tagged(vlan_id=5) x

Flow Instruction Structures

class ryu.ofproto.ofproto_v1_3_parser.OFPInstructionGotoTable(table_id, type_=None, len_=None)

Goto table instruction

This instruction indicates the next table in the processing pipeline.

Attribute Description
table_id Next table
class ryu.ofproto.ofproto_v1_3_parser.OFPInstructionWriteMetadata(metadata, metadata_mask, type_=None, len_=None)

Write metadata instruction

This instruction writes the masked metadata value into the metadata field.

Attribute Description
metadata Metadata value to write
metadata_mask Metadata write bitmask
class ryu.ofproto.ofproto_v1_3_parser.OFPInstructionActions(type_, actions=None, len_=None)

Actions instruction

This instruction writes/applies/clears the actions.

Attribute Description
type

One of following values.

OFPIT_WRITE_ACTIONS
OFPIT_APPLY_ACTIONS
OFPIT_CLEAR_ACTIONS
actions list of OpenFlow action class

type attribute corresponds to type_ parameter of __init__.

class ryu.ofproto.ofproto_v1_3_parser.OFPInstructionMeter(meter_id=1, type_=None, len_=None)

Meter instruction

This instruction applies the meter.

Attribute Description
meter_id Meter instance

Action Structures

class ryu.ofproto.ofproto_v1_3_parser.OFPActionOutput(port, max_len=65509, type_=None, len_=None)

Output action

This action indicates output a packet to the switch port.

Attribute Description
port Output port
max_len Max length to send to controller
class ryu.ofproto.ofproto_v1_3_parser.OFPActionGroup(group_id=0, type_=None, len_=None)

Group action

This action indicates the group used to process the packet.

Attribute Description
group_id Group identifier
class ryu.ofproto.ofproto_v1_3_parser.OFPActionSetQueue(queue_id, type_=None, len_=None)

Set queue action

This action sets the queue id that will be used to map a flow to an already-configured queue on a port.

Attribute Description
queue_id Queue ID for the packets
class ryu.ofproto.ofproto_v1_3_parser.OFPActionSetMplsTtl(mpls_ttl, type_=None, len_=None)

Set MPLS TTL action

This action sets the MPLS TTL.

Attribute Description
mpls_ttl MPLS TTL
class ryu.ofproto.ofproto_v1_3_parser.OFPActionDecMplsTtl(type_=None, len_=None)

Decrement MPLS TTL action

This action decrements the MPLS TTL.

class ryu.ofproto.ofproto_v1_3_parser.OFPActionSetNwTtl(nw_ttl, type_=None, len_=None)

Set IP TTL action

This action sets the IP TTL.

Attribute Description
nw_ttl IP TTL
class ryu.ofproto.ofproto_v1_3_parser.OFPActionDecNwTtl(type_=None, len_=None)

Decrement IP TTL action

This action decrements the IP TTL.

class ryu.ofproto.ofproto_v1_3_parser.OFPActionCopyTtlOut(type_=None, len_=None)

Copy TTL Out action

This action copies the TTL from the next-to-outermost header with TTL to the outermost header with TTL.

class ryu.ofproto.ofproto_v1_3_parser.OFPActionCopyTtlIn(type_=None, len_=None)

Copy TTL In action

This action copies the TTL from the outermost header with TTL to the next-to-outermost header with TTL.

class ryu.ofproto.ofproto_v1_3_parser.OFPActionPushVlan(ethertype=33024, type_=None, len_=None)

Push VLAN action

This action pushes a new VLAN tag to the packet.

Attribute Description
ethertype Ether type. The default is 802.1Q. (0x8100)
class ryu.ofproto.ofproto_v1_3_parser.OFPActionPushMpls(ethertype=34887, type_=None, len_=None)

Push MPLS action

This action pushes a new MPLS header to the packet.

Attribute Description
ethertype Ether type
class ryu.ofproto.ofproto_v1_3_parser.OFPActionPopVlan(type_=None, len_=None)

Pop VLAN action

This action pops the outermost VLAN tag from the packet.

class ryu.ofproto.ofproto_v1_3_parser.OFPActionPopMpls(ethertype=2048, type_=None, len_=None)

Pop MPLS action

This action pops the MPLS header from the packet.

class ryu.ofproto.ofproto_v1_3_parser.OFPActionSetField(field=None, **kwargs)

Set field action

This action modifies a header field in the packet.

The set of keywords available for this is same as OFPMatch.

Example:

set_field = OFPActionSetField(eth_src="00:00:00:00:00:00")
class ryu.ofproto.ofproto_v1_3_parser.OFPActionExperimenter(experimenter)

Experimenter action

This action is an extensible action for the experimenter.

Attribute Description
experimenter Experimenter ID

Note

For the list of the supported Nicira experimenter actions, please refer to ryu.ofproto.nx_actions.