X-Git-Url: http://git.onelab.eu/?a=blobdiff_plain;f=src%2Fnepi%2Fresources%2Fplanetlab%2Ftap.py;h=2f2975ac347a20c4002ed392c2a31c21e6e19db5;hb=b6c4948fd994223cff257cbdae7146da1339b58d;hp=b6b1744c42f5ed767f56963b805aed7b63e1a336;hpb=f73ff8dcf111fe0bcfcd688a6571c49620935688;p=nepi.git diff --git a/src/nepi/resources/planetlab/tap.py b/src/nepi/resources/planetlab/tap.py index b6b1744c..2f2975ac 100644 --- a/src/nepi/resources/planetlab/tap.py +++ b/src/nepi/resources/planetlab/tap.py @@ -18,8 +18,7 @@ # Author: Alina Quereilhac from nepi.execution.attribute import Attribute, Flags, Types -from nepi.execution.resource import clsinit_copy, ResourceState, \ - reschedule_delay +from nepi.execution.resource import clsinit_copy, ResourceState from nepi.resources.linux.application import LinuxApplication from nepi.resources.planetlab.node import PlanetlabNode from nepi.util.timefuncs import tnow, tdiffsec @@ -27,135 +26,172 @@ from nepi.util.timefuncs import tnow, tdiffsec import os import time -# TODO: - routes!!! -# - CREATE GRE - PlanetlabGRE - it only needs to set the gre and remote -# properties when configuring the vif_up - PYTHON_VSYS_VERSION = "1.0" @clsinit_copy class PlanetlabTap(LinuxApplication): - _rtype = "PlanetlabTap" + _rtype = "planetlab::Tap" _help = "Creates a TAP device on a PlanetLab host" _backend = "planetlab" @classmethod def _register_attributes(cls): - ip4 = Attribute("ip4", "IPv4 Address", - flags = Flags.ExecReadOnly) + ip = Attribute("ip", "IP of the endpoint. This is the attribute " + "you should use to establish a tunnel or a remote " + "connection between endpoint", + flags = Flags.Design) mac = Attribute("mac", "MAC Address", - flags = Flags.ExecReadOnly) + flags = Flags.Design) - prefix4 = Attribute("prefix4", "IPv4 network prefix", - type = Types.Integer, - flags = Flags.ExecReadOnly) + prefix = Attribute("prefix", "IPv4 network prefix of the endpoint", + flags = Flags.Design) mtu = Attribute("mtu", "Maximum transmition unit for device", type = Types.Integer) devname = Attribute("deviceName", "Name of the network interface (e.g. eth0, wlan0, etc)", - flags = Flags.ReadOnly) + flags = Flags.NoWrite) up = Attribute("up", "Link up", type = Types.Bool) snat = Attribute("snat", "Set SNAT=1", type = Types.Bool, - flags = Flags.ExecReadOnly) + flags = Flags.Design) pointopoint = Attribute("pointopoint", "Peer IP address", - flags = Flags.ExecReadOnly) + flags = Flags.Design) + + txqueuelen = Attribute("txqueuelen", "Length of transmission queue", + flags = Flags.Design) + + txqueuelen = Attribute("txqueuelen", "Length of transmission queue", + flags = Flags.Design) + + gre_key = Attribute("greKey", + "GRE key to be used to configure GRE tunnel", + default = "1", + flags = Flags.Design) - tear_down = Attribute("tearDown", "Bash script to be executed before " + \ - "releasing the resource", - flags = Flags.ExecReadOnly) + gre_remote = Attribute("greRemote", + "Public IP of remote endpoint for GRE tunnel", + flags = Flags.Design) - cls._register_attribute(ip4) + tear_down = Attribute("tearDown", + "Bash script to be executed before releasing the resource", + flags = Flags.Design) + + cls._register_attribute(ip) cls._register_attribute(mac) - cls._register_attribute(prefix4) + cls._register_attribute(prefix) cls._register_attribute(mtu) cls._register_attribute(devname) cls._register_attribute(up) cls._register_attribute(snat) cls._register_attribute(pointopoint) + cls._register_attribute(txqueuelen) + cls._register_attribute(gre_key) + cls._register_attribute(gre_remote) cls._register_attribute(tear_down) def __init__(self, ec, guid): super(PlanetlabTap, self).__init__(ec, guid) self._home = "tap-%s" % self.guid + self._gre_enabled = False @property def node(self): node = self.get_connected(PlanetlabNode.get_rtype()) if node: return node[0] - return None + raise RuntimeError, "TAP/TUN devices must be connected to Node" + + @property + def gre_enabled(self): + if not self._gre_enabled: + from nepi.resources.linux.gretunnel import LinuxGRETunnel + gre = self.get_connected(LinuxGRETunnel.get_rtype()) + if gre: self._gre_enabled = True + + return self._gre_enabled def upload_sources(self): - # upload vif-creation python script + scripts = [] + + # vif-creation python script pl_vif_create = os.path.join(os.path.dirname(__file__), "scripts", "pl-vif-create.py") - self.node.upload(pl_vif_create, - os.path.join(self.node.src_dir, "pl-vif-create.py"), - overwrite = False) - - # upload vif-stop python script - pl_vif_stop = os.path.join(os.path.dirname(__file__), "scripts", - "pl-vif-stop.py") + scripts.append(pl_vif_create) + + # vif-up python script + pl_vif_up = os.path.join(os.path.dirname(__file__), "scripts", + "pl-vif-up.py") + + scripts.append(pl_vif_up) - self.node.upload(pl_vif_stop, - os.path.join(self.node.src_dir, "pl-vif-stop.py"), - overwrite = False) + # vif-down python script + pl_vif_down = os.path.join(os.path.dirname(__file__), "scripts", + "pl-vif-down.py") + + scripts.append(pl_vif_down) - # upload vif-connect python script + # udp-connect python script pl_vif_connect = os.path.join(os.path.dirname(__file__), "scripts", "pl-vif-udp-connect.py") + + scripts.append(pl_vif_connect) - self.node.upload(pl_vif_connect, - os.path.join(self.node.src_dir, "pl-vif-udp-connect.py"), - overwrite = False) - - # upload tun-connect python script + # tunnel creation python script tunchannel = os.path.join(os.path.dirname(__file__), "..", "linux", "scripts", "tunchannel.py") - self.node.upload(tunchannel, - os.path.join(self.node.src_dir, "tunchannel.py"), + scripts.append(tunchannel) + + # Upload scripts + scripts = ";".join(scripts) + + self.node.upload(scripts, + os.path.join(self.node.src_dir), overwrite = False) # upload stop.sh script stop_command = self.replace_paths(self._stop_command) - self.node.upload(stop_command, - os.path.join(self.app_home, "stop.sh"), - text = True, + + self.node.upload_command(stop_command, + shfile = os.path.join(self.app_home, "stop.sh"), # Overwrite file every time. - # The stop.sh has the path to the socket, wich should change + # The stop.sh has the path to the socket, which should change # on every experiment run. overwrite = True) def upload_start_command(self): - # Overwrite file every time. - # The stop.sh has the path to the socket, wich should change - # on every experiment run. - super(PlanetlabTap, self).upload_start_command(overwrite = True) - - # We want to make sure the device is up and running - # before the deploy finishes (so things will be ready - # before other stuff starts running). - # Run the command as a bash script in background, - # in the host ( but wait until the command has - # finished to continue ) - self._run_in_background() - - # Retrive if_name - if_name = self.wait_if_name() - self.set("deviceName", if_name) + # If GRE mode is enabled, TAP creation is delayed until the + # tunnel is established + if not self.gre_enabled: + # Overwrite file every time. + # The start.sh has the path to the socket, wich should change + # on every experiment run. + super(PlanetlabTap, self).upload_start_command(overwrite = True) + + # We want to make sure the device is up and running + # before the deploy finishes, so we execute now the + # start script. We run it in background, because the + # TAP will live for as long as the process that + # created it is running, and wait until the TAP + # is created. + self._run_in_background() + + # After creating the TAP, the pl-vif-create.py script + # will write the name of the TAP to a file. We wait until + # we can read the interface name from the file. + vif_name = self.wait_vif_name() + self.set("deviceName", vif_name) def do_deploy(self): if not self.node or self.node.state < ResourceState.PROVISIONED: - self.ec.schedule(reschedule_delay, self.deploy) + self.ec.schedule(self.reschedule_delay, self.deploy) else: if not self.get("command"): self.set("command", self._start_command) @@ -169,7 +205,6 @@ class PlanetlabTap(LinuxApplication): self.do_discover() self.do_provision() - self.debug("----- READY ---- ") self.set_ready() def do_start(self): @@ -193,11 +228,14 @@ class PlanetlabTap(LinuxApplication): (out, err), proc = self.execute_command(command, blocking = True) + if err: + msg = " Failed to stop command '%s' " % command + self.error(msg, out, err) + self.set_stopped() @property def state(self): - # First check if the ccnd has failed state_check_delay = 0.5 if self._state == ResourceState.STARTED and \ tdiffsec(tnow(), self._last_state_check) > state_check_delay: @@ -216,41 +254,167 @@ class PlanetlabTap(LinuxApplication): def do_release(self): # Node needs to wait until all associated RMs are released # to be released - from nepi.resources.linux.udptunnel import UdpTunnel - rms = self.get_connected(UdpTunnel.get_rtype()) + from nepi.resources.linux.tunnel import LinuxTunnel + rms = self.get_connected(LinuxTunnel.get_rtype()) + for rm in rms: if rm.state < ResourceState.STOPPED: - self.ec.schedule(reschedule_delay, self.release) + self.ec.schedule(self.reschedule_delay, self.release) return super(PlanetlabTap, self).do_release() - def wait_if_name(self): - """ Waits until the if_name file for the command is generated, - and returns the if_name for the device """ - if_name = None - delay = 1.0 + def wait_vif_name(self, exec_run_home = None): + """ Waits until the vif_name file for the command is generated, + and returns the vif_name for the device """ + vif_name = None + delay = 0.5 + + # The vif_name file will be created in the tap-home, while the + # current execution home might be elsewhere to check for errors + # (e.g. could be a tunnel-home) + if not exec_run_home: + exec_run_home = self.run_home + + for i in xrange(20): + (out, err), proc = self.node.check_output(self.run_home, "vif_name") - for i in xrange(10): - (out, err), proc = self.node.check_output(self.run_home, "if_name") + if proc.poll() > 0: + (out, err), proc = self.node.check_errors(exec_run_home) + + if err.strip(): + raise RuntimeError, err if out: - if_name = out.strip() + vif_name = out.strip() break else: time.sleep(delay) delay = delay * 1.5 else: - msg = "Couldn't retrieve if_name" + msg = "Couldn't retrieve vif_name" self.error(msg, out, err) raise RuntimeError, msg - return if_name + return vif_name - def udp_connect_command(self, remote_ip, local_port_file, - remote_port_file, ret_file, cipher, cipher_key, - bwlimit, txqueuelen): - command = ["sudo -S "] + def gre_connect(self, remote_endpoint, connection_app_home, + connection_run_home): + gre_connect_command = self._gre_connect_command( + remote_endpoint, connection_run_home) + + # upload command to connect.sh script + shfile = os.path.join(connection_app_home, "gre-connect.sh") + self.node.upload_command(gre_connect_command, + shfile = shfile, + overwrite = False) + + # invoke connect script + cmd = "bash %s" % shfile + (out, err), proc = self.node.run(cmd, connection_run_home) + + # check if execution errors occurred + msg = " Failed to connect endpoints " + + if proc.poll() or err: + self.error(msg, out, err) + raise RuntimeError, msg + + # Wait for pid file to be generated + pid, ppid = self.node.wait_pid(connection_run_home) + + # If the process is not running, check for error information + # on the remote machine + if not pid or not ppid: + (out, err), proc = self.node.check_errors(connection_run_home) + # Out is what was written in the stderr file + if err: + msg = " Failed to start command '%s' " % command + self.error(msg, out, err) + raise RuntimeError, msg + + # After creating the TAP, the pl-vif-create.py script + # will write the name of the TAP to a file. We wait until + # we can read the interface name from the file. + vif_name = self.wait_vif_name(exec_run_home = connection_run_home) + self.set("deviceName", vif_name) + + return True + + def initiate_udp_connection(self, remote_endpoint, connection_app_home, + connection_run_home, cipher, cipher_key, bwlimit, txqueuelen): + port = self.udp_connect(remote_endpoint, connection_app_home, + connection_run_home, cipher, cipher_key, bwlimit, txqueuelen) + return port + + def udp_connect(self, remote_endpoint, connection_app_home, + connection_run_home, cipher, cipher_key, bwlimit, txqueuelen): + udp_connect_command = self._udp_connect_command( + remote_endpoint, connection_run_home, + cipher, cipher_key, bwlimit, txqueuelen) + + # upload command to connect.sh script + shfile = os.path.join(self.app_home, "udp-connect.sh") + self.node.upload_command(udp_connect_command, + shfile = shfile, + overwrite = False) + + # invoke connect script + cmd = "bash %s" % shfile + (out, err), proc = self.node.run(cmd, self.run_home) + + # check if execution errors occurred + msg = "Failed to connect endpoints " + + if proc.poll(): + self.error(msg, out, err) + raise RuntimeError, msg + + # Wait for pid file to be generated + self._pid, self._ppid = self.node.wait_pid(self.run_home) + + # If the process is not running, check for error information + # on the remote machine + if not self._pid or not self._ppid: + (out, err), proc = self.node.check_errors(self.run_home) + # Out is what was written in the stderr file + if err: + msg = " Failed to start command '%s' " % command + self.error(msg, out, err) + raise RuntimeError, msg + + port = self.wait_local_port() + + return port + + def _udp_connect_command(self, remote_endpoint, connection_run_home, + cipher, cipher_key, bwlimit, txqueuelen): + + # Set the remote endpoint, (private) IP of the device + self.set("pointopoint", remote_endpoint.get("ip")) + + # Public IP of the node + remote_ip = remote_endpoint.node.get("ip") + + local_port_file = os.path.join(self.run_home, + "local_port") + + remote_port_file = os.path.join(self.run_home, + "remote_port") + + ret_file = os.path.join(self.run_home, + "ret_file") + + # Generate UDP connect command + # Use pl-vif-up.py script to configure TAP with peer info + vif_up_command = self._vif_up_command + + command = ["( "] + command.append(vif_up_command) + + # Use pl-vid-udp-connect.py to stablish the tunnel between endpoints + command.append(") & (") + command.append("sudo -S") command.append("PYTHONPATH=$PYTHONPATH:${SRC}") command.append("python ${SRC}/pl-vif-udp-connect.py") command.append("-t %s" % self.vif_type) @@ -268,31 +432,185 @@ class PlanetlabTap(LinuxApplication): if bwlimit: command.append("-b %s " % bwlimit) + command.append(")") + + command = " ".join(command) + command = self.replace_paths(command) + + return command + + def establish_udp_connection(self, remote_endpoint, port): + # upload remote port number to file + rem_port = "%s\n" % port + self.node.upload(rem_port, + os.path.join(self.run_home, "remote_port"), + text = True, + overwrite = False) + + def verify_connection(self): + self.wait_result() + + def terminate_connection(self): + if self._pid and self._ppid: + (out, err), proc = self.node.kill(self._pid, self._ppid, + sudo = True) + + # check if execution errors occurred + if proc.poll() and err: + msg = " Failed to Kill the Tap" + self.error(msg, out, err) + raise RuntimeError, msg + + def check_status(self): + return self.node.status(self._pid, self._ppid) + + def wait_local_port(self): + """ Waits until the local_port file for the endpoint is generated, + and returns the port number + + """ + return self.wait_file("local_port") + + def wait_result(self): + """ Waits until the return code file for the endpoint is generated + + """ + return self.wait_file("ret_file") + + def wait_file(self, filename): + """ Waits until file on endpoint is generated """ + result = None + delay = 1.0 + + for i in xrange(20): + (out, err), proc = self.node.check_output( + self.run_home, filename) + if out: + result = out.strip() + break + else: + time.sleep(delay) + delay = delay * 1.5 + else: + msg = "Couldn't retrieve %s" % filename + self.error(msg, out, err) + raise RuntimeError, msg + + return result + + def _gre_connect_command(self, remote_endpoint, connection_run_home): + # Set the remote endpoint, (private) IP of the device + self.set("pointopoint", remote_endpoint.get("ip")) + # Public IP of the node + self.set("greRemote", remote_endpoint.node.get("ip")) + + # Generate GRE connect command + + # Use vif_down command to first kill existing TAP in GRE mode + vif_down_command = self._vif_down_command + + # Use pl-vif-up.py script to configure TAP with peer info + vif_up_command = self._vif_up_command + + command = ["("] + command.append(vif_down_command) + command.append(") ; (") + command.append(vif_up_command) + command.append(")") + command = " ".join(command) command = self.replace_paths(command) + return command @property def _start_command(self): - command = ["sudo -S python ${SRC}/pl-vif-create.py"] - + if self.gre_enabled: + command = [] + else: + command = ["sudo -S python ${SRC}/pl-vif-create.py"] + + command.append("-t %s" % self.vif_type) + command.append("-a %s" % self.get("ip")) + command.append("-n %s" % self.get("prefix")) + command.append("-f %s " % self.vif_name_file) + command.append("-S %s " % self.sock_name) + + if self.get("snat") == True: + command.append("-s") + + if self.get("pointopoint"): + command.append("-p %s" % self.get("pointopoint")) + + if self.get("txqueuelen"): + command.append("-q %s" % self.get("txqueuelen")) + + return " ".join(command) + + @property + def _stop_command(self): + if self.gre_enabled: + command = self._vif_down_command + else: + command = ["sudo -S "] + command.append("PYTHONPATH=$PYTHONPATH:${SRC}") + command.append("python ${SRC}/pl-vif-down.py") + command.append("-S %s " % self.sock_name) + command = " ".join(command) + + return command + + @property + def _vif_up_command(self): + if self.gre_enabled: + device_name = "%s" % self.guid + else: + device_name = self.get("deviceName") + + # Use pl-vif-up.py script to configure TAP + command = ["sudo -S "] + command.append("PYTHONPATH=$PYTHONPATH:${SRC}") + command.append("python ${SRC}/pl-vif-up.py") + command.append("-u %s" % self.node.get("username")) + command.append("-N %s" % device_name) command.append("-t %s" % self.vif_type) - command.append("-a %s" % self.get("ip4")) - command.append("-n %d" % self.get("prefix4")) - command.append("-f %s " % self.if_name_file) - command.append("-S %s " % self.sock_name) + command.append("-a %s" % self.get("ip")) + command.append("-n %s" % self.get("prefix")) + if self.get("snat") == True: command.append("-s") + if self.get("pointopoint"): command.append("-p %s" % self.get("pointopoint")) + + if self.get("txqueuelen"): + command.append("-q %s" % self.get("txqueuelen")) + + if self.gre_enabled: + command.append("-g %s" % self.get("greKey")) + command.append("-G %s" % self.get("greRemote")) + + command.append("-f %s " % self.vif_name_file) return " ".join(command) @property - def _stop_command(self): - command = ["sudo -S python ${SRC}/pl-vif-stop.py"] + def _vif_down_command(self): + if self.gre_enabled: + device_name = "%s" % self.guid + else: + device_name = self.get("deviceName") + + command = ["sudo -S "] + command.append("PYTHONPATH=$PYTHONPATH:${SRC}") + command.append("python ${SRC}/pl-vif-down.py") + command.append("-N %s " % device_name) - command.append("-S %s " % self.sock_name) + if self.gre_enabled: + command.append("-u %s" % self.node.get("username")) + command.append("-t %s" % self.vif_type) + command.append("-D") + return " ".join(command) @property @@ -300,8 +618,8 @@ class PlanetlabTap(LinuxApplication): return "IFF_TAP" @property - def if_name_file(self): - return os.path.join(self.run_home, "if_name") + def vif_name_file(self): + return os.path.join(self.run_home, "vif_name") @property def sock_name(self):