Esempio n. 1
0
def worker(options):
    """
    Start background worker process.
    """
    workerPid = os.getpid()

    if not options.noaffinity:
        p = psutil.Process(workerPid)
        print "affinity [before]", p.cpu_affinity()
        p.cpu_affinity([options.cpuid])
        print "affinity [after]", p.cpu_affinity()

    factory = EchoServerFactory(options.wsuri)

    # The master already created the socket, just start listening and accepting
    ##
    reactor.adoptStreamPort(options.fd, AF_INET, factory)

    if not options.silence:
        print "Worker started on PID %s using factory %s and protocol %s" % (workerPid, factory, factory.protocol)
        # print "Worker %d PYPYLOG=%s" % (workerPid, os.environ.get('PYPYLOG', None))

    if options.profile:
        statprof.reset(PROFILER_FREQ)
        statprof.start()

    if not options.silence:
        def stat():
            if options.profile:
                statprof.stop()

            output = StringIO.StringIO()
            output.write("-" * 80 + "\n")
            output.write("Worker Statistics (PID %s)\n\n%s" % (workerPid, factory.stats.stats()))

            if options.profile:
                output.write("\n")
                # format = statprof.DisplayFormats.ByLine
                # format = statprof.DisplayFormats.ByMethod
                # statprof.display(output, format = format)
                statprof.display(output)

            output.write("-" * 80 + "\n\n")

            sys.stdout.write(output.getvalue())

            if options.profile:
                statprof.reset(PROFILER_FREQ)
                statprof.start()

            reactor.callLater(options.interval, stat)

        reactor.callLater(options.interval, stat)

    if False:
        import cProfile
        print "RUNNING cProfile"
        cProfile.run('reactor.run()')
    else:
        reactor.run()
Esempio n. 2
0
    def run(self):
        self.factory = HTTPFactory(
            self.channel_layer,
            self.action_logger,
            timeout=self.http_timeout,
            websocket_timeout=self.websocket_timeout,
            ping_interval=self.ping_interval,
            ws_protocols=self.ws_protocols,
            root_path=self.root_path,
        )
        # Redirect the Twisted log to nowhere
        globalLogBeginner.beginLoggingTo([lambda _: None], redirectStandardIO=False, discardBuffer=True)
        # Listen on a socket
        if self.unix_socket:
            reactor.listenUNIX(self.unix_socket, self.factory)
        elif self.file_descriptor:
            # socket returns the same socket if supplied with a fileno
            sock = socket.socket(fileno=self.file_descriptor)
            reactor.adoptStreamPort(self.file_descriptor, sock.family, self.factory)
        else:
            reactor.listenTCP(self.port, self.factory, interface=self.host)

        if "twisted" in self.channel_layer.extensions:
            logging.info("Using native Twisted mode on channel layer")
            reactor.callLater(0, self.backend_reader_twisted)
        else:
            logging.info("Using busy-loop synchronous mode on channel layer")
            reactor.callLater(0, self.backend_reader_sync)
        reactor.callLater(2, self.timeout_checker)
        reactor.run(installSignalHandlers=self.signal_handlers)
Esempio n. 3
0
def standalone():
    """
    Initializes Tornado and our application.  Forks worker processes to handle
    requests.  Does not return until all child processes exit normally.
    """

    # Parse arguments
    parser = argparse.ArgumentParser(description="Homer web server")
    parser.add_argument("--background", action="store_true", help="Detach and run server in background")
    parser.add_argument("--worker-processes", default=1, type=int)
    parser.add_argument("--shared-http-fd", default=None, type=int)
    parser.add_argument("--process-id", default=0, type=int)
    args = parser.parse_args()

    # We don't initialize logging until we fork because we want each child to
    # have its own logging and it's awkward to reconfigure logging that is
    # defined by the parent.
    application = create_application()

    if args.background:
        # Get a new logfile, rotating the old one if present.
        err_log_name = os.path.join(settings.LOGS_DIR, settings.LOG_FILE_PREFIX + "-err.log")
        try:
            os.rename(err_log_name, err_log_name + ".old")
        except OSError:
            pass
        # Fork into background.
        utils.daemonize(err_log_name)

    # Drop a pidfile.
    pid = os.getpid()
    with open(settings.PID_FILE, "w") as pidfile:
        pidfile.write(str(pid) + "\n")

    utils.install_sigusr1_handler(settings.LOG_FILE_PREFIX)

    # Setup logging
    logging_config.configure_logging(args.process_id)

    # setup accumulators and counters for statistics gathering
    api.base.setupStats(args.process_id, args.worker_processes)

    if args.shared_http_fd:
        reactor.adoptStreamPort(args.shared_http_fd, AF_INET, application)
    else:
        # Cyclone
        _log.info("Going to listen for HTTP on port %s", settings.HTTP_PORT)
        http_port = reactor.listenTCP(settings.HTTP_PORT, application, interface=settings.LOCAL_IP)

        for process_id in range(1, args.worker_processes):
            reactor.spawnProcess(None, executable, [executable, __file__,
                                 "--shared-http-fd", str(http_port.fileno()),
                                 "--process-id", str(process_id)],
                                 childFDs={0: 0, 1: 1, 2: 2, http_port.fileno(): http_port.fileno()},
                                 env = os.environ)

    # Kick off the reactor to start listening on configured ports
    reactor.run()
Esempio n. 4
0
def run_server(fd=None, port=None, procs=None, verbose=False):
    if args.verbose:
        log.startLogging(stdout)
        environ['SOLEDAD_LOG_TO_STDOUT'] = '1'

    config = get_config()
    path = config["blobs_path"]
    if not port:
        port = int(config["blobs_port"])

    root = Resource()
    root.putChild('blobs', BlobsResource("filesystem", path))
    factory = Site(root)

    if fd is None:
        # Create a new listening port and several other
        # processes to help out.
        if procs is None:
            procs = cpu_count()
        log.msg('A total of %d processes will listen on port %d.' % (procs, port))
        port = reactor.listenTCP(port, factory)
        for i in range(procs - 1):
            reactor.spawnProcess(
                None, executable, [executable, __file__, str(port.fileno())],
                childFDs={0: 0, 1: 1, 2: 2, port.fileno(): port.fileno()},
                env=environ)
    else:
        # Another process created the port, just start listening on it.
        log.msg('Adopting file descriptor %d...' % fd)
        port = reactor.adoptStreamPort(fd, AF_INET, factory)

    reactor.run()
 def child(self, fd):
   """
     Reactor child instance configure
   """
   # Attach to the existing port instance                                                                         
   port = reactor.adoptStreamPort(
     fd, 
     AF_INET, 
     ReceiverFactory()
   )
Esempio n. 6
0
    def start(self, fd=None):
        pids = [str(os.getpid())]  # script pid

        if fd is None:
            # anything in this block is only run once

            # TODO add global services here, possibly add a services kwarg on
            # __init__
            self.addGlobalServices()

            self.hendrix.startService()
            if self.options['workers']:
                # Create a new listening port and several other processes to help out.
                childFDs = {0: 0, 1: 1, 2: 2}
                self.fds = {}
                for name in self.servers:
                    port = self.hendrix.get_port(name)
                    fd = port.fileno()
                    childFDs[fd] = fd
                    self.fds[name] = fd

                args = self.getSpawnArgs()
                transports = []
                for i in range(self.options['workers']):
                    transport = reactor.spawnProcess(
                        None, executable, args, childFDs=childFDs, env=environ
                    )
                    transports.append(transport)
                    pids.append(str(transport.pid))
            with open(self.pid, 'w') as pid_file:
                pid_file.write('\n'.join(pids))
        else:
            # Another process created the port, drop the tcp service and
            # just start listening on it.
            fds = pickle.loads(fd)
            factories = {}
            for name in self.servers:
                factory = self.disownService(name)
                factories[name] = factory
            self.hendrix.startService()
            for name, factory in factories.iteritems():
                if name == 'main_web_ssl':
                    privateCert = PrivateCertificate.loadPEM(
                        open(self.options['cert']).read() + open(self.options['key']).read()
                    )
                    factory = TLSMemoryBIOFactory(
                        privateCert.options(), False, factory
                    )
                port = reactor.adoptStreamPort(fds[name], AF_INET, factory)

        reactor.run()
Esempio n. 7
0
def main(fd=None):
    resource = WSGIResource(reactor, reactor.getThreadPool(), app)

    if fd is None:
        # Create a new listening port and several other processes to help out.
        port = reactor.listenTCP(8080, Site(resource))

        for i in range(3):
            reactor.spawnProcess(
                None, executable, [executable, __file__, str(port.fileno())],
                childFDs={0: 0, 1: 1, 2: 2, port.fileno(): port.fileno()},
                env=environ
            )
    else:
        # Another process created the port, just start listening on it.
        port = reactor.adoptStreamPort(fd, AF_INET, Site(resource))

    reactor.run()
Esempio n. 8
0
    def startService(self):
        # use socket creation from twisted to use the same options as before
        if hasattr(self.protocol, 'datagramReceived'):
            tmp_port = udp.Port(None, None, interface=self.interface)
        else:
            tmp_port = tcp.Port(None, None, interface=self.interface)
        carbon_sock = tmp_port.createInternetSocket()
        if hasattr(socket, 'SO_REUSEPORT'):
            carbon_sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEPORT, 1)
        carbon_sock.bind((self.interface, self.port))

        if hasattr(self.protocol, 'datagramReceived'):
            self._port = reactor.adoptDatagramPort(
                carbon_sock.fileno(), socket.AF_INET, self.protocol())
        else:
            carbon_sock.listen(tmp_port.backlog)
            self._port = reactor.adoptStreamPort(
                carbon_sock.fileno(), socket.AF_INET, self.factory)
        carbon_sock.close()
Esempio n. 9
0
        self.ClientNum=0
        self.ClientList={}

if __name__=='__main__':
    RootCheck=PasswordCheck()
    Accessdata=open(r'accessfile.txt','r')
    data=Accessdata.read()
    Accessdata.close()
    login_name=None
    login_passwd=None
    while 1:
        login_name=raw_input("Please enter your login name:")
        login_passwd=getpass.getpass('Please enter your login passed:')
        login_Mess=[login_name,data]
        RootCheck.password=login_passwd
        if RootCheck.PasswdCheck(login_Mess):
            break
    del RootCheck
    Jsonh=JsonHandle()
    dbpool=adbapi.ConnectionPool('MySQLdb',db='Nautidoidea',user=login_name,passwd=login_passwd,host='127.0.0.1')
    log.startLogging(open(r'/Nautiloidea.log'),'w')
    factory=TCPServerFactory()
    factory.protocol=TCPServerProtocol
    print "Server start!"
    portSocket=socket(AF_INET,SOCK_STREAM)
    portSocket.setblocking(False)
    portSocket.bind("192.168.1.107",9990)
    portSocket.listen(SOMAXCONN)
    reactor.adoptStreamPort(portSocket.fileno(),AF_INET,factory)
    portSocket.close()
    reactor.run()
Esempio n. 10
0
def standalone():
    """
    Initializes Tornado and our application.  Forks worker processes to handle
    requests.  Does not return until all child processes exit normally.
    """
    # Hack to work-around issue with Cyclone and UNIX domain sockets
    twisted.internet.address.UNIXAddress.host = "localhost"

    # Parse arguments
    parser = argparse.ArgumentParser(description="Crest web server")
    parser.add_argument("--background", action="store_true", help="Detach and run server in background")
    parser.add_argument("--signaling-namespace", action="store_true", help="Server running in signaling namespace")
    parser.add_argument("--worker-processes", default=1, type=int)
    parser.add_argument("--shared-http-tcp-fd", default=None, type=int)
    parser.add_argument("--process-id", default=0, type=int)
    args = parser.parse_args()

    # Set process name.
    prctl.prctl(prctl.NAME, settings.PROCESS_NAME)

    # We don't initialize logging until we fork because we want each child to
    # have its own logging and it's awkward to reconfigure logging that is
    # defined by the parent.
    application = create_application()

    if args.background:
        # Get a new logfile, rotating the old one if present.
        err_log_name = os.path.join(settings.LOGS_DIR, settings.LOG_FILE_PREFIX + "-err.log")
        try:
            os.rename(err_log_name, err_log_name + ".old")
        except OSError:
            pass
        # Fork into background.
        utils.daemonize(err_log_name)

    utils.install_sigusr1_handler(settings.LOG_FILE_PREFIX)

    # Setup logging
    syslog.openlog(settings.LOG_FILE_PREFIX, syslog.LOG_PID)
    logging_config.configure_logging(settings.LOG_LEVEL, settings.LOGS_DIR, settings.LOG_FILE_PREFIX, args.process_id)
    twisted.python.log.addObserver(on_twisted_log)

    pdlogs.CREST_STARTING.log()

    # setup accumulators and counters for statistics gathering
    api.base.setupStats(args.process_id, args.worker_processes)

    # Initialize reactor ports and create worker sub-processes
    if args.process_id == 0:
        # Main process startup, create pidfile.

        # We must keep a reference to the file object here, as this keeps
        # the file locked and provides extra protection against two processes running at
        # once.
        pidfile_lock = None
        try:
            pidfile_lock = utils.lock_and_write_pid_file(settings.PID_FILE) # noqa
        except IOError:
            # We failed to take the lock - another process is already running
            exit(1)

        # Create UNIX domain socket for nginx front-end (used for
        # normal operation and as a bridge from the default namespace to the signaling
        # namespace in a multiple interface configuration).
        bind_safely(reactor, args.process_id, application)
        pdlogs.CREST_UP.log()

        if args.signaling_namespace and settings.PROCESS_NAME == "homer":
            # Running in signaling namespace as Homer, create TCP socket for XDMS requests
            # from signaling interface
            _log.info("Going to listen for HTTP on TCP port %s", settings.HTTP_PORT)
            http_tcp_port = reactor.listenTCP(settings.HTTP_PORT, application, interface=settings.LOCAL_IP)

            # Spin up worker sub-processes, passing TCP file descriptor
            for process_id in range(1, args.worker_processes):
                reactor.spawnProcess(None, executable, [executable, __file__,
                                     "--shared-http-tcp-fd", str(http_tcp_port.fileno()),
                                     "--process-id", str(process_id)],
                                     childFDs={0: 0, 1: 1, 2: 2, http_tcp_port.fileno(): http_tcp_port.fileno()},
                                     env = os.environ)
        else:
            # Spin up worker sub-processes
            for process_id in range(1, args.worker_processes):
                reactor.spawnProcess(None, executable, [executable, __file__,
                                     "--process-id", str(process_id)],
                                     childFDs={0: 0, 1: 1, 2: 2},
                                     env = os.environ)
    else:
        # Sub-process startup, ensure we die if our parent does.
        prctl.prctl(prctl.PDEATHSIG, signal.SIGTERM)

        # Create UNIX domain socket for nginx front-end based on process ID.
        bind_safely(reactor, args.process_id, application)

        # Create TCP socket if file descriptor was passed.
        if args.shared_http_tcp_fd:
            reactor.adoptStreamPort(args.shared_http_tcp_fd, AF_INET, application)

    # We need to catch the shutdown request so that we can properly stop
    # the ZMQ interface; otherwise the reactor won't shut down on a SIGTERM
    # and will be SIGKILLed when the service is stopped.
    reactor.addSystemEventTrigger('before', 'shutdown', on_before_shutdown)

    # Kick off the reactor to start listening on configured ports
    reactor.run()
Esempio n. 11
0
def standalone():
    """
    Initializes Tornado and our application.  Forks worker processes to handle
    requests.  Does not return until all child processes exit normally.
    """
    # Hack to work-around issue with Cyclone and UNIX domain sockets
    twisted.internet.address.UNIXAddress.host = "localhost"

    # Parse arguments
    parser = argparse.ArgumentParser(description="Homer web server")
    parser.add_argument("--background", action="store_true", help="Detach and run server in background")
    parser.add_argument("--signaling-namespace", action="store_true", help="Server running in signaling namespace")
    parser.add_argument("--worker-processes", default=1, type=int)
    parser.add_argument("--shared-http-tcp-fd", default=None, type=int)
    parser.add_argument("--process-id", default=0, type=int)
    args = parser.parse_args()

    # We don't initialize logging until we fork because we want each child to
    # have its own logging and it's awkward to reconfigure logging that is
    # defined by the parent.
    application = create_application()

    if args.background:
        # Get a new logfile, rotating the old one if present.
        err_log_name = os.path.join(settings.LOGS_DIR, settings.LOG_FILE_PREFIX + "-err.log")
        try:
            os.rename(err_log_name, err_log_name + ".old")
        except OSError:
            pass
        # Fork into background.
        utils.daemonize(err_log_name)

    # Drop a pidfile.
    pid = os.getpid()
    with open(settings.PID_FILE, "w") as pidfile:
        pidfile.write(str(pid) + "\n")

    utils.install_sigusr1_handler(settings.LOG_FILE_PREFIX)

    # Setup logging
    logging_config.configure_logging(settings.LOG_LEVEL, settings.LOGS_DIR, settings.LOG_FILE_PREFIX, args.process_id)

    # setup accumulators and counters for statistics gathering
    api.base.setupStats(args.process_id, args.worker_processes)

    # Initialize reactor ports and create worker sub-processes
    if args.process_id == 0:
        # Main process startup, create UNIX domain socket for nginx front-end (used for
        # normal operation and as a bridge from the default namespace to the signaling
        # namespace in a multiple interface configuration).
        _lock_fd = bind_safely(reactor, args.process_id, application)

        if args.signaling_namespace and settings.PROCESS_NAME == "homer":
            # Running in signaling namespace as Homer, create TCP socket for XDMS requests
            # from signaling interface
            _log.info("Going to listen for HTTP on TCP port %s", settings.HTTP_PORT)
            http_tcp_port = reactor.listenTCP(settings.HTTP_PORT, application, interface=settings.LOCAL_IP)

            # Spin up worker sub-processes, passing TCP file descriptor
            for process_id in range(1, args.worker_processes):
                reactor.spawnProcess(None, executable, [executable, __file__,
                                     "--shared-http-tcp-fd", str(http_tcp_port.fileno()),
                                     "--process-id", str(process_id)],
                                     childFDs={0: 0, 1: 1, 2: 2, http_tcp_port.fileno(): http_tcp_port.fileno()},
                                     env = os.environ)
        else:
            # Spin up worker sub-processes
            for process_id in range(1, args.worker_processes):
                reactor.spawnProcess(None, executable, [executable, __file__,
                                     "--process-id", str(process_id)],
                                     childFDs={0: 0, 1: 1, 2: 2},
                                     env = os.environ)
    else:
        # Sub-process startup, create UNIX domain socket for nginx front-end based on
        # process ID.
        _lock_fd = bind_safely(reactor, args.process_id, application)

        # Create TCP socket if file descriptor was passed.
        if args.shared_http_tcp_fd:
            reactor.adoptStreamPort(args.shared_http_tcp_fd, AF_INET, application)

    # Kick off the reactor to start listening on configured ports
    reactor.run()
Esempio n. 12
0
def worker(options, socket, factory):

    workerPid = os.getpid()
    port = reactor.adoptStreamPort(socket.fileno(), AF_INET, factory)
    reactor.run()
Esempio n. 13
0
                               interface=conf.LISTEN)
    os.environ['ADOPTED_STREAM'] = str(stream.fileno())

    supervisor = GlobalSupervisor()
    supervisor.setServiceParent(application)

    heroku_unidling_supervisor = HerokuUnidlingSupervisor()
    heroku_unidling_supervisor.setServiceParent(application)

    if conf.MULTIPROCESS > 0:
        m = MultiProcess(__file__,
                         number=conf.MULTIPROCESS,
                         fds=[stream.fileno()])
        m.setServiceParent(application)
else:
    reactor.adoptStreamPort(int(conf.ADOPTED_STREAM), AF_INET, app)

metrics_supervisor = MetricsSupervisor()
metrics_supervisor.setServiceParent(application)

xmpp_keepalive_supervisor = XMPPKeepAliveSupervisor()
xmpp_keepalive_supervisor.setServiceParent(application)

KatooAPNSService().service.setServiceParent(application)

if conf.REDIS_WORKERS > 0:
    worker.LOGGING_OK_JOBS = conf.LOGGING_OK_JOBS
    worker.SLEEP_CALL = sleep
    worker.MAX_RETRIES = conf.BACKEND_MAX_RETRIES
    worker.MAX_DELAY_TIME = conf.BACKEND_MAX_DELAY
def worker(options):
    """
    Start background worker process.
    """
    workerPid = os.getpid()

    if not options.noaffinity:
        p = psutil.Process(workerPid)
        print "affinity [before]", p.get_cpu_affinity()
        p.set_cpu_affinity([options.cpuid])
        print "affinity [after]", p.get_cpu_affinity()

    factory = EchoServerFactory(options.wsuri, debug=options.debug)

    # The master already created the socket, just start listening and accepting
    ##
    reactor.adoptStreamPort(options.fd, AF_INET, factory)

    if not options.silence:
        print "Worker started on PID %s using factory %s and protocol %s" % (
            workerPid, factory, factory.protocol)
        # print "Worker %d PYPYLOG=%s" % (workerPid, os.environ.get('PYPYLOG', None))

    if options.profile:
        statprof.reset(PROFILER_FREQ)
        statprof.start()

    if not options.silence:

        def stat():
            if options.profile:
                statprof.stop()

            output = StringIO.StringIO()
            output.write("-" * 80 + "\n")
            output.write("Worker Statistics (PID %s)\n\n%s" %
                         (workerPid, factory.stats.stats()))

            if options.profile:
                output.write("\n")
                # format = statprof.DisplayFormats.ByLine
                # format = statprof.DisplayFormats.ByMethod
                # statprof.display(output, format = format)
                statprof.display(output)

            output.write("-" * 80 + "\n\n")

            sys.stdout.write(output.getvalue())

            if options.profile:
                statprof.reset(PROFILER_FREQ)
                statprof.start()

            reactor.callLater(options.interval, stat)

        reactor.callLater(options.interval, stat)

    if False:
        import cProfile
        print "RUNNING cProfile"
        cProfile.run('reactor.run()')
    else:
        reactor.run()
Esempio n. 15
0
def worker(options):
    """
   Start background worker process.
   """
    workerPid = os.getpid()

    payload = "*" * options.payload

    if options.resource == 'file':
        f = open('index.html', 'wb')
        f.write(payload)
        f.close()
        root = static.File('.')

    elif options.resource == 'data':
        root = static.Data(payload, 'text/html')

    elif options.resource == 'fixed':
        root = FixedResource(payload)

    else:
        raise Exception("logic error")

    if not options.silence:
        print "Worker started on PID %s using resource %s" % (workerPid, root)

    if not options.silence:
        site = CountingSite(root)
    else:
        site = Site(root)
    site.log = lambda _: None  # disable any logging

    ## The master already created the socket, just start listening and accepting
    ##
    port = reactor.adoptStreamPort(options.fd, AF_INET, site)

    if options.profile:
        statprof.start()

    if not options.silence:

        def stat():
            if options.profile:
                statprof.stop()

            output = StringIO.StringIO()
            output.write("-" * 80)
            output.write("\nWorker with PID %s processed %d requests\n" %
                         (workerPid, site.cnt))

            if options.profile:
                output.write("\n")
                #format = statprof.DisplayFormats.ByLine
                #format = statprof.DisplayFormats.ByMethod
                #statprof.display(output, format = format)
                statprof.display(output)

            output.write("-" * 80)
            output.write("\n")
            output.write("\n")

            sys.stdout.write(output.getvalue())

            if options.profile:
                statprof.reset()
                statprof.start()

            reactor.callLater(options.interval, stat)

        reactor.callLater(options.interval, stat)

    reactor.run()
Esempio n. 16
0
def worker(options):
   """
   Start background worker process.
   """
   workerPid = os.getpid()

   payload = "*" * options.payload

   if options.resource == 'file':
      f = open('index.html', 'wb')
      f.write(payload)
      f.close()
      root = static.File('.')

   elif options.resource == 'data':
      root = static.Data(payload, 'text/html')

   elif options.resource == 'fixed':
      root = FixedResource(payload)

   else:
      raise Exception("logic error")

   if not options.silence:
      print "Worker started on PID %s using resource %s" % (workerPid, root)

   if not options.silence:
      site = CountingSite(root)
   else:
      site = Site(root)
   site.log = lambda _: None # disable any logging
 
   ## The master already created the socket, just start listening and accepting
   ##
   port = reactor.adoptStreamPort(options.fd, AF_INET, site)

   if options.profile:
      statprof.start()

   if not options.silence:
      def stat():
         if options.profile:
            statprof.stop()

         output = StringIO.StringIO()
         output.write("-" * 80)
         output.write("\nWorker with PID %s processed %d requests\n"  % (workerPid, site.cnt))

         if options.profile:
            output.write("\n")
            #format = statprof.DisplayFormats.ByLine
            #format = statprof.DisplayFormats.ByMethod
            #statprof.display(output, format = format)
            statprof.display(output)

         output.write("-" * 80)
         output.write("\n")
         output.write("\n")

         sys.stdout.write(output.getvalue())

         if options.profile:
            statprof.reset()
            statprof.start()

         reactor.callLater(options.interval, stat)

      reactor.callLater(options.interval, stat)

   reactor.run()
Esempio n. 17
0
def listenTCPonExistingFD(reactor, fd, factory):
    return reactor.adoptStreamPort(fd, socket.AF_INET, factory)