def main(argv=sys.argv[1:]) -> int:
"""main entry point for ghast"""
parser = get_parser()
args = parser.parse_args(argv)
init_logging(args, "ghast.log")
__log__.info("starting ghast server on "
"host: {} port: {} "
"graylog_http_alert_url: {} "
"graylog_http_alert_script: {}".format(
args.host, args.port, args.graylog_http_alert_url,
args.graylog_http_alert_script))
# Setup and start the flask / cheroot server
ghast.server.API_HTTPS = args.api_https
ghast.server.ALERT_SCRIPT_PATH = args.graylog_http_alert_script
ghast.server.APP.register_blueprint(ghast.server.API_BLUEPRINT,
url_prefix=args.graylog_http_alert_url)
if args.debug:
ghast.server.APP.run(host=args.host, port=args.port, debug=True)
else:
path_info_dispatcher = PathInfoDispatcher({'/': ghast.server.APP})
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
return 0
def test_dispatch_no_script_name():
"""Despatch despite lack of SCRIPT_NAME in environ."""
# Bare bones WSGI hello world app (from PEP 333).
def app(environ, start_response):
start_response(
'200 OK', [
('Content-Type', 'text/plain; charset=utf-8'),
],
)
return [u'Hello, world!'.encode('utf-8')]
# Build a dispatch table.
d = PathInfoDispatcher([
('/', app),
])
# Dispatch a request without `SCRIPT_NAME`.
response = wsgi_invoke(
d, {
'PATH_INFO': '/foo',
},
)
assert response == {
'status': '200 OK',
'headers': [
('Content-Type', 'text/plain; charset=utf-8'),
],
'body': b'Hello, world!',
}
def run(self):
import utils.runtime_handler
utils.runtime_handler.enable_traceback_hook(
) # Enable custom traceback handling (to strip build path info)
self._shutdown_handler.add_task()
if self._use_ssl:
self._init_ssl()
ks = _KeyStore.query.first()
if ks is not None:
_app.config['SECRET_KEY'] = ks.flask_secret
else:
# Temporary static key for first run. We should roll this occasionally.
_app.config[
'SECRET_KEY'] = b'\xee\xf0\xabc>\xc8\xa4S\xa1\x89\xff\xa3\xaf\xcfX\xac'
self._jwt = JWT(_app, user_authenticate, user_identity)
self._wsgi_server = WSGIServer((self._host, int(self._port)),
PathInfoDispatcher({'/': _app}))
# TODO: Issue with SSL:
# Firefox causes a (socket.error 1) exception to be thrown on initial connection (before accepting cert)
# This is internal to cheroot, so it may be difficult to handle
print('LiquiTrader is ready for action!')
print(
f'Visit http{"s" if self._use_ssl else ""}://{self._host}:{self._port} in your favorite browser'
)
print('to start trading!')
self._wsgi_server.start()
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 get_server(cmd_line_args):
args = _parse_args(cmd_line_args)
logger = _get_logger(args)
a = create_app([args['sql_source']], {})
d = PathInfoDispatcher({'/': a})
server = WSGIServer((args['url'], args['port']), d)
return logger, server, a
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 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 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 main(argv=sys.argv[1:]) -> int:
"""main entry point undiscord flask/cheroot server"""
parser = get_parser()
args = parser.parse_args(argv)
init_logging(args, "undiscord_server.log")
graph_dir = os.path.abspath(args.graph_dir)
os.makedirs(graph_dir, exist_ok=True)
__log__.info("starting server: host: {} port: {} graph_dir: {}".format(
args.host, args.port, graph_dir))
undiscord.server.server.GRAPH_DIR = graph_dir
if args.debug:
undiscord.server.server.APP.run(host=args.host,
port=args.port,
debug=True)
else:
path_info_dispatcher = PathInfoDispatcher(
{'/': undiscord.server.server.APP})
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 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_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 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 setUp(self):
self.app = create_app(TestConfig)
self.app_context = self.app.app_context()
self.app_context.push()
db.create_all()
d = PathInfoDispatcher({'/': self.app})
self.server = WSGIServer(('0.0.0.0', 5000), d)
Thread(target=self.server.start).start()
self.driver = webdriver.Firefox()
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()
def start(self):
d = PathInfoDispatcher({'/': self.app})
self.server = Server(('0.0.0.0', self.rpcport), d)
self.proxy_thread = threading.Thread(target=self.server.start)
self.proxy_thread.daemon = True
self.proxy_thread.start()
# Now that bitcoind is running on the real rpcport, let's tell all
# future callers to talk to the proxyport. We use the bind_addr as a
# signal that the port is bound and accepting connections.
while self.server.bind_addr[1] == 0:
pass
self.rpcport = self.server.bind_addr[1]
logging.debug("BitcoinRpcProxy proxying incoming port {} to {}".format(self.rpcport, self.bitcoind.rpcport))
def start(self):
d = PathInfoDispatcher({"/": self.app})
self.server = Server(("0.0.0.0", self.proxyport), d)
self.proxy_thread = threading.Thread(target=self.server.start)
self.proxy_thread.daemon = True
self.proxy_thread.start()
BitcoinD.start(self)
# Now that bitcoind is running on the real rpcport, let's tell all
# future callers to talk to the proxyport. We use the bind_addr as a
# signal that the port is bound and accepting connections.
while self.server.bind_addr[1] == 0:
pass
self.proxiedport = self.rpcport
self.rpcport = self.server.bind_addr[1]
logging.debug(
"bitcoind reverse proxy listening on {}, forwarding to {}".format(
self.rpcport, self.proxiedport
)
)
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 start(ip, port, head_callback, front_callback):
global listening
global server
global head_process_callback
global front_process_callback
if hasattr(thismodule, "listening") and listening:
return
head_process_callback = head_callback
front_process_callback = front_callback
listening = True
current_ip = os.environ.get('SERVER_HOST', str(ip))
try:
current_port = int(os.environ.get('SERVER_PORT', str(port)))
except ValueError:
current_port = port
d = PathInfoDispatcher({'/': web_server})
server = Server((current_ip, current_port), d)
server.safe_start()
from flask_jwt_extended import JWTManager, jwt_required, jwt_refresh_token_required, get_jwt_identity, get_raw_jwt
import logging
LOGGINGFORMAT = '%(asctime)-15s %(levelname)-8s %(name)-8s %(message)s'
logging.basicConfig(level=logging.DEBUG,
format=LOGGINGFORMAT,
datefmt='%d-%b-%y %H:%M:%S')
mapp = Flask(__name__)
mapp.secret_key = 'super secret key'
mapp.config['PROPAGATE_EXCEPTIONS'] = True
mapp.config['JWT_SECRET_KEY'] = 'test-123'
mapp.config['JWT_DECODE_AUDIENCE'] = 'testapp'
mapp.config['JWT_ENCODE_AUDIENCE'] = 'testapp'
api.init_app(mapp)
jwt = JWTManager(mapp)
#register error handlers (inbuilt)
jwt._set_error_handler_callbacks(api)
#host multiple instances
d = PathInfoDispatcher({'/product-api': mapp})
server = WSGIServer(('0.0.0.0', 8083), d)
#docker run -d -p 8088:8088 -t nginx
#start web server
try:
server.start()
except KeyboardInterrupt:
server.stop()
from flask import Flask
from flask_restful import Api
from cheroot.wsgi import Server as WSGIServer, PathInfoDispatcher
from viridi.resources.city_data import CityData
from viridi.resources.city_news import CityNews
APP = Flask(__name__)
API = Api(APP)
DISPATCHER = PathInfoDispatcher({'/': APP})
SERVER = WSGIServer(('0.0.0.0', 8080), DISPATCHER)
API.add_resource(CityData, '/data')
API.add_resource(CityNews, '/news')
if __name__ == '__main__':
print('Running on port 8080')
SERVER.safe_start()
LOGGINGFORMAT = '%(asctime)-15s %(levelname)-8s %(name)-8s %(message)s'
logging.basicConfig(level=logging.DEBUG, format=LOGGINGFORMAT, datefmt='%d-%b-%y %H:%M:%S')
mapp=Flask(__name__)
mapp.secret_key = os.getenv('tokenkey')
mapp.config['PROPAGATE_EXCEPTIONS'] = True
mapp.config['JWT_SECRET_KEY']=os.getenv('tokenkey')
mapp.config['JWT_DECODE_AUDIENCE']=os.getenv('usc')
#mapp.config['JWT_ENCODE_AUDIENCE']='testapp'
api.init_app(mapp)
jwt = JWTManager(mapp)
#register error handlers (inbuilt)
jwt._set_error_handler_callbacks(api)
#host multiple instances
d=PathInfoDispatcher({'/':mapp})
server=WSGIServer(('0.0.0.0',80),d)
#docker run -d -p 8088:8088 -t nginx
#start web server
try:
server.start()
except KeyboardInterrupt:
server.stop()
def main():
clear_screen()
print_logo()
redirect_url = ask(
"Giriş yapıldıktan sonra nereye yönlendirilsin (Varsayılan: https://www.instagram.com)"
)
port = ask("Web sunucusu hangi port'u kullansın (Varsayılan: 80)")
if (port != "" and (port.isdigit()) == False):
error("Hatalı giriş!")
_exit(0)
try_accounts = ask(
"Girilen kullanıcılar denensin mi (Varsayılan: Hayır) [E/H]")
print("")
if ((try_accounts != "") and (try_accounts.lower() != "e")
and (try_accounts.lower() != "h")):
error("Hatalı giriş!")
_exit(0)
if (redirect_url != ""):
info("Yönlendirme '{0}' olarak ayarlandı!".format(redirect_url))
SETTINGS["REDIRECT_URL"] = redirect_url
else:
info("Varsayılan yönlendirme adresi kullanılıyor!")
SETTINGS["REDIRECT_URL"] = "https://www.instagram.com"
if (port != ""):
info("Sunucunun web portu '{0}' olarak ayarlandı!".format(port))
SETTINGS["PORT"] = int(port)
else:
info("Varsayılan sunucu portu kullanılıyor!")
SETTINGS["PORT"] = 80
if (try_accounts != ""):
if (try_accounts.lower() == "e"):
info("Sunucuya girilen kullanıcılar giriş yapılarak denenecektir!")
SETTINGS["TRY_ACCOUNTS"] = True
print("")
if ("arm" not in uname().machine):
success("NGROK servisi başlatılıyor!")
public_url = ngrok.connect()
web_url = ngrok.connect(SETTINGS["PORT"], "http")
success("Port yönlendirme başarılı!")
print("")
success("Web sunucusu {0} adresinde açıldı!".format(web_url))
print("")
else:
info(
"Program Termux'dan çalıştırılıyor! NGROK'u 'ngrok http 80' komutuyla manuel başlatmalısınız!"
)
print("")
success("Web sunucusu http://localhost:{0} adresinde açıldı!".format(
SETTINGS["PORT"]))
print("")
try:
http_server = WSGIServer(('0.0.0.0', SETTINGS["PORT"]),
PathInfoDispatcher({'/': website_app}))
http_server.start()
except:
info(
"Program yönetici olarak çalıştırılmadığından dolayı web portu 5000 olarak değiştirildi!"
)
SETTINGS["PORT"] = 5000
http_server = WSGIServer(('0.0.0.0', SETTINGS["PORT"]),
PathInfoDispatcher({'/': website_app}))
http_server.start()
config = json.load(f)
if 'email' in config['snips_console']:
email = config['snips_console']['email']
if 'password' in config['snips_console']:
password = config['snips_console']['password']
assistant_zip = config['assistant']
# Replicate code from funcs.sh to locate the assistant_zip file
# If it doesn't exist in /share/snips, check /share. If it's in
# neither, assume it's in /share/snips!
test_path1 = Path('/share/snips') / assistant_zip
if test_path1.exists():
assistant_zip = test_path1
else:
test_path2 = Path('/share') / assistant_zip
if test_path2.exists():
assistant_zip = test_path2
else:
assistant_zip = test_path1
dispatcher = PathInfoDispatcher({'/': app.wsgi_app, root: app.wsgi_app})
server = WSGIServer((host, port), dispatcher)
try:
info("Starting server!")
server.start()
except Exception as e:
error("caught exception: {}".format(e))
server.stop()
5: "lumières in-reception",
6: "lumières banque",
7: "lumières salle petit-déj buffet",
8: "lumières salle petit-déj tables",
}
state_relais = {relai: lock_door.is_on(relai) for relai in list_relais.keys()}
return {"list_relais":list_relais, "state_relais":state_relais, "myip":get_ip()}
@pyaccess.route("/turn/<state>/<relai_ch>")
def turn(state, relai_ch):
lock_door.turn(state, int(relai_ch))
resp = Response(f"{datetime.now().strftime('%H:%M:%S')} {relai_ch} : {state}")
resp.set_header('Access-Control-Allow-Origin', '*')
return resp
lock_door.init_GPIO()
from cheroot.wsgi import Server as WSGIServer, PathInfoDispatcher
d = PathInfoDispatcher({"/": pyaccess})
server = WSGIServer(("0.0.0.0", 8080), d)
if __name__ == "__main__":
try:
# pyaccess.run(host="0.0.0.0", port=8080)
server.start()
pass
except KeyboardInterrupt:
server.stop()
from cheroot.wsgi import Server as WSGIServer,PathInfoDispatcher
import signal
import TestResourceServer
import AuthanticationServer
#host multiple instances
d=PathInfoDispatcher({'/app':TestResourceServer.TestApp,'/auth':AuthanticationServer.AuthApp})
server=WSGIServer(('0.0.0.0',8088),d)
#docker run -d -p 8088:8088 -t nginx
#start web server
try:
server.start()
except KeyboardInterrupt:
server.stop()
def api(db):
@returns_json
def get_data(environ, start_response):
key = pop_path_info(environ)
with eliot.start_action(action_type='api:get-data', key=key) as action:
data = db.get(key)
if data is None:
action.add_success_fields(found=False)
start_response('404 Not Found', [])
return {'error': 'not_found', 'key': key}
else:
action.add_success_fields(found=True)
return data
@returns_json
def insert_data(environ, start_response):
with eliot.start_action(action_type='api:insert-data') as action:
instream = make_line_iter(
get_input_stream(environ, safe_fallback=False))
lines = (json.loads(line.decode('utf-8')) for line in instream)
keys = db.insert(lines)
action.add_success_fields(inserted_count=len(keys))
return {'message': 'Inserted OK', 'keys': keys}
@returns_json
def search_data(environ, start_response):
with eliot.start_action(action_type='api:search-data') as action:
qs = parse_qs(get_query_string(environ))
query = {key: value[0] for key, value in qs.items()}
if '_start_time' in query:
query['_start_time'] = _make_search_date(query['_start_time'])
if '_end_time' in query:
query['_end_time'] = _make_search_date(query['_end_time'])
if '_count' in query:
query['_count'] = int(query['_count'])
if '_summary' in query:
summarise = query['_summary'] == 'true'
aggregate = query['_summary'] == 'aggregate'
del query['_summary']
else:
summarise = False
aggregate = False
action.add_success_fields(query=query)
query_result = db.search(**query)
if summarise:
result = [(key, _summarize_callgraph(cg))
for key, cg in query_result]
elif aggregate:
result = combine_call_graphs(cg for key, cg in query_result)
else:
result = list(query_result)
action.add_success_fields(results=len(result))
return result
@responder
def data(environ, start_response):
method = environ[REQUEST_METHOD]
if method == 'GET':
if peek_path_info(environ):
return get_data
else:
return search_data
elif method == 'POST':
return insert_data
else:
return Response('Method {} Not Allowed'.format(method),
'405 Method Not Allowed')
@returns_json
def attrib_names(environ, start_response):
with eliot.start_action(action_type='api:get-attrib-names') as action:
return db.attrib_names()
@returns_json
def attrib_values(environ, start_response):
key = pop_path_info(environ)
with eliot.start_action(action_type='api:get-attrib-values',
key=key) as action:
return db.attrib_values(key)
@responder
def attribs(environ, start_response):
method = environ[REQUEST_METHOD]
if method == 'GET':
if peek_path_info(environ):
return attrib_values
else:
return attrib_names
else:
return Response('Method {} Not Allowed'.format(method),
'405 Method Not Allowed')
return PathInfoDispatcher({"/data": data, "/attribs": attribs})
'SQLALCHEMY_DATABASE_URI'] = f"sqlite:///{working_dir}/data/web_interface.db"
db = SQLAlchemy(app)
bcrypt = Bcrypt(app)
login = LoginManager()
login.init_app(app)
@app.before_first_request
def init_db():
db.create_all()
import_module('pagermaid.interface.views')
import_module('pagermaid.interface.modals')
dispatcher = PathInfoDispatcher({'/': app})
server = WSGIServer(
(config['web_interface']['host'], int(config['web_interface']['port'])),
dispatcher)
def start():
if strtobool(config['web_interface']['enable']):
logs.info(
f"已经启动Web界面 {config['web_interface']['host']}:{config['web_interface']['port']}"
)
app.logger.removeHandler(default_handler)
app.logger.addHandler(logging_handler)
try:
server.start()
except OSError:
def run(self):
self._configure_flask_app()
dispatcher = PathInfoDispatcher({"/": app})
self.server = WSGIServer((self.host, self.port), dispatcher)
self.server.start()
def _run(self) -> None:
# Server and end points
app = Flask(__name__)
def _with_state_lock(
req: Request, callback: Callable[[Request],
Response]) -> Response:
if self.processing:
return Response("Processing contribution. Retry later.", 503)
self.state_lock.acquire()
try:
return callback(req)
except Exception as ex:
warning(f"error in request: {ex}")
print(f"error in request: {ex}")
return Response("error: {ex}", 400)
finally:
self.state_lock.release()
@app.route('/contributors', methods=['GET'])
def contributors() -> Response: # pylint: disable=unused-variable
return _with_state_lock(request, self._contributors)
@app.route('/state', methods=['GET'])
def state() -> Response: # pylint: disable=unused-variable
return _with_state_lock(request, self._state)
@app.route('/challenge', methods=['GET'])
def challenge() -> Response: # pylint: disable=unused-variable
return _with_state_lock(request, self._challenge)
@app.route('/contribute', methods=['POST'])
def contribute() -> Response: # pylint: disable=unused-variable
return _with_state_lock(request, self._contribute)
def _tick() -> None:
self.state_lock.acquire()
try:
self._update_state(time.time())
finally:
self.state_lock.release()
interval = Interval(60.0, _tick)
try:
if not exists(self.config.tls_certificate):
raise Exception(f"no cert file {self.config.tls_certificate}")
if not exists(self.config.tls_key):
raise Exception(f"no key file {self.config.tls_key}")
listen_addr = ('0.0.0.0', self.config.port)
self.server = WSGIServer(listen_addr,
PathInfoDispatcher({'/': app}),
numthreads=1)
self.server.ssl_adapter = BuiltinSSLAdapter(
self.config.tls_certificate, self.config.tls_key)
print(f"Listening on {listen_addr} ...")
self.server.start()
finally:
interval.stop()
self.server = None