def handle(self, addr_port=None, pool_size=None, *args, **options): if args: raise CommandError('Usage: [ipaddr:]addr_port pool_size') addr_port = addr_port or getattr(settings, 'GEVENT_ADDR_PORT', defaults['GEVENT_ADDR_PORT']) pool_size = pool_size or getattr(settings, 'GEVENT_POOL_SIZE', defaults['GEVENT_POOL_SIZE']) try: addr, port = addr_port.split(':') except ValueError: addr, port = '', addr_port try: port = int(port) except ValueError: raise CommandError('Port must be an integer') if pool_size: try: pool_size = int(pool_size) pool = Pool(pool_size) except ValueError: raise CommandError('Spawn pool size must be an integer') else: pool = None wsgi_application = get_internal_wsgi_application() wsgi.WSGIServer((addr, port), wsgi_application, spawn=pool).serve_forever()
def run_wsgi(self): http = self.cfgs.get('http') host = http.get('host', '127.0.0.1') port = http.get('port', 5000) print 'Server Started, Listen on %s:%s ...' % (host, port) server = wsgi.WSGIServer((host, port), self.flask_app) server.serve_forever()
def run(self, handler): if not self.options.pop('fast', None): wsgi = pywsgi self.options['log'] = sys.stdout if cfg.config.get( 'dologstdout', None) else None address = (self.host, self.port) wsgi.WSGIServer(address, handler, **self.options).serve_forever()
def start_sever(http_id, port, gpu_id, vocab_file, gpu_memory_fraction, model_path, max_seq_length): model = ClassificationModel() model.load_model(gpu_id, vocab_file, gpu_memory_fraction, model_path, max_seq_length) print("load model ending!") app = Flask(__name__) @app.route('/') def index(): return "This is News Classification Model Server" @app.route('/news-classification', methods=['Get', 'POST']) def response_request(): if request.method == 'POST': text = request.form.get('text') else: text = request.args.get('text') label, label_name = model.predict(text) d = {"label": str(label), "label_name": label_name} print(d) return json.dumps(d, ensure_ascii=False) server = wsgi.WSGIServer((str(http_id), port), app) server.serve_forever()
def main(): from gevent.monkey import patch_all patch_all() import os from datetime import timedelta from gevent import wsgi from .collector import PrometheusMetricCollector class QuietWSGIHandler(wsgi.WSGIHandler): """WSGIHandler subclass that will not create an access log""" def log_request(self, *args): pass port = int(os.environ['SERVICE_PORT']) ttl = timedelta(hours=int(os.environ.get('TORCH_TTL', 24))) metrics_prefix = '/metrics' application = PrometheusMetricCollector(prefix=metrics_prefix, ttl=ttl) httpd = wsgi.WSGIServer(('0.0.0.0', port), application, handler_class=QuietWSGIHandler) try: httpd.serve_forever() except: httpd.stop()
def start_sever(): args = set_args() os.environ["CUDA_DEVICE_ORDER"] = "PCI_BUS_ID" os.environ["CUDA_VISIBLE_DEVICE"] = args.device device = torch.device("cuda" if torch.cuda.is_available() and int(args.device) >= 0 else "cpu") # 实例化tokenizer和model tokenizer = BertTokenizer.from_pretrained(args.vocab_path, do_lower_case=True) model = GPT2LMHeadModel.from_pretrained(args.output_dir) model.to(device) model.eval() print("load model ending!") app = Flask(__name__) @app.route('/') def index(): return "This is News Title Generate Model Server" @app.route('/news-title-generate', methods=['Get', 'POST']) def response_request(): if request.method == 'POST': content = request.form.get('content') titles = predict_one_sample(model, tokenizer, device, args, content) title_str = "" for i, t in enumerate(titles): title_str += "生成的第{}个标题为:{}\n".format(i + 1, t) return render_template("index_ok.html", content=content, titles=title_str) return render_template("index.html") server = wsgi.WSGIServer((str(args.http_id), args.port), app) server.serve_forever()
def runserver(): log.info("Poracle is running on: http://{}:{}".format(args.host, args.port)) server = wsgi.WSGIServer( (args.host, args.port), app, log=logging.getLogger('Webserver')) server.serve_forever()
def run(self, handler): import threading, os, _socket from gevent import wsgi, pywsgi, local if not isinstance(threading.local(), local.local): msg = "Bottle requires gevent.monkey.patch_all() (before import)" raise RuntimeError(msg) if not self.options.pop('fast', None): wsgi = pywsgi self.options['log'] = None if self.quiet else 'default' address = (self.host, self.port) server = wsgi.WSGIServer(address, handler, **self.options) server.init_socket() if hasattr(_socket, 'SO_KEEPALIVE'): server.socket.setsockopt(_socket.SOL_SOCKET, _socket.SO_KEEPALIVE, 1) if hasattr(_socket, 'TCP_KEEPIDLE'): server.socket.setsockopt(_socket.IPPROTO_TCP, _socket.TCP_KEEPIDLE, self.tcp_keepalive_idle_time) if hasattr(_socket, 'TCP_KEEPINTVL'): server.socket.setsockopt(_socket.IPPROTO_TCP, _socket.TCP_KEEPINTVL, self.tcp_keepalive_interval) if hasattr(_socket, 'TCP_KEEPCNT'): server.socket.setsockopt(_socket.IPPROTO_TCP, _socket.TCP_KEEPCNT, self.tcp_keepalive_probes) if hasattr(_socket, 'SO_REUSEADDR'): server.socket.setsockopt(_socket.SOL_SOCKET, _socket.SO_REUSEADDR, 1) if 'BOTTLE_CHILD' in os.environ: import signal signal.signal(signal.SIGINT, lambda s, f: server.stop()) server.serve_forever()
def __init__(self, orion_host="http://localhost:1026", orion_api="v2", labels=None, accumulate_address="http://localhost:8080", *args, **kw): super(OrionContextBroker, self).__init__(*args, **kw) if isinstance(labels, basestring): self.labels = {labels} elif hasattr(labels, '__iter__'): self.labels = set(labels) else: self.labels = None self._entity_names = {} self._subscriptions = {} self.logger.critical(accumulate_address) self.orion_api = OrionAPI( orion_host=orion_host, api_version=orion_api, accumulate_endpoint="{}/accumulate".format(accumulate_address)) # Subscription Sink for OCB self.app = Flask(__name__) self.app.add_url_rule( '/accumulate', 'process_notification', self.process_notification, methods=["POST"]) accumulate_ip, accumulate_port = accumulate_address.split('//')[ 1].split(':') self.server = wsgi.WSGIServer((accumulate_ip, int(accumulate_port)), self.app) self.server.start()
def example1(): print "The sweet thing is running on http://localhost:8912/" pool = gevent.pool.Pool( ) # A pool of greenlets.Each greenlets runs the above defined function app for a client request server = wsgi.WSGIServer( ("localhost", 8912), app, spawn=pool ) # the server is created and runs multiple greenlets concurrently server.serve_forever() # the server is made to run in loop
def main(options): server = wsgi.WSGIServer(('', config.PORT), wsgi_main) client_gc = gc.ClientGC() try: client_gc.start() server.serve_forever() except KeyboardInterrupt: server.stop()
def runConfilterSingle(): host = config.get('host') port = int(config.get('port')) poolSize = int(config.get('poolSize')) p = pool.Pool(poolSize) log.info("Start server on %s:%s with pool size %s" % (host, port, poolSize)) wsgi.WSGIServer((host, port), confilterApp, spawn=p).serve_forever()
def runServer(): host = config.get('host') port = int(config.get('port')) poolSize = int(config.get('poolSize')) p = pool.Pool(poolSize) log.info("Start server on %s:%s with pool szie %s" % (host, port, poolSize)) application = web.application(urls, globals()).wsgifunc() wsgi.WSGIServer((host, port), application, spawn=p).serve_forever()
def start(locust, hatch_rate, num_clients, num_requests, ramp): global _locust, _hatch_rate, _num_clients, _num_requests, _ramp _locust = locust _hatch_rate = hatch_rate _num_clients = num_clients _num_requests = num_requests _ramp = ramp wsgi.WSGIServer(('', 8089), app, log=None).serve_forever()
def run(self): http = self.conf.get('http') host = http.get('host', '127.0.0.1') port = http.get('port', 5000) app = self.getFlaskApp() self.server = wsgi.WSGIServer((host, port), app) print 'Server: %s started, Listen on %s:%s ...' % (self.appId, host, port) self.server.start() Application.run(self)
def setUp(self): super(TestWebUI, self).setUp() stats.global_stats.clear_all() runners.locust_runner = LocustRunner([], None, None, None, None) self._web_ui_server = wsgi.WSGIServer(('127.0.0.1', 0), web.app, log=None) gevent.spawn(lambda: self._web_ui_server.serve_forever()) gevent.sleep(0.01) self.web_port = self._web_ui_server.server_port
def runConfilterMultiproc(CHILD_COUNT=5): host = config.get('host') port = int(config.get('port')) poolSize = int(config.get('poolSize')) p = pool.Pool(poolSize) log.info("Start server on %s:%s with pool size %s" % (host, port, poolSize)) listener = socket.socket(socket.AF_INET, socket.SOCK_STREAM, 0) listener.bind((host, port)) listener.listen(CHILD_COUNT) for _ in range(CHILD_COUNT): pid = os.fork() if pid == 0: wsgi.WSGIServer(listener, confilterApp, spawn=p).serve_forever() sys.exit(0) elif pid > 0: continue # wsgi.WSGIServer((host, port), confilterApp, spawn = p).serve_forever() wsgi.WSGIServer(listener, confilterApp, spawn=p).serve_forever()
def __call__(self, app, host, port): # we don't need to run the server in request context # so just run it directly from gevent import monkey; monkey.patch_all() from gevent import wsgi print "* Running gserver on http://%s:%s" % (host, port) try: wsgi.WSGIServer((host, int(port)), app).serve_forever() except KeyboardInterrupt: sys.exit(0)
def runserver(): app_dir = os.path.abspath(os.path.dirname(__file__)) sys.path.append(os.path.dirname(app_dir)) os.environ['DJANGO_SETTINGS_MODULE'] = 'eventlet_django.settings' # application = django.core.handlers.wsgi.WSGIHandler() application = get_wsgi_application() server = wsgi.WSGIServer(('', 8080), application, spawn='default') try: server.serve_forever() except KeyboardInterrupt: server.stop() sys.exit(0)
def runserver(): t = Thread(target=provision_bot, ) t.daemon = True t.start() # Start thread for discord bot log.info("Poracle is running on: http://{}:{}".format( args.host, args.port)) threads = pool.Pool(args.concurrency) server = wsgi.WSGIServer((args.host, args.port), app, log=logging.getLogger('Webserver'), spawn=threads) server.serve_forever()
def setUp(self): super(TestWebUI, self).setUp() stats.global_stats.clear_all() parser = parse_options()[0] options = parser.parse_args([])[0] runners.locust_runner = LocustRunner([], options) web.request_stats.clear_cache() self._web_ui_server = wsgi.WSGIServer(('127.0.0.1', 0), web.app, log=None) gevent.spawn(lambda: self._web_ui_server.serve_forever()) gevent.sleep(0.01) self.web_port = self._web_ui_server.server_port
def run(self, handler): from gevent import wsgi, pywsgi, local import threading _lcth = threading.local() if not isinstance(_lcth, local.local): msg = "Bottle requires gevent.monkey.patch_all() (before import)" raise RuntimeError(msg) if not self.options.get('fast'): wsgi = pywsgi log = None if self.quiet else 'default' wsgi.WSGIServer( (self.host, self.port), handler, log=log, keyfile='/opt/smanagement/api-rest/key.pem', certfile='/opt/smanagement/api-rest/cert.pem').serve_forever()
def fun_forever(): from brubeck.request_handling import CORO_LIBRARY print "Serving on port %s..." % (self.port) def proc_msg(environ, callback): return self.process_message(application, environ, callback) if CORO_LIBRARY == 'gevent': from gevent import wsgi server = wsgi.WSGIServer(('', self.port), proc_msg) server.serve_forever() elif CORO_LIBRARY == 'eventlet': import eventlet server = eventlet.wsgi.server(eventlet.listen(('', self.port)), proc_msg)
def run(self, handler): from gevent import wsgi, pywsgi, local if not isinstance(threading.local(), local.local): msg = "Bottle requires gevent.monkey.patch_all() (before import)" raise RuntimeError(msg) if not self.options.pop('fast', None): wsgi = pywsgi self.options['log'] = None if self.quiet else 'default' address = (self.host, self.port) server = wsgi.WSGIServer(address, handler, **self.options) # if 'BOTTLE_CHILD' in os.environ: # import signal # signal.signal(signal.SIGINT, lambda s, f: server.stop()) if self.forever: server.serve_forever() else: if not server.started: server.start()
def greenlet_admin(self): """ This greenlet is used to get status information about the worker when --admin_port was given """ if self.config["processes"] > 1: self.log.debug( "Admin server disabled because of multiple processes.") return class Devnull(object): def write(self, *_): pass from gevent import wsgi def admin_routes(env, start_response): path = env["PATH_INFO"] status = "200 OK" res = "" if path in ["/", "/report", "/report_mem"]: report = self.get_worker_report( with_memory=(path == "/report_mem")) res = bytes(json_stdlib.dumps(report, cls=MongoJSONEncoder), 'utf-8') elif path == "/wait_for_idle": self.idle_wait_count = 0 self.idle_event.clear() self.idle_event.wait() res = "idle" else: status = "404 Not Found" start_response(status, [('Content-Type', 'application/json')]) return [res] server = wsgi.WSGIServer( (self.config["admin_ip"], self.config["admin_port"]), admin_routes, log=Devnull()) try: self.log.debug("Starting admin server on port %s" % self.config["admin_port"]) server.serve_forever() except Exception as e: # pylint: disable=broad-except self.log.debug("Error in admin server : %s" % e)
def start_server(): # Parse Settings parse_settings(os.path.abspath(os.path.dirname(__file__))) # Start Webhook Manager in a Thread spawn(manage_webhook_data, data_queue) # Start up Server log.info("PokeAlarm is listening for webhooks on http://{}:{}" "".format(config['HOST'], config['PORT'])) threads = pool.Pool(config['CONCURRENCY']) global server server = wsgi.WSGIServer( (config['HOST'], config['PORT']), app, log=logging.getLogger('webserver.internal'), spawn=threads) server.serve_forever()
def run(self, addr_port=None, pool_size=None, *args, **options): if args: raise CommandError('Usage: [ipaddr:]addr_port pool_size') addr_port = addr_port or getattr(settings, 'GEVENT_ADDR_PORT', defaults['GEVENT_ADDR_PORT']) pool_size = pool_size or getattr(settings, 'GEVENT_POOL_SIZE', defaults['GEVENT_POOL_SIZE']) try: addr, port = addr_port.split(':') except ValueError: addr, port = '', addr_port try: port = int(port) except ValueError: raise CommandError('Port must be an integer') if pool_size: try: pool_size = int(pool_size) pool = Pool(pool_size) except ValueError: raise CommandError('Spawn pool size must be an integer') else: pool = None quit_command = (sys.platform == 'win32') and 'CTRL-BREAK' or 'CONTROL-C' self.stdout.write("Validating models...\n\n") self.validate(display_num_errors=True) self.stdout.write(( "%(started_at)s\n" "Django version %(version)s, using settings %(settings)r\n" "Development server is running at http://%(addr)s:%(port)s/\n" "Quit the server with %(quit_command)s.\n" ) % { "started_at": datetime.now().strftime('%B %d, %Y - %X'), "version": self.get_version(), "settings": settings.SETTINGS_MODULE, "addr": addr, "port": port, "quit_command": quit_command, }) wsgi_application = get_internal_wsgi_application() wsgi.WSGIServer((addr, port), wsgi_application, spawn=pool).serve_forever()
def start_server(): log.setLevel(logging.INFO) logging.getLogger('PokeAlarm').setLevel(logging.INFO) logging.getLogger('requests').setLevel(logging.WARNING) logging.getLogger('pyswgi').setLevel(logging.WARNING) logging.getLogger('connectionpool').setLevel(logging.WARNING) logging.getLogger('gipc').setLevel(logging.WARNING) logging.getLogger("urllib3").setLevel(logging.WARNING) parse_settings(os.path.abspath(os.path.dirname(__file__))) # Start Webhook Manager in a Thread spawn(manage_webhook_data, data_queue) # Start up Server log.info("PokeAlarm is listening for webhooks on: http://{}:{}".format(config['HOST'], config['PORT'])) server = wsgi.WSGIServer((config['HOST'], config['PORT']), app, log=logging.getLogger('pyswgi')) server.serve_forever()
def main(): parser = argparse.ArgumentParser( description="Xbox One SmartGlass REST server") parser.add_argument('--address', '-a', default='0.0.0.0', help='IP address to bind to') parser.add_argument('--port', '-p', default=5557, help='Port to bind to') parser.add_argument('--tokens', '-t', default=TOKENS_FILE, help='Tokenfile to load') parser.add_argument('--logfile', '-l', help="Path for logfile") args = parser.parse_args() root_logger = logging.getLogger() root_logger.setLevel(logging.DEBUG) root_logger.addHandler(default_handler) if args.logfile: app.logger.info('Setting logfile path to {0}'.format(args.logfile)) file_handler = RotatingFileHandler(args.logfile, backupCount=2) file_handler.setLevel(logging.DEBUG) file_handler.setFormatter(logging.Formatter(LOG_FMT)) root_logger.addHandler(file_handler) app.logger.info( 'Starting Xbox Smartglass REST server started on {0}:{1}'.format( args.address, args.port)) app.logger.debug('Setting tokenfile path to {0}'.format(args.tokens)) app.token_file = args.tokens try: app.logger.info('Trying to load & refresh tokens') app.authentication_mgr.load(args.tokens) app.authentication_mgr.authenticate(do_refresh=True) except Exception as e: app.logger.warning( 'Failed to authenticate with tokenfile from {0}, error: {1}'. format(args.tokens, e)) server = wsgi.WSGIServer((args.address, args.port), app) server.serve_forever()
def __init__(self, port=DEFAULT_PORT): # REST services monkey.patch_all() signal(SIGQUIT, shutdown) self.is_config = False self.server = wsgi.WSGIServer(('', int(port)), self._response_handler, log=None) # sharding self.prefix = None self.shard_id = None self.ring = None # concurrency based on message passing / barrier pattern self._task_event = None self._task_queue = None # UnitOfWork self._uow = None