def run_server(host=None, port=None, workers=None, debug=None,
logfile=None, stdout=None, loglevel=None):
if not host:
host = settings.server_host
if not port:
port = settings.server_port
if workers is not None:
settings.workers = workers
if debug:
settings.debug = True
try:
proctitle = settings.proctitle
except AttributeError:
proctitle = 'geweb'
setproctitle(proctitle)
log.info('Starting HTTP server at %s:%d' % (host, port))
pool = Pool(10000)
server = WSGIServer("%s:%s" % (host, port), handle, spawn=pool)
server.init_socket()
for i in xrange(settings.workers - 1):
pid = gevent.fork()
if pid == 0:
break
server.serve_forever()
def main():
options = parser.parse_args()
logging.basicConfig(
level=getattr(logging, options.log_level.upper(), logging.INFO),
format="[%(asctime)s] %(filename)s:%(lineno)d %(levelname)s %(message)s"
)
app.config['DATABASE'] = options.db
init_db()
app.template_folder = TEMPLATES_PATH
app.static_folder = STATIC_PATH
log.info("Starting service on http://%s:%d/", options.listen, options.port)
if options.debug:
log.warning("Running on debug mode not for production.")
app.run(host=options.listen, port=options.port, debug=True)
else:
http_server = WSGIServer((options.listen, options.port), app)
with suppress(KeyboardInterrupt):
http_server.serve_forever()
def run(interface='0.0.0.0', port=5000):
print u" * Server is running at %s:%s" % (interface, port)
wsgi = DebuggedApplication(app)
http_server = WSGIServer((interface, port), wsgi)
http_server.serve_forever()
def run_server(port=5000, debug=False):
app = twidder.app
if debug:
app = werkzeug.debug.DebuggedApplication(app)
http_server = WSGIServer(('', port), app, handler_class=WebSocketHandler)
http_server.serve_forever()
def main():
if args.action == 'run':
host = ''.join(args.bind.split(':')[:-1])
port = int(args.bind.split(':')[-1])
if args.name != PROC_TITLE_DEFAULT:
try:
import setproctitle
proc_title = 'Spray Server: ' + args.name
setproctitle.setproctitle(proc_title)
logging.debug('Using custom process title ' + proc_title)
except ImportError:
logging.debug('Could not set process title as specified. Python module "setproctitle" required')
if args.mode == 'development':
app = create_app(args)
logging.debug('Launching server in development mode')
app.run(debug=args.debug, host=host, port=port)
elif args.mode == 'production':
args.cache = True
cache_path = os.path.abspath(os.path.join(args.path, 'cache'))
logging.debug('Clearing cache directory {path}'.format(path=cache_path))
if os.path.exists(cache_path):
shutil.rmtree(cache_path)
create_directory(cache_path)
app = create_app(args)
try:
from gevent.wsgi import WSGIServer
logging.debug('Launching server in production mode with gevent')
server = WSGIServer((host, port), app, log=None)
server.serve_forever()
except ImportError:
logging.debug('Launching server in production mode without gevent')
app.run(host=host, port=port)
elif args.action == 'create':
create_project()
class DjangoApp(DirtApp):
log = logging.getLogger(__name__)
def setup(self):
self.application = DjangoWSGIApp()
if self.settings.DEBUG:
from werkzeug import DebuggedApplication
self.application = DebuggedApplication(self.application, evalex=True)
settings.get_api = self.settings.get_api
self.server = WSGIServer(self.settings.http_bind, self.application, log=None)
def serve_dirt_rpc(self):
""" Calls ``DirtApp.serve`` to start the RPC server, which lets callers
use the debug API. """
if getattr(self.settings, "bind_url", None) is None:
self.log.info("no `bind_url` specified; RPC server not starting.")
return
DirtApp.serve(self)
def serve(self):
self.api_thread = gevent.spawn(self.serve_dirt_rpc)
self.log.info("Starting server on http://%s:%s...", *self.settings.http_bind)
self.server.serve_forever()
def get_api(self, *args, **kwargs):
""" The DjangoApp returns an empty API object by default so that tab
completion of the API will work. Feel free to override this method.
"""
return object()
def main(argv):
global port, log, pidfile, interface
try:
opts, args = getopt.getopt(argv, "p:l:i:h", ["pidfile="])
except getopt.GetoptError:
usage()
sys.exit(2)
for opt, arg in opts:
if opt == '-h':
usage()
sys.exit()
elif opt == '-p':
port = int(arg)
elif opt == '-l':
try:
log = open(arg, 'w')
except:
sys.stderr.write("Can not open log file.\n")
sys.exit(1)
elif opt == '-i':
interface = arg
elif opt == '--pidfile':
pidfile = arg
if pidfile:
with open(pidfile, 'w') as f:
f.write(str(os.getpid()))
signal.signal(signal.SIGTERM, shutdown_handler)
signal.signal(signal.SIGINT, shutdown_handler)
http_server = WSGIServer((interface, port), application=app, log=log)
try:
http_server.serve_forever()
except:
clean_pidfile()
sys.exit() # Don't print backtrace for KeyboardInterrupt
def start_servers(upstream_dns, ifname):
dns_queue = Queue()
dnsserver = PACDNSServer(upstream_dns, queue=dns_queue)
dnsserver.start()
gevent.spawn(handle_subscriptions, dns_queue)
server = WSGIServer(('0.0.0.0', 8081), app)
server.serve_forever()
def run():
"""Run gevent server"""
http_server = WSGIServer((core_settings.SERVER_ADDRESS, core_settings.SERVER_PORT), app)
try:
http_server.serve_forever()
except KeyboardInterrupt:
http_server.stop()
def serve(self, port):
"""
Serve status over HTTP forever.
"""
flaskapp._status = self._status
http_server = WSGIServer(('', port), flaskapp)
http_server.serve_forever()
def main(argv=None):
args = parse_paasta_api_args()
if args.debug:
logging.basicConfig(level=logging.DEBUG)
else:
logging.basicConfig(level=logging.WARNING)
if args.soa_dir:
settings.soa_dir = args.soa_dir
# Exit on exceptions while loading settings
settings.cluster = load_system_paasta_config().get_cluster()
marathon_config = marathon_tools.load_marathon_config()
settings.marathon_client = marathon_tools.get_marathon_client(
marathon_config.get_url(),
marathon_config.get_username(),
marathon_config.get_password()
)
# Set up transparent cache for http API calls. With expire_after, responses
# are removed only when the same request is made. Expired storage is not a
# concern here. Thus remove_expired_responses is not needed.
requests_cache.install_cache("paasta-api", backend="memory", expire_after=30)
server = WSGIServer(('', int(args.port)), make_app())
log.info("paasta-api started on port %d with soa_dir %s" % (args.port, settings.soa_dir))
try:
server.serve_forever()
except KeyboardInterrupt:
sys.exit(0)
class GeventWSGIServer(object):
"""Adapter for a gevent.wsgi.WSGIServer."""
def __init__(self, *args, **kwargs):
from eden.web.patch import patch_cherrypy
patch_cherrypy()
self.args = args
self.kwargs = kwargs
self.ready = False
def start(self):
"""Start the GeventWSGIServer."""
# We have to instantiate the server class here because its __init__
from gevent.wsgi import WSGIServer
self.ready = True
LOGGER.debug('Starting Gevent WSGI Server...')
self.httpd = WSGIServer(*self.args, **self.kwargs)
self.httpd.serve_forever()
def stop(self):
"""Stop the HTTP server."""
LOGGER.debug('Stoping Gevent WSGI Server...')
self.ready = False
self.httpd.stop()
def start_server():
WSGIServer.handler_class = ErrorHandler
server = WSGIServer(("", PORT), app)
print "Please open a web browser to http://127.0.0.1:", PORT
ferr = open('out.log', 'w')
server.log = ferr #redirect the server log
server.serve_forever()
def gevent():
from gevent.wsgi import WSGIServer
bipbalance_client.logger.info("Running Gevent on port %s", config.port)
http_server = WSGIServer(('', config.port), bipbalance_client)
http_server.serve_forever()
def serve(self, port, app, block=False):
server = WSGIServer(("", port), app)
server.handler_class = CustomHandler
if not block:
self.greenlets.append(gevent.spawn(server.serve_forever))
else:
server.serve_forever()
def main():
if config["ENV"] == "local":
app.debug = True
print "Explainer listening on http://%s" % config["EXPLAINER"]
sys.stdout.flush()
http_server = WSGIServer((config["EXPLAINER"].split(":")[0], int(config["EXPLAINER"].split(":")[1])), app)
http_server.serve_forever()
def execute_from_cli(hostname, cluster, with_ui, peers):
polar_client = PolarClient(hosts=peers, handler=GeventHandler())
polar_client.start()
crow = CrowContext(polar_client, hostname, cluster)
actor_name = "%s-%s" % (hostname, cluster)
actor_system = ActorSystem(
polar_client=polar_client,
name=actor_name
)
actor_system.actor_of(KeepRpcActor.props(
crow=crow,
polar_client=polar_client
))
crow.announce()
if with_ui == True:
from keep.ui import app
app.config["actor_flask"] = actor_system
app.config["polar_client"] = polar_client
# adapt polar client wo work with the WSGI adapter
http_server = WSGIServer(('', 5000), app)
print "Stared UI on port 5000"
http_server.serve_forever()
gevent.wait()
def run():
skipped_components = []
LOGGER.info('environment: %s' % os.environ.items())
if not config.read().getboolean('fqrouter', 'BypassDirectlyEnabled'):
LOGGER.info('scrambler component disabled by config')
COMPONENTS.remove(comp_scrambler)
for comp in COMPONENTS:
try:
shutdown_hook.add(comp.stop)
handlers = comp.start()
for method, url, handler in handlers or []:
HANDLERS[(method, url)] = handler
LOGGER.info('started component: %s' % comp.__name__)
except:
LOGGER.exception('failed to start component: %s' % comp.__name__)
comp.stop()
if getattr(comp, '__MANDATORY__', False):
raise
skipped_components.append(comp.__name__)
LOGGER.info('all components started except: %s' % skipped_components)
try:
httpd = WSGIServer(('127.0.0.1', 8318), handle_request)
LOGGER.info('serving HTTP on port 8318...')
except:
LOGGER.exception('failed to start HTTP server on port 8318')
sys.exit(1)
httpd.serve_forever()
def serve_forever(self,*args,**kw):
from handlers_base import APIHandler
from process_reader import ProcessReader
from u2py.config import reader_path
try:
APIHandler.readers = [ProcessReader(**reader_kw) for reader_kw in reader_path]
[reader.open() for reader in APIHandler.readers]
def signal_handler(sgn,frame):
logging.debug('Stop signal catched[%i].' % (sgn))
self.stop()
logging.debug('Web-server stopped.')
try:
if hasattr(signal,'SIGBREAK'):
signal.signal(signal.SIGBREAK, signal_handler) #maps to CTRL_BREAK_EVENT on windows
signal.signal(signal.SIGINT, signal_handler) #maps to CTRL_C_EVENT for windows
signal.signal(signal.SIGTERM, signal_handler)
except ValueError:
print 'Signals only works in main thread'
WSGIServer.serve_forever(self,*args,**kw)
except KeyboardInterrupt:
pass
finally:
[reader.close() for reader in APIHandler.readers]
def run(self):
# setups
self.setup_application()
self.setup_api()
# start periodic update thread
pa = api.PeriodicUpdater()
pa.start()
# start API server
if False:
# default server:
logging.info("API Server: Pure Flask")
self.app.run(debug=False, use_reloader=False,
port=model.CONFIG["api"]["port"])
elif False:
logging.info("API Server: Gevent")
from gevent.wsgi import WSGIServer
http_server = WSGIServer(('',
model.CONFIG["api"]["port"]),
self.app)
http_server.serve_forever()
else:
logging.info("API Server: Tornado")
from tornado.wsgi import WSGIContainer
from tornado.httpserver import HTTPServer
from tornado.ioloop import IOLoop
http_server = HTTPServer(WSGIContainer(self.app))
http_server.listen(model.CONFIG["api"]["port"])
IOLoop.instance().start()
def main():
parser = argparse.ArgumentParser()
parser.add_argument('-p', '--port', help='server port',
type=int, default=9000)
args = parser.parse_args()
http_server = WSGIServer(('', args.port), app)
http_server.serve_forever()
def gevent_run(app, port=5000, log=None, error_log=None, address='',
monkey_patch=True, start=True, **kwargs): # pragma: no cover
"""Run your app in gevent.wsgi.WSGIServer
:param app: wsgi application, ex. Microservice instance
:param port: int, listen port, default 5000
:param address: str, listen address, default: ""
:param log: logger instance, default app.logger
:param error_log: logger instance, default app.logger
:param monkey_patch: boolean, use gevent.monkey.patch_all() for patching standard modules, default: True
:param start: boolean, if True, server will be start (server.serve_forever())
:param kwargs: other params for WSGIServer(**kwargs)
:return: server
"""
if log is None:
log = app.logger
if error_log is None:
error_log = app.logger
if monkey_patch:
from gevent import monkey
monkey.patch_all()
from gevent.wsgi import WSGIServer
http_server = WSGIServer((address, port), app, log=log, error_log=error_log,
**kwargs)
if start:
http_server.serve_forever()
return http_server
def gevent_main():
"""
Gevent coroutine WDGI standalone server
"""
from gevent.wsgi import WSGIServer
http_server = WSGIServer(("", PORT), app)
http_server.serve_forever()
def main(args):
from gevent.wsgi import WSGIServer
if args.debug:
app.run(debug=True, port=config.app.TESTING_FRONTEND_TCP_PORT)
else:
http_server = WSGIServer(("0.0.0.0", config.app.APP_TCP_PORT), app)
http_server.serve_forever()
return 0
def serve_forever():
try:
server = WSGIServer((LISTEN_IP, LISTEN_PORT), handle_request)
LOGGER.info('serving HTTP on port %s:%s...' % (LISTEN_IP, LISTEN_PORT))
except:
LOGGER.exception('failed to start HTTP server on port %s:%s' % (LISTEN_IP, LISTEN_PORT))
os._exit(1)
server.serve_forever()
def serve_forever():
try:
httpd = WSGIServer(('127.0.0.1', 8318), handle_request)
LOGGER.info('serving HTTP on port 8318...')
except:
LOGGER.exception('failed to start HTTP server on port 8318')
sys.exit(1)
httpd.serve_forever()
def run(self):
#while True:
self.logger = logging.getLogger("sms_khomp_api")
self.logger.info("Creating sms_khomp_api")
#Run WSGIServer
http = WSGIServer(('', PORT), app.wsgi_app)
http.serve_forever()
self.logger.info("Done.")
def run_server():
options = get_options()
configure_app(flatdb_app, options)
from gevent.wsgi import WSGIServer
server = WSGIServer((options.host, options.port), flatdb_app)
server.serve_forever()
def start_vaurien_httpserver(port):
"""Start a vaurien httpserver, controlling a fake proxy"""
config = get_config()
config.registry['proxy'] = FakeProxy()
server = WSGIServer(('localhost', int(port)), config.make_wsgi_app(),
log=None)
server.serve_forever()
def start(server_port, app):
server = WSGIServer(("", server_port), app)
try:
server.serve_forever()
except KeyboardInterrupt:
pass
finally:
# Clean-up server (close socket, etc.)
server.close()
def main(): # pragma: no cover
logger.info('Starting Server')
http_server = WSGIServer(('0.0.0.0', 8080), app)
http_server.serve_forever()
def run():
http_server = WSGIServer(('', config.PORT), app)
http_server.serve_forever()
def run(app):
http_server = WSGIServer(('0.0.0.0', 5555), app)
http_server.serve_forever()
def runGevent(app, port=80):
http_server = WSGIServer(('', port), app)
http_server.serve_forever()
def run_server():
http_server = WSGIServer(('', 9453), app)
http_server.serve_forever()
def run_server():
http_server = WSGIServer(('localhost', 5000), DebuggedApplication(app))
http_server.serve_forever()
def main():
port = int(os.getenv('LISTEN_PORT', 8080))
server = WSGIServer(('0.0.0.0', port), proxy, log=None)
setServer(server)
server.serve_forever()
def main():
http_server = WSGIServer(('', 8080), app)
http_server.serve_forever()
def _GeventServer(host, port):
http_server = WSGIServer((host, port), app)
print("gevent server started at {host}:{port}".format(host=host,
port=port))
http_server.serve_forever()
if request.method == 'POST':
process_post_request(request, html_needed)
if html_needed:
return redirect("/")
return "OK\n"
if 'topic' in request.args:
return redirect("/%s" % request.args.get('topic'))
if topic is None:
topic = ":firstpage"
if topic.startswith(':shell-x/'):
return _proxy()
#return requests.get('http://127.0.0.1:3000'+topic[8:]).text
ip_address = get_request_ip(request)
if '+' in topic:
not_allowed = LIMITS.check_ip(ip_address)
if not_allowed:
return "429 %s\n" % not_allowed, 429
result, found = cheat_wrapper(topic, request_options=options, html=is_html_needed(user_agent))
log_query(ip_address, found, topic, user_agent)
return result
SRV = WSGIServer(("", 8002), app) # log=None)
SRV.serve_forever()
def run_server():
http_server = WSGIServer(('', settings.port), app)
http_server.serve_forever()
socket_timeout=30)
app = Flask(__name__)
@app.route("/thrift", methods=['GET'])
def sequence_service():
"""
测试返回的序列是否乱序
:return:
"""
res_body = None
try:
data = request.args.get('num', '')
req = sequence_thrift.SequenceRequest()
if data:
req.num = str(data)
res = client_pool_sequence_with_zookeeper.getnum(req)
print "Request:" + req.num + " " + "Response:" + res.num
res_body = {'req': req.num, 'res': res.num}
except Exception, ex:
print ex.message
finally:
pass
return jsonify(res_body)
if __name__ == "__main__":
http_server = WSGIServer(('127.0.0.1', 8000), app, log=None)
http_server.serve_forever()
def start_server():
http_server = WSGIServer(('', flask_port), flask_app)
http_server.serve_forever()
def web():
http_server = WSGIServer(('', PORT), app)
http_server.serve_forever()
def main():
# Parse command line arguments
parser = argparse.ArgumentParser(description='Run all modules defined for '
'this system')
parser.add_argument('--verbose', '-v', action='count', default=0)
parser.add_argument('--log', default=None)
args = parser.parse_args()
# Configure logging
logger = logging.getLogger("openag_brain")
logger.setLevel(logging.DEBUG)
formatter = logging.Formatter(
"%(levelname)s %(asctime)s (%(name)s): %(message)s")
stream_log_level = max(10, 30 - 10 * args.verbose)
stream_handler = logging.StreamHandler()
stream_handler.setFormatter(formatter)
stream_handler.setLevel(stream_log_level)
logger.addHandler(stream_handler)
if args.log:
file_handler = logging.FileHandler(args.log)
file_handler.setFormatter(formatter)
file_handler.setLevel(min(logging.INFO, stream_log_level))
logger.addHandler(file_handler)
# Connect to the databases
module_db = db_server[DbName.MODULE]
module_type_db = db_server[DbName.MODULE_TYPE]
module_connection_db = db_server[DbName.MODULE_CONNECTION]
env_data_db = db_server[DbName.ENVIRONMENTAL_DATA_POINT]
# Construct all of the modules
for mod_id in module_db:
if mod_id.startswith('_'):
continue
mod_info = ModuleModel.load(module_db, mod_id)
mod_type_info = ModuleTypeModel.load(module_type_db, mod_info.type)
package_path, class_name = mod_type_info._id.split(':')
py_mod = import_module(package_path)
mod_class = getattr(py_mod, class_name)
mod = mod_class(mod_id)
# Initialize all of the modules
for mod_id in module_db:
if mod_id.startswith('_'):
continue
mod_info = ModuleModel.load(module_db, mod_id)
mod = Module.get_by_id(mod_id)
params = mod_info.parameters
for arg_name in mod.init.__code__.co_varnames[1:mod.init.__code__.
co_argcount]:
annotation = mod.init.__annotations__.get(arg_name, '')
if isinstance(annotation, Parameter) and arg_name in params:
params[arg_name] = annotation.encode(params[arg_name])
mod.init(**mod_info.parameters)
# Hook up all of the connections
for mod_conn_id in module_connection_db:
if mod_conn_id.startswith('_'):
continue
mod_conn = ModuleConnectionModel.load(module_connection_db,
mod_conn_id)
output_module = Module.get_by_id(mod_conn.output_module)
input_module = Module.get_by_id(mod_conn.input_module)
output = getattr(output_module, mod_conn.output_name)
input = getattr(input_module, mod_conn.input_name)
output.output_to(input)
# Run all of the modules
threads = []
for mod_id in module_db:
if mod_id.startswith('_'):
continue
mod = Module.get_by_id(mod_id)
mod.start()
logger.info("Running {} modules".format(len(module_db)))
# Create and run a Flask app for calling endpoints
app = Flask(__name__)
# Set cross-origin headers
CORS(app)
app.debug = True
mod_id = uuid4().hex
while Module.get_by_id(mod_id):
mod_id = uuid4().hex
app.mod = Module(mod_id)
app.mod.start()
def find_recipe_start(env_data_db, env_id):
"""Given a pointer to the environmental data point db, return the
latest recipe start for a given environment.
returns a Dict or None.
"""
# Query latest view with key (requires this design doc to exist)
recipe_start_view = env_data_db.view(
'openag/latest',
key=[env_id, EnvironmentalVariable.RECIPE_START, 'desired'])
recipe_end_view = env_data_db.view(
'openag/latest',
key=[env_id, EnvironmentalVariable.RECIPE_END, 'desired'])
# Collect results of iterator (ViewResult has no next method).
recipe_starts = [recipe_start for recipe_start in recipe_start_view]
recipe_ends = [recipe_end for recipe_end in recipe_end_view]
# Narrow list of results down to one and unbox the value
recipe_start = recipe_starts[0].value if len(recipe_starts) else None
recipe_end = recipe_ends[0].value if len(recipe_ends) else None
# If we have a recipe_end, check that it is older than the latest
# recipe_start
if recipe_start and recipe_end and recipe_start[
"timestamp"] > recipe_end["timestamp"]:
return recipe_start
# If we don't have a recipe end, but do have a recipe_start, return it.
elif recipe_start:
return recipe_start
else:
return None
def find_env_recipe_handler_id(module_db, env_id):
"""Find ID of recipe handler that is running in current environment.
Returns ID or None.
"""
recipe_type = 'openag.brain.modules.recipe_handler:RecipeHandler'
module_view = module_db.view('openag/by_type')
recipe_handler_ids = [
module.id for module in module_view if module.key == recipe_type
]
return recipe_handler_ids[0] if len(recipe_handler_ids) > 0 else None
@app.route("/api/{v}/module/<mod_id>/<endpoint>".format(v=API_VER),
methods=['POST'])
def serve_endpoint(mod_id, endpoint):
return getattr(app.mod.ask(mod_id), endpoint)(**request.json)
@app.route("/api/{v}/environment/<env_id>".format(v=API_VER),
methods=['GET'])
def serve_environment(env_id):
recipe_handler_id = find_env_recipe_handler_id(module_db, env_id)
recipe_start = find_recipe_start(env_data_db, env_id)
recipe_id = recipe_start["value"] if recipe_start else None
recipe_start_timestamp = recipe_start[
"timestamp"] if recipe_start else None
return jsonify(env_id=env_id,
recipe_id=recipe_id,
recipe_start_timestamp=recipe_start_timestamp,
recipe_handler_id=recipe_handler_id)
http_server = WSGIServer(('', 5000), app)
logger.info("Listening for requests on http://localhost:5000/")
http_server.serve_forever()
def run_app(app, port=5000):
http_server = WSGIServer(('', port), app)
webbrowser.open_new('http://localhost:' + str(port))
http_server.serve_forever()
def main():
port = 8080
print("start server on port:%s" % (port, ))
http_server = WSGIServer(('', port), app)
http_server.serve_forever()
# -*- coding: utf-8 -*-
from app import app
from gevent.wsgi import WSGIServer
https = WSGIServer(('0.0.0.0', 80), app)
https.serve_forever()
def run_server():
print('start server at: 127.0.0.1:%s' % port)
http_server = WSGIServer(('', port), wsgi)
http_server.serve_forever()
def runserver(port=18340):
flask_instance.config['PORT'] = port
# flask_instance.run('0.0.0.0', port, debug=False, threaded=True)
http_server = WSGIServer(('0.0.0.0', port), flask_instance)
http_server.serve_forever()
def serve_gevent(app):
from gevent.wsgi import WSGIServer
http_server = WSGIServer((host, port), app)
http_server.serve_forever()
def run():
from gevent.wsgi import WSGIServer
gws = WSGIServer((host, port), app)
gws.base_env['wsgi.multithread'] = threaded
gws.base_env['wsgi.multiprocess'] = processes > 0
gws.serve_forever()
def gevent_server(app, port):
import gevent.monkey
from gevent.wsgi import WSGIServer
gevent.monkey.patch_all()
http_server = WSGIServer(('', port), app)
http_server.serve_forever()
def run_server():
http_server = WSGIServer(('0.0.0.0', PORT), app)
http_server.serve_forever()
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# Copyright (c) 2018, Måns Gezelius
# All rights reserved.
#
# This script creates and runs the server module.
from gevent.wsgi import WSGIServer
from server import *
if __name__ == '__main__':
port = 34447
server = WSGIServer(("", port), app, handler_class=WebSocketHandler)
print "* Running on http://0.0.0.0:{}/".format(port)
server.serve_forever()
#app.run(debug=True, host='0.0.0.0', port=port, threaded=True)
class RestApiEndpoint(object):
"""
Simple API endpoint that offers a REST
interface. This interface will be used by the
default command line client.
"""
def __init__(self, listenip, port, DCnetwork=None):
self.ip = listenip
self.port = port
# connect this DC network to the rest api endpoint (needed for the networking and monitoring api)
self.connectDCNetwork(DCnetwork)
# setup Flask
# find directory of dashboard files
dashboard_file = pkg_resources.resource_filename(
'emuvim.dashboard', "index.html")
dashboard_dir = path.dirname(dashboard_file)
logging.info("Started emu dashboard: {0}".format(dashboard_dir))
self.app = Flask(__name__,
static_folder=dashboard_dir,
static_url_path='/dashboard')
self.api = Api(self.app)
# setup endpoints
# compute related actions (start/stop VNFs, get info)
self.api.add_resource(Compute,
"/restapi/compute/<dc_label>/<compute_name>")
self.api.add_resource(ComputeList, "/restapi/compute",
"/restapi/compute/<dc_label>")
self.api.add_resource(
ComputeResources,
"/restapi/compute/resources/<dc_label>/<compute_name>")
self.api.add_resource(DatacenterStatus,
"/restapi/datacenter/<dc_label>")
self.api.add_resource(DatacenterList, "/restapi/datacenter")
# network related actions (setup chaining between VNFs)
self.api.add_resource(NetworkAction, "/restapi/network")
self.api.add_resource(DrawD3jsgraph, "/restapi/network/d3jsgraph")
# monitoring related actions
# export a network interface traffic rate counter
self.api.add_resource(MonitorInterfaceAction,
"/restapi/monitor/interface")
# export flow traffic counter, of a manually pre-installed flow entry, specified by its cookie
self.api.add_resource(MonitorFlowAction, "/restapi/monitor/flow")
# install monitoring of a specific flow on a pre-existing link in the service.
# the traffic counters of the newly installed monitor flow are exported
self.api.add_resource(MonitorLinkAction, "/restapi/monitor/link")
# install skewness monitor of resource usage disribution
# the skewness metric is exported
self.api.add_resource(MonitorSkewAction, "/restapi/monitor/skewness")
# start a terminal window for the specified vnfs
self.api.add_resource(MonitorTerminal, "/restapi/monitor/term")
logging.debug("Created API endpoint %s(%s:%d)" %
(self.__class__.__name__, self.ip, self.port))
def connectDatacenter(self, dc):
compute.dcs[dc.label] = dc
logging.info("Connected DC(%s) to API endpoint %s(%s:%d)" %
(dc.label, self.__class__.__name__, self.ip, self.port))
def connectDCNetwork(self, DCnetwork):
network.net = DCnetwork
monitor.net = DCnetwork
logging.info("Connected DCNetwork to API endpoint %s(%s:%d)" %
(self.__class__.__name__, self.ip, self.port))
def start(self):
self.thread = threading.Thread(target=self._start_flask, args=())
self.thread.daemon = True
self.thread.start()
logging.info("Started API endpoint @ http://%s:%d" %
(self.ip, self.port))
def stop(self):
if self.http_server:
self.http_server.close()
def _start_flask(self):
#self.app.run(self.ip, self.port, debug=False, use_reloader=False)
#this should be a more production-fit http-server
#self.app.logger.setLevel(logging.ERROR)
self.http_server = WSGIServer(
(self.ip, self.port),
self.app,
log=open(
"/dev/null", "w"
) # This disables HTTP request logs to not mess up the CLI when e.g. the auto-updated dashboard is used
)
self.http_server.serve_forever()
"""Start server for production purpose"""
# -*- coding: utf-8 -*-
import os
from app import app
from gevent.wsgi import WSGIServer
from gevent import monkey
if __name__ == '__main__':
monkey.patch_all()
HOST = os.environ.get('HOST', 'localhost')
PORT = int(os.environ.get('PORT', 5000))
HTTP_SERVER = WSGIServer((HOST, PORT), app)
HTTP_SERVER.serve_forever()
def run_server():
http_server = WSGIServer(('', int(os.environ.get('PORT', 3000))),
DebuggedApplication(app))
http_server.serve_forever()
@requires_auth
def train():
data_string = request.get_data(as_text=True)
current_app.data_router.start_train_process(data_string)
return jsonify(info="training started. Current pids: {}".format(
current_app.data_router.train_procs))
logging.basicConfig(filename=config['log_file'], level=config['log_level'])
logging.captureWarnings(True)
logging.info(config.view())
logging.debug("Creating a new data router")
rasa_nlu_app.data_router = DataRouter(config)
return rasa_nlu_app
if __name__ == '__main__':
# Running as standalone python application
arg_parser = create_arg_parser()
cmdline_args = {
key: val
for key, val in vars(arg_parser.parse_args()).items()
if val is not None
}
rasa_nlu_config = RasaNLUConfig(cmdline_args.get("config"), os.environ,
cmdline_args)
app = WSGIServer(('0.0.0.0', rasa_nlu_config['port']),
create_app(rasa_nlu_config))
logging.info('Started http server on port %s' % rasa_nlu_config['port'])
app.serve_forever()
def main():
port = int(os.getenv('FLASK_PROXY_PORT', 8080))
server = WSGIServer(('', port), proxy, log=None)
server.serve_forever()
