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()