SysTutorials

Linux Manual Pages › Section 3

nfstest-rexec(3)

nfstest.rexec – Remote procedure module

Description

Provides a set of tools for executing a wide range commands, statements, expressions or functions on a remote host by running a server process on the remote host serving requests without disconnecting. This allows for a sequence of operations to be done remotely and not losing state. A file could be opened remotely, do some other things and then write to the same opened file without opening the file again.

In order to use this module the user id must be able to ‘ssh’ to the remote host without the need for a password.

Classes

class Rexec(baseobj.BaseObj)

Rexec object
 Rexec() -> New remote procedure object
 Arguments:
 servername:
 Name or IP address of remote server
 logfile:
 Name of logfile to create on remote server
 Usage:
 from nfstest.rexec import Rexec
 # Function to be defined at remote host
 def add_one(n):
 return n + 1
 # Function to be defined at remote host
 def get_time(delay=0):
 time.sleep(delay)
 return time.time()
 # Create remote procedure object
 x = Rexec("192.168.0.85")
 # Define function at remote host
 x.rcode(add_one)
 # Evaluate the expression calling add_one()
 out = x.reval("add_one(67)")
 # Run the function with the given argument
 out = x.run("add_one", 7)
 # Run built-in functions
 import time
 out = x.run(time.time)
 # Import libraries and symbols
 x.rimport("time", ["sleep"])
 x.run("sleep", 2)
 # Define function at remote host -- since function uses the
 # time module, this module must be first imported
 x.rimport("time")
 x.rcode(get_time)
 # Evaluate the expression calling get_time()
 out = x.reval("get_time()")
 # Run the function with the given argument
 out = x.run("get_time", 10)
 # Open file on remote host
 fd = x.run(os.open, "/tmp/testfile", os.O_WRONLY|os.O_CREAT|os.O_TRUNC)
 count = x.run(os.write, fd, "hello there
	")
 x.run(os.close, fd)
 # Use of positional arguments
 out = x.run('get_time', 2)
 # Use of named arguments
 out = x.run('get_time', delay=2)
 # Use of NOWAIT option for long running functions so other things
 # can be done while waiting
 x.run('get_time', 2, NOWAIT=True)
 while True:
 # Poll every 0.1 secs to see if function has finished
 if x.poll(0.1):
 # Get results
 out = x.results()
 break
Methods defined here:
---------------------
__del__(self)
Destructor
__init__(self, servername='', logfile=None, sync_timeout=0.10000000000000001)
Constructor
Initialize object's private data.
servername:
Host name or IP address of host where remote server will run
logfile:
Pathname of log file to be created on remote host [Default: "/dev/null"]
sync_timeout:
Timeout used for synchronizing the connection stream [Default: 0.1]
poll(self, timeout=0) Return whether there is any data available to be read
timeout:
Maximum time in seconds to block, if timeout is None then an infinite timeout is used
rcode(self, code) Define function on remote server results(self) Return pending results reval(self, expr) Evaluate expression on remote server rexec(self, expr) Execute statement on remote server rimport(self, module, symbols=[]) Import module on remote server
module:
Module to import in the remote server
symbols:
If given, import only these symbols from the module
run(self, *kwts, **kwds) Run function on remote server The first positional argument is the function to be executed. All other positional arguments and any named arguments are treated as arguments to the function wait(self, objlist=None, timeout=0) Return a list of Rexec objects where data is available to be read
objlist:
List of Rexec objects to poll, if not given use current object
timeout:
Maximum time in seconds to block, if timeout is None then an infinite timeout is used

Functions

bare_server(port, logfile)

Bare-bones remote server

proc_requests(fd, conn)

Main remote procedure server

fd:
File descriptor for logfile
conn:
Connection object

write_log(fd, msg, nl=’)

Return timestamp

See Also

baseobj(3)

Bugs

No known bugs.

Author

Jorge Mora (mora [at] netapp.com)