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 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 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 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 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 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 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
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_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")