def makeService(self, options): srv = service.MultiService() s = None if options["app"]: app = reflect.namedAny(options["app"]) else: app = App # http s = internet.TCPServer(options["port"], app(options), interface=options["listen"]) s.setServiceParent(srv) # https if options["use-ssl"]: if ssl_support: s = internet.SSLServer(options["ssl-port"], app(options), ssl.DefaultOpenSSLContextFactory( options["ssl-key"], options["ssl-cert"]), interface=options["ssl-listen"]) s.setServiceParent(srv) else: print("SSL is not supported. Please install PyOpenSSL.") if s is None: print("Nothing to do. Try --help") sys.exit(1) return srv
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(self, options): if options['data-dir'] != None: if not os.access(options['data-dir'], os.X_OK | os.W_OK): raise core.SmapException("Cannot access " + options['data-dir']) smapconf.SERVER['DataDir'] = options['data-dir'] inst = loader.load(options['conf']) # override defaults with command-line args smapconf.SERVER.update( dict([(k.lower(), v) for (k, v) in options.iteritems() if v != None])) if 'SuggestThreadPool' in smapconf.SERVER: reactor.suggestThreadPoolSize( int(smapconf.SERVER['SuggestThreadPool'])) inst.start() reactor.addSystemEventTrigger('before', 'shutdown', inst.stop) site = getSite(inst, docroot=smapconf.SERVER['docroot']) service = MultiService() # add HTTP and HTTPS servers to the twisted multiservice if 'port' in smapconf.SERVER: service.addService( internet.TCPServer(int(smapconf.SERVER['port']), site)) if 'sslport' in smapconf.SERVER: service.addService( internet.SSLServer(int(smapconf.SERVER['sslport']), site, SslServerContextFactory(smapconf.SERVER))) return service
def makeService(): s = service.MultiService() f = protocol.ServerFactory() f.protocol = ProtocolSwitcher f.clients = [] f.gameDB = GameDB() f.db = Database() h = internet.TCPServer(settings.port, f).setServiceParent(s) h = internet.SSLServer( settings.ssl_port, f, ssl.DefaultOpenSSLContextFactory( settings.ssl_key, settings.ssl_cert)).setServiceParent(s) # Debug add some games # for i in xrange(30): # game = f.gameDB.create(4, True) # f.gameDB.updateGame(game['gameId'], { # "host" : "localhost", # "port" : 2100, # "description" : "Test %d" % i, # "currentPlayers" : 1, # "maxPlayers" : 3, # "multiVer" : "None existend test", # "wzVerMajor" : 4, # "wzVerMinor" : 11012, # "isPrivate" : True, # "modlist" : "", # "mapname" : "Sk-Rush-T1", # "hostplayer" : "Test %d" % i, # }) return s
def get_service(self): from twisted.application import service, internet top_service = service.MultiService() internet.UDPServer( self.authport, self.auth_protocol, interface=self.radiusd_host).setServiceParent(top_service) internet.UDPServer( self.acctport, self.acct_protocol, interface=self.radiusd_host).setServiceParent(top_service) if self.use_ssl: log.msg('WS SSL Enable!') from twisted.internet import ssl sslContext = ssl.DefaultOpenSSLContextFactory( self.privatekey, self.certificate) internet.SSLServer( self.adminport, self.admin_factory, contextFactory=sslContext, interface=self.radiusd_host).setServiceParent(top_service) else: log.msg('WS SSL Disable!') internet.TCPServer( self.adminport, self.admin_factory, interface=self.radiusd_host).setServiceParent(top_service) return top_service
def startService(self): """ This sets up the OpenNSA service and ties together everything in the initialization. There are a lot of things going on, but none of it it particular deep. """ log.msg('OpenNSA service initializing', system='opennsa.setup') vc = self.vc topology_sources = [ open(tf) for tf in vc[config.TOPOLOGY_FILE] ] topology, internal_topology = gole.parseTopology(topology_sources, open(vc[config.NRM_MAP_FILE]) if vc[config.NRM_MAP_FILE] else None ) if vc[config.HOST] is None: import socket vc[config.HOST] = socket.getfqdn() ctx_factory = None if vc[config.TLS]: from opennsa import ctxfactory ctx_factory = ctxfactory.ContextFactory(vc[config.KEY], vc[config.CERTIFICATE], vc[config.CERTIFICATE_DIR], vc[config.VERIFY_CERT]) backend = setupBackend(vc['backend'], vc[config.NETWORK_NAME], internal_topology) factory = createService(vc[config.NETWORK_NAME], backend, topology, vc[config.HOST], vc[config.PORT], vc[config.WSDL_DIRECTORY]) if vc[config.TLS]: internet.SSLServer(vc[config.PORT], factory, ctx_factory).setServiceParent(self) else: internet.TCPServer(vc[config.PORT], factory).setServiceParent(self) # do not start sub-services until we have started this one twistedservice.MultiService.startService(self) log.msg('OpenNSA service started')
def read_listeners_in_config(config_file, apns_daemon, service_parent): """ Reads the config file and return all the listeners in it one by one. """ if not os.path.isfile(config_file): import sys print >> sys.stderr, "Config Path: %s" % os.environ("APNSD_CONFIG_DIR") raise errors.ConfigFileError(config_file, "File not found: %s" % config_file) configs = eval(open(config_file).read()) if 'listeners' not in configs: raise errors.ConfigFileError(config_file, "'listeners' section not found") listeners = configs['listeners'] for listener_name in listeners: listener_data = listeners[listener_name] listener_class = listener_data['class'] listener_class = importClass(listener_class) logging.debug("Creating listener: " + str(listener_class)) listener = listener_class(apns_daemon, **listener_data) if listener_data.get("secure", False): server = internet.SSLServer(listener_data["port"], listener) else: server = internet.TCPServer(listener_data["port"], listener) server.setServiceParent(service_parent) logging.debug("Listener Created: " + str(listener)) apns_daemon.registerListener(listener_name, listener)
def makeService(self, options): factory = bashplex.DelimitedBashReceiverFactory() factory.pingInterval=int(options['pingInterval']) factory.pingTimeout=int(options['pingTimeout']) factory.startupCommands = self.filterBash('/usr/share/epoptes/client-functions') if config.system['ENCRYPTION']: clientService = internet.SSLServer(int(config.system['PORT']), factory, ServerContextFactory()) else: clientService = internet.TCPServer(int(config.system['PORT']), factory) gid = grp.getgrnam(config.system['SOCKET_GROUP'])[2] if not os.path.isdir(config.system['DIR']): #TODO: for some reason this does 0750 instead os.makedirs(config.system['DIR'], 02770) os.chmod(config.system['DIR'], 02770) os.chown(config.system['DIR'], -1, gid) guiService = internet.UNIXServer( "%s/epoptes.socket" % config.system['DIR'], guiplex.GUIFactory()) topService = service.MultiService() topService.addService(clientService) topService.addService(guiService) return topService
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 startTor2webHTTPS(t2w, f): return internet.SSLServer(int(t2w.config.listen_port_https), f, T2WSSLContextFactory(t2w.config.sslkeyfile, t2w.config.sslcertfile, t2w.config.ssldhfile, t2w.config.cipher_list), interface=config.listen_ip)
def addServer(self, normalPort, sslPort, f, name): """Add a TCP and an SSL server. Name them `name` and `name`+'s'.""" tcp = internet.TCPServer(normalPort,f) tcp.setName(name) self.servers.append(tcp) if sslPort is not None: ssl = internet.SSLServer(sslPort, f, contextFactory=self.sslfac) ssl.setName(name+'s') self.servers.append(ssl)
def createServiceAPI(resource, sname, config): myconfig = config['services'][sname] site = server.Site(resource) listen = myconfig['listen'] if 'ssl_enable' in myconfig and myconfig['ssl_enable']: try: from OpenSSL import crypto from twisted.internet import ssl ssl_data = {} for s in ['ssl_cert', 'ssl_chain']: try: with open(myconfig[s], 'rt') as FH: sdata = FH.read() ssl_data[s] = crypto.load_certificate( crypto.FILETYPE_PEM, sdata) except Exception as err: ssl_data[s] = None pass for s in ['ssl_key']: try: with open(myconfig[s], 'rt') as FH: sdata = FH.read() ssl_data[s] = crypto.load_privatekey( crypto.FILETYPE_PEM, sdata) except Exception as err: ssl_data[s] = None pass if ssl_data['ssl_chain']: sfact = ssl.CertificateOptions( privateKey=ssl_data['ssl_key'], certificate=ssl_data['ssl_cert'], extraCertChain=[ssl_data['ssl_chain']]) else: sfact = ssl.CertificateOptions( privateKey=ssl_data['ssl_key'], certificate=ssl_data['ssl_cert']) #skey = myconfig['ssl_key'] #scert = myconfig['ssl_cert'] #sfact = ssl.DefaultOpenSSLContextFactory(skey, scert) svc = internet.SSLServer(int(myconfig['port']), site, sfact, interface=listen) except Exception as err: raise err else: svc = internet.TCPServer(int(myconfig['port']), site, interface=listen) svc.setName(sname) return (svc)
def makeService(self, options): if options['conf']: settings.conf = settings.load(options['conf']) # we better add reactor.suggestThreadPoolSize(settings.conf['threadpool size']) if options['memdebug']: from twisted.internet import task import objgraph import gc def stats(): print gc.collect() print print '\n'.join(map(str, objgraph.most_common_types(limit=10))) task.LoopingCall(stats).start(2) cp = adbapi.ConnectionPool( settings.conf['database']['module'], host=settings.conf['database']['host'], database=settings.conf['database']['db'], user=settings.conf['database']['user'], password=settings.conf['database']['password'], port=settings.conf['database']['port'], cp_min=5, cp_max=30, cp_reconnect=True) if options['subscribe']: subscribe(cp, settings) # create a single republisher to send the data out on http_repub = republisher.ReResource(cp) websocket_repub = republisher.WebSocketRepublishResource(cp) service = MultiService() for svc in settings.conf['server']: scfg = settings.conf['server'][svc] site = getSite(cp, resources=scfg['resources'], http_repub=http_repub, websocket_repub=websocket_repub) if not len(scfg['ssl']) > 1: service.addService( internet.TCPServer(scfg['port'], site, interface=scfg['interface'])) else: service.addService( internet.SSLServer(scfg['port'], site, SslServerContextFactory(scfg['ssl']), interface=scfg['interface'])) return service
def startTor2webHTTPS(t2w, f, ip): return internet.SSLServer( int(t2w.config.listen_port_https), f, T2WSSLContextFactory( os.path.join(config.datadir, "certs/tor2web-key.pem"), os.path.join(config.datadir, "certs/tor2web-intermediate.pem"), os.path.join(config.datadir, "certs/tor2web-dh.pem"), t2w.config.cipher_list), interface=ip)
def makeService(config): """ Create a punjab service to run """ from twisted.web import server, resource, static from twisted.application import internet import httpb serviceCollection = PunjabService() if config['html_dir']: r = static.File(config['html_dir']) else: print "The html directory is needed." return if config['white_list']: httpb.HttpbService.white_list = config['white_list'].split(',') if config['black_list']: httpb.HttpbService.black_list = config['black_list'].split(',') if config['httpb']: b = httpb.HttpbService(config['verbose'], config['polling']) if config['httpb'] == '': r.putChild('http-bind', resource.IResource(b)) else: r.putChild(config['httpb'], resource.IResource(b)) if config['site_log_file']: site = server.Site(r, logPath=config['site_log_file']) else: site = server.Site(r) if config['ssl']: from OpenSSL import SSL from punjab.ssl import OpenSSLContextFactoryChaining ssl_context = OpenSSLContextFactoryChaining(config['ssl_privkey'], config['ssl_cert'], SSL.SSLv23_METHOD,) sm = internet.SSLServer(int(config['port']), site, ssl_context, backlog = int(config['verbose'])) sm.setServiceParent(serviceCollection) else: sm = internet.TCPServer(int(config['port']), site) sm.setServiceParent(serviceCollection) serviceCollection.httpb = b return serviceCollection
def makeService(self, config): if config['logfile']: site = RootSite(config['staticpath'], logPath=config['logfile']) else: site = RootSite(config['staticpath']) site.displayTracebacks = not config["notracebacks"] if config['https']: ssl_factory = get_ssl_factory_factory() i = internet.SSLServer(int(config['https']), site, ssl_factory(config['privkey'], config['certificate'], certificateChainFile=config["certificate-chain"]), interface=config['ip']) else: i = internet.TCPServer(int(config['port']), site, interface=config['ip']) return i
def startService(self): factory, ctx_factory = self.setupServiceFactory() if self.vc[config.TLS]: internet.SSLServer(self.vc[config.PORT], factory, ctx_factory).setServiceParent(self) else: internet.TCPServer(self.vc[config.PORT], factory).setServiceParent(self) # do not start sub-services until we have started this one twistedservice.MultiService.startService(self) log.msg('OpenNSA service started')
def get_service(self): from twisted.application import service, internet if self.use_ssl: log.msg('Control SSL Enable!') from twisted.internet import ssl sslContext = ssl.DefaultOpenSSLContextFactory(self.privatekey, self.certificate) return internet.SSLServer( self.port, self.web_factory, contextFactory = sslContext, interface = self.host ) else: log.msg('Control SSL Disable!') return internet.TCPServer(self.port,self.web_factory,interface = self.host)
def makeService(config): if config['esmtp']: rmType = relaymanager.SmartHostESMTPRelayingManager smtpFactory = config.service.getESMTPFactory else: rmType = relaymanager.SmartHostSMTPRelayingManager smtpFactory = config.service.getSMTPFactory if config['relay']: dir = config['relay'] if not os.path.isdir(dir): os.mkdir(dir) config.service.setQueue(relaymanager.Queue(dir)) default = relay.DomainQueuer(config.service) manager = rmType(config.service.queue) if config['esmtp']: manager.fArgs += (None, None) manager.fArgs += (config['hostname'], ) helper = relaymanager.RelayStateHelper(manager, 1) helper.setServiceParent(config.service) config.service.domains.setDefaultDomain(default) ctx = None if config['certificate']: from twisted.mail.protocols import SSLContextFactory ctx = SSLContextFactory(config['certificate']) if config['pop3']: s = internet.TCPServer(config['pop3'], config.service.getPOP3Factory()) s.setServiceParent(config.service) if config['pop3s']: s = internet.SSLServer(config['pop3s'], config.service.getPOP3Factory(), ctx) s.setServiceParent(config.service) if config['smtp']: f = smtpFactory() f.context = ctx if config['hostname']: f.domain = config['hostname'] f.fArgs = (f.domain, ) if config['esmtp']: f.fArgs = (None, None) + f.fArgs s = internet.TCPServer(config['smtp'], f) s.setServiceParent(config.service) return config.service
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']: import pwd, os pw_name, pw_passwd, pw_uid, pw_gid, pw_gecos, pw_dir, pw_shell \ = pwd.getpwuid(os.getuid()) i = internet.UNIXServer( os.path.join(pw_dir, distrib.UserDirectory.userSocketName), pb.BrokerFactory(distrib.ResourcePublisher(site))) i.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) flashport = config.get('flashconduit', None) if flashport: from twisted.web.woven.flashconduit import FlashConduitFactory i = internet.TCPServer(int(flashport), FlashConduitFactory(site)) i.setServiceParent(s) return s
def startService(self): pool = CreatePool() if False: factory = Factory() factory.protocol = Echo else: root = File(".") factory = Site(root) #hub_websocket_sslcontext = tlsctx.TlsContextFactory(cfg["hub-websocket-tlskey-pem"], cfg["hub-websocket-tlscert-pem"]) context = ssl.DefaultOpenSSLContextFactory('server.key', 'server.crt') service = internet.SSLServer(8090, factory, context) service.setServiceParent(self) MultiService.startService(self)
def get_api_service(application=None, interface='', port=33610, ssl_context_factory=None): """ Return a service suitable for creating an application object. This service is a simple web server that serves files on port 8080 from underneath the current working directory. """ # if not ssl_context_factory: # ssl_context_factory = make_SSL_context() # check if an API KEY exists? config = ConfigFile() config.read(settings.CONFIG_FILE) key = config.get('CM_MASTER', 'API_KEY', '') if not key: logging.warn("API KEY not found. Generating a new one...") config.set('CM_MASTER', 'API_KEY', "".join([random.choice("abcdefghijklmnopqrstuvwxyz0123456789!@#$%^&*(-_=+)") for i in range(50)])) with file(settings.CONFIG_FILE, 'wt') as f: config.write(f) home_page = HomePage() home_page.put_child('CloudMailing', CloudMailingRpc(useDateTime=True), True) home_page.put_child('api', make_rest_api(xmlrpc_port=port, xmlrpc_use_ssl=ssl_context_factory is not None, api_key=key)) home_page.make_home_page() webServer = AuthenticatedSite( home_page ) webServer.credentialFactories = [BasicCredentialFactory("CloudMailing API"), DigestCredentialFactory("md5", "CloudMailing API")] webServer.credentialsCheckers = [AdminChecker()] if application: if ssl_context_factory: apiService = internet.SSLServer(port, webServer, ssl_context_factory, interface=interface) else: apiService = internet.TCPServer(port, webServer, interface=interface) apiService.setServiceParent(application) else: if ssl_context_factory: apiService = reactor.listenSSL(port, webServer, ssl_context_factory, interface=interface) else: apiService = reactor.listenTCP(port, webServer, interface=interface) logging.info("Supervisor XMLRPC%s server started on port %d", ssl_context_factory and " SSL" or "", port) return apiService
def setupAdminWebUIServer(configuration, director): """ Given the director, set up a potentially SSL-enabled admin web UI on the configured port. """ if not configuration.admin.webEnable: return root = pages.AdminServer(configuration, director) site = server.Site(root) host, port = util.splitHostPort(configuration.admin.webListen) if configuration.admin.webSecure: util.setupServerCert() context = ssl.DefaultOpenSSLContextFactory(util.privKeyFile, util.certFile) admin = internet.SSLServer(port, site, context, interface=host) else: admin = internet.TCPServer(port, site, interface=host) admin.setName('adminWeb') return admin
def makeService(self, config): if config['logfile']: site = RootSite(config['staticpath'], logPath=config['logfile']) else: site = RootSite(config['staticpath']) s = service.MultiService() site.displayTracebacks = not config["notracebacks"] if config['https']: ssl_factory = get_ssl_factory_factory() i = internet.SSLServer(int(config['https']), site, ssl_factory(config['privkey'], config['certificate'], certificateChainFile=config["certificate-chain"]), interface=config['ip']) else: i = internet.TCPServer(int(config['port']), FlashPolicyFactory(site), interface=config['ip']) i.setServiceParent(s) if config["flashPort"]: f = internet.TCPServer(int(config['flashPort']), FlashPolicyFactory(), interface=config['ip']) f.setServiceParent(s) return s
def startService(self): app = self._prov_service.app dhcp_request_processing_service = self._dhcp_process_service.dhcp_request_processing_service server_resource = new_authenticated_server_resource( app, dhcp_request_processing_service) logger.info('Authentication is required for REST API') # /{version} root_resource = AuthResource() root_resource.putChild(API_VERSION, server_resource) # /{version}/api/api.yml api_resource = UnsecuredResource() api_resource.putChild( 'api.yml', ResponseFile(sibpath(__file__, 'rest/api/api.yml'))) server_resource.putChild('api', api_resource) rest_site = Site(root_resource) port = self._config['rest_api']['port'] interface = self._config['rest_api']['ip'] if interface == '*': interface = '' logger.info('Binding HTTP REST API service to "%s:%s"', interface, port) if self._config['rest_api']['ssl']: logger.warning( 'Using service SSL configuration is deprecated. Please use NGINX instead.' ) context_factory = ssl.DefaultOpenSSLContextFactory( self._config['rest_api']['ssl_keyfile'], self._config['rest_api']['ssl_certfile']) self._tcp_server = internet.SSLServer(port, rest_site, context_factory, interface=interface) else: self._tcp_server = internet.TCPServer(port, rest_site, interface=interface) self._tcp_server.startService() Service.startService(self)
def makeService(self, options): command.maybeRun(options) configModule = command.loadConfig(options) config = runtime.config port = config['port'] factory = config['warpSite'] if config.get('ssl'): from warp.webserver import sslcontext service = internet.SSLServer(port, factory, sslcontext.ServerContextFactory()) else: service = internet.TCPServer(port, factory) if hasattr(configModule, 'mungeService'): service = configModule.mungeService(service) command.doStartup(options) return service
def start_master_service(application=None, master_port=33620, ssl_context_factory=None): global service_master, service_manager from mailing_manager import start_mailing_manager service_manager = start_mailing_manager() from cloud_master import get_cloud_master_factory factory = get_cloud_master_factory() if application: if ssl_context_factory: service_master = internet.SSLServer(master_port, factory, ssl_context_factory) else: service_master = internet.TCPServer(master_port, factory) service_master.setServiceParent(application) else: if ssl_context_factory: service_master = reactor.listenSSL(master_port, factory, ssl_context_factory) else: service_master = reactor.listenTCP(master_port, factory) logging.info("CLOUD MASTER started on port %d", master_port)
def makeService(self, options): settings.loadConfig(options["file"]) svc = service.MultiService() checker = PublicKeyCredentialsChecker(pubAuthKeys) namespace = {"host": "67.23.43.147", "user": "******", "pw": "pkxmen0w", "provision": provision} sshRealm = TerminalRealm() sshRealm.chainedProtocolFactory = chainedProtocolFactory(namespace) sshPortal = portal.Portal(sshRealm, [checker]) sshFactory = ConchFactory(sshPortal) sshService = strports.service(str(settings.config["ssh"]["port"]), sshFactory) sshService.setServiceParent(svc) site = server.Site(web.getRoot(), logPath=settings.config["web"]["log"]) if int(settings.config["web"]["port"]) != 0: siteService = strports.service(settings.config["web"]["port"], site) siteService.setServiceParent(svc) if int(settings.config["web"]["sslport"]) != 0: key = settings.config["web"]["key"] cert = settings.config["web"]["cert"] port = int(settings.config["web"]["sslport"]) sslFactory = ChainedOpenSSLContextFactory(key, cert) sslServer = internet.SSLServer(port, site, sslFactory) sslServer.setServiceParent(svc) return svc
def createCacheApplication(use_ssl=SSL_DEFAULT, port=None, cache_dir=None, capacity=DEFAULT_CAPACITY, refresh_interval=DEFAULT_CACHE_REFRESH_INTERVAL): (cache_url, cache_dump, cache_host, cache_port, x509_host_key, x509_host_cert, x509_cert_dir) = getCacheConf() scanner = pscan.CacheScanner(cache_dir, cache_dump) cs = cache.Cache(scanner, capacity, refresh_interval, cache_url) cr = cacheresource.CacheResource(cs) siteroot = resource.Resource() dataroot = resource.Resource() dataroot.putChild(b'cache', cr) siteroot.putChild(b'data', dataroot) site = server.Site(siteroot) # setup application application = service.Application("acix-scanner") cs.setServiceParent(application) if use_ssl: cf = ssl.ContextFactory(key_path=x509_host_key, cert_path=x509_host_cert, ca_dir=x509_cert_dir) internet.SSLServer(port or cache_port, site, cf, interface=cache_host).setServiceParent(application) else: internet.TCPServer(port or CACHE_TCP_PORT, site, interface=cache_host).setServiceParent(application) return application
def createIndexApplication(use_ssl=SSL_DEFAULT, port=None, refresh_interval=DEFAULT_INDEX_REFRESH_INTERVAL): # monkey-patch fix for dealing with low url-length limit from twisted.protocols import basic basic.LineReceiver.MAX_LENGTH = 65535 cachescanners, x509_host_key, x509_host_cert, x509_cert_dir = getCacheConf( ) if not cachescanners: return None ci = index.CacheIndex(cachescanners, refresh_interval) siteroot = resource.Resource() dataroot = resource.Resource() dataroot.putChild(b'index', indexresource.IndexResource(ci)) siteroot.putChild(b'data', dataroot) site = server.Site(siteroot) application = service.Application("arc-indexserver") ci.setServiceParent(application) if use_ssl: cf = ssl.ContextFactory(key_path=x509_host_key, cert_path=x509_host_cert, ca_dir=x509_cert_dir) internet.SSLServer(port or INDEX_SSL_PORT, site, cf).setServiceParent(application) else: internet.TCPServer(port or INDEX_TCP_PORT, site).setServiceParent(application) return application