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):
# 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, which should change
# on every experiment run.
super(PlanetlabTap, self).do_release()
- def wait_vif_name(self):
+ 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")
if proc.poll() > 0:
- (out, err), proc = self.node.check_errors(self.run_home)
+ (out, err), proc = self.node.check_errors(exec_run_home)
if err.strip():
raise RuntimeError, err
return vif_name
- def udp_connect_command(self, remote_endpoint, connection_run_home,
+ 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 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(connection_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, connection_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
+ 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
+
+ return pid, ppid
+
+ 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"))
+ remote_endpoint.node.get("ip"))
local_port_file = os.path.join(connection_run_home,
"local_port")
return command
- def gre_connect_command(self, remote_endpoint, connection_run_home):
+ 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")))
+ remote_endpoint.node.get("ip")))
# Generate GRE connect command