def setUp(self):
self.port = 8000
self.url = 'localhost'
self.server = WSGIServer((self.url, self.port), WSGIRequestHandler)
self.server.set_app(timezones_app)
self.t = threading.Thread(target=self.server.serve_forever)
self.t.start()
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(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(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 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
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.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()
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()
def make_server(host, port, app):
server = WSGIServer((host, port), WSGIRequestHandler)
server.set_app(app)
return server
def _make_server(self):
from wsgiref.simple_server import WSGIServer, WSGIRequestHandler
server = WSGIServer((self._host, self._port), WSGIRequestHandler)
server.set_app(self.application)
return server
@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()
from os import environ
from wsgiref.simple_server import WSGIServer
from main import app
if __name__ == '__main__':
HOST = environ.get('SERVER_HOST', 'localhost')
app.secret_key = "SuPeR_SeCReT_KeY"
try:
PORT = int(environ.get('SERVER_PORT', '5555'))
except ValueError:
PORT = 5555
app.run(HOST, PORT, debug=True, threaded=True)
server = WSGIServer(("", 5000), app)
server.serve_forever()
usage = """
Usage: peak launch [options] NAME_OR_URL ...
Run NAME_OR_URL as a WSGI application in a local webserver on the address given
by the 'peak.tools.server.url' property. The object found at the specified
name or URL will be adapted to the 'running.IWSGIApplication' interface, and
then run in a local web server.
This command is similar to the 'peak serve' command, except that it also
attempts to open the application in a web browser window.
"""
cgiWrapper = WSGILauncher
def demo_service(environ, start_response):
stdout = StringIO()
print >> stdout, "Hello world!"
print >> stdout
h = environ.items()
h.sort()
for k, v in h:
print >> stdout, k, '=', ` v `
start_response("200 OK", [('Content-Type', 'text/plain')])
return [stdout.getvalue()]
protocols.adviseObject(demo_service, [running.IWSGIApplication])
if __name__ == '__main__':
WSGIServer(config.makeRoot(), cgiCommand=demo_service()).run()
def __init__(self, host, port, serviceName):
services = {serviceName: self.echo}
gw = WSGIGateway(services, logger=logging)
self.httpd = WSGIServer((host, port), ServerRequestLogger)
self.httpd.set_app(gw)
verbosity = LVL_VERBOSE
from sys import stdout, stderr
log.assign_logfile(stdout, verbosity, (PyLogger.WARNING, PyLogger.INFO))
log.assign_logfile(stderr, verbosity, (PyLogger.ERROR, ))
log.log([], LVL_ALWAYS, PyLogger.INFO, 'Starting the SRL-Stats server')
# Add all rules
execfile('rules.py')
usermatch = re.compile('^[0-9|A-Z|a-z]+$')
app = stats
app = ScheduledJob(app)
app = SessionHack(app)
app = SessionMiddleware(app, session_options)
if USE_OWN_HTTPD:
from wsgiref.simple_server import make_server, \
WSGIServer, WSGIRequestHandler
WSGIRequestHandler.log_message = lambda *x: None
httpd = make_server('',
8000,
app,
server_class=WSGIServer,
handler_class=WSGIRequestHandler)
httpd.serve_forever()
else:
from flup.server.fcgi import WSGIServer
WSGIServer(app).run()
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)
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()
def _gevent_serve(wsgi_app):
ServeCommand.out('Starting Gevent HTTP server on http://%s:%s' %
(host, port))
WSGIServer((host, port), wsgi_app).serve_forever()
