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 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()
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_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 test_server(self):
"""Test http server"""
test_dir, application = self.create_server()
# Prepare server thread
server = Server(('localhost', 0), application.rest)
server.prepare()
server_port = server.bind_addr[1]
thread = threading.Thread(target=server.serve)
thread.start()
# Run test
response = urlopen('http://localhost:{}/en/cs/unit/Hello/'.format(server_port))
payload = json.loads(response.read().decode('utf-8'))
assert payload[0]['target'] == 'Ahoj'
# Shutdown the server thread
server.stop()
thread.join()
self.cleanup(test_dir, application)
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 main(argv=sys.argv[1:]):
parser = argparse.ArgumentParser(
description='Start Aurora on http://<host>:<port>')
parser.add_argument(
dest='input',
nargs='?',
help='Path where to find Aurora content or catalog file',
default='.')
parser.add_argument('--live',
dest='live',
help='Run Aurora in live mode',
action='store_true')
parser.add_argument('-p',
'--port',
dest='port',
help='Port to serve HTTP files at (default: 5000)',
default=PORT)
parser.add_argument('-H',
'--host',
dest='host',
help='IP to serve HTTP files at (default: localhost)',
default=HOST)
args = parser.parse_args(argv)
# The default behavior should be as follows:
# * If the user provides a catalog file to open, open it
# * If the user does not provide a catalog file to open:
# * Webapp should prompt them to either open a file
# or specify the location for a new one.
#
# In the meantime, we'll just create one in memory
if os.path.isfile(args.input):
# User provided a catalog file
engine = new_engine(catalog=args.input)
else:
engine = new_engine()
session = new_session(engine)
Base.metadata.create_all(bind=engine)
api.session = scoped_session(session, scopefunc=_app_ctx_stack)
# We need to read the config from the db here to figure out what to do re: a bunch of stuff
server = Server((args.host, args.port), app)
if args.live:
print("F**k it, we'll do it live")
else:
pass
# Stand up the webserver
print(f'Running Aurora on http://{args.host}:{args.port}')
try:
server.start()
if CONFIG['autolaunch_browser']:
webbrowser.open(f'http://{HOST}:{PORT}', new=2)
except KeyboardInterrupt:
print(f'\n\nShutting down Aurora')
server.stop()
class ProxiedBitcoinD(BitcoinD):
def __init__(self, bitcoin_dir, proxyport=0):
BitcoinD.__init__(self, bitcoin_dir, rpcport=None)
self.app = Flask("BitcoindProxy")
self.app.add_url_rule("/",
"API entrypoint",
self.proxy,
methods=['POST'])
self.proxyport = proxyport
self.mocks = {}
def _handle_request(self, r):
conf_file = os.path.join(self.bitcoin_dir, 'bitcoin.conf')
brpc = BitcoinProxy(btc_conf_file=conf_file)
method = r['method']
# If we have set a mock for this method reply with that instead of
# forwarding the request.
if method in self.mocks and type(method) == dict:
return self.mocks[method]
elif method in self.mocks and callable(self.mocks[method]):
return self.mocks[method](r)
try:
reply = {
"result": brpc._call(r['method'], *r['params']),
"error": None,
"id": r['id']
}
except JSONRPCError as e:
reply = {"error": e.error, "id": r['id']}
return reply
def proxy(self):
r = json.loads(request.data.decode('ASCII'))
if isinstance(r, list):
reply = [self._handle_request(subreq) for subreq in r]
else:
reply = self._handle_request(r)
reply = json.dumps(reply, cls=DecimalEncoder)
logging.debug("Replying to %r with %r", r, reply)
response = flask.Response(reply)
response.headers['Content-Type'] = 'application/json'
return response
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 stop(self):
BitcoinD.stop(self)
self.server.stop()
self.proxy_thread.join()
def mock_rpc(self, method, response=None):
"""Mock the response to a future RPC call of @method
The response can either be a dict with the full JSON-RPC response, or a
function that returns such a response. If the response is None the mock
is removed and future calls will be passed through to bitcoind again.
"""
if response is not None:
self.mocks[method] = response
elif method in self.mocks:
del self.mocks[method]
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()
from cheroot.wsgi import Server as WSGIServer
from cheroot.wsgi import PathInfoDispatcher as WSGIPathInfoDispatcher
from cheroot.ssl.builtin import BuiltinSSLAdapter
from webpage import app
from net import get_ip
#script per il settaggio del wsgi
my_app = WSGIPathInfoDispatcher({'/': app})
server = WSGIServer((get_ip(), 443), my_app)
ssl_cert = "cert.pem"
ssl_key = "privkey.pem"
server.ssl_adapter = BuiltinSSLAdapter(ssl_cert, ssl_key, None)
if __name__ == '__main__':
try:
server.start()
except KeyboardInterrupt:
server.stop()
class CherryProxy:
"""
CherryProxy: a filtering HTTP proxy.
"""
# class variables: unique id for each request
_req_id = 0
_lock_req_id = threading.Lock()
def __init__(self,
listen_address,
listen_port,
redirect_address,
redirect_port,
verbosity,
log_stream=sys.stdout):
self.listen_address = listen_address
self.listen_port = listen_port
self.redirect_address = redirect_address
self.redirect_port = redirect_port
self._verbosity = verbosity
self._log_stream = log_stream
# thread local variables to store request/response data per thread:
self.req = threading.local()
self.resp = threading.local()
self.server = CherryPyWSGIServer(
(self.listen_address, self.listen_port), self._proxy_app)
self.log_debug('__init__',
'server.bind_addr: {}'.format(self.server.bind_addr))
def log(self, s, prefix='### ', req_id=None):
if self._verbosity > 0:
if req_id:
prefix += '{:06} | '.format(req_id)
self._log_stream.write('{}{}\n'.format(prefix, s))
def log_debug(self, method_name, s):
if self._verbosity > 1:
options = {
's': '{:25s} | {}'.format(method_name, s),
'prefix': '*** ',
}
if hasattr(self.req, 'id'):
options['req_id'] = self.req.id
self.log(**options)
def start(self):
self.log('Starting proxy to listen on {} and redirect to {}'.format(
self.server.bind_addr,
(self.redirect_address, self.redirect_port)))
self.log('Proxy listening ... (press Ctrl+C to stop)'.format(
self.server.bind_addr))
self.server.start()
def stop(self):
self.server.stop()
self.log('Proxy stopped.')
def set_response(self,
status,
reason=None,
data=None,
content_type='text/plain'):
"""
Set a HTTP response to be sent to the client instead of the one from the server.
:param status: int, HTTP status code (see RFC 2616)
:param reason: str, optional text for the response line, standard text by default
:param data: str, optional body for the response, default="status reason"
:param content_type: str, content-type corresponding to data
:return:
"""
self.resp.status = status
if not reason:
reason = client.responses[
status] # get standard text corresponding to status
self.resp.reason = reason
if not data:
data = '{} {}'.format(status, reason)
self.resp.data = data
# reset all headers
self.resp.headers = []
self.resp.headers.append(('content-type', content_type))
# self.resp.headers.append(('content-length', str(len(data))))
def set_response_forbidden(self):
self.set_response(403, reason='Forbidden')
def filter_request_headers(self):
"""
Method to be overridden:
Called to analyse/filter/modify the request received from the client,
before reading the full request with its body if there is one,
before it is sent to the server.
This method may call set_response() if the request needs to be blocked
before being sent to the server.
The following attributes can be read and MODIFIED:
self.req.headers: dictionary of HTTP headers, with lowercase names
self.req.method: HTTP method, e.g. 'GET', 'POST', etc
self.req.scheme: protocol from URL, e.g. 'http' or 'https'
self.req.path: path in URL, for example '/folder/index.html'
self.req.query: query string, found after question mark in URL
The following attributes can be READ only:
self.req.environ: dictionary of request attributes following WSGI format (PEP 333)
self.req.url: partial URL containing 'path?query'
self.req.content_type: content-type, for example 'text/html'
self.req.charset: charset, for example 'UTF-8'
self.req.length: length of request data in bytes, 0 if none
"""
pass
def filter_request(self):
"""
Method to be overridden:
Called to analyse/filter/modify the request received from the client,
after reading the full request with its body if there is one,
before it is sent to the server.
This method may call set_response() if the request needs to be blocked
before being sent to the server.
The same attributes as in filter_request_headers are available:
The following attributes can also be read and MODIFIED:
self.req.data: data sent with the request (POST or PUT)
"""
pass
def filter_response_headers(self):
"""
Method to be overridden:
Called to analyse/filter/modify the response received from the server,
before reading the full response with its body if there is one,
before it is sent back to the client.
This method may call set_response() if the response needs to be blocked
(e.g. replaced by a simple response) before being sent to the client.
The following attributes can be read and MODIFIED:
self.resp.status: int, HTTP status of response, e.g. 200, 404, etc
self.resp.reason: reason string, e.g. 'OK', 'Not Found', etc
self.resp.headers: response headers, list of (header, value) tuples
The following attributes can be READ only:
self.resp.httpconn: httplib.HTTPConnection object
self.resp.response: httplib.HTTPResponse object
self.resp.content_type: content-type of response
"""
pass
def filter_response(self):
"""
Method to be overridden:
Called to analyse/filter/modify the response received from the server,
after reading the full response with its body if there is one,
before it is sent back to the client.
This method may call set_response() if the response needs to be blocked
(e.g. replaced by a simple response) before being sent to the client.
The same attributes as in filter_response_headers are available:
The following attributes can be read and MODIFIED:
self.resp.data: data sent with the response
"""
pass
def _proxy_app(self, environ, f_start_response):
"""
Main method called when a request is received from a client (WSGI application).
:param environ:
:param f_start_response:
:return:
"""
t_start = time.perf_counter()
self._init_request_response()
self.log('START', req_id=self.req.id)
self._parse_request(environ)
# method to be overridden by subclass: filter request headers before reading the body
self.filter_request_headers()
if not self.resp.status:
self._read_request_body()
# method to be overridden by subclass: filter request before sending it to the server
self.filter_request()
self.log('request {} {}'.format(self.req.method, self.req.url),
req_id=self.req.id)
if not self.resp.status:
self._send_request()
self._parse_response()
# method to be overridden by subclass: filter response headers before reading the body
self.filter_response_headers()
if not self.resp.data: # here we need to check resp.data
self._read_response_body()
# method to be overridden by subclass: filter request before sending it to the client
self.filter_response()
# for now we always close the connection, even if the client sends several requests;
# this is not optimal performance-wise, but simpler to code
if self.resp.httpconn:
self.resp.httpconn.close()
self._send_response(f_start_response)
t_end = time.perf_counter()
self.log('response {} {} in {:5.3f} seconds'.format(
self.resp.status, self.resp.reason, t_end - t_start),
req_id=self.req.id)
return [self.resp.data]
def _init_request_response(self):
# set request id (simply increase number at each request)
with self._lock_req_id:
self._req_id += 1
self.req.id = self._req_id
# request variables
self.req.environ = {}
self.req.headers = {}
self.req.method = None
self.req.scheme = None
self.req.path = None
self.req.query = None
self.req.url = None
self.req.content_type = None
self.req.charset = None
self.req.length = 0
self.req.data = None
# response variables
self.resp.httpconn = None
self.resp.response = None
self.resp.status = None
self.resp.reason = None
self.resp.headers = [
] # http.client headers is a list of (header, value) tuples
self.resp.content_type = None
self.resp.data = None
def _parse_request(self, environ):
self.req.environ = environ
self.log_debug('_parse_request', 'req.environ:')
for k, v in sorted(environ.items(), key=lambda x: x[0]):
self.log_debug('_parse_request', ' {}: {}'.format(k, v))
# convert WSGI environ to a dict of HTTP headers:
self.req.headers = {}
for h in environ:
if h.startswith('HTTP_'):
self.req.headers[h[5:].replace('_', '-').lower()] = environ[h]
# content-type is stored without 'HTTP_'
# see RFC 2616: http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.17
content_type = environ.get('CONTENT_TYPE', None)
if content_type:
if ';' in content_type:
content_type, charset = content_type.split(';', 1)
self.req.content_type = content_type.strip()
self.req.charset = charset.strip()
ct = '{};{}'.format(self.req.content_type, self.req.charset)
else:
self.req.content_type = content_type.strip()
ct = self.req.content_type
self.req.headers['content-type'] = ct
self.log_debug('_parse_request',
'req.content_type: {}'.format(self.req.content_type))
self.log_debug('_parse_request',
'req.charset: {}'.format(self.req.charset))
# content-length is also stored without 'HTTP_'
self.req.headers['content-length'] = environ.get('CONTENT_LENGTH', 0)
self.log_debug('_parse_request', 'req.headers:')
for k, v in sorted(self.req.headers.items(), key=lambda x: x[0]):
self.log_debug('_parse_request', ' {}: {}'.format(k, v))
self.req.method = environ.get('REQUEST_METHOD', None)
self.req.scheme = environ.get('wsgi.url_scheme', None) # http
self.req.path = environ.get('PATH_INFO', None)
self.req.query = environ.get('QUERY_STRING', None)
self.req.url = parse.urlunsplit(
('', '', self.req.path, self.req.query, ''))
self.log_debug('_parse_request',
'req.method: {}'.format(self.req.method))
self.log_debug('_parse_request',
'req.scheme: {}'.format(self.req.scheme))
self.log_debug('_parse_request', 'req.path: {}'.format(self.req.path))
self.log_debug('_parse_request',
'req.query: {}'.format(self.req.query))
self.log_debug('_parse_request', 'req.url: {}'.format(self.req.url))
if self.req.method not in ALLOWED_METHODS:
# here I use 501 "not implemented" rather than 405 or 401, because it seems to be the
# most appropriate response according to RFC 2616.
# see http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html
msg = 'Method "{}" not supported.'.format(self.req.method)
self.set_response(501, reason=msg)
self.log_debug('_parse_request', msg)
if self.req.scheme not in ALLOWED_SCHEMES:
msg = 'Scheme "{}" not supported.'.format(self.req.scheme)
self.set_response(501, reason=msg)
self.log_debug('_parse_request', msg)
def _read_request_body(self):
try:
length = int(self.req.environ.get('CONTENT_LENGTH', 0))
except ValueError:
length = 0
if length > 0:
self.req.length = length
input_ = self.req.environ.get('wsgi.input')
if input_:
self.req.data = input_.read(self.req.length)
self.log_debug('_read_request_body',
'req.length: {}'.format(self.req.length))
self.log_debug('_read_request_body',
'req.data: {} b'.format(len(self.req.data)))
return
self.log_debug('_read_request_body', 'No request body')
def _send_request(self):
self.log_debug('_send_request', 'starting')
# forward a request received from a client to the server.
# TO DO: handle connection errors
self.resp.httpconn = client.HTTPConnection(self.redirect_address,
self.redirect_port)
self.log_debug('_send_request', 'initialized connection')
self.resp.httpconn.request(self.req.method,
self.req.url,
body=self.req.data,
headers=self.req.headers)
self.log_debug('_send_request', 'made request')
# Get the response (but not the response body yet).
self.resp.response = self.resp.httpconn.getresponse()
self.log_debug('_send_request', 'got response')
def _parse_response(self):
self.resp.status = self.resp.response.status
self.resp.reason = self.resp.response.reason
self.log_debug(
'_parse_response', 'resp: {} {}'.format(self.resp.status,
self.resp.reason))
self.resp.headers = self.resp.response.getheaders()
self.log_debug('_parse_response', 'resp.headers:')
for e in sorted(self.resp.headers):
self.log_debug('_parse_response', ' {}: {}'.format(e[0], e[1]))
self.resp.content_type = self.resp.response.msg.get_content_type(
).lower()
self.log_debug('_parse_response',
'resp.content_type: {}'.format(self.resp.content_type))
def _read_response_body(self):
# TO DO: check content-length?
self.resp.data = self.resp.response.read()
self.log_debug('_read_response_body',
'resp.data: {} b'.format(len(self.resp.data)))
def _send_response(self, f_start_response):
# Send the response with headers (but no body yet).
status = '{} {}'.format(self.resp.status, self.resp.reason)
f_start_response(status, self.resp.headers)
self.log_debug('_send_response', 'status: {}'.format(status))
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 run(self):
self._configure_flask_app()
dispatcher = PathInfoDispatcher({"/": app})
self.server = WSGIServer((self.host, self.port), dispatcher)
self.server.start()
action='store_true',
help='Enable pudb post mortem debugging')
parser.add_argument('--port',
type=int,
default=8034,
help='Port to listen for connections on')
parser.add_argument('--host', default='0.0.0.0', help='Host to bind to')
args = parser.parse_args()
eliot.add_destination(eliot.FileDestination(sys.stderr))
dbdir = args.database or tempfile.mkdtemp()
try:
with Database(dbdir) as db:
the_app = app(db)
if args.debug:
the_app = debug_wrapper(the_app)
httpd = Server((args.host, args.port), the_app)
print('Serving "{dbdir}" on {args.host}:{args.port}'.format(
dbdir=dbdir, args=args))
httpd.safe_start()
finally:
if not args.database:
shutil.rmtree(dbdir)
elif os.getenv(_DB_DIR_ENV_VAR):
# To run from within a WSGI container like uWSGI, must configure DB dir via
# env var PROFILOMATIC_DB_DIR
eliot.add_destination(eliot.FileDestination(sys.stderr))
db = Database(os.getenv(_DB_DIR_ENV_VAR))
the_app = app(db)
parser.add_argument('--certificate', nargs='?', help='TLS cert location')
parser.add_argument('--key', nargs='?', help='TLS private key location')
args = parser.parse_args()
bp_perf = BPPerformance(classifiers, endpoint=args.nodeos_url)
thread = threading.Thread(target=bp_perf.watch)
thread.start()
app = cache_middleware(60)(
PathInfoDispatcher({
'/': index(bp_perf),
'/chart': transaction_chart(bp_perf),
'/transactions.csv': transaction_csv(bp_perf),
'/missed_slots': missed_slots(bp_perf),
'/missed_slots_by_time': missed_slots_by_time(bp_perf),
'/missed_slots.csv': missed_slots_csv(bp_perf),
'/transactions_per_block': transactions_per_block(bp_perf)
})
)
httpd = Server((args.host, args.port), app)
if args.certificate:
from cheroot.ssl.builtin import BuiltinSSLAdapter
httpd.ssl_adapter = BuiltinSSLAdapter(args.certificate, args.key)
try:
print(f"Serving on {args.host}:{args.port}")
httpd.safe_start()
finally:
bp_perf.stop()
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 _build_fake_ssm():
app = DomainDispatcherApplication(create_backend_app, "ssm")
httpd = Server((FAKE_SSM_HOST, FAKE_SSM_PORT), app)
return ThreadedHttpd(httpd)
cur_image = img
with new_img_ev:
new_img_ev.notify_all()
with new_img_ev:
new_img_ev.notify_all()
def stop_capture():
global running
running = False
print('Stop Capturing...')
d = PathInfoDispatcher({'/': app})
server = None
if __name__ == '__main__':
print('Usage: python cam.py [src] [width height]')
server = Server(
('0.0.0.0', 8081 + (int(sys.argv[1]) if len(sys.argv) > 1 else 0)), d)
t = threading.Thread(target=worker)
t.start()
try:
server.start()
except KeyboardInterrupt:
stop_capture()
server.stop()
print('Terminated.')
# Denne fila kjører dere når dere vil gjøre serveren offentlig, eller generelt når dere vil teste den på en "skikkelig" server
from cheroot.wsgi import Server as WSGIServer
from cheroot.wsgi import PathInfoDispatcher as WSGIPathInfoDispatcher
from cheroot.ssl.builtin import BuiltinSSLAdapter
from app import app # Importerer variabelen app fra filen app.py
my_app = WSGIPathInfoDispatcher({'/': app})
# 'localhost' privat, bare lokal
# '127.0.0.1' privat, bare lokal
# '192.168.0.37' offentlig, tilgjengelig for andre på nettverket (eksempel IPv4 addresse, sett inn din egen)
# '0.0.0.0' offentlig, tilgjengelig for andre på nettverket (alle IP addressene til maskinen kan brukes for å nå siden)
server = WSGIServer(('0.0.0.0', 443), my_app) # For å åpne denne serveren må en skrive https:// forran addressen
ssl_cert = "application/certificate/MyCertificate.crt"
ssl_key = "application/certificate/MyKey.key"
server.ssl_adapter = BuiltinSSLAdapter(ssl_cert, ssl_key, None)
if __name__ == '__main__':
try:
server.start()
except KeyboardInterrupt: # Med dette så mener den ctrl+c
server.stop() # På linje 2070 i koden hvor stop() er definert har jeg satt inn: self.serving = False # We don't care, fordi koden fryser der, er noe feil med cheroot
except SystemExit:
server.stop() # På linje 2070 i koden hvor stop() er definert har jeg satt inn: self.serving = False # We don't care, fordi koden fryser der, er noe feil med cheroot
# TLS test
# https://www.ssllabs.com/ssltest/index.html
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
def main():
# Set null device file path to stdout, stdin, stderr if they are None
for _name in ('stdin', 'stdout', 'stderr'):
if getattr(sys, _name) is None:
setattr(sys, _name,
open(os.devnull, 'r' if _name == 'stdin' else 'w'))
# Build Javascript files when DEBUG
if config.DEBUG:
from pgadmin.utils.javascript.javascript_bundler import \
JavascriptBundler, JsState
app.debug = True
javascript_bundler = JavascriptBundler()
javascript_bundler.bundle()
if javascript_bundler.report() == JsState.NONE:
app.logger.error(
"Unable to generate javascript.\n"
"To run the app ensure that yarn install command runs "
"successfully"
)
raise RuntimeError("No generated javascript, aborting")
# Output a startup message if we're not under the runtime and startup.
# If we're under WSGI, we don't need to worry about this
if not app.PGADMIN_RUNTIME:
print(
"Starting %s. Please navigate to http://%s:%d in your browser." %
(config.APP_NAME, config.DEFAULT_SERVER,
config.EFFECTIVE_SERVER_PORT)
)
sys.stdout.flush()
else:
# For unknown reason the runtime does not pass the environment
# variables (i.e. PYTHONHOME, and PYTHONPATH), to the Python
# sub-processes, leading to failures executing background processes.
#
# This has been observed only on windows. On *nix systems, it is likely
# picking the system python environment, which is good enough to run
# the process-executor.
#
# Setting PYTHONHOME launch them properly.
from pgadmin.utils import IS_WIN
if IS_WIN:
os.environ['PYTHONHOME'] = sys.prefix
# Initialize Flask service only once
# If `WERKZEUG_RUN_MAIN` is None, i.e: app is initializing for first time
# so set `use_reloader` = False, thus reload won't call.
# Reference:
# https://github.com/pallets/werkzeug/issues/220#issuecomment-11176538
try:
if config.DEBUG:
app.run(
host=config.DEFAULT_SERVER,
port=config.EFFECTIVE_SERVER_PORT,
use_reloader=(
(not app.PGADMIN_RUNTIME) and app.debug and
os.environ.get("WERKZEUG_RUN_MAIN") is not None
),
threaded=config.THREADED_MODE
)
else:
# Can use cheroot instead of flask dev server when not in debug
# 10 is default thread count in CherootServer
num_threads = 10 if config.THREADED_MODE else 1
prod_server = CherootServer(
(config.DEFAULT_SERVER, config.EFFECTIVE_SERVER_PORT),
wsgi_app=app,
numthreads=num_threads,
server_name=config.APP_NAME)
try:
print("Using production server...")
prod_server.start()
except KeyboardInterrupt:
prod_server.stop()
except IOError:
app.logger.error("Error starting the app server: %s", sys.exc_info())
class Server:
"""
Server to coordinate an MPC, that serves challenges and accepts responses
from contributors. Performs basic contribution management, ensuring
contributions are from the correct party and submitted within the correct
time window. MPC-specific operations (validation / challenge computation,
etc) are performed by an IContributionHandler object.
"""
def __init__(self, handler: IContributionHandler,
server_config: Configuration, server_dir: str):
logging.basicConfig(filename=LOG_FILE, level=logging.DEBUG)
self.handler = handler
self.config = server_config
self.contributors: ContributorList
self.upload_file = join(server_dir, UPLOAD_FILE)
self.state_file_path = join(server_dir, STATE_FILE)
self.state: ServerState
self.processing = False
# Try to open contributors file and state files. Perform sanity checks.
with open(self.config.contributors_file, "r") as contributors_f:
self.contributors = ContributorList.from_json(
contributors_f.read())
print(f"Contributors: {self.contributors}")
self.contributors.ensure_validity()
if exists(STATE_FILE):
info(f"run_server: using existing state file: {STATE_FILE}")
with open(STATE_FILE, "r") as state_f:
self.state = ServerState.from_json(state_f.read())
else:
self.state = initial_server_state(self.config, self.contributors)
self._write_state_file()
self._notify_next_contributor()
self.handler_finalized = self.state.have_all_contributions()
self.state_lock = Lock()
self.server: Optional[WSGIServer] = None
self.thread = Thread(target=self._run)
self.thread.start()
while self.server is None or self.server.socket is None:
info("Waiting for MPC server to start ...")
time.sleep(1)
port = self.server.socket.getsockname()[1]
info(f"MPC server started (port: {port}).")
def stop(self) -> None:
if self.server is not None:
self.server.stop()
while self.server is not None:
info("Waiting for server to stop ...")
time.sleep(1.0)
self.thread.join()
info("Server stopped.")
def _write_state_file(self) -> None:
info(f"Writing state: {self.state_file_path}")
with open(self.state_file_path, "w") as state_f:
state_f.write(self.state.to_json())
def _finalize_handler_once(self) -> None:
if (not self.handler_finalized
) and self.state.have_all_contributions():
self.handler_finalized = True
self.handler.on_completed()
def _update_state(self, now: float) -> None:
if self.state.update(now, self.config.contribution_interval):
self._on_next_contributor()
def _on_contribution(self, now: float) -> None:
next_deadline = now + self.config.contribution_interval
self.state.received_contribution(next_deadline)
self._on_next_contributor()
def _on_next_contributor(self) -> None:
self._finalize_handler_once()
self._write_state_file()
self._notify_next_contributor()
def _notify_next_contributor(self) -> None:
if self.state.have_all_contributions() or not self.config.email_server:
return
contributor_idx = self.state.next_contributor_index
idx_readable = contributor_idx + 1
total = self.state.num_contributors
contributor = self.contributors[contributor_idx]
try:
_send_mail(
email_server=self.config.email_server,
email_address=cast(str, self.config.email_address),
email_password_file=cast(str, self.config.email_password_file),
to_addr=contributor.email,
subject=
f"[MPC] Your timeslot has begun ({idx_readable}/{total})",
body="Please contribute to the MPC using your key: " +
export_verification_key(contributor.verification_key))
except Exception as ex:
print(f"Failed to notify: {contributor.email}: {ex}")
error(f"Failed to notify: {contributor.email}: {ex}")
def _tick(self) -> None:
if self.processing:
info("_tick: processing. Ignoring tick")
return
self.state_lock.acquire()
try:
self._update_state(time.time())
finally:
self.state_lock.release()
def _contributors(self, _req: Request) -> Response:
return Response(self.contributors.to_json(), 200)
def _state(self, _req: Request) -> Response:
return Response(self.state.to_json(), 200)
def _challenge(self, _req: Request) -> Response:
# TODO: Require authentication here, to avoid DoS?
self._update_state(time.time())
if self.state.have_all_contributions():
return Response("MPC is complete. No remaining challenges", 405)
# Function used to stream the challenge file to the contributor.
# Streaming is required to avoid timing out while writing the
# full challenge file on the socket.
def produce_file_chunks(path: str) -> Iterable[bytes]:
with open(path, 'rb') as in_f:
while True:
buf = in_f.read(SEND_CHUNK_SIZE)
if buf:
yield buf
else:
break
challenge_file = self.handler.get_current_challenge_file(
self.state.next_contributor_index)
return Response(stream_with_context(
produce_file_chunks(challenge_file)),
mimetype="application/octet-stream")
def _contribute(self, req: Request) -> Response:
# Basic request check
headers = req.headers
if 'Content-Length' not in headers:
raise Exception("no Content-Length header")
if 'Content-Type' not in headers:
raise Exception("no Content-Type header")
if 'X-MPC-Digest' not in headers:
raise Exception("no X-MPC-Digest header")
if 'X-MPC-Public-Key' not in headers:
raise Exception("no X-MPC-Public-Key header")
if 'X-MPC-Signature' not in headers:
raise Exception("no X-MPC-Signature header")
content_length = int(headers['Content-Length'])
content_type = headers['Content-Type']
digest = import_digest(headers['X-MPC-Digest'])
pub_key_str = headers.get('X-MPC-Public-Key')
sig = import_signature(headers['X-MPC-Signature'])
boundary: str = ""
for val in content_type.split("; "):
if val.startswith("boundary="):
boundary = val[len("boundary="):]
break
if not boundary:
raise Exception("content-type contains no boundary")
now = time.time()
info(f"Contribute: current time = {now}")
# Update state using the current time and return an error if
# the MPC is no longer active.
self._update_state(now)
if self.state.have_all_contributions():
return Response("MPC complete. No contributions accepted.", 405)
# Check that the public key matches the expected next
# contributor (as text, rather than relying on comparison
# operators)
contributor_idx = self.state.next_contributor_index
contributor = self.contributors[contributor_idx]
verification_key = contributor.verification_key
expect_pub_key_str = export_verification_key(verification_key)
if expect_pub_key_str != pub_key_str:
return Response(
f"Contributor key mismatch (contributor {contributor_idx})",
403)
# Check signature correctness. Ensures that the uploader is the owner
# of the correct key BEFORE the costly file upload, taking as little
# time as possible with remote hosts other than the next contributor.
# (Note that this pre-upload check requires the digest to be passed in
# the HTTP header.)
if not verify(sig, verification_key, digest):
return Response(
f"Signature check failed (contributor {contributor_idx})", 403)
# Accept the upload (if the digest matches). If successful,
# pass the file to the handler.
if exists(self.upload_file):
remove(self.upload_file)
handle_upload_request(content_length, boundary, digest,
cast(io.BufferedIOBase, request.stream),
self.upload_file)
# Mark this instance as busy, launch a processing thread, and
# return (releasing the state lock). Until the processing thread
# has finished, further requests will just return 503.
self.processing = True
Thread(target=self._process_contribution).start()
info(f"Launched thread for {self.state.next_contributor_index}" +
f"/{self.state.num_contributors} contrib")
return Response("OK", 200)
def _process_contribution(self) -> None:
try:
info("_process_contribution(thread): processing contribution " +
f"{self.state.next_contributor_index}" +
f"/{self.state.num_contributors} (start={time.time()})")
if self.handler.process_contribution(
self.state.next_contributor_index, self.upload_file):
now = time.time()
info(
f"_process_contribution(thread): SUCCESS (finished {now})")
self._on_contribution(now)
else:
warning("_process_contribution(thread): contribution failed")
return
finally:
try:
# Remove the uploaded file if it is still there
if exists(self.upload_file):
remove(self.upload_file)
finally:
# Mark server as ready again
self.processing = False
info("_process_contribution(thread): completed")
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
from cheroot.wsgi import Server
from personal_website import create_app
import cherrypy
app = create_app()
cherrypy.tree.graft(app, '/')
cherrypy.config.update({'engine.autoreload.on': True})
server = Server(('127.0.0.1', 5000), cherrypy.tree, server_name='XFU/1.1.0')
if __name__ == '__main__':
server.start()
def cherrypy(app, address, **options):
from cheroot.wsgi import Server as WSGIServer
server = WSGIServer(address, app)
server.start()
if len(customers) == 0:
return '[]'
for customer in customers:
result += json.dumps(customer.to_dict()) + ','
result = result[:-1]
return result + ']'
#Take a look on running the cherry server:
# https://stackoverflow.com/questions/55366395/how-to-run-a-flask-app-on-cherrypy-wsgi-server-cheroot-using-https
# https://www.digitalocean.com/community/tutorials/how-to-deploy-python-wsgi-applications-using-a-cherrypy-web-server-behind-nginx
#
if __name__ == '__main__':
"""Run the cherry server"""
d = PathInfoDispatcher({'/': app})
server = WSGIServer(('0.0.0.0', 8000), d)
path = settings['sslPath']
server.ssl_adapter = BuiltinSSLAdapter(certificate=f'{path}cert.pem',
private_key=f'{path}privkey.pem')
try:
server.start()
except KeyboardInterrupt:
server.stop()
class BitcoindRpcProxy(object):
"""A proxy to the bitcoind RPC interface that can replace commands with arbitrary results.
Starts a HTTP server in a thread, listens for incoming JSONRPC requests, and responds with
either a mocked result or the result it got from bitcoind.
This was taken and adapted from the C-lightning test suite.
"""
def __init__(self, bitcoind_rpc_port, bitcoind_cookie_path, mocks):
self.app = Flask("BitcoindProxy")
self.app.add_url_rule(
"/",
"Entrypoint",
self.proxy,
methods=["POST"],
defaults={"path": ""},
)
self.app.add_url_rule(
"/<path:path>",
"Entrypoint",
self.proxy,
methods=["POST"],
)
self.rpcport = reserve()
# A mapping from method name to result as a dict.
# Eventually, the results could be callable.
self.mocks = mocks
self.bitcoind_rpc_port = bitcoind_rpc_port
self.bitcoind_cookie_path = bitcoind_cookie_path
self.start()
def __del__(self):
self.stop()
def _handle_request(self, r, path):
"""Handle a JSONRPC request {r} made to the HTTP endpoint {path} (to handle
wallet paths)"""
method = r["method"]
# If we have set a mock for this method reply with that
if method in self.mocks:
return {"id": r["id"], "error": None, "result": self.mocks[method]}
# Otherwise, just forward the request
with open(self.bitcoind_cookie_path) as fd:
authpair = fd.read()
service_url = f"http://{authpair}@localhost:{self.bitcoind_rpc_port}/{path}"
try:
res = AuthServiceProxy(service_url, r["method"])(*r["params"])
return {"result": res, "id": r["id"]}
except JSONRPCException as e:
return {"error": e.error, "id": r["id"]}
def proxy(self, path):
r = json.loads(request.data.decode("ASCII"))
if isinstance(r, list):
reply = [self._handle_request(subreq, path) for subreq in r]
else:
reply = self._handle_request(r, path)
# \r\n because rust-jsonrpc expects it..
response = Response(json.dumps(reply, cls=DecimalEncoder) + "\r\n")
response.headers["Content-Type"] = "application/json"
return response
def start(self):
self.server = Server(
("127.0.0.1", self.rpcport),
self.app,
numthreads=32,
request_queue_size=10,
accepted_queue_timeout=20,
timeout=TIMEOUT * 2,
)
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]
def stop(self):
self.server.stop()
self.proxy_thread.join()
class BitcoinRpcProxy(object):
def __init__(self, bitcoind, rpcport=0):
self.app = Flask("BitcoindProxy")
self.app.add_url_rule("/", "API entrypoint", self.proxy, methods=['POST'])
self.rpcport = rpcport
self.mocks = {}
self.mock_counts = {}
self.bitcoind = bitcoind
self.request_count = 0
def _handle_request(self, r):
conf_file = os.path.join(self.bitcoind.bitcoin_dir, 'bitcoin.conf')
brpc = BitcoinProxy(btc_conf_file=conf_file)
method = r['method']
# If we have set a mock for this method reply with that instead of
# forwarding the request.
if method in self.mocks and type(method) == dict:
self.mock_counts[method] += 1
return self.mocks[method]
elif method in self.mocks and callable(self.mocks[method]):
self.mock_counts[method] += 1
return self.mocks[method](r)
try:
reply = {
"result": brpc._call(r['method'], *r['params']),
"error": None,
"id": r['id']
}
except JSONRPCError as e:
reply = {
"error": e.error,
"code": -32603,
"id": r['id']
}
self.request_count += 1
return reply
def proxy(self):
r = json.loads(request.data.decode('ASCII'))
if isinstance(r, list):
reply = [self._handle_request(subreq) for subreq in r]
else:
reply = self._handle_request(r)
response = flask.Response(json.dumps(reply, cls=DecimalEncoder))
response.headers['Content-Type'] = 'application/json'
return response
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 stop(self):
self.server.stop()
self.proxy_thread.join()
logging.debug("BitcoinRpcProxy shut down after processing {} requests".format(self.request_count))
def mock_rpc(self, method, response=None):
"""Mock the response to a future RPC call of @method
The response can either be a dict with the full JSON-RPC response, or a
function that returns such a response. If the response is None the mock
is removed and future calls will be passed through to bitcoind again.
"""
if response is not None:
self.mocks[method] = response
self.mock_counts[method] = 0
elif method in self.mocks:
del self.mocks[method]
HOST = CONFIG.HOST
PORT = CONFIG.PORT
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:
def cherrypy(app, address, **options):
from cheroot.wsgi import Server as WSGIServer
server = WSGIServer(address, app)
server.start()
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
from cheroot.wsgi import Server
from wsgi_benchmark.handlers import app
from multiprocessing import cpu_count
if __name__ == '__main__':
httpd = Server(('0.0.0.0', 8765), app, numthreads=cpu_count() * 10)
httpd.safe_start()
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 main():
server = Server(("0.0.0.0", 8000), PathInfoDispatcher({"/": app}))
server.start()
HOST = CONFIG.HOST
PORT = CONFIG.PORT
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:
def make_healthcheck_server(host='0.0.0.0', port=8888):
app = HealthcheckApplication()
return Server((host, port), app)
from cheroot.wsgi import Server
from titan_app import app
server = Server(('0.0.0.0', 1010), app)
if __name__ == '__main__':
try:
server.start()
except KeyboardInterrupt:
server.stop()
SP = Saml2Client(config_file="%s" % CNFBASE)
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), 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()
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()
class WebServer:
bind_hostname: str = None
bind_port: str = None
wsgi_applications: List[WebApp] = None
server: WSGIServer = None
@inject
def __init__(self, bind_hostname: _WebserverBindHostnameKey,
bind_port: _WebserverBindPortKey,
wsgi_applications: List[WebApp]):
self.bind_hostname = bind_hostname
self.bind_port = bind_port
self.wsgi_applications = wsgi_applications
self.url_map = Map(
[rule for app in self.wsgi_applications for rule in app.get_rules()])
self.mount_map = {
mount.mount_path: mount.app for app in self.wsgi_applications
for mount in app.get_mounts()
}
def _handler(self, environ, start_response):
adapter = self.url_map.bind_to_environ(environ)
try:
rule, values = adapter.match(return_rule=True)
except HTTPException as e:
return e.get_response(environ)(environ, start_response)
def custom_start_response(status_, response_headers_, exc_info_=None):
framework_webserver_endpoint_requests_z.labels(
rule=rule.rule,
method=environ['REQUEST_METHOD'],
status=_get_status_code(status_)).inc()
return start_response(status_, response_headers_, exc_info_)
try:
return rule.endpoint(environ, custom_start_response, **values)
except HTTPException as e:
return e.get_response(environ)(environ, custom_start_response)
except Exception as e:
log.exception('Unknown error occurred processing request')
return InternalServerError(
description='Unknown error occurred',
original_exception=e).get_response(environ)(environ,
custom_start_response)
def _server_thread(self):
log.info(f'Starting webserver on {self.bind_hostname}:{self.bind_port}')
app = self._handler
app = DispatcherMiddleware(app, self.mount_map)
app = WSGILogger(app)
self.server = WSGIServer((self.bind_hostname, self.bind_port), app)
self.server.stats['Enabled'] = True
self.server.start()
@execute()
def run(self):
t = Thread(target=self._server_thread, name='Webserver')
t.start()
return t
@on_shutdown()
def on_shutdown(self):
log.info('Shutting down webserver')
if self.server:
self.server.stop()
