class RemoteServer(builtins.object)¶

Methods defined here:
---------------------

__del__(self)
Destructor

__init__(self, port, logfile=None)
Remote procedure server

log(self, msg)
Write message to log file

start(self)

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


           sudo:


               Run remote server as root


       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


           # Create remote procedure object as a different user


           # First, run the remote server as root


           x = Rexec("192.168.0.85", sudo=True)


           # Then set the effective user id


           x.run(os.seteuid, 1000)

Methods defined here:
---------------------

__del__(self)
Destructor

__init__(self, servername=None, logfile=None, sudo=False, timeout=30.0)
Constructor
Initialize object's private data.

close(self)
Close connection to remote server

poll(self, timeout=0)
Return whether there is any data available to be read

rcode(self, code)
Define function on remote server

results(self, xid=None)
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

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