def monkeypatch_select():
log.debug("Monkeypatching STS select")
mux_select = None
demuxers = []
if self.multiplex_sockets:
revert_select_monkeypatch()
revert_socket_monkeypatch()
# Monkey patch select to use our deterministic version
mux_select = MultiplexedSelect()
for c in self.controller_manager.controller_configs:
# Connect the true sockets
true_socket = connect_socket_with_backoff(
address=c.address, port=c.port)
true_socket.setblocking(0)
io_worker = mux_select.create_worker_for_socket(
true_socket)
mux_select.set_true_io_worker(io_worker)
demux = STSSocketDemultiplexer(io_worker, c.server_info)
demuxers.append(demux)
# Monkey patch select.select
select._old_select = select.select
select.select = mux_select.select
# Monkey patch socket.socket
socket._old_socket = socket.socket
def socket_patch(protocol, sock_type):
if sock_type == socket.SOCK_STREAM:
return STSMockSocket(protocol, sock_type)
else:
socket._old_socket(protocol, sock_type)
socket.socket = socket_patch
return (mux_select, demuxers)
def monkeypatch_select():
log.debug("Monkeypatching STS select")
mux_select = None
demuxers = []
if self.multiplex_sockets:
revert_select_monkeypatch()
revert_socket_monkeypatch()
# Monkey patch select to use our deterministic version
mux_select = MultiplexedSelect()
for c in self.controller_manager.controller_configs:
# Connect the true sockets
true_socket = connect_socket_with_backoff(address=c.address, port=c.port)
true_socket.setblocking(0)
io_worker = mux_select.create_worker_for_socket(true_socket)
mux_select.set_true_io_worker(io_worker)
demux = STSSocketDemultiplexer(io_worker, c.server_info)
demuxers.append(demux)
# Monkey patch select.select
select._old_select = select.select
select.select = mux_select.select
# Monkey patch socket.socket
socket._old_socket = socket.socket
def socket_patch(protocol, sock_type):
if sock_type == socket.SOCK_STREAM:
return STSMockSocket(protocol, sock_type)
else:
socket._old_socket(protocol, sock_type)
socket.socket = socket_patch
return (mux_select, demuxers)
def fetchSnapshot(self, controller):
from pox.lib.util import connect_socket_with_backoff
import socket
snapshotSocket = connect_socket_with_backoff('127.0.0.1', self.port)
log.debug("Sending Request")
snapshotSocket.send("{\"hello\":\"nommessenger\"}")
snapshotSocket.send("{\"getnom\":0}", socket.MSG_WAITALL)
log.debug("Receiving Results")
jsonstr = ""
while True:
data = snapshotSocket.recv(1024)
log.debug("%d byte packet received" % len(data))
if not data: break
jsonstr += data
if len(data) != 1024: break
snapshotSocket.close()
jsonNOM = json.loads(jsonstr) # (json string with the NOM)
# Update local Snapshot object
self.snapshot.switches = [
self.myNOMDecoder.decode(s) for s in jsonNOM["switches"]
]
self.snapshot.hosts = [
self.myNOMDecoder.decode(h) for h in jsonNOM["hosts"]
]
self.snapshot.links = [
self.myNOMDecoder.decode(l) for l in jsonNOM["links"]
]
self.snapshot.time = time.time()
return self.snapshot
def fetchSnapshot(self, controller):
from pox.lib.util import connect_socket_with_backoff
import socket
snapshotSocket = connect_socket_with_backoff('127.0.0.1', self.port)
log.debug("Sending Request")
snapshotSocket.send("{\"hello\":\"nommessenger\"}")
snapshotSocket.send("{\"getnom\":0}", socket.MSG_WAITALL)
log.debug("Receiving Results")
jsonstr = ""
while True:
data = snapshotSocket.recv(1024)
log.debug("%d byte packet received" % len(data))
if not data: break
jsonstr += data
if len(data) != 1024: break
snapshotSocket.close()
jsonNOM = json.loads(jsonstr) # (json string with the NOM)
# Update local Snapshot object
self.snapshot.switches = [self.myNOMDecoder.decode(s) for s in jsonNOM["switches"]]
self.snapshot.hosts = [self.myNOMDecoder.decode(h) for h in jsonNOM["hosts"]]
self.snapshot.links = [self.myNOMDecoder.decode(l) for l in jsonNOM["links"]]
self.snapshot.time = time.time()
return self.snapshot
def connect(self, io_master):
if self.mode != "tcp":
raise RuntimeError("only tcp (active) mode supported by now")
socket = connect_socket_with_backoff(self.host, self.port)
self.io_delegate = SyncIODelegate(io_master, socket)
self.speaker = STSSyncProtocolSpeaker(controller=self.controller,
state_master=self.state_master, io_delegate=self.io_delegate)
def connect(self, io_master):
if self.mode != "tcp":
raise RuntimeError("only tcp (active) mode supported by now")
socket = connect_socket_with_backoff(self.host, self.port)
self.io_delegate = SyncIODelegate(io_master, socket)
self.speaker = STSSyncProtocolSpeaker(controller=self.controller,
state_master=self.state_master,
io_delegate=self.io_delegate)
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(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 setup_client(self, num_socks, address):
from pox.lib.util import connect_socket_with_backoff
io_master = MultiplexedSelect()
socket = connect_socket_with_backoff(address=address)
io_worker = io_master.create_worker_for_socket(socket)
io_master.set_true_io_worker(io_worker)
demux = STSSocketDemultiplexer(io_worker, address)
mock_socks = []
for i in xrange(num_socks):
mock_socket = STSMockSocket(None, None)
mock_socket.connect(address)
mock_socket.send(self.client_messages[i])
mock_socks.append(mock_socket)
io_master.select(mock_socks, mock_socks, [])
def create_connection(controller_info, switch):
''' Connect switches to controllers. May raise a TimeoutError '''
while controller_info.address == "__address__":
log.debug("Waiting for controller address for %s..." % controller_info.label)
time.sleep(5)
# TODO(cs): move this into a ConnectionFactory class
socket = connect_socket_with_backoff(controller_info.address,
controller_info.port,
max_backoff_seconds=1024)
# Set non-blocking
socket.setblocking(0)
io_worker = DeferredIOWorker(self.io_master.create_worker_for_socket(socket))
connection = DeferredOFConnection(io_worker, controller_info.cid, switch.dpid, self.openflow_buffer)
return connection
def __init__(self, create_io_worker):
super(OVSControllerPatchPanel, self).__init__(create_io_worker)
# Boot up POX.
args = str("""./pox.py openflow.of_01 --address=127.0.0.1 --port=%d"""
""" messenger.messenger --tcp_address=127.0.0.1 --tcp_port=%d """
""" sts_of_forwarder.sts_of_forwarder """ %
(self.of_port, self.messenger_port)).split()
self.pox = subprocess.Popen(args, cwd="./pox/", preexec_fn=lambda: os.setsid())
# Establish connection with POX messenger component.
true_socket = connect_socket_with_backoff(address="127.0.0.1",
port=self.messenger_port)
self.json_worker = JSONIOWorker(create_io_worker(true_socket))
# Send the handshake.
self.json_worker.send({"sts_connection": ""})
self._initialize_switch()
def setup_client(self, num_socks, address):
from pox.lib.util import connect_socket_with_backoff
io_master = MultiplexedSelect()
socket = connect_socket_with_backoff(address=address)
io_worker = io_master.create_worker_for_socket(socket)
io_master.set_true_io_worker(io_worker)
# TODO(cs): unused variable demux
demux = STSSocketDemultiplexer(io_worker, address)
mock_socks = []
for i in xrange(num_socks):
mock_socket = STSMockSocket(None, None)
mock_socket.connect(address)
mock_socket.send(self.client_messages[i])
mock_socks.append(mock_socket)
io_master.select(mock_socks, mock_socks, [])
def __init__(self, create_io_worker):
super(OVSControllerPatchPanel, self).__init__(create_io_worker)
# Boot up POX.
args = str(
"""./pox.py openflow.of_01 --address=127.0.0.1 --port=%d"""
""" messenger.messenger --tcp_address=127.0.0.1 --tcp_port=%d """
""" sts_of_forwarder.sts_of_forwarder """ %
(self.of_port, self.messenger_port)).split()
self.pox = subprocess.Popen(args,
cwd="./pox/",
preexec_fn=lambda: os.setsid())
# Establish connection with POX messenger component.
true_socket = connect_socket_with_backoff(address="127.0.0.1",
port=self.messenger_port)
self.json_worker = JSONIOWorker(create_io_worker(true_socket))
# Send the handshake.
self.json_worker.send({"sts_connection": ""})
self._initialize_switch()
def snapshot_proceed(self):
"""
Tell the previously fork()ed controller process to wake up, and connect
a new socket to the fork()ed controller's (OpenFlow) port. Also
de-registers the old controller process and registers the new controller
process.
Note that it is the responsibility of the caller to kill the previously
fork()ed controller process.
This method may block if the fork()ed process is not ready to proceed.
Returns: a new socket connected to the woken controller.
Pre: snapshot() has been invoked
"""
self.log.info("Initiating snapshot proceed")
# Check that the fork()ed controller is ready
self.log.debug("Checking READY")
# N.B. snapshot_socket is blocking
response = self.snapshot_socket.recv(100)
match = re.match(r"READY (?P<pid>\d+)", response)
if not match:
raise ValueError("Unknown response %s" % response)
pid = int(match.group('pid'))
# De-registers the old controller process and registers the new controller
# process.
self._unregister_proc(self.process)
self.process = SnapshotPopen(pid)
self._register_proc(self.process)
# Send PROCEED
self.log.debug("Sending PROCEED")
self.snapshot_socket.send("PROCEED")
# Reconnect
self.log.debug("Connecting new mux socket")
true_socket = connect_socket_with_backoff(address=self.config.address,
port=self.config.port)
true_socket.setblocking(0)
self.log.debug("Finished snapshot proceed")
return true_socket
def snapshot_proceed(self):
"""
Tell the previously fork()ed controller process to wake up, and connect
a new socket to the fork()ed controller's (OpenFlow) port. Also
de-registers the old controller process and registers the new controller
process.
Note that it is the responsibility of the caller to kill the previously
fork()ed controller process.
This method may block if the fork()ed process is not ready to proceed.
Returns: a new socket connected to the woken controller.
Pre: snapshot() has been invoked
"""
self.log.info("Initiating snapshot proceed")
# Check that the fork()ed controller is ready
self.log.debug("Checking READY")
# N.B. snapshot_socket is blocking
response = self.snapshot_socket.recv(100)
match = re.match(r"READY (?P<pid>\d+)", response)
if not match:
raise ValueError("Unknown response %s" % response)
pid = int(match.group('pid'))
# De-registers the old controller process and registers the new controller
# process.
self._unregister_proc(self.process)
self.process = SnapshotPopen(pid)
self._register_proc(self.process)
# Send PROCEED
self.log.debug("Sending PROCEED")
self.snapshot_socket.send("PROCEED")
# Reconnect
self.log.debug("Connecting new mux socket")
true_socket = connect_socket_with_backoff(address=self.config.address,
port=self.config.port)
true_socket.setblocking(0)
self.log.debug("Finished snapshot proceed")
return true_socket
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
def setup_client(self, num_socks, address):
try:
from pox.lib.util import connect_socket_with_backoff
io_master = MultiplexedSelect()
socket = connect_socket_with_backoff(address=address)
io_worker = io_master.create_worker_for_socket(socket)
# TODO(cs): unused variable demux
demux = STSSocketDemultiplexer(io_worker, address)
mock_socks = []
for i in xrange(num_socks):
mock_socket = STSMockSocket(None, None)
mock_socket.connect(address)
mock_socket.send(self.client_messages[i])
mock_socks.append(mock_socket)
# Now flush messages
while [ m for m in mock_socks if m.json_worker.io_worker._ready_to_send ] != []:
io_master.select(mock_socks, mock_socks, [])
except Exception as e:
log.critical("Client died: %s" % e)
raise e
def monkeypatch_select(multiplex_sockets, controller_manager):
mux_select = None
demuxers = []
if multiplex_sockets:
log.debug("Monkeypatching STS select")
revert_select_monkeypatch()
# Monkey patch select to use our deterministic version
mux_select = MultiplexedSelect()
for c in controller_manager.controller_configs:
# Connect the true sockets
true_socket = connect_socket_with_backoff(address=c.address, port=c.port)
true_socket.setblocking(0)
io_worker = mux_select.create_worker_for_socket(true_socket)
demux = STSSocketDemultiplexer(io_worker, c.server_info)
demuxers.append(demux)
# Monkey patch select.select
select._old_select = select.select
select.select = mux_select.select
return (mux_select, demuxers)
def monkeypatch_select(multiplex_sockets, controller_manager):
mux_select = None
demuxers = []
if multiplex_sockets:
log.debug("Monkeypatching STS select")
revert_select_monkeypatch()
# Monkey patch select to use our deterministic version
mux_select = MultiplexedSelect()
for c in controller_manager.controller_configs:
# Connect the true sockets
true_socket = connect_socket_with_backoff(address=c.address, port=c.port)
true_socket.setblocking(0)
io_worker = mux_select.create_worker_for_socket(true_socket)
demux = STSSocketDemultiplexer(io_worker, c.server_info)
demuxers.append(demux)
# Monkey patch select.select
select._old_select = select.select
select.select = mux_select.select
return (mux_select, demuxers)
def setup_client(self, num_socks, address):
try:
from pox.lib.util import connect_socket_with_backoff
io_master = MultiplexedSelect()
socket = connect_socket_with_backoff(address=address)
io_worker = io_master.create_worker_for_socket(socket)
# TODO(cs): unused variable demux
demux = STSSocketDemultiplexer(io_worker, address)
mock_socks = []
for i in xrange(num_socks):
mock_socket = STSMockSocket(None, None)
mock_socket.connect(address)
mock_socket.send(self.client_messages[i])
mock_socks.append(mock_socket)
# Now flush messages
while [
m for m in mock_socks
if m.json_worker.io_worker._ready_to_send
] != []:
io_master.select(mock_socks, mock_socks, [])
except Exception as e:
log.critical("Client died: %s" % e)
raise e
def create_io_worker(switch, controller_info): controller_socket = connect_socket_with_backoff(controller_info.address, controller_info.port) # Set non-blocking controller_socket.setblocking(0) return io_worker_generator(controller_socket)
def _check_snapshot_connect(self):
if getattr(self.config, "snapshot_address", None):
# N.B. snapshot_socket is intended to be blocking
self.log.debug("Connecting snapshot socket")
self.snapshot_socket = connect_socket_with_backoff(
address=self.config.snapshot_address)
def _check_snapshot_connect(self):
if getattr(self.config, "snapshot_address", None):
# N.B. snapshot_socket is intended to be blocking
self.log.debug("Connecting snapshot socket")
self.snapshot_socket = connect_socket_with_backoff(
address=self.config.snapshot_address)