def main(workers):
worker_pids = []
if workers <= 0:
workers = multiprocessing.cpu_count()
if workers == 1:
print(f"Server started with pid={os.getpid()}")
bjoern.run(application, 'localhost', 8080)
else:
print(f"Starting {workers} worker(s)...")
bjoern.listen(application, 'localhost', 8080)
print(f"Master started with pid={os.getpid()}")
for _ in range(workers):
pid = os.fork()
if pid > 0:
worker_pids.append(pid)
elif pid == 0:
try:
print(f"Worker started with pid={os.getpid()}")
bjoern.run()
except KeyboardInterrupt:
pass
exit()
try:
for _ in range(workers):
os.wait()
except KeyboardInterrupt:
for pid in worker_pids:
os.kill(pid, signal.SIGINT)
def main(self):
parser, args = self.parse_args(self.description,
self.default_config_file)
# TODO allow port, socket, and host config from config file
if not (args.socket or args.port):
print('Either a socket or port must be specified.\n',
file=sys.stderr)
parser.print_help(sys.stderr)
exit(2)
listen_address = args.socket if args.socket else ':'.join(
[args.host, str(args.port)])
try:
bjoern.listen(self.app(),
args.host or args.socket,
args.port,
reuse_port=args.reuse_port)
print('Listening at {listen_address}'.format(
listen_address=listen_address),
file=sys.stderr)
bjoern.run()
except KeyboardInterrupt:
print('\rExit requested', file=sys.stderr)
exit()
def main_loop(opts):
logger.info('Starting bjoern wsgi server: {}'.format(
_get_wsgi_server_version()))
worker_pids = []
host, port = get_host_and_port(opts)
logger.info("Listening: {host}:{port}".format(host=host, port=port))
bjoern.listen(application, host, port)
for worker_id in range(opts.workers):
pid = os.fork()
if pid > 0:
# in master
worker_pids.append(pid)
elif pid == 0:
# in worker
logger.info('registering worker-{}'.format(worker_id))
bjoern.run()
exit()
try:
for _ in range(opts.workers):
os.wait()
#: redundant, however it could be rewritten to use out of main signal
except KeyboardInterrupt:
for pid in worker_pids:
os.kill(pid, signal.SIGINT)
return 0
def _wsgi_helloworld_server(lock, port):
grpc_wsgi_app = sonora.wsgi.grpcWSGI(None)
helloworld_pb2_grpc.add_GreeterServicer_to_server(SyncGreeter(),
grpc_wsgi_app)
bjoern.listen(grpc_wsgi_app, "localhost", port)
lock.release()
bjoern.run()
def _wsgi_benchmark_server(lock, port):
grpc_wsgi_app = sonora.wsgi.grpcWSGI(None)
benchmark_pb2_grpc.add_BenchmarkServiceServicer_to_server(
SyncBenchmark(), grpc_wsgi_app)
bjoern.listen(grpc_wsgi_app, "localhost", port)
lock.release()
bjoern.run()
def start(name):
print "started server at "+str(host)+":"+str(port)
if name =="meinheld":
from meinheld import server
server.set_access_logger(None)
server.set_error_logger(None)
server.listen((host, port))
server.run(app)
elif name =="gevent":
#from gevent import wsgi
#wsgi.WSGIServer((host, port), application=app.application, log=None).serve_forever()
from gevent.pywsgi import WSGIServer
WSGIServer((host, port), app, log=None).serve_forever()
elif name =="bjoern":
import bjoern
bjoern.listen(app, host, port)
bjoern.run()
elif name =="eventlet":
import eventlet
from eventlet import wsgi
#worker_pool = eventlet.GreenPool(2000)
#wsgi.server(eventlet.listen(('', port)), app, custom_pool=worker_pool, log=file('/dev/null', 'w'))
# max_size
wsgi.server(eventlet.listen(('', port)), app, max_size=10000, log=file('/dev/null', 'w'))
elif name =="fapws":
import fapws._evwsgi as evwsgi
from fapws import base
evwsgi.start(host, str(port))
evwsgi.set_base_module(base)
evwsgi.wsgi_cb(('/', app))
evwsgi.set_debug(0)
evwsgi.run()
elif name=="uwsgi":
print ("""Enter this command in the console
\nsudo uwsgi --http :8000 --master --disable-logging --pythonpath /home/a/g --wsgi-file w.py --listen 2 --buffer-size 2048 --async 10000 --ugreen -p 4
""")
# http://osdir.com/ml/python-wsgi-uwsgi-general/2011-02/msg00136.html
#
# Re: strange SIGPIPE: writing to a closed pipe/socket/fd on image requested from facebook -msg#00136
"""
SIGPIPE: writing to a closed pipe/socket/fd (probably the client disconnected) on request /1 (ip 127.0.0.1) !!!
uwsgi_response_write_body_do(): Broken pipe [core/writer.c line 260]
IOError: write error
"""
cmd_txt = "sudo uwsgi --http :8000 --master --harakiri 1 --harakiri-verbose --close-on-exec --disable-logging --pythonpath /home/a/todo/test --wsgi-file w2.py --listen 2 --buffer-size 2048 --async 10000 --ugreen -p 4"
cmd(cmd_txt)
elif name=="pycgi":
from wsgiref.handlers import CGIHandler
CGIHandler().run(app)
elif name=="pystandard":
from wsgiref.simple_server import make_server
make_server(host, port, app).serve_forever()
def bjoern(entry, app, port, params):
import bjoern
def server(environ, start_response):
headers, response = entry(environ, app)
start_response('200 OK', headers)
if isinstance(response, str):
response = (response,)
return response
try:
bjoern.listen(server, '0.0.0.0', port)
bjoern.run()
except KeyboardInterrupt:
pass
print 'Closing...'
# Falcon API Configuration #
############################
# Middleware Configuration
api = falcon.API(
middleware=[
MySQLSessionManager(Session)
]
)
#################
# Route Loading #
#################
for route in ROUTES:
api.add_route('{}{}'.format(BASE_ENDPOINT, route), ROUTES[route]())
# Serve application
if __name__ == '__main__':
# If running on windows use waitress
if os.name == 'nt':
print('Starting waitress server on {}:{}'.format(AppConfig.SERVER['url'], AppConfig.SERVER['port']))
waitress.serve(api, host=AppConfig.SERVER['url'], port=AppConfig.SERVER['port'])
else:
print('Starting bjoern server on {}:{}'.format(AppConfig.SERVER['url'], AppConfig.SERVER['port']))
bjoern.listen(api, AppConfig.SERVER['url'], AppConfig.SERVER['port'])
bjoern.run()
def split_integer(num, parts):
quotient, remainder = divmod(num, parts)
lower_elements = [quotient for i in range(parts - remainder)]
higher_elements = [quotient + 1 for j in range(remainder)]
return lower_elements + higher_elements
def request_token():
if (int(time.time()) - REQUEST_TOKEN["last"]) < 3000:
return REQUEST_TOKEN["token"]
else:
_string = CLIENT_ID + ":" + CLIENT_SECRET
_enc = base64.b64encode(_string.encode())
_url = "https://accounts.spotify.com/api/token"
_header = {
"Authorization": "Basic " + _enc.decode(),
"Content-Type": "application/x-www-form-urlencoded",
}
_payload = "grant_type=client_credentials&undefined="
response = requests.post(_url, data=_payload, headers=_header)
access_token = response.json()["access_token"]
REQUEST_TOKEN["token"] = access_token
REQUEST_TOKEN["last"] = int(time.time())
return access_token
if __name__ == '__main__':
bjoern.listen(app, host="0.0.0.0", port=8006)
bjoern.run()
@app.route("/http/mongo_most")
def mongo_most():
collection = db.most_played_collection
alfal = collection.find()
ls = []
for item in alfal:
i = dict()
i["name"] = item["name"]
i["value"] = item["val"]
ls.append(i)
return Response(str(ls))
@app.route("/http/mongo_response")
def mongo_response():
collection = db.connectiontime
alfl = collection.find()
ls = []
for item in alfl:
i = dict()
i["x"] = item["x"]
i["y"] = item["y"]
ls.append(i)
return Response(str(ls))
if __name__ == "__main__":
bjoern.listen(host=HOST, port=PORT, wsgi_app=app)
bjoern.run()
predictions = verify(verification['source'],
data['renditions'],
do_profiling,
max_samples,
model_file,
model_name)
results = []
i = 0
for rendition in data['renditions']:
results.append(predictions[i])
i += 1
# Append the results to the verification object
verification['results'] = results
verification['model'] = model_uri
VERIFICATIONS_LOGGER.info(verification)
CONSOLE_LOGGER.info('Verification results: %s', results)
return jsonify(verification)
if __name__ == '__main__':
HOST = '0.0.0.0'
PORT = 5000
CONSOLE_LOGGER.info('Verifier server listening in port %s', PORT)
OPERATIONS_LOGGER.info('Verifier server listening in port %s', PORT)
bjoern.listen(APP, HOST, PORT)
bjoern.run()
import codeart.benchmarks
import codeart.benchmarks.servers as _util
from codeart.benchmarks._wsgi import *
_util.disable_logs()
if __name__ == "__main__":
import bjoern
bjoern.listen(app, 'localhost', _util.get_port(), reuse_port=True)
bjoern.run()
import os
import signal
import bjoern
import json
from x.app import init_app
NUM_WORKERS = os.cpu_count()
HOST = "0.0.0.0"
PORT = 5000
workers = []
print(f"Starting WSGI on {HOST}:{PORT}")
bjoern.listen(init_app(), HOST, PORT)
main_pid = os.getpid()
print(f"Main worker on PID {main_pid}")
KB_64 = 1024 * 64
cache = SharedCache(name="sharedcache")
print("Cache started")
for _ in range(NUM_WORKERS):
pid = os.fork()
if pid > 0:
workers.append(pid)
print(f"Worker process added with PID: {pid}")
else:
try:
import bjoern
import os, signal, sys
PORT = 6780
from cybersafe.wsgi import application
NUM_WORKERS = 8
worker_pids = []
bjoern.listen(application, 'localhost', PORT)
for _ in range(NUM_WORKERS):
pid = os.fork()
if pid > 0:
# in master
worker_pids.append(pid)
elif pid == 0:
# in worker
try:
bjoern.run()
except KeyboardInterrupt:
pass
exit()
try:
# Wait for the first worker to exit. They should never exit!
# Once first is dead, kill the others and exit with error code.
pid, xx = os.wait()
worker_pids.remove(pid)
finally:
for pid in worker_pids:
os.kill(pid, signal.SIGINT)
import bjoern
import os, signal
NUM_WORKERS = 8
worker_pids = []
def app(environ, start_response):
start_response('200 OK', [])
yield b'Hello world from worker %d' % os.getpid()
bjoern.listen(app, '0.0.0.0', 8080)
for _ in range(NUM_WORKERS):
pid = os.fork()
if pid > 0:
# in master
worker_pids.append(pid)
elif pid == 0:
# in worker
try:
bjoern.run()
except KeyboardInterrupt:
pass
exit()
try:
for _ in range(NUM_WORKERS):
os.wait()
except KeyboardInterrupt:
# execute SQL statement
cursor = link.cursor(dictionary=True)
try:
cursor.execute(sql)
# print results, insert id or affected row count
start_response('200 OK', [('Content-Type', 'text/html')])
if method == 'GET':
if key == 0:
yield str('[')
i = 0
for row in cursor:
yield str((',' if i > 0 else '') + json.dumps(row))
i += 1
if key == 0:
yield str(']')
elif method == 'POST':
yield str(cursor.lastrowid)
else:
yield str(cursor.rowcount)
except (mysql.connector.errors.DatabaseError) as err:
# die if SQL statement failed
start_response('404 Not Found', [('Content-Type', 'text/html')])
yield str(err.args[1])
# close mysql connection
link.close()
if __name__ == "__main__":
bjoern.listen(app, '127.0.0.1', 8000)
bjoern.run()
#
# def __call__(self, *args, **kwargs):
# if self.shall_reload():
# print('Reloading...')
# self.app = self.import_func()
# return self.app(*args, **kwargs)
#
# def import_app():
# sys.modules.pop('app', None)
# import app
# return app.app
NUM_WORKERS = 3
worker_pids = []
bjoern.listen(app, "localhost", 5000)
for _ in range(NUM_WORKERS):
pid = os.fork()
if pid > 0:
worker_pids.append(pid)
elif pid == 0:
try:
bjoern.run()
except KeyboardInterrupt:
pass
exit()
try:
for _ in range(NUM_WORKERS):
os.wait()
except KeyboardInterrupt:
from datarelay import wsgi
import bjoern
import os
from multiprocessing import Process
HOST = '0.0.0.0'
PORT = int(os.environ.get('RELAY_PORT', '7070'))
NUM_WORKERS = int(os.environ.get('WORKER_COUNT', '2'))
workers = []
print("Start server " + HOST + ":" + str(PORT))
bjoern.listen(wsgi.application, HOST, PORT)
def run(number):
try:
print("start worker #" + str(number))
bjoern.run()
except KeyboardInterrupt:
pass
for i in range(NUM_WORKERS):
p = Process(target=run, args=(i, ))
p.daemon = True
p.start()
workers.append(p)
try:
# response_body = urls[environ['PATH_INFO']]
# if environ['PATH_INFO'] == '/mjpeg':
response_body = cam.read()
status = '200 OK'
response_headers = [
('Content-Type', 'image/jpeg'),
('Content-Length', str(len(response_body)))
]
# start_response(status, response_headers)
start_response(status, response_headers)
# yield [response_body]
except Exception as e:
print(e)
status = '404 OK'
response_body = 'File not found'
response_headers = [
('Content-Type', 'text/plain'),
('Content-Length', str(len(response_body)))
]
start_response(status, response_headers)
# print('>>', response_body)
# start_response(status, response_headers)
return [response_body]
bjoern.listen(app, "localhost", 8000, True)
bjoern.run()
import bjoern
import os
import signal
from api import app
NUM_WORKERS = 2
worker_pids = []
bjoern.listen(app, 'unix:/tmp/website.sock')
for _ in range(NUM_WORKERS):
pid = os.fork()
if pid > 0:
# in master
worker_pids.append(pid)
elif pid == 0:
# in worker
try:
bjoern.run()
except KeyboardInterrupt:
pass
exit()
def run(self):
host, port = self.config.bind_addr
bjoern.listen(self.config.app, host, port)
bjoern.run()
import bjoern import os import signal from app import app host = '0.0.0.0' port = 5000 NUM_WORKERS = 2 worker_pids = [] bjoern.listen(app, host, port)
import bjoern
import os
import signal
from pyDMON import app
host = '0.0.0.0'
port = 5001
NUM_WORKERS = 2
worker_pids = []
bjoern.listen(app, host, port)
for _ in xrange(NUM_WORKERS):
pid = os.fork()
if pid > 0:
# in master
worker_pids.append(pid)
elif pid == 0:
# in worker
try:
bjoern.run()
except KeyboardInterrupt:
pass
exit()
try:
for _ in xrange(NUM_WORKERS):
os.wait()
except KeyboardInterrupt:
for pid in worker_pids:
os.kill(pid, signal.SIGINT)
import codeart.benchmarks
import codeart.benchmarks.servers as _util
import pyximport; pyximport.install()
import _wsgi_cython
_util.disable_logs()
if __name__ == "__main__":
import bjoern
bjoern.listen(_wsgi_cython.app, 'localhost', _util.get_port(), reuse_port=True)
bjoern.run()
def usage():
print("usage: python {} $iterations $log_level".format(sys.argv[0]))
if __name__ == "__main__":
if len(sys.argv) > 1 and sys.argv[1] in {"-h", "--help"}:
usage()
sys.exit(0)
iterations = int(sys.argv[1]) if len(sys.argv) > 1 else 1
level = getattr(
logging, sys.argv[2].upper()) if len(sys.argv) > 2 else logging.WARNING
host, port = "0.0.0.0", 8081
sock = bjoern.listen(app, host, port, reuse_port=True)
t = threading.Thread(target=bjoern.server_run, args=[sock, app])
t.setDaemon(True)
t.start()
reports = []
responses = []
tests = [{
"expectation": "100-continue",
"assertion": expect_100_continue
}, {
"expectation": "100-continue",
"assertion": expect_100_continue,
"body": ""
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import bjoern
import os
import signal
from openwater import wsgi
NUM_WORKERS = 8
worker_pids = []
bjoern.listen(wsgi.application, '127.0.0.1', 7777)
for _ in xrange(NUM_WORKERS):
pid = os.fork()
if pid > 0:
# in master
worker_pids.append(pid)
elif pid == 0:
# in worker
try:
bjoern.run()
except KeyboardInterrupt:
pass
exit()
try:
for _ in xrange(NUM_WORKERS):
os.wait()
except KeyboardInterrupt:
for pid in worker_pids:
response = json.dumps(data)
response_headers = [
('Content-Type', 'application/json; charset=utf-8'),
('Content-Length', str(len(response))),
]
start_response(b'200 OK', response_headers)
return [response]
def app(environ, start_response):
path = environ['PATH_INFO']
if path.startswith('/json-response'):
return request_json(environ, start_response)
else:
return request_json(environ, start_response)
if __name__ == "__main__":
import logging
import os
logging.disable(logging.CRITICAL)
logger = logging.getLogger()
logger.setLevel(logging.CRITICAL)
logger.disabled = True
logger.propagate = False
import bjoern
bjoern.listen(app, '0.0.0.0', int(os.getenv('PORT', 8000)), reuse_port=True)
bjoern.run()
import bjoern, os
def application(environ, start_response):
start_response('200 OK', [('Content-Type', 'text/plain')])
return b'Hello World!'
if __name__ == "__main__":
bjoern.listen(application, "localhost", 8080)
bjoern.run()
'An alphanumeric key and integer value must be supplied.')
with self.semaphore:
if not key in self.work_map:
self.work_map[key] = []
self.work_map[key].append(int(value))
response.status = falcon.HTTP_200
response.body = "Total Requests: {}".format(self.total_requests)
app = falcon.API()
app.req_options.auto_parse_form_urlencoded = True
numbers = NumberResource()
gevent.spawn(numbers.store_periodically)
app.add_route('/increment', numbers)
if __name__ == '__main__' and len(sys.argv) > 1:
if sys.argv[1] == 'bjoern':
# Bjoern is blazing fast, but its event loop is opaque.
# This means no background workers, and thus no guarantee that the server
# state will be completely flushed to the database at any given moment.
print "Bjoern WSGI server active - host {} port {}...".format(
HOST, PORT)
import bjoern
bjoern.listen(app, HOST, PORT)
bjoern.run()
elif sys.argv[1] == 'pywsgi':
# PyWSGI with gevent support is far faster than I expected - faster
# it seems than an out-of-the-box node/express installation.
print "PyWSGI server active - host {} port {}...".format(HOST, PORT)
server = pywsgi.WSGIServer((HOST, PORT), app, log=None)
server.serve_forever()
from gevent.wsgi import WSGIServer
except ImportError as e:
print(e)
from gevent.pywsgi import WSGIServer
# tornado方式部署,异步模式.
# http_server = HTTPServer(WSGIContainer(app))
# http_server.bind(port)
# # http_server.start(0)
# http_server.start(1)
# print("server running on {} port ...".format(port))
# IOLoop.current().start()
# bjoern部署方式,c语言,异步模式.注意,这种方式不支持ssl,也不能自定义headers
print("bjoern running on {} port ..".format(port))
bjoern.listen(app, "0.0.0.0", port)
bjoern.run()
# cherrypy部署方式,py语言,线程池模式.生产环境使用较多
# cherrypy.tree.graft(app, "/")
# server = cherrypy._cpserver.Server()
# server.socket_host = '0.0.0.0'
# server.socket_port = port
# server.thread_pool = 1500
# server.thread_pool_max = 5000
# server.start()
# meinheld 方式,部分c的py.
# server.listen(("0.0.0.0", port))
# server.run(app)
def main():
parser = ArgumentParser(prog='bjoern-cli',
formatter_class=arg_help_formatter)
parser.add_argument('--host',
default='0.0.0.0',
help='Host name or the IP address to bind with',
metavar='host')
parser.add_argument('--port',
default=8787,
type=int,
help='Port number to bind with',
metavar='port')
parser.add_argument(
'--module',
required=True,
help='Importable python module that exposes the WSGI app',
metavar='module')
parser.add_argument('--app',
default='app',
help='Name of the app as exposed by the module',
metavar='app')
parser.add_argument('--statsd-enable',
action='store_true',
help=feature_help_msg('Expose metrics to statsd',
has_statsd))
parser.add_argument('--statsd-host',
default='127.0.0.1',
help=feature_help_msg(
'Address of the Statsd collector', has_statsd),
metavar='host')
parser.add_argument('--statsd-port',
default=8125,
type=int,
help=feature_help_msg('Port of the Statsd collector',
has_statsd),
metavar='port')
parser.add_argument('--statsd-ns',
default='bjoern',
help=feature_help_msg('Statsd metrics namespace',
has_statsd),
metavar='namespace')
parser.add_argument(
'--statsd-tags',
default=[],
help=feature_help_msg(
'Comma separated list of tags to expose with metrics',
has_statsd_tags),
metavar='tags')
args = parser.parse_args()
try:
mod = importlib.import_module(args.module)
except ImportError:
raise ImportError('Failed to find module {}'.format(args.module))
try:
app = getattr(mod, args.app)
except AttributeError:
raise ImportError(
'Failed to find app {app} in module {mod}. Is {mod}.{app} importable?'
.format(app=args.app, mod=args.module))
if not callable(app):
raise TypeError('{mod}.{app} must be callable'.format(app=args.app,
mod=args.module))
statsd_args = dict()
if args.statsd_enable:
if has_statsd:
statsd_args = {
'enable': True,
'host': args.statsd_host,
'port': args.statsd_port,
'ns': args.statsd_ns
}
if args.statsd_tags and has_statsd_tags:
statsd_args['tags'] = args.statsd_tags
server_args = dict()
if statsd_args:
server_args['statsd'] = statsd_args
bjoern.listen(app, args.host, args.port)
bjoern.run(**server_args)
common_log(environ, '200', size)
headers = [('Content-Type', mime), ('Content-Length', size)]
start_response(status, headers)
return body
if __name__ == "__main__":
WORKERS = int(os.environ.get('WORKERS', '8'))
PORT = int(os.environ.get('PORT', '8890'))
UBNT_PASSWORD = os.environ.get('UBNT_PASSWORD', 'ubnt')
print(
f'Staring at http://0.0.0.0:{PORT}/metrics (use PORT environment variable to change).',
file=sys.stderr)
bjoern.listen(application, '0.0.0.0', PORT)
worker_pids = []
print('Workers', end='', file=sys.stderr)
for _ in range(WORKERS):
pid = os.fork()
if pid > 0: # in master
worker_pids.append(pid)
print('', pid, end='', file=sys.stderr)
elif pid == 0: # in worker
try:
bjoern.run()
except:
pass
exit()
print(
def get(self):
rows = find_all()
response = HTTPResponse()
response.write(rows)
return response
def post(self):
data = self.request.form
insert(data)
response = HTTPResponse()
response.status_code = 201
return response
all_urls = [
url('', DatabaseHandler, name='database'),
url('hello', HelloHandler, name='hello'),
]
main = WSGIApplication(
middleware=[bootstrap_defaults(url_mapping=all_urls), path_routing_middleware_factory],
options={}
)
if __name__ == '__main__':
bjoern.listen(main, '0.0.0.0', 8080)
bjoern.run()
import falcon
import bjoern
from side import detect, find, status, upload
app = falcon.API()
app.add_route('/detect/', detect())
app.add_route('/find/', find())
app.add_route('/health/', status())
app.add_route('/photo/', upload())
if __name__ == '__main__':
print("Server Started")
bjoern.listen(app, '0.0.0.0', 6978)
bjoern.run()
@app.route('/api/jpeg', methods=['POST'])
def login():
if request.method == 'POST':
r = request
nparr = np.fromstring(r.data, np.uint8)
frame = cv2.imdecode(nparr, cv2.IMREAD_COLOR)
result = network.predict(format_image(frame))
resp = dict()
if result is not None:
resp = {
'contains': True,
'emotions': {
'angry': result.item(0),
'disgusted': result.item(1),
'fearful': result.item(2),
'happy': result.item(3),
'sad': result.item(4),
'surprised': result.item(5),
'neutral': result.item(6)
}
}
else:
resp = {'contains': False, 'emotions': None}
return jsonify(resp)
if __name__ == '__main__':
network.build_network()
bjoern.listen(app, "0.0.0.0", 8888)
print("Listening on 8888")
bjoern.run()
import bjoern
def app(environ, start_response):
start_response('200 OK', [])
yield b'Hello world'
yield b''
bjoern.listen(app, '0.0.0.0', 8080)
bjoern.run()
def run(app):
bjoern.listen(app, "0.0.0.0", port=8000, reuse_port=True)
bjoern.run()
