Exemple #1
0
def get_server():
    if ENSURE_DAEMON:
        ensure_daemon()

    manager = get_ServerManager()
    manager.connect()
    return manager.Server()
Exemple #2
0
def aRunningServer(request, mocker):
    mocker.patch('taskqueue.client.ENSURE_DAEMON', False)

    sm = taskqueue.get_ServerManager(make_server=True)
    logging.info("Opening a socket at %s", sm.address)
    sm.start()
    request.addfinalizer(sm.shutdown)
    return sm.Server()
Exemple #3
0
def daemonize():
    "Start a daemonized taskqueue"
    import daemon

    try:
        # make tqdaemon a bit nicer than whatever parent launched us.
        os.nice(4)
    except:
        pass

    # Before daemonizing figure out which handlers we want to keep.
    # We only want to keep handlers for this library that aren't going
    # to stderr or stdout
    other_handlers = set(logging._handlerList)
    fds = []
    l = logger
    while l:
        for h in l.handlers:
            if hasattr(h, 'stream') and \
              hasattr(h.stream, 'fileno') and \
              h.stream.fileno() not in [1,2]:
                fds.append(h.stream.fileno())
                other_handlers.discard(h)
        l = l.propagate and l.parent

    # Kill of any other loggers
    logging.raiseExceptions = False
    logger.debug("Killing other loggers")
    logging.shutdown(list(other_handlers))

    pidfile = get_pidfile()
    check_for_process(pidfile.read_pid())
    if pidfile.is_locked():
        logger.error("Daemon already running")
        return INSTANCE_ALREADY_RUNNING
    else:
        logger.debug("Daemonizing, pidfile: %r", pidfile.path)
    try:
        with daemon.DaemonContext(
                pidfile=pidfile, files_preserve=fds, detach_process=True):
            logging.raiseExceptions = True
            try:
                import setproctitle
                import taskqueue
                setproctitle.setproctitle(taskqueue.PROC_TITLE)
                logger.debug(
                    "Successfully setproctitle: %r", taskqueue.PROC_TITLE)
            except:
                logger.exception("Couldn't setproctitle.")
                pass

            import taskqueue.server
            logger.info("Daemonized context")
            sm = taskqueue.get_ServerManager(make_server=True)
            sm.get_server().serve_forever()
    finally:
        logger.warning("Exiting (hopefully intentionally)")
Exemple #4
0
def getexecutor(name):
    sm = None
    name = name.lower()
    try:
        if name == 'server':
            from taskqueue import get_ServerManager
            sm = get_ServerManager(make_server=True, logger=True)
            logging.info("Opening a socket at %s", sm.address)
            sm.start()
            e = sm.Server()
        elif name == 'inline':
            e = executors.InlineExecutor()
        elif name == 'daemon':
            from taskqueue import client
            e = client.get_server()
        yield e
    finally:
        if sm:
            sm.shutdown()
Exemple #5
0
def async_executor(request):
    taskqueue.LISTEN_ADDRESS = ('127.0.1.1', 57129)
    sm = taskqueue.get_ServerManager(make_server=True)
    sm.start()
    request.addfinalizer(sm.shutdown)
    return sm.Server()
Exemple #6
0
def run():
    "Start the server in the foreground instead of as a daemon"
    import taskqueue.server
    logger.info("Running in foreground forever")
    taskqueue.get_ServerManager(make_server=True).get_server().serve_forever()