def test_not_sent_until_permitted(self):
i = DeferredIOWorker(IOWorker())
i.set_receive_handler(self.call_later)
i.block()
i.send("foo")
self.assertFalse(i._io_worker._ready_to_send)
self.assertFalse(i._send_queue.empty())
i.unblock()
self.assertTrue(i._send_queue.empty())
i._io_worker._consume_send_buf(3)
self.assertFalse(i._io_worker._ready_to_send)
def test_not_sent_until_permitted(self):
i = DeferredIOWorker(IOWorker())
i.set_receive_handler(self.call_later)
i.block()
i.send("foo")
self.assertFalse(i._io_worker._ready_to_send)
self.assertFalse(i._send_queue.empty())
i.unblock()
self.assertTrue(i._send_queue.empty())
i._io_worker._consume_send_buf(3)
self.assertFalse(i._io_worker._ready_to_send)
def test_receive_consume(self):
i = DeferredIOWorker(IOWorker())
i.set_receive_handler(self.call_later)
self.data = None
def consume(worker):
self.data = worker.peek_receive_buf()
worker.consume_receive_buf(len(self.data))
i.set_receive_handler(consume)
i.block()
i._io_worker._push_receive_data("bar")
self.assertEqual(self.data, None)
i.unblock()
self.assertEqual(self.data, "bar")
# data has been consumed
i._io_worker._push_receive_data("hepp")
self.assertEqual(self.data, "hepp")
def test_not_received_until_permitted(self):
i = DeferredIOWorker(IOWorker())
i.set_receive_handler(self.call_later)
i.block()
self.data = None
def d(worker):
self.data = worker.peek_receive_buf()
i.set_receive_handler(d)
i._io_worker._push_receive_data("bar")
self.assertEqual(self.data, None)
i.unblock()
self.assertEqual(self.data, "bar")
# Now if unblocked, should go through immediately
# Note: d does not consume the data
i._io_worker._push_receive_data("hepp")
self.assertEqual(self.data, "barhepp")
def test_receive_consume(self):
i = DeferredIOWorker(IOWorker())
i.set_receive_handler(self.call_later)
self.data = None
def consume(worker):
self.data = worker.peek_receive_buf()
worker.consume_receive_buf(len(self.data))
i.set_receive_handler(consume)
i.block()
i._io_worker._push_receive_data("bar")
self.assertEqual(self.data, None)
i.unblock()
self.assertEqual(self.data, "bar")
# data has been consumed
i._io_worker._push_receive_data("hepp")
self.assertEqual(self.data, "hepp")
def test_not_received_until_permitted(self):
i = DeferredIOWorker(IOWorker())
i.set_receive_handler(self.call_later)
i.block()
self.data = None
def d(worker):
self.data = worker.peek_receive_buf()
i.set_receive_handler(d)
i._io_worker._push_receive_data("bar")
self.assertEqual(self.data, None)
i.unblock()
self.assertEqual(self.data, "bar")
# Now if unblocked, should go through immediately
# Note: d does not consume the data
i._io_worker._push_receive_data("hepp")
self.assertEqual(self.data, "barhepp")
def create_connection(controller_info, switch):
''' Connect switches to controllers. May raise a TimeoutError '''
# TODO(cs): move this into a ConnectionFactory class
socket = connect_socket_with_backoff(controller_info.address,
controller_info.port,
max_backoff_seconds=8)
# Set non-blocking
socket.setblocking(0)
io_worker = DeferredIOWorker(
io_master.create_worker_for_socket(socket))
return DeferredOFConnection(io_worker, switch.dpid, god_scheduler)
def create_connection(self, controller_info, switch, max_backoff_seconds=1024):
''' Connect switches to controllers. May raise a TimeoutError '''
# TODO(cs): move this into a ConnectionFactory class
while controller_info.address == "__address__":
log.debug("Waiting for controller address for %s..." % controller_info.label)
time.sleep(5)
if self.multiplex_sockets:
socket_ctor = STSMockSocket
else:
socket_ctor = socket.socket
sock = connect_socket_with_backoff(controller_info.address,
controller_info.port,
max_backoff_seconds=max_backoff_seconds,
socket_ctor=socket_ctor)
# Set non-blocking
sock.setblocking(0)
io_worker = DeferredIOWorker(self.io_master.create_worker_for_socket(sock))
connection = DeferredOFConnection(io_worker, controller_info.cid, switch.dpid, self.openflow_buffer)
return connection
