def act(self, subject, msg): messages = [msg] def write(msg): self.stderr.write('%s\n' % msg) self.stderr.flush() messages.append(msg) try: specs = self.rpc.supervisor.getAllProcessInfo() except Exception as e: write('Exception retrieving process info %s, not acting' % e) return waiting = list(self.programs) if self.any: write('Restarting all running processes') for spec in specs: name = spec['name'] group = spec['group'] self.restart(spec, write) namespec = make_namespec(group, name) if name in waiting: waiting.remove(name) if namespec in waiting: waiting.remove(namespec) else: write('Restarting selected processes %s' % self.programs) for spec in specs: name = spec['name'] group = spec['group'] namespec = make_namespec(group, name) if (name in self.programs) or (namespec in self.programs): self.restart(spec, write) if name in waiting: waiting.remove(name) if namespec in waiting: waiting.remove(namespec) if waiting: write( 'Programs not restarted because they did not exist: %s' % waiting) if self.email: message = '\n'.join(messages) self.mail(self.email, subject, message) if self.dingding: ding = DingDing(self.token) message = '\n'.join(messages) ding.send_text(message, at_all=True)
def act(self, subject, msg): messages = [msg] def write(msg): self.stderr.write('%s\n' % msg) self.stderr.flush() messages.append(msg) try: specs = self.rpc.supervisor.getAllProcessInfo() except Exception as e: write('Exception retrieving process info %s, not acting' % e) return waiting = list(self.programs) write(msg) if self.any: write('Restarting all running processes') for spec in specs: name = spec['name'] group = spec['group'] self.restart(spec, write) namespec = make_namespec(group, name) if name in waiting: waiting.remove(name) if namespec in waiting: waiting.remove(namespec) else: write('Restarting selected processes %s' % self.programs) for spec in specs: name = spec['name'] group = spec['group'] namespec = make_namespec(group, name) if (name in self.programs) or (namespec in self.programs): self.restart(spec, write) if name in waiting: waiting.remove(name) if namespec in waiting: waiting.remove(namespec) if waiting: write( 'Programs not restarted because they did not exist: %s' % waiting) if self.email: message = '\n'.join(messages) self.mail(self.email, subject, message)
def _show_statuses(self, process_infos): namespecs, maxlen = [], 30 for i, info in enumerate(process_infos): namespecs.append(make_namespec(info['group'], info['name'])) if len(namespecs[i]) > maxlen: maxlen = len(namespecs[i]) global_ports = self._get_tcp_ports() template = '%(namespec)-' + str(maxlen + 3) + 's%(state)-10s%(desc)s' for i, info in enumerate(process_infos): process_pid = info['pid'] description = info['description'] try: ports = self._get_listen_ports(process_pid, global_ports) if ports: description = description + ', ports: ' + '|'.join( str(x) for x in ports) else: description = description + ', ports: ' + str(None) except Exception as e: description = description line = template % { 'namespec': namespecs[i], 'state': info['statename'], 'desc': description } self.ctl.output(line)
def do_clear(self, arg): if not self.ctl.upcheck(): return names = arg.split() if not names: self.ctl.output('Error: clear requires a process name') self.help_clear() return supervisor = self.ctl.get_supervisor() if 'all' in names: results = supervisor.clearAllProcessLogs() for result in results: result = self._clearresult(result) self.ctl.output(result) else: for name in names: group_name, process_name = split_namespec(name) try: supervisor.clearProcessLogs(name) except xmlrpclib.Fault as e: error = self._clearresult({'status': e.faultCode, 'name': process_name, 'group': group_name, 'description': e.faultString}) self.ctl.output(error) else: name = make_namespec(group_name, process_name) self.ctl.output('%s: cleared' % name)
def clearall(): if not callbacks: return results group, process, callback = callbacks.pop(0) name = make_namespec(group.config.name, process.config.name) try: callback(name) except RPCError as e: results.append( {"name": process.config.name, "group": group.config.name, "status": e.code, "description": e.text} ) else: results.append( { "name": process.config.name, "group": group.config.name, "status": Faults.SUCCESS, "description": "OK", } ) if callbacks: return NOT_DONE_YET return results
def do_clear(self, arg): if not self.ctl.upcheck(): return names = arg.split() if not names: self.ctl.output("Error: clear requires a process name") self.help_clear() return supervisor = self.ctl.get_supervisor() if "all" in names: results = supervisor.clearAllProcessLogs() for result in results: result = self._clearresult(result) self.ctl.output(result) else: for name in names: group_name, process_name = split_namespec(name) try: result = supervisor.clearProcessLogs(name) except xmlrpclib.Fault, e: error = self._clearresult( {"status": e.faultCode, "name": process_name, "group": group_name, "description": e.faultString} ) self.ctl.output(error) else: name = make_namespec(group_name, process_name) self.ctl.output("%s: cleared" % name)
def _restart_processes(self): try: specs = self.rpc.supervisor.getAllProcessInfo() except Exception as e: print("Unable to get process info: {}. No action taken.".format(e), file=self.stderr) else: waiting = set(self.restart_programs) for spec in specs: name = spec["name"] namespec = make_namespec(spec["group"], name) if self.restart_any_program or name in waiting or namespec in waiting: if spec["state"] is ProcessStates.RUNNING: print("Restarting process: {}.".format(namespec), file=self.stderr) try: self.rpc.supervisor.stopProcess(namespec) except xmlrpclib.Fault as e: print("Unable to stop process {}: {}.".format(namespec, e), file=self.stderr) try: self.rpc.supervisor.startProcess(namespec) except xmlrpclib.Fault as e: print("Unable to start process {}: {}.".format(namespec, e), file=self.stderr) else: print("Restarted process {}.".format(namespec), file=self.stderr) else: print("Process {} is not in RUNNING state. No action taken.".format(namespec)) waiting.discard(name) waiting.discard(namespec) if len(waiting) > 0: print("Programs specified could not be found: {}.".format(", ".join(waiting)), file=self.stderr)
def stopProcessGroup(self, name, wait=True): """ Stop all processes in the process group named 'name' @param string name The group name @param boolean wait Wait for each process to be fully stopped @return array result An array of process status info structs """ self._update('stopProcessGroup') group = self.supervisord.process_groups.get(name) if group is None: raise RPCError(Faults.BAD_NAME, name) processes = group.processes.values() processes.sort() processes = [ (group, process) for process in processes ] results=[] for group, process in processes: name = make_namespec(group.config.name, process.config.name) grp, proc = self._getGroupAndProcess(name) msg=proc.stop() results.append( {'name':process.config.name, 'group':group.config.name, 'status':Faults.SUCCESS, 'description':'OK'} ) return results # deferred
def stopAllProcesses(self, wait=True): """ Stop all processes in the process list @param boolean wait Wait for each process to be fully stopped @return array result An array of process status info structs """ self._update('stopAllProcesses') processes = self._getAllProcesses() results=[] for group, process in processes: name = make_namespec(group.config.name, process.config.name) grp, proc = self._getGroupAndProcess(name) msg=proc.stop() results.append( {'name':process.config.name, 'group':group.config.name, 'status':Faults.SUCCESS, 'description':'OK'} ) #killall.rpcinterface = self return results # deferred
def restart(self, spec, write): namespec = make_namespec(spec['group'], spec['name']) if spec['state'] is ProcessStates.RUNNING: if self.coredir and self.gcore: corename = os.path.join(self.coredir, namespec) cmd = self.gcore + ' "%s" %s' % (corename, spec['pid']) with os.popen(cmd) as m: write('gcore output for %s:\n\n %s' % ( namespec, m.read())) write('%s is in RUNNING state, restarting' % namespec) try: self.rpc.supervisor.stopProcess(namespec) except xmlrpclib.Fault as e: write('Failed to stop process %s: %s' % ( namespec, e)) try: self.rpc.supervisor.startProcess(namespec) except xmlrpclib.Fault as e: write('Failed to start process %s: %s' % ( namespec, e)) else: write('%s restarted' % namespec) else: write('%s not in RUNNING state, NOT restarting' % namespec)
def allfunc( processes=processes, predicate=predicate, func=func, extra_kwargs=extra_kwargs, callbacks=callbacks, # used only to fool scoping, never passed by caller results=results, # used only to fool scoping, never passed by caller ): if not callbacks: for group, process in processes: name = make_namespec(group.config.name, process.config.name) if predicate(process): try: callback = func(name, **extra_kwargs) except RPCError, e: results.append({'name':process.config.name, 'group':group.config.name, 'status':e.code, 'description':e.text}) continue if isinstance(callback, types.FunctionType): callbacks.append((group, process, callback)) else: results.append( {'name':process.config.name, 'group':group.config.name, 'status':Faults.SUCCESS, 'description':'OK'} )
def clearall(): if not callbacks: return results group, process, callback = callbacks.pop(0) name = make_namespec(group.config.name, process.config.name) try: callback(name) except RPCError as e: results.append( {'name': process.config.name, 'group': group.config.name, 'status': e.code, 'description': e.text}) else: results.append( {'name': process.config.name, 'group': group.config.name, 'status': Faults.SUCCESS, 'description': 'OK'} ) if callbacks: return NOT_DONE_YET return results
def clearall(): if not callbacks: return results group, process, callback = callbacks.pop(0) name = make_namespec(group.config.name, process.config.name) try: callback(name) except RPCError as e: results.append( {'name':process.config.name, 'group':group.config.name, 'status':e.code, 'description':e.text}) else: results.append( {'name':process.config.name, 'group':group.config.name, 'status':Faults.SUCCESS, 'description':'OK'} ) if callbacks: return NOT_DONE_YET return results
def allfunc(processes=processes, predicate=predicate, func=func, extra_kwargs=extra_kwargs, callbacks=callbacks, # used only to fool scoping, never passed by caller results=results): # used only to fool scoping, never passed by caller if not callbacks: for group, process in processes: name = make_namespec(group.config.name, process.config.name) if predicate(process): try: callback = func(name, **extra_kwargs) except RPCError as e: results.append({ 'name': process.config.name, 'group': group.config.name, 'status': e.code, 'description': e.text }) continue if isinstance(callback, types.FunctionType): callbacks.append((group, process, callback)) else: results.append({ 'name': process.config.name, 'group': group.config.name, 'status': Faults.SUCCESS, 'description': 'OK' }) if not callbacks: return results for struct in callbacks[:]: group, process, cb = struct try: value = cb() except RPCError as e: results.append({ 'name': process.config.name, 'group': group.config.name, 'status': e.code, 'description': e.text }) callbacks.remove(struct) else: if value is not NOT_DONE_YET: results.append({ 'name': process.config.name, 'group': group.config.name, 'status': Faults.SUCCESS, 'description': 'OK' }) callbacks.remove(struct) if callbacks: return NOT_DONE_YET return results
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 logname(self): """ The name of this subprocess as used in logging. """ if self.group is None: return self.config.name else: return make_namespec(self.group.config.name, self.config.name)
def match(spec): name = spec['name'] group = spec['group'] namespec = make_namespec(name, group) for pattern in self.programs: if fnmatch.fnmatch(name, pattern) or fnmatch.fnmatch(namespec, pattern): return True return False
def allfunc(processes=processes, predicate=predicate, func=func, extra_kwargs=extra_kwargs, callbacks=callbacks, results=results): if not callbacks: for group, process in processes: name = make_namespec(group.config.name, process.config.name) if predicate(process): try: callback = func(name, **extra_kwargs) callbacks.append((group, process, callback)) except RPCError: e = sys.exc_info()[1] results.append({ 'name': process.config.name, 'group': group.config.name, 'status': e.code, 'description': e.text }) continue if not callbacks: return results group, process, callback = callbacks.pop(0) try: value = callback() except RPCError: e = sys.exc_info()[1] results.append({ 'name': process.config.name, 'group': group.config.name, 'status': e.code, 'description': e.text }) return NOT_DONE_YET if value is NOT_DONE_YET: # push it back into the queue; it will finish eventually callbacks.append((group, process, callback)) else: results.append({ 'name': process.config.name, 'group': group.config.name, 'status': Faults.SUCCESS, 'description': 'OK' }) if callbacks: return NOT_DONE_YET return results
def stop(self, spec, write): namespec = make_namespec(spec['group'], spec['name']) if spec['state'] is ProcessStates.STOPPED: return write('%s is in RUNNING state, stopping' % namespec) try: self.rpc.supervisor.stopProcess(namespec) except xmlrpclib.Fault, what: write('Failed to stop process %s: %s' % ( namespec, what))
def _getGroupProcessInfo(self, group): """ Get info about the processes of a certian group @return array result An array of process status results """ output = [] for process in group.processes.values(): name = make_namespec(group.config.name, process.config.name) output.append(self.getProcessInfo(name)) return output
def _getGroupProcessInfo(self, group): """ Get info about the processes of a certain group @return array result An array of process status results """ output = [] for process in group.processes.values(): name = make_namespec(group.config.name, process.config.name) output.append(self.getProcessInfo(name)) return output
def start(self, spec, write): namespec = make_namespec(spec['group'], spec['name']) if spec['state'] is ProcessStates.RUNNING: return try: self.rpc.supervisor.startProcess(namespec) except xmlrpclib.Fault, what: write('Failed to start process %s: %s' % ( namespec, what))
def _spawn_as_parent(self, pid): # Parent self.pid = pid options = self.config.options options.close_child_pipes(self.pipes) options.logger.info('spawned: %r with pid %s' % (make_namespec(self.group.config.name, self.config.name), pid)) self.spawnerr = None self.delay = time.time() + self.config.startsecs options.pidhistory[pid] = self return pid
def _clearresult(self, result): name = make_namespec(result['group'], result['name']) code = result['status'] template = '%s: ERROR (%s)' if code == xmlrpc.Faults.BAD_NAME: return template % (name, 'no such process') elif code == xmlrpc.Faults.FAILED: return template % (name, 'failed') elif code == xmlrpc.Faults.SUCCESS: return '%s: cleared' % name raise ValueError('Unknown result code %s for %s' % (code, name))
def start_stop(self, spec, start=True): namespec = make_namespec(spec['group'], spec['name']) if spec['state'] is ProcessStates.RUNNING and not start: self.write_stderr('%s is in RUNNING state, stopping' % namespec) try: self.rpc.supervisor.stopProcess(namespec) except xmlrpclib.Fault, what: self.write_stderr('Failed to stop process %s: %s' % (namespec, what)) else: self.write_stderr('%s stopped' % namespec)
def _clearresult(self, result): name = make_namespec(result["group"], result["name"]) code = result["status"] template = "%s: ERROR (%s)" if code == xmlrpc.Faults.BAD_NAME: return template % (name, "no such process") elif code == xmlrpc.Faults.FAILED: return template % (name, "failed") elif code == xmlrpc.Faults.SUCCESS: return "%s: cleared" % name raise ValueError("Unknown result code %s for %s" % (code, name))
def stop(self, spec): namespec = make_namespec(spec['group'], spec['name']) if spec['state'] in [ProcessStates.RUNNING, ProcessStates.STARTING]: self.write('%s is in RUNNING/STARTING state, stopping' % namespec) try: self.rpc.supervisor.stopProcess(namespec) self.write('stopping %s' % namespec) except Exception as e: self.write('Failed to stop process %s: %s' % (namespec, e)) else: self.write('%s not in RUNNING state, NOT stopping' % namespec)
def _show_statuses(self, process_infos): namespecs, maxlen = [], 30 for i, info in enumerate(process_infos): namespecs.append(make_namespec(info["group"], info["name"])) if len(namespecs[i]) > maxlen: maxlen = len(namespecs[i]) template = "%(namespec)-" + str(maxlen + 3) + "s%(state)-10s%(desc)s" for i, info in enumerate(process_infos): line = template % {"namespec": namespecs[i], "state": info["statename"], "desc": info["description"]} self.ctl.output(line)
def write_process_table(self, root): """ Rendering of the processes managed through Supervisor """ # collect data on processes data = [] try: for info in self.info_source.supervisor_rpc_interface.getAllProcessInfo(): data.append({'application_name': info['group'], 'process_name': info['name'], 'namespec': make_namespec(info['group'], info['name']), 'statename': info['statename'], 'statecode': info['state'], 'desc': info['description']}) except RPCError, e: self.logger.warn('failed to get all process info from {}: {}'.format(self.address, e.text))
def allfunc( processes=processes, predicate=predicate, func=func, extra_kwargs=extra_kwargs, callbacks=callbacks, # used only to fool scoping, never passed by caller results=results, # used only to fool scoping, never passed by caller ): if not callbacks: for group, process in processes: name = make_namespec(group.config.name, process.config.name) if predicate(process): try: callback = func(name, **extra_kwargs) callbacks.append((group, process, callback)) except RPCError as e: results.append({'name':process.config.name, 'group':group.config.name, 'status':e.code, 'description':e.text}) continue if not callbacks: return results group, process, callback = callbacks.pop(0) try: value = callback() except RPCError as e: results.append( {'name':process.config.name, 'group':group.config.name, 'status':e.code, 'description':e.text}) return NOT_DONE_YET if value is NOT_DONE_YET: # push it back into the queue; it will finish eventually callbacks.append((group, process, callback)) else: results.append( {'name':process.config.name, 'group':group.config.name, 'status':Faults.SUCCESS, 'description':'OK'} ) if callbacks: return NOT_DONE_YET return results
def _show_statuses(self, process_infos): namespecs, maxlen = [], 30 for i, info in enumerate(process_infos): namespecs.append(make_namespec(info['group'], info['name'])) if len(namespecs[i]) > maxlen: maxlen = len(namespecs[i]) template = '%(namespec)-' + str(maxlen+3) + 's%(state)-10s%(desc)s' for i, info in enumerate(process_infos): line = template % {'namespec': namespecs[i], 'state': info['statename'], 'desc': info['description']} self.ctl.output(line)
def do_signal(self, arg): if not self.ctl.upcheck(): return args = arg.split() if len(args) < 2: self.ctl.error_output( 'Error: signal requires a signal name and a process name') self.help_signal() return sig = args[0] names = args[1:] supervisor = self.ctl.get_supervisor() if 'all' in names: results = supervisor.signalAllProcesses(sig) for result in results: result = self._signalresult(result) self.ctl.output(result) else: for name in names: group_name, process_name = split_namespec(name) if process_name is None: try: results = supervisor.signalProcessGroup( group_name, sig) for result in results: result = self._signalresult(result) self.ctl.output(result) except xmlrpclib.Fault as e: if e.faultCode == xmlrpc.Faults.BAD_NAME: error = "%s: ERROR (no such group)" % group_name self.ctl.error_output(error) else: raise else: try: supervisor.signalProcess(name, sig) except xmlrpclib.Fault as e: error = self._signalresult({ 'status': e.faultCode, 'name': process_name, 'group': group_name, 'description': e.faultString }) self.ctl.error_output(error) else: name = make_namespec(group_name, process_name) self.ctl.output('%s: signalled' % name)
def getAllProcessInfo(self): """ Get info about all processes @return array result An array of process status results """ self._update('getAllProcessInfo') all_processes = self._getAllProcesses(lexical=True) output = [] for group, process in all_processes: name = make_namespec(group.config.name, process.config.name) output.append(self.getProcessInfo(name)) return output
def clearall(): if not callbacks: return results group, process, callback = callbacks.pop(0) name = make_namespec(group.config.name, process.config.name) try: callback(name) except RPCError, e: results.append( {'name':process.config.name, 'group':group.config.name, 'status':e.code, 'description':e.text})
def do_signal(self, arg): if not self.ctl.upcheck(): return args = arg.split() if len(args) < 2: self.ctl.output( 'Error: signal requires a signal name and a process name') self.help_signal() return sig = args[0] names = args[1:] supervisor = self.ctl.get_supervisor() if 'all' in names: results = supervisor.signalAllProcesses(sig) for result in results: result = self._signalresult(result) self.ctl.output(result) else: for name in names: group_name, process_name = split_namespec(name) if process_name is None: try: results = supervisor.signalProcessGroup( group_name, sig ) for result in results: result = self._signalresult(result) self.ctl.output(result) except xmlrpclib.Fault as e: if e.faultCode == xmlrpc.Faults.BAD_NAME: error = "%s: ERROR (no such group)" % group_name self.ctl.output(error) else: raise else: try: supervisor.signalProcess(name, sig) except xmlrpclib.Fault as e: error = self._signalresult({'status': e.faultCode, 'name': process_name, 'group': group_name, 'description':e.faultString}) self.ctl.output(error) else: name = make_namespec(group_name, process_name) self.ctl.output('%s: signalled' % name)
def _stopresult(self, result): name = make_namespec(result['group'], result['name']) code = result['status'] fault_string = result['description'] template = '%s: ERROR (%s)' if code == xmlrpc.Faults.BAD_NAME: return template % (name, 'no such process') elif code == xmlrpc.Faults.NOT_RUNNING: return template % (name, 'not running') elif code == xmlrpc.Faults.SUCCESS: return '%s: stopped' % name elif code == xmlrpc.Faults.FAILED: return fault_string # assertion raise ValueError('Unknown result code %s for %s' % (code, name))
def _stopresult(self, result): name = make_namespec(result["group"], result["name"]) code = result["status"] fault_string = result["description"] template = "%s: ERROR (%s)" if code == xmlrpc.Faults.BAD_NAME: return template % (name, "no such process") elif code == xmlrpc.Faults.NOT_RUNNING: return template % (name, "not running") elif code == xmlrpc.Faults.SUCCESS: return "%s: stopped" % name elif code == xmlrpc.Faults.FAILED: return fault_string # assertion raise ValueError("Unknown result code %s for %s" % (code, name))
def _formatConfigInfo(self, configinfo): name = make_namespec(configinfo["group"], configinfo["name"]) formatted = {"name": name} if configinfo["inuse"]: formatted["inuse"] = "in use" else: formatted["inuse"] = "avail" if configinfo["autostart"]: formatted["autostart"] = "auto" else: formatted["autostart"] = "manual" formatted["priority"] = "%s:%s" % (configinfo["group_prio"], configinfo["process_prio"]) template = "%(name)-32s %(inuse)-9s %(autostart)-9s %(priority)s" return template % formatted
def start(self, spec): namespec = make_namespec(spec['group'], spec['name']) if spec['state'] in [ ProcessStates.STOPPED, ProcessStates.EXITED, ProcessStates.FATAL ]: self.write('%s is in STOPPED/EXITED/FATAL state, starting' % namespec) try: self.rpc.supervisor.startProcess(namespec) self.write('starting %s' % namespec) except Exception as e: self.write('Failed to start process %s: %s' % (namespec, e)) else: self.write('%s in RUNNING state, NOT starting' % namespec)
def do_stop(self, arg, exitOnError=True): if not self.ctl.upcheck(): return names = arg.split() supervisor = self.ctl.get_supervisor() if not names: self.handle_error('Error: stop requires a process name') self.help_stop() return if 'all' in names: results = supervisor.stopAllProcesses() for result in results: result = self._stopresult(result) self.ctl.output(result) else: for name in names: group_name, process_name = split_namespec(name) if process_name is None: try: results = supervisor.stopProcessGroup(group_name) for result in results: result = self._stopresult(result) self.ctl.output(result) except xmlrpclib.Fault as e: if e.faultCode == xmlrpc.Faults.BAD_NAME: error = "%s: ERROR (no such group)" % group_name logOnly = not exitOnError self.handle_error(message=error, logOnly=logOnly) else: self.handle_error(unhandled=True) else: try: supervisor.stopProcess(name) except xmlrpclib.Fault as e: error = self._stopresult({ 'status': e.faultCode, 'name': process_name, 'group': group_name, 'description': e.faultString }) self.ctl.error_output(error) else: name = make_namespec(group_name, process_name) self.ctl.output('%s: stopped' % name)
def _formatConfigInfo(self, configinfo): name = make_namespec(configinfo['group'], configinfo['name']) formatted = { 'name': name } if configinfo['inuse']: formatted['inuse'] = 'in use' else: formatted['inuse'] = 'avail' if configinfo['autostart']: formatted['autostart'] = 'auto' else: formatted['autostart'] = 'manual' formatted['priority'] = "%s:%s" % (configinfo['group_prio'], configinfo['process_prio']) template = '%(name)-32s %(inuse)-9s %(autostart)-9s %(priority)s' return template % formatted
def do_start(self, arg): if not self.ctl.upcheck(): return names = arg.split() supervisor = self.ctl.get_supervisor() if not names: self.ctl.output("Error: start requires a process name") self.help_start() return if 'all' in names: results = supervisor.startAllProcesses() for result in results: result = self._startresult(result) self.ctl.output(result) else: for name in names: group_name, process_name = split_namespec(name) if process_name is None: try: results = supervisor.startProcessGroup(group_name) for result in results: result = self._startresult(result) self.ctl.output(result) except xmlrpclib.Fault as e: if e.faultCode == xmlrpc.Faults.BAD_NAME: error = "%s: ERROR (no such group)" % group_name self.ctl.output(error) else: raise else: try: result = supervisor.startProcess(name) except xmlrpclib.Fault as e: error = self._startresult({ 'status': e.faultCode, 'name': process_name, 'group': group_name, 'description': e.faultString }) self.ctl.output(error) else: name = make_namespec(group_name, process_name) self.ctl.output('%s: started' % name)
def allfunc(processes=processes, predicate=predicate, func=func, extra_kwargs=extra_kwargs, callbacks=callbacks, results=results): if not callbacks: for group, process in processes: name = make_namespec(group.config.name, process.config.name) if predicate(process): try: callback = func(name, **extra_kwargs) callbacks.append((group, process, callback)) except RPCError, e: results.append({'name':process.config.name, 'group':group.config.name, 'status':e.code, 'description':e.text}) continue
def actions_for_process(self, process): state = process.get_state() processname = urllib.quote( make_namespec(process.group.config.name, process.config.name)) start = { 'name': 'Start', 'href': 'index.html?processname=%s&action=start' % processname, 'target': None, } restart = { 'name': 'Restart', 'href': 'index.html?processname=%s&action=restart' % processname, 'target': None, } stop = { 'name': 'Stop', 'href': 'index.html?processname=%s&action=stop' % processname, 'target': None, } clearlog = { 'name': 'Clear Log', 'href': 'index.html?processname=%s&action=clearlog' % processname, 'target': None, } tailf = { 'name': 'Tail -f', 'href': 'logtail/%s/stderr' % processname, 'target': '_blank' } signalhup = { 'name': 'HUP', 'href': 'index.html?processname=%s&action=signalhup' % processname, 'target': None } if state == ProcessStates.RUNNING: actions = [restart, stop, clearlog, tailf, signalhup] elif state in (ProcessStates.STOPPED, ProcessStates.EXITED, ProcessStates.FATAL): actions = [start, None, clearlog, tailf] else: actions = [None, None, clearlog, tailf] return actions
def _startresult(self, result): name = make_namespec(result['group'], result['name']) code = result['status'] template = '%s: ERROR (%s)' if code == xmlrpc.Faults.BAD_NAME: return template % (name, 'no such process') elif code == xmlrpc.Faults.NO_FILE: return template % (name, 'no such file') elif code == xmlrpc.Faults.NOT_EXECUTABLE: return template % (name, 'file is not executable') elif code == xmlrpc.Faults.ALREADY_STARTED: return template % (name, 'already started') elif code == xmlrpc.Faults.SPAWN_ERROR: return template % (name, 'spawn error') elif code == xmlrpc.Faults.ABNORMAL_TERMINATION: return template % (name, 'abnormal termination') elif code == xmlrpc.Faults.SUCCESS: return '%s: started' % name # assertion raise ValueError('Unknown result code %s for %s' % (code, name))
def do_extstop(self, arg): if not self.ctl.upcheck(): self.ctl.exitstatus = LSBStatusExitStatuses.UNKNOWN return supervisor = self.ctl.get_supervisor() all_infos = supervisor.getAllProcessInfo() names = arg.split() if not names or "all" in names: matching_names = 'all' else: matching_names = '' for name in names: bad_name = True group_name, process_name = split_namespec(name) for info in all_infos: matched = info['group'] == group_name if process_name is not None: matched = matched and info['name'] == process_name if group_name == process_name: matched = fnmatch(info['name'], process_name) if matched: bad_name = False program_name = make_namespec(info['group'], info['name']) matching_names = matching_names + ' ' + program_name if bad_name: if process_name is None: msg = "%s: ERROR (no such group)" % group_name else: msg = "%s: ERROR (no such process)" % name self.ctl.output(msg) self.ctl.exitstatus = LSBStatusExitStatuses.UNKNOWN if matching_names: self._extstop(matching_names)
def render(self): form = self.context.form response = self.context.response processname = form.get('processname') action = form.get('action') message = form.get('message') if action: if not self.callback: self.callback = self.make_callback(processname, action) return NOT_DONE_YET else: message = self.callback() if message is NOT_DONE_YET: return NOT_DONE_YET if message is not None: server_url = form['SERVER_URL'] location = server_url + '?message=%s' % urllib.quote( message) response['headers']['Location'] = location supervisord = self.context.supervisord rpcinterface = RootRPCInterface([ ('supervisor', SupervisorNamespaceRPCInterface(supervisord)) ]) processnames = [] groups = supervisord.process_groups.values() for group in groups: gprocnames = group.processes.keys() for gprocname in gprocnames: processnames.append((group.config.name, gprocname)) processnames.sort() data = [] for groupname, processname in processnames: actions = self.actions_for_process( supervisord.process_groups[groupname].processes[processname]) sent_name = make_namespec(groupname, processname) info = rpcinterface.supervisor.getProcessInfo(sent_name) data.append({ 'status': info['statename'], 'name': processname, 'group': groupname, 'actions': actions, 'state': info['state'], 'description': info['description'], }) root = self.clone() if message is not None: statusarea = root.findmeld('statusmessage') statusarea.attrib['class'] = 'status_msg' statusarea.content(message) if data: iterator = root.findmeld('tr').repeat(data) shaded_tr = False for tr_element, item in iterator: status_text = tr_element.findmeld('status_text') status_text.content(item['status'].lower()) status_text.attrib['class'] = self.css_class_for_state( item['state']) info_text = tr_element.findmeld('info_text') info_text.content(item['description']) anchor = tr_element.findmeld('name_anchor') processname = make_namespec(item['group'], item['name']) anchor.attributes(href='tail.html?processname=%s' % urllib.quote(processname)) anchor.content(processname) actions = item['actions'] actionitem_td = tr_element.findmeld('actionitem_td') for li_element, actionitem in actionitem_td.repeat(actions): anchor = li_element.findmeld('actionitem_anchor') if actionitem is None: anchor.attrib['class'] = 'hidden' else: anchor.attributes(href=actionitem['href'], name=actionitem['name']) anchor.content(actionitem['name']) if actionitem['target']: anchor.attributes(target=actionitem['target']) if shaded_tr: tr_element.attrib['class'] = 'shade' shaded_tr = not shaded_tr else: table = root.findmeld('statustable') table.replace('No programs to manage') copyright_year = str(datetime.date.today().year) root.findmeld('copyright_date').content(copyright_year) return root.write_xhtmlstring()