def runserver():
"""Lance un serveur wsgi de test, puis lui attribue l'application a
lancer avec eventuellement le chainage de middleware
"""
from pyson.middleware.error import HandleError
from pyson.middleware.log import Log
from pyson.middleware.session import Session #se wrapp automatiquement avec cookie
from pyson.middleware.force_auth import Force_auth
from pyson.middleware.http_basic import Http_basic
from pyson.middleware.formdata import Formdata
from pyson.middleware.restriction import Middle as Restriction
if os.environ.get("REQUEST_METHOD", ""):
from wsgiref.handlers import BaseCGIHandler
BaseCGIHandler(sys.stdin, sys.stdout, sys.stderr,
os.environ).run(urls.urls)
print "------------- Attention ---------------"
else:
import wsgiref
from wsgiref.simple_server import WSGIServer, WSGIRequestHandler
httpd = WSGIServer(('', int(context.conf["port"])), WSGIRequestHandler)
wrapper = Session(Formdata((Restriction(urls.urls))))
httpd.set_app(wrapper)
print "Serving HTTP on %s port %s ..." % httpd.socket.getsockname()
httpd.serve_forever()
def serve(site_factory, port=0, use_reloader=False, dry=False):
"""Create a new WSGI server listening on `host` and `port` for `app`"""
server = WSGIServer(('', port), WSGIRequestHandler)
server.set_app(site_factory.wsgi())
LOGGER.info('Serving on port {0}'.format(port))
if not dry: #pragma nocover
server.serve_forever()
def run_wsgi(port=8123):
server = WSGIServer(('', port), WSGIRequestHandler)
app = create_publisher()
server.set_app(app)
print 'serving on %s:%d' % (interface, port,)
server.serve_forever()
def start_wsgi_server():
from rdb.RobotDebuger import DebugSetting
app_settings = DebugSetting()
work_root = os.getcwd()
config_path = os.path.abspath(config_file)
if os.path.isfile(config_path):
app_settings.load_from_file(config_path)
init_sys_logging(app_settings)
logger = logging.getLogger("rdb.proxy")
logger.info("Loading RDB proxy at %s" % work_root)
try:
SERVER_CONTEXT = ApplicationContext(work_root, app_settings)
globals()['SERVER_CONTEXT'] = SERVER_CONTEXT
from wsgiref.simple_server import WSGIServer
server_address = (app_settings.WEB_BIND, int(app_settings.WEB_PORT))
server = WSGIServer(server_address, RDBProxyWSGIHandler)
server.set_app(wsgi_global_app)
SERVER_CONTEXT.server = server
logger.info("Serving HTTP on %s:%s..." %(app_settings.WEB_BIND,
app_settings.WEB_PORT))
server.serve_forever()
except BaseException, e:
logger.exception(e)
def runserver():
"""Lance un serveur wsgi de test, puis lui attribue l'application a
lancer avec eventuellement le chainage de middleware
"""
from pyson.middleware.error import HandleError
from pyson.middleware.log import Log
from pyson.middleware.session import Session #se wrapp automatiquement avec cookie
from pyson.middleware.force_auth import Force_auth
from pyson.middleware.http_basic import Http_basic
from pyson.middleware.formdata import Formdata
from pyson.middleware.restriction import Middle as Restriction
if os.environ.get("REQUEST_METHOD", ""):
from wsgiref.handlers import BaseCGIHandler
BaseCGIHandler(sys.stdin, sys.stdout, sys.stderr, os.environ).run(urls.urls)
print "------------- Attention ---------------"
else:
import wsgiref
from wsgiref.simple_server import WSGIServer, WSGIRequestHandler
httpd = WSGIServer(('', int(context.conf["port"])), WSGIRequestHandler)
wrapper = Session(Formdata((Restriction(urls.urls))))
httpd.set_app(wrapper)
print "Serving HTTP on %s port %s ..." % httpd.socket.getsockname()
httpd.serve_forever()
def run(create_publisher, host='', port=80, handler_class=RequestHandler):
"""Runs a Quixote application using the simple server from wsgiref."""
publisher = create_publisher()
app = QWIP(publisher)
server = WSGIServer((host, port), handler_class)
server.set_app(app)
try:
server.serve_forever()
finally:
server.server_close()
def run():
import urls
if os.environ.get("REQUEST_METHOD", ""):
from wsgiref.handlers import BaseCGIHandler
BaseCGIHandler(sys.stdin, sys.stdout, sys.stderr, os.environ).run(urls.urls)
else:
from wsgiref.simple_server import WSGIServer, WSGIRequestHandler
httpd = WSGIServer(('', 8000), WSGIRequestHandler)
httpd.set_app(urls.urls)
print "Serving HTTP os %s port %s ..." % httpd.socket.getsockname()
httpd.serve_forever()
def run():
import urls
if os.environ.get('REQUEST_METHOD', ''):
from wsgiref.handlers import BaseCGIHandler
BaseCGIHandler(
sys.stdin, sys.stdout, sys.stderr, os.environ).run(urls.urls)
else:
from wsgiref.simple_server import WSGIServer, WSGIRequestHandler
httpd = WSGIServer(('', 8080), WSGIRequestHandler)
httpd.set_app(urls.urls)
print "Server HTTP on %s port %s..." % httpd.socket.getsockname()
httpd.serve_forever()
def run():
import urls
if os.environ.get("REQUEST_METHOD", ""):
from wsgiref.handlers import BaseCGIHandler
BaseCGIHandler(sys.stdin, sys.stdout, sys.stderr, os.environ) \
.run(urls.load('urls.map'))
else:
os.environ = {}
from wsgiref.simple_server import WSGIServer, WSGIRequestHandler
httpd = WSGIServer(('', 8080), WSGIRequestHandler)
httpd.set_app(urls.load('urls.map'))
print "Serving HTTP on %s port %s ..." % httpd.socket.getsockname()
httpd.serve_forever()
def run():
import urls
if os.environ.get('REQUEST_METHOD', ''):
from wsgiref.handlers import BaseCGIHandler
BaseCGIHandler(sys.stdin, sys.stdout, sys.stderr, os.environ).run(urls.urls)
else:
from wsgiref.simple_server import WSGIServer, WSGIRequestHandler
httpd = WSGIServer(('', 8080), WSGIRequestHandler)
httpd.set_app(urls.urls)
host, port = httpd.socket.getsockname()[:2]
print 'Serving HTTP on {0} port {1}...'.format(host, port)
httpd.serve_forever()
class HealthCheck:
def __init__(self, port):
self.server = WSGIServer(('0.0.0.0', port),
NoLoggingWSGIRequestHandler)
api = falcon.App()
api.add_route('/health', self)
self.server.set_app(api)
def on_get(self, _, response):
response.media = {'status': 'available'}
def start(self):
self.server.serve_forever()
def run():
import urls
if os.environ.get("REQUEST_METHOD", ""):
from wsgiref.handlers import BaseCGIHandler
f = file("log", "a")
BaseCGIHandler(sys.stdin, sys.stdout, f, os.environ).run(urls.urls)
f.close()
else:
from wsgiref.simple_server import WSGIServer, WSGIRequestHandler
httpd = WSGIServer(('', 8080), WSGIRequestHandler)
httpd.set_app(urls.urls)
print "Serving HTTP on %s port %s ..." % httpd.socket.getsockname()
httpd.serve_forever()
def run():
import urls
if os.environ.get('REQUEST_METHOD', ''):
from wsgiref.handlers import BaseCGIHandler
BaseCGIHandler(sys.stdin, sys.stdout, sys.stderr,
os.environ).run(urls.urls)
else:
from wsgiref.simple_server import WSGIServer, WSGIRequestHandler
httpd = WSGIServer(('', 8080), WSGIRequestHandler)
httpd.set_app(urls.urls)
host, port = httpd.socket.getsockname()[:2]
print 'Serving HTTP on {0} port {1}...'.format(host, port)
httpd.serve_forever()
def serve(handler, host='localhost', port=8080, debug=True):
"""
Starts a developent server on the local machine. By default, the
server runs on port 8080 on localhost. You can pass in a different
hostname and/or IP using the keyword arguments.
"""
if debug:
handler = DebugMiddleware.wrap(handler)
httpd = WSGIServer((host, port), WSGIRequestHandler)
httpd.set_app(WSGIHandler(handler))
print("Development server is running at http://%s:%s/" % (host, port))
httpd.serve_forever()
def run(selector):
"""Run the server provided by selector"""
print selector
exec "from " + selector + " import urls, port"
if os.environ.get("REQUEST_METHOD", ""):
from wsgiref.handlers import BaseCGIHandler
BaseCGIHandler(sys.stdin, sys.stdout, sys.stderr, os.environ) \
.run(urls)
else:
from wsgiref.simple_server import WSGIServer, WSGIRequestHandler
# with the code like this we are binding to no particular interface, matter?
httpd = WSGIServer(('', port), WSGIRequestHandler)
httpd.set_app(urls)
print "Serving HTTP on %s port %s ..." % httpd.socket.getsockname()
httpd.serve_forever()
def start_simple(filename, hostname, port):
"""
Start a wsgiref.simple_server to run our app.
Provides the simplest base for testing, debugging
and development.
XXX no longer used
"""
os.environ = {}
from wsgiref.simple_server import WSGIServer, WSGIRequestHandler
hostname = config["server_host"]["host"]
port = int(config["server_host"]["port"])
httpd = WSGIServer((hostname, port), WSGIRequestHandler)
httpd.set_app(load_app())
print >>sys.stderr, "Serving HTTP on %s port %s ..." % httpd.socket.getsockname()
httpd.serve_forever()
class GaeTestServer(object):
def __init__(self):
self.sdk_path = resolve_sdk_path()
print 'python sdk found', self.sdk_path
sys.path.insert(0, self.sdk_path)
import dev_appserver
dev_appserver.fix_sys_path()
sys.path.insert(0, 'src')
self.testbed = None
self.httpd = None
def boot_gae(self):
from google.appengine.api import memcache
from google.appengine.ext import ndb
from google.appengine.ext import testbed
from google.appengine.datastore import datastore_stub_util
self.testbed = testbed.Testbed()
self.testbed.activate()
self.policy = datastore_stub_util.PseudoRandomHRConsistencyPolicy(probability=0)
self.testbed.init_datastore_v3_stub(consistency_policy=self.policy)
self.testbed.init_memcache_stub()
def boot_web(self, port, app):
self.port = port
self.httpd = WSGIServer(('localhost', port), WSGIRequestHandler)
self.httpd.set_app(app)
def server_forever_background(self):
self.thread = threading.Thread(target=self.httpd.serve_forever)
self.thread.start()
def server_forever(self):
self.httpd.serve_forever()
def shutdown(self):
if self.testbed:
self.testbed.deactivate()
if self.httpd:
self.httpd.shutdown()
self.httpd = None
def run():
""" run server """
from users import urls
if os.environ.get("REQUEST_METHOD", ""):
from wsgiref.handlers import BaseCGIHandler
BaseCGIHandler(sys.stdin, sys.stdout, sys.stderr,
os.environ).run(urls.urls)
else:
from wsgiref.simple_server import WSGIServer, WSGIRequestHandler
from beaker.middleware import SessionMiddleware
session_opts = {
'session.type': 'file',
'session.cookie_expires': True,
'session.data_dir': 'var',
}
app = SessionMiddleware(urls.urls, session_opts)
httpd = WSGIServer(('', 8080), WSGIRequestHandler)
httpd.set_app(app)
print "Serving HTTP on %s port %s ..." % httpd.socket.getsockname()
httpd.serve_forever()
class _HTTPServer(bottle.ServerAdapter):
"""
Reimplement bottle's WSGIRefServer. Override the request handler class and
add a stop() method for cleanly shutting down the server.
"""
srv = None
app = None
def run(self, handler):
# Handle the TIME_WAIT state for quick server restarts
WSGIServer.allow_reuse_address = 1
# Create the server and start it
self.srv = WSGIServer((self.host, self.port), _HTTPRequestHandler)
self.srv.set_app(self.app)
try:
self.srv.serve_forever()
finally:
self.srv.server_close()
def stop(self):
if self.srv:
self.srv.shutdown()
ret = tools.sparql_post(env)
elif path[0].lower() == 'submit':
ret = tools.submit(env)
elif env['REQUEST_METHOD'] == 'PUT':
if path[0].lower() == 'submit':
ret = tools.submit(env)
elif env['REQUEST_METHOD'] == 'DELETE':
# Not supported until authentication gets added TODO
pass
else:
# Unsupported as yet
pass
status, headers, content = ret
start_response(status, headers)
return content
if __name__ == '__main__':
if 'REQUEST_METHOD' in os.environ:
from wsgiref.handlers import BaseCGIHandler
BaseCGIHandler(sys.stdin, sys.stdout, sys.stderr, os.environ).run(run)
else:
from wsgiref.simple_server import WSGIServer, WSGIRequestHandler
httpd = WSGIServer(('', config.port), WSGIRequestHandler)
httpd.set_app(run)
print "Serving HTTP on %s port %s ..." % httpd.socket.getsockname()
httpd.serve_forever()
def serve(handler, host='localhost', port=8080):
httpd = WSGIServer((host, port), WSGIRequestHandler)
httpd.set_app(WSGIHandler(handler))
print "Server is running at http://%s:%s/" % (host, port)
httpd.serve_forever()
app = dash.Dash()
auth = dash_auth.BasicAuth(app, USERNAME_PASSWORD_PAIRS)
server = app.server
cov_data = pd.read_csv("data.csv")
print(cov_data)
fig = px.scatter_mapbox(cov_data, lat="Lat", lon="Long_", hover_name="Country_Region", hover_data=["Confirmed"],
color_discrete_sequence=["fuchsia"], zoom=3, height=300)
fig.update_layout(
mapbox_style="white-bg",
mapbox_layers=[
{
"below": 'traces',
"sourcetype": "raster",
"source": [
"https://basemap.nationalmap.gov/arcgis/rest/services/USGSImageryOnly/MapServer/tile/{z}/{y}/{x}"
],
}
],
)
fig.update_layout(height=1400, margin={"r": 0, "t": 0, "l": 0, "b": 0})
fig.show()
if __name__ == '__main__':
http_server = WSGIServer(('', 5000), app)
http_server.serve_forever()
@register('/update', method=['POST'])
def update_book(self, request):
return 'update book'
@register('/query', method=['GET'])
def query_book(self, request):
return 'query books'
@tramp.before_request
def judge_user(request):
return Response('Find Page')
@tramp.before_request
def judge_hello(request):
response = Response('Sorry')
response.set_status_code(404)
return response
if __name__ == '__main__':
host = '127.0.0.1'
port = 9000
server = WSGIServer((host, port), WSGIRequestHandler)
server.set_app(tramp)
print('Server Listen at: {}:{}'.format(host, port))
server.serve_forever()
def run(app):
from wsgiref.simple_server import WSGIServer, WSGIRequestHandler
httpd = WSGIServer(('127.0.0.1', 8080), WSGIRequestHandler)
httpd.set_app(app)
print "Serving HTTP on %s port %s ..." % httpd.socket.getsockname()
httpd.serve_forever()
def server(cls):
server = WSGIServer(('localhost', 8999), WsgiHandler)
server.set_app(cls.wsgi_app)
server.serve_forever()
