def start_server(config: Type[Config],
task_definitions: Dict[str, Tuple[int, Callable]]):
"""
Starts the flask application using a cheroot WSGI server
:param config: The configuration to use
:param task_definitions: The background tasks, consisting of:
- the name of the task
- the time to wait before running
the task again
- a function that takes no arguments that
executes the task
:return: None
"""
if not config.TELEGRAM_API_KEY == "" \
and not config.TESTING \
and config.TELEGRAM_WHOAMI: # pragma: no cover
try:
config.initialize_telegram()
Config.TELEGRAM_BOT_CONNECTION.bot.logger.setLevel(logging.WARNING)
except TimedOut:
print("Could not initialize telegram")
sys.exit(1)
task_definitions.update({"telegram_bg": (30, telegram_whoami)})
__start_background_tasks(task_definitions)
app.logger.info("STARTING FLASK")
server = Server(("0.0.0.0", config.HTTP_PORT),
PathInfoDispatcher({"/": app}))
try:
server.start()
except KeyboardInterrupt:
server.stop()
def run_server(self, port=None):
log.info("home_dir %s",config.get('DEFAULT', 'home_dir'))
log.info("hydra_base_dir %s",config.get('DEFAULT', 'hydra_base_dir'))
log.info("common_app_data_folder %s",config.get('DEFAULT', 'common_app_data_folder'))
log.info("win_common_documents %s",config.get('DEFAULT', 'win_common_documents'))
log.info("sqlite url %s",config.get('mysqld', 'url'))
log.info("layout_xsd_path %s",config.get('hydra_server', 'layout_xsd_path'))
log.info("default_directory %s",config.get('plugin', 'default_directory'))
log.info("result_file %s",config.get('plugin', 'result_file'))
log.info("plugin_xsd_path %s",config.get('plugin', 'plugin_xsd_path'))
log.info("log_config_path %s",config.get('logging_conf', 'log_config_path'))
if port is None:
port = config.getint('hydra_server', 'port', 8080)
domain = config.get('hydra_server', 'domain', '127.0.0.1')
check_port_available(domain, port)
spyne.const.xml_ns.DEFAULT_NS = 'soap_server.hydra_complexmodels'
cp_wsgi_application = Server((domain,port), application, numthreads=10)
log.info("listening to http://%s:%s", domain, port)
log.info("wsdl is at: http://%s:%s/soap/?wsdl", domain, port)
try:
cp_wsgi_application.start()
except KeyboardInterrupt:
cp_wsgi_application.stop()
def run_webserver():
server = WSGIServer(bind_addr=(MY_IP, int(MY_PORT)),
wsgi_app=app,
numthreads=100)
print(
"[DDR_INSTALLER][INFO] ------------------------------------------------------------------------"
)
print("[DDR_INSTALLER][INFO] Starting IDA plugin installation.")
print(
"[DDR_INSTALLER][INFO] Please go to your IDA machine and point your browser to:\n"
)
print("[DDR_INSTALLER][INFO] http://{}:{}\n".format(MY_IP, MY_PORT))
print(
"[DDR_INSTALLER][INFO] Once you are done installing the IDA plugin, hit Ctrl-C here to stop the"
)
print("[DDR_INSTALLER][INFO] webserver and proceed with the installation.")
print(
"[DDR_INSTALLER][INFO] ------------------------------------------------------------------------"
)
try:
server.start()
except KeyboardInterrupt:
server.stop()
except:
print(
"[DDR_INSTALLER][ERROR] Failed to start installation server. Please check if you"
)
print(
"[DDR_INSTALLER][ERROR] have configured a valid NGINX IP address above.\n"
)
raise
class WebServer(Thread):
def __init__(self,
port=defaults.WEB_SERVER_PORT,
static_path=TESTPLAN_UI_STATIC_DIR,
data_path='./',
report_name=TESTPLAN_REPORT):
super(WebServer, self).__init__()
self.host = defaults.WEB_SERVER_HOSTNAME
self.port = port
self.static_path = static_path
self.data_path = data_path
self.report_name = report_name
self.server = None
def _configure_flask_app(self):
app.config['STATIC_PATH'] = self.static_path
app.config['DATA_PATH'] = self.data_path
app.config['TESTPLAN_REPORT_NAME'] = self.report_name
app.static_folder = os.path.abspath(
os.path.join(app.config['STATIC_PATH'], 'testing', 'build',
'static'))
def run(self):
self._configure_flask_app()
dispatcher = PathInfoDispatcher({'/': app})
self.server = WSGIServer((self.host, self.port), dispatcher)
self.server.start()
def ready(self):
if self.server:
return self.server.ready
return False
def stop(self):
self.server.stop()
def runtime(self, flask_instance: Flask, mode: int = ENABLE_FLASK):
"""
This method deploys a REST endpoint as using different technologies according to the "mode" value.
This endpoint will listen for incoming REST requests on different route paths.
"""
if mode == ENABLE_FLASK:
# simply run Flask
flask_instance.run(host=self._listening_address,
port=self._listening_port,
threaded=True)
elif mode == ENABLE_CHERRYPY:
# Run Flask wrapped by Cherrypy
cherrypy.tree.graft(flask_instance, "/")
cherrypy.config.update({
"server.socket_host": self._listening_address,
"server.socket_port": self._listening_port,
"engine.autoreload.on": False,
})
cherrypy.engine.start()
cherrypy.engine.block()
elif mode == ENABLE_WSGISERVER:
# Run Flask wrapped by a WSGI Server.
dispatcher = PathInfoDispatcher({'/': flask_instance})
server = WSGIServer(
(self._listening_address, self._listening_port), dispatcher)
try:
server.start()
# server.block
except KeyboardInterrupt:
server.stop()
else:
raise RuntimeError("Invalid runtime mode was selected.")
def start_server(options):
"""
Start CherryPy server
"""
if options['daemonize'] and options['server_user'] and options['server_group']:
# ensure the that the daemon runs as specified user
change_uid_gid(options['server_user'], options['server_group'])
try:
from cheroot.wsgi import Server as Server
except ImportError:
from cherrypy.wsgiserver import CherryPyWSGIServer as Server
from django.core.handlers.wsgi import WSGIHandler
server = Server(
(options['host'], int(options['port'])),
WSGIHandler(),
int(options['threads']),
options['server_name']
)
if options['ssl_certificate'] and options['ssl_private_key']:
server.ssl_certificate = options['ssl_certificate']
server.ssl_private_key = options['ssl_private_key']
try:
server.start()
except KeyboardInterrupt:
server.stop()
def start_ui(url, port, interpreter, quiet, language):
openurl = "localhost" if url == "0.0.0.0" else url
if not quiet:
print("Booting CherryPy server...")
d = PathInfoDispatcher({'/': create_app(interpreter, language)})
server = WSGIServer((url, port), d)
try:
p = multiprocessing.Process(target=delayed_browser_open,
args=(openurl, port))
p.start()
if not quiet:
print("Hosting at http://" + openurl + ":" + str(port) +
"/#loaded")
server.start()
except KeyboardInterrupt:
if not quiet:
print("Stopping CherryPy server...")
server.stop()
if not quiet:
print("Stopped")
def start_ui(url, port, interpreter, quiet):
openurl = "localhost" if url == "0.0.0.0" else url
if not quiet:
print("Initializing CherryPy server...")
os.environ["FLASK_APP"] = "satyrnUI.satyrnUI"
os.environ["FLASK_ENV"] = "production"
d = PathInfoDispatcher({'/': create_app(interpreter)})
server = WSGIServer((url, port), d)
try:
p = multiprocessing.Process(target=delayed_browser_open,
args=(openurl, port))
p.start()
if not quiet:
print("Hosting at http://" + openurl + ":" + str(port) +
"/#loaded")
server.start()
except KeyboardInterrupt:
if not quiet:
print("Stopping CherryPy server...")
server.stop()
if not quiet:
print("Stopped")
def main(argv=sys.argv[1:]) -> int:
"""main entry point for the autotradeweb server"""
parser = get_parser()
args = parser.parse_args(argv)
init_logging(args, "autotradeweb.log")
# monkey patch courtesy of
# https://github.com/noirbizarre/flask-restplus/issues/54
# so that /swagger.json is served over https
if not args.disable_https:
@property
def specs_url(self):
"""Monkey patch for HTTPS"""
return url_for(self.endpoint("specs"), _external=True, _scheme="https")
Api.specs_url = specs_url
__log__.info("starting server: host: {} port: {}".format(args.host, args.port))
APP.config["SQLALCHEMY_DATABASE_URI"] = args.database
if args.debug:
APP.run(host=args.host, port=args.port, debug=True)
else:
path_info_dispatcher = PathInfoDispatcher({"/": APP})
# See SRS: S.8.R.4
server = WSGIServer((args.host, args.port), path_info_dispatcher)
try:
server.start()
except KeyboardInterrupt:
__log__.info("stopping server: KeyboardInterrupt detected")
server.stop()
return 0
except Exception:
__log__.exception("stopping server: unexpected exception")
raise
def wsgi_serve(
wsgi_handler: Callable,
host: str = "127.0.0.1",
port: int = 80,
workers: int = 1,
) -> None:
wsgi_server = Server((host, port), wsgi_handler, numthreads=workers)
wsgi_server.start()
def initiate():
log_main.info('Iniciando a API versão: {}'.format(app_version))
signal.signal(signal.SIGTERM, finalize)
signal.signal(signal.SIGINT, finalize)
global token, database, sms
token = conf.get('Auth',
'Token',
fallback='14acd1c3b2f50c1e7354668f7d0b4057')
ttvToken = open(
os.path.join(workdir, conf.get('Auth', 'TokenTTV', fallback=False)),
'r')
sms = SMS(ttvToken.readline())
ttvToken.close()
log_main.warning('Iniciando conexão com banco de dados ...')
try:
db = os.path.join(workdir,
conf.get('Database', 'Database', fallback='data.db'))
database = Database(db)
except Exception as e:
log_main.exception(
'Erro ao iniciar a conexão com o banco de dados: [{}]'.format(e))
_port = conf.getint('Flask', 'Port', fallback=8860)
_host = conf.get('Flask', 'Host', fallback='0.0.0.0')
_threads = conf.getint('Flask', 'Threads', fallback=100)
_ssl_cert = os.path.join(workdir, 'SSL',
conf.get('Flask', 'SSL_Cert', fallback=''))
_ssl_key = os.path.join(workdir, 'SSL',
conf.get('Flask', 'SSL_Key', fallback=''))
try:
_ssl_enabled = os.path.isfile(_ssl_cert) and os.path.isfile(_ssl_key)
except Exception:
_ssl_enabled = False
if len(sys.argv) > 1:
if sys.argv[1] in ('-v', '--version'):
print('API')
print('Versão: {}'.format(app_version))
sys.exit(0)
elif sys.argv[1] in ('-d', '--debug'):
app.run(host=_host, port=_port, threaded=True, debug=True)
else:
print('ERRO | Parâmetro desconhecido: {}'.format(sys.argv))
sys.exit(2)
else:
global server
server = WSGIServer(bind_addr=(_host, _port),
wsgi_app=app,
numthreads=_threads)
if _ssl_enabled:
server.ssl_adapter = BuiltinSSLAdapter(_ssl_cert, _ssl_key)
log_main.warning('Iniciando flask ...')
server.start()
def launch_server(host, port, app, **kwargs):
"""Use cheroot WSGI server, a multithreaded scallable server."""
server = Server((host, port), app, **kwargs)
logging.info("Starting server, listening on port %s", port)
try:
server.start()
except KeyboardInterrupt:
server.stop()
def launch_server(host, port, app, **kwargs):
"""Use cheroot WSGI server, a multithreaded scallable server."""
server = Server((host, port), app, **kwargs)
logging.info("Starting server, listening on port %s", port)
try:
server.start()
except KeyboardInterrupt:
server.stop()
def start_rest_service(port, num_threads, ovms_port):
available_models = get_available_models()
dispatcher = PathInfoDispatcher(
{'/': create_dispatcher(available_models, ovms_port)})
server = WSGIServer(('0.0.0.0', port), dispatcher, numthreads=num_threads)
logger.info(f"AMS service will start listening on port {port}")
try:
server.start()
except KeyboardInterrupt:
server.stop()
def run(self, handler):
cert = SSL_CERT
#cert_chain = SSL_CERT_CHAIN
privkey = SSL_PRIVKEY
server = WSGIServer((self.host, self.port), handler)
server.ssl_adapter = SecuredSSLServer(cert, privkey) #, cert_chain)
try:
server.start()
finally:
server.stop()
def _flaskthread(self):
if self.debug:
self.app.run(host=self.host, port=self.port, debug=self.debug)
else:
wsgi_server = WSGIServer(bind_addr=("0.0.0.0", self.wsgi_port),
wsgi_app=self.app,
numthreads=100)
try:
wsgi_server.start()
except KeyboardInterrupt:
wsgi_server.stop()
def run(self, handler):
from cheroot.wsgi import Server
self.options['bind_addr'] = (self.host, self.port)
self.options['wsgi_app'] = handler
server = Server(**self.options)
try:
server.start()
finally:
server.stop()
class Controller (object):
def listen(self):
print("listening")
self.server = WSGIServer(('0.0.0.0', 8000), webapp)
# run(webapp, server=self.server)
# run(webapp, server='bjoern', port=8000)
self.server.start()
def shutdown(self):
self.server.stop()
print("done listening")
def start_web_rest_server(models, rest_port):
d = PathInfoDispatcher({'/': create_rest_api(models)})
server = WSGIServer(('0.0.0.0', rest_port),
d,
numthreads=1,
request_queue_size=50)
try:
server.start()
except KeyboardInterrupt:
server.stop()
def run(self, handler):
try:
from cheroot.wsgi import Server as WSGIServer
except ImportError:
from cherrypy.wsgiserver import CherryPyWSGIServer as WSGIServer
server = WSGIServer((self.host, self.port), handler)
try:
server.start()
finally:
server.stop()
def run(self, handler):
from cheroot.wsgi import Server as WSGIServer
from cheroot.ssl.pyopenssl import pyOpenSSLAdapter
server = WSGIServer((self.host, self.port), handler)
server.ssl_adapter = pyOpenSSLAdapter(
certificate=SolUtils.AppConfig().get('solserver_certificate'),
private_key=SolUtils.AppConfig().get('solserver_private_key'),
)
try:
server.start()
log.info("Server started")
finally:
server.stop()
def main():
args = get_args()
app = create_app(args.output)
d = PathInfoDispatcher({"/": app})
server = WSGIServer((args.netmask, args.port), d)
try:
print(f"Logging location set to: {args.output}")
print(f"Listening on {args.netmask}:{args.port}....")
server.start()
except KeyboardInterrupt:
print("Exiting....")
sys.exit(0)
def start_web_rest_server(models, rest_port, num_threads):
d = PathInfoDispatcher({'/': create_rest_api(models)})
server = WSGIServer(('0.0.0.0', rest_port), d,
numthreads=num_threads,
request_queue_size=GLOBAL_CONFIG[
'rest_requests_queue_size'])
logger.info("REST server listens on port {port} and will be "
"serving models: {models}".format(port=rest_port,
models=list(models.keys())))
try:
server.start()
except KeyboardInterrupt:
server.stop()
class CherryPyServer(ServerAdapter):
def run(self, handler):
try:
from cheroot.wsgi import Server as CherryPyWSGIServer
except ImportError:
from cherrypy.wsgiserver import CherryPyWSGIServer
self.server = CherryPyWSGIServer((self.host, self.port), handler)
try:
self.server.start()
finally:
self.server.stop()
def stop(self):
if hasattr(self, 'server'):
self.server.stop()
def start_server(config):
from cheroot.wsgi import Server as WSGIServer
hostname = config['server_host']['host']
port = int(config['server_host']['port'])
scheme = config['server_host']['scheme']
app = load_app()
server = WSGIServer((hostname, port), app)
try:
LOGGER.debug('starting Cheroot at %s://%s:%s',
scheme, hostname, port)
std_error_message("Starting Cheroot at %s://%s:%s"
% (scheme, hostname, port))
server.start()
except KeyboardInterrupt:
server.stop()
sys.exit(0)
def run(self):
logger.info(
f"HTTP server listens on http://{self.host}:{self.port}{self.endpoint}"
)
if self.agent:
self.agent.server_status.starttime = datetime.now()
if self.debug:
self.app.run(host=self.host, port=self.port, debug=self.debug)
else:
wsgi_server = WSGIServer(bind_addr=("0.0.0.0", self.wsgi_port),
wsgi_app=self.app,
numthreads=100)
try:
wsgi_server.start()
except KeyboardInterrupt:
wsgi_server.stop()
def run(self, handler):
"""
Runs a CherryPy Server using the SSL certificate.
"""
from cheroot.wsgi import Server as CherryPyWSGIServer
from cheroot.ssl.builtin import BuiltinSSLAdapter
server = CherryPyWSGIServer((self.host, self.port), handler)
server.ssl_adapter = BuiltinSSLAdapter(
certificate=get_ssl_certificate(),
private_key=get_ssl_private_key(),
certificate_chain=get_ssl_certificate_chain()
if get_ssl_certificate_chain() != "" else None)
try:
server.start()
except Exception as ex:
LOG.error('Unable to start SSL server: %s' % ex)
server.stop()
def run(self, handler):
"""
Run server
"""
try:
from cheroot.wsgi import Server as WSGIServer
except ImportError:
from cherrypy.wsgiserver import CherryPyWSGIServer as WSGIServer
global server
# server = wsgiserver.CherryPyWSGIServer((self.host, self.port), handler)
server = WSGIServer((self.host, self.port), handler)
# cert = 'server.pem' # certificate path
# server.ssl_certificate = cert
# server.ssl_private_key = cert
try:
server.start()
finally:
server.stop()
class HTTPServer:
def __init__(self, port=8090):
self.mappings = {}
self.port = port
self.server = CherryPyWSGIServer(("0.0.0.0", port),
self,
server_name="localhost")
self.started = False
self.t = threading.Thread(target=self._start)
self.t.start()
time.sleep(0.1)
def _start(self):
try:
self.server.start()
except Exception as e:
print('ERROR: failed to start server', str(e))
def stop(self):
self.server.stop()
self.t.join()
def request(self, path, method='GET', query=None):
query = query or {}
response = Respose()
if isinstance(query, dict):
query = urllib.parse.urlencode(query)
self.mappings[path, method, query] = response
return response
def __call__(self, environ, start_response):
_method = environ.get('REQUEST_METHOD', 'GET')
_path = environ.get('PATH_INFO')
for (path, method, query_string), response in self.mappings.items():
if _path == path and _method == method:
return response(start_response)
return Respose()(start_response)
def run(self, handler): # pragma: no cover
from cheroot.wsgi import Server as WSGIServer
self.options['bind_addr'] = (self.host, self.port)
self.options['wsgi_app'] = handler
certfile = self.options.get('certfile')
if certfile:
del self.options['certfile']
keyfile = self.options.get('keyfile')
if keyfile:
del self.options['keyfile']
server = WSGIServer(**self.options)
if certfile:
server.ssl_certificate = certfile
if keyfile:
server.ssl_private_key = keyfile
try:
server.start()
finally:
server.stop()
def main():
clear_screen()
print_logo()
with AdbInstaller() as installer:
installer.install()
AdbWrapper().disconnect_all()
success("Açık kalan ADB bağlantıları kapatıldı!")
web.api_key = "Girilmedi!"
success("Sunucu başlatılıyor!")
try:
http_server = WSGIServer(("127.0.0.1", 5000),
PathInfoDispatcher({'/': website_app}))
success("Sunucu başlatıldı!")
success("Arayüz adresi: http://localhost:5000")
http_server.start()
except KeyboardInterrupt:
clear_screen()
success("Kapatılıyor!")
_exit(0)
def run_server(self, port=None):
log.info("home_dir %s", config.get('DEFAULT', 'home_dir'))
log.info("hydra_base_dir %s", config.get('DEFAULT', 'hydra_base_dir'))
log.info("common_app_data_folder %s",
config.get('DEFAULT', 'common_app_data_folder'))
log.info("win_common_documents %s",
config.get('DEFAULT', 'win_common_documents'))
log.info("sqlite url %s", config.get('mysqld', 'url'))
log.info("layout_xsd_path %s",
config.get('hydra_server', 'layout_xsd_path'))
log.info("default_directory %s",
config.get('plugin', 'default_directory'))
log.info("result_file %s", config.get('plugin', 'result_file'))
log.info("plugin_xsd_path %s", config.get('plugin', 'plugin_xsd_path'))
log.info("log_config_path %s",
config.get('logging_conf', 'log_config_path'))
if port is None:
port = config.getint('hydra_server', 'port', 8080)
domain = config.get('hydra_server', 'domain', '127.0.0.1')
check_port_available(domain, port)
spyne.const.xml_ns.DEFAULT_NS = 'soap_server.hydra_complexmodels'
cp_wsgi_application = Server((domain, port),
application,
numthreads=10)
log.info("listening to http://%s:%s", domain, port)
log.info("wsdl is at: http://%s:%s/soap/?wsdl", domain, port)
try:
cp_wsgi_application.start()
except KeyboardInterrupt:
cp_wsgi_application.stop()
if sucess_login:
session['logged_in'] = True
logger.info("{ip} successfully looged in".format(ip=ip))
flash('You were successfully logged in!')
else:
logger.warning(
"{ip} attempted to log in with wrong password".format(ip=ip))
flash('wrong password!')
return index()
##################################################
# END API part
##################################################
if __name__ == "__main__":
log_manager = LogManager()
logger = log_manager.logger
logger.info('Running Flask Server on http://localhost:{port}'.format(
port=os.environ.get("SERVER_PORT")))
app.secret_key = os.urandom(12)
server = WSGIServer(('0.0.0.0', int(os.environ.get("SERVER_PORT"))),
app,
numthreads=int(os.environ.get("SERVER_NUM_THREADS")))
try:
server.start()
except KeyboardInterrupt:
logger.critical("KeyboardInterrupt")
sign_alg = None
digest_alg = None
try:
sign_alg = CONFIG.SIGN_ALG
except AttributeError:
pass
try:
digest_alg = CONFIG.DIGEST_ALG
except AttributeError:
pass
ds.DefaultSignature(sign_alg, digest_alg)
SRV = WSGIServer((HOST, PORT), application)
_https = ""
if CONFIG.HTTPS:
https = "using HTTPS"
# SRV.ssl_adapter = ssl_pyopenssl.pyOpenSSLAdapter(
# config.SERVER_CERT, config.SERVER_KEY, config.CERT_CHAIN)
SRV.ssl_adapter = BuiltinSSLAdapter(CONFIG.SERVER_CERT,
CONFIG.SERVER_KEY,
CONFIG.CERT_CHAIN)
logger.info("Server starting")
print("IDP listening on %s:%s%s" % (HOST, PORT, _https))
try:
SRV.start()
except KeyboardInterrupt:
SRV.stop()
POLICY = service_conf.POLICY
add_urls()
sign_alg = None
digest_alg = None
try:
sign_alg = service_conf.SIGN_ALG
except:
pass
try:
digest_alg = service_conf.DIGEST_ALG
except:
pass
ds.DefaultSignature(sign_alg, digest_alg)
SRV = WSGIServer((HOST, PORT), ToBytesMiddleware(application))
_https = ""
if service_conf.HTTPS:
SRV.ssl_adapter = pyopenssl.pyOpenSSLAdapter(
SERVER_CERT, SERVER_KEY, CERT_CHAIN
)
_https = " using SSL/TLS"
logger.info("Server starting")
print("SP listening on %s:%s%s" % (HOST, PORT, _https))
try:
SRV.start()
except KeyboardInterrupt:
SRV.stop()
def cherrypy_server_runner(
app, global_conf=None, host='127.0.0.1', port=None,
ssl_pem=None, protocol_version=None, numthreads=None,
server_name=None, max=None, request_queue_size=None,
timeout=None
): # pragma: no cover
"""
Entry point for CherryPy's WSGI server
Serves the specified WSGI app via CherryPyWSGIServer.
``app``
The WSGI 'application callable'; multiple WSGI applications
may be passed as (script_name, callable) pairs.
``host``
This is the ipaddress to bind to (or a hostname if your
nameserver is properly configured). This defaults to
127.0.0.1, which is not a public interface.
``port``
The port to run on, defaults to 8080 for HTTP, or 4443 for
HTTPS. This can be a string or an integer value.
``ssl_pem``
This an optional SSL certificate file (via OpenSSL) You can
generate a self-signed test PEM certificate file as follows:
$ openssl genrsa 1024 > host.key
$ chmod 400 host.key
$ openssl req -new -x509 -nodes -sha1 -days 365 \\
-key host.key > host.cert
$ cat host.cert host.key > host.pem
$ chmod 400 host.pem
``protocol_version``
The protocol used by the server, by default ``HTTP/1.1``.
``numthreads``
The number of worker threads to create.
``server_name``
The string to set for WSGI's SERVER_NAME environ entry.
``max``
The maximum number of queued requests. (defaults to -1 = no
limit).
``request_queue_size``
The 'backlog' argument to socket.listen(); specifies the
maximum number of queued connections.
``timeout``
The timeout in seconds for accepted connections.
"""
is_ssl = False
if ssl_pem:
port = port or 4443
is_ssl = True
if not port:
if ':' in host:
host, port = host.split(':', 1)
else:
port = 8080
bind_addr = (host, int(port))
kwargs = {}
for var_name in ('numthreads', 'max', 'request_queue_size', 'timeout'):
var = locals()[var_name]
if var is not None:
kwargs[var_name] = int(var)
try:
from cheroot.wsgi import Server as WSGIServer
except ImportError:
from cherrypy.wsgiserver import CherryPyWSGIServer as WSGIServer
server = WSGIServer(bind_addr, app,
server_name=server_name, **kwargs)
if ssl_pem is not None:
if PY2:
server.ssl_certificate = server.ssl_private_key = ssl_pem
else:
# creates wsgiserver.ssl_builtin as side-effect
try:
from cheroot.server import get_ssl_adapter_class
from cheroot.ssl.builtin import BuiltinSSLAdapter
except ImportError:
from cherrypy.wsgiserver import get_ssl_adapter_class
from cherrypy.wsgiserver.ssl_builtin import BuiltinSSLAdapter
get_ssl_adapter_class()
server.ssl_adapter = BuiltinSSLAdapter(ssl_pem, ssl_pem)
if protocol_version:
server.protocol = protocol_version
try:
protocol = is_ssl and 'https' or 'http'
if host == '0.0.0.0':
print('serving on 0.0.0.0:%s view at %s://127.0.0.1:%s' %
(port, protocol, port))
else:
print('serving on %s://%s:%s' % (protocol, host, port))
server.start()
except (KeyboardInterrupt, SystemExit):
server.stop()
return server
def cherrypy(app, address, **options):
from cheroot.wsgi import Server as WSGIServer
server = WSGIServer(address, app)
server.start()
