def __init__(self, interfaces, create_io_worker, name="", hid=None,
cmd="/bin/bash sleep"):
"""
Args:
cmd: a string of the command to execute in the separate namespace
The default is "xterm", which opens up a new terminal window.
"""
super(NamespaceHost, self).__init__(interfaces=interfaces, name=name,
hid=hid)
assert len(self.interfaces) == 1, ("Currently only one interface per "
"host is supported")
interface = self.interfaces[0]
self.cmd = cmd
(self.guest, guest_eth_addr, host_device) = ns.launch_namespace(
cmd, interface.ips[0].toStr(), self.hid, guest_hw_addr=interface.hw_addr)
self.socket = ns.bind_raw_socket(host_device)
# Set up an io worker for our end of the socket
self.io_worker = create_io_worker(self.socket)
self.io_worker.set_receive_handler(self._io_worker_receive_handler)
assert interface.hw_addr == EthAddr(guest_eth_addr)
if name in ["", None]:
self._name = "host:" + interface.ips[0].toStr()
self.log = logging.getLogger(self.name)
def start(self, multiplex_sockets=False):
"""
Start a new controller process based on the config's start_cmd
attribute. Registers the Popen member variable for deletion upon a SIG*
received in the simulator process
"""
self.log.info(self.welcome_msg)
if self.state != ControllerState.DEAD:
self.log.warn("Starting controller %s when it is not dead!" % self.label)
return
if self.config.start_cmd == "":
raise RuntimeError(
"No command found to start controller %s!" % self.label)
self.log.info(
"Launching controller %s: %s" % (
self.label, " ".join(self.config.expanded_start_cmd)))
# These configurations are specific to controllers launched in namespaces
# Probably it should be factored somewhere else
launch_in_network_namespace = getattr(self.config,
'launch_in_network_namespace', None)
if launch_in_network_namespace:
unclaimed_address = IPAddressSpace.find_unclaimed_address(
ip_prefix=self.config.address)
(self.process, self.guest_eth_addr, self.host_device) = \
launch_namespace(" ".join(self.config.expanded_start_cmd),
self.config.address, self.cid,
host_ip_addr_str=unclaimed_address)
else:
self.process = popen_filtered("[%s]" % self.label,
self.config.expanded_start_cmd,
self.config.cwd)
self._register_proc(self.process)
self._check_snapshot_connect()
self.state = ControllerState.ALIVE
def start(self, multiplex_sockets=False):
"""
Start a new controller process based on the config's start_cmd
attribute. Registers the Popen member variable for deletion upon a SIG*
received in the simulator process
"""
self.log.info(self.welcome_msg)
if self.state != ControllerState.DEAD:
self.log.warn("Starting controller %s when it is not dead!" %
self.label)
return
if self.config.start_cmd == "":
raise RuntimeError("No command found to start controller %s!" %
self.label)
self.log.info("Launching controller %s: %s" %
(self.label, " ".join(self.config.expanded_start_cmd)))
# These configurations are specific to controllers launched in namespaces
# Probably it should be factored somewhere else
launch_in_network_namespace = getattr(self.config,
'launch_in_network_namespace',
None)
if launch_in_network_namespace:
unclaimed_address = IPAddressSpace.find_unclaimed_address(
ip_prefix=self.config.address)
(self.process, self.guest_eth_addr, self.host_device) = \
launch_namespace(" ".join(self.config.expanded_start_cmd),
self.config.address, self.cid,
host_ip_addr_str=unclaimed_address)
else:
self.process = popen_filtered("[%s]" % self.label,
self.config.expanded_start_cmd,
self.config.cwd)
self._register_proc(self.process)
self._check_snapshot_connect()
self.state = ControllerState.ALIVE
def __init__(self,
interfaces,
create_io_worker,
name="",
hid=None,
cmd="/bin/bash sleep"):
"""
Args:
cmd: a string of the command to execute in the separate namespace
The default is "xterm", which opens up a new terminal window.
"""
super(NamespaceHost, self).__init__(interfaces=interfaces,
name=name,
hid=hid)
assert len(self.interfaces) == 1, ("Currently only one interface per "
"host is supported")
interface = self.interfaces[0]
self.cmd = cmd
(self.guest, guest_eth_addr,
host_device) = ns.launch_namespace(cmd,
interface.ips[0].toStr(),
self.hid,
guest_hw_addr=interface.hw_addr)
self.socket = ns.bind_raw_socket(host_device)
# Set up an io worker for our end of the socket
self.io_worker = create_io_worker(self.socket)
self.io_worker.set_receive_handler(self._io_worker_receive_handler)
assert interface.hw_addr == EthAddr(guest_eth_addr)
if name in ["", None]:
self._name = "host:" + interface.ips[0].toStr()
self.log = logging.getLogger(self.name)
def __init__(self, ip_addr_str, create_io_worker, name="", cmd="xterm"):
'''
- ip_addr_str must be a string! not a IPAddr object
- cmd: a string of the command to execute in the separate namespace
The default is "xterm", which opens up a new terminal window.
'''
self.hid = self._hids.next()
(self.guest, guest_eth_addr, host_device) = launch_namespace(cmd, ip_addr_str, self.hid)
self.socket = bind_raw_socket(host_device)
# Set up an io worker for our end of the socket
self.io_worker = create_io_worker(self.socket)
self.io_worker.set_receive_handler(self._io_worker_receive_handler)
self.interfaces = [HostInterface(self.guest_eth_addr, IPAddr(ip_addr_str))]
if name == "":
name = "host:" + ip_addr_str
self.name = name
def start(self):
''' Start a new controller process based on the config's start_cmd
attribute. Registers the Popen member variable for deletion upon a SIG*
received in the simulator process '''
if self.state != ControllerState.DEAD:
self.log.warn("Starting controller %s when it is not dead!" % self.label)
return
if self.config.start_cmd == "":
raise RuntimeError("No command found to start controller %s!" % self.label)
self.log.info("Launching controller %s: %s" % (self.label, " ".join(self.config.expanded_start_cmd)))
if self.config.launch_in_network_namespace:
(self.process, self.guest_eth_addr, self.host_device) = \
launch_namespace(" ".join(self.config.expanded_start_cmd),
self.config.address, self.cid,
host_ip_addr_str=IPAddressSpace.find_unclaimed_address(ip_prefix=self.config.address))
else:
self.process = popen_filtered("[%s]" % self.label, self.config.expanded_start_cmd, self.config.cwd)
self._register_proc(self.process)
self.state = ControllerState.ALIVE
def start(self, multiplex_sockets=False):
"""
Start a new POX controller process based on the config's start_cmd
attribute. Registers the Popen member variable for deletion upon a SIG*
received in the simulator process
"""
self.log.info(self.welcome_msg)
if self.state != ControllerState.DEAD:
self.log.warn(
"Starting controller %s when controller is not dead!" % self.label)
return
msg.event("Starting POX controller %s" % (str(self.cid)))
env = None
if self.config.sync:
# If a sync connection has been configured in the controller conf
# launch the controller with environment variable 'sts_sync' set
# to the appropriate listening port. This is quite a hack.
env = os.environ.copy()
port_match = re.search(r':(\d+)$', self.config.sync)
if port_match is None:
raise ValueError("sync: cannot find port in %s" % self.config.sync)
port = port_match.group(1)
env['sts_sync'] = "ptcp:0.0.0.0:%d" % (int(port),)
if self.config.sync or multiplex_sockets:
src_dir = os.path.join(os.path.dirname(__file__), "../../")
pox_ext_dir = os.path.join(self.config.cwd, "ext")
if os.path.exists(pox_ext_dir):
for f in ("sts/util/io_master.py", "sts/syncproto/base.py",
"sts/syncproto/pox_syncer.py", "sts/__init__.py",
"sts/util/socket_mux/__init__.py",
"sts/util/socket_mux/pox_monkeypatcher.py",
"sts/util/socket_mux/base.py",
"sts/util/socket_mux/server_socket_multiplexer.py"):
src_path = os.path.join(src_dir, f)
if not os.path.exists(src_path):
raise ValueError(
"Integrity violation: sts sync source path %s (abs: %s) "
"does not exist" % (src_path, os.path.abspath(src_path)))
dst_path = os.path.join(pox_ext_dir, f)
dst_dir = os.path.dirname(dst_path)
init_py = os.path.join(dst_dir, "__init__.py")
if not os.path.exists(dst_dir):
os.makedirs(dst_dir)
if not os.path.exists(init_py):
open(init_py, "a").close()
if os.path.islink(dst_path):
# Remove symlink and recreate
os.remove(dst_path)
if not os.path.exists(dst_path):
rel_link = os.path.abspath(src_path)
self.log.debug("Creating symlink %s -> %s", rel_link, dst_path)
os.symlink(rel_link, dst_path)
else:
self.log.warn("Could not find pox ext dir in %s. " +
"Cannot check/link in sync module" % pox_ext_dir)
if self.config.start_cmd in ["", None]:
raise RuntimeError(
"No command found to start controller %s!" % self.label)
start_cmd = getattr(self.config, "expanded_start_cmd",
self.config.start_cmd)
self.log.info(
"Launching controller %s: %s" % (self.label, " ".join(start_cmd)))
launch_in_network_namespace = getattr(self.config,
"launch_in_network_namespace",
False)
if launch_in_network_namespace:
(self.process, self.guest_eth_addr, self.host_device) = \
launch_namespace(
" ".join(start_cmd),
self.config.address, self.cid,
host_ip_addr_str=IPAddressSpace.find_unclaimed_address(
ip_prefix=self.config.address),
cwd=self.config.cwd, env=env)
else:
self.process = popen_filtered("[%s]" % self.label,
start_cmd, self.config.cwd, env)
self._register_proc(self.process)
if self.config.sync:
self.sync_connection = self.sync_connection_manager.connect(
self, self.config.sync)
self._check_snapshot_connect()
self.state = ControllerState.ALIVE
def start(self, multiplex_sockets=False):
"""
Start a new POX controller process based on the config's start_cmd
attribute. Registers the Popen member variable for deletion upon a SIG*
received in the simulator process
"""
self.log.info(self.welcome_msg)
if self.state != ControllerState.DEAD:
self.log.warn(
"Starting controller %s when controller is not dead!" %
self.label)
return
msg.event("Starting POX controller %s" % (str(self.cid)))
env = None
if self.config.sync:
# If a sync connection has been configured in the controller conf
# launch the controller with environment variable 'sts_sync' set
# to the appropriate listening port. This is quite a hack.
env = os.environ.copy()
port_match = re.search(r':(\d+)$', self.config.sync)
if port_match is None:
raise ValueError("sync: cannot find port in %s" %
self.config.sync)
port = port_match.group(1)
env['sts_sync'] = "ptcp:0.0.0.0:%d" % (int(port), )
if self.config.sync or multiplex_sockets:
src_dir = os.path.join(os.path.dirname(__file__), "../../")
pox_ext_dir = os.path.join(self.config.cwd, "ext")
if os.path.exists(pox_ext_dir):
for f in ("sts/util/io_master.py", "sts/syncproto/base.py",
"sts/syncproto/pox_syncer.py", "sts/__init__.py",
"sts/util/socket_mux/__init__.py",
"sts/util/socket_mux/pox_monkeypatcher.py",
"sts/util/socket_mux/base.py",
"sts/util/socket_mux/server_socket_multiplexer.py"):
src_path = os.path.join(src_dir, f)
if not os.path.exists(src_path):
raise ValueError(
"Integrity violation: sts sync source path %s (abs: %s) "
"does not exist" %
(src_path, os.path.abspath(src_path)))
dst_path = os.path.join(pox_ext_dir, f)
dst_dir = os.path.dirname(dst_path)
init_py = os.path.join(dst_dir, "__init__.py")
if not os.path.exists(dst_dir):
os.makedirs(dst_dir)
if not os.path.exists(init_py):
open(init_py, "a").close()
if os.path.islink(dst_path):
# Remove symlink and recreate
os.remove(dst_path)
if not os.path.exists(dst_path):
rel_link = os.path.abspath(src_path)
self.log.debug("Creating symlink %s -> %s", rel_link,
dst_path)
os.symlink(rel_link, dst_path)
else:
self.log.warn("Could not find pox ext dir in %s. " +
"Cannot check/link in sync module" % pox_ext_dir)
if self.config.start_cmd in ["", None]:
raise RuntimeError("No command found to start controller %s!" %
self.label)
start_cmd = getattr(self.config, "expanded_start_cmd",
self.config.start_cmd)
self.log.info("Launching controller %s: %s" %
(self.label, " ".join(start_cmd)))
launch_in_network_namespace = getattr(self.config,
"launch_in_network_namespace",
False)
if launch_in_network_namespace:
(self.process, self.guest_eth_addr, self.host_device) = \
launch_namespace(
" ".join(start_cmd),
self.config.address, self.cid,
host_ip_addr_str=IPAddressSpace.find_unclaimed_address(
ip_prefix=self.config.address),
cwd=self.config.cwd, env=env)
else:
self.process = popen_filtered("[%s]" % self.label, start_cmd,
self.config.cwd, env)
self._register_proc(self.process)
if self.config.sync:
self.sync_connection = self.sync_connection_manager.connect(
self, self.config.sync)
self._check_snapshot_connect()
self.state = ControllerState.ALIVE
