X-Git-Url: http://git.onelab.eu/?a=blobdiff_plain;f=src%2Fnepi%2Fresources%2Fplanetlab%2Ftap.py;h=dc6d448c84ec4deb969264d720dc4db92faf914a;hb=731febb6e113ad858232827fd03f9a932dea16b5;hp=6d1be501db703d046209fb94f441c7507960781f;hpb=2e80f0fafa0c2ef6a5f536efd4c868c91468f962;p=nepi.git diff --git a/src/nepi/resources/planetlab/tap.py b/src/nepi/resources/planetlab/tap.py index 6d1be501..dc6d448c 100644 --- a/src/nepi/resources/planetlab/tap.py +++ b/src/nepi/resources/planetlab/tap.py @@ -25,12 +25,9 @@ from nepi.resources.planetlab.node import PlanetlabNode from nepi.util.timefuncs import tnow, tdiffsec import os +import socket 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 @@ -68,8 +65,23 @@ class PlanetlabTap(LinuxApplication): pointopoint = Attribute("pointopoint", "Peer IP address", flags = Flags.Design) - tear_down = Attribute("tearDown", "Bash script to be executed before " + \ - "releasing the resource", + 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) + + gre_remote = Attribute("greRemote", + "Public IP of remote endpoint for GRE tunnel", + flags = Flags.Design) + + tear_down = Attribute("tearDown", + "Bash script to be executed before releasing the resource", flags = Flags.Design) cls._register_attribute(ip4) @@ -80,11 +92,15 @@ class PlanetlabTap(LinuxApplication): 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): @@ -92,66 +108,88 @@ class PlanetlabTap(LinuxApplication): if node: return node[0] return None + @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, # 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: @@ -192,11 +230,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: @@ -215,8 +256,9 @@ 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) @@ -224,32 +266,62 @@ class PlanetlabTap(LinuxApplication): 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): + """ 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 for i in xrange(20): - (out, err), proc = self.node.check_output(self.run_home, "if_name") + (out, err), proc = self.node.check_output(self.run_home, "vif_name") + + if proc.poll() > 0: + (out, err), proc = self.node.check_errors(self.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 udp_connect_command(self, remote_endpoint, connection_run_home, + cipher, cipher_key, bwlimit, txqueuelen): + + # Set the remote endpoint + self.set("pointopoint", remote_endpoint.get("ip4")) + + remote_ip = socket.gethostbyname( + remote_endpoint.node.get("hostname")) + + local_port_file = os.path.join(connection_run_home, + "local_port") + + remote_port_file = os.path.join(connection_run_home, + "remote_port") + + ret_file = os.path.join(connection_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) @@ -267,31 +339,126 @@ class PlanetlabTap(LinuxApplication): if bwlimit: command.append("-b %s " % bwlimit) + command.append(")") + command = " ".join(command) command = self.replace_paths(command) + + return command + + def gre_connect_command(self, remote_endpoint, connection_run_home): + # Set the remote endpoint + self.set("pointopoint", remote_endpoint.get("ip4")) + self.set("greRemote", socket.gethostbyname( + remote_endpoint.node.get("hostname"))) + + # 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("ip4")) + command.append("-n %d" % self.get("prefix4")) + 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) + 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 @@ -299,8 +466,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):