def wait_disconnected(self, timeout=-1):
"""
@param timeout Block for up to timeout seconds. Pass -1 for the default.
@return Boolean, True if disconnected
"""
with self.connect_cv:
util.timed_wait(self.connect_cv,
lambda: True if not self.switch_socket else None,
timeout=timeout)
return self.switch_socket is None
def transact(self, msg, timeout=-1):
"""
Run a message transaction with the switch
Send the message in msg and wait for a reply with a matching
transaction id. Transactions have the highest priority in
received message handling.
@param msg The message object to send; must not be a string
@param timeout The timeout in seconds; if -1 use default.
"""
if msg.xid == None:
msg.xid = util.gen_xid()
self.logger.debug("Running transaction %d" % msg.xid)
with self.xid_cv:
if self.xid:
self.logger.error("Can only run one transaction at a time")
return (None, None)
self.xid = msg.xid
self.xid_response = None
self.message_send(msg)
self.logger.debug("Waiting for transaction %d" % msg.xid)
util.timed_wait(self.xid_cv, lambda: self.xid_response, timeout=timeout)
if self.xid_response:
(resp, pkt) = self.xid_response
self.xid_response = None
else:
(resp, pkt) = (None, None)
if resp is None:
self.logger.warning("No response for xid " + str(self.xid))
return (resp, pkt)
def poll(self, exp_msg=None, timeout=-1):
"""
Wait for the next OF message received from the switch.
@param exp_msg If set, return only when this type of message
is received (unless timeout occurs).
@param timeout Maximum number of seconds to wait for the message.
Pass -1 for the default timeout.
@retval A pair (msg, pkt) where msg is a message object and pkt
the string representing the packet as received from the socket.
This allows additional parsing by the receiver if necessary.
The data members in the message are in host endian order.
If an error occurs, (None, None) is returned
"""
if exp_msg is None:
self.logger.warn("DEPRECATED polling for any message class")
klass = None
else:
raise ValueError("Unexpected exp_msg argument %r" % exp_msg)
# Take the packet from the queue
def grab():
for i, (msg, pkt) in enumerate(self.packets):
if klass is None or isinstance(msg, klass):
self.logger.debug("Got %s message", msg.__class__.__name__)
return self.packets.pop(i)
# Not found
return None
with self.packets_cv:
ret = util.timed_wait(self.packets_cv, grab, timeout=timeout)
if ret != None:
(msg, pkt) = ret
return (msg, pkt)
else:
return (None, None)