def context_serve(options, context): """ Takes a context object, which implements the __enter__/__exit__ "with" interface and starts a server within that context. This method is a refactored single-place for handling the server-run code whether running in daemon or non-daemon mode. It is invoked with a dummy (passthrough) context object for the non-daemon use case. @param options: The compiled collection of options that need to be parsed. @type options: C{ConfigParser} @param context: The context object that implements __enter__/__exit__ "with" methods. @type context: C{object} @raise Exception: Any underlying exception will be logged but then re-raised. @see: server_from_config() """ server = None try: with context: # There's a possibility here that init_logging() will throw an exception. If it does, # AND we're in a daemon context, then we're not going to be able to do anything with it. # We've got no stderr/stdout here; and so (to my knowledge) no reliable (& cross-platform), # way to display errors. level = logging.DEBUG if options.debug else logging.INFO init_logging(logfile=options.logfile, loglevel=level, configfile=options.configfile) server = server_from_config() logger().info("Stomp server listening on %s:%s" % server.server_address) server.serve_forever() except (KeyboardInterrupt, SystemExit): logger().info("Stomp server stopped by user interrupt.") raise SystemExit() except Exception, e: logger().error("Stomp server stopped due to error: %s" % e) logger().exception(e) raise SystemExit()
def context_serve(context, configfile, listen_addr, listen_port, logfile, debug, daemon, uid, gid, pidfile, umask, rundir): """ Takes a context object, which implements the __enter__/__exit__ "with" interface and starts a server within that context. This method is a refactored single-place for handling the server-run code whether running in daemon or non-daemon mode. It is invoked with a dummy (passthrough) context object for the non-daemon use case. @param options: The compiled collection of options that need to be parsed. @type options: C{ConfigParser} @param context: The context object that implements __enter__/__exit__ "with" methods. @type context: C{object} @raise Exception: Any underlying exception will be logged but then re-raised. @see: server_from_config() """ global global_config server = None try: with context: # There's a possibility here that init_logging() will throw an exception. If it does, # AND we're in a daemon context, then we're not going to be able to do anything with it. # We've got no stderr/stdout here; and so (to my knowledge) no reliable (& cross-platform), # way to display errors. level = logging.DEBUG if debug else logging.INFO init_logging(logfile=logfile, loglevel=level, configfile=configfile) server = server_from_config() logger.info("Stomp server listening on %s:%s" % server.server_address) if debug: poll_interval = float(global_config.get( 'coilmq', 'debug.stats_poll_interval')) if poll_interval: # Setting poll_interval to 0 effectively disables it. def diagnostic_loop(server): log = logger while True: log.debug( "Stats heartbeat -------------------------------") store = server.queue_manager.store for dest in store.destinations(): log.debug("Queue %s: size=%s, subscribers=%s" % ( dest, store.size(dest), server.queue_manager.subscriber_count(dest))) # TODO: Add number of subscribers? time.sleep(poll_interval) diagnostic_thread = threading.Thread( target=diagnostic_loop, name='DiagnosticThread', args=(server,)) diagnostic_thread.daemon = True diagnostic_thread.start() server.serve_forever() except (KeyboardInterrupt, SystemExit): logger.info("Stomp server stopped by user interrupt.") raise SystemExit() except Exception as e: logger.error("Stomp server stopped due to error: %s" % e) logger.exception(e) raise SystemExit() finally: if server: server.server_close()
def context_serve(options, context): """ Takes a context object, which implements the __enter__/__exit__ "with" interface and starts a server within that context. This method is a refactored single-place for handling the server-run code whether running in daemon or non-daemon mode. It is invoked with a dummy (passthrough) context object for the non-daemon use case. @param options: The compiled collection of options that need to be parsed. @type options: C{ConfigParser} @param context: The context object that implements __enter__/__exit__ "with" methods. @type context: C{object} @raise Exception: Any underlying exception will be logged but then re-raised. @see: server_from_config() """ global global_config server = None try: with context: # There's a possibility here that init_logging() will throw an exception. If it does, # AND we're in a daemon context, then we're not going to be able to do anything with it. # We've got no stderr/stdout here; and so (to my knowledge) no reliable (& cross-platform), # way to display errors. level = logging.DEBUG if options.debug else logging.INFO init_logging(logfile=options.logfile, loglevel=level, configfile=options.configfile) server = server_from_config() logger().info("Stomp server listening on %s:%s" % server.server_address) if options.debug: poll_interval = float( global_config.get('coilmq', 'debug.stats_poll_interval')) if poll_interval: # Setting poll_interval to 0 effectively disables it. def diagnostic_loop(server): log = logger() while True: log.debug( "Stats heartbeat -------------------------------" ) store = server.queue_manager.store for dest in store.destinations(): log.debug( "Queue %s: size=%s, subscribers=%s" % (dest, store.size(dest), server.queue_manager.subscriber_count( dest))) # TODO: Add number of subscribers? time.sleep(poll_interval) diagnostic_thread = threading.Thread( target=diagnostic_loop, name='DiagnosticThread', args=(server, )) diagnostic_thread.daemon = True diagnostic_thread.start() server.serve_forever() except (KeyboardInterrupt, SystemExit): logger().info("Stomp server stopped by user interrupt.") raise SystemExit() except Exception, e: logger().error("Stomp server stopped due to error: %s" % e) logger().exception(e) raise SystemExit()