def start_server(options): """ Start CherryPy server """ global SERVER print 'starting server with options %s' % options if options['daemonize'] == '1' and options['server_user'] and options['server_group']: #ensure the that the daemon runs as specified user change_uid_gid(options['server_user'], options['server_group']) #from cherrypy.wsgiserver import CherryPyWSGIServer as Server from wsgiserver import CherryPyWSGIServer as Server from django.core.handlers.wsgi import WSGIHandler threads = int(options['threads']) SERVER = Server( (options['host'], int(options['port'])), WSGIHandler(), numthreads=threads, max=threads, server_name=options['server_name'], verbose=int(options['verbose']), shutdown_timeout = int(options['shutdown_timeout']), request_queue_size = int(options['request_queue_size']) ) #if options['ssl_certificate'] and options['ssl_private_key']: #server.ssl_certificate = options['ssl_certificate'] #server.ssl_private_key = options['ssl_private_key'] try: SERVER.start() #from django.utils import autoreload #autoreload.main(server.start) except KeyboardInterrupt: SERVER.stop()
def run(self, handler): from wsgiserver import CherryPyWSGIServer server = CherryPyWSGIServer((self.host, self.port), handler, numthreads=self.numthreads) server.start()
def run(self, handler): from wsgiserver import CherryPyWSGIServer if self.cert and self.key: CherryPyWSGIServer.ssl_certificate = self.cert CherryPyWSGIServer.ssl_private_key = self.key server = CherryPyWSGIServer((self.host, self.port), handler, numthreads=self.connection) server.start()
def run_cherrypy_server(self, host='localhost', port=9000): from wsgiserver import CherryPyWSGIServer #debug mode can serve static file and check trace app = self if self.debug: app = FileServerMiddleware(app, self.config.get('static', '')) app = ExceptionMiddleware(app) server = CherryPyWSGIServer( (host, port), app)#, server_name='www.cherrypy.example') server.start()
def start_server(options): """ Start CherryPy server """ global SERVER try: import newrelic.agent PATH_TO_NEWRELIC = os.path.join(os.getcwd(), 'newrelic.ini') newrelic.agent.initialize(PATH_TO_NEWRELIC) except: print "To run cherrypy instances with newrelic," print "(1) pip install newrelic" print "(2) newrelic-admin generate-config [YOUR_API_KEY] newrelic.ini" print "continuing runcpserver without newrelic..." pass print 'starting server with options %s' % options if options['daemonize'] == '1' and options['server_user'] and options['server_group']: #ensure the that the daemon runs as specified user change_uid_gid(options['server_user'], options['server_group']) #from cherrypy.wsgiserver import CherryPyWSGIServer as Server from wsgiserver import CherryPyWSGIServer as Server from django.core.handlers.wsgi import WSGIHandler threads = int(options['threads']) SERVER = Server( (options['host'], int(options['port'])), WSGIHandler(), numthreads = threads, max = threads, server_name = options['server_name'], verbose = int(options['verbose']), shutdown_timeout = int(options['shutdown_timeout']), request_queue_size = int(options['request_queue_size']) ) #if options['ssl_certificate'] and options['ssl_private_key']: #server.ssl_certificate = options['ssl_certificate'] #server.ssl_private_key = options['ssl_private_key'] try: SERVER.start() #from django.utils import autoreload #autoreload.main(server.start) except KeyboardInterrupt: SERVER.stop()
def WSGIServer(server_address, wsgi_app): """Creates CherryPy WSGI server listening at `server_address` to serve `wsgi_app`. This function can be overwritten to customize the webserver or use a different webserver. """ from wsgiserver import CherryPyWSGIServer return CherryPyWSGIServer(server_address, wsgi_app, server_name="localhost")
def start_server(options): """ Start CherryPy server """ global SERVER try: import newrelic.agent PATH_TO_NEWRELIC = os.path.join(os.getcwd(), 'newrelic.ini') newrelic.agent.initialize(PATH_TO_NEWRELIC) except: print "To run cherrypy instances with newrelic," print "(1) pip install newrelic" print "(2) newrelic-admin generate-config [YOUR_API_KEY] newrelic.ini" print "continuing runcpserver without newrelic..." pass print 'starting server with options %s' % options if options['daemonize'] == '1' and options['server_user'] and options[ 'server_group']: #ensure the that the daemon runs as specified user change_uid_gid(options['server_user'], options['server_group']) #from cherrypy.wsgiserver import CherryPyWSGIServer as Server from wsgiserver import CherryPyWSGIServer as Server from django.core.handlers.wsgi import WSGIHandler threads = int(options['threads']) SERVER = Server((options['host'], int(options['port'])), WSGIHandler(), numthreads=threads, max=threads, server_name=options['server_name'], verbose=int(options['verbose']), shutdown_timeout=int(options['shutdown_timeout']), request_queue_size=int(options['request_queue_size'])) #if options['ssl_certificate'] and options['ssl_private_key']: #server.ssl_certificate = options['ssl_certificate'] #server.ssl_private_key = options['ssl_private_key'] try: SERVER.start() #from django.utils import autoreload #autoreload.main(server.start) except KeyboardInterrupt: SERVER.stop()
def run(self): """Launch CherryPy Django web server.""" options = CPSERVER_OPTIONS server = CherryPyWSGIServer( (options['host'], int(options['port'])), WSGIPathInfoDispatcher({ '/': WSGIHandler(), urlparse(settings.MEDIA_URL).path: MediaHandler( settings.MEDIA_ROOT), settings.ADMIN_MEDIA_PREFIX: MediaHandler( os.path.join(admin.__path__[0], 'media')) }), int(options['threads']), options['host'], request_queue_size=int(options['request_queue_size'])) try: server.start() except KeyboardInterrupt: server.stop()
def start(self): """ Starts the WSGI server. """ server = CherryPyWSGIServer((self.host, self.port), self.dispatcher) server.environ.update(self.wsgi_env) if self.daemonize: daemonize() if self.pidfile: print "writing pid (%s)" % self.pidfile writepid(self.pidfile) # setup the process environment for var, value in self.env.items(): os.environ[var] = value try: server.start() except KeyboardInterrupt: # likely not a daemon so make sure to shutdown properly. server.stop()
def runsimple(func, server_address=("0.0.0.0", 8080)): """ Runs [CherryPy][cp] WSGI server hosting WSGI app `func`. The directory `static/` is hosted statically. [cp]: http://www.cherrypy.org """ func = StaticMiddleware(func) func = LogMiddleware(func) from wsgiserver import CherryPyWSGIServer server = CherryPyWSGIServer(server_address, func, server_name="localhost") print "http://%s:%d/" % server_address try: server.start() except KeyboardInterrupt: server.stop()
def runsimple(func, server_address=("0.0.0.0", 8080)): """ Runs [CherryPy][cp] WSGI server hosting WSGI app `func`. The directory `static/` is hosted statically. [cp]: http://www.cherrypy.org """ from wsgiserver import CherryPyWSGIServer from SimpleHTTPServer import SimpleHTTPRequestHandler from BaseHTTPServer import BaseHTTPRequestHandler class StaticApp(SimpleHTTPRequestHandler): """WSGI application for serving static files.""" def __init__(self, environ, start_response): self.headers = [] self.environ = environ self.start_response = start_response def send_response(self, status, msg=""): self.status = str(status) + " " + msg def send_header(self, name, value): self.headers.append((name, value)) def end_headers(self): pass def log_message(*a): pass def __iter__(self): environ = self.environ self.path = environ.get('PATH_INFO', '') self.client_address = environ.get('REMOTE_ADDR','-'), \ environ.get('REMOTE_PORT','-') self.command = environ.get('REQUEST_METHOD', '-') from cStringIO import StringIO self.wfile = StringIO() # for capturing error f = self.send_head() self.start_response(self.status, self.headers) if f: block_size = 16 * 1024 while True: buf = f.read(block_size) if not buf: break yield buf f.close() else: value = self.wfile.getvalue() yield value class WSGIWrapper(BaseHTTPRequestHandler): """WSGI wrapper for logging the status and serving static files.""" def __init__(self, app): self.app = app self.format = '%s - - [%s] "%s %s %s" - %s' def __call__(self, environ, start_response): def xstart_response(status, response_headers, *args): write = start_response(status, response_headers, *args) self.log(status, environ) return write path = environ.get('PATH_INFO', '') if path.startswith('/static/'): return StaticApp(environ, xstart_response) else: return self.app(environ, xstart_response) def log(self, status, environ): outfile = environ.get('wsgi.errors', web.debug) req = environ.get('PATH_INFO', '_') protocol = environ.get('ACTUAL_SERVER_PROTOCOL', '-') method = environ.get('REQUEST_METHOD', '-') host = "%s:%s" % (environ.get( 'REMOTE_ADDR', '-'), environ.get('REMOTE_PORT', '-')) #@@ It is really bad to extend from #@@ BaseHTTPRequestHandler just for this method time = self.log_date_time_string() print >> outfile, self.format % (host, time, protocol, method, req, status) func = WSGIWrapper(func) server = CherryPyWSGIServer(server_address, func, server_name="localhost") print "http://%s:%d/" % server_address try: server.start() except KeyboardInterrupt: server.stop()
def __init__(self, host, port): self.host = host self.port = port self.server = CherryPyWSGIServer \ ((self.host, self.port), self.service_request)
class WebServer(object): http_date = "%a, %d %b %Y %H:%M:%S %Z" http_date_gmt = "%a, %d %b %Y %H:%M:%S GMT" def __init__(self, host, port): self.host = host self.port = port self.server = CherryPyWSGIServer \ ((self.host, self.port), self.service_request) # XXX self.server.environ["wsgi.version"] = (1, 1) def start(self): self.server.start() def stop(self): self.server.stop() def service_request(self, env, response): pass def send_not_found(self, response, headers): message = "404 Not Found" headers.append(("Content-Length", str(len(message)))) headers.append(("Content-Type", "text/plain")) response(message, headers) return (message,) def send_message(self, response, headers, message): headers.append(("Content-Length", str(len(message)))) headers.append(("Content-Type", "text/plain")) response(message, headers) return (message,) def send_redirect(self, response, headers, url): headers.append(("Location", url)) headers.append(("Content-Length", "0")) response("303 See Other", headers) return () def send_not_modified(self, response, headers): headers.append(("Content-Length", "0")) response("304 Not Modified", headers) return () def print_url_vars(self, query, writer): writer.write("URL variables:\n\n") if query: vars = query.split(";") for var in sorted(vars): key, value = var.split("=") writer.write(" %-30s %s\n" % (key, value)) writer.write("\n") def print_environment(self, env, writer): writer.write("Environment:\n\n") for key in sorted(env): value = env[key] writer.write(" %-30s %s\n" % (key, value)) writer.write("\n")
#itemlist.extend(local_itemlist) itemlist.append(web.form.Button('Submit')) my_form = web.form.Form(*itemlist) urls = ('/', 'D4Web') render = web.template.render('templates/') app = web.application(urls, globals()) func = app.wsgifunc() server_address = validip('127.0.0.1',8080) func = StaticMiddleware(func) #func = LogMiddleware(func) server = CherryPyWSGIServer(server_address, func, server_name="localhost",numthreads=1) #print "http://%s:%d/" % server_address class D4Web: def GET(self): form = my_form() return render.D4Web( form ) form.validates() s = str(form.value) stderr_return(s) return s try: server.start() except (KeyboardInterrupt, SystemExit): server.stop() server = None
def run(self, handler): from wsgiserver import CherryPyWSGIServer server = CherryPyWSGIServer((self.host, self.port), handler) server.start()
def runsimple(func, server_address=("0.0.0.0", 8080)): """ Runs [CherryPy][cp] WSGI server hosting WSGI app `func`. The directory `static/` is hosted statically. [cp]: http://www.cherrypy.org """ from wsgiserver import CherryPyWSGIServer from SimpleHTTPServer import SimpleHTTPRequestHandler from BaseHTTPServer import BaseHTTPRequestHandler class StaticApp(SimpleHTTPRequestHandler): """WSGI application for serving static files.""" def __init__(self, environ, start_response): self.headers = [] self.environ = environ self.start_response = start_response def send_response(self, status, msg=""): self.status = str(status) + " " + msg def send_header(self, name, value): self.headers.append((name, value)) def end_headers(self): pass def log_message(*a): pass def __iter__(self): environ = self.environ self.path = environ.get('PATH_INFO', '') self.client_address = environ.get('REMOTE_ADDR','-'), \ environ.get('REMOTE_PORT','-') self.command = environ.get('REQUEST_METHOD', '-') from cStringIO import StringIO self.wfile = StringIO() # for capturing error f = self.send_head() self.start_response(self.status, self.headers) if f: block_size = 16 * 1024 while True: buf = f.read(block_size) if not buf: break yield buf f.close() else: value = self.wfile.getvalue() yield value class WSGIWrapper(BaseHTTPRequestHandler): """WSGI wrapper for logging the status and serving static files.""" def __init__(self, app): self.app = app self.format = '%s - - [%s] "%s %s %s" - %s' def __call__(self, environ, start_response): def xstart_response(status, response_headers, *args): write = start_response(status, response_headers, *args) self.log(status, environ) return write path = environ.get('PATH_INFO', '') if path.startswith('/static/'): return StaticApp(environ, xstart_response) else: return self.app(environ, xstart_response) def log(self, status, environ): outfile = environ.get('wsgi.errors', web.debug) req = environ.get('PATH_INFO', '_') protocol = environ.get('ACTUAL_SERVER_PROTOCOL', '-') method = environ.get('REQUEST_METHOD', '-') host = "%s:%s" % (environ.get('REMOTE_ADDR','-'), environ.get('REMOTE_PORT','-')) #@@ It is really bad to extend from #@@ BaseHTTPRequestHandler just for this method time = self.log_date_time_string() msg = self.format % (host, time, protocol, method, req, status) print >> outfile, utils.safestr(msg) func = WSGIWrapper(func) server = CherryPyWSGIServer(server_address, func, server_name="localhost") print "http://%s:%d/" % server_address try: server.start() except KeyboardInterrupt: server.stop()