class FlowMod(GenericMessage):
"""Modifies the flow table from the controller."""
header = Header(message_type=Type.OFPT_FLOW_MOD)
match = Match()
cookie = UBInt64()
command = UBInt16(enum_ref=FlowModCommand)
idle_timeout = UBInt16()
hard_timeout = UBInt16()
priority = UBInt16()
buffer_id = UBInt32()
out_port = UBInt16(enum_ref=Port)
flags = UBInt16(enum_ref=FlowModFlags)
actions = ListOfActions()
def __init__(self,
xid=None,
match=None,
cookie=0,
command=None,
idle_timeout=0,
hard_timeout=0,
priority=0,
buffer_id=NO_BUFFER,
out_port=Port.OFPP_NONE,
flags=FlowModFlags.OFPFF_CHECK_OVERLAP,
actions=None):
"""The constructor just assings parameters to object attributes.
Args:
xid (int): xid to be used on the message header.
match (Match): Fields to match.
cookie (int): Opaque controller-issued identifier.
command (FlowModCommand): One of OFPFC_*.
idle_timeout (int): Idle time before discarding (seconds).
hard_timeout (int): Max time before discarding (seconds).
priority (int): Priority level of flow entry.
buffer_idle (int): Buffered packet to apply to (or -1).
Not meaningful for OFPFC_DELETE*.
out_port (Port): For OFPFC_DELETE* commands, require matching
entries to include this as an output port.
A value of OFPP_NONE indicates no restriction.
flags (FlowModFlags): One of OFPFF_*.
actions (ListOfActions): The action length is inferred from the
length field in the header.
"""
super().__init__(xid)
self.match = match
self.cookie = cookie
self.command = command
self.idle_timeout = idle_timeout
self.hard_timeout = hard_timeout
self.priority = priority
self.buffer_id = buffer_id
self.out_port = out_port
self.flags = flags
self.actions = [] if actions is None else actions
class PacketOut(GenericMessage):
"""Send packet (controller -> datapath)."""
header = Header(message_type=Type.OFPT_PACKET_OUT)
buffer_id = UBInt32()
in_port = UBInt16(enum_ref=Port)
actions_len = UBInt16()
actions = ListOfActions()
data = BinaryData()
def __init__(self,
xid=None,
buffer_id=NO_BUFFER,
in_port=Port.OFPP_NONE,
actions=None,
data=b''):
"""The constructor just assings parameters to object attributes.
Args:
xid (int): xid of the message header.
buffer_id (int): ID assigned by datapath (-1 if none).
in_port (:class:`int`, :class:`.Port`): Packet's input port
(:attr:`.Port.OFPP_NONE` if none). Virtual ports OFPP_IN_PORT,
OFPP_TABLE, OFPP_NORMAL, OFPP_FLOOD, and OFPP_ALL cannot be
used as input port.
actions (ListOfActions): Actions (class ActionHeader).
data (bytes): Packet data. The length is inferred from the length
field in the header. (Only meaningful if buffer_id == -1).
"""
super().__init__(xid)
self.buffer_id = buffer_id
self.in_port = in_port
self.actions = [] if actions is None else actions
self.data = data
def validate(self):
"""Validate the entire message."""
if not super().is_valid():
raise ValidationError()
self._validate_in_port()
def is_valid(self):
"""Answer if this message is valid."""
try:
self.validate()
return True
except ValidationError:
return False
def pack(self, value=None):
"""Update the action_len attribute and call super's pack."""
if value is None:
self._update_actions_len()
return super().pack()
elif isinstance(value, type(self)):
return value.pack()
else:
msg = "{} is not an instance of {}".format(value,
type(self).__name__)
raise PackException(msg)
def unpack(self, buff, offset=0):
"""Unpack a binary message into this object's attributes.
Unpack the binary value *buff* and update this object attributes based
on the results. It is an inplace method and it receives the binary data
of the message **without the header**.
This class' unpack method is like the :meth:`.GenericMessage.unpack`
one, except for the ``actions`` attribute which has a length determined
by the ``actions_len`` attribute.
Args:
buff (bytes): Binary data package to be unpacked, without the
header.
offset (int): Where to begin unpacking.
"""
begin = offset
for attribute_name, class_attribute in self.get_class_attributes():
#print( " attribute_name : " + str(attribute_name) + " class_attribute : " + str(type(class_attribute)) )
if type(class_attribute).__name__ != "Header":
attribute = deepcopy(class_attribute)
if attribute_name == 'actions':
length = self.actions_len.value
attribute.unpack(buff[begin:begin + length])
else:
attribute.unpack(buff, begin)
setattr(self, attribute_name, attribute)
begin += attribute.get_size()
def _update_actions_len(self):
"""Update the actions_len field based on actions value."""
if isinstance(self.actions, ListOfActions):
self.actions_len = self.actions.get_size()
else:
self.actions_len = ListOfActions(self.actions).get_size()
def _validate_in_port(self):
port = self.in_port
valid = True
if isinstance(port, int) and (port < 1 or port >= Port.OFPP_MAX.value):
valid = False
elif isinstance(port, Port) and port not in _VIRT_IN_PORTS:
valid = False
if not valid:
raise ValidationError('{} is not a valid input port.'.format(port))
def _update_actions_len(self):
"""Update the actions_len field based on actions value."""
if isinstance(self.actions, ListOfActions):
self.actions_len = self.actions.get_size()
else:
self.actions_len = ListOfActions(self.actions).get_size()