def run_scrAPI(): resource = wsgi.WSGIResource(reactor, reactor.getThreadPool(), app) site = server.Site(resource) http_server = endpoints.TCP4ServerEndpoint(reactor, 5005) http_server.listen(site) reactor.run() return reactor
def _run(): reactor.suggestThreadPoolSize(FLAGS.threadpool_size) resource = wsgi.WSGIResource(reactor, reactor.getThreadPool(), app) site = server.Site(resource) endpoint = endpoints.serverFromString(reactor, address) endpoint.listen(site).addErrback(err_shutdown) reactor.run(installSignalHandlers=int(not debug))
def makeService(self, options): pool = threadpool.ThreadPool(minthreads=1, maxthreads=100) reactor.callWhenRunning(pool.start) reactor.addSystemEventTrigger('after', 'shutdown', pool.stop) root = wsgi.WSGIResource(reactor, pool, wsgi_hello.application) site = server.Site(root) return strports.service('tcp:8000', site)
def wsgi_resource(): pool = threadpool.ThreadPool() pool.start() # Allow Ctrl-C to get you out cleanly: reactor.addSystemEventTrigger('after', 'shutdown', pool.stop) wsgi_resource = wsgi.WSGIResource(reactor, pool, WSGIHandler()) return wsgi_resource
def wsgi_resource(): pool = threadpool.ThreadPool() pool.start() # Allow Ctrl-C to get you out cleanly: reactor.addSystemEventTrigger('after', 'shutdown', pool.stop) handler = StaticFilesHandler(get_internal_wsgi_application()) wsgi_resource = wsgi.WSGIResource(reactor, pool, handler) return wsgi_resource
def getRoot(pool): application = blog.app.app wsgi_resource = wsgi.WSGIResource(reactor, pool, application) root = DelegatingResource(wsgi_resource) static_resource = static.File('index.html') root.putChild(b'', static_resource) static_resource = static.File('static') root.putChild(b'static', static_resource) return root
def makeService(self, options): s = service.MultiService() pool = threadpool.ThreadPool() reactor.callWhenRunning(pool.start) reactor.addSystemEventTrigger('after', 'shutdown', pool.stop) root = wsgi.WSGIResource(reactor, pool, wsgi_param.application) site = server.Site(root) strports.service('tcp:8000', site).setServiceParent(s) ts = internet.TimerService(1, update, wsgi_param.application, reactor) ts.setServiceParent(s) return s
def wsgi_resource(multi): # make a new ThreadPoolService and add it to the multi service tps = ThreadPoolService(threadpool.ThreadPool()) tps.setServiceParent(multi) # Allow Ctrl-C to get you out cleanly: reactor.addSystemEventTrigger('after', 'shutdown', tps.pool.stop) wsgi_resource = wsgi.WSGIResource(reactor, tps.pool, WSGIHandler()) return wsgi_resource
def __init__(self): resource.Resource.__init__(self) pool = threadpool.ThreadPool() pool.start() # Allow Ctrl-C to get you out cleanly: reactor.addSystemEventTrigger('after', 'shutdown', pool.stop) self.wsgi_resource = wsgi.WSGIResource(reactor, pool, WSGIHandler()) staticsrc = static.File(blog.settings.STATIC_ROOT, blog.settings.STATIC_URL) self.putChild('static', staticsrc)
def makeService(self, options): s = service.MultiService() pool = threadpool.ThreadPool() reactor.callWhenRunning(pool.start) reactor.addSystemEventTrigger('after', 'shutdown', pool.stop) root = wsgi.WSGIResource(reactor, pool, wsgi_param.application) site = server.Site(root) strports.service('tcp:8000', site).setServiceParent(s) factory = protocol.Factory.forProtocol(UpdateMessage) factory.application = wsgi_param.application strports.service('tcp:8001', factory).setServiceParent(s) return s
def makeService(self, options): application = wsgi_hello.application pool = threadpool.ThreadPool(minthreads=1, maxthreads=100) reactor.callWhenRunning(pool.start) reactor.addSystemEventTrigger('after', 'shutdown', pool.stop) dynamic = wsgi.WSGIResource(reactor, pool, application) files = static.File('static') root = vhost.NameVirtualHost() root.addHost(b'app.example.org', dynamic) root.addHost(b'static.example.org', files) site = server.Site(root) return strports.service(options['port'], site)
def _run(): log.msg("logging run") # this is set in an oscar flag in pyg reactor.suggestThreadPoolSize( 30 ) # this is the default in pyg. Maybe we use something different. resource = wsgi.WSGIResource(reactor, reactor.getThreadPool(), app) site = server.Site(resource) endpoint = endpoints.serverFromString(reactor, address) endpoint.listen(site).addErrback(err_shutdown) # this suggests that debug is boolean, perhaps reactor.run(installSignalHandlers=int(not debug))
def opt_wsgi(self, name): """ The FQPN of a WSGI application object to serve as the root resource of the webserver. """ pool = threadpool.ThreadPool() reactor.callWhenRunning(pool.start) reactor.addSystemEventTrigger('after', 'shutdown', pool.stop) try: application = reflect.namedAny(name) except (AttributeError, ValueError): raise usage.UsageError("No such WSGI application: %r" % (name,)) self['root'] = wsgi.WSGIResource(reactor, pool, application)
def makeService(self, options): application = pyramid_dynamic.application pool = threadpool.ThreadPool(minthreads=1, maxthreads=100) reactor.callWhenRunning(pool.start) reactor.addSystemEventTrigger('after', 'shutdown', pool.stop) root = wsgi.WSGIResource(reactor, pool, application) site = server.Site(root) control = protocol.Factory() control.protocol = lambda: amp.AMP(locator=AppConfiguration()) ret = service.MultiService() strports.service('tcp:8000', site).setServiceParent(ret) strports.service('tcp:8001', control).setServiceParent(ret) return ret
def twisted_adapter(host, port): from twisted.web import server, wsgi from twisted.python.threadpool import ThreadPool from twisted.internet import reactor thread_pool = ThreadPool() thread_pool.start() reactor.addSystemEventTrigger('after', 'shutdown', thread_pool.stop) ittyResource = wsgi.WSGIResource(reactor, thread_pool, handle_request) site = server.Site(ittyResource) reactor.listenTCP(port, site) reactor.run()
def _build_api_service(self): """ Once called, the resource is initialized. Any calls to self._add_resource() should be done before calling this fn. :return: """ wsgi_app = self.anchore_service.get_api_application() wsgi_site = wsgi.WSGIResource(reactor, reactor.getThreadPool(), application=wsgi_app) self._add_resource(self.anchore_service.__service_api_version__.encode('utf-8'), wsgi_site) self.root_resource = web.resource.Resource() # Add nodes for name, resource in self.resource_nodes.items(): self.root_resource.putChild(name, resource) # this will rewrite any calls that do not have an explicit version to the base path before being processed by flask self._api_version_bytes = self.anchore_service.__service_api_version__.encode('utf-8') # This is optimization # Handle the auth vs non-auth child resources to not consume a path element root = rewrite.RewriterResource(self.root_resource, self._default_version_rewrite) # Build the main site server site = server.Site(root) listen = self.anchore_service.configuration['listen'] if str(self.anchore_service.configuration.get('ssl_enable', '')).lower() == 'true': try: ssl_data = { 'ssl_cert': _load_ssl_cert(self.anchore_service.configuration['ssl_cert']) if 'ssl_cert' in self.anchore_service.configuration else None, 'ssl_chain': _load_ssl_cert(self.anchore_service.configuration['ssl_chain']) if 'ssl_chain' in self.anchore_service.configuration else None, 'ssl_key': _load_ssl_key(self.anchore_service.configuration['ssl_key']) if 'ssl_key' in self.anchore_service.configuration else None } 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']) endpoint = SSL4ServerEndpoint(reactor=reactor, port=int(self.anchore_service.configuration['port']), sslContextFactory=sfact, interface=listen) except Exception as err: raise err else: endpoint = TCP4ServerEndpoint(reactor=reactor, port=int(self.anchore_service.configuration['port']), interface=listen) ret_svc = StreamServerEndpointService(endpoint=endpoint, factory=site) ret_svc.setName(self.anchore_service.name) return ret_svc
def getfactory(reactor): # Create a WSGI callable from our application app = cherrypy.Application(Node(LIBVIRT_URIS), "", APPCONFIG) # Twisted needs a threadpool to run this in threads = threadpool.ThreadPool(minthreads=1, maxthreads=1, name='virtweb') threads.start() # Shut it down, too! reactor.addSystemEventTrigger('after', 'shutdown', threads.stop) # Setup the twisted.web factory resource = wsgi.WSGIResource(reactor, threads, app) factory = server.Site(resource, 'server.log') return factory
def twisted_adapter(host, port, application): from twisted.application import service, strports from twisted.web import server, http, wsgi from twisted.python.threadpool import ThreadPool from twisted.internet import reactor thread_pool = ThreadPool() thread_pool.start() reactor.addSystemEventTrigger('after', 'shutdown', thread_pool.stop) resource = wsgi.WSGIResource(reactor, thread_pool, application) site = server.Site(resource) reactor.listenTCP(port, site) reactor.run()
def do_run(self): resource = wsgi.WSGIResource(internet.reactor, internet.reactor.getThreadPool(), WSGIHandler()) if settings.USE_SSL: internet.reactor.listenSSL(settings.BLOB_PORT, server.Site(resource), ChainedOpenSSLContextFactory( settings.SSL_CERTIFICATE, settings.SSL_CERTIFICATE), interface=settings.BLOB_HOST) else: internet.reactor.listenTCP(settings.BLOB_PORT, server.Site(resource), interface=settings.BLOB_HOST) internet.reactor.run()
def makeService(cliconfig): application = service.Application('TSX API') ch = logging.StreamHandler() ch.setLevel(logging.DEBUG) formatter = logging.Formatter( '%(asctime)s - %(name)s - %(levelname)s - %(message)s') ch.setFormatter(formatter) logger.addHandler(ch) observer = log.PythonLoggingObserver("tsxapi") observer.start() # config = read_config(cliconfig) # JW - disabling this for now # setup python logging log_file = tsx.config.get("api", "log_file", default="/var/log/tsxapi.log") from logging.handlers import TimedRotatingFileHandler fh = TimedRotatingFileHandler(log_file, when='midnight', backupCount=7) fh.setLevel(logging.DEBUG) formatter = logging.Formatter( '%(asctime)s - %(name)s - %(levelname)s - %(message)s') fh.setFormatter(formatter) logger.addHandler(fh) # read config file. this could do with some prettifying to give more # verbose feedback if a key isn't found. port = int(tsx.config.get("api", "port", default=8080)) logger.info("Using Port %d" % port) from tsx.api.api import app # TODO - make package naming less awkward # This bit is a workaround around a bug in Twisted. # If the threadpool is initialised before Twisted is daemonised, the # whole thing goes up in flames (sort of). # We avoid this by putting the multi-service in between. multi = service.MultiService() pool = threadpool.ThreadPool() tps = ThreadPoolService(pool) tps.setServiceParent(multi) resource = wsgi.WSGIResource(reactor, tps.pool, app) # Serve it up: main_site = server.Site(resource) internet.TCPServer(port, main_site).setServiceParent(multi) multi.setServiceParent(application) return multi
def makeService(self, options): s = service.MultiService() for name, port in port_assignments.items(): application = reflect.namedAny(name) pool = threadpool.ThreadPool() reactor.callWhenRunning(pool.start) reactor.addSystemEventTrigger('after', 'shutdown', pool.stop) root = wsgi.WSGIResource(reactor, pool, application) site = server.Site(root) strports.service(port, site).setServiceParent(s) root = static.File('data') site = server.Site(root) strports.service('tcp:8085', site).setServiceParent(s) fle = filepath.FilePath('data/time.txt') ts = internet.TimerService(1, update, fle, reactor) ts.setServiceParent(s) return s
def webResourceFactory(staticfiles, datafiles=None): """This factory function creates an instance of the front end web resource tree containing both the django wsgi and the async notebook resources. """ class Root(resource.Resource): def __init__(self, wsgi_resource): resource.Resource.__init__(self) self.wsgi_resource = wsgi_resource def getChild(self, path, request): path0 = request.prepath.pop(0) request.postpath.insert(0, path0) return self.wsgi_resource # The kernel server does not require django, so this step is not # required for every import of service.py (this file) from django.core.handlers.wsgi import WSGIHandler from twisted.python import threadpool pool = threadpool.ThreadPool() reactor.callWhenRunning(pool.start) reactor.addSystemEventTrigger('after', 'shutdown', pool.stop) django_wsgi_resource = wsgi.WSGIResource(reactor, pool, WSGIHandler()) resource_root = Root(django_wsgi_resource) static_resource = static.File(staticfiles) backend_bus = backend.BackendBus() resource_root.putChild("asyncnotebook", backend.EngineBusAdapter(backend_bus)) resource_root.putChild("static", static_resource) if datafiles: data_resource = static.File(datafiles) resource_root.putChild("data", data_resource) return resource_root
def run_twisted_wsgi(): from sys import stdout from twisted.logger import globalLogBeginner, textFileLogObserver from twisted.web import server, wsgi from twisted.internet import endpoints, reactor # start the logger globalLogBeginner.beginLoggingTo([textFileLogObserver(stdout)]) # logger = logging.getLogger(__name__) logging.basicConfig(level=logging.INFO) # start the WSGI server root_resource = wsgi.WSGIResource(reactor, reactor.getThreadPool(), app) factory = server.Site(root_resource) http_server = endpoints.TCP4ServerEndpoint(reactor, 5000) http_server.listen(factory) # start event loop reactor.run(**reactor_args)
def build_service(reactor): multi = MultiService() StreamServerEndpointService( TCP4ServerEndpoint(reactor, port), server.Site( wsgi.WSGIResource(reactor, reactor.getThreadPool(), app), )).setServiceParent(multi) logger = Logger() TimerService( # Run every 10 minutes 10 * 60, lambda: deferToThread(check_for_revocation, cert_db, crtsh_checker) .addErrback(lambda f: logger.failure( "Error checking for revocation", f))).setServiceParent(multi) TimerService( 60 * 60, lambda: deferToThread(raw_app._update_lint_summaries).addErrback( lambda f: logger.failure("Error updating cablint summaries", f ))).setServiceParent(multi) return multi
def makeService(config): from django.core.handlers.wsgi import WSGIHandler os.environ['DJANGO_SETTINGS_MODULE'] = 'lisa.server.web.weblisa.settings' if config['configuration']: ConfigManagerSingleton.get().setConfiguration(config['configuration']) configuration = ConfigManagerSingleton.get().getConfiguration() dir_path = ConfigManagerSingleton.get().getPath() from lisa.server import libs # Creating MultiService multi = service.MultiService() pool = threadpool.ThreadPool() tps = ThreadPoolService(pool) tps.setServiceParent(multi) # Creating the web stuff resource_wsgi = wsgi.WSGIResource(reactor, tps.pool, WSGIHandler()) root = static.File('/'.join([dir_path, 'web/frontend/build'])) backendsrc = libs.Root(resource_wsgi) root.putChild("backend", backendsrc) staticrsrc = static.File('/'.join([dir_path, 'web/interface/static'])) root.putChild("static", staticrsrc) socketfactory = SockJSFactory(Factory.forProtocol(libs.WebSocketProtocol)) root.putChild("websocket", socketfactory) # Configuring servers to launch if configuration['enable_secure_mode'] or configuration[ 'enable_unsecure_mode']: if configuration['enable_secure_mode']: SSLContextFactoryEngine = ssl.DefaultOpenSSLContextFactory( os.path.normpath(dir_path + '/' + 'configuration/ssl/server.key'), os.path.normpath(dir_path + '/' + 'configuration/ssl/server.crt')) SSLContextFactoryWeb = ssl.DefaultOpenSSLContextFactory( os.path.normpath(dir_path + '/' + 'configuration/ssl/server.key'), os.path.normpath(dir_path + '/' + 'configuration/ssl/server.crt')) ctx = SSLContextFactoryEngine.getContext() ctx.set_verify(SSL.VERIFY_PEER | SSL.VERIFY_FAIL_IF_NO_PEER_CERT, libs.verifyCallback) # Since we have self-signed certs we have to explicitly # tell the server to trust them. with open( os.path.normpath(dir_path + '/' + 'configuration/ssl/server.pem'), 'w') as outfile: for file in os.listdir( os.path.normpath(dir_path + '/' + 'configuration/ssl/public/')): with open( os.path.normpath(dir_path + '/' + 'configuration/ssl/public/' + file)) as infile: for line in infile: outfile.write(line) ctx.load_verify_locations( os.path.normpath(dir_path + '/' + 'configuration/ssl/server.pem')) internet.SSLServer(configuration['lisa_web_port_ssl'], server.Site(root), SSLContextFactoryWeb).setServiceParent(multi) internet.SSLServer(configuration['lisa_engine_port_ssl'], libs.LisaFactorySingleton.get(), SSLContextFactoryEngine).setServiceParent(multi) if configuration['enable_unsecure_mode']: # Serve it up: internet.TCPServer(configuration['lisa_web_port'], server.Site(root)).setServiceParent(multi) internet.TCPServer( configuration['lisa_engine_port'], libs.LisaFactorySingleton.get()).setServiceParent(multi) configuration['enable_cloud_mode'] = True #if configuration['enable_cloud_mode']: # portforward.ProxyClient.dataReceived = client_dataReceived # portforward.ProxyServer.dataReceived = server_dataReceived # reactor.listenTCP(1080, portforward.ProxyFactory('localhost', 8000)) else: exit(1) libs.scheduler.setServiceParent(multi) multi.setServiceParent(application) libs.Initialize() return multi
def init(): global _WSGIListener global _WSGIPort result = Deferred() if _Debug: lg.out(_DebugLevel, 'control.init') request_update() if _WSGIListener: if _Debug: lg.out(_DebugLevel, ' SKIP listener already exist') result.callback(0) return result try: import django # ver = django.get_version() # if not ver.startswith('1.7'): # if _Debug: # lg.out(_DebugLevel, ' Django version must be 1.7, skip!') # result.callback(0) # return result except: lg.exc() result.callback(0) return result if _Debug: lg.out(_DebugLevel + 6, ' \n' + pprint.pformat(sys.path)) if _Debug: lg.out( _DebugLevel, ' setting environment DJANGO_SETTINGS_MODULE=web.asite.settings' ) os.environ.setdefault("DJANGO_SETTINGS_MODULE", "web.asite.settings") from django.core.wsgi import get_wsgi_application from django.conf import settings as django_settings from django.core import management # from django.contrib.auth.management.commands import changepassword if _Debug: lg.out(_DebugLevel, ' configuring WSGI bridge from Twisted to Django') wsgi_handler = get_wsgi_application() my_wsgi_handler = MyFakedWSGIHandler(wsgi_handler) pool = threadpool.ThreadPool() pool.start() reactor.addSystemEventTrigger('after', 'shutdown', pool.stop) resource = wsgi.WSGIResource(reactor, pool, my_wsgi_handler) root = DjangoRootResource(resource) root_static_dir = os.path.join(bpio.getExecutableDir(), "web") for sub in os.listdir(root_static_dir): static_path = os.path.join(root_static_dir, sub, 'static') if not os.path.isdir(static_path): continue node = static.File(static_path) root.putChild(sub, node) if _Debug: lg.out(_DebugLevel, ' added static dir: %s->%s' % (sub, static_path)) if sub == 'asite': admin_path = os.path.join(root_static_dir, sub, 'admin', 'static') node.putChild('admin', static.File(admin_path)) if _Debug: lg.out( _DebugLevel, ' added ADMIN static dir: admin->%s' % admin_path) site = server.Site(root) _WSGIPort = 8080 # TODO: read port num from settings if _Debug: lg.out(_DebugLevel, ' %s' % my_wsgi_handler) lg.out(_DebugLevel, ' %s' % resource) lg.out(_DebugLevel, ' %s' % site) verbosity = 0 if lg.is_debug(18): verbosity = 3 if lg.is_debug(12): verbosity = 2 if lg.is_debug(8): verbosity = 1 # lg.out(4, ' running django "flush" command') # management.call_command('flush', interactive=False, verbosity=verbosity) # lg.out(4, ' running django "createsuperuser" command') # management.call_command('createsuperuser', # interactive=False, verbosity=verbosity, # username="******", email="admin@localhost") # command = changepassword.Command() # command._get_pass = lambda *args: 'admin' # command.execute("admin") if _Debug: lg.out(_DebugLevel, ' running django "syncdb" command') management.call_command('syncdb', stdout=open( os.path.join(settings.LogsDir(), 'django-syncdb.log'), 'w'), interactive=False, verbosity=verbosity) _ShortPoolPort = 8081 # TODO: read port num from settings # shortpool.init(get_update_items, set_updated, _ShortPoolPort) if _Debug: lg.out(_DebugLevel, ' starting listener: %s' % site) result = start_listener(site) result.addCallback(lambda portnum: post_init(portnum)) return result
def init_protocol(self): self.web_factory = server.Site(wsgi.WSGIResource(reactor, reactor.getThreadPool(), self.app))
return 'Scrape Still Progress' def finished_scrape(null): """ A callback that is fired after the scrape has completed. Set a flag to allow display the results from /results """ global scrape_complete scrape_complete = True if __name__ == '__main__': from sys import stdout from twisted.logger import globalLogBeginner, textFileLogObserver from twisted.web import server, wsgi from twisted.internet import endpoints, reactor # start the logger globalLogBeginner.beginLoggingTo([textFileLogObserver(stdout)]) # start the WSGI server root_resource = wsgi.WSGIResource(reactor, reactor.getThreadPool(), app) factory = server.Site(root_resource) http_server = endpoints.TCP4ServerEndpoint(reactor, 9000) http_server.listen(factory) # start event loop reactor.run()
def _build_api_service(self): """ Once called, the resource is initialized. Any calls to self._add_resource() should be done before calling this fn. :return: """ thread_count = int( self.service_config.get('max_request_threads', localconfig.DEFAULT_SERVICE_THREAD_COUNT)) wsgi_app = self.anchore_service.get_api_application() wsgi_site = wsgi.WSGIResource(reactor, reactor.getThreadPool(), application=wsgi_app) reactor.getThreadPool().adjustPoolsize(maxthreads=thread_count) logger.debug('Thread pool size stats. Min={}, Max={}'.format( reactor.getThreadPool().min, reactor.getThreadPool().max)) self._add_resource( self.anchore_service.__service_api_version__.encode('utf-8'), wsgi_site) if enable_thread_dumper: logger.warn( "Adding thread dump route for debugging since debug flag is set. This is dangerous and should not be done in normal production" ) self._add_resource(b'threads', ThreadDumperResource()) self.root_resource = web.resource.Resource() # Add nodes for name, resource in self.resource_nodes.items(): self.root_resource.putChild(name, resource) # this will rewrite any calls that do not have an explicit version to the base path before being processed by flask self._api_version_bytes = self.anchore_service.__service_api_version__.encode( 'utf-8') # This is optimization # Handle the auth vs non-auth child resources to not consume a path element root = rewrite.RewriterResource(self.root_resource, self._default_version_rewrite) # Build the main site server site = server.Site(root) listen = self.anchore_service.configuration['listen'] # Disable the twisted access logging by overriding the log function as it uses a raw 'write' and cannot otherwise be disabled, iff enable_access_logging is set to False in either the service or global config try: eal = True if "enable_access_logging" in self.anchore_service.configuration: eal = self.anchore_service.configuration.get( "enable_access_logging", True) elif "enable_access_logging" in self.configuration: eal = self.configuration.get("enable_access_logging", True) if not eal: def _null_logger(request): pass site.log = _null_logger except: pass if str(self.anchore_service.configuration.get('ssl_enable', '')).lower() == 'true': try: ssl_data = { 'ssl_cert': _load_ssl_cert( self.anchore_service.configuration['ssl_cert']) if 'ssl_cert' in self.anchore_service.configuration else None, 'ssl_chain': _load_ssl_cert( self.anchore_service.configuration['ssl_chain']) if 'ssl_chain' in self.anchore_service.configuration else None, 'ssl_key': _load_ssl_key( self.anchore_service.configuration['ssl_key']) if 'ssl_key' in self.anchore_service.configuration else None } 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']) endpoint = SSL4ServerEndpoint( reactor=reactor, port=int(self.anchore_service.configuration['port']), sslContextFactory=sfact, interface=listen) except Exception as err: raise err else: endpoint = TCP4ServerEndpoint( reactor=reactor, port=int(self.anchore_service.configuration['port']), interface=listen) ret_svc = StreamServerEndpointService(endpoint=endpoint, factory=site) ret_svc.setName(self.anchore_service.name) return ret_svc
def makeService(config): from django.core.handlers.wsgi import WSGIHandler os.environ['DJANGO_SETTINGS_MODULE'] = 'lisa.server.web.weblisa.settings' # Get configuration if config['configuration']: if ConfigManager.setConfiguration(config['configuration']) == False: log.err("Error : configuration file invalid") return configuration = ConfigManager.getConfiguration() dir_path = configuration['path'] from lisa.server import libs # Multiservice mode multi = service.MultiService() multi.setServiceParent(application) pool = threadpool.ThreadPool() tps = ThreadPoolService(pool) tps.setServiceParent(multi) libs.scheduler.setServiceParent(multi) # Creating the web stuff resource_wsgi = wsgi.WSGIResource(reactor, tps.pool, WSGIHandler()) root = libs.Root(resource_wsgi) staticrsrc = static.File('/'.join([dir_path, 'web/interface/static'])) root.putChild("static", staticrsrc) # Start client protocol factory if configuration['enable_secure_mode']: # Create a SSL context factory for clients clientAuthContextFactory = ssl.DefaultOpenSSLContextFactory( configuration['lisa_ssl_key'], configuration['lisa_ssl_crt']) # Add client authentification to SSL context ctx = clientAuthContextFactory.getContext() ctx.set_verify(SSL.VERIFY_PEER | SSL.VERIFY_FAIL_IF_NO_PEER_CERT, ClientAuthVerifyCallback) # Load client certificates authorized to connect cert_path = dir_path + '/' + 'configuration/ssl/public/' outfile = os.path.normpath(dir_path + '/' + 'configuration/ssl/public/server.pem') with open(outfile, "w") as f: wildcard = os.path.normpath("{path}*.crt".format(path=cert_path)) for infile in glob.glob(wildcard): call(['openssl', 'x509', '-in', infile, '-text'], stdout=f) ctx.load_verify_locations(outfile) # Initialize client factory engineService = internet.SSLServer(configuration['lisa_port'], libs.ClientFactory.get(), clientAuthContextFactory) # Create a SSL context factory for web interface webAuthContextFactory = ssl.DefaultOpenSSLContextFactory( configuration['lisa_ssl_key'], configuration['lisa_ssl_crt']) # Initialize web factory webService = internet.SSLServer(configuration['lisa_web_port'], server.Site(root), webAuthContextFactory) else: # Initialize factories engineService = internet.TCPServer(configuration['lisa_port'], libs.ClientFactory.get()) webService = internet.TCPServer(configuration['lisa_web_port'], server.Site(root)) # Create the websocket factory if configuration['enable_secure_mode']: socketfactory = WebSocketServerFactory( "wss://" + configuration['lisa_url'] + ":" + str(configuration['lisa_web_port']), debug=False) else: # Initialize factories socketfactory = WebSocketServerFactory( "ws://" + configuration['lisa_url'] + ":" + str(configuration['lisa_web_port']), debug=False) socketfactory.protocol = libs.WebSocketProtocol socketresource = WebSocketResource(socketfactory) root.putChild("websocket", socketresource) # Add services to application engineService.setServiceParent(multi) webService.setServiceParent(multi) return multi