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