Synnefo » snf-vncauthproxy

        # Create pidfile

        pidf = pidlockfile.TimeoutPIDLockFile(opts.pid_file, 10)

        # Init ephemeral port pool

        ports = range(opts.min_port, opts.max_port + 1)

        # Init VncAuthProxy class attributes

        VncAuthProxy.server_timeout = opts.server_timeout

        VncAuthProxy.connect_retries = opts.connect_retries

        VncAuthProxy.retry_wait = opts.retry_wait

        VncAuthProxy.connect_timeout = opts.connect_timeout

        VncAuthProxy.ports = ports

        wrap_ssl = lambda sock: sock

        if opts.enable_ssl:

            ssl_prot = ssl.PROTOCOL_TLSv1

            wrap_ssl = lambda sock: ssl.wrap_socket(sock, server_side=True,

                                                    keyfile=opts.key_file,

                                                    certfile=opts.cert_file,

                                                    ssl_version=ssl_prot)

        # Become a daemon:

        # Redirect stdout and stderr to handler.stream to catch

        # early errors in the daemonization process [e.g., pidfile creation]

        # which will otherwise go to /dev/null.

        daemon_context = AllFilesDaemonContext(

            pidfile=pidf,

            umask=0022,

            stdout=handler.stream,

            stderr=handler.stream,

            files_preserve=[handler.stream])

        # Remove any stale PID files, left behind by previous invocations

        if daemon.runner.is_pidfile_stale(pidf):

            logger.warning("Removing stale PID lock file %s", pidf.path)

            pidf.break_lock()

        try:

            daemon_context.open()

        except (AlreadyLocked, LockTimeout):

            raise InternalError(("Failed to lock PID file %s, another "

                                 "instance running?"), pidf.path)

        logger.info("Became a daemon")

        # A fork() has occured while daemonizing,

        # we *must* reinit gevent

        gevent.reinit()

        # Catch signals to ensure graceful shutdown,

        #

        # Uses gevent.signal so the handler fires even during

        # gevent.socket.accept()

        gevent.signal(SIGINT, fatal_signal_handler, "SIGINT")

        gevent.signal(SIGTERM, fatal_signal_handler, "SIGTERM")

        logger.critical(err)

        logger.critical("Unexpected error:")

            logger.error("Unexpected error:")

    try:

        logger.info("Closing control sockets")

        while sockets:

            sock = sockets.pop()

            sock.close()

        daemon_context.close()

        sys.exit(0)

    except Exception as err:

        logger.critical("Unexpected error:")

        logger.exception(err)

        sys.exit(1)