def startApplication(self, application):
        """
        Configure global process state based on the given application and run
        the application.

        @param application: An object which can be adapted to
            L{service.IProcess} and L{service.IService}.
        """
        process = service.IProcess(application)
        if not self.config['originalname']:
            launchWithName(process.processName)
        self.setupEnvironment(
            self.config['chroot'], self.config['rundir'],
            self.config['nodaemon'], self.config['umask'],
            self.config['pidfile'])

        service.IService(application).privilegedStartService()

        uid, gid = self.config['uid'], self.config['gid']
        if uid is None:
            uid = process.uid
        if gid is None:
            gid = process.gid

        self.shedPrivileges(self.config['euid'], uid, gid)
        app.startApplication(application, not self.config['no_save'])

def siptrackd_twisted_init(object_store, application):
    log.msg('Loading object store, this might take a while')
    yield object_store.init()
    log.msg('Object store loading complete')
    log.msg('Starting rpc listener')
    app.startApplication(application, False)
    log.msg('Running')

def daemon():
    from twisted.internet import glib2reactor
    glib2reactor.install()
    from twisted.internet import reactor

    main_app = Application("Audio Failure Monitor") #, uid, gid)

    services = IServiceCollection(main_app)
    options = DaemonOptions()
    options.parseOptions()

    application = options.getService()
    application.infotub.setServiceParent(services)
    application.coretub.setServiceParent(services)

    app.startApplication(main_app, False)

    reactor.addSystemEventTrigger('before', 'shutdown',
                                  logging.getLogger(__name__).info,
                                  'Stopping AFM')

    logging.getLogger(__name__).info("AFM Started")
    try:
        reactor.run()
    except KeyboardInterrupt:
        reactor.stop()

def execute(config_file):
    global config
    config = _get_config(config_file)
    log.startLogging(sys.stderr)
    application = get_application(config)
    app.startApplication(application, False)
    reactor.run() #@UndefinedVariable

 def handle_noargs(self, *args, **options):
     ## ! XXX: `from django.utils import autoreload`?  Might put it into
     ## xmppface or xmppwoker
     from xmppface.s2scfg import cfg_override
     from xmppface.s2sbase import setup_twisted_app
     application = setup_twisted_app(cfg_override(settings))
     startApplication(application, False)
     reactor.run()

 def runApp(res):
     """
     Start the actual service Application.
     """
     log.debug("[D] %s %s " % (__file__, __name__), "Class GLBaseRunner", "preApplication", "runApp")
     service.IService(self.application).privilegedStartService()
     app.startApplication(self.application, not self.config['no_save'])
     app.startApplication(internet.TimerService(0.1, lambda:None), 0)
     startAsynchronous()

 def postApplication(self):
     """
     Start the application and run the reactor.
     """
     service.IService(self.application).privilegedStartService()
     app.startApplication(self.application, not self.config['no_save'])
     app.startApplication(internet.TimerService(0.1, lambda:None), 0)
     self.startReactor(None, self.oldstdout, self.oldstderr)
     log.msg("Server Shut Down.")

def execute():
    try:
        config = _get_config()
    except NotConfigured:
        config = None
    log.startLogging(sys.stderr)
    application = get_application(config)
    app.startApplication(application, False)
    reactor.run()

 def postApplication(self):
     """
     Start the application and run the reactor.
     """
     service.IService(self.application).privilegedStartService()
     app.startApplication(self.application, not self.config['no_save'])
     app.startApplication(internet.TimerService(0.1, lambda:None), 0)
     app.runReactorWithLogging(self.config, self.oldstdout, self.oldstderr)
     app.reportProfile(self.config['report-profile'],
                       service.IProcess(self.application).processName)
     log.msg("Server Shut Down.")

def run():
    if platform.system() != "Windows":
        if not sys.modules.has_key('twisted.internet.reactor'):
                print "installing poll reactor"
                pollreactor.install()
        else:
                print "poll reactor already installed"
    from twisted.internet import reactor
    application = makeApplication(sys.argv)
    app.startApplication(application, None)
    from twisted.internet import pollreactor
    reactor.run()

 def start(self, portno=None):
     import sys
     lfname = self['logfile']
     if lfname == '-':
         lf = sys.stdout
     else:
         lf = file(os.path.expanduser(lfname), 'ab+')
     log.startLogging(lf,
                      setStdout=False)
     srv = self.getService()
     from twisted.application.app import startApplication
     startApplication(srv, False)
     reactor.run()

def run(appName):
    application = service.Application(appName)

    from sparked import tap
    config = tap.Options()
    config.parseOptions(sys.argv[1:])
    svc = tap.makeService(config)
    svc.setServiceParent(application)

    app.startApplication(application, False)
    log.addObserver(log.FileLogObserver(sys.stdout).emit)

    reactor.run()

def run():
    twisted_log.startLogging(sys.stdout)
    if platform.system() != "Windows":
        if 'twisted.internet.reactor' not in sys.modules:
            log.debug("installing epoll reactor")
            from twisted.internet import epollreactor
            epollreactor.install()
        else:
            log.debug("reactor already installed")
    from twisted.internet import reactor
    application = makeApplication(sys.argv)
    app.startApplication(application, None)
    reactor.run()

def execute():
    sys.path.insert(0, os.getcwd())
    arguments = parse_arguments()
    if arguments.settings:
        settings.setmodule(arguments.settings)
    if arguments.set:
        for name, value in arguments.set:
            settings.set(name.upper(), value)
    settings.set('PROJECT_SETTINGS', find_scrapy_project(arguments.project))
    settings.freeze()
    setup_logging()
    application = get_application(arguments)
    app.startApplication(application, save=False)
    reactor.run()

def start_services(config):
    client = XMPPClient(jid.internJID(config.credentials['jid']), config.credentials['password'])

    application = service.Application('commitbot')

    bot = CommitBot(config)
    bot.setHandlerParent(client)

    site = server.Site(WebHook(config, bot))
    tcp_server = reactor.listenTCP(8888, site)

    app.startApplication(application, None)
    client.startService()

    reactor.run()

        def _inner_run():
            # Initialize logging
            log.startLogging(sys.stdout)

            # Setup Twisted application
            application = service.Application('django')
            wsgi_root = wsgi_resource()
            root = Root(wsgi_root)

            main_site = server.Site(root)
            internet.TCPServer(int(self.port), main_site
                    ).setServiceParent(application)

            service.IService(application).startService()
            app.startApplication(application, False)

            reactor.addSystemEventTrigger('before', 'shutdown',
                    service.IService(application).stopService)

            reactor.run()

    def SvcDoRun(self):
        import servicemanager
        from LJSocket import SocketServiceFactory, DeviceManager
        import ljsocketServiceTac
        
        self.CheckForQuit()
        
        try:
            f = file("C:\LJSocket.log", 'w')
        except:
            f = file("LJSocket.log", 'w')

        from twisted.python.log import startLogging
        from twisted.application.app import startApplication
        from twisted.internet import reactor        
        startLogging(f)
        startApplication(ljsocketServiceTac.application, 0)
        #reactor.run()

        reactor.run(installSignalHandlers=0)

        def _inner_run():
            # Initialize logging
            log.startLogging(sys.stdout)

            # Setup Twisted application
            application = service.Application('django')
            root = Root(wsgi_resource())

            # Handle static files
            root.putChild('static', StaticFileFinder('/'))
            main_site = server.Site(root)
            internet.TCPServer(int(self.port), main_site).setServiceParent(application)

            service.IService(application).startService()
            app.startApplication(application, False)

            reactor.addSystemEventTrigger('before', 'shutdown',
                    service.IService(application).stopService)
            self._start_bebop(use_repl)

            reactor.run()

def run():
    application = makeApplication(sys.argv[1:])
    app.startApplication(application, None)
    reactor.run()

 def test_startApplication(self):
     appl = service.Application("lala")
     app.startApplication(appl, 0)
     self.assert_(service.IService(appl).running)