def start_forwarder_backend(): if parse_bool(config.get_conf('beah-backend').get('DEFAULT', 'DEVEL')): print_this = log_this(lambda s: log.debug(s), log_on=True) make_class_verbose(ForwarderBackend, print_this) make_class_verbose(_RemoteBackend, print_this) backend = ForwarderBackend() # Start a default TCP client: start_backend(backend) return backend
def start_watchdog_backend(conf): '''Starts a watchdog backend with specified configuration.''' log = logging.getLogger('backend') if parse_bool(conf.get('DEFAULT', 'DEVEL')): print_this = log_this(log.debug, log_on=True) make_class_verbose(WatchdogBackend, print_this) make_class_verbose(Task, print_this) handlers = dict(DEFAULT_HANDLERS) load_plugins(WATCHDOG_ENTRYPOINT, handlers) backend = WatchdogBackend(conf=conf, log=log, handlers=handlers) query_interval = int(conf.get('DEFAULT', 'QUERY_WATCHDOG')) if query_interval > 0: watchdogs_request = LoopingCall(backend.query_watchdogs) watchdogs_request.start(query_interval, now=False) #pylint: disable=E1101 reactor.addSystemEventTrigger('before', 'shutdown', watchdogs_request.stop) # Start a default TCP client: backend.initialize() start_backend(backend)
def main(): ################################################################################ # EXECUTE: ################################################################################ global conf, runtime, uploader, results conf = conf_main({}, sys.argv[1:]) name = conf['name'] var_path = os.path.join(conf['root'], VAR_PATH, name) runtime = runtimes.ShelveRuntime(os.path.join(var_path, "runtime")) log = logging.getLogger('beah_fakelc') twisted_logging(log, level=logging.WARNING) # FIXME: redirect to console or syslog? misc.make_log_handler(log, os.path.join(conf['root'], LOG_PATH), "%s.log" % name) log.setLevel(misc.str2log_level(conf.get('LOG', 'warning'))) if conf.get('DEVEL', False): print_this = log_this.log_this(lambda s: log.debug(s), log_on=True) # make the classes verbose: misc.make_class_verbose(LCRecipes, print_this) misc.make_class_verbose(LCRecipeTasks, print_this) misc.make_class_verbose(LCHandler, print_this) lc = LCHandler() lc.XMLRPC_TIMEOUT = safe_int(conf['timeout'], 0) s = server.Site(lc, None, 60 * 60 * 12) reactor.listenTCP(conf['port'], s, interface='') # To support testing in IPv6 and mixed IPv4/IPv6 environments, # we attempt to listen on the specified (defaults to IPv6) # interface as well. try: reactor.listenTCP(conf['port'], s, interface=conf['interface']) except CannotListenError: pass reactor.addSystemEventTrigger("before", "shutdown", close, log) upload_path = os.path.join(var_path, "fakelc-uploads") results = Results(var_path, upload_path) uploader = Uploader(upload_path) reactor.run()
def main(): ################################################################################ # EXECUTE: ################################################################################ global conf, runtime, uploader, results conf = conf_main({}, sys.argv[1:]) name = conf['name'] var_path = os.path.join(conf['root'], VAR_PATH, name) runtime = runtimes.ShelveRuntime(os.path.join(var_path, "runtime")) log = logging.getLogger('beah_fakelc') twisted_logging(log, level=logging.WARNING) # FIXME: redirect to console or syslog? misc.make_log_handler(log, os.path.join(conf['root'], LOG_PATH), "%s.log" % name) log.setLevel(misc.str2log_level(conf.get('LOG', 'warning'))) if conf.get('DEVEL', False): print_this = log_this.log_this(lambda s: log.debug(s), log_on=True) # make the classes verbose: misc.make_class_verbose(LCRecipes, print_this) misc.make_class_verbose(LCRecipeTasks, print_this) misc.make_class_verbose(LCHandler, print_this) lc = LCHandler() lc.XMLRPC_TIMEOUT = safe_int(conf['timeout'], 0) s = server.Site(lc, None, 60*60*12) reactor.listenTCP(conf['port'], s, interface='') # To support testing in IPv6 and mixed IPv4/IPv6 environments, # we attempt to listen on the specified (defaults to IPv6) # interface as well. try: reactor.listenTCP(conf['port'], s, interface=conf['interface']) except CannotListenError: pass reactor.addSystemEventTrigger("before", "shutdown", close, log) upload_path = os.path.join(var_path, "fakelc-uploads") results = Results(var_path, upload_path) uploader = Uploader(upload_path) reactor.run()
def start_server(conf=None, backend_host=None, backend_port=None, backend_adaptor=BackendAdaptor_JSON, task_host=None, task_port=None, task_adaptor=TaskAdaptor_JSON, spawn=None): # CONFIG: if not conf: config.beah_conf() conf = config.get_conf('beah') # LOGGING: twisted_logging(log, level=logging.WARNING) log.setLevel(str2log_level(conf.get('CONTROLLER', 'LOG'))) # Create a directory for runtime # FIXME: should try to create a temp path if following fails: ensuredir(conf.get('CONTROLLER', 'VAR_ROOT')) # Create a directory for logging and check permissions lp = conf.get('CONTROLLER', 'LOG_PATH') make_log_handler(log, lp, conf.get('CONTROLLER', 'LOG_FILE_NAME'), syslog=True, console=conf.get('CONTROLLER', 'CONSOLE_LOG', False)) if parse_bool(config.get_conf('beah').get('CONTROLLER', 'DEVEL')): print_this = log_this(log.debug, True) make_class_verbose(Controller, print_this) make_class_verbose(MasterTask, print_this) # RUN: backend_host = backend_host or conf.get('BACKEND', 'INTERFACE') backend_port = backend_port or conf.get('BACKEND', 'PORT') task_host = task_host or conf.get('TASK', 'INTERFACE') task_port = task_port or int(conf.get('TASK', 'PORT')) if os.name == 'posix': if backend_port != '': backend_port = int(backend_port) backend_socket = conf.get('BACKEND', 'SOCKET') if task_port != '': task_port = int(task_port) task_socket = conf.get('TASK', 'SOCKET') else: backend_port = int(backend_port) backend_socket = '' task_port = int(task_port) task_socket = '' runtime = runtimes.ShelveRuntime(conf.get('CONTROLLER', 'RUNTIME_FILE_NAME')) runtime.vars = runtimes.TypeDict(runtime, 'vars') runtime.tasks = runtimes.TypeDict(runtime, 'tasks') controller = Controller(spawn or Spawn(task_host, task_port, socket=task_socket), runtime=runtime) def on_killed(): if not controller.backends: reactor.stop() return reactor.callLater(2, reactor.stop) controller.on_killed = on_killed log.info("################################") log.info("# Starting a Controller... #") log.info("################################") backend_listener = BackendListener(controller, backend_adaptor) if backend_port != '': if backend_host == 'localhost': listening = listen_loopback_tcp(backend_port, backend_listener) elif backend_host: listening = reactor.listenTCP(backend_port, backend_listener, interface=backend_host) else: listening = listen_all_tcp(backend_port, backend_listener, ipv6_disabled=parse_bool(conf.get('DEFAULT', 'IPV6_DISABLED'))) log.info("Controller: BackendListener listening on %s port %s", listening.getHost().host, listening.getHost().port) if backend_socket: if os.path.exists(backend_socket): # clean-up after e.g. system crash: log.warning("Controller: BackendListener cleaning %s", backend_socket) os.remove(backend_socket) log.info("Controller: BackendListener listening on %s", backend_socket) reactor.listenUNIX(backend_socket, backend_listener) task_listener = TaskListener(controller, task_adaptor) if task_port != '': if task_host == 'localhost': listening = listen_loopback_tcp(task_port, task_listener) elif task_host: listening = reactor.listenTCP(task_port, task_listener, interface=task_host) else: listening = listen_all_tcp(task_port, task_listener, ipv6_disabled=parse_bool(conf.get('DEFAULT', 'IPV6_DISABLED'))) log.info("Controller: TaskListener listening on %s port %s", listening.getHost().host, listening.getHost().port) if task_socket: if os.path.exists(task_socket): # clean-up after e.g. system crash: log.warning("Controller: TaskListener cleaning %s", task_socket) os.remove(task_socket) log.info("Controller: TaskListener listening on %s", task_socket) reactor.listenUNIX(task_socket, task_listener) return controller
def start_server(conf=None, backend_host=None, backend_port=None, backend_adaptor=BackendAdaptor_JSON, task_host=None, task_port=None, task_adaptor=TaskAdaptor_JSON, spawn=None): # CONFIG: if not conf: config.beah_conf() conf = config.get_conf('beah') # LOGGING: twisted_logging(log, level=logging.WARNING) log.setLevel(str2log_level(conf.get('CONTROLLER', 'LOG'))) # Create a directory for runtime # FIXME: should try to create a temp path if following fails: ensuredir(conf.get('CONTROLLER', 'VAR_ROOT')) # Create a directory for logging and check permissions lp = conf.get('CONTROLLER', 'LOG_PATH') make_log_handler(log, lp, conf.get('CONTROLLER', 'LOG_FILE_NAME'), syslog=True, console=conf.get('CONTROLLER', 'CONSOLE_LOG', False)) if parse_bool(config.get_conf('beah').get('CONTROLLER', 'DEVEL')): print_this = log_this(log.debug, True) make_class_verbose(Controller, print_this) make_class_verbose(MasterTask, print_this) # RUN: backend_host = backend_host or conf.get('BACKEND', 'INTERFACE') backend_port = backend_port or conf.get('BACKEND', 'PORT') task_host = task_host or conf.get('TASK', 'INTERFACE') task_port = task_port or int(conf.get('TASK', 'PORT')) if os.name == 'posix': if backend_port != '': backend_port = int(backend_port) backend_socket = conf.get('BACKEND', 'SOCKET') if task_port != '': task_port = int(task_port) task_socket = conf.get('TASK', 'SOCKET') else: backend_port = int(backend_port) backend_socket = '' task_port = int(task_port) task_socket = '' runtime = runtimes.ShelveRuntime( conf.get('CONTROLLER', 'RUNTIME_FILE_NAME')) runtime.vars = runtimes.TypeDict(runtime, 'vars') runtime.tasks = runtimes.TypeDict(runtime, 'tasks') controller = Controller(spawn or Spawn(task_host, task_port, socket=task_socket), runtime=runtime) def on_killed(): if not controller.backends: reactor.stop() return reactor.callLater(2, reactor.stop) controller.on_killed = on_killed log.info("################################") log.info("# Starting a Controller... #") log.info("################################") backend_listener = BackendListener(controller, backend_adaptor) if backend_port != '': if backend_host == 'localhost': listening = listen_loopback_tcp(backend_port, backend_listener) elif backend_host: listening = reactor.listenTCP(backend_port, backend_listener, interface=backend_host) else: listening = listen_all_tcp(backend_port, backend_listener, ipv6_disabled=parse_bool( conf.get('DEFAULT', 'IPV6_DISABLED'))) log.info("Controller: BackendListener listening on %s port %s", listening.getHost().host, listening.getHost().port) if backend_socket: if os.path.exists(backend_socket): # clean-up after e.g. system crash: log.warning("Controller: BackendListener cleaning %s", backend_socket) os.remove(backend_socket) log.info("Controller: BackendListener listening on %s", backend_socket) reactor.listenUNIX(backend_socket, backend_listener) task_listener = TaskListener(controller, task_adaptor) if task_port != '': if task_host == 'localhost': listening = listen_loopback_tcp(task_port, task_listener) elif task_host: listening = reactor.listenTCP(task_port, task_listener, interface=task_host) else: listening = listen_all_tcp(task_port, task_listener, ipv6_disabled=parse_bool( conf.get('DEFAULT', 'IPV6_DISABLED'))) log.info("Controller: TaskListener listening on %s port %s", listening.getHost().host, listening.getHost().port) if task_socket: if os.path.exists(task_socket): # clean-up after e.g. system crash: log.warning("Controller: TaskListener cleaning %s", task_socket) os.remove(task_socket) log.info("Controller: TaskListener listening on %s", task_socket) reactor.listenUNIX(task_socket, task_listener) return controller
self.rem_call(p, 'retry_set', True, (2,)) self.rem_call(p, 'retry', True, args=(), repeat=repeatingproxy.repeatAlways) self.rem_call(p, 'retry_set', True, (3,)) self.rem_call(p, 'retry', False, args=(), repeat=repeatingproxy.repeatTimes(2)) return p.when_idle() def test02NotSerializing(self): reactor.callLater(0, self.startServer) p = self.proxy p.serializing = False p.set_timeout(repeatingproxy.IncreasingTimeout(p.DELAY_TIMEOUT, factor=p.TIMEOUT_FACTOR)) self.handler.retries = 2 self.rem_call(p, 'test', True) self.rem_call(p, 'test', True) self.rem_call(p, 'test2', False) self.rem_call(p, 'test_exc', False) self.rem_call(p, 'test_exc2', False) self.rem_call(p, 'test_long_call', True, (p.LONG_CALL,)) self.rem_call(p, 'test_long_call', True, (2*p.LONG_CALL,)) self.rem_call(p, 'retry', True, args=(), repeat=repeatingproxy.repeatAlways) return p.when_idle() if VERBOSE: repeatingproxy.RepeatingProxy._VERBOSE = repeatingproxy.RepeatingProxy._VERBOSE + repeatingproxy.RepeatingProxy._MORE_VERBOSE make_class_verbose(repeatingproxy.RepeatingProxy, print_this) make_class_verbose(TestHandler, print_this) make_class_verbose(TestRepeatingProxy, print_this)