Viewing file:  supervisorctl.py (20.99 KB) -rw-r--r--
Select action/file-type:
 (+) |  (+) |  (+) | Code (+) | Session (+) |  (+) | SDB (+) |  (+) |  (+) |  (+) |  (+) |  (+) |
##############################################################################
#
# Copyright (c) 2001, 2002 Zope Corporation and Contributors.
# All Rights Reserved.
#
# This software is subject to the provisions of the Zope Public License,
# Version 2.0 (ZPL). A copy of the ZPL should accompany this distribution.
# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
# FOR A PARTICULAR PURPOSE.
#
##############################################################################
"""supervisorctl -- control applications run by supervisord from the cmd line.
Usage: python supervisorctl.py [-C URL] [-h] [action [arguments]]
Options:
-c/--configuration URL -- configuration file or URL
-h/--help -- print usage message and exit
-i/--interactive -- start an interactive shell after executing commands
-s/--serverurl URL -- URL on which supervisord server is listening
(default "http://localhost:9001").
-u/--username -- username to use for authentication with server
-p/--password -- password to use for authentication with server
action [arguments] -- see below
Actions are commands like "tail" or "stop". If -i is specified or no action is
specified on the command line, a"shell" interpreting actions typed
interactively is started. Use the action "help" to find out about available
actions.
"""
import os
import cmd
import sys
import time
import getpass
import xmlrpclib
import urllib2
import fcntl
import socket
import asyncore
import errno
import time
import datetime
import urlparse
from options import ClientOptions
from supervisord import ProcessStates
from supervisord import getProcessStateDescription
import xmlrpc
class Controller(cmd.Cmd):
def __init__(self, options, completekey='tab', stdin=None, stdout=None):
self.options = options
self.prompt = self.options.prompt + '> '
cmd.Cmd.__init__(self, completekey, stdin, stdout)
def emptyline(self):
# We don't want a blank line to repeat the last command.
return
def onecmd(self, line):
""" Override the onecmd method to catch and print all exceptions
"""
origline = line
cmd, arg, line = self.parseline(line)
if not line:
return self.emptyline()
if cmd is None:
return self.default(line)
self.lastcmd = line
if cmd == '':
return self.default(line)
else:
try:
func = getattr(self, 'do_' + cmd)
except AttributeError:
return self.default(line)
try:
try:
return func(arg)
except xmlrpclib.ProtocolError, e:
if e.errcode == 401:
if self.options.interactive:
self._output('Server requires authentication')
username = raw_input('Username:')
password = getpass.getpass(prompt='Password:')
self._output('')
self.options.username = username
self.options.password = password
return self.onecmd(origline)
else:
self.options.usage('Server requires authentication')
else:
raise
except SystemExit:
raise
except Exception, e:
(file, fun, line), t, v, tbinfo = asyncore.compact_traceback()
error = 'error: %s, %s: file: %s line: %s' % (t, v, file, line)
self._output(error)
def _output(self, stuff):
if stuff is not None:
self.stdout.write(stuff + '\n')
def _makeNamespace(self, namespace):
proxy = self.options.getServerProxy()
namespace = getattr(proxy, namespace)
return namespace
def _get_supervisor(self):
supervisor = self._makeNamespace('supervisor')
return supervisor
def _upcheck(self):
try:
supervisor = self._get_supervisor()
supervisor.getVersion()
except socket.error, why:
if why[0] == errno.ECONNREFUSED:
self._output('%s refused connection' % self.options.serverurl)
return False
raise
return True
def help_help(self):
self._output("help\t\tPrint a list of available actions.")
self._output("help <action>\tPrint help for <action>.")
def do_EOF(self, arg):
self._output('')
return 1
def help_EOF(self):
self._output("To quit, type ^D or use the quit command.")
def _tailf(self, path):
if not self._upcheck():
return
self._output('==> Press Ctrl-C to exit <==')
username = self.options.username
password = self.options.password
try:
# Python's urllib2 (at least as of Python 2.4.2) isn't up
# to this task; it doesn't actually implement a proper
# HTTP/1.1 client that deals with chunked responses (it
# always sends a Connection: close header). We use a
# homegrown client based on asyncore instead. This makes
# me sad.
import http_client
listener = http_client.Listener()
handler = http_client.HTTPHandler(listener, username, password)
handler.get(self.options.serverurl, path)
asyncore.loop()
except KeyboardInterrupt:
handler.close()
self._output('')
return
def do_tail(self, arg):
if not self._upcheck():
return
args = arg.strip().split()
if len(args) < 1:
self._output('Error: too few arguments')
self.help_tail()
return
elif len(args) > 2:
self._output('Error: too many arguments')
self.help_tail()
return
elif len(args) == 2:
if args[0].startswith('-'):
what = args[0][1:]
if what == 'f':
path = '/logtail/' + args[1]
return self._tailf(path)
try:
what = int(what)
except:
self._output('Error: bad argument %s' % args[0])
return
else:
bytes = what
else:
self._output('Error: bad argument %s' % args[0])
else:
bytes = 1600
processname = args[-1]
supervisor = self._get_supervisor()
try:
output = supervisor.readProcessLog(processname, -bytes, 0)
except xmlrpclib.Fault, e:
template = '%s: ERROR (%s)'
if e.faultCode == xmlrpc.Faults.NO_FILE:
self._output(template % (processname, 'no log file'))
elif e.faultCode == xmlrpc.Faults.FAILED:
self._output(template % (processname,
'unknown error reading log'))
elif e.faultCode == xmlrpc.Faults.BAD_NAME:
self._output(template % (processname, 'no such process name'))
else:
self._output(output)
def help_tail(self):
self._output(
"tail -f <processname>\tContinuous tail of named process stdout,\n"
"\t\t\tCtrl-C to exit.\n"
"tail -100 <processname>\tlast 100 *bytes* of process log file\n"
"tail <processname>\tlast 1600 *bytes* of process log file\n"
)
def do_maintail(self, arg):
if not self._upcheck():
return
args = arg.strip().split()
if len(args) > 1:
self._output('Error: too many arguments')
self.help_maintail()
return
elif len(args) == 1:
if args[0].startswith('-'):
what = args[0][1:]
if what == 'f':
path = '/mainlogtail'
return self._tailf(path)
try:
what = int(what)
except:
self._output('Error: bad argument %s' % args[0])
return
else:
bytes = what
else:
self._output('Error: bad argument %s' % args[0])
else:
bytes = 1600
supervisor = self._get_supervisor()
try:
output = supervisor.readLog(-bytes, 0)
except xmlrpclib.Fault, e:
template = '%s: ERROR (%s)'
if e.faultCode == xmlrpc.Faults.NO_FILE:
self._output(template % (processname, 'no log file'))
elif e.faultCode == xmlrpc.Faults.FAILED:
self._output(template % (processname,
'unknown error reading log'))
else:
self._output(output)
def help_maintail(self):
self._output(
"maintail -f \tContinuous tail of supervisor main log file,\n"
"\t\t\tCtrl-C to exit.\n"
"maintail -100\tlast 100 *bytes* of supervisord main log file\n"
"maintail\tlast 1600 *bytes* of supervisor main log file\n"
)
def do_quit(self, arg):
sys.exit(0)
def help_quit(self):
self._output("quit\tExit the supervisor shell.")
do_exit = do_quit
def help_exit(self):
self._output("exit\tExit the supervisor shell.")
def do_status(self, arg):
if not self._upcheck():
return
supervisor = self._get_supervisor()
template = '%(name)-14s %(state)-10s %(desc)s'
processnames = arg.strip().split()
if processnames:
for processname in processnames:
try:
info = supervisor.getProcessInfo(processname)
except xmlrpclib.Fault, e:
if e.faultCode == xmlrpc.Faults.BAD_NAME:
self._output('No such process %s' % processname)
else:
raise
continue
newinfo = {'name':info['name'], 'state':info['statename'],
'desc':info['description']}
self._output(template % newinfo)
else:
for info in supervisor.getAllProcessInfo():
newinfo = {'name':info['name'], 'state':info['statename'],
'desc':info['description']}
self._output(template % newinfo)
def help_status(self):
self._output("status\t\t\tGet all process status info.")
self._output("status <name>\t\tGet status on a single process by name.")
self._output("status <name> <name>\tGet status on multiple named "
"processes.")
def _startresult(self, code, processname, default=None):
template = '%s: ERROR (%s)'
if code == xmlrpc.Faults.BAD_NAME:
return template % (processname,'no such process')
elif code == xmlrpc.Faults.ALREADY_STARTED:
return template % (processname,'already started')
elif code == xmlrpc.Faults.SPAWN_ERROR:
return template % (processname, 'spawn error')
elif code == xmlrpc.Faults.ABNORMAL_TERMINATION:
return template % (processname, 'abnormal termination')
elif code == xmlrpc.Faults.SUCCESS:
return '%s: started' % processname
return default
def do_start(self, arg):
if not self._upcheck():
return
processnames = arg.strip().split()
supervisor = self._get_supervisor()
if not processnames:
self._output("Error: start requires a process name")
self.help_start()
return
if 'all' in processnames:
results = supervisor.startAllProcesses()
for result in results:
name = result['name']
code = result['status']
result = self._startresult(code, name)
if result is None:
# assertion
raise ValueError('Unknown result code %s for %s' %
(code, name))
else:
self._output(result)
else:
for processname in processnames:
try:
result = supervisor.startProcess(processname)
except xmlrpclib.Fault, e:
error = self._startresult(e.faultCode, processname)
if error is not None:
self._output(error)
else:
raise
else:
if result == True:
self._output('%s: started' % processname)
else:
raise # assertion
def help_start(self):
self._output("start <processname>\t\t\tStart a process.")
self._output("start <processname> <processname>\tStart multiple "
"processes")
self._output("start all\t\t\t\tStart all processes")
self._output(" When all processes are started, they are started "
"in")
self._output(" priority order (see config file)")
def _stopresult(self, code, processname, fault_string=None):
template = '%s: ERROR (%s)'
if code == xmlrpc.Faults.BAD_NAME:
return template % (processname, 'no such process')
elif code == xmlrpc.Faults.NOT_RUNNING:
return template % (processname, 'not running')
elif code == xmlrpc.Faults.SUCCESS:
return '%s: stopped' % processname
elif code == xmlrpc.Faults.FAILED:
return fault_string
return None
def do_stop(self, arg):
if not self._upcheck():
return
processnames = arg.strip().split()
supervisor = self._get_supervisor()
if not processnames:
self._output('Error: stop requires a process name')
self.help_stop()
return
if 'all' in processnames:
results = supervisor.stopAllProcesses()
for result in results:
name = result['name']
code = result['status']
fault_string = result['description']
result = self._stopresult(code, name, fault_string)
if result is None:
# assertion
raise ValueError('Unknown result code %s for %s' %
(code, name))
else:
self._output(result)
else:
for processname in processnames:
try:
result = supervisor.stopProcess(processname)
except xmlrpclib.Fault, e:
error = self._stopresult(e.faultCode, processname,
e.faultString)
if error is not None:
self._output(error)
else:
raise
else:
if result == True:
self._output('%s: stopped' % processname)
else:
raise # assertion
def help_stop(self):
self._output("stop <processname>\t\t\tStop a process.")
self._output("stop <processname> <processname>\tStop multiple "
"processes")
self._output("stop all\t\t\t\tStop all processes")
self._output(" When all processes are stopped, they are stopped "
"in")
self._output(" reverse priority order (see config file)")
def do_restart(self, arg):
if not self._upcheck():
return
processnames = arg.strip().split()
if not processnames:
self._output('Error: restart requires a process name')
self.help_restart()
return
self.do_stop(arg)
self.do_start(arg)
def help_restart(self):
self._output("restart <processname>\t\t\tRestart a process.")
self._output("restart <processname> <processname>\tRestart multiple "
"processes")
self._output("restart all\t\t\t\tRestart all processes")
self._output(" When all processes are restarted, they are "
"started in")
self._output(" priority order (see config file)")
def do_shutdown(self, arg):
if self.options.interactive:
yesno = raw_input('Really shut the remote supervisord process '
'down y/N? ')
really = yesno.lower().startswith('y')
else:
really = 1
if really:
supervisor = self._get_supervisor()
try:
supervisor.shutdown()
except xmlrpclib.Fault, e:
if e.faultCode == xmlrpc.Faults.SHUTDOWN_STATE:
self._output('ERROR: already shutting down')
else:
self._output('Shut down')
def help_shutdown(self):
self._output("shutdown \t\tShut the remote supervisord down.")
def do_reload(self, arg):
if self.options.interactive:
yesno = raw_input('Really restart the remote supervisord process '
'y/N? ')
really = yesno.lower().startswith('y')
else:
really = 1
if really:
supervisor = self._get_supervisor()
try:
supervisor.restart()
except xmlrpclib.Fault, e:
if e.faultCode == xmlrpc.Faults.SHUTDOWN_STATE:
self._output('ERROR: already shutting down')
else:
self._output('Restarted supervisord')
def help_reload(self):
self._output("reload \t\tRestart the remote supervisord.")
def _clearresult(self, code, processname, default=None):
template = '%s: ERROR (%s)'
if code == xmlrpc.Faults.BAD_NAME:
return template % (processname, 'no such process')
elif code == xmlrpc.Faults.FAILED:
return template % (processname, 'failed')
elif code == xmlrpc.Faults.SUCCESS:
return '%s: cleared' % processname
return default
def do_clear(self, arg):
if not self._upcheck():
return
processnames = arg.strip().split()
if not processnames:
self._output('Error: clear requires a process name')
self.help_clear()
return
supervisor = self._get_supervisor()
if 'all' in processnames:
results = supervisor.clearAllProcessLogs()
for result in results:
name = result['name']
code = result['status']
result = self._clearresult(code, name)
if result is None:
# assertion
raise ValueError('Unknown result code %s for %s' %
(code, name))
else:
self._output(result)
else:
for processname in processnames:
try:
result = supervisor.clearProcessLog(processname)
except xmlrpclib.Fault, e:
error = self._clearresult(e.faultCode, processname)
if error is not None:
self._output(error)
else:
raise
else:
if result == True:
self._output('%s: cleared' % processname)
else:
raise # assertion
def help_clear(self):
self._output("clear <processname>\t\t\tClear a process' log file.")
self._output("clear <processname> <processname>\tclear multiple "
"process log files")
self._output("clear all\t\t\t\tClear all process log files")
def do_open(self, arg):
url = arg.strip()
parts = urlparse.urlparse(url)
if parts[0] not in ('unix', 'http'):
self._output('ERROR: url must be http:// or unix://')
return
self.options.serverurl = url
self.do_status('')
def help_open(self):
self._output("open <url>\t\t\tConnect to a remote supervisord process.")
self._output("\t\t\t(for UNIX domain socket, use unix:///socket/path)")
def main(args=None, options=None):
if options is None:
options = ClientOptions()
options.realize(args)
c = Controller(options)
if options.args:
c.onecmd(" ".join(options.args))
if options.interactive:
try:
import readline
except ImportError:
pass
try:
c.onecmd('status')
c.cmdloop()
except KeyboardInterrupt:
c._output('')
pass
if __name__ == "__main__":
main()
|