src/nepi/resources/linux/application.py

   1 #
   2 #    NEPI, a framework to manage network experiments
   3 #    Copyright (C) 2013 INRIA
   4 #
   5 #    This program is free software: you can redistribute it and/or modify
   6 #    it under the terms of the GNU General Public License as published by
   7 #    the Free Software Foundation, either version 3 of the License, or
   8 #    (at your option) any later version.
   9 #
  10 #    This program is distributed in the hope that it will be useful,
  11 #    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 #    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 #    GNU General Public License for more details.
  14 #
  15 #    You should have received a copy of the GNU General Public License
  16 #    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  17 #
  18 # Author: Alina Quereilhac <alina.quereilhac@inria.fr>
  19
  20 from nepi.execution.attribute import Attribute, Flags, Types
  21 from nepi.execution.trace import Trace, TraceAttr
  22 from nepi.execution.resource import ResourceManager, clsinit_copy, \
  23         ResourceState, reschedule_delay
  24 from nepi.resources.linux.node import LinuxNode
  25 from nepi.util.sshfuncs import ProcStatus
  26 from nepi.util.timefuncs import tnow, tdiffsec
  27
  28 import os
  29 import subprocess
  30
  31 # TODO: Resolve wildcards in commands!!
  32 # TODO: When a failure occurs during deployment, scp and ssh processes are left running behind!!
  33
  34 @clsinit_copy
  35 class LinuxApplication(ResourceManager):
  36     """
  37     .. class:: Class Args :
  38
  39         :param ec: The Experiment controller
  40         :type ec: ExperimentController
  41         :param guid: guid of the RM
  42         :type guid: int
  43
  44     .. note::
  45
  46         A LinuxApplication RM represents a process that can be executed in
  47         a remote Linux host using SSH.
  48
  49         The LinuxApplication RM takes care of uploadin sources and any files
  50         needed to run the experiment, to the remote host.
  51         It also allows to provide source compilation (build) and installation
  52         instructions, and takes care of automating the sources build and
  53         installation tasks for the user.
  54
  55         It is important to note that files uploaded to the remote host have
  56         two possible scopes: single-experiment or multi-experiment.
  57         Single experiment files are those that will not be re-used by other
  58         experiments. Multi-experiment files are those that will.
  59         Sources and shared files are always made available to all experiments.
  60
  61         Directory structure:
  62
  63         The directory structure used by LinuxApplication RM at the Linux
  64         host is the following:
  65
  66         ${HOME}/.nepi/nepi-usr --> Base directory for multi-experiment files
  67                       |
  68         ${LIB}        |- /lib --> Base directory for libraries
  69         ${BIN}        |- /bin --> Base directory for binary files
  70         ${SRC}        |- /src --> Base directory for sources
  71         ${SHARE}      |- /share --> Base directory for other files
  72
  73         ${HOME}/.nepi/nepi-exp --> Base directory for single-experiment files
  74                       |
  75         ${EXP_HOME}   |- /<exp-id>  --> Base directory for experiment exp-id
  76                           |
  77         ${APP_HOME}       |- /<app-guid> --> Base directory for application
  78                                |     specific files (e.g. command.sh, input)
  79                                |
  80         ${RUN_HOME}            |- /<run-id> --> Base directory for run specific
  81
  82     """
  83
  84     _rtype = "LinuxApplication"
  85     _help = "Runs an application on a Linux host with a BASH command "
  86     _backend_type = "linux"
  87
  88     @classmethod
  89     def _register_attributes(cls):
  90         command = Attribute("command", "Command to execute at application start. "
  91                 "Note that commands will be executed in the ${RUN_HOME} directory, "
  92                 "make sure to take this into account when using relative paths. ",
  93                 flags = Flags.Design)
  94         forward_x11 = Attribute("forwardX11", "Enables X11 forwarding for SSH connections",
  95                 flags = Flags.Design)
  96         env = Attribute("env", "Environment variables string for command execution",
  97                 flags = Flags.Design)
  98         sudo = Attribute("sudo", "Run with root privileges",
  99                 flags = Flags.Design)
 100         depends = Attribute("depends",
 101                 "Space-separated list of packages required to run the application",
 102                 flags = Flags.Design)
 103         sources = Attribute("sources",
 104                 "semi-colon separated list of regular files to be uploaded to ${SRC} "
 105                 "directory prior to building. Archives won't be expanded automatically. "
 106                 "Sources are globally available for all experiments unless "
 107                 "cleanHome is set to True (This will delete all sources). ",
 108                 flags = Flags.Design)
 109         files = Attribute("files",
 110                 "semi-colon separated list of regular miscellaneous files to be uploaded "
 111                 "to ${SHARE} directory. "
 112                 "Files are globally available for all experiments unless "
 113                 "cleanHome is set to True (This will delete all files). ",
 114                 flags = Flags.Design)
 115         libs = Attribute("libs",
 116                 "semi-colon separated list of libraries (e.g. .so files) to be uploaded "
 117                 "to ${LIB} directory. "
 118                 "Libraries are globally available for all experiments unless "
 119                 "cleanHome is set to True (This will delete all files). ",
 120                 flags = Flags.Design)
 121         bins = Attribute("bins",
 122                 "semi-colon separated list of binary files to be uploaded "
 123                 "to ${BIN} directory. "
 124                 "Binaries are globally available for all experiments unless "
 125                 "cleanHome is set to True (This will delete all files). ",
 126                 flags = Flags.Design)
 127         code = Attribute("code",
 128                 "Plain text source code to be uploaded to the ${APP_HOME} directory. ",
 129                 flags = Flags.Design)
 130         build = Attribute("build",
 131                 "Build commands to execute after deploying the sources. "
 132                 "Sources are uploaded to the ${SRC} directory and code "
 133                 "is uploaded to the ${APP_HOME} directory. \n"
 134                 "Usage example: tar xzf ${SRC}/my-app.tgz && cd my-app && "
 135                 "./configure && make && make clean.\n"
 136                 "Make sure to make the build commands return with a nonzero exit "
 137                 "code on error.",
 138                 flags = Flags.Design)
 139         install = Attribute("install",
 140                 "Commands to transfer built files to their final destinations. "
 141                 "Install commands are executed after build commands. ",
 142                 flags = Flags.Design)
 143         stdin = Attribute("stdin", "Standard input for the 'command'",
 144                 flags = Flags.Design)
 145         tear_down = Attribute("tearDown", "Command to be executed just before "
 146                 "releasing the resource",
 147                 flags = Flags.Design)
 148
 149         cls._register_attribute(command)
 150         cls._register_attribute(forward_x11)
 151         cls._register_attribute(env)
 152         cls._register_attribute(sudo)
 153         cls._register_attribute(depends)
 154         cls._register_attribute(sources)
 155         cls._register_attribute(code)
 156         cls._register_attribute(files)
 157         cls._register_attribute(bins)
 158         cls._register_attribute(libs)
 159         cls._register_attribute(build)
 160         cls._register_attribute(install)
 161         cls._register_attribute(stdin)
 162         cls._register_attribute(tear_down)
 163
 164     @classmethod
 165     def _register_traces(cls):
 166         stdout = Trace("stdout", "Standard output stream", enabled = True)
 167         stderr = Trace("stderr", "Standard error stream", enabled = True)
 168
 169         cls._register_trace(stdout)
 170         cls._register_trace(stderr)
 171
 172     def __init__(self, ec, guid):
 173         super(LinuxApplication, self).__init__(ec, guid)
 174         self._pid = None
 175         self._ppid = None
 176         self._home = "app-%s" % self.guid
 177         # whether the command should run in foreground attached
 178         # to a terminal
 179         self._in_foreground = False
 180
 181         # whether to use sudo to kill the application process
 182         self._sudo_kill = False
 183
 184         # keep a reference to the running process handler when
 185         # the command is not executed as remote daemon in background
 186         self._proc = None
 187
 188         # timestamp of last state check of the application
 189         self._last_state_check = tnow()
 190
 191     def log_message(self, msg):
 192         return " guid %d - host %s - %s " % (self.guid,
 193                 self.node.get("hostname"), msg)
 194
 195     @property
 196     def node(self):
 197         node = self.get_connected(LinuxNode.get_rtype())
 198         if node: return node[0]
 199         return None
 200
 201     @property
 202     def app_home(self):
 203         return os.path.join(self.node.exp_home, self._home)
 204
 205     @property
 206     def run_home(self):
 207         return os.path.join(self.app_home, self.ec.run_id)
 208
 209     @property
 210     def pid(self):
 211         return self._pid
 212
 213     @property
 214     def ppid(self):
 215         return self._ppid
 216
 217     @property
 218     def in_foreground(self):
 219         """ Returns True if the command needs to be executed in foreground.
 220         This means that command will be executed using 'execute' instead of
 221         'run' ('run' executes a command in background and detached from the
 222         terminal)
 223
 224         When using X11 forwarding option, the command can not run in background
 225         and detached from a terminal, since we need to keep the terminal attached
 226         to interact with it.
 227         """
 228         return self.get("forwardX11") or self._in_foreground
 229
 230     def trace_filepath(self, filename):
 231         return os.path.join(self.run_home, filename)
 232
 233     def trace(self, name, attr = TraceAttr.ALL, block = 512, offset = 0):
 234         self.info("Retrieving '%s' trace %s " % (name, attr))
 235
 236         path = self.trace_filepath(name)
 237
 238         command = "(test -f %s && echo 'success') || echo 'error'" % path
 239         (out, err), proc = self.node.execute(command)
 240
 241         if (err and proc.poll()) or out.find("error") != -1:
 242             msg = " Couldn't find trace %s " % name
 243             self.error(msg, out, err)
 244             return None
 245
 246         if attr == TraceAttr.PATH:
 247             return path
 248
 249         if attr == TraceAttr.ALL:
 250             (out, err), proc = self.node.check_output(self.run_home, name)
 251
 252             if proc.poll():
 253                 msg = " Couldn't read trace %s " % name
 254                 self.error(msg, out, err)
 255                 return None
 256
 257             return out
 258
 259         if attr == TraceAttr.STREAM:
 260             cmd = "dd if=%s bs=%d count=1 skip=%d" % (path, block, offset)
 261         elif attr == TraceAttr.SIZE:
 262             cmd = "stat -c%%s %s " % path
 263
 264         (out, err), proc = self.node.execute(cmd)
 265
 266         if proc.poll():
 267             msg = " Couldn't find trace %s " % name
 268             self.error(msg, out, err)
 269             return None
 270
 271         if attr == TraceAttr.SIZE:
 272             out = int(out.strip())
 273
 274         return out
 275
 276     def do_provision(self):
 277         # take a snapshot of the system if user is root
 278         # to ensure that cleanProcess will not kill
 279         # pre-existent processes
 280         if self.node.get("username") == 'root':
 281             import pickle
 282             procs = dict()
 283             ps_aux = "ps aux |awk '{print $2,$11}'"
 284             (out, err), proc = self.node.execute(ps_aux)
 285             if len(out) != 0:
 286                 for line in out.strip().split("\n"):
 287                     parts = line.strip().split(" ")
 288                     procs[parts[0]] = parts[1]
 289                 pickle.dump(procs, open("/tmp/save.proc", "wb"))
 290
 291         # create run dir for application
 292         self.node.mkdir(self.run_home)
 293
 294         # List of all the provision methods to invoke
 295         steps = [
 296             # upload sources
 297             self.upload_sources,
 298             # upload files
 299             self.upload_files,
 300             # upload binaries
 301             self.upload_binaries,
 302             # upload libraries
 303             self.upload_libraries,
 304             # upload code
 305             self.upload_code,
 306             # upload stdin
 307             self.upload_stdin,
 308             # install dependencies
 309             self.install_dependencies,
 310             # build
 311             self.build,
 312             # Install
 313             self.install]
 314
 315         command = []
 316
 317         # Since provisioning takes a long time, before
 318         # each step we check that the EC is still
 319         for step in steps:
 320             if self.ec.abort:
 321                 self.debug("Interrupting provisioning. EC says 'ABORT")
 322                 return
 323
 324             ret = step()
 325             if ret:
 326                 command.append(ret)
 327
 328         # upload deploy script
 329         deploy_command = ";".join(command)
 330         self.execute_deploy_command(deploy_command)
 331
 332         # upload start script
 333         self.upload_start_command()
 334
 335         self.info("Provisioning finished")
 336
 337         super(LinuxApplication, self).do_provision()
 338
 339     def upload_start_command(self, overwrite = False):
 340         # Upload command to remote bash script
 341         # - only if command can be executed in background and detached
 342         command = self.get("command")
 343
 344         if command and not self.in_foreground:
 345             self.info("Uploading command '%s'" % command)
 346
 347             # replace application specific paths in the command
 348             command = self.replace_paths(command)
 349
 350             # replace application specific paths in the environment
 351             env = self.get("env")
 352             env = env and self.replace_paths(env)
 353
 354             shfile = os.path.join(self.app_home, "start.sh")
 355
 356             self.node.upload_command(command,
 357                     shfile = shfile,
 358                     env = env,
 359                     overwrite = overwrite)
 360
 361     def execute_deploy_command(self, command, prefix="deploy"):
 362         if command:
 363             # Upload the command to a bash script and run it
 364             # in background ( but wait until the command has
 365             # finished to continue )
 366             shfile = os.path.join(self.app_home, "%s.sh" % prefix)
 367             self.node.run_and_wait(command, self.run_home,
 368                     shfile = shfile,
 369                     overwrite = False,
 370                     pidfile = "%s_pidfile" % prefix,
 371                     ecodefile = "%s_exitcode" % prefix,
 372                     stdout = "%s_stdout" % prefix,
 373                     stderr = "%s_stderr" % prefix)
 374
 375     def upload_sources(self, sources = None, src_dir = None):
 376         if not sources:
 377             sources = self.get("sources")
 378
 379         command = ""
 380
 381         if not src_dir:
 382             src_dir = self.node.src_dir
 383
 384         if sources:
 385             self.info("Uploading sources ")
 386
 387             sources = map(str.strip, sources.split(";"))
 388
 389             # Separate sources that should be downloaded from
 390             # the web, from sources that should be uploaded from
 391             # the local machine
 392             command = []
 393             for source in list(sources):
 394                 if source.startswith("http") or source.startswith("https"):
 395                     # remove the hhtp source from the sources list
 396                     sources.remove(source)
 397
 398                     command.append( " ( "
 399                             # Check if the source already exists
 400                             " ls %(src_dir)s/%(basename)s "
 401                             " || ( "
 402                             # If source doesn't exist, download it and check
 403                             # that it it downloaded ok
 404                             "   wget -c --directory-prefix=%(src_dir)s %(source)s && "
 405                             "   ls %(src_dir)s/%(basename)s "
 406                             " ) ) " % {
 407                                 "basename": os.path.basename(source),
 408                                 "source": source,
 409                                 "src_dir": src_dir
 410                                 })
 411
 412             command = " && ".join(command)
 413
 414             # replace application specific paths in the command
 415             command = self.replace_paths(command)
 416
 417             if sources:
 418                 sources = ';'.join(sources)
 419                 self.node.upload(sources, src_dir, overwrite = False)
 420
 421         return command
 422
 423     def upload_files(self, files = None):
 424         if not files:
 425             files = self.get("files")
 426
 427         if files:
 428             self.info("Uploading files %s " % files)
 429             self.node.upload(files, self.node.share_dir, overwrite = False)
 430
 431     def upload_libraries(self, libs = None):
 432         if not libs:
 433             libs = self.get("libs")
 434
 435         if libs:
 436             self.info("Uploading libraries %s " % libaries)
 437             self.node.upload(libs, self.node.lib_dir, overwrite = False)
 438
 439     def upload_binaries(self, bins = None):
 440         if not bins:
 441             bins = self.get("bins")
 442
 443         if bins:
 444             self.info("Uploading binaries %s " % binaries)
 445             self.node.upload(bins, self.node.bin_dir, overwrite = False)
 446
 447     def upload_code(self, code = None):
 448         if not code:
 449             code = self.get("code")
 450
 451         if code:
 452             self.info("Uploading code")
 453
 454             dst = os.path.join(self.app_home, "code")
 455             self.node.upload(code, dst, overwrite = False, text = True)
 456
 457     def upload_stdin(self, stdin = None):
 458         if not stdin:
 459            stdin = self.get("stdin")
 460
 461         if stdin:
 462             # create dir for sources
 463             self.info("Uploading stdin")
 464
 465             # upload stdin file to ${SHARE_DIR} directory
 466             if os.path.isfile(stdin):
 467                 basename = os.path.basename(stdin)
 468                 dst = os.path.join(self.node.share_dir, basename)
 469             else:
 470                 dst = os.path.join(self.app_home, "stdin")
 471
 472             self.node.upload(stdin, dst, overwrite = False, text = True)
 473
 474             # create "stdin" symlink on ${APP_HOME} directory
 475             command = "( cd %(app_home)s ; [ ! -f stdin ] &&  ln -s %(stdin)s stdin )" % ({
 476                 "app_home": self.app_home,
 477                 "stdin": dst })
 478
 479             return command
 480
 481     def install_dependencies(self, depends = None):
 482         if not depends:
 483             depends = self.get("depends")
 484
 485         if depends:
 486             self.info("Installing dependencies %s" % depends)
 487             return self.node.install_packages_command(depends)
 488
 489     def build(self, build = None):
 490         if not build:
 491             build = self.get("build")
 492
 493         if build:
 494             self.info("Building sources ")
 495
 496             # replace application specific paths in the command
 497             return self.replace_paths(build)
 498
 499     def install(self, install = None):
 500         if not install:
 501             install = self.get("install")
 502
 503         if install:
 504             self.info("Installing sources ")
 505
 506             # replace application specific paths in the command
 507             return self.replace_paths(install)
 508
 509     def do_deploy(self):
 510         # Wait until node is associated and deployed
 511         node = self.node
 512         if not node or node.state < ResourceState.READY:
 513             self.debug("---- RESCHEDULING DEPLOY ---- node state %s " % self.node.state )
 514             self.ec.schedule(reschedule_delay, self.deploy)
 515         else:
 516             command = self.get("command") or ""
 517             self.info("Deploying command '%s' " % command)
 518             self.do_discover()
 519             self.do_provision()
 520
 521             super(LinuxApplication, self).do_deploy()
 522
 523     def do_start(self):
 524         command = self.get("command")
 525
 526         self.info("Starting command '%s'" % command)
 527
 528         if not command:
 529             # If no command was given (i.e. Application was used for dependency
 530             # installation), then the application is directly marked as STOPPED
 531             super(LinuxApplication, self).set_stopped()
 532         else:
 533             if self.in_foreground:
 534                 self._run_in_foreground()
 535             else:
 536                 self._run_in_background()
 537
 538             super(LinuxApplication, self).do_start()
 539
 540     def _run_in_foreground(self):
 541         command = self.get("command")
 542         sudo = self.get("sudo") or False
 543         x11 = self.get("forwardX11")
 544         env = self.get("env")
 545
 546         # Command will be launched in foreground and attached to the
 547         # terminal using the node 'execute' in non blocking mode.
 548
 549         # We save the reference to the process in self._proc
 550         # to be able to kill the process from the stop method.
 551         # We also set blocking = False, since we don't want the
 552         # thread to block until the execution finishes.
 553         (out, err), self._proc = self.execute_command(command,
 554                 env = env,
 555                 sudo = sudo,
 556                 forward_x11 = x11,
 557                 blocking = False)
 558
 559         if self._proc.poll():
 560             self.error(msg, out, err)
 561             raise RuntimeError, msg
 562
 563     def _run_in_background(self):
 564         command = self.get("command")
 565         env = self.get("env")
 566         sudo = self.get("sudo") or False
 567
 568         stdout = "stdout"
 569         stderr = "stderr"
 570         stdin = os.path.join(self.app_home, "stdin") if self.get("stdin") \
 571                 else None
 572
 573         # Command will be run as a daemon in baground and detached from any
 574         # terminal.
 575         # The command to run was previously uploaded to a bash script
 576         # during deployment, now we launch the remote script using 'run'
 577         # method from the node.
 578         cmd = "bash %s" % os.path.join(self.app_home, "start.sh")
 579         (out, err), proc = self.node.run(cmd, self.run_home,
 580             stdin = stdin,
 581             stdout = stdout,
 582             stderr = stderr,
 583             sudo = sudo)
 584
 585         # check if execution errors occurred
 586         msg = " Failed to start command '%s' " % command
 587
 588         if proc.poll():
 589             self.error(msg, out, err)
 590             raise RuntimeError, msg
 591
 592         # Wait for pid file to be generated
 593         pid, ppid = self.node.wait_pid(self.run_home)
 594         if pid: self._pid = int(pid)
 595         if ppid: self._ppid = int(ppid)
 596
 597         # If the process is not running, check for error information
 598         # on the remote machine
 599         if not self.pid or not self.ppid:
 600             (out, err), proc = self.node.check_errors(self.run_home,
 601                     stderr = stderr)
 602
 603             # Out is what was written in the stderr file
 604             if err:
 605                 msg = " Failed to start command '%s' " % command
 606                 self.error(msg, out, err)
 607                 raise RuntimeError, msg
 608
 609     def do_stop(self):
 610         """ Stops application execution
 611         """
 612         command = self.get('command') or ''
 613
 614         if self.state == ResourceState.STARTED:
 615
 616             self.info("Stopping command '%s' " % command)
 617
 618             # If the command is running in foreground (it was launched using
 619             # the node 'execute' method), then we use the handler to the Popen
 620             # process to kill it. Else we send a kill signal using the pid and ppid
 621             # retrieved after running the command with the node 'run' method
 622             if self._proc:
 623                 self._proc.kill()
 624             else:
 625                 # Only try to kill the process if the pid and ppid
 626                 # were retrieved
 627                 if self.pid and self.ppid:
 628                     (out, err), proc = self.node.kill(self.pid, self.ppid,
 629                             sudo = self._sudo_kill)
 630
 631                     # TODO: check if execution errors occurred
 632                     if (proc and proc.poll()) or err:
 633                         msg = " Failed to STOP command '%s' " % self.get("command")
 634                         self.error(msg, out, err)
 635
 636             super(LinuxApplication, self).do_stop()
 637
 638     def do_release(self):
 639         self.info("Releasing resource")
 640
 641         self.do_stop()
 642
 643         tear_down = self.get("tearDown")
 644         if tear_down:
 645             self.node.execute(tear_down)
 646
 647         hard_release = self.get("hardRelease")
 648         if hard_release:
 649             self.node.rmdir(self.app_home)
 650
 651         super(LinuxApplication, self).do_release()
 652
 653     @property
 654     def state(self):
 655         """ Returns the state of the application
 656         """
 657         if self._state == ResourceState.STARTED:
 658             if self.in_foreground:
 659                 # Check if the process we used to execute the command
 660                 # is still running ...
 661                 retcode = self._proc.poll()
 662
 663                 # retcode == None -> running
 664                 # retcode > 0 -> error
 665                 # retcode == 0 -> finished
 666                 if retcode:
 667                     out = ""
 668                     msg = " Failed to execute command '%s'" % self.get("command")
 669                     err = self._proc.stderr.read()
 670                     self.error(msg, out, err)
 671                     self.do_fail()
 672
 673                 elif retcode == 0:
 674                     self.set_stopped()
 675             else:
 676                 # We need to query the status of the command we launched in
 677                 # background. In order to avoid overwhelming the remote host and
 678                 # the local processor with too many ssh queries, the state is only
 679                 # requested every 'state_check_delay' seconds.
 680                 state_check_delay = 0.5
 681                 if tdiffsec(tnow(), self._last_state_check) > state_check_delay:
 682                     if self.pid and self.ppid:
 683                         # Make sure the process is still running in background
 684                         status = self.node.status(self.pid, self.ppid)
 685
 686                         if status == ProcStatus.FINISHED:
 687                             # If the program finished, check if execution
 688                             # errors occurred
 689                             (out, err), proc = self.node.check_errors(
 690                                     self.run_home)
 691
 692                             if err:
 693                                 msg = "Failed to execute command '%s'" % \
 694                                         self.get("command")
 695                                 self.error(msg, out, err)
 696                                 self.do_fail()
 697                             else:
 698                                 self.set_stopped()
 699
 700                     self._last_state_check = tnow()
 701
 702         return self._state
 703
 704     def execute_command(self, command,
 705             env = None,
 706             sudo = False,
 707             forward_x11 = False,
 708             blocking = False):
 709
 710         environ = ""
 711         if env:
 712             environ = self.node.format_environment(env, inline = True)
 713         command = environ + command
 714         command = self.replace_paths(command)
 715
 716         return self.node.execute(command,
 717                 sudo = sudo,
 718                 forward_x11 = forward_x11,
 719                 blocking = blocking)
 720
 721     def replace_paths(self, command):
 722         """
 723         Replace all special path tags with shell-escaped actual paths.
 724         """
 725         return ( command
 726             .replace("${USR}", self.node.usr_dir)
 727             .replace("${LIB}", self.node.lib_dir)
 728             .replace("${BIN}", self.node.bin_dir)
 729             .replace("${SRC}", self.node.src_dir)
 730             .replace("${SHARE}", self.node.share_dir)
 731             .replace("${EXP}", self.node.exp_dir)
 732             .replace("${EXP_HOME}", self.node.exp_home)
 733             .replace("${APP_HOME}", self.app_home)
 734             .replace("${RUN_HOME}", self.run_home)
 735             .replace("${NODE_HOME}", self.node.node_home)
 736             .replace("${HOME}", self.node.home_dir)
 737             )
 738
 739     def valid_connection(self, guid):
 740         # TODO: Validate!
 741         return True
 742