def __init__(self): 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 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 __init__(self): import proctools pm = proctools.get_procmanager() proc = pm.spawnpty("vttest") self.term = get_ansiterm(proc, 24, 80, ReprPrinter(sys.stdout)) self.logfile = file("/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 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_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_pinger(retries=3, timeout=5, delay=0, size=64, hops=30, logfile=None): 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 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 ssh_command(host, command, user=None, password=None, prompt=None, logfile=None): """ssh_command(host, command, [user], [password], [prompt], [logfile]) Runs the command on the given host via SSH, and return the result. """ pm = proctools.get_procmanager() if user is None: cmd = "%s %s %s" %(SSH, host, command) else: cmd = "%s %s@%s %s" %(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 initialize(self): pm = proctools.get_procmanager() proc = pm.spawnpty("cat") self.term = ANSIterm.get_ansiterm(proc, 24, 80, terminal.ReprPrinter(sys.stdout)) self.term.printer.set_file(self.config.logfile)
def death_callback(self, deadcu): if self._log: self._log.write("cu exited: %s" % (deadcu.exitstatus)) self.close() def get_cu(port, speed, user=None, password=None, prompt=None, callback=None, logfile=None, extraoptions="", async=False): pm = proctools.get_procmanager() command = "%s %s %s -l %s -s %s dir" % (CU, CU_OPTIONS, extraoptions, port, speed) cuproc = pm.spawnpty(command, logfile=logfile, async=async) cu = CUExpect(cuproc) cuproc.set_callback(callback or cu.death_callback) cu.set_prompt(prompt or "$") if password is not None: cu.login(user, password) return cu get_expect = get_cu def get_serial(port,
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 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
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 killall(): pm = proctools.get_procmanager() for proc in pm.getbyname(NETCAT): proc.kill()
def get_procs(): """get_ssh_list() Returns list of managed ssh processes.""" pm = proctools.get_procmanager() return pm.getbyname("ssh")
The input is read and interpreted as Python. If a syntax or name error occurs it is assumed to be a shell style command and it is re-parsed and run as a system command. """ import sys, os, sre, readline, glob import debugger import interactive import proctools import shparser sys.ps1 = "pysh$ " PM = proctools.get_procmanager() def shell_hook(type, value, tb): if type in (NameError, SyntaxError): do_shell(value) elif type in (IndentationError,): sys.__excepthook__(type, value, tb) else: print if __debug__: debugger.post_mortem(tb, type, value) else: import traceback traceback.print_exception(type, value, tb) sys.excepthook = shell_hook
def _get_process(self, pid): pm = proctools.get_procmanager() return pm.getbypid(pid)