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
