def run(self):
if (self['Key'] == 'data/key.pem') and (self['Cert']
== 'data/cert.pem'):
if not os.path.exists(self['Key']) or not os.path.exists(
self['Cert']) or self['RegenCert']:
create_self_signed_cert()
config = Config()
config.ciphers = 'ALL'
config.accesslog = './data/logs/access.log'
config.bind = f"{self['BindIP']}:{self['Port']}"
config.certfile = self['Cert']
config.keyfile = self['Key']
config.include_server_header = False # This doesn't seem to do anything?
config.use_reloader = False
config.debug = False
"""
While we could use the standard decorators to register these routes,
using add_url_rule() allows us to create diffrent endpoint names
programmatically and pass the classes self object to the routes
"""
http_blueprint = Blueprint(__name__, 'https')
http_blueprint.before_request(self.check_if_naughty)
#http_blueprint.after_request(self.make_normal)
http_blueprint.add_url_rule('/<uuid:GUID>',
'key_exchange',
self.key_exchange,
methods=['POST'])
http_blueprint.add_url_rule('/<uuid:GUID>',
'stage',
self.stage,
methods=['GET'])
http_blueprint.add_url_rule('/<uuid:GUID>/jobs',
'jobs',
self.jobs,
methods=['GET'])
http_blueprint.add_url_rule('/<uuid:GUID>/jobs/<job_id>',
'job_result',
self.job_result,
methods=['POST'])
# Add a catch all route
http_blueprint.add_url_rule('/',
'unknown_path',
self.unknown_path,
defaults={'path': ''})
http_blueprint.add_url_rule('/<path:path>',
'unknown_path',
self.unknown_path,
methods=['GET', 'POST'])
#logging.getLogger('quart.app').setLevel(logging.DEBUG if state.args['--debug'] else logging.ERROR)
#logging.getLogger('quart.serving').setLevel(logging.DEBUG if state.args['--debug'] else logging.ERROR)
self.app = Quart(__name__)
self.app.register_blueprint(http_blueprint)
asyncio.run(serve(self.app, config))
def run(self):
"""
While we could use the standard decorators to register these routes,
using add_url_rule() allows us to create diffrent endpoint names
programmatically and pass the classes self object to the routes
"""
config = Config()
config.accesslog = os.path.join(get_path_in_data_folder("logs"), "access.log")
config.bind = f"{self['BindIP']}:{self['Port']}"
config.insecure_bind = True
config.include_server_header = False
config.use_reloader = False
config.debug = False
http_blueprint = Blueprint(__name__, 'http')
http_blueprint.before_request(self.check_if_naughty)
#http_blueprint.after_request(self.make_normal)
http_blueprint.add_url_rule('/<uuid:GUID>', 'key_exchange', self.key_exchange, methods=['POST'])
http_blueprint.add_url_rule('/<uuid:GUID>', 'stage', self.stage, methods=['GET'])
http_blueprint.add_url_rule('/<uuid:GUID>/jobs', 'jobs', self.jobs, methods=['GET'])
http_blueprint.add_url_rule('/<uuid:GUID>/jobs/<job_id>', 'job_result', self.job_result, methods=['POST'])
# Add a catch all route
http_blueprint.add_url_rule('/', 'unknown_path', self.unknown_path, defaults={'path': ''})
http_blueprint.add_url_rule('/<path:path>', 'unknown_path', self.unknown_path, methods=['GET', 'POST'])
#logging.getLogger('quart.app').setLevel(logging.DEBUG if state.args['--debug'] else logging.ERROR)
#logging.getLogger('quart.serving').setLevel(logging.DEBUG if state.args['--debug'] else logging.ERROR)
self.app = Quart(__name__)
self.app.register_blueprint(http_blueprint)
asyncio.run(serve(self.app, config))
def serve(
gateway: Gateway,
host: str = "localhost",
port: int = constants.DEFAULT_PORT_EDGE,
use_reloader: bool = True,
ssl_creds: Optional[Tuple[Any, Any]] = None,
**kwargs,
) -> None:
"""
Serve the given Gateway through a hypercorn server and block until it is completed.
:param gateway: the Gateway instance to serve
:param host: the host to expose the server on
:param port: the port to expose the server on
:param use_reloader: whether to use the reloader
:param ssl_creds: the ssl credentials (tuple of certfile and keyfile)
:param kwargs: any oder parameters that can be passed to the hypercorn.Config object
"""
config = Config()
config.bind = f"{host}:{port}"
config.use_reloader = use_reloader
if ssl_creds:
cert_file_name, key_file_name = ssl_creds
if cert_file_name:
kwargs["certfile"] = cert_file_name
if key_file_name:
kwargs["keyfile"] = key_file_name
for k, v in kwargs.items():
setattr(config, k, v)
loop = asyncio.get_event_loop()
loop.run_until_complete(
serve_hypercorn(AsgiGateway(gateway, event_loop=loop), config))
def run(self):
if (self['Key'] == f'{self.certs_path}/artic2_private.key') and (
self['Cert'] == f'{self.certs_path}/artic2_cert.pem'):
if not os.path.exists(get_path_in_data_folder(
"artic2_private.key")) or not os.path.exists(
get_path_in_data_folder(
"artic2_cert.pem")) or self['RegenCert']:
create_self_signed_cert()
config = Config()
config.ciphers = 'ALL'
config.accesslog = os.path.join(get_path_in_artic2("logs"),
"access.log")
config.bind = f"{self['BindIP']}:{self['Port']}"
config.certfile = os.path.expanduser(self['Cert'])
config.keyfile = os.path.expanduser(self['Key'])
config.include_server_header = False
config.use_reloader = False
config.debug = False
"""
While we could use the standard decorators to register these routes,
using add_url_rule() allows us to create diffrent endpoint names
programmatically and pass the classes self object to the routes
"""
http_blueprint = Blueprint(__name__, 'https')
http_blueprint.before_request(self.check_if_naughty)
http_blueprint.add_url_rule('/<uuid:GUID>',
'key_exchange',
self.key_exchange,
methods=['POST'])
http_blueprint.add_url_rule('/<uuid:GUID>',
'stage',
self.stage,
methods=['GET'])
http_blueprint.add_url_rule('/<uuid:GUID>/jobs',
'jobs',
self.jobs,
methods=['GET'])
http_blueprint.add_url_rule('/<uuid:GUID>/jobs/<job_id>',
'job_result',
self.job_result,
methods=['POST'])
http_blueprint.add_url_rule('/',
'unknown_path',
self.unknown_path,
defaults={'path': ''})
http_blueprint.add_url_rule('/<path:path>',
'unknown_path',
self.unknown_path,
methods=['GET', 'POST'])
self.app = Quart(__name__)
self.app.register_blueprint(http_blueprint)
asyncio.run(serve(self.app, config))
def run_command(info: ScriptInfo, host: str, port: int) -> None:
config = Config()
config.access_log_format = "%(h)s %(r)s %(s)s %(b)s %(D)s"
config.access_logger = create_serving_logger()
config.debug = True
config.error_logger = config.access_logger
config.host = host
config.port = port
config.use_reloader = True
run_single(info.load_app(), config)
def run_hypercorn(app: quart.Quart):
config = HyperConfig()
config.access_log_format = (
"%(h)s %(l)s %(u)s [%(asctime)s] \"%(r)s\" %(s)s %(b)s %(D)s")
config.accesslog = logging.getLogger('quart.serving')
config.bind = [app.config.get('LISTEN', 'localhost:5000')]
config.errorlog = config.accesslog
config.use_reloader = (app.env == 'development')
loop = asyncio.get_event_loop()
loop.add_signal_handler(signal.SIGTERM, _signal_handler)
loop.add_signal_handler(signal.SIGINT, _signal_handler)
loop.set_exception_handler(_loop_exception_handler)
loop.run_until_complete(
hypercorn_serve(
waterfurnace.app,
config,
shutdown_trigger=waterfurnace.app.shutdown_trigger.wait))
await websocket.send(rtn(1, "No Join"))
def get_tools(user_table, logger):
ctools = ClientTools(user_table, logger)
sstools = ServerSTools("pppwaw", ctools, logger)
sctools = ServerCTools(sstools, logger)
ctools.set_stools(sstools)
sstools.set_url_queue(sctools.urlqueue)
return ctools, sstools, sctools
if __name__ == '__main__':
logger = logging.getLogger(__name__)
logger.setLevel(logging.DEBUG)
logger.addHandler(logging.StreamHandler(sys.stdout))
config = Config()
config.bind = ["0.0.0.0:5700", ":::5700"]
config.access_logger = logger
config.error_logger = logger
config.use_reloader = False
ctools, stools, sctools = get_tools("user.json", logger)
web = lambda: asyncio.run(serve(app=app, config=config))
sts = lambda: sctools.main() # servertoserver
pool = [
multiprocessing.Process(target=web),
multiprocessing.Process(target=sts)
]
[i.start() for i in pool]
[i.join() for i in pool]