SYMBOL INDEX (490 symbols across 38 files)

FILE: chaperone/cproc/client.py
  class CommandClient (line 3) | class CommandClient(asyncio.Protocol):
    method sendCommand (line 6) | def sendCommand(cls, cmd):
    method __init__ (line 14) | def __init__(self, message, loop):
    method connection_made (line 19) | def connection_made(self, transport):
    method data_received (line 22) | def data_received(self, data):
    method connection_lost (line 35) | def connection_lost(self, exc):

FILE: chaperone/cproc/commands.py
  class _BaseCommand (line 28) | class _BaseCommand(object):
    method match (line 34) | def match(self, opts):
    method exec (line 40) | def exec(self, opts, protocol):
  class statusCommand (line 57) | class statusCommand(_BaseCommand):
    method do_exec (line 63) | def do_exec(self, opts, controller):
  class dependenciesCommand (line 69) | class dependenciesCommand(_BaseCommand):
    method do_exec (line 75) | def do_exec(self, opts, controller):
  class serviceReset (line 79) | class serviceReset(_BaseCommand):
    method do_exec (line 84) | def do_exec(self, opts, controller):
  class serviceEnable (line 89) | class serviceEnable(_BaseCommand):
    method do_exec (line 94) | def do_exec(self, opts, controller):
  class serviceDisable (line 98) | class serviceDisable(_BaseCommand):
    method do_exec (line 103) | def do_exec(self, opts, controller):
  class serviceStart (line 107) | class serviceStart(_BaseCommand):
    method do_exec (line 112) | def do_exec(self, opts, controller):
  class serviceStop (line 121) | class serviceStop(_BaseCommand):
    method do_exec (line 126) | def do_exec(self, opts, controller):
  class loglevelCommand (line 135) | class loglevelCommand(_BaseCommand):
    method do_exec (line 140) | def do_exec(self, opts, controller):
  class shutdownCommand (line 156) | class shutdownCommand(_BaseCommand):
    method do_exec (line 161) | def do_exec(self, opts, controller):
  class CommandProtocol (line 195) | class CommandProtocol(ServerProtocol):
    method _interpret_command (line 200) | def _interpret_command(self, msg):
    method _command_task (line 219) | def _command_task(self, cmd, interactive = False):
    method data_received (line 225) | def data_received(self, data):
  class _InteractiveServer (line 233) | class _InteractiveServer(Server):
    method _create_server (line 235) | def _create_server(self):
    method server_running (line 241) | def server_running(self):
    method close (line 244) | def close(self):
  class CommandServer (line 249) | class CommandServer(Server):
    method __init__ (line 255) | def __init__(self, controller, filename = CHAP_FIFO, **kwargs):
    method server_running (line 266) | def server_running(self):
    method _open (line 271) | def _open(self):
    method _create_server (line 285) | def _create_server(self):
    method close (line 288) | def close(self):

FILE: chaperone/cproc/process_manager.py
  class CustomEventLoop (line 26) | class CustomEventLoop(asyncio.SelectorEventLoop):
    method _make_socket_transport (line 27) | def _make_socket_transport(self, sock, protocol, waiter=None, *,
  class TopLevelProcess (line 43) | class TopLevelProcess(objectplus):
    method __init__ (line 68) | def __init__(self, config):
    method debug (line 91) | def debug(self):
    method debug (line 94) | def debug(self, val):
    method loop (line 98) | def loop(self):
    method system_alive (line 102) | def system_alive(self):
    method version (line 113) | def version(self):
    method uptime (line 118) | def uptime(self):
    method services (line 122) | def services(self):
    method force_log_level (line 125) | def force_log_level(self, level = None):
    method _queue_no_processes (line 149) | def _queue_no_processes(self):
    method _no_processes (line 154) | def _no_processes(self, ignore_service_state = False):
    method _final_system_stop (line 181) | def _final_system_stop(self):
    method _got_sigint (line 191) | def _got_sigint(self):
    method signal_ready (line 195) | def signal_ready(self):
    method _report_status (line 210) | def _report_status(self):
    method kill_system (line 216) | def kill_system(self, errno = None, force = False):
    method _cancel_pending (line 234) | def _cancel_pending(self):
    method _kill_system_co (line 242) | def _kill_system_co(self):
    method activate_result (line 288) | def activate_result(self, future):
    method activate (line 291) | def activate(self, cr):
    method _system_coro_check (line 297) | def _system_coro_check(self, f):
    method _system_started (line 302) | def _system_started(self, startup, future=None):
    method _start_system_services (line 312) | def _start_system_services(self):
    method run_event_loop (line 337) | def run_event_loop(self, startup_coro = None, exit_when_done = True):
    method run_services (line 354) | def run_services(self, extra_services, disable_others = False):

FILE: chaperone/cproc/pt/cron.py
  class CronProcess (line 17) | class CronProcess(SubProcess):
    method __init__ (line 24) | def __init__(self, service, family=None):
    method default_status (line 37) | def default_status(self):
    method scheduled (line 43) | def scheduled(self):
    method start (line 47) | def start(self):
    method _cron_hit (line 65) | def _cron_hit(self):
    method stoppable (line 80) | def stoppable(self):
    method stop (line 84) | def stop(self):
    method process_started_co (line 89) | def process_started_co(self):
    method _monitor_service (line 100) | def _monitor_service(self):

FILE: chaperone/cproc/pt/forking.py
  class ForkingProcess (line 5) | class ForkingProcess(SubProcess):
    method process_started_co (line 10) | def process_started_co(self):
    method _exit_timeout (line 19) | def _exit_timeout(self):

FILE: chaperone/cproc/pt/inetd.py
  class InetdServiceProtocol (line 10) | class InetdServiceProtocol(ServerProtocol):
    method acquire_socket (line 14) | def acquire_socket(self, sock):
    method _done (line 27) | def _done(self, f):
    method start_socket_process (line 33) | def start_socket_process(self, fd):
  class InetdService (line 77) | class InetdService(Server):
    method __init__ (line 79) | def __init__(self, process):
    method _create_server (line 83) | def _create_server(self):
  class InetdProcess (line 88) | class InetdProcess(SubProcess):
    method __init__ (line 94) | def __init__(self, service, family=None):
    method add_process (line 101) | def add_process(self, proc):
    method remove_process (line 104) | def remove_process(self, proc):
    method scheduled (line 108) | def scheduled(self):
    method note (line 112) | def note(self):
    method start_subprocess (line 122) | def start_subprocess(self):
    method reset (line 133) | def reset(self, dependents = False, enable = False, restarts_ok = False):
    method final_stop (line 145) | def final_stop(self):

FILE: chaperone/cproc/pt/notify.py
  class NotifyProcess (line 11) | class NotifyProcess(SubProcess):
    method _close_listener (line 20) | def _close_listener(self):
    method process_prepare_co (line 26) | def process_prepare_co(self, environ):
    method _notify_timeout (line 37) | def _notify_timeout(self):
    method reset (line 49) | def reset(self, dependents = False, enable = False, restarts_ok = False):
    method final_stop (line 54) | def final_stop(self):
    method process_started_co (line 59) | def process_started_co(self):
    method _monitor_service (line 88) | def _monitor_service(self):
    method _notify_received (line 100) | def _notify_received(self, which, var, value):
    method _setready (line 106) | def _setready(self):
    method notify_MAINPID (line 112) | def notify_MAINPID(self, value):
    method notify_BUSERROR (line 120) | def notify_BUSERROR(self, value):
    method notify_ERRNO (line 127) | def notify_ERRNO(self, value):
    method notify_READY (line 139) | def notify_READY(self, value):
    method notify_STATUS (line 143) | def notify_STATUS(self, value):
    method status (line 147) | def status(self):

FILE: chaperone/cproc/pt/oneshot.py
  class OneshotProcess (line 5) | class OneshotProcess(SubProcess):
    method process_started_co (line 10) | def process_started_co(self):
    method _exit_timeout (line 18) | def _exit_timeout(self):

FILE: chaperone/cproc/pt/simple.py
  class SimpleProcess (line 4) | class SimpleProcess(SubProcess):
    method process_started_co (line 9) | def process_started_co(self):
    method _monitor_service (line 28) | def _monitor_service(self):

FILE: chaperone/cproc/subproc.py
  function _process_logger (line 21) | def _process_logger(stream, kind, service):
  class SubProcess (line 38) | class SubProcess(object):
    method __new__ (line 75) | def __new__(cls, service, family=None):
    method __init__ (line 95) | def __init__(self, service, family=None):
    method __getattr__ (line 122) | def __getattr__(self, name):
    method __setattr__ (line 126) | def __setattr__(self, name, value):
    method _setup_subprocess (line 136) | def _setup_subprocess(self):
    method _get_states (line 149) | def _get_states(self):
    method pid (line 164) | def pid(self):
    method pid (line 168) | def pid(self, newpid):
    method returncode (line 180) | def returncode(self):
    method returncode (line 186) | def returncode(self, val):
    method loginfo (line 192) | def loginfo(self, *args, **kwargs):
    method logerror (line 195) | def logerror(self, *args, **kwargs):
    method logwarn (line 199) | def logwarn(self, *args, **kwargs):
    method logdebug (line 202) | def logdebug(self, *args, **kwargs):
    method note (line 206) | def note(self):
    method note (line 209) | def note(self, value):
    method status (line 213) | def status(self):
    method default_status (line 238) | def default_status(self):
    method enabled (line 244) | def enabled(self):
    method enabled (line 247) | def enabled(self, val):
    method _try_to_enable (line 253) | def _try_to_enable(self):
    method scheduled (line 280) | def scheduled(self):
    method kill_signal (line 291) | def kill_signal(self):
    method running (line 298) | def running(self):
    method started (line 303) | def started(self):
    method stoppable (line 310) | def stoppable(self):
    method failed (line 319) | def failed(self):
    method ready (line 325) | def ready(self):
    method prerequisites (line 339) | def prerequisites(self):
    method start (line 351) | def start(self):
    method get_expanded_environment (line 433) | def get_expanded_environment(self):
    method start_subprocess (line 441) | def start_subprocess(self):
    method process_prepare_co (line 493) | def process_prepare_co(self, environment):
    method process_started_co (line 497) | def process_started_co(self):
    method wait_for_pidfile (line 501) | def wait_for_pidfile(self):
    method _wait_kill_on_exit (line 543) | def _wait_kill_on_exit(self):
    method _attach_pid (line 547) | def _attach_pid(self, newpid):
    method _child_watcher_callback (line 557) | def _child_watcher_callback(self, pid, returncode):
    method process_exit (line 560) | def process_exit(self, code):
    method _abnormal_exit (line 580) | def _abnormal_exit(self, code):
    method _restart_callback (line 616) | def _restart_callback(self, fut):
    method _kill_system (line 626) | def _kill_system(self):
    method add_pending (line 629) | def add_pending(self, future):
    method reset (line 634) | def reset(self, dependents = False, enable = False, restarts_ok = False):
    method stop (line 669) | def stop(self):
    method final_stop (line 673) | def final_stop(self):
    method terminate (line 681) | def terminate(self):
    method do_startup_pause (line 705) | def do_startup_pause(self):
    method timed_wait (line 726) | def timed_wait(self, timeout, func = None):
    method wait (line 749) | def wait(self):
  class SubProcessFamily (line 767) | class SubProcessFamily(lazydict):
    method __init__ (line 774) | def __init__(self, controller, services_config):
    method get_status_formatter (line 787) | def get_status_formatter(self):
    method system_alive (line 793) | def system_alive(self):
    method get_scheduled_services (line 796) | def get_scheduled_services(self):
    method get_status (line 799) | def get_status(self):
    method run (line 831) | def run(self, servicelist = None):
    method _lookup_services (line 849) | def _lookup_services(self, names):
    method start (line 861) | def start(self, service_names, force = False, wait = False, enable = F...
    method _queued_start (line 895) | def _queued_start(self, slist, names):
    method stop (line 902) | def stop(self, service_names, force = False, wait = False, disable = F...
    method _queued_stop (line 920) | def _queued_stop(self, slist, names, disable):
    method reset (line 930) | def reset(self, service_names, force = False, wait = False):
    method _queued_reset (line 945) | def _queued_reset(self, slist, names):
    method enable (line 953) | def enable(self, service_names):
    method disable (line 959) | def disable(self, service_names):

FILE: chaperone/cproc/watcher.py
  class InitChildWatcher (line 13) | class InitChildWatcher(BaseChildWatcher):
    method __init__ (line 19) | def __init__(self, **kwargs):
    method close (line 29) | def close(self):
    method __enter__ (line 34) | def __enter__(self):
    method __exit__ (line 40) | def __exit__(self, a, b, c):
    method number_of_waiters (line 55) | def number_of_waiters(self):
    method add_child_handler (line 58) | def add_child_handler(self, pid, callback, *args):
    method remove_child_handler (line 71) | def remove_child_handler(self, pid):
    method check_processes (line 78) | def check_processes(self):
    method _do_waitpid_all (line 82) | def _do_waitpid_all(self):

FILE: chaperone/cutil/config.py
  function IsExecutable (line 19) | def IsExecutable(v):
  function print_services (line 90) | def print_services(label, svlist):
  class _BaseConfig (line 104) | class _BaseConfig(object):
    method createConfig (line 118) | def createConfig(cls, config=None, **kwargs):
    method _typecheck_assure_bool (line 127) | def _typecheck_assure_bool(self, attr):
    method _typecheck_assure_int (line 138) | def _typecheck_assure_int(self, attr):
    method __init__ (line 148) | def __init__(self, initdict, name = "MAIN", env = None, settings = None):
    method shortname (line 193) | def shortname(self):
    method post_init (line 196) | def post_init(self):
    method augment_environment (line 199) | def augment_environment(self, env):
    method get (line 202) | def get(self, attr, default = None):
    method __repr__ (line 205) | def __repr__(self):
  class ServiceConfig (line 211) | class ServiceConfig(_BaseConfig):
    method shortname (line 255) | def shortname(self):
    method augment_environment (line 258) | def augment_environment(self, env):
    method post_init (line 262) | def post_init(self):
  class LogConfig (line 291) | class LogConfig(_BaseConfig):
    method shortname (line 310) | def shortname(self):
  class ServiceDict (line 314) | class ServiceDict(lazydict):
    method __init__ (line 318) | def __init__(self, servdict, env = None, settings = None):
    method add (line 326) | def add(self, service):
    method clear (line 329) | def clear(self):
    method get_dependency_graph (line 333) | def get_dependency_graph(self):
    method get_startup_list (line 372) | def get_startup_list(self):
  class Configuration (line 460) | class Configuration(object):
    method configFromCommandSpec (line 468) | def configFromCommandSpec(cls, spec, user = None, default = None, extr...
    method __init__ (line 503) | def __init__(self, *args, default = None, uid = None, extra_settings =...
    method _merge (line 541) | def _merge(self, items):
    method get_services (line 551) | def get_services(self):
    method get_logconfigs (line 559) | def get_logconfigs(self):
    method get_settings (line 566) | def get_settings(self):
    method update_settings (line 569) | def update_settings(self, updates):
    method get_environment (line 574) | def get_environment(self):
    method dump (line 579) | def dump(self):

FILE: chaperone/cutil/env.py
  class EnvScanner (line 39) | class EnvScanner:
    method __init__ (line 52) | def __init__(self, variable_id = None, open_expansion = None):
    method parse (line 60) | def parse(self, buf, func, *args):
  class Environment (line 134) | class Environment(lazydict):
    method set_parse_parameters (line 157) | def set_parse_parameters(cls, variable_id = None, open_expansion = None):
    method set_backtick_expansion (line 161) | def set_backtick_expansion(cls, enabled = True, cache = True):
    method __init__ (line 165) | def __init__(self, from_env = os.environ, config = None, uid = None, g...
    method _get_shadow_environment (line 241) | def _get_shadow_environment(self, var):
    method __setitem__ (line 262) | def __setitem__(self, key, value):
    method __delitem__ (line 266) | def __delitem__(self, key):
    method clear (line 270) | def clear(self):
    method _elookup (line 274) | def _elookup(self, match):
    method expand (line 278) | def expand(self, instr):
    method expand_attributes (line 296) | def expand_attributes(self, obj, *args):
    method expanded (line 310) | def expanded(self):
    method _expand_into (line 336) | def _expand_into(self, k, wholematch, result, parent = None):
    method _recurse (line 427) | def _recurse(self, result, buf, parent_var = None):
    method _backtick_expand (line 432) | def _backtick_expand(self, cmd):
    method get_public_environment (line 479) | def get_public_environment(self):

FILE: chaperone/cutil/errors.py
  class ChError (line 3) | class ChError(Exception):
    method annotate (line 10) | def annotate(self, text):
    method __str__ (line 16) | def __str__(self):
    method __init__ (line 22) | def __init__(self, message = None, errno = None):
  class ChParameterError (line 27) | class ChParameterError(ChError):
  class ChNotFoundError (line 30) | class ChNotFoundError(ChError):
  class ChSystemError (line 33) | class ChSystemError(ChError):
  class ChProcessError (line 36) | class ChProcessError(ChError):
    method __init__ (line 38) | def __init__(Self, message = None, errno = None, resultcode = None):
  class ChVariableError (line 43) | class ChVariableError(ChError):
  function get_errno_from_exception (line 46) | def get_errno_from_exception(ex):

FILE: chaperone/cutil/events.py
  function SWALLOW_EVENT (line 4) | def SWALLOW_EVENT(*args, **kwargs):
  class EventSource (line 8) | class EventSource:
    method __init__ (line 27) | def __init__(self, **kwargs):
    method __getattribute__ (line 32) | def __getattribute__(self, key):
    method _exec_kwargs (line 38) | def _exec_kwargs(self, oper, kwargs):
    method clear (line 49) | def clear(self):
    method reset (line 53) | def reset(self, **kwargs):
    method add (line 58) | def add(self, **kwargs):
    method remove (line 67) | def remove(self, **kwargs):
    method _do_add (line 76) | def _do_add(self, name, value):
    method _do_remove (line 103) | def _do_remove(self, name, value):

FILE: chaperone/cutil/format.py
  function fstr (line 1) | def fstr(s):
  class TableFormatter (line 8) | class TableFormatter(list):
    method __init__ (line 19) | def __init__(self, *args, sort=None):
    method add_rows (line 26) | def add_rows(self, rows):
    method get_formatted_data (line 33) | def get_formatted_data(self):

FILE: chaperone/cutil/logging.py
  function set_log_level (line 24) | def set_log_level(lev):
  function set_custom_handler (line 31) | def set_custom_handler(handler, enable = True):
  function _versatile_logprint (line 42) | def _versatile_logprint(delegate, fmt, *args,

FILE: chaperone/cutil/misc.py
  class objectplus (line 10) | class objectplus:
    method sharedInstance (line 18) | def sharedInstance(cls):
  class lazydict (line 25) | class lazydict(dict):
    method __init__ (line 29) | def __init__(self, *args):
    method get (line 37) | def get(self, key, default = None):
    method setdefault (line 47) | def setdefault(self, key, default = None):
    method smart_update (line 58) | def smart_update(self, key, theirs):
    method deepcopy (line 76) | def deepcopy(self):
  function maybe_remove (line 80) | def maybe_remove(fn, strict = False):
  function is_exe (line 97) | def is_exe(p):
  function executable_path (line 100) | def executable_path(fn, env = os.environ):
  function lookup_user (line 124) | def lookup_user(uid, gid = None):
  function lookup_group (line 167) | def lookup_group(gid, optional = False):
  function groupadd (line 196) | def groupadd(name, gid):
  function useradd (line 215) | def useradd(name, uid = None, gid = None, home = None):
  function userdel (line 259) | def userdel(name):
  function get_user_directories_directory (line 283) | def get_user_directories_directory():
  function maybe_create_user (line 308) | def maybe_create_user(user, uid = None, gid = None, using_file = None, d...
  function _assure_dir_for (line 384) | def _assure_dir_for(path, pwrec, gid):
  function open_foruser (line 397) | def open_foruser(filename, mode = 'r', uid = None, gid = None, exists_ok...
  function remove_for_recreate (line 424) | def remove_for_recreate(filename):
  function get_signal_name (line 435) | def get_signal_name(signum):
  function get_signal_number (line 438) | def get_signal_number(signame):

FILE: chaperone/cutil/notify.py
  class NotifyProtocol (line 12) | class NotifyProtocol(ServerProtocol):
    method datagram_received (line 14) | def datagram_received(self, data, addr):
  class NotifyListener (line 22) | class NotifyListener(Server):
    method _create_server (line 24) | def _create_server(self):
    method is_client (line 29) | def is_client(self):
    method socket_name (line 33) | def socket_name(self):
    method bind_name (line 37) | def bind_name(self):
    method __init__ (line 42) | def __init__(self, socket_name, **kwargs):
    method send (line 47) | def send(self, message):
    method server_running (line 54) | def server_running(self):
    method close (line 71) | def close(self):
  class NotifyClient (line 79) | class NotifyClient(NotifyListener):
    method is_client (line 82) | def is_client(self):
  class NotifySink (line 88) | class NotifySink:
    method __init__ (line 106) | def __init__(self):
    method level (line 111) | def level(self):
    method level (line 118) | def level(self, val):
    method enable (line 123) | def enable(self, ntype):
    method disable (line 126) | def disable(self, ntype):
    method error (line 129) | def error(self, val):
    method stopping (line 133) | def stopping(self):
    method ready (line 137) | def ready(self):
    method status (line 141) | def status(self, statmsg):
    method mainpid (line 144) | def mainpid(self):
    method sent (line 147) | def sent(self, name):
    method send (line 150) | def send(self, name, val):
    method _do_send (line 159) | def _do_send(self, msg):
    method connect (line 164) | def connect(self, socket = None):
    method close (line 190) | def close(self):

FILE: chaperone/cutil/patches.py
  function PATCH_CLASS (line 11) | def PATCH_CLASS(module, clsname, member, oldstr, newfunc):
  function NEW_process_exited (line 35) | def NEW_process_exited(self):

FILE: chaperone/cutil/proc.py
  class ProcStatus (line 4) | class ProcStatus(int):
    method __new__ (line 9) | def __new__(cls, val):
    method exited (line 20) | def exited(self):
    method signaled (line 24) | def signaled(self):
    method stopped (line 28) | def stopped(self):
    method continued (line 32) | def continued(self):
    method exit_status (line 36) | def exit_status(self):
    method normal_exit (line 43) | def normal_exit(self):
    method errno (line 47) | def errno(self):
    method errno (line 55) | def errno(self, val):
    method exit_message (line 59) | def exit_message(self):
    method signal (line 66) | def signal(self):
    method briefly (line 74) | def briefly(self):
    method __format__ (line 81) | def __format__(self, spec):

FILE: chaperone/cutil/servers.py
  class ServerProtocol (line 5) | class ServerProtocol(asyncio.Protocol):
    method buildProtocol (line 8) | def buildProtocol(cls, owner, **kwargs):
    method __init__ (line 11) | def __init__(self, owner, **kwargs):
    method connection_made (line 25) | def connection_made(self, transport):
    method error_received (line 29) | def error_received(self, exc):
    method connection_lost (line 33) | def connection_lost(self, exc):
  class Server (line 36) | class Server:
    method __init__ (line 40) | def __init__(self, **kwargs):
    method run (line 44) | def run(self):
    method server_running (line 50) | def server_running(self):
    method close (line 53) | def close(self):

FILE: chaperone/cutil/syslog.py
  class _syslog_spec_matcher (line 33) | class _syslog_spec_matcher:
    method __init__ (line 83) | def __init__(self, selector, minimum_priority = None):
    method reset_minimum_priority (line 87) | def reset_minimum_priority(self, minimum_priority = None):
    method _compile (line 94) | def  _compile(self, minimum_priority):
    method _buildex (line 112) | def _buildex(self, expr):
    method _init_spec (line 120) | def _init_spec(self, spec, neg, pos, minpri):
    method match (line 176) | def match(self, msg, prog = None, priority = syslog_info.LOG_ERR, faci...
  class SyslogServerProtocol (line 182) | class SyslogServerProtocol(ServerProtocol):
    method datagram_received (line 184) | def datagram_received(self, data, addr):
    method data_received (line 187) | def data_received(self, data):
  class SyslogServer (line 202) | class SyslogServer(Server):
    method __init__ (line 210) | def __init__(self, logsock = "/dev/log", datagram = True, **kwargs):
    method _create_server (line 221) | def _create_server(self):
    method server_running (line 233) | def server_running(self):
    method close (line 240) | def close(self):
    method configure (line 248) | def configure(self, config, minimum_priority = None):
    method reset_minimum_priority (line 255) | def reset_minimum_priority(self, minimum_priority = None):
    method capture_python_logging (line 263) | def capture_python_logging(self, enable = True):
    method parse_to_output (line 272) | def parse_to_output(self, msg):
    method writeLog (line 290) | def writeLog(self, logattrs, priority, facility):
  class SysLogFormatter (line 298) | class SysLogFormatter(logging.Formatter):
    method __init__ (line 303) | def __init__(self, program, pid):
    method format (line 310) | def format(self, record):
    method formatTime (line 317) | def formatTime(self, record, datefmt=None):
  class CustomSysLog (line 325) | class CustomSysLog(logging.Handler):
    method __init__ (line 346) | def __init__(self, owner):
    method emit (line 351) | def emit(self, record):

FILE: chaperone/cutil/syslog_handlers.py
  class LogOutput (line 13) | class LogOutput:
    method register (line 21) | def register(cls, handlercls):
    method getOutputHandlers (line 25) | def getOutputHandlers(cls, config):
    method getName (line 29) | def getName(cls, config):
    method matchesConfig (line 33) | def matchesConfig(cls, config):
    method getHandler (line 37) | def getHandler(cls, config):
    method __init__ (line 45) | def __init__(self, config):
    method close (line 49) | def close(self):
    method writeLog (line 52) | def writeLog(self, logattrs, priority, facility):
    method write (line 64) | def write(self, data):
  class StdoutHandler (line 71) | class StdoutHandler(LogOutput):
  class StderrHandler (line 80) | class StderrHandler(LogOutput):
  class RemoteClientProtocol (line 89) | class RemoteClientProtocol:
    method __init__ (line 90) | def __init__(self, loop):
    method connection_made (line 94) | def connection_made(self, transport):
    method send (line 97) | def send(self, message):
    method datagram_received (line 100) | def datagram_received(self, data, addr):
    method error_received (line 103) | def error_received(self, exc):
    method connection_lost (line 106) | def connection_lost(self, exc):
    method close (line 109) | def close(self):
  class RemoteHandler (line 114) | class RemoteHandler(LogOutput):
    method getName (line 122) | def getName(cls, config):
    method setup_handler (line 126) | def setup_handler(self):
    method __init__ (line 134) | def __init__(self, config):
    method write (line 138) | def write(self, data):
    method close (line 142) | def close(self):
  class FileHandler (line 154) | class FileHandler(LogOutput):
    method getName (line 166) | def getName(cls, config):
    method __init__ (line 169) | def __init__(self, config):
    method _maybe_reopen (line 174) | def _maybe_reopen(self):
    method close (line 200) | def close(self):
    method write (line 207) | def write(self, data):

FILE: chaperone/cutil/syslog_info.py
  function get_syslog_info (line 24) | def get_syslog_info(facility, priority):
  function syslog_to_python_lev (line 35) | def syslog_to_python_lev(lev):

FILE: chaperone/exec/chaperone.py
  function main_entry (line 86) | def main_entry():

FILE: chaperone/exec/envcp.py
  function check_canwrite (line 38) | def check_canwrite(flist, overok):
  function main_entry (line 44) | def main_entry():

FILE: chaperone/exec/sdnotify.py
  function _mkabstract (line 35) | def _mkabstract(socket_name):
  function do_notify (line 41) | def do_notify(msg):
  function main_entry (line 53) | def main_entry():

FILE: chaperone/exec/sdnotify_exec.py
  function maybe_quote (line 71) | def maybe_quote(s):
  class SDNotifyExec (line 76) | class SDNotifyExec:
    method __init__ (line 97) | def __init__(self, options):
    method info (line 145) | def info(self, msg):
    method _got_sig (line 149) | def _got_sig(self):
    method kill_program (line 152) | def kill_program(self, exitcode = None):
    method _really_kill (line 157) | def _really_kill(self):
    method _parent_closed (line 161) | def _parent_closed(self, which, ex):
    method _do_proxy_send (line 167) | def _do_proxy_send(self, name, value):
    method send_to_proxy (line 177) | def send_to_proxy(self, name, value):
    method notify_received (line 180) | def notify_received(self, which, name, value):
    method _notify_timeout (line 205) | def _notify_timeout(self):
    method _run_process (line 212) | def _run_process(self):
    method run (line 227) | def run(self):
  function main_entry (line 247) | def main_entry():

FILE: chaperone/exec/telchap.py
  function main_entry (line 21) | def main_entry():

FILE: doc/source/conf.py
  function setup (line 261) | def setup(app):

FILE: setup.py
  function read (line 12) | def read(fname):
  function get_version (line 15) | def get_version():
  function which (line 18) | def which(program):

FILE: tests/bin/daemonutil.py
  class Daemon (line 13) | class Daemon:
    method __init__ (line 18) | def __init__(self, pidfile = None):
    method daemonize (line 21) | def daemonize(self, exitwith = 0):
    method delpid (line 71) | def delpid(self):
    method start (line 74) | def start(self, exitwith = 0):
    method stop (line 96) | def stop(self):
    method restart (line 128) | def restart(self):
    method run (line 133) | def run(self):

FILE: tests/env_expand.py
  function printdict (line 158) | def printdict(d, legend = "Dict:", compare = None):
  function canonical (line 167) | def canonical(d, nl = False):
  class TestEnvOrder (line 175) | class TestEnvOrder(unittest.TestCase):
    method test_expand1 (line 179) | def test_expand1(self):
    method test_expand2 (line 186) | def test_expand2(self):
    method test_expand3 (line 193) | def test_expand3(self):
    method test_expand4 (line 200) | def test_expand4(self):
    method test_expand5 (line 207) | def test_expand5(self):
    method test_expand6 (line 217) | def test_expand6(self):
    method test_expand7 (line 229) | def test_expand7(self):
    method test_expand8 (line 236) | def test_expand8(self):

FILE: tests/env_parse.py
  class ScanTester (line 33) | class ScanTester:
    method __init__ (line 35) | def __init__(self, test):
    method run (line 39) | def run(self, tc):
    method callback (line 45) | def callback(self, buf, whole):
  class TestScanner (line 49) | class TestScanner(unittest.TestCase):
    method test_parse1 (line 51) | def test_parse1(self):

FILE: tests/events.py
  class handlers (line 5) | class handlers:
    method __init__ (line 7) | def __init__(self):
    method handler1 (line 10) | def handler1(self, val):
    method handler2 (line 13) | def handler2(self, val):
    method handler3 (line 16) | def handler3(self, val):
  class TestEvents (line 19) | class TestEvents(unittest.TestCase):
    method setUp (line 21) | def setUp(self):
    method test_event1 (line 25) | def test_event1(self):
    method test_event2 (line 39) | def test_event2(self):
    method test_event3 (line 43) | def test_event3(self):

FILE: tests/service_order.py
  function printlist (line 36) | def printlist(title, d):
  function checkorder (line 42) | def checkorder(result, *series):
  class TestServiceOrder (line 53) | class TestServiceOrder(unittest.TestCase):
    method test_order1 (line 55) | def test_order1(self):
    method test_order2 (line 63) | def test_order2(self):
    method test_order3 (line 69) | def test_order3(self):

FILE: tests/syslog_spec.py
  class TestSyslogSpec (line 28) | class TestSyslogSpec(unittest.TestCase):
    method test_specs (line 30) | def test_specs(self):