def run(app, root_prefix="", hostname="0.0.0.0", http_port=None, https_port=None, https_cert_path=None, https_certkey_path=None): root_prefix = root_prefix or "" dispatcher = wsgi.PathInfoDispatcher({root_prefix: app}) global _http_server global _https_server http_thread = None https_thread = None if http_port: _http_server = wsgi.Server((hostname, http_port), dispatcher) http_thread = threading.Thread(target=_http_server.start) if https_port: _https_server = wsgi.Server((hostname, https_port), dispatcher) _https_server.ssl_adapter = BuiltinSSLAdapter(https_cert_path, https_certkey_path) https_thread = threading.Thread(target=_https_server.start) if http_thread is not None: http_thread.start() if https_thread is not None: https_thread.start()
def run_webapp(self): from main.wsgi import application class Root(): pass cherrypy.config.update({'environment': 'production'}) static_app = cherrypy.tree.mount(Root(), '/', config={ '/': { 'tools.staticdir.on': True, 'tools.staticdir.dir': join(settings.ROOT_DIR, 'public') } }) addr = ('0.0.0.0', settings.HTTP_PLATFORM_PORT) dispatcher = wsgi.PathInfoDispatcher({ '/': application, '/static': static_app, }) server = wsgi.Server(addr, dispatcher) self.logger.info('Starting webapp: {}'.format(server._bind_addr)) server.safe_start()
def start_miniwiki( import_filename, export_filename, initdb, host, port, config_filename, ): config = load_config(config_filename) app = make_app(config) if initdb: with app.app_context(): db.create_all() click.echo('Database initialized!') return if import_filename: with app.app_context(): return import_pages(import_filename) if export_filename: with app.app_context(): return export_pages(export_filename) if config['debug']: app.run(host=host, port=port) else: server = wsgi.Server((host, port), app) server.start()
def activate(self): Component.activate(self) # Late import to speed up application startup. from cheroot import wsgi self.wsgi_server = wsgi.Server(\ ("0.0.0.0", self.port), self.wsgi_app, server_name="localhost", numthreads=1, timeout=5)
def main() -> None: args = parse_arguments() if args.print_version: print('{}, version {}'.format(os.path.basename(sys.argv[0]), __version__)) sys.exit(0) elif args.print_default_config: Config.write_default_config(sys.stdout) sys.exit(0) config.read_config(args.config_filename) app = setup_app() if config.debug: if config.server_prefix != '/': app = DispatcherMiddleware( Flask('debugging_frontend'), {config.server_prefix: app}) # type: ignore run_simple(config.socket_host, config.socket_port, app, use_debugger=True, use_reloader=True) # type: ignore else: wsgi_server = wsgi.Server( (config.socket_host, config.socket_port), wsgi.PathInfoDispatcher({config.server_prefix: app})) wsgi_server.safe_start()
def run(self, handler): server = wsgi.Server((self.host, self.port), handler) try: server.start() finally: server.stop()
def run(self, handler): from cheroot import wsgi from cheroot.ssl.builtin import BuiltinSSLAdapter import ssl self.server = wsgi.Server((self.host, self.port), handler) cert_file = self.options.get('cert_file', None) key_file = self.options.get('key_file', None) enable_ssl = self.options.get('enable_ssl', False) p_cert_file = Path(cert_file) p_key_file = Path(key_file) if p_cert_file.exists() and p_key_file.exists() and enable_ssl: self.server.ssl_adapter = BuiltinSSLAdapter( str(p_cert_file.absolute()), str(p_key_file.absolute())) # By default, the server will allow negotiations with extremely old protocols # that are susceptible to attacks, so we only allow TLSv1.2 self.server.ssl_adapter.context.options |= ssl.OP_NO_TLSv1 self.server.ssl_adapter.context.options |= ssl.OP_NO_TLSv1_1 else: dlna_server: SimpleDLNAServer = self.options.get('dlna_server') dlna_server.is_ssl_enabled = False self.server.prepare() # 必须在self.server被赋值后触发初始化完成时间 # 这里在开启循环前触发,保证服务器已经启动 init_event: threading.Event = self.options.get('init_event', None) if init_event is not None: init_event.set() self.server.serve()
def run(self, handler): server = wsgi.Server((self.host, self.port), handler) server.ssl_adapter = BuiltinSSLAdapter(kconfig.certificate_file, kconfig.key_file) try: server.start() finally: server.stop()
def main(): cheroot_server_options = { 'wsgi_app': wsgi_app, 'bind_addr': ('0.0.0.0', 8082), # numthreads (int): number of threads for WSGI thread pool 'numthreads': 10, # server_name (str): web server name to be advertised via Server HTTP header # 'server_name': None, # max (int): maximum number of worker threads # 'max': -1, # request_queue_size (int): the 'backlog' arg to socket.listen(); max queued conn # 'request_queue_size': 5, # timeout (int): the timeout in seconds for accepted connections # 'timeout': 10, # shutdown_timeout (int): the total time (sec), 2 wait 4 worker threads 2 cleanly exit # 'shutdown_timeout': 5, # accepted_queue_size (int): maximum number of active requests in queue # 'accepted_queue_size': -1, # accepted_queue_timeout (int): timeout for putting request into queue # 'accepted_queue_timeout': 10, } server = wsgi.Server(**cheroot_server_options) try: server.start() finally: server.stop()
def run(self): """ Starts listening server""" logging.info (" [+] Starting Macro_Pack WebDAV server...") logging.info (" [-] Files in \"" + self.WRoot + r"\" folder are accessible using url http://<hostname>:%s or \\<hostname>@%s\DavWWWRoot" % (self.listenPort, self.listenPort)) logging.info (" [-] Listening on port %s (ctrl-c to exit)...", self.listenPort) # Prepare WsgiDAV config config = { 'middleware_stack' : { WsgiDavDirBrowser, #Enabling dir_browser middleware }, 'host': 'localhost', 'dir_browser': {'davmount': False, 'enable': True, #Enabling directory browsing on dir_browser 'ms_mount': False, 'ms_sharepoint_plugin': True, 'ms_sharepoint_urls': False, 'response_trailer': ''}, 'port': self.listenPort, # Specifying listening port 'provider_mapping': {'/': self.WRoot} #Specifying root folder } app = WsgiDAVApp(config) server_args = { "bind_addr": (config["host"], config["port"]), "wsgi_app": app, } server = wsgi.Server(**server_args) try: server.start() except: logging.info(" [!] Ctrl + C detected, closing WebDAV sever") server.stop()
def run(self, handler): try: # First try to use the new version from cheroot.ssl.pyopenssl import pyOpenSSLAdapter from cheroot import wsgi server = wsgi.Server((self.host, self.port), handler, request_queue_size=32) except: from cherrypy.wsgiserver.ssl_pyopenssl import pyOpenSSLAdapter from cherrypy import wsgiserver server = wsgiserver.CherryPyWSGIServer((self.host, self.port), handler, request_queue_size=32) self.srv = server # If cert variable is has a valid path, SSL will be used # You can set it to None to disable SSL server.ssl_adapter = pyOpenSSLAdapter(Config.REST_SSL_CERTFILE, Config.REST_SSL_KEYFILE, Config.REST_SSL_CA_CERTS) try: server.start() finally: server.stop()
def run_webapp(self): from main.wsgi import application class Root: pass cherrypy.config.update({"environment": "production"}) static_app = cherrypy.tree.mount( Root(), "/", config={ "/": { "tools.staticdir.on": True, "tools.staticdir.dir": join(settings.ROOT_DIR, "public"), } }, ) addr = ("0.0.0.0", settings.HTTP_PLATFORM_PORT) dispatcher = wsgi.PathInfoDispatcher({ "/": application, "/static": static_app }) server = wsgi.Server(addr, dispatcher) self.logger.info("Starting webapp: {}".format(server._bind_addr)) server.safe_start()
def WSGIServer(server_address, wsgi_app): """Creates CherryPy WSGI server listening at `server_address` to serve `wsgi_app`. This function can be overwritten to customize the webserver or use a different webserver. """ from cheroot import wsgi server = wsgi.Server(server_address, wsgi_app, server_name='localhost') server.nodelay = not sys.platform.startswith('java') return server
def run(self): cx_Logging.Info("Running the web server") try: self.server = wsgi.Server((address, port), StaticFilesHandler(WSGIHandler())) self.server.start() except Exception as e: cx_Logging.ERROR("Exception: %s" % e)
def run(self, handler): server = wsgi.Server((self.host, self.port), handler) certificate, key = get_x509_material() server.ssl_adapter = BuiltinSSLAdapter(certificate, key) try: server.start() finally: server.stop()
def runserver(): app = WsgiDAVApp(DEFAULT_CONFIG) server_args = { "bind_addr": (DEFAULT_CONFIG["host"], DEFAULT_CONFIG["port"]), "wsgi_app": app, } server = wsgi.Server(**server_args) return server.start()
def main( filenames, port, host, prefix, incognito, debug, profile, profile_dir ): """Start Fava for FILENAMES on http://<host>:<port>. If the `BEANCOUNT_FILE` environment variable is set, Fava will use the files (space-delimited) specified there in addition to FILENAMES. Note you can also specify command-line options via environment variables. For example, `--host=0.0.0.0` is equivalent to setting the environment variable `FAVA_HOST=0.0.0.0`. """ if profile: # pragma: no cover debug = True env_filename = os.environ.get("BEANCOUNT_FILE") if env_filename: filenames = filenames + tuple(env_filename.split()) if not filenames: raise click.UsageError("No file specified") app.config["BEANCOUNT_FILES"] = filenames app.config["INCOGNITO"] = incognito if prefix: app.wsgi_app = DispatcherMiddleware( simple_wsgi, {prefix: app.wsgi_app} ) if not debug: server = wsgi.Server((host, port), app) print("Running Fava on http://{}:{}".format(host, port)) server.safe_start() else: if profile: from werkzeug.contrib.profiler import ProfilerMiddleware app.config["PROFILE"] = True app.wsgi_app = ProfilerMiddleware( app.wsgi_app, restrictions=(30,), profile_dir=profile_dir if profile_dir else None, ) app.jinja_env.auto_reload = True try: app.run(host, port, debug) except OSError as error: if error.errno == errno.EADDRINUSE: raise click.UsageError( "Can not start webserver because the port is already in " "use. Please choose another port with the '-p' option." ) raise
def create_wsgi_server(**conf): """Create test server.""" ssl_adapter = BuiltinSSLAdapter( certificate=conf.pop('certificate'), private_key=conf.pop('private_key'), certificate_chain=conf.pop('certificate_chain')) ssl_adapter.context.verify_mode = conf.pop('verify_mode', ssl.CERT_NONE) server = wsgi.Server(**conf) server.ssl_adapter = ssl_adapter return server
def run(self, handler): from cheroot.ssl.builtin import BuiltinSSLAdapter from cheroot import wsgi server = wsgi.Server((self.host, self.port), handler) self.srv = server server.ssl_adapter = BuiltinSSLAdapter(self._ssl_certfile, self._ssl_keyfile) try: server.start() finally: server.stop()
def start_davsrv(config=False): if config == False: config = commonConf app = WsgiDAVApp(config) server_args = { "bind_addr": (config["host"], config["port"]), "wsgi_app": app, } server = wsgi.Server(**server_args) server.start()
def setup(self): """ Generate the flask App and prepare the HTTP server. :return: server host and port tuple :rtype: ``Tuple[str, int]`` """ app, _ = generate_interactive_api(self.cfg.ihandler) self._server = wsgi.Server((self.cfg.host, self.cfg.port), app) self._server.prepare() return self._server.bind_addr
def run(self): """ Starts listening server""" logging.info(" [+] Starting Macro_Pack WebDAV server...") logging.info( " [-] Files in \"" + self.WRoot + r"\" folder are accessible using url http://{ip}:{port} or \\{ip}@{port}\DavWWWRoot" .format(ip=getHostIp(), port=self.listenPort)) logging.info(" [-] Listening on port %s (ctrl-c to exit)...", self.listenPort) # Prepare WsgiDAV config config = { 'middleware_stack': { WsgiDavDirBrowser, #Enabling dir_browser middleware }, 'verbose': 3, 'add_header_MS_Author_Via': True, 'unquote_path_info': False, 're_encode_path_info': None, 'host': '0.0.0.0', 'dir_browser': { 'davmount': False, 'enable': True, #Enabling directory browsing on dir_browser 'ms_mount': False, 'show_user': True, 'ms_sharepoint_plugin': True, 'ms_sharepoint_urls': False, 'response_trailer': False }, 'port': self.listenPort, # Specifying listening port 'provider_mapping': { '/': self.WRoot } #Specifying root folder } app = WsgiDAVApp(config) server_args = { "bind_addr": (config["host"], config["port"]), "wsgi_app": app, } server = wsgi.Server(**server_args) try: log = logging.getLogger('wsgidav') log.raiseExceptions = False # hack to avoid false exceptions log.propagate = True log.setLevel(logging.INFO) server.start() except KeyboardInterrupt: logging.info(" [!] Ctrl + C detected, closing WebDAV sever") server.stop()
def run(self): """Start up the server.""" subprocess.run(["flask", "db", "upgrade"], check=True) # pylint: disable=import-outside-toplevel import coverage coverage.process_startup() # pylint: disable=import-outside-toplevel from animeu.app import app self.app = app self.app.config["SERVER_NAME"] = f"{self.host}:{self.port}" self.server = wsgi.Server((self.host, self.port), self.app, max=1) self.server.start()
def run(self, handler): server = wsgi.Server((self.host, self.port), handler) certificate, key = get_x509_material() ssl_adapter = BuiltinSSLAdapter(certificate, key) ssl_adapter.context.options |= ssl.OP_NO_SSLv2 ssl_adapter.context.options |= ssl.OP_NO_SSLv3 ssl_adapter.context.options |= ssl.OP_NO_TLSv1 ssl_adapter.context.options |= ssl.OP_NO_TLSv1_1 server.ssl_adapter = ssl_adapter try: server.start() finally: server.stop()
def run(self, handler): server = wsgi.Server((self.host, self.port), handler) server.ssl_adapter = BuiltinSSLAdapter('cacert.pem', 'privkey.pem') # By default, the server will allow negotiations with extremely old protocols # that are susceptible to attacks, so we only allow TLSv1.2 server.ssl_adapter.context.options |= ssl.OP_NO_TLSv1 server.ssl_adapter.context.options |= ssl.OP_NO_TLSv1_1 try: server.start() finally: server.stop()
def handle(self, **options): from cheroot import wsgi # Determine the port number port = options["port"] # Determine the number of threads threads = options["threads"] if threads < 1: raise Exception("Invalid number of threads: %s" % threads) # Determine the IP-address to listen on: # - either as command line argument # - either 0.0.0.0 by default, which means all active IPv4 interfaces address = options["address"] or "0.0.0.0" # Validate the address and port number try: s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) s.bind((address, port)) s.close() except socket.error as e: raise Exception( "Invalid address '%s' and/or port '%s': %s" % (address, port, e) ) # Print a header message hostname = socket.getfqdn() print("Starting frePPLe %s web server\n" % VERSION) print( "To access the server, point your browser to either of the following URLS:" ) if address == "0.0.0.0": print(" http://%s:%s/" % (hostname, port)) for ip in socket.gethostbyname_ex(socket.gethostname())[2]: print(" http://%s:%s/" % (ip, port)) else: print(" http://%s:%s/" % (address, port)) print("Quit the server with CTRL-C.\n") # Run the WSGI server server = wsgi.Server( (address, port), StaticFilesHandler(WSGIHandler()), numthreads=threads ) # Want SSL support? Just set these attributes apparently, but I haven't tested or verified this # server.ssl_certificate = <filename> # server.ssl_private_key = <filename> try: server.start() except KeyboardInterrupt: server.stop()
def run(self, handler): # pragma: no cover from cheroot import wsgi from cheroot.ssl import builtin self.options['bind_addr'] = (self.host, self.port) self.options['wsgi_app'] = handler certfile = self.options.pop('certfile', None) keyfile = self.options.pop('keyfile', None) chainfile = self.options.pop('chainfile', None) self.server = wsgi.Server(**self.options) if certfile and keyfile: self.server.ssl_adapter = builtin.BuiltinSSLAdapter( certfile, keyfile, chainfile) self.server.start()
def run(self, handler): try: # First try to use the new version from cheroot import wsgi server = wsgi.Server((self.host, self.port), handler, request_queue_size=32) except: from cherrypy import wsgiserver server = wsgiserver.CherryPyWSGIServer((self.host, self.port), handler, request_queue_size=32) self.srv = server try: server.start() finally: server.stop()
def main(filenames, port, host, prefix, incognito, debug, profile, profile_dir): """Start Fava for FILENAMES on http://<host>:<port>. If the `BEANCOUNT_FILE` environment variable is set, Fava will use the files (space-delimited) specified there in addition to FILENAMES. """ if profile: # pragma: no cover debug = True env_filename = os.environ.get('BEANCOUNT_FILE') if env_filename: filenames = filenames + tuple(env_filename.split()) if not filenames: raise click.UsageError('No file specified') # TODO: do we actually support multiple filenames, when cli has nargs=-1? app.config['BEANCOUNT_FILES'] = filenames app.config['INCOGNITO'] = incognito if prefix: app.wsgi_app = DispatcherMiddleware(simple_wsgi, {prefix: app.wsgi_app}) if not debug: server = wsgi.Server((host, port), app) print('Running Fava on http://{}:{}'.format(host, port)) server.safe_start() else: if profile: from werkzeug.contrib.profiler import ProfilerMiddleware app.config['PROFILE'] = True app.wsgi_app = ProfilerMiddleware( app.wsgi_app, restrictions=(30, ), profile_dir=profile_dir if profile_dir else None) app.jinja_env.auto_reload = True try: app.run(host, port, debug) except OSError as error: if error.errno == errno.EADDRINUSE: raise click.UsageError( "Can not start webserver because the port is already in " "use. Please choose another port with the '-p' option.") else: # pragma: no cover raise
def run(self, handler): server = wsgi.Server((self.host, self.port), handler) server.ssl_adapter = BuiltinSSLAdapter('./certs/device.crt', './certs/device.key') # By default, the server will allow negotiations with extremely old # protocols that are susceptible to attacks, so only allow TLSv1.2 server.ssl_adapter.context.options |= ssl.OP_NO_TLSv1 server.ssl_adapter.context.options |= ssl.OP_NO_TLSv1_1 try: server.start() finally: log.info("Stopping web server.") server.stop()