def pstat(self, pid):
pm = proctools.get_procmanager()
proc = pm.getbypid(pid)
if proc is not None:
return proc.stat()
else:
return -errno.ENOENT
def run(self, cmd, user=None):
UserLog.msg("run", cmd, str(user))
pm = proctools.get_procmanager()
proc = pm.spawnpty(cmd, pwent=user)
text = proc.read()
sts = proc.wait()
return sts, text
def spawn(self, cmd, user=None):
UserLog.msg("spawn", cmd)
pm = proctools.get_procmanager()
proc = pm.spawnpty(cmd, pwent=user, async=True)
handle = id(proc)
self._files[handle] = proc
return handle
def start_proc_manager(config, logfile):
from pycopia import proctools
from pycopia import scheduler
from pycopia import asyncio
asyncio.start_sigio()
pm = proctools.get_procmanager()
for name, serverlist in config.VHOSTS.items():
for servername in serverlist:
print "Starting %s for %s." % (servername, name)
p = pm.spawnpipe("%s/fcgi_server -n %s" %
(config.LIBEXEC, servername),
persistent=True,
logfile=logfile)
asyncio.poller.register(p)
scheduler.sleep(1.0) # give it time to init...
if config.USEFRONTEND:
lighttpd = proctools.which("lighttpd")
pm.spawnpipe("%s -D -f %s" % (lighttpd, LTCONFIG),
persistent=True,
logfile=logfile)
try:
while 1:
asyncio.poller.loop()
for proc in pm.getprocs():
if proc.readable():
print proc.read(4096)
except KeyboardInterrupt:
asyncio.poller.unregister_all()
for proc in pm.getprocs():
proc.kill()
proc.wait()
if os.path.exists(config.PIDFILE):
os.unlink(config.PIDFILE)
def __init__(self):
from pycopia import proctools
pm = proctools.get_procmanager()
proc = pm.spawnpty("vttest")
self.term = get_ansiterm(proc, 24, 80, ReprPrinter(sys.stdout))
self.logfile = open("/tmp/ANSITerm_test.log", "w")
self.term.printer.set_file(self.logfile)
def pipe(self, cmd, user=None):
UserLog.msg("pipe", cmd)
pm = proctools.get_procmanager()
proc = pm.spawnpipe(cmd, pwent=user)
text = proc.read()
sts = proc.wait()
return sts, text
def spawn(self, cmd, user=None):
UserLog.msg("spawn", cmd)
pm = proctools.get_procmanager()
proc = pm.spawnpty(cmd, pwent=user, async=True)
handle = id(proc)
self._files[handle] = proc
return handle
def run(self, cmd, user=None):
UserLog.msg("run", cmd, str(user))
pm = proctools.get_procmanager()
proc = pm.spawnpty(cmd, pwent=user)
text = proc.read()
sts = proc.wait()
return sts, text
def pstat(self, pid):
pm = proctools.get_procmanager()
proc = pm.getbypid(pid)
if proc is not None:
return proc.stat()
else:
return -errno.ENOENT
def run_async(self, cmd, user=None):
UserLog.msg("run_async", cmd, str(user))
pm = proctools.get_procmanager()
proc = pm.spawnpty(cmd, callback=self._status_cb, pwent=user)
# status with a key present, but None value means a running process.
self._status[proc.childpid] = None
return proc.childpid
def run_async(self, cmd, user=None):
UserLog.msg("run_async", cmd, str(user))
pm = proctools.get_procmanager()
proc = pm.spawnpty(cmd, callback=self._status_cb, pwent=user)
# status with a key present, but None value means a running process.
self._status[proc.childpid] = None
return proc.childpid
def start_proc_manager(config, logfile):
from pycopia import proctools
from pycopia import scheduler
from pycopia import asyncio
pm = proctools.get_procmanager()
libexec = config.get("LIBEXEC", "/usr/libexec/pycopia")
for name, serverlist in config.VHOSTS.items():
for servername in serverlist:
print "Starting %s for %s." % (servername, name)
p = pm.spawnpipe("%s/fcgi_server -n %s" % (libexec, servername),
persistent=True,
logfile=logfile)
asyncio.poller.register(p)
#scheduler.sleep(1.0) # give it time to init...
if config.USEFRONTEND:
lighttpd = proctools.which("lighttpd")
if asyncio.poller:
pm.spawnpipe("%s -D -f %s" % (lighttpd, LTCONFIG),
persistent=True,
logfile=logfile)
else: # no servers, just run frontend alone
pm.spawnpipe("%s -f %s" % (lighttpd, LTCONFIG))
try:
asyncio.poller.loop()
print "No servers, exited loop."
except KeyboardInterrupt:
pass
if asyncio.poller:
asyncio.poller.unregister_all()
for proc in pm.getprocs():
proc.killwait()
if os.path.exists(config.PIDFILE):
os.unlink(config.PIDFILE)
def pipe(self, cmd, user=None):
UserLog.msg("pipe", cmd)
pm = proctools.get_procmanager()
proc = pm.spawnpipe(cmd, pwent=user)
text = proc.read()
sts = proc.wait()
return sts, text
def start_proc_manager(config, logfile):
from pycopia import proctools
from pycopia import scheduler
from pycopia import asyncio
asyncio.start_sigio()
pm = proctools.get_procmanager()
for name, serverlist in config.VHOSTS.items():
for servername in serverlist:
print "Starting %s for %s." % (servername, name)
p = pm.spawnpipe("%s/fcgi_server -n %s" % (config.LIBEXEC, servername), persistent=True, logfile=logfile)
asyncio.poller.register(p)
scheduler.sleep(1.0) # give it time to init...
if config.USEFRONTEND:
lighttpd = proctools.which("lighttpd")
pm.spawnpipe("%s -D -f %s" % (lighttpd, LTCONFIG), persistent=True, logfile=logfile)
try:
while 1:
asyncio.poller.loop()
for proc in pm.getprocs():
if proc.readable():
print proc.read(4096)
except KeyboardInterrupt:
asyncio.poller.unregister_all()
for proc in pm.getprocs():
proc.kill()
proc.wait()
if os.path.exists(config.PIDFILE):
os.unlink(config.PIDFILE)
def start_proc_manager(config, logfile):
from pycopia import proctools
from pycopia import scheduler
from pycopia import asyncio
pm = proctools.get_procmanager()
libexec = config.get("LIBEXEC", "/usr/libexec/pycopia")
for name, serverlist in config.VHOSTS.items():
for servername in serverlist:
print "Starting %s for %s." % (servername, name)
p = pm.spawnpipe("%s/fcgi_server -n %s" % (libexec, servername), persistent=True, logfile=logfile)
asyncio.poller.register(p)
#scheduler.sleep(1.0) # give it time to init...
if config.USEFRONTEND:
lighttpd = proctools.which("lighttpd")
if asyncio.poller:
pm.spawnpipe("%s -D -f %s" % (lighttpd, LTCONFIG), persistent=True, logfile=logfile)
else: # no servers, just run frontend alone
pm.spawnpipe("%s -f %s" % (lighttpd, LTCONFIG))
try:
asyncio.poller.loop()
print "No servers, exited loop."
except KeyboardInterrupt:
pass
if asyncio.poller:
asyncio.poller.unregister_all()
for proc in pm.getprocs():
proc.killwait()
if os.path.exists(config.PIDFILE):
os.unlink(config.PIDFILE)
def start_proc_manager(config, logfile):
from pycopia import asyncio
pm = proctools.get_procmanager()
libexec = config.get("LIBEXEC", "/usr/libexec/pycopia")
for name, serverlist in list(config.VHOSTS.items()):
for servername in serverlist:
logging.info("Starting {} for vhost {}.".format(servername, name))
cmd = "{}/scgi_server -n {}".format(libexec, servername)
p = pm.spawnprocess(
ServerProcess, cmd, persistent=True, logfile=logfile)
asyncio.poller.register(p)
if config.USEFRONTEND:
if asyncio.poller:
pm.spawnpipe("{} -D -f {}".format(LIGHTTPD, LTCONFIG),
persistent=True, logfile=logfile)
else: # no servers, just run frontend alone
pm.spawnpipe("{} -f {}".format(LIGHTTPD, LTCONFIG))
try:
asyncio.poller.loop()
logging.info("No servers, exited loop.")
except KeyboardInterrupt:
pass
if asyncio.poller:
asyncio.poller.unregister_all()
for proc in pm.getprocs():
proc.killwait()
if os.path.exists(config.PIDFILE):
os.unlink(config.PIDFILE)
def run_as(self, cmd, user, password=None):
#cmd = 'su - %s %s' % (user.pw_name, cmd)
UserLog.msg("run_as", cmd, user)
pm = proctools.get_procmanager()
proc = pm.spawnpty(cmd, pwent=user)
out = proc.read()
es = proc.wait()
return es, out
def subprocess(self, _meth, *args, **kwargs):
"""Run a python method asynchronously as a subprocess."""
logging.msg("subprocess", str(_meth))
pm = proctools.get_procmanager()
proc = pm.submethod(_meth, args, kwargs)
proc.callback = self._status_cb
self._status[proc.childpid] = None
return proc.childpid
def subprocess(self, _meth, *args, **kwargs):
"""Run a python method asynchronously as a subprocess."""
logging.msg("subprocess", str(_meth))
pm = proctools.get_procmanager()
proc = pm.submethod(_meth, args, kwargs)
proc.callback = self._status_cb
self._status[proc.childpid] = None
return proc.childpid
def run_as(self, cmd, user, password=None):
#cmd = 'su - %s %s' % (user.pw_name, cmd)
UserLog.msg("run_as", cmd, user)
pm = proctools.get_procmanager()
proc = pm.spawnpty(cmd, pwent=user)
out = proc.read()
es = proc.wait()
return es, out
def get_dnsupdate(logfile=None, env=None, callback=None):
pm = proctools.get_procmanager()
proc = pm.spawnprocess(_DNSUpdate,
NSUPDATE,
logfile,
env,
callback,
merge=0)
return proc
def _perform(self, cmd):
pm = proctools.get_procmanager()
proc = pm.spawnpipe(cmd)
out = proc.read()
es = proc.wait()
if es:
return out
else:
raise RouterConfigError((int(es), out))
def _perform(self, cmd):
pm = proctools.get_procmanager()
proc = pm.spawnpipe(cmd)
out = proc.read()
es = proc.wait()
if es:
return out
else:
raise RouterConfigError(int(es), out)
def get_netcat(host, port, callback=None, logfile=None, extraoptions=""):
"""get_netcat(host, port, [prompt], [callback], [logfile], [extraoptions])
Returns a Netcat object (an Expect subclass) attached to a netcat client.
The logfile parameter should be a file-like object (has a 'write' method).
"""
cmd = "%s %s %s %s" %(NETCAT, extraoptions, host, port)
pm = proctools.get_procmanager()
proc = pm.spawnpipe(cmd, callback=callback, logfile=logfile, merge=0)
return proc
def get_netcat(host, port, callback=None, logfile=None, extraoptions=""):
"""get_netcat(host, port, [prompt], [callback], [logfile], [extraoptions])
Returns a Netcat object (an Expect subclass) attached to a netcat client.
The logfile parameter should be a file-like object (has a 'write' method).
"""
cmd = "%s %s %s %s" %(NETCAT, extraoptions, host, port)
pm = proctools.get_procmanager()
proc = pm.spawnpipe(cmd, callback=callback, logfile=logfile, merge=0)
return proc
def pipe(self, cmd, user=None):
"""Run a subprocess, but connect by pipes rather than pty."""
logging.msg("pipe", cmd, "user=", str(user))
pm = proctools.get_procmanager()
if type(user) is str:
user = passwd.getpwnam(user)
proc = pm.spawnpipe(cmd, pwent=user, callback=self._status_cb)
text = proc.read()
sts = proc.wait()
proc.close()
return sts, text
def pipe(self, cmd, user=None):
"""Run a subprocess, but connect by pipes rather than pty."""
logging.msg("pipe", cmd, "user=", str(user))
pm = proctools.get_procmanager()
if type(user) is str:
user = passwd.getpwnam(user)
proc = pm.spawnpipe(cmd, pwent=user, callback=self._status_cb)
text = proc.read()
sts = proc.wait()
proc.close()
return sts, text
def check(config):
"Check the lighttpd configuration."
from pycopia import proctools
pm = proctools.get_procmanager()
lighttpd = proctools.which("lighttpd")
proc = pm.spawnpipe("%s -p -f %s" % (lighttpd, LTCONFIG))
out = proc.read()
es = proc.wait()
if es:
print out
else:
print "Error: %s" % (es, )
def _DreamUpdate(self, filename, wipe, flash):
cmd = "fastboot %s update %s" % (
aid.IF(wipe, "-w", ""),
filename,
)
pm = proctools.get_procmanager()
proc = pm.spawnpipe(cmd)
output = proc.read()
errors = proc.readerr()
proc.close()
status = proc.wait()
return status, output, errors
def get_pinger(retries=3, timeout=5, delay=0, size=64, hops=30, logfile=None):
"""Returns a Pinger process that you can call various ICMP methods
on."""
pm = proctools.get_procmanager()
pinger = pm.spawnprocess(Pinger, "pyntping -b", logfile=logfile, env=None, callback=None,
persistent=False, merge=True, pwent=None, async=False, devnull=False)
pinger.retries = retries
pinger.timeout = timeout
pinger.delay = delay
pinger.size = size
pinger.hops = hops
return pinger
def check(config):
"Check the lighttpd configuration."
from pycopia import proctools
pm = proctools.get_procmanager()
lighttpd = proctools.which("lighttpd")
proc = pm.spawnpipe("%s -p -f %s" % (lighttpd, LTCONFIG))
out = proc.read()
es = proc.wait()
if es:
print out
else:
print "Error: %s" % (es,)
def AdbCommand(cmd, logfile=None):
"""Run device agnostic adb command.
Used to run commans that control the adb server.
"""
pm = proctools.get_procmanager()
proc = pm.spawnpipe("%s %s" % (ADB, cmd), logfile=logfile, merge=0)
output = proc.read()
errors = proc.readerr()
proc.close()
status = proc.wait()
return status, output, errors
def get_pinger(retries=3, timeout=5, delay=0, size=64, hops=30, logfile=None):
"""Returns a Pinger process that you can call various ICMP methods
on."""
pm = proctools.get_procmanager()
pinger = pm.spawnprocess(Pinger, "pyntping -b", logfile=logfile, env=None, callback=None,
persistent=False, merge=True, pwent=None, async=False, devnull=False)
pinger.retries = retries
pinger.timeout = timeout
pinger.delay = delay
pinger.size = size
pinger.hops = hops
return pinger
def run(self, cmd, user=None):
"""Run a subprocess, wait for completion and return status and
stdout as text.
"""
logging.msg("run", cmd, "user=", str(user))
pm = proctools.get_procmanager()
if type(user) is str:
user = passwd.getpwnam(user)
proc = pm.spawnpty(cmd, pwent=user)
text = proc.read()
sts = proc.wait()
proc.close()
return sts, text
def run(self, cmd, user=None):
"""Run a subprocess, wait for completion and return status and
stdout as text.
"""
logging.msg("run", cmd, "user=", str(user))
pm = proctools.get_procmanager()
if type(user) is str:
user = passwd.getpwnam(user)
proc = pm.spawnpty(cmd, pwent=user)
text = proc.read()
sts = proc.wait()
proc.close()
return sts, text
def waitpid(self, pid):
pm = proctools.get_procmanager()
while True:
rv = self.poll(pid)
if rv == -errno.ENOENT:
return None
if rv == -errno.EAGAIN:
pm.waitpid(pid)
es = self.poll(pid)
del self._status[pid]
return es
else: # already exited
es = self.poll(pid)
del self._status[pid]
return es
def waitpid(self, pid):
pm = proctools.get_procmanager()
while True:
rv = self.poll(pid)
if rv == -errno.ENOENT:
return None
if rv == -errno.EAGAIN:
pm.waitpid(pid)
es = self.poll(pid)
del self._status[pid]
return es
else: # already exited
es = self.poll(pid)
del self._status[pid]
return es
def kill(self, pid):
"""Kills a process that was started by run_async."""
try:
sts = self._status.pop(pid)
except KeyError:
return errno.ENOENT
else:
if sts is None: # a running process
pm = proctools.get_procmanager()
proc = pm.getbypid(pid)
proc.kill()
proc.wait()
sts = self.poll(pid)
return sts
else: # already exited
return sts
def kill(self, pid):
"""Kills a process that was started by run_async."""
try:
sts = self._status.pop(pid)
except KeyError:
return errno.ENOENT
else:
if sts is None: # a running process
pm = proctools.get_procmanager()
proc = pm.getbypid(pid)
proc.kill()
proc.wait()
sts = self.poll(pid)
return sts
else: # already exited
return sts
def check(config):
"Check the lighttpd configuration."
pm = proctools.get_procmanager()
cmd = "{} -p -f {}".format(LIGHTTPD, LTCONFIG)
print("Running:", cmd)
proc = pm.spawnpipe(cmd)
out = proc.read()
es = proc.wait()
if es:
sys.stdout.buffer.write(out)
else:
from pycopia.WWW import serverconfig
print("ERROR: {}".format(es))
sys.stdout.buffer.write(out)
print("config_server output:")
serverconfig.config_lighttpd(["config_lighttpd"], sys.stdout)
def ssh_command(host, command, user=None, password=None, prompt=None, logfile=None):
"""Runs the command on the given host via SSH, and return the result.
"""
pm = proctools.get_procmanager()
if user is None:
cmd = "{} {} {}".format(SSH, host, command)
else:
cmd = "{} {}@{} {}".format(SSH, user, host, command)
sshproc = pm.spawnpty(cmd)
ssh = SSHExpect(sshproc)
sshproc.set_callback(ssh.death_callback)
ssh.set_prompt(prompt or "$")
ssh.setlog(logfile)
if password is not None:
ssh.login(password)
rv = ssh.read()
return rv
def ssh_command(host,
command,
user=None,
password=None,
prompt=None,
logfile=None):
"""Runs the command on the given host via SSH, and return the result.
"""
pm = proctools.get_procmanager()
if user is None:
cmd = "{} {} {}".format(SSH, host, command)
else:
cmd = "{} {}@{} {}".format(SSH, user, host, command)
sshproc = pm.spawnpty(cmd)
ssh = SSHExpect(sshproc)
sshproc.set_callback(ssh.death_callback)
ssh.set_prompt(prompt or "$")
ssh.setlog(logfile)
if password is not None:
ssh.login(password)
rv = ssh.read()
return rv
ssh.set_prompt(prompt or "$")
ssh.setlog(logfile)
if password is not None:
ssh.login(password)
rv = ssh.read()
return rv
def get_ssh(host, user=None, password=None, prompt=None, callback=None, logfile=None, extraoptions="",
cmd=None, async=False):
"""get_ssh(host, [user], [password], [prompt], [callback], [logfile])
Uses ssh to get a shell on the given host, and automatically authenticate by
password if a password is given. Returns an SSHExpect object.
The logfile parameter should be a file-like object (has a 'write' method).
"""
pm = proctools.get_procmanager()
hostuser = "******" % (user, host) if user else host
command = "%s %s %s %s %s" % (SSH, SSH_OPTIONS, extraoptions, hostuser, cmd or "")
sshproc = pm.spawnpty(command, logfile=logfile, async=async)
ssh = SSHExpect(sshproc)
sshproc.set_callback(callback or ssh.death_callback)
ssh.set_prompt(prompt or "$")
if password is not None:
ssh.login(password)
return ssh
def get_ssh_unsafe(host, *args, **kwargs):
"""get_ssh_unsafe(host, ...)
Like get_ssh(), but automatically removes any stale known_hosts entry, if
required."""
try:
def _get_process(self, pid):
pm = proctools.get_procmanager()
return pm.getbypid(pid)
def netcat_server(port, callback=None, logfile=None, extraoptions=""):
extraoptions += " -l -p %d" % (port)
cmd = "%s %s" %(NETCAT, extraoptions)
pm = proctools.get_procmanager()
proc = pm.spawnpipe(cmd, callback=callback, logfile=logfile, merge=0)
return proc
def __init__(self, pwent=None):
from pycopia import proctools
self._procmanager = proctools.get_procmanager()
self.pwent = pwent
def _get_process(self, pid):
pm = proctools.get_procmanager()
return pm.getbypid(pid)
def get_ssh(host,
user=None,
password=None,
prompt=None,
callback=None,
logfile=None,
extraoptions="",
cmd=None,
async=False):
"""get_ssh(host, [user], [password], [prompt], [callback], [logfile])
Uses ssh to get a shell on the given host, and automatically authenticate by
password if a password is given. Returns an SSHExpect object.
The logfile parameter should be a file-like object (has a 'write' method).
"""
pm = proctools.get_procmanager()
hostuser = "******" % (user, host) if user else host
command = "%s %s %s %s %s" % (SSH, SSH_OPTIONS, extraoptions, hostuser, cmd
or "")
sshproc = pm.spawnpty(command, logfile=logfile, async=async)
ssh = SSHExpect(sshproc)
sshproc.set_callback(callback or ssh.death_callback)
ssh.set_prompt(prompt or "$")
if password is not None:
ssh.login(password)
return ssh
def get_ssh_unsafe(host, *args, **kwargs):
"""get_ssh_unsafe(host, ...)
Like get_ssh(), but automatically removes any stale known_hosts entry, if
def __init__(self):
from pycopia import proctools
self._procmanager = proctools.get_procmanager()
def killall():
pm = proctools.get_procmanager()
for proc in pm.getbyname(NETCAT):
proc.kill()
def __init__(self, pwent=None):
from pycopia import proctools
self._procmanager = proctools.get_procmanager()
self._pwent = pwent
def __init__(self, pwent=None):
self._procmanager = proctools.get_procmanager()
self._pwent = pwent
def subprocess(self, meth, *args, **kwargs):
UserLog.msg("subprocess", str(meth))
pm = proctools.get_procmanager()
proc = pm.subprocess(meth, *args, **kwargs)
self._status[proc.childpid] = proc
return proc.childpid
class PosixAgent(object):
def __init__(self):
self._files = {}
self._status = {} # holds async process pids
self._dirstack = []
def platform(self):
return sys.platform
def whatami(self):
"""Return agent implementation (class name)."""
return self.__class__.__name__
# Since file objects are not pickle-able, a handle is returned. Use the
# handle for subsequent file operations on f* methods.
def fopen(self, fname, mode="r", bufsize=-1):
"Opens a file object and returns a handle to it."
fo = PosixFile(fname, mode, bufsize)
handle = fo.fileno()
self._files[handle] = fo
return handle
def fclose(self, handle):
"Closes a file object given the handle."
fo = self._files.get(handle, None)
if fo:
fo.close()
del self._files[handle]
def fread(self, handle, amt=-1):
"Reads from the file object given the handle and amount to read."
fo = self._files.get(handle, None)
if fo:
return fo.read(amt)
else:
return ''
def fwrite(self, handle, data):
"Writes to a file object given the handle."
fo = self._files.get(handle, None)
if fo:
return fo.write(data)
def fsync(self, handle):
"fsync the file object."
fo = self._files.get(handle, None)
if fo:
fo.flush()
return os.fsync(fo.fileno())
def fseek(self, handle, pos, how=0):
"Seek in the file object."
fo = self._files.get(handle, None)
if fo:
return fo.seek(pos, how)
def ftell(self, handle):
"Tell where the seek pointer is in the file object."
fo = self._files.get(handle, None)
if fo:
return fo.tell()
def fflush(self, handle):
"""Flush the file object buffer."""
fo = self._files.get(handle, None)
if fo:
return fo.flush()
def fileno(self, handle):
"Return the file objects file descriptor."
fo = self._files.get(handle, None)
if fo:
return fo.fileno()
def flock(self, handle, length=0, start=0, whence=0, nonblocking=False):
"""Lock the file with the given range."""
fo = self._files.get(handle, None)
if fo:
return fo.lock_exclusive(length, start, whence, nonblocking)
def funlock(self, handle, length, start=0, whence=0):
fo = self._files.get(handle, None)
if fo:
fo.unlock(length, start, whence)
def fstat(self, handle):
fo = self._files.get(handle, None)
if fo:
return os.fstat(fo.fileno())
def fstatvfs(self, handle):
fo = self._files.get(handle, None)
if fo:
return os.fstatvfs(fo.fileno())
def ftruncate(self, handle, length):
fo = self._files.get(handle, None)
if fo:
return os.ftruncate(fo.fileno(), length)
def flist(self):
return self._files.keys()
def get_handle_info(self, handle):
fo = self._files.get(handle, None)
if fo:
return repr(fo) # XXX
else:
return None
def unlink(self, path):
"Unlink (delete) the given file."
return os.unlink(path)
def rename(self, src, dst):
"Rename file from src to dst."
return os.rename(src, dst)
# directory methods
def mkdir(self, path, mode=0777):
"Make a directory."
return os.mkdir(path, mode)
def makedirs(self, path, mode=0777):
"Make a full path."
return os.makedirs(path, mode)
def chdir(self, path):
return os.chdir(path)
def rmdir(self, path):
"Delete a directory."
return os.rmdir(path)
def getcwd(self):
return os.getcwd()
def getcwdu(self):
return os.getcwdu()
def pushd(self, path=None):
self._dirstack.append(os.getcwd())
if path:
os.chdir(path)
def popd(self):
try:
path = self._dirstack.pop()
except IndexError:
return None
else:
os.chdir(path)
return path
def get_pwent(self, name=None, uid=None):
if uid is not None:
return passwd.getpwuid(int(uid))
return passwd.getpwnam(name)
def listdir(self, path):
return os.listdir(path)
def listfiles(self, path):
isfile = os.path.isfile
pjoin = os.path.join
rv = []
for fname in os.listdir(path):
if isfile(pjoin(path, fname)):
rv.append(fname)
return rv
def chmod(self, path, mode):
return os.chmod(path, mode)
def chown(self, path, uid, gid):
return os.chown(path, uid, gid)
def stat(self, path):
return os.stat(path)
def statvfs(self, path):
return os.statvfs(path)
# fd ops ruturn the file descript as handle (of course)
def open(self, fname, flags, mode=0777):
fd = os.open(fname, mode)
return fd
def close(self, fd):
return os.close(fd)
def write(self, fd, data):
return os.write(fd, data)
def read(self, fd, n):
return os.read(fd, n)
# end fd ops
# shutil interface
def copyfile(self, src, dst):
return shutil.copyfile(src, dst)
def copymode(self, src, dst):
return shutil.copymode(src, dst)
def copystat(self, src, dst):
return shutil.copystat(src, dst)
def copy(self, src, dst):
return shutil.copy(src, dst)
def copy2(self, src, dst):
return shutil.copy2(src, dst)
def copytree(self, src, dst, symlinks=False):
return shutil.copytree(src, dst, symlinks)
def move(self, src, dst):
return shutil.move(src, dst)
def rmtree(self, path):
self._rmtree_errors = []
shutil.rmtree(path, ignore_errors=True, onerror=self._rmtree_error_cb)
return self._rmtree_errors
def _rmtree_error_cb(self, func, arg, exc):
self._rmtree_errors.append((str(arg), str(exc[1])))
# os.path delegates
def exists(self, path):
return os.path.exists(path)
def isabs(self, path):
return os.path.isabs(path)
def isdir(self, path):
return os.path.isdir(path)
def isfile(self, path):
return os.path.isfile(path)
def islink(self, path):
return os.path.islink(path)
def ismount(self, path):
return os.path.ismount(path)
def system(self, cmd):
return proctools.system("%s >/dev/null 2>&1" % cmd)
def run(self, cmd, user=None):
"""Run a subprocess, wait for completion and return status and
stdout as text.
"""
logging.msg("run", cmd, "user="******"""Run a subprocess, but connect by pipes rather than pty."""
logging.msg("pipe", cmd, "user="******"""Spawn a subprocess and return immediatly."""
pm = proctools.get_procmanager()
if type(user) is str:
user = passwd.getpwnam(user)
proc = pm.spawnpty(cmd,
callback=self._status_cb,
pwent=user,
async=async)
def get_procs():
"""get_ssh_list() Returns list of managed ssh processes."""
pm = proctools.get_procmanager()
return pm.getbyname("ssh")
def get_procs():
"""get_ssh_list() Returns list of managed ssh processes."""
pm = proctools.get_procmanager()
return pm.getbyname("ssh")
def __init__(self, pwent=None):
self._procmanager = proctools.get_procmanager()
self._pwent = pwent
