This patch deletes some NX Actions in ofproto_v1_0_parser and fixes to use actions in nx_actions.py. Together, delete Obsolete action in OVS.
Signed-off-by: Shinpei Muraoka <[email protected]> --- ryu/ofproto/nx_actions.py | 2 +- ryu/ofproto/ofproto_v1_0.py | 2 + ryu/ofproto/ofproto_v1_0_parser.py | 534 ++++-------------------------- ryu/tests/unit/ofproto/test_parser_v10.py | 126 ------- 4 files changed, 62 insertions(+), 602 deletions(-) diff --git a/ryu/ofproto/nx_actions.py b/ryu/ofproto/nx_actions.py index b91ce95..a442868 100644 --- a/ryu/ofproto/nx_actions.py +++ b/ryu/ofproto/nx_actions.py @@ -154,7 +154,7 @@ def generate(ofp_name, ofpp_name): _experimenter = ofproto_common.NX_EXPERIMENTER_ID def __init__(self): - super(NXAction, self).__init__(experimenter=self._experimenter) + super(NXAction, self).__init__(self._experimenter) self.subtype = self._subtype @classmethod diff --git a/ryu/ofproto/ofproto_v1_0.py b/ryu/ofproto/ofproto_v1_0.py index afc59d0..0ba0620 100644 --- a/ryu/ofproto/ofproto_v1_0.py +++ b/ryu/ofproto/ofproto_v1_0.py @@ -227,6 +227,8 @@ OFP_ACTION_VENDOR_HEADER_PACK_STR = '!HHI' OFP_ACTION_VENDOR_HEADER_SIZE = 8 assert (calcsize(OFP_ACTION_VENDOR_HEADER_PACK_STR) == OFP_ACTION_VENDOR_HEADER_SIZE) +# OpenFlow1.2 or later compatible +OFP_ACTION_EXPERIMENTER_HEADER_SIZE = OFP_ACTION_VENDOR_HEADER_SIZE OFP_ACTION_HEADER_PACK_STR = '!HH4x' OFP_ACTION_HEADER_SIZE = 8 diff --git a/ryu/ofproto/ofproto_v1_0_parser.py b/ryu/ofproto/ofproto_v1_0_parser.py index 0ccc64e..a34564b 100644 --- a/ryu/ofproto/ofproto_v1_0_parser.py +++ b/ryu/ofproto/ofproto_v1_0_parser.py @@ -28,10 +28,11 @@ from ryu.lib import addrconv from ryu.lib import ip from ryu.lib import mac from ryu.lib.pack_utils import msg_pack_into +from ryu.ofproto import nx_match from ryu.ofproto import ofproto_common from ryu.ofproto import ofproto_parser from ryu.ofproto import ofproto_v1_0 as ofproto -from ryu.ofproto import nx_match +from ryu.ofproto import nx_actions from ryu import utils import logging @@ -784,16 +785,63 @@ class OFPActionVendor(OFPAction): return cls return _register_action_vendor - def __init__(self): + def __init__(self, vendor=None): super(OFPActionVendor, self).__init__() - self.vendor = self.cls_vendor + self.type = ofproto.OFPAT_VENDOR + self.len = None + + if vendor is None: + self.vendor = self.cls_vendor + else: + self.vendor = vendor @classmethod def parser(cls, buf, offset): type_, len_, vendor = struct.unpack_from( ofproto.OFP_ACTION_VENDOR_HEADER_PACK_STR, buf, offset) - cls_ = cls._ACTION_VENDORS.get(vendor) - return cls_.parser(buf, offset) + + data = buf[(offset + ofproto.OFP_ACTION_VENDOR_HEADER_SIZE + ): offset + len_] + + if vendor == ofproto_common.NX_EXPERIMENTER_ID: + obj = NXAction.parse(data) # noqa + else: + cls_ = cls._ACTION_VENDORS.get(vendor, None) + + if cls_ is None: + obj = OFPActionVendorUnknown(vendor, data) + else: + obj = cls_.parser(buf, offset) + + obj.len = len_ + return obj + + def serialize(self, buf, offset): + msg_pack_into(ofproto.OFP_ACTION_VENDOR_HEADER_PACK_STR, + buf, offset, self.type, self.len, self.vendor) + +# OpenFlow1.2 or later compatible +OFPActionExperimenter = OFPActionVendor + + +class OFPActionVendorUnknown(OFPActionVendor): + def __init__(self, vendor, data=None, type_=None, len_=None): + super(OFPActionVendorUnknown, + self).__init__(vendor=vendor) + self.data = data + + def serialize(self, buf, offset): + # fixup + data = self.data + if data is None: + data = bytearray() + self.len = (utils.round_up(len(data), 8) + + ofproto.OFP_ACTION_VENDOR_HEADER_SIZE) + super(OFPActionVendorUnknown, self).serialize(buf, offset) + msg_pack_into('!%ds' % len(self.data), + buf, + offset + ofproto.OFP_ACTION_VENDOR_HEADER_SIZE, + self.data) @OFPActionVendor.register_action_vendor(ofproto_common.NX_EXPERIMENTER_ID) @@ -825,476 +873,6 @@ class NXActionHeader(OFPActionVendor): return cls_.parser(buf, offset) -class NXActionResubmitBase(NXActionHeader): - def __init__(self, in_port, table): - super(NXActionResubmitBase, self).__init__() - assert self.subtype in (ofproto.NXAST_RESUBMIT, - ofproto.NXAST_RESUBMIT_TABLE) - self.in_port = in_port - self.table = table - - def serialize(self, buf, offset): - msg_pack_into(ofproto.NX_ACTION_RESUBMIT_PACK_STR, buf, offset, - self.type, self.len, self.vendor, self.subtype, - self.in_port, self.table) - - [email protected]_nx_action_subtype( - ofproto.NXAST_RESUBMIT, ofproto.NX_ACTION_RESUBMIT_SIZE) -class NXActionResubmit(NXActionResubmitBase): - def __init__(self, in_port=ofproto.OFPP_IN_PORT): - super(NXActionResubmit, self).__init__(in_port, 0) - - @classmethod - def parser(cls, buf, offset): - type_, len_, vendor, subtype, in_port, table = struct.unpack_from( - ofproto.NX_ACTION_RESUBMIT_PACK_STR, buf, offset) - return cls(in_port) - - [email protected]_nx_action_subtype( - ofproto.NXAST_RESUBMIT_TABLE, ofproto.NX_ACTION_RESUBMIT_SIZE) -class NXActionResubmitTable(NXActionResubmitBase): - def __init__(self, in_port=ofproto.OFPP_IN_PORT, table=0xff): - super(NXActionResubmitTable, self).__init__(in_port, table) - - @classmethod - def parser(cls, buf, offset): - type_, len_, vendor, subtype, in_port, table = struct.unpack_from( - ofproto.NX_ACTION_RESUBMIT_PACK_STR, buf, offset) - return cls(in_port, table) - - [email protected]_nx_action_subtype( - ofproto.NXAST_SET_TUNNEL, ofproto.NX_ACTION_SET_TUNNEL_SIZE) -class NXActionSetTunnel(NXActionHeader): - def __init__(self, tun_id): - super(NXActionSetTunnel, self).__init__() - self.tun_id = tun_id - - def serialize(self, buf, offset): - msg_pack_into(ofproto.NX_ACTION_SET_TUNNEL_PACK_STR, buf, - offset, self.type, self.len, self.vendor, self.subtype, - self.tun_id) - - @classmethod - def parser(cls, buf, offset): - type_, len_, vendor, subtype, tun_id = struct.unpack_from( - ofproto.NX_ACTION_SET_TUNNEL_PACK_STR, buf, offset) - return cls(tun_id) - - [email protected]_nx_action_subtype( - ofproto.NXAST_SET_QUEUE, ofproto.NX_ACTION_SET_QUEUE_SIZE) -class NXActionSetQueue(NXActionHeader): - def __init__(self, queue_id): - super(NXActionSetQueue, self).__init__() - self.queue_id = queue_id - - def serialize(self, buf, offset): - msg_pack_into(ofproto.NX_ACTION_SET_QUEUE_PACK_STR, buf, - offset, self.type, self.len, self.vendor, - self.subtype, self.queue_id) - - @classmethod - def parser(cls, buf, offset): - (type_, len_, vendor, subtype, queue_id) = struct.unpack_from( - ofproto.NX_ACTION_SET_QUEUE_PACK_STR, buf, offset) - return cls(queue_id) - - [email protected]_nx_action_subtype( - ofproto.NXAST_POP_QUEUE, ofproto.NX_ACTION_POP_QUEUE_SIZE) -class NXActionPopQueue(NXActionHeader): - def __init__(self): - super(NXActionPopQueue, self).__init__() - - def serialize(self, buf, offset): - msg_pack_into(ofproto.NX_ACTION_POP_QUEUE_PACK_STR, buf, - offset, self.type, self.len, self.vendor, - self.subtype) - - @classmethod - def parser(cls, buf, offset): - (type_, len_, vendor, subtype) = struct.unpack_from( - ofproto.NX_ACTION_POP_QUEUE_PACK_STR, buf, offset) - return cls() - - [email protected]_nx_action_subtype( - ofproto.NXAST_REG_MOVE, ofproto.NX_ACTION_REG_MOVE_SIZE) -class NXActionRegMove(NXActionHeader): - def __init__(self, n_bits, src_ofs, dst_ofs, src, dst): - super(NXActionRegMove, self).__init__() - self.n_bits = n_bits - self.src_ofs = src_ofs - self.dst_ofs = dst_ofs - self.src = src - self.dst = dst - - def serialize(self, buf, offset): - msg_pack_into(ofproto.NX_ACTION_REG_MOVE_PACK_STR, buf, - offset, self.type, self.len, self.vendor, - self.subtype, self.n_bits, self.src_ofs, self.dst_ofs, - self.src, self.dst) - - @classmethod - def parser(cls, buf, offset): - (type_, len_, vendor, subtype, n_bits, src_ofs, dst_ofs, - src, dst) = struct.unpack_from( - ofproto.NX_ACTION_REG_MOVE_PACK_STR, buf, offset) - return cls(n_bits, src_ofs, dst_ofs, src, dst) - - [email protected]_nx_action_subtype( - ofproto.NXAST_REG_LOAD, ofproto.NX_ACTION_REG_LOAD_SIZE) -class NXActionRegLoad(NXActionHeader): - def __init__(self, ofs_nbits, dst, value): - super(NXActionRegLoad, self).__init__() - self.ofs_nbits = ofs_nbits - self.dst = dst - self.value = value - - def serialize(self, buf, offset): - msg_pack_into(ofproto.NX_ACTION_REG_LOAD_PACK_STR, buf, - offset, self.type, self.len, self.vendor, - self.subtype, self.ofs_nbits, self.dst, self.value) - - @classmethod - def parser(cls, buf, offset): - (type_, len_, vendor, subtype, ofs_nbits, dst, - value) = struct.unpack_from( - ofproto.NX_ACTION_REG_LOAD_PACK_STR, buf, offset) - return cls(ofs_nbits, dst, value) - - [email protected]_nx_action_subtype( - ofproto.NXAST_SET_TUNNEL64, ofproto.NX_ACTION_SET_TUNNEL64_SIZE) -class NXActionSetTunnel64(NXActionHeader): - def __init__(self, tun_id): - super(NXActionSetTunnel64, self).__init__() - self.tun_id = tun_id - - def serialize(self, buf, offset): - msg_pack_into(ofproto.NX_ACTION_SET_TUNNEL64_PACK_STR, buf, - offset, self.type, self.len, self.vendor, self.subtype, - self.tun_id) - - @classmethod - def parser(cls, buf, offset): - type_, len_, vendor, subtype, tun_id = struct.unpack_from( - ofproto.NX_ACTION_SET_TUNNEL64_PACK_STR, buf, offset) - return cls(tun_id) - - [email protected]_nx_action_subtype( - ofproto.NXAST_MULTIPATH, ofproto.NX_ACTION_MULTIPATH_SIZE) -class NXActionMultipath(NXActionHeader): - def __init__(self, fields, basis, algorithm, max_link, arg, - ofs_nbits, dst): - super(NXActionMultipath, self).__init__() - self.fields = fields - self.basis = basis - self.algorithm = algorithm - self.max_link = max_link - self.arg = arg - self.ofs_nbits = ofs_nbits - self.dst = dst - - def serialize(self, buf, offset): - msg_pack_into(ofproto.NX_ACTION_MULTIPATH_PACK_STR, buf, - offset, self.type, self.len, self.vendor, self.subtype, - self.fields, self.basis, self.algorithm, self.max_link, - self.arg, self.ofs_nbits, self.dst) - - @classmethod - def parser(cls, buf, offset): - (type_, len_, vendor, subtype, fields, basis, algorithm, - max_link, arg, ofs_nbits, dst) = struct.unpack_from( - ofproto.NX_ACTION_MULTIPATH_PACK_STR, buf, offset) - return cls(fields, basis, algorithm, max_link, arg, ofs_nbits, - dst) - - [email protected]_nx_action_subtype(ofproto.NXAST_NOTE, 0) -class NXActionNote(NXActionHeader): - def __init__(self, note): - super(NXActionNote, self).__init__() - # should check here if the note is valid (only hex values) - pad = (len(note) + 10) % 8 - if pad: - note += [0x0 for i in range(8 - pad)] - self.note = note - self.len = len(note) + 10 - - def serialize(self, buf, offset): - note = self.note - extra = None - extra_len = len(self.note) - 6 - if extra_len > 0: - extra = note[6:] - note = note[0:6] - msg_pack_into(ofproto.NX_ACTION_NOTE_PACK_STR, buf, - offset, self.type, self.len, self.vendor, self.subtype, - *note) - if extra_len > 0: - msg_pack_into('B' * extra_len, buf, - offset + ofproto.NX_ACTION_NOTE_SIZE, - *extra) - - @classmethod - def parser(cls, buf, offset): - note = struct.unpack_from( - ofproto.NX_ACTION_NOTE_PACK_STR, buf, offset) - (type_, len_, vendor, subtype) = note[0:4] - note = [i for i in note[4:]] - if len_ > ofproto.NX_ACTION_NOTE_SIZE: - note_start = offset + ofproto.NX_ACTION_NOTE_SIZE - note_end = note_start + len_ - ofproto.NX_ACTION_NOTE_SIZE - note += [int(binascii.b2a_hex(i), 16) for i - in buf[note_start:note_end]] - return cls(note) - - -class NXActionBundleBase(NXActionHeader): - def __init__(self, algorithm, fields, basis, slave_type, n_slaves, - ofs_nbits, dst, slaves): - super(NXActionBundleBase, self).__init__() - _len = ofproto.NX_ACTION_BUNDLE_SIZE + len(slaves) * 2 - _len += (_len % 8) - self.len = _len - - self.algorithm = algorithm - self.fields = fields - self.basis = basis - self.slave_type = slave_type - self.n_slaves = n_slaves - self.ofs_nbits = ofs_nbits - self.dst = dst - self.slaves = slaves - - def serialize(self, buf, offset): - slave_offset = offset + ofproto.NX_ACTION_BUNDLE_SIZE - - for s in self.slaves: - msg_pack_into('!H', buf, slave_offset, s) - slave_offset += 2 - - pad_len = (len(self.slaves) * 2 + - ofproto.NX_ACTION_BUNDLE_SIZE) % 8 - - if pad_len != 0: - msg_pack_into('%dx' % pad_len, buf, slave_offset) - - msg_pack_into(ofproto.NX_ACTION_BUNDLE_PACK_STR, buf, - offset, self.type, self.len, self.vendor, self.subtype, - self.algorithm, self.fields, self.basis, - self.slave_type, self.n_slaves, - self.ofs_nbits, self.dst) - - @classmethod - def parser(cls, action_cls, buf, offset): - (type_, len_, vendor, subtype, algorithm, fields, basis, - slave_type, n_slaves, ofs_nbits, dst) = struct.unpack_from( - ofproto.NX_ACTION_BUNDLE_PACK_STR, buf, offset) - slave_offset = offset + ofproto.NX_ACTION_BUNDLE_SIZE - - slaves = [] - for i in range(0, n_slaves): - s = struct.unpack_from('!H', buf, slave_offset) - slaves.append(s[0]) - slave_offset += 2 - - return action_cls(algorithm, fields, basis, slave_type, - n_slaves, ofs_nbits, dst, slaves) - - [email protected]_nx_action_subtype(ofproto.NXAST_BUNDLE, 0) -class NXActionBundle(NXActionBundleBase): - def __init__(self, algorithm, fields, basis, slave_type, n_slaves, - ofs_nbits, dst, slaves): - super(NXActionBundle, self).__init__( - algorithm, fields, basis, slave_type, n_slaves, - ofs_nbits, dst, slaves) - - @classmethod - def parser(cls, buf, offset): - return NXActionBundleBase.parser(NXActionBundle, buf, offset) - - [email protected]_nx_action_subtype(ofproto.NXAST_BUNDLE_LOAD, 0) -class NXActionBundleLoad(NXActionBundleBase): - def __init__(self, algorithm, fields, basis, slave_type, n_slaves, - ofs_nbits, dst, slaves): - super(NXActionBundleLoad, self).__init__( - algorithm, fields, basis, slave_type, n_slaves, - ofs_nbits, dst, slaves) - - @classmethod - def parser(cls, buf, offset): - return NXActionBundleBase.parser(NXActionBundleLoad, buf, offset) - - [email protected]_nx_action_subtype( - ofproto.NXAST_AUTOPATH, ofproto.NX_ACTION_AUTOPATH_SIZE) -class NXActionAutopath(NXActionHeader): - def __init__(self, ofs_nbits, dst, id_): - super(NXActionAutopath, self).__init__() - self.ofs_nbits = ofs_nbits - self.dst = dst - self.id = id_ - - def serialize(self, buf, offset): - msg_pack_into(ofproto.NX_ACTION_AUTOPATH_PACK_STR, buf, offset, - self.type, self.len, self.vendor, self.subtype, - self.ofs_nbits, self.dst, self.id) - - @classmethod - def parser(cls, buf, offset): - (type_, len_, vendor, subtype, ofs_nbits, dst, - id_) = struct.unpack_from( - ofproto.NX_ACTION_AUTOPATH_PACK_STR, buf, offset) - return cls(ofs_nbits, dst, id_) - - [email protected]_nx_action_subtype( - ofproto.NXAST_OUTPUT_REG, ofproto.NX_ACTION_OUTPUT_REG_SIZE) -class NXActionOutputReg(NXActionHeader): - def __init__(self, ofs_nbits, src, max_len): - super(NXActionOutputReg, self).__init__() - self.ofs_nbits = ofs_nbits - self.src = src - self.max_len = max_len - - def serialize(self, buf, offset): - msg_pack_into(ofproto.NX_ACTION_OUTPUT_REG_PACK_STR, buf, offset, - self.type, self.len, self.vendor, self.subtype, - self.ofs_nbits, self.src, self.max_len) - - @classmethod - def parser(cls, buf, offset): - (type_, len_, vendor, subtype, ofs_nbits, src, - max_len) = struct.unpack_from( - ofproto.NX_ACTION_OUTPUT_REG_PACK_STR, buf, offset) - return cls(ofs_nbits, src, max_len) - - [email protected]_nx_action_subtype( - ofproto.NXAST_EXIT, ofproto.NX_ACTION_HEADER_SIZE) -class NXActionExit(NXActionHeader): - def __init__(self): - super(NXActionExit, self).__init__() - - def serialize(self, buf, offset): - msg_pack_into(ofproto.NX_ACTION_HEADER_PACK_STR, buf, offset, - self.type, self.len, self.vendor, self.subtype) - - @classmethod - def parser(cls, buf, offset): - (type_, len_, vendor, subtype) = struct.unpack_from( - ofproto.NX_ACTION_HEADER_PACK_STR, buf, offset) - return cls() - - [email protected]_nx_action_subtype( - ofproto.NXAST_DEC_TTL, ofproto.NX_ACTION_HEADER_SIZE) -class NXActionDecTtl(NXActionHeader): - def __init__(self): - super(NXActionDecTtl, self).__init__() - - def serialize(self, buf, offset): - msg_pack_into(ofproto.NX_ACTION_HEADER_PACK_STR, buf, offset, - self.type, self.len, self.vendor, self.subtype) - - @classmethod - def parser(cls, buf, offset): - (type_, len_, vendor, subtype) = struct.unpack_from( - ofproto.NX_ACTION_HEADER_PACK_STR, buf, offset) - return cls() - - [email protected]_nx_action_subtype(ofproto.NXAST_LEARN, 0) -class NXActionLearn(NXActionHeader): - def __init__(self, idle_timeout, hard_timeout, priority, cookie, flags, - table_id, fin_idle_timeout, fin_hard_timeout, spec): - super(NXActionLearn, self).__init__() - len_ = len(spec) + ofproto.NX_ACTION_LEARN_SIZE - pad_len = 8 - (len_ % 8) - self.len = len_ + pad_len - - self.idle_timeout = idle_timeout - self.hard_timeout = hard_timeout - self.priority = priority - self.cookie = cookie - self.flags = flags - self.table_id = table_id - self.fin_idle_timeout = fin_idle_timeout - self.fin_hard_timeout = fin_hard_timeout - self.spec = spec + bytearray(b'\x00' * pad_len) - - def serialize(self, buf, offset): - msg_pack_into(ofproto.NX_ACTION_LEARN_PACK_STR, buf, offset, - self.type, self.len, self.vendor, self.subtype, - self.idle_timeout, self.hard_timeout, self.priority, - self.cookie, self.flags, self.table_id, - self.fin_idle_timeout, self.fin_hard_timeout) - buf += self.spec - - @classmethod - def parser(cls, buf, offset): - (type_, len_, vendor, subtype, idle_timeout, hard_timeout, priority, - cookie, flags, table_id, fin_idle_timeout, - fin_hard_timeout) = struct.unpack_from( - ofproto.NX_ACTION_LEARN_PACK_STR, buf, offset) - spec = buf[offset + ofproto.NX_ACTION_LEARN_SIZE:] - return cls(idle_timeout, hard_timeout, priority, - cookie, flags, table_id, fin_idle_timeout, - fin_hard_timeout, spec) - - [email protected]_nx_action_subtype( - ofproto.NXAST_CONTROLLER, ofproto.NX_ACTION_CONTROLLER_SIZE) -class NXActionController(NXActionHeader): - def __init__(self, max_len, controller_id, reason): - super(NXActionController, self).__init__() - self.max_len = max_len - self.controller_id = controller_id - self.reason = reason - - def serialize(self, buf, offset): - msg_pack_into(ofproto.NX_ACTION_CONTROLLER_PACK_STR, buf, offset, - self.type, self.len, self.vendor, self.subtype, - self.max_len, self.controller_id, self.reason, 0) - - @classmethod - def parser(cls, buf, offset): - (type_, len_, vendor, subtype, max_len, controller_id, reason, - _zero) = struct.unpack_from( - ofproto.NX_ACTION_CONTROLLER_PACK_STR, buf, offset) - return cls(max_len, controller_id, reason) - - [email protected]_nx_action_subtype( - ofproto.NXAST_FIN_TIMEOUT, ofproto.NX_ACTION_FIN_TIMEOUT_SIZE) -class NXActionFinTimeout(NXActionHeader): - def __init__(self, fin_idle_timeout, fin_hard_timeout): - super(NXActionFinTimeout, self).__init__() - self.fin_idle_timeout = fin_idle_timeout - self.fin_hard_timeout = fin_hard_timeout - - def serialize(self, buf, offset): - msg_pack_into(ofproto.NX_ACTION_FIN_TIMEOUT_PACK_STR, buf, offset, - self.type, self.len, self.vendor, self.subtype, - self.fin_idle_timeout, self.fin_hard_timeout) - - @classmethod - def parser(cls, buf, offset): - (type_, len_, vendor, subtype, fin_idle_timeout, - fin_hard_timeout) = struct.unpack_from( - ofproto.NX_ACTION_FIN_TIMEOUT_PACK_STR, buf, offset) - return cls(fin_idle_timeout, fin_hard_timeout) - - class OFPDescStats(ofproto_parser.namedtuple('OFPDescStats', ( 'mfr_desc', 'hw_desc', 'sw_desc', 'serial_num', 'dp_desc'))): @@ -3646,3 +3224,9 @@ class NXAggregateStatsRequest(NXStatsRequest): ofproto.NX_AGGREGATE_STATS_REQUEST_PACK_STR, self.buf, ofproto.NX_STATS_MSG_SIZE, self.out_port, self.match_len, self.table_id) + + +nx_actions.generate( + 'ryu.ofproto.ofproto_v1_0', + 'ryu.ofproto.ofproto_v1_0_parser' +) diff --git a/ryu/tests/unit/ofproto/test_parser_v10.py b/ryu/tests/unit/ofproto/test_parser_v10.py index 6e025e4..c4dd474 100644 --- a/ryu/tests/unit/ofproto/test_parser_v10.py +++ b/ryu/tests/unit/ofproto/test_parser_v10.py @@ -1275,60 +1275,6 @@ class TestNXActionSetTunnel(unittest.TestCase): eq_(self.tun_id['val'], res[4]) -class TestNXActionSetQueue(unittest.TestCase): - """ Test case for ofproto_v1_0_parser.NXActionSetQueue - """ - - # NX_ACTION_SET_QUEUE_PACK_STR - # '!HHIH2xI'...type, len, vendor, subtype, zfill, queue_id - type_ = {'buf': b'\xff\xff', 'val': ofproto.OFPAT_VENDOR} - len_ = {'buf': b'\x00\x10', 'val': ofproto.NX_ACTION_SET_TUNNEL_SIZE} - vendor = {'buf': b'\x00\x00\x23\x20', - 'val': ofproto_common.NX_EXPERIMENTER_ID} - subtype = {'buf': b'\x00\x04', 'val': ofproto.NXAST_SET_QUEUE} - zfill = b'\x00' * 2 - queue_id = {'buf': b'\xde\xbe\xc5\x18', 'val': 3737044248} - - buf = type_['buf'] \ - + len_['buf'] \ - + vendor['buf'] \ - + subtype['buf'] \ - + zfill \ - + queue_id['buf'] - - c = NXActionSetQueue(queue_id['val']) - - def setUp(self): - pass - - def tearDown(self): - pass - - def test_init(self): - eq_(self.type_['val'], self.c.type) - eq_(self.len_['val'], self.c.len) - eq_(self.vendor['val'], self.c.vendor) - eq_(self.subtype['val'], self.c.subtype) - eq_(self.queue_id['val'], self.c.queue_id) - - def test_parser(self): - res = self.c.parser(self.buf, 0) - eq_(self.queue_id['val'], res.queue_id) - - def test_serialize(self): - buf = bytearray() - self.c.serialize(buf, 0) - - fmt = ofproto.NX_ACTION_SET_QUEUE_PACK_STR - res = struct.unpack(fmt, six.binary_type(buf)) - - eq_(self.type_['val'], res[0]) - eq_(self.len_['val'], res[1]) - eq_(self.vendor['val'], res[2]) - eq_(self.subtype['val'], res[3]) - eq_(self.queue_id['val'], res[4]) - - class TestNXActionPopQueue(unittest.TestCase): """ Test case for ofproto_v1_0_parser.NXActionPopQueue """ @@ -1908,78 +1854,6 @@ class TestNXActionBundleLoad(unittest.TestCase): eq_(self.dst['val'], res[10]) -class TestNXActionAutopath(unittest.TestCase): - """ Test case for ofproto_v1_0_parser.NXActionAutopath - """ - - # NX_ACTION_AUTOPATH_PACK_STR - # '!HHIHHII4x'...type, len, vendor, subtype, ofs_nbits, - # dst, id_, zfill - type_ = {'buf': b'\xff\xff', 'val': ofproto.OFPAT_VENDOR} - len_ = {'buf': b'\x00\x20', 'val': ofproto.NX_ACTION_OUTPUT_REG_SIZE} - vendor = {'buf': b'\x00\x00\x23\x20', - 'val': ofproto_common.NX_EXPERIMENTER_ID} - subtype = {'buf': b'\x00\x0b', 'val': ofproto.NXAST_AUTOPATH} - ofs_nbits = {'buf': b'\xfe\x78', 'val': 65144} - dst = {'buf': b'\xf8\x55\x74\x95', 'val': 4166349973} - id_ = {'buf': b'\x02\x2d\x37\xed', 'val': 36517869} - zfill = b'\x00' * 4 - - buf = type_['buf'] \ - + len_['buf'] \ - + vendor['buf'] \ - + subtype['buf'] \ - + ofs_nbits['buf'] \ - + dst['buf'] \ - + id_['buf'] \ - + zfill - - c = NXActionAutopath(ofs_nbits['val'], - dst['val'], - id_['val']) - - def setUp(self): - pass - - def tearDown(self): - pass - - def test_init(self): - eq_(self.type_['val'], self.c.type) - eq_(self.len_['val'], self.c.len) - eq_(self.vendor['val'], self.c.vendor) - eq_(self.subtype['val'], self.c.subtype) - eq_(self.ofs_nbits['val'], self.c.ofs_nbits) - eq_(self.dst['val'], self.c.dst) - eq_(self.id_['val'], self.c.id) - - def test_parser(self): - res = self.c.parser(self.buf, 0) - - eq_(self.type_['val'], res.type) - eq_(self.len_['val'], res.len) - eq_(self.vendor['val'], res.vendor) - eq_(self.subtype['val'], res.subtype) - eq_(self.ofs_nbits['val'], res.ofs_nbits) - eq_(self.dst['val'], res.dst) - eq_(self.id_['val'], res.id) - - def test_serialize(self): - buf = bytearray() - self.c.serialize(buf, 0) - - fmt = ofproto.NX_ACTION_AUTOPATH_PACK_STR - res = struct.unpack(fmt, six.binary_type(buf)) - - eq_(self.type_['val'], res[0]) - eq_(self.len_['val'], res[1]) - eq_(self.vendor['val'], res[2]) - eq_(self.subtype['val'], res[3]) - eq_(self.ofs_nbits['val'], res[4]) - eq_(self.dst['val'], res[5]) - eq_(self.id_['val'], res[6]) - - class TestNXActionOutputReg(unittest.TestCase): """ Test case for ofproto_v1_0_parser.NXActionOutputReg """ -- 1.9.1 ------------------------------------------------------------------------------ What NetFlow Analyzer can do for you? Monitors network bandwidth and traffic patterns at an interface-level. Reveals which users, apps, and protocols are consuming the most bandwidth. Provides multi-vendor support for NetFlow, J-Flow, sFlow and other flows. Make informed decisions using capacity planning reports. https://ad.doubleclick.net/ddm/clk/305295220;132659582;e _______________________________________________ Ryu-devel mailing list [email protected] https://lists.sourceforge.net/lists/listinfo/ryu-devel
