def main(): import argparse import os parser = argparse.ArgumentParser(executable_name, description="Supervisor event listener which restarts processes on TICK events.") parser.add_argument("-p", "--programs", type=str, nargs="*", metavar="PROGRAM", help="Supervisor process name/s to be restarted if in RUNNING state.") parser.add_argument("-a", "--any-program", action="store_true", help="Restart any supervisor processes in RUNNING state.") parser.add_argument("--dither", type=int, metavar="DITHER_MAX", dest="dither_max", help="Add dither before restarting processes. Specify maximum time to dither in seconds.") args = parser.parse_args() if not(args.programs or args.any_program): parser.error("Must specify either -p/--programs or -a/--any-program.") try: rpc = childutils.getRPCInterface(os.environ) except KeyError as e: if e.args[0] == "SUPERVISOR_SERVER_URL": print("{0} must be run as a supervisor event listener.".format(executable_name), file=sys.stderr) sys.exit(1) else: raise listener = ProcessRestarter(rpc, args.programs or [], args.any_program) listener.runforever()
def main(): memmon = memmon_from_args(sys.argv[1:]) if memmon is None: # something went wrong or -h has been given usage() memmon.rpc = childutils.getRPCInterface(os.environ) memmon.runforever()
def main(): import argparse import os import sys parser = argparse.ArgumentParser(executable_name, description="Supervisor event listener which executes a command when " "events are received and optionally restarts processes on non-zero exit status.") parser.add_argument("-e", "--execute", metavar="COMMAND", dest="command", required=True, help="Command or script to execute on supervisor events.") parser.add_argument("-p", "--restart-programs", type=str, nargs="*", metavar="PROGRAM", help="Supervisor process name/s to be restarted on non-zero exit status if in RUNNING state.") parser.add_argument("-a", "--restart-any-program", action="store_true", help="Restart any supervisor processes in RUNNING state on non-zero exit status.") parser.add_argument("--dither", type=int, metavar="DITHER_MAX", dest="dither_max", help="Add dither before restarting processes. Specify maximum time to dither in seconds.") args = parser.parse_args() try: rpc = childutils.getRPCInterface(os.environ) except KeyError as e: if e.args[0] == "SUPERVISOR_SERVER_URL": print("{0} must be run as a supervisor event listener.".format(executable_name), file=sys.stderr) sys.exit(1) else: raise listener = EventExec(rpc, args.restart_programs or [], args.restart_any_program, args.command) listener.runforever()
def start_timemon(group, interval, number, sleep=0): max_serial = 0 while True: rpc = childutils.getRPCInterface(os.environ) hdrs, payload = childutils.listener.wait(sys.stdin, sys.stdout) if int(hdrs['serial']) <= max_serial: continue max_serial = int(hdrs['serial']) process_info = rpc.supervisor.getAllProcessInfo() should_restart = getattr(datetime.datetime.now(), interval) % int(number) if should_restart: for process in process_info: if process['group'] == group and \ should_restart: try: rpc.supervisor.stopProcess(':'.join([process['group'], process['name']]), True) except Exception as e: write_stderr(str(e) + "\n") if sleep: time.sleep(float(sleep)) try: rpc.supervisor.startProcess(':'.join([process['group'], process['name']]), True) except Exception as e: write_stderr(str(e) + "\n") write_stdout("RESULT 2\nOK")
def _restart_process(self, process_spec): """Restart a process. """ name_spec = make_namespec( process_spec[GROUP_KEY], process_spec[NAME_KEY]) rpc_client = childutils.getRPCInterface(self._environment) process_spec = rpc_client.supervisor.getProcessInfo(name_spec) if process_spec[STATE_KEY] is ProcessStates.RUNNING: self._log('Trying to stop process %s', name_spec) try: rpc_client.supervisor.stopProcess(name_spec) self._log('Stopped process %s', name_spec) except xmlrpclib.Fault as exc: self._log('Failed to stop process %s: %s', name_spec, exc) try: self._log('Starting process %s', name_spec) rpc_client.supervisor.startProcess(name_spec, False) except xmlrpclib.Fault as exc: self._log('Failed to start process %s: %s', name_spec, exc) else: self._log('%s not in RUNNING state, cannot restart', name_spec)
def main(): memmon = memmon_from_args(sys.argv[1:]) if memmon is help_request: # --help usage(exitstatus=0) elif memmon is None: # something went wrong usage() memmon.rpc = childutils.getRPCInterface(os.environ) memmon.runforever()
def get_last_lines_of_process_stdout_unwrapped(pheaders, stdout_lines): rpc = childutils.getRPCInterface(os.environ) proc_name = get_proc_name(pheaders) result = get_last_lines( proc_name, rpc.supervisor.tailProcessStdoutLog, rpc.supervisor.readProcessStdoutLog, stdout_lines) return result
def main(): rpcinterface = childutils.getRPCInterface(os.environ) while 1: headers, payload = childutils.listener.wait() if headers['eventname'].startswith('PROCESS_COMMUNICATION'): pheaders, pdata = childutils.eventdata(payload) pname = '%s:%s' % (pheaders['processname'], pheaders['groupname']) rpcinterface.supervisor.sendProcessStdin(pname, 'Got it yo\n') childutils.listener.ok()
def main(): rpcinterface = childutils.getRPCInterface(os.environ) while 1: headers, payload = childutils.listener.wait() if headers["eventname"].startswith("PROCESS_COMMUNICATION"): pheaders, pdata = childutils.eventdata(payload) pname = "%s:%s" % (pheaders["processname"], pheaders["groupname"]) rpcinterface.supervisor.sendProcessStdin(pname, "Got it yo\n") childutils.listener.ok()
def main(): import getopt short_args="hp:g:a:s:m:i:" long_args=[ "help", "program=", "group=", "any=", "sendmail_program=", "email=", "pingport=", ] arguments = sys.argv[1:] if not arguments: usage() try: opts, args=getopt.getopt(arguments, short_args, long_args) except: print __doc__ sys.exit(2) programs = {} groups = {} any = None sendmail = '/usr/sbin/sendmail -t -i' email = None pingport = None for option, value in opts: if option in ('-h', '--help'): usage() if option in ('-p', '--program'): name, size = parse_namesize(option, value) programs[name] = size if option in ('-g', '--group'): name, size = parse_namesize(option, value) groups[name] = size if option in ('-a', '--any'): size = parse_size(option, value) any = size if option in ('-s', '--sendmail_program'): sendmail = value if option in ('-m', '--email'): email = value if option in ('-i', '--pingport'): pingport = value rpc = childutils.getRPCInterface(os.environ) memmon = CustomMemmon(programs, groups, any, sendmail, email, rpc, pingport) memmon.runforever()
def main(cmd, arg): rpcinterface = childutils.getRPCInterface(conf) #while 1: # headers, payload = childutils.listener.wait() # if headers['eventname'].startswith('TICK'): print >>sys.stderr, childutils.get_asctime(), ':', cmd, arg rpcinterface.supervisor.sendRemoteCommEvent(cmd, arg + '\n')
def tail(self, group, process, stream, chars): """Return the last lines from the process stream (stderr or stdout).""" rpc = childutils.getRPCInterface(os.environ) processname = '{group}{process}'.format(group=group + ':' if group else '', process=process) if stream == 'stdout': log, _, _ = rpc.supervisor.tailProcessStdoutLog(processname, 0, chars) else: log, _, _ = rpc.supervisor.tailProcessStderrLog(processname, 0, chars) log = '\n'.join(log.split('\n')[1:]) return log
def main(argv=sys.argv): import getopt short_args="hp:o:n:m:" long_args=[ "help", "program=", "offset=", "num=", "multiple=" ] arguments = argv[1:] try: opts, args = getopt.getopt(arguments, short_args, long_args) except: usage() if not opts: usage() programs = [] offset = 0 num = -1 multiple = 1 for option, value in opts: if option in ('-h', '--help'): usage() if option in ('-p', '--program'): programs.append(value) if option in ('-o', '--offset'): offset = int(value) if option in ('-n', '--num'): if value == "auto": num = -1 else: num = int(value) if option in ('-m', '--multiple'): multiple = int(value) url = arguments[-1] try: rpc = childutils.getRPCInterface(os.environ) except KeyError, why: if why[0] != 'SUPERVISOR_SERVER_URL': raise sys.stderr.write('rubber must be run as a supervisor event ' 'listener\n') sys.stderr.flush() return
def setUp(self): """ The setUp starts the subscriber to the Supvisors events and get the event queues. """ # get the addresses proxy = getRPCInterface(os.environ).supvisors addresses_info = proxy.get_all_addresses_info() self.HOST_01 = addresses_info[0]['address_name'] self.HOST_02 = addresses_info[1]['address_name'] self.HOST_03 = addresses_info[2]['address_name'] self.HOST_04 = addresses_info[3]['address_name'] # create a context self.context = Context() # create the thread of event subscriber self.evloop = SequenceChecker() self.evloop.start()
def main(): import argparse import os import sys parser = argparse.ArgumentParser(executable_name, description="Supervisor TICK event listener which restarts processes " "if file system changes occur between ticks.") parser.add_argument("-p", "--programs", type=str, nargs="*", metavar="PROGRAM", help="Supervisor process name/s to be restarted if in RUNNING state.") parser.add_argument("-a", "--any-program", action="store_true", help="Restart any supervisor processes in RUNNING state.") parser.add_argument("-f", "--paths", type=str, nargs="+", metavar="PATH", required=True, help="Path to watch for file system events.") parser.add_argument("-r", "--recursive", action="store_true", help="Watch path/s recursively.") parser.add_argument("--watched-events", type=str, nargs="*", choices=["moved", "created", "deleted", "modified"], help="Specify which file system events to watch, by default all events will be watched.") parser.add_argument("--dither", type=int, metavar="DITHER_MAX", dest="dither_max", help="Add dither before restarting processes. Specify maximum time to dither in seconds.") args = parser.parse_args() if not(args.programs or args.any_program): parser.error("Must specify either -p/--programs or -a/--any-program.") for path in args.paths: if not(os.path.exists(path)): parser.error("Path {0} does not exits.".format(path)) try: rpc = childutils.getRPCInterface(os.environ) except KeyError as e: if e.args[0] == "SUPERVISOR_SERVER_URL": print("{0} must be run as a supervisor event listener.".format(executable_name), file=sys.stderr) sys.exit(1) else: raise if args.watched_events: fs_event_handler = PollableFileSystemEventHandler( "moved" in args.watched_events, "created" in args.watched_events, "deleted" in args.watched_events, "modified" in args.watched_events) else: fs_event_handler = PollableFileSystemEventHandler(True, True, True, True) listener = FSEventWatcher( rpc, args.programs or [], args.any_program, args.paths, args.recursive, fs_event_handler, args.dither_max) listener.runforever()
def __init__(self, check_name, process_group, checks_config, env=None): """Constructor. :param str check_name: the name of check to display in log. :param str process_group: the name of the process group. :param list checks_config: the list of check module configurations in format [(check_class, check_configuration_dictionary)] :param dict env: environment. """ self._environment = env or os.environ self._name = check_name self._checks_config = checks_config self._checks = self._init_checks() self._process_group = process_group self._group_check_name = '%s_check' % (self._process_group,) self._rpc_client = childutils.getRPCInterface(self._environment) self._stop_event = threading.Event()
def main(argv=sys.argv): import getopt short_args="hp:b:" long_args=[ "help", "program=", "body=", ] arguments = argv[1:] try: opts, args = getopt.getopt(arguments, short_args, long_args) except: usage() if not args: usage() if len(args) > 1: usage() programs = [] inbody = None for option, value in opts: if option in ('-h', '--help'): usage() if option in ('-p', '--program'): programs.append(value) if option in ('-b', '--body'): inbody = value url = arguments[-1] try: rpc = childutils.getRPCInterface(os.environ) except KeyError, why: if why[0] != 'SUPERVISOR_SERVER_URL': raise sys.stderr.write('httpctrl must be run as a supervisor event ' 'listener\n') sys.stderr.flush() return
def setUp(self): """ Check that 3 running addresses are available. """ # get a reference to the local RPC proxy self.local_proxy = childutils.getRPCInterface(os.environ) self.local_supervisor = self.local_proxy.supervisor self.local_supvisors = self.local_proxy.supvisors # check the number of running addresses addresses_info = self.local_supvisors.get_all_addresses_info() self.running_addresses = [info['address_name'] for info in addresses_info if info['statecode'] == AddressStates.RUNNING] self.assertEqual(3, len(self.running_addresses)) # assumption is made that this test is run on Supvisors Master address self.assertEqual(gethostname(), self.local_supvisors.get_master_address()) # keep a reference to all RPC proxies self.proxies = {address: rpcrequests.getRPCInterface(address, os.environ) for address in self.running_addresses} # create the thread of event subscriber self.evloop = SupvisorsEventQueues() # start the thread self.evloop.start()
def test_sequencing(self): """ Test the whole sequencing of the starting of the test application. At this point, Supvisors is in OPERATION phase. This process is the first to be started. """ # store a proxy to perform XML-RPC requests self.proxy = getRPCInterface(os.environ) # wait for address_queue to trigger self.get_addresses() # define the context to know which process is running self.create_context() # start a converter self.proxy.supvisors.start_args('my_movies:converter_05') # empty queues (pull STARTING / RUNNING events) self.check_converter_running() # send restart request self.proxy.supvisors.restart() # test the starting of web_movies application self.check_web_movies_stopping() # test the starting of my_movies application self.check_my_movies_stopping() # test the starting of database application self.check_database_stopping()
def main(): import getopt short_args = "hp:g:" long_args = [ "help", "program=", "group=", ] arguments = sys.argv[1:] if not arguments: usage() try: opts, args = getopt.getopt(arguments, short_args, long_args) except: usage() uptime_per_program = {} uptime_per_group = {} for option, value in opts: if option in ('-h', '--help'): usage() if option in ('-p', '--program'): name, uptime = parse_option(option, value) uptime_per_program[name] = uptime if option in ('-g', '--group'): name, uptime = parse_option(option, value) uptime_per_group[name] = uptime logging.basicConfig( level=logging.INFO, format='%(asctime)s %(levelname)s %(message)s') rpc = childutils.getRPCInterface(os.environ) uptimemon = Uptimemon(uptime_per_program, uptime_per_group, rpc) uptimemon.roundhouse_forever()
def main(): import argparse import os parser = argparse.ArgumentParser("supervisor-event-exec") parser.add_argument("-e", "--execute", metavar="COMMAND", dest="command", required=True, help="Command or script to execute on supervisor events.") parser.add_argument("-p", "--restart-programs", type=str, nargs="*", metavar="PROGRAM", help="Supervisor process name/s to be restarted on non-zero exit status if in RUNNING state.") parser.add_argument("-a", "--restart-any-program", action="store_true", help="Restart any supervisor processes in RUNNING state on non-zero exit status.") args = parser.parse_args() try: rpc = childutils.getRPCInterface(os.environ) except KeyError as e: if e.args[0] == "SUPERVISOR_SERVER_URL": print("supervisor-event-exec must be run as a supervisor event listener.", file=sys.stderr) sys.exit(1) else: raise event_exec = SupervisorEventExec(rpc, args.command, args.restart_programs, args.restart_any_program) event_exec.runforever()
def main(): rpci = getRPCInterface(os.environ) while True: h, p = listener.wait() if not h['eventname'] == 'PROCESS_STATE_EXITED': listener.ok() continue ph, _pd = eventdata(p + '\n') if ph['processname'] == 'mongodb': if int(ph['expected']): listener.ok() continue listener.send("MONGODB HAS BEEN RESTARTED. SO WILL THE APP!") rpci.supervisor.stopProcessGroup('app') rpci.supervisor.startProcessGroup('app', True) listener.ok() now = datetime.now() send_twitter("[FATAL] %s - mongodb has been restarted" % now.isoformat()) return listener.ok()
def main(): import getopt short_args="hp:g:a:s:m:n:u:t" long_args=[ "help", "program=", "group=", "any=", "sendmail_program=", "email=", "uptime=", "name=", ] arguments = sys.argv[1:] if not arguments: usage() try: opts, args=getopt.getopt(arguments, short_args, long_args) except: print __doc__ sys.exit(2) programs = {} groups = {} any = None sendmail = '/usr/sbin/sendmail -t -i' email = None uptime = sys.maxint name = None tree = False for option, value in opts: if option in ('-h', '--help'): usage() if option in ('-p', '--program'): name, size = parse_namesize(option, value) programs[name] = size if option in ('-g', '--group'): name, size = parse_namesize(option, value) groups[name] = size if option in ('-a', '--any'): size = parse_size(option, value) any = size if option in ('-s', '--sendmail_program'): sendmail = value if option in ('-m', '--email'): email = value if option in ('-u', '--uptime'): uptime = parse_seconds(option, value) if option in ('-n', '--name'): name = value if option in ('-t', '--tree'): tree = True rpc = childutils.getRPCInterface(os.environ) memmon = Memmon(programs, groups, any, sendmail, email, name, uptime, rpc, tree) memmon.runforever()
def main(argv=sys.argv): import getopt short_args="hp:at:cC:b:s:m:g:d:eE" long_args=[ "help", "program=", "any", "timeout=", "code=", "not-code=", "body=", "sendmail_program=", "email=", "gcore=", "coredir=", "eager", "not-eager", ] arguments = argv[1:] try: opts, args = getopt.getopt(arguments, short_args, long_args) except: usage() if not args: usage() if len(args) > 1: usage() programs = [] any = False sendmail = '/usr/sbin/sendmail -t -i' gcore = '/usr/bin/gcore -o' coredir = None eager = True email = None timeout = 10 status = '200' nstatus = '' inbody = None for option, value in opts: if option in ('-h', '--help'): usage() if option in ('-p', '--program'): programs.append(value) if option in ('-a', '--any'): any = True if option in ('-s', '--sendmail_program'): sendmail = value if option in ('-m', '--email'): email = value if option in ('-t', '--timeout'): timeout = int(value) if option in ('-c', '--code'): status = value if option in ('-C', '--not-code'): nstatus = value status = '' if option in ('-b', '--body'): inbody = value if option in ('-g', '--gcore'): gcore = value if option in ('-d', '--coredir'): coredir = value if option in ('-e', '--eager'): eager = True if option in ('-E', '--not-eager'): eager = False url = arguments[-1] try: rpc = childutils.getRPCInterface(os.environ) except KeyError, why: if why[0] != 'SUPERVISOR_SERVER_URL': raise sys.stderr.write('httpok must be run as a supervisor event ' 'listener\n') sys.stderr.flush() return
def test_getRPCInterface(self): from supervisor.childutils import getRPCInterface rpc = getRPCInterface({'SUPERVISOR_SERVER_URL':'http://localhost:9001'})
def main(): import getopt short_args="hp:g:a:s:m:k:c:" long_args=[ "help", "program=", "group=", "any=", "sendmail_program=", "email=", "aws_access_key=", "aws_secret_key=", "env_prefix=" ] arguments = sys.argv[1:] if not arguments: usage() try: opts, args=getopt.getopt(arguments, short_args, long_args) except: print __doc__ sys.exit(2) programs = {} groups = {} any = None sendmail = '/usr/sbin/sendmail -t -i' email = None aws_access_key = None aws_secret_key = None for option, value in opts: if option in ('-h', '--help'): usage() if option in ('-p', '--program'): name, size = parse_namesize(option, value) programs[name] = size if option in ('-g', '--group'): name, size = parse_namesize(option, value) groups[name] = size if option in ('-a', '--any'): size = parse_size(option, value) any = size if option in ('-s', '--sendmail_program'): sendmail = value if option in ('-m', '--email'): email = value if option in ('-k', '--aws_access_key'): aws_access_key = value if option in ('-c', '--aws_secret_key'): aws_secret_key = value log.debug('Starting memmon') log.debug('aws_access_key:%s' % (aws_access_key)) log.debug('aws_secret_key:%s' % (aws_secret_key)) rpc = childutils.getRPCInterface(os.environ) memmon = Memmon(programs, groups, any, sendmail, email, rpc, aws_access_key, aws_secret_key) memmon.runforever()
from StringIO import StringIO config_file = StringIO() config_file.write(default_config) config_file.seek(0) (parser, options, argv) = configglue( config_file, args=sys.argv[1:], usage="%prog [options]", extra_parsers=[("comma_separated_list", comma_separated_list_parser)]) if not options.groups or not options.interval or not options.timeout: parser.print_help() sys.exit(2) # configure the logger try: level = logging._levelNames[options.log_level] except KeyError: # if level doesn't exist fallback to DEBUG level = logging.DEBUG root_logger = logging.getLogger() configure_logger(logger=root_logger, filename=options.log_file, level=level, log_format=options.log_format) rpc = childutils.getRPCInterface(os.environ) hbl = HeartbeatListener(options.timeout, options.interval, options.groups, options.processes, rpc) hbl.runforever()
def test_getRPCInterface(self): from supervisor.childutils import getRPCInterface rpc = getRPCInterface({'SUPERVISOR_SERVER_URL':'http://localhost:9001'}) # we can't really test this thing; its a magic object self.assertTrue(rpc is not None)
config_file.seek(0) (parser, options, argv) = configglue(config_file, args=sys.argv[1:], usage="%prog [options]", extra_parsers=[("comma_separated_list", comma_separated_list_parser)]) if not options.groups or not options.interval or not options.timeout: parser.print_help() sys.exit(2) # configure the logger try: level = logging._levelNames[options.log_level] except KeyError: # if level doesn't exist fallback to DEBUG level = logging.DEBUG root_logger = logging.getLogger() configure_logger(logger=root_logger, filename=options.log_file, level=level, log_format=options.log_format) rpc = childutils.getRPCInterface(os.environ) hbl = HeartbeatListener(options.timeout, options.interval, options.groups, options.processes, rpc) hbl.runforever()
def main(argv=sys.argv): short_args="hp:at:c:b:s:m:g:d:eEn:" long_args=[ "help", "program=", "any", "timeout=", "code=", "body=", "sendmail_program=", "email=", "gcore=", "coredir=", "eager", "not-eager", "name=", ] arguments = argv[1:] try: opts, args = getopt.getopt(arguments, short_args, long_args) except: usage() # check for -h must be done before positional args check for option, value in opts: if option in ('-h', '--help'): usage(exitstatus=0) if not args: usage() if len(args) > 1: usage() programs = [] any = False sendmail = '/usr/sbin/sendmail -t -i' gcore = '/usr/bin/gcore -o' coredir = None eager = True email = None timeout = 10 retry_time = 10 statuses = [] inbody = None name = None for option, value in opts: if option in ('-p', '--program'): programs.append(value) if option in ('-a', '--any'): any = True if option in ('-s', '--sendmail_program'): sendmail = value if option in ('-m', '--email'): email = value if option in ('-t', '--timeout'): timeout = int(value) if option in ('-c', '--code'): statuses.append(int(value)) if option in ('-b', '--body'): inbody = value if option in ('-g', '--gcore'): gcore = value if option in ('-d', '--coredir'): coredir = value if option in ('-e', '--eager'): eager = True if option in ('-E', '--not-eager'): eager = False if option in ('-n', '--name'): name = value if not statuses: statuses = [200] url = arguments[-1] try: rpc = childutils.getRPCInterface(os.environ) except KeyError as e: if e.args[0] != 'SUPERVISOR_SERVER_URL': raise sys.stderr.write('httpok must be run as a supervisor event ' 'listener\n') sys.stderr.flush() return prog = HTTPOk(rpc, programs, any, url, timeout, statuses, inbody, email, sendmail, coredir, gcore, eager, retry_time, name) prog.runforever()
def test_getRPCInterface(self): from supervisor.childutils import getRPCInterface rpc = getRPCInterface( {'SUPERVISOR_SERVER_URL': 'http://localhost:9001'})
def main(): logging.basicConfig(filename='ordered_startup.log', level=logging.DEBUG) log = logging.getLogger('ordered_startup_supervisord.main') try: config_file = None if len(sys.argv) > 1: config_file = sys.argv[1] if config_file is None: config_file = get_default_config_file() if config_file is None: print("Unable to find a config file!", file=sys.stderr) sys.exit(1) if not os.path.exists(config_file): print("Config path {} does not exist!".format(config_file), file=sys.stderr) sys.exit(1) parser = UnhosedConfigParser() parser.read(get_all_configs(config_file)) startup_plan = StartupPlan(parser) rpcinterface = childutils.getRPCInterface(os.environ) # get group for all processes processes = rpcinterface.supervisor.getAllProcessInfo() for proc in processes: # if group and name differ, process is in a group and startProcess needs "group:name" as arg if proc['name'] != proc['group']: for p in startup_plan.programs: if p.name == proc['name']: p.group = proc['group'] p.procname = "{}:{}".format(proc['group'], proc['name']) break log.info("programs in order: ") for prog in startup_plan.programs: log.info(prog.name) if not startup_plan.programs[0].options.autostart: rpcinterface.supervisor.startProcess(startup_plan.programs[0].name, False) initial_start = 'STARTED' while 1: headers, payload = childutils.listener.wait() if headers['eventname'].startswith( 'PROCESS_STATE') and initial_start != 'FINISHED': pheaders = childutils.get_headers(payload) log.debug("headers = {}".format(repr(headers))) log.debug("payload = {}".format(repr(pheaders))) state = headers['eventname'][len('PROCESS_STATE_'):] start_next = False for program in startup_plan.programs: if start_next: log.info("Starting process: {}".format( program.procname)) rpcinterface.supervisor.startProcess(program.procname) start_next = False break if program.options.startinorder and program.name == pheaders[ 'processname'] and program.options.startnextafter == state: if program.options.startnext: log.info( "Recieved process state of {} from {}, starting next process." .format(state, program.name)) start_next = True else: log.info( "Recieved process state of {} from {}, with startnext set to false." .format(state, program.name)) log.info( "No more processes to start for initial startup, ignoring all future events." ) initial_start = 'FINISHED' break else: if start_next: log.info( "No more processes to start for initial startup, ignoring all future events." ) initial_start = 'FINISHED' #log.debug("data = {}".format(repr(pdata))) childutils.listener.ok() except: log.error("ERROR: ", exc_info=sys.exc_info())
def main(argv=sys.argv): import getopt short_args = "hp:at:c:b:s:m:g:d:eE" long_args = [ "help", "program=", "any", "timeout=", "code=", "body=", "sendmail_program=", "email=", "gcore=", "coredir=", "eager", "not-eager", ] arguments = argv[1:] try: opts, args = getopt.getopt(arguments, short_args, long_args) except: usage() if not args: usage() if len(args) > 1: usage() programs = [] any = False sendmail = '/usr/sbin/sendmail -t -i' gcore = '/usr/bin/gcore -o' coredir = None eager = True email = None timeout = 10 retry_time = 10 status = '200' inbody = None for option, value in opts: if option in ('-h', '--help'): usage() if option in ('-p', '--program'): programs.append(value) if option in ('-a', '--any'): any = True if option in ('-s', '--sendmail_program'): sendmail = value if option in ('-m', '--email'): email = value if option in ('-t', '--timeout'): timeout = int(value) if option in ('-c', '--code'): status = value if option in ('-b', '--body'): inbody = value if option in ('-g', '--gcore'): gcore = value if option in ('-d', '--coredir'): coredir = value if option in ('-e', '--eager'): eager = True if option in ('-E', '--not-eager'): eager = False url = arguments[-1] try: rpc = childutils.getRPCInterface(os.environ) except KeyError as e: if e.args[0] != 'SUPERVISOR_SERVER_URL': raise sys.stderr.write('httpok must be run as a supervisor event ' 'listener\n') sys.stderr.flush() return prog = HTTPOk(rpc, programs, any, url, timeout, status, inbody, email, sendmail, coredir, gcore, eager, retry_time) prog.runforever()
def get_supervisor(): return childutils.getRPCInterface({ 'SUPERVISOR_SERVER_URL': 'unix:///tmp/vpnsupervisor.sock' }).supervisor
def main(): rpc = childutils.getRPCInterface(conf) prog = Dispatcher(rpc) prog.run()
def main(): import getopt short_args = "hp:g:a:s:m:n:u:t" long_args = [ "help", "program=", "group=", "any=", "sendmail_program=", "email=", "uptime=", "name=", ] arguments = sys.argv[1:] if not arguments: usage() try: opts, args = getopt.getopt(arguments, short_args, long_args) except: print __doc__ sys.exit(2) programs = {} groups = {} any = None sendmail = '/usr/sbin/sendmail -t -i' email = None uptime = sys.maxint name = None tree = False for option, value in opts: if option in ('-h', '--help'): usage() if option in ('-p', '--program'): name, size = parse_namesize(option, value) programs[name] = size if option in ('-g', '--group'): name, size = parse_namesize(option, value) groups[name] = size if option in ('-a', '--any'): size = parse_size(option, value) any = size if option in ('-s', '--sendmail_program'): sendmail = value if option in ('-m', '--email'): email = value if option in ('-u', '--uptime'): uptime = parse_seconds(option, value) if option in ('-n', '--name'): name = value if option in ('-t', '--tree'): tree = True rpc = childutils.getRPCInterface(os.environ) memmon = Memmon(programs, groups, any, sendmail, email, name, uptime, rpc, tree) memmon.runforever()
def __init__(self, events: Dict[str, List[CronEvent]]): self.events = events self.rpc = childutils.getRPCInterface(os.environ) self.stdin = sys.stdin self.stdout = sys.stdout self.stderr = sys.stderr
def test_getRPCInterface(self): from supervisor.childutils import getRPCInterface rpc = getRPCInterface( {'SUPERVISOR_SERVER_URL': 'http://localhost:9001'}) # we can't really test this thing; its a magic object self.assertTrue(rpc is not None)