Python strports.service函数代码示例

def makeService(config):
    if config['logfile']:
        logObserver = log.FileAccessLoggingObserver(config['logfile'])
    else:
        logObserver = log.DefaultCommonAccessLoggingObserver()

    if config['root']:
        if config['indexes']:
            config['root'].indexNames = config['indexes']
            
        root = log.LogWrapperResource(config['root'])


    s = Web2Service(logObserver)

    site = server.Site(root)
    chan = channel.HTTPFactory(site)
    
    if config['https']:
        from twisted.internet.ssl import DefaultOpenSSLContextFactory
        i = internet.SSLServer(int(config['https']), chan,
                               DefaultOpenSSLContextFactory(config['privkey'],
                                                            config['certificate']))
        i.setServiceParent(s)
        
    strports.service(config['port'], chan
                     ).setServiceParent(s)

    return s

def makeService(config):
    s = service.MultiService()
    if config['root']:
        root = config['root']
        if config['indexes']:
            config['root'].indexNames = config['indexes']
    else:
        # This really ought to be web.Admin or something
        root = demo.Test()

    if isinstance(root, static.File):
        root.registry.setComponent(interfaces.IServiceCollection, s)

    if config['logfile']:
        site = server.Site(root, logPath=config['logfile'])
    else:
        site = server.Site(root)

    site.displayTracebacks = not config["notracebacks"]

    if config['personal']:
        personal = strports.service(
            config['port'], makePersonalServerFactory(site))
        personal.setServiceParent(s)
    else:
        if config['https']:
            from twisted.internet.ssl import DefaultOpenSSLContextFactory
            i = internet.SSLServer(int(config['https']), site,
                          DefaultOpenSSLContextFactory(config['privkey'],
                                                       config['certificate']))
            i.setServiceParent(s)
        strports.service(config['port'], site).setServiceParent(s)

    return s

    def test_serviceDeprecatedDefault(self):
        """
        L{strports.service} still accepts a 'default' argument, which will
        affect the parsing of 'default' (i.e. 'not containing a colon')
        endpoint descriptions, but this behavior is deprecated.
        """
        svc = strports.service("8080", None, "unix")
        self.assertIsInstance(svc.endpoint, UNIXServerEndpoint)
        warnings = self.flushWarnings([self.test_serviceDeprecatedDefault])
        self.assertEqual(warnings[0]['category'], DeprecationWarning)
        self.assertEqual(
            warnings[0]['message'],
            "The 'default' parameter was deprecated in Twisted 10.2.0.  "
            "Use qualified endpoint descriptions; for example, 'tcp:8080'.")
        self.assertEqual(len(warnings), 1)

        # Almost the same case, but slightly tricky - explicitly passing the
        # old default value, None, also must trigger a deprecation warning.
        svc = strports.service("tcp:8080", None, None)
        self.assertIsInstance(svc.endpoint, TCP4ServerEndpoint)
        warnings = self.flushWarnings([self.test_serviceDeprecatedDefault])
        self.assertEqual(warnings[0]['category'], DeprecationWarning)
        self.assertEqual(
            warnings[0]['message'],
            "The 'default' parameter was deprecated in Twisted 10.2.0.")
        self.assertEqual(len(warnings), 1)

def makeService (config_global, config, ) :
    sys.path.insert(0, config_global.get("root"), )
    os.environ["DJANGO_SETTINGS_MODULE"] = config.get("django-settings")

    _ms = service.MultiService()

    # `HTTP` interface
    _resource = RootResource()
    _resource.putChild("file", FileResource(config.get("file-directory"), ), )

    strports.service(
        "tcp:%d%s" % (
            config.get("file-port"),
            config_global.get("interface"),
        ),
        HTTPFactory(
                _resource,
                is_stand="--nodaemon" in sys.argv or "-n" in sys.argv,
                quite=config_global.get("quite"),
            ),
    ).setServiceParent(_ms, )

    XMPPClient(
            "[email protected]%s" % config_global.get("hostname"),
            "io.data",
            host=config_global.get("xmpp-host"),
            port=config_global.get("xmpp-port"),
            file_directory=config.get("file-directory"),
        ).setServiceParent(_ms, )

    return _ms

    def makeService(self, options):
        master = Master(options)

        web = Web(master)
        strports.service(options["web"], web).setServiceParent(master)

        return master

def makeService(config):
    s = service.MultiService()

    router = component.Router()

    # Set up the XMPP server service

    serverService = server.ServerService(router, secret=config['server-secret'])
    serverService.domains = config['domains']
    serverService.logTraffic = config['verbose']

    # Hook up XMPP server-to-server service
    s2sFactory = server.XMPPS2SServerFactory(serverService)
    s2sFactory.logTraffic = config['verbose']
    s2sService = strports.service(config['server-port'], s2sFactory)
    s2sService.setServiceParent(s)

    # Hook up XMPP external server-side component service
    cFactory = component.XMPPComponentServerFactory(router,
                                                    config['component-secret'])

    cFactory.logTraffic = config['verbose']
    cServer = strports.service(config['component-port'], cFactory)
    cServer.setServiceParent(s)

    return s

 def __init__(self, relayport, transitport, advertise_version):
     service.MultiService.__init__(self)
     self.db = get_db("relay.sqlite")
     welcome = {
         "current_version": __version__,
         # adding .motd will cause all clients to display the message,
         # then keep running normally
         #"motd": "Welcome to the public relay.\nPlease enjoy this service.",
         #
         # adding .error will cause all clients to fail, with this message
         #"error": "This server has been disabled, see URL for details.",
         }
     if advertise_version:
         welcome["current_version"] = advertise_version
     self.root = Root()
     site = server.Site(self.root)
     self.relayport_service = strports.service(relayport, site)
     self.relayport_service.setServiceParent(self)
     self.relay = Relay(self.db, welcome) # accessible from tests
     self.root.putChild("wormhole-relay", self.relay)
     t = internet.TimerService(EXPIRATION_CHECK_PERIOD,
                               self.relay.prune_old_channels)
     t.setServiceParent(self)
     if transitport:
         self.transit = Transit()
         self.transit.setServiceParent(self) # for the timer
         self.transport_service = strports.service(transitport, self.transit)
         self.transport_service.setServiceParent(self)

def makeService(config):
	from twisted.internet import reactor, task

	multi = service.MultiService()

	domain = config['domain']
	mutils.maybeWarnAboutDomain(reactor, domain)

	closureLibrary = FilePath(config['closure-library'])
	mutils.maybeWarnAboutClosureLibrary(reactor, closureLibrary)

	socketPorts = []
	for minervaStrport in config['minerva']:
		_, _args, _ = strports.parse(minervaStrport, object())
		socketPorts.append(_args[0])

	doReloading = bool(int(os.environ.get('PYRELOADING', '0')))
	fileCache = FileCache(lambda: reactor.seconds(), 0.1 if doReloading else -1)
	stf, httpSite = demosminerva_site.makeMinervaAndHttp(
		reactor, fileCache, socketPorts, domain, closureLibrary)
	httpSite.displayTracebacks = not config["no-tracebacks"]

	for httpStrport in config['http']:
		httpServer = strports.service(httpStrport, httpSite)
		httpServer.setServiceParent(multi)

	for minervaStrport in config['minerva']:
		minervaServer = strports.service(minervaStrport, stf)
		minervaServer.setServiceParent(multi)

	if doReloading:
		mutils.enablePyquitter(reactor)

	return multi

def makeService(config):
    from twisted.internet import reactor

    multi = service.MultiService()

    domain = config['domain']
    mutils.maybeWarnAboutDomain(reactor, domain)

    closureLibrary = FilePath(config['closure-library'])
    mutils.maybeWarnAboutClosureLibrary(reactor, closureLibrary)

    socketPorts = []
    for minervaStrport in config['minerva']:
            _, _args, _ = strports.parse(minervaStrport, object())
            socketPorts.append(_args[0])

    fileCache = FileCache(lambda: reactor.seconds(), -1)
    stf, httpSite = site.setupMinerva(
            reactor, fileCache, socketPorts, domain, closureLibrary
    )
    httpSite.displayTracebacks = not config["no-tracebacks"]

    for httpStrport in config['http']:
            httpServer = strports.service(httpStrport, httpSite)
            httpServer.setServiceParent(multi)

    for minervaStrport in config['minerva']:
            minervaServer = strports.service(minervaStrport, stf)
            minervaServer.setServiceParent(multi)

    return multi

def makeService(options):
    """Create a manhole server service.

    @type options: C{dict}
    @param options: A mapping describing the configuration of
    the desired service.  Recognized key/value pairs are::

        "telnetPort": strports description of the address on which
                      to listen for telnet connections.  If None,
                      no telnet service will be started.

        "sshPort": strports description of the address on which to
                   listen for ssh connections.  If None, no ssh
                   service will be started.

        "namespace": dictionary containing desired initial locals
                     for manhole connections.  If None, an empty
                     dictionary will be used.

        "passwd": Name of a passwd(5)-format username/password file.

    @rtype: L{twisted.application.service.IService}
    @return: A manhole service.
    """

    svc = service.MultiService()

    namespace = options['namespace']
    if namespace is None:
        namespace = {}

    checker = checkers.FilePasswordDB(options['passwd'])

    if options['telnetPort']:
        telnetRealm = _StupidRealm(telnet.TelnetBootstrapProtocol,
                                   insults.ServerProtocol,
                                   manhole.ColoredManhole,
                                   namespace)

        telnetPortal = portal.Portal(telnetRealm, [checker])

        telnetFactory = protocol.ServerFactory()
        telnetFactory.protocol = makeTelnetProtocol(telnetPortal)
        telnetService = strports.service(options['telnetPort'],
                                         telnetFactory)
        telnetService.setServiceParent(svc)

    if options['sshPort']:
        sshRealm = manhole_ssh.TerminalRealm()
        sshRealm.chainedProtocolFactory = chainedProtocolFactory(namespace)

        sshPortal = portal.Portal(sshRealm, [checker])
        sshFactory = manhole_ssh.ConchFactory(sshPortal)
        sshService = strports.service(options['sshPort'],
                                      sshFactory)
        sshService.setServiceParent(svc)

    return svc

def makeService(config):
    """
    Set up the otter-api service.
    """
    s = MultiService()
    core = MimicCore.fromPlugins(Clock())
    root = MimicRoot(core)
    site = Site(root.app.resource())
    site.displayTracebacks = False
    service(config['listen'], site).setServiceParent(s)
    return s

 def makeService(self, options):
     s = MultiService()
     tps = ThreadPoolService()
     tps.setServiceParent(s)
     site = Site(
         RootResource(
             store=Store(options['dbdir']),
             steamKey=options['steamkey'],
             paypalSandbox=options['paypal-sandbox'],
             threadPool=tps.threadpool))
     strports.service(options['port'], site).setServiceParent(s)
     return s

def makeService(config):
    computername = unicode(os.popen("/usr/sbin/networksetup -getcomputername",
                                    "r").readlines()[0]).strip()
    s = service.MultiService()

    for host_config in config['hosts']:

        prepareMultiService(s, host_config)

        if host_config['vhosts']:

            vhost_root = vhost.NameVirtualHost()
            vhost_root.default = host_config['root']

            for vhost_config in host_config['vhosts']:

                prepareMultiService(s, vhost_config)

                vhost_root.addHost(vhost_config['fqdn'], vhost_config['root'])

            host_config['root'] = vhost_root

        if config['logfile']:
            site = server.Site(host_config['root'], logPath=config['logfile'])
        else:
            site = server.Site(host_config['root'])

        site.displayTracebacks = not config["notracebacks"]

        if not host_config['shape'] is None:
            site.protocol = shaper.gen_token_bucket(site.protocol,
                                                    *host_config['shape'])

        port = host_config['port']
        if ":" in str(host_config['port']):
            port = host_config['port'].split(':', 2)[1]
        port = int(port)

        if not host_config['bonjour']:
            host_config['bonjour'].append(u"Mediacast-Webserver (%s on port %d)")

        for bonjour_desc in host_config['bonjour']:
            if '%s' in bonjour_desc and '%d' in bonjour_desc:
                bonjour_desc %= (computername, port)
            elif '%s' in bonjour_desc:
                bonjour_desc %= computername
            elif '%d' in bonjour_desc:
                bonjour_desc %= port
            bonjour.mDNSService(bonjour_desc, "_http._tcp", port).setServiceParent(s)

        strports.service(host_config['port'], site).setServiceParent(s)

    return s

 def makeService(self, options):
     """
     Construct a TCPServer from a factory defined in myproject.
     """
     player = Player(reactor)
     reactor.addSystemEventTrigger("before", "shutdown", player.kill)
     s = service.MultiService()
     payload_service = strports.service(options["payload"],                                   
                                        CustomServer(PayloadProtocol, player))
     payload_service.setServiceParent(s)
     control_service = strports.service(options["control"],
                                        CustomServer(ControlProtocol, player))
     control_service.setServiceParent(s)
     return s

    def startService(self):
        def chainedProtocolFactory():
            def getManhole():
                return Manhole({"store": self.store})

            protocol = insults.ServerProtocol(ColoredManhole)
            protocol.protocolFactory = getManhole
            return protocol

        checker = checkers.InMemoryUsernamePasswordDatabaseDontUse(**{str(self.username): self.password})
        realm = TerminalRealm()
        realm.chainedProtocolFactory = chainedProtocolFactory
        p = portal.Portal(realm, [checker])
        strports.service(self.listen, ConchFactory(p)).setServiceParent(self.parent)