@classmethod
def _register_attributes(cls):
hostname = Attribute("hostname", "Hostname of the machine",
- flags = Flags.ExecReadOnly)
+ flags = Flags.Design)
username = Attribute("username", "Local account username",
flags = Flags.Credential)
- port = Attribute("port", "SSH port", flags = Flags.ExecReadOnly)
+ port = Attribute("port", "SSH port", flags = Flags.Design)
home = Attribute("home",
"Experiment home directory to store all experiment related files",
- flags = Flags.ExecReadOnly)
+ flags = Flags.Design)
identity = Attribute("identity", "SSH identity file",
flags = Flags.Credential)
server_key = Attribute("serverKey", "Server public key",
- flags = Flags.ExecReadOnly)
+ flags = Flags.Design)
clean_home = Attribute("cleanHome", "Remove all nepi files and directories "
" from node home folder before starting experiment",
type = Types.Bool,
default = False,
- flags = Flags.ExecReadOnly)
+ flags = Flags.Design)
clean_experiment = Attribute("cleanExperiment", "Remove all files and directories "
" from a previous same experiment, before the new experiment starts",
type = Types.Bool,
default = False,
- flags = Flags.ExecReadOnly)
+ flags = Flags.Design)
clean_processes = Attribute("cleanProcesses",
"Kill all running processes before starting experiment",
type = Types.Bool,
default = False,
- flags = Flags.ExecReadOnly)
+ flags = Flags.Design)
tear_down = Attribute("tearDown", "Bash script to be executed before " + \
"releasing the resource",
- flags = Flags.ExecReadOnly)
+ flags = Flags.Design)
+
+ gateway_user = Attribute("gatewayUser", "Gateway account username",
+ flags = Flags.Design)
+
+ gateway = Attribute("gateway", "Hostname of the gateway machine",
+ flags = Flags.Design)
cls._register_attribute(hostname)
cls._register_attribute(username)
cls._register_attribute(clean_experiment)
cls._register_attribute(clean_processes)
cls._register_attribute(tear_down)
+ cls._register_attribute(gateway_user)
+ cls._register_attribute(gateway)
def __init__(self, ec, guid):
super(LinuxNode, self).__init__(ec, guid)
self._os = None
# home directory at Linux host
self._home_dir = ""
-
+
# lock to prevent concurrent applications on the same node,
# to execute commands at the same time. There are potential
# concurrency issues when using SSH to a same host from
# TODO: Validate!
return True
- def clean_processes(self, killer = False):
+ def clean_processes(self):
self.info("Cleaning up processes")
-
- if killer:
- # Hardcore kill
- cmd = ("sudo -S killall python tcpdump || /bin/true ; " +
- "sudo -S killall python tcpdump || /bin/true ; " +
- "sudo -S kill $(ps -N -T -o pid --no-heading | grep -v $PPID | sort) || /bin/true ; " +
- "sudo -S killall -u root || /bin/true ; " +
- "sudo -S killall -u root || /bin/true ; ")
- else:
- # Be gentler...
+
+ if self.get("username") != 'root':
cmd = ("sudo -S killall tcpdump || /bin/true ; " +
- "sudo -S killall tcpdump || /bin/true ; " +
- "sudo -S killall -u %s || /bin/true ; " % self.get("username") +
+ "sudo -S kill $(ps aux | grep '[n]epi' | awk '{print $2}') || /bin/true ; " +
"sudo -S killall -u %s || /bin/true ; " % self.get("username"))
+ else:
+ if self.state >= ResourceState.READY:
+ import pickle
+ pids = pickle.load(open("/tmp/save.proc", "rb"))
+ pids_temp = dict()
+ ps_aux = "ps aux |awk '{print $2,$11}'"
+ (out, err), proc = self.execute(ps_aux)
+ for line in out.strip().split("\n"):
+ parts = line.strip().split(" ")
+ pids_temp[parts[0]] = parts[1]
+ kill_pids = set(pids_temp.items()) - set(pids.items())
+ kill_pids = ' '.join(dict(kill_pids).keys())
+
+ cmd = ("killall tcpdump || /bin/true ; " +
+ "kill $(ps aux | grep '[n]epi' | awk '{print $2}') || /bin/true ; " +
+ "kill %s || /bin/true ; " % kill_pids)
+ else:
+ cmd = ("killall tcpdump || /bin/true ; " +
+ "kill $(ps aux | grep '[n]epi' | awk '{print $2}') || /bin/true ; ")
out = err = ""
(out, err), proc = self.execute(cmd, retry = 1, with_lock = True)
def execute(self, command,
sudo = False,
- stdin = None,
env = None,
tty = False,
forward_x11 = False,
- timeout = None,
retry = 3,
- err_on_timeout = True,
connect_timeout = 30,
strict_host_checking = False,
persistent = True,
if self.localhost:
(out, err), proc = execfuncs.lexec(command,
- user = user,
+ user = self.get("username"), # still problem with localhost
sudo = sudo,
- stdin = stdin,
env = env)
else:
if with_lock:
+ # If the execute command is blocking, we don't want to keep
+ # the node lock. This lock is used to avoid race conditions
+ # when creating the ControlMaster sockets. A more elegant
+ # solution is needed.
with self._node_lock:
(out, err), proc = sshfuncs.rexec(
command,
host = self.get("hostname"),
user = self.get("username"),
port = self.get("port"),
+ gwuser = self.get("gatewayUser"),
+ gw = self.get("gateway"),
agent = True,
sudo = sudo,
- stdin = stdin,
identity = self.get("identity"),
server_key = self.get("serverKey"),
env = env,
tty = tty,
forward_x11 = forward_x11,
- timeout = timeout,
retry = retry,
- err_on_timeout = err_on_timeout,
connect_timeout = connect_timeout,
persistent = persistent,
blocking = blocking,
host = self.get("hostname"),
user = self.get("username"),
port = self.get("port"),
+ gwuser = self.get("gatewayUser"),
+ gw = self.get("gateway"),
agent = True,
sudo = sudo,
- stdin = stdin,
identity = self.get("identity"),
server_key = self.get("serverKey"),
env = env,
tty = tty,
forward_x11 = forward_x11,
- timeout = timeout,
retry = retry,
- err_on_timeout = err_on_timeout,
connect_timeout = connect_timeout,
persistent = persistent,
blocking = blocking,
host = self.get("hostname"),
user = self.get("username"),
port = self.get("port"),
+ gwuser = self.get("gatewayUser"),
+ gw = self.get("gateway"),
agent = True,
identity = self.get("identity"),
server_key = self.get("serverKey"),
host = self.get("hostname"),
user = self.get("username"),
port = self.get("port"),
+ gwuser = self.get("gatewayUser"),
+ gw = self.get("gateway"),
agent = True,
identity = self.get("identity"),
server_key = self.get("serverKey")
host = self.get("hostname"),
user = self.get("username"),
port = self.get("port"),
+ gwuser = self.get("gatewayUser"),
+ gw = self.get("gateway"),
agent = True,
identity = self.get("identity"),
server_key = self.get("serverKey")
host = self.get("hostname"),
user = self.get("username"),
port = self.get("port"),
+ gwuser = self.get("gatewayUser"),
+ gw = self.get("gateway"),
agent = True,
sudo = sudo,
identity = self.get("identity"),
(out, err), proc = sshfuncs.rcopy(
src, dst,
port = self.get("port"),
+ gwuser = self.get("gatewayUser"),
+ gw = self.get("gateway"),
identity = self.get("identity"),
server_key = self.get("serverKey"),
recursive = True,
def upload(self, src, dst, text = False, overwrite = True):
""" Copy content to destination
- src content to copy. Can be a local file, directory or a list of files
+ src string with the content to copy. Can be:
+ - plain text
+ - a string with the path to a local file
+ - a string with a semi-colon separeted list of local files
+ - a string with a local directory
- dst destination path on the remote host (remote is always self.host)
+ dst string with destination path on the remote host (remote is
+ always self.host)
- text src is text input, it must be stored into a temp file before uploading
+ text src is text input, it must be stored into a temp file before
+ uploading
"""
# If source is a string input
f = None
src = f.name
# If dst files should not be overwritten, check that the files do not
- # exits already
+ # exits already
+ if isinstance(src, str):
+ src = map(str.strip, src.split(";"))
+
if overwrite == False:
src = self.filter_existing_files(src, dst)
if not src:
- return ("", ""), None
+ return ("", ""), None
if not self.localhost:
# Build destination as <user>@<server>:<path>
self._home_dir = out.strip()
except:
trace = traceback.format_exc()
- msg = "Impossible to retrieve HOME directory" % trace
+ msg = "Impossible to retrieve HOME directory %s" % trace
if not self._home_dir:
- self.error(msg, out, err)
+ self.error(msg)
raise RuntimeError, msg
def filter_existing_files(self, src, dst):
""" Removes files that already exist in the Linux host from src list
"""
# construct a dictionary with { dst: src }
- dests = dict(map(lambda x: ( os.path.join(dst, os.path.basename(x) ), x ),
- src.strip().split(" ") ) ) if src.strip().find(" ") != -1 else dict({dst: src})
+ dests = dict(map(
+ lambda s: (os.path.join(dst, os.path.basename(s)), s ), s)) \
+ if len(src) > 1 else dict({dst: src[0]})
command = []
for d in dests.keys():
del dests[d]
if not dests:
- return ""
+ return []
- return " ".join(dests.values())
+ return dests.values()
git://git.onelab.eu / nepi.git / blobdiff