class FlupSCGIServer(object): """Adapter for a flup.server.scgi.WSGIServer.""" def __init__(self, *args, **kwargs): self.args = args self.kwargs = kwargs self.ready = False def start(self): """Start the SCGI server.""" # We have to instantiate the server class here because its __init__ # starts a threadpool. If we do it too early, daemonize won't work. from flup.server.scgi import WSGIServer self.scgiserver = WSGIServer(*self.args, **self.kwargs) # TODO: report this bug upstream to flup. # If we don't set _oldSIGs on Windows, we get: # File "C:\Python24\Lib\site-packages\flup\server\threadedserver.py", # line 108, in run # self._restoreSignalHandlers() # File "C:\Python24\Lib\site-packages\flup\server\threadedserver.py", # line 156, in _restoreSignalHandlers # for signum,handler in self._oldSIGs: # AttributeError: 'WSGIServer' object has no attribute '_oldSIGs' self.scgiserver._installSignalHandlers = lambda: None self.scgiserver._oldSIGs = [] self.ready = True self.scgiserver.run() def stop(self): """Stop the HTTP server.""" self.ready = False # Forcibly stop the scgi server main event loop. self.scgiserver._keepGoing = False # Force all worker threads to die off. self.scgiserver._threadPool.maxSpare = 0
def _runFlup(app, config, mode): """Run WsgiDAV using flup.server.fcgi, if Flup is installed.""" try: # http://trac.saddi.com/flup/wiki/FlupServers if mode == "flup-fcgi" or "runfcgi": from flup.server.fcgi import WSGIServer, __version__ as flupver elif mode == "flup-fcgi_fork": from flup.server.fcgi_fork import WSGIServer, __version__ as flupver else: raise ValueError if config["verbose"] >= 2: print "Running WsgiDAV/%s %s/%s..." % (__version__, WSGIServer.__module__, flupver) server = WSGIServer(app, bindAddress=(config["host"], config["port"]), # bindAddress=("127.0.0.1", 8001), # debug=True, ) server.run() except ImportError, e: if config["verbose"] >= 1: print "Could not import flup.server.fcgi", e return False
def main(): app = create_app() log_fmt = logging.Formatter("[%(asctime)s] %(module)s " "%(levelname)s %(message)s") suggestion_log_path = os.path.join(app.instance_path, 'database.log') suggestion_handler = logging.FileHandler(suggestion_log_path) suggestion_handler.setFormatter(log_fmt) database.log.addHandler(suggestion_handler) import sys if len(sys.argv) > 1: cmd = sys.argv[1] else: cmd = 'runserver' if cmd == 'runserver': app.run(debug=True) elif cmd == 'shell': from code import interact with app.test_request_context(): interact(local={'app': app}) elif cmd == 'fastcgi': from flup.server.fcgi import WSGIServer error_log_path = os.path.join(app.instance_path, 'error.log') error_handler = logging.FileHandler(error_log_path) error_handler.setFormatter(log_fmt) error_handler.setLevel(logging.ERROR) logging.getLogger().addHandler(error_handler) sock_path = os.path.join(app.instance_path, 'fcgi.sock') server = WSGIServer(app, bindAddress=sock_path, umask=0) server.run()
def _runFlup(app, config, mode): """Run WsgiDAV using flup.server.fcgi, if Flup is installed.""" try: # http://trac.saddi.com/flup/wiki/FlupServers if mode == "flup-fcgi" or "runfcgi": from flup.server.fcgi import WSGIServer, __version__ as flupver elif mode == "flup-fcgi_fork": from flup.server.fcgi_fork import WSGIServer, __version__ as flupver else: raise ValueError if config["verbose"] >= 2: print "Running WsgiDAV/%s %s/%s..." % ( __version__, WSGIServer.__module__, flupver) server = WSGIServer( app, bindAddress=(config["host"], config["port"]), # bindAddress=("127.0.0.1", 8001), # debug=True, ) server.run() except ImportError, e: if config["verbose"] >= 1: print "Could not import flup.server.fcgi", e return False
class FlupFCGIServer(object): """Adapter for a flup.server.fcgi.WSGIServer.""" def __init__(self, *args, **kwargs): from flup.server.fcgi import WSGIServer self.fcgiserver = WSGIServer(*args, **kwargs) # TODO: report this bug upstream to flup. # If we don't set _oldSIGs on Windows, we get: # File "C:\Python24\Lib\site-packages\flup\server\threadedserver.py", # line 108, in run # self._restoreSignalHandlers() # File "C:\Python24\Lib\site-packages\flup\server\threadedserver.py", # line 156, in _restoreSignalHandlers # for signum,handler in self._oldSIGs: # AttributeError: 'WSGIServer' object has no attribute '_oldSIGs' self.fcgiserver._oldSIGs = [] self.ready = False def start(self): """Start the FCGI server.""" self.ready = True self.fcgiserver.run() def stop(self): """Stop the HTTP server.""" self.ready = False # Forcibly stop the fcgi server main event loop. self.fcgiserver._keepGoing = False # Force all worker threads to die off. self.fcgiserver._threadPool.maxSpare = 0
def main(): app = create_app() log_fmt = logging.Formatter("[%(asctime)s] %(module)s " "%(levelname)s %(message)s") suggestion_log_path = os.path.join(app.instance_path, "database.log") suggestion_handler = logging.FileHandler(suggestion_log_path) suggestion_handler.setFormatter(log_fmt) database.log.addHandler(suggestion_handler) import sys if len(sys.argv) > 1: cmd = sys.argv[1] else: cmd = "runserver" if cmd == "runserver": app.run(debug=True) elif cmd == "shell": from code import interact with app.test_request_context(): interact(local={"app": app}) elif cmd == "fastcgi": from flup.server.fcgi import WSGIServer error_log_path = os.path.join(app.instance_path, "error.log") error_handler = logging.FileHandler(error_log_path) error_handler.setFormatter(log_fmt) error_handler.setLevel(logging.ERROR) logging.getLogger().addHandler(error_handler) sock_path = os.path.join(app.instance_path, "fcgi.sock") server = WSGIServer(app, bindAddress=sock_path, umask=0) server.run() elif cmd == "update_identities": import sync with app.test_request_context(): sync.update_identities() elif cmd == "new_people": with app.test_request_context(): database.add_people(line.strip() for line in sys.stdin) database.db.session.commit()
class FlupFCGIServer(object): """Adapter for a flup.server.fcgi.WSGIServer.""" def __init__(self, *args, **kwargs): if kwargs.get('bindAddress', None) is None: import socket if not hasattr(socket.socket, 'fromfd'): raise ValueError( 'Dynamic FCGI server not available on this platform. ' 'You must use a static or external one by providing a ' 'legal bindAddress.') self.args = args self.kwargs = kwargs self.ready = False def start(self): """Start the FCGI server.""" # We have to instantiate the server class here because its __init__ # starts a threadpool. If we do it too early, daemonize won't work. from flup.server.fcgi import WSGIServer self.fcgiserver = WSGIServer(*self.args, **self.kwargs) # TODO: report this bug upstream to flup. # If we don't set _oldSIGs on Windows, we get: # File "C:\Python24\Lib\site-packages\flup\server\threadedserver.py", # line 108, in run # self._restoreSignalHandlers() # File "C:\Python24\Lib\site-packages\flup\server\threadedserver.py", # line 156, in _restoreSignalHandlers # for signum,handler in self._oldSIGs: # AttributeError: 'WSGIServer' object has no attribute '_oldSIGs' self.fcgiserver._installSignalHandlers = lambda: None self.fcgiserver._oldSIGs = [] self.ready = True self.fcgiserver.run() def stop(self): """Stop the HTTP server.""" # Forcibly stop the fcgi server main event loop. self.fcgiserver._keepGoing = False # Force all worker threads to die off. self.fcgiserver._threadPool.maxSpare = self.fcgiserver._threadPool._idleCount self.ready = False
def main(): app = create_app() log_fmt = logging.Formatter("[%(asctime)s] %(module)s " "%(levelname)s %(message)s") suggestion_log_path = os.path.join(app.instance_path, 'database.log') suggestion_handler = logging.FileHandler(suggestion_log_path) suggestion_handler.setFormatter(log_fmt) database.log.addHandler(suggestion_handler) import sys if len(sys.argv) > 1: cmd = sys.argv[1] else: cmd = 'runserver' if cmd == 'runserver': app.run(debug=True) elif cmd == 'shell': from code import interact with app.test_request_context(): interact(local={'app': app}) elif cmd == 'fastcgi': from flup.server.fcgi import WSGIServer error_log_path = os.path.join(app.instance_path, 'error.log') error_handler = logging.FileHandler(error_log_path) error_handler.setFormatter(log_fmt) error_handler.setLevel(logging.ERROR) logging.getLogger().addHandler(error_handler) sock_path = os.path.join(app.instance_path, 'fcgi.sock') server = WSGIServer(app, bindAddress=sock_path, umask=0) server.run() elif cmd == 'update_identities': import sync with app.test_request_context(): sync.update_identities() elif cmd == 'new_people': with app.test_request_context(): database.add_people(line.strip() for line in sys.stdin) database.db.session.commit()
def _runFlup(app, config, mode): """Run WsgiDAV using flup.server.fcgi, if Flup is installed.""" # http://trac.saddi.com/flup/wiki/FlupServers if mode == "flup-fcgi": from flup.server.fcgi import WSGIServer, __version__ as flupver elif mode == "flup-fcgi-fork": from flup.server.fcgi_fork import WSGIServer, __version__ as flupver else: raise ValueError if config["verbose"] >= 2: print("Running WsgiDAV/%s %s/%s..." % (__version__, WSGIServer.__module__, flupver)) server = WSGIServer(app, bindAddress=(config["host"], config["port"]), # debug=True, ) try: server.run() except KeyboardInterrupt: if config["verbose"] >= 1: print("Caught Ctrl-C, shutting down...") return
stack = app._dispatcher stack = processStack(stack) # == FCGI (Flup-provided) # if method == FCGI: if not has(FLUP): raise ImportError("Flup is required to run FCGI") fcgi_address = address or config.get("address") fcgi_port = port or config.get("port") if fcgi_port and fcgi_address: server = FLUP_FCGIServer(stack, bindAddress=(fcgi_address, fcgi_port)) elif fcgi_address: server = FLUP_FCGIServer(stack, bindAddress=fcgi_address) else: server = FLUP_FCGIServer(stack) server.run() # # == SCGI (Flup-provided) # elif method == SCGI: if not has(FLUP): raise ImportError("Flup is required to run SCGI") fcgi_address = address or config.get("address") fcgi_port = port or config.get("port") if fcgi_port and fcgi_address: server = FLUP_SCGIServer(stack, bindAddress=(fcgi_address, fcgi_port)) elif fcgi_address: server = FLUP_SCGIServer(stack, bindAddress=fcgi_address) else: server = FLUP_SCGIServer(stack) server.run()
def run_fcgi(app, args): from flup.server.fcgi import WSGIServer sock_path = args.fastcgi_socket wsgi_server = WSGIServer(app, bindAddress=sock_path, umask=0) wsgi_server.run()
#!/usr/bin/env python import os from flup.server.fcgi import WSGIServer import server wsgi = WSGIServer(server.app, bindAddress="/var/www/run/starroamer.sock", umask=0002) print("running as process %s" % os.getpid()) while wsgi.run(): reload(server) wsgi.application = server.app print("application reloaded")
stack = processStack(stack) # == FCGI (Flup-provided) # if method == FCGI: if not has(FLUP): raise ImportError("Flup is required to run FCGI") fcgi_address = address or config.get("address") fcgi_port = port or config.get("port") if fcgi_port and fcgi_address: server = FLUP_FCGIServer(stack, bindAddress=(fcgi_address, fcgi_port)) elif fcgi_address: server = FLUP_FCGIServer(stack, bindAddress=fcgi_address) else: server = FLUP_FCGIServer(stack) server.run() # # == SCGI (Flup-provided) # elif method == SCGI: if not has(FLUP): raise ImportError("Flup is required to run SCGI") fcgi_address = address or config.get("address") fcgi_port = port or config.get("port") if fcgi_port and fcgi_address: server = FLUP_SCGIServer(stack, bindAddress=(fcgi_address, fcgi_port)) elif fcgi_address: server = FLUP_SCGIServer(stack, bindAddress=fcgi_address) else: server = FLUP_SCGIServer(stack)
from flup.server.fcgi import WSGIServer from weeklypedia.labs import wsgi_app wsgi_server = WSGIServer(wsgi_app) if __name__ == '__main__': wsgi_server.run()
#!/usr/bin/python """ FastCGI server using flup. Reloads on SIGHUP. """ import site, os site.addsitedir(os.path.dirname(__file__)) import restrack.server from flup.server.fcgi import WSGIServer import os, sys, logging, site lh = logging.StreamHandler(sys.stderr) lh.setFormatter(logging.Formatter(restrack.server.FORMAT)) logging.root.addHandler(lh) logging.root.setLevel(logging.DEBUG) f = open('/tmp/restracker.pid', 'w') f.write(str(os.getpid())) f.close() try: ws = WSGIServer(restrack.server.restracker_app, bindAddress='/tmp/restracker.sock') rerun = ws.run() finally: os.unlink('/tmp/restracker.pid') if rerun: os.spawnv(__file__, sys.argv)
except: yield json_helper.getError(500, 'Unable to decode message as JSON.'); myGetter = MetadataGetter(lang=req_params['lang']); if not myGetter.checkLang(): yield json_helper.getError(501, 'Error: Language not supported.'); if not myGetter.connect(): yield json_helper.getError(500, 'Error: Unable to connect to database servers.'); # Check that the given list of titles is actually a list. if not isinstance(req_titles, list): yield json_helper.getError(400, 'Error: Titles not given in a list.'); metadata = myGetter.getListData(titles=req_titles); myGetter.close(); yield json_helper.getSuccess(metadata); # Test code, uncomment and run from command line to verify functionality #if __name__ == "__main__": # myGetter = MetadataGetter(lang='en', verbose=True); # myGetter.connect(); # metadata = myGetter.getListData(titles=[u'Günter Kunert']); # myGetter.close(); # print metadata; # Also, comment out these if you run from command line wsgi = WSGIServer(app); wsgi.run();
from flup.server.fcgi import WSGIServer from weeklypedia.labs import wsgi_app wsgi_server = WSGIServer(wsgi_app) if __name__ == "__main__": wsgi_server.run()
def handle(self, app, sock): _production_logging(app) from flup.server.fcgi import WSGIServer server = WSGIServer(app, bindAddress=sock, umask=0, maxThreads=5) server.run()
def run_fcgi(config): from flup.server.fcgi import WSGIServer app = create_app(config) server = WSGIServer(app, bindAddress='/tmp/mdpress.sock') server.run()
def handle(self, app): _error_log(os.path.join(app.instance_path, 'error.log')) from flup.server.fcgi import WSGIServer sock_path = os.path.join(app.instance_path, 'fcgi.sock') server = WSGIServer(app, bindAddress=sock_path, umask=0) server.run()
def run( app=None, components=(), method=STANDALONE, name="retro", root = ".", resetlog=False, address="", port=None, prefix='', asynchronous=False, sessions=False, withReactor=None, processStack=lambda x:x, runCondition=lambda:True, onError=None ): """Runs this web application with the given method (easiest one is STANDALONE), with the given root (directory from where the web app-related resource will be resolved). This function is the 'main' for your web application, so this is basically the last call you should have in your web application main.""" if app == None: app = Application(prefix=prefix,components=components) else: for _ in components: app.register(_) # We set up the configuration if necessary config = app.config() if not config: config = Configuration(CONFIG) # Adjusts the working directory to basepath root = os.path.abspath(root) if os.path.isfile(root): root = os.path.dirname(root) # We set the application root to the given root, and do a chdir os.chdir(root) config.setdefault("root", root) config.setdefault("name", name) config.setdefault("logfile", name + ".log") if resetlog: os.path.unlink(config.logfile()) # We set the configuration app.config(config) # And start the application app.start() # NOTE: Maybe we should always print it #print app.config() # We start the WSGI stack stack = app._dispatcher stack = processStack(stack) # == FCGI (Flup-provided) # if method == FCGI: if not has(FLUP): raise ImportError("Flup is required to run FCGI") fcgi_address = address or config.get("address") fcgi_port = port or config.get("port") if fcgi_port and fcgi_address: server = FLUP_FCGIServer(stack, bindAddress=(fcgi_address, fcgi_port)) elif fcgi_address: server = FLUP_FCGIServer(stack, bindAddress=fcgi_address) else: server = FLUP_FCGIServer(stack) server.run() # # == SCGI (Flup-provided) # elif method == SCGI: if not has(FLUP): raise ImportError("Flup is required to run SCGI") fcgi_address = address or config.get("address") fcgi_port = port or config.get("port") if fcgi_port and fcgi_address: server = FLUP_SCGIServer(stack, bindAddress=(fcgi_address, fcgi_port)) elif fcgi_address: server = FLUP_SCGIServer(stack, bindAddress=fcgi_address) else: server = FLUP_SCGIServer(stack) server.run() # # == CGI # elif method == CGI: environ = {} ; environ.update(os.environ) # From <http://www.python.org/dev/peps/pep-0333/#the-server-gateway-side> environ['wsgi.input'] = sys.stdin environ['wsgi.errors'] = sys.stderr environ['wsgi.version'] = (1,0) environ['wsgi.multithread'] = False environ['wsgi.multiprocess'] = True environ['wsgi.run_once'] = True if environ.get('HTTPS','off') in ('on','1'): environ['wsgi.url_scheme'] = 'https' else: environ['wsgi.url_scheme'] = 'http' # FIXME: Don't know if it's the proper solution req_uri = environ["REQUEST_URI"] script_name = environ["SCRIPT_NAME"] if req_uri.startswith(script_name): environ["PATH_INFO"] = req_uri[len(script_name):] else: environ["PATH_INFO"] = "/" if sessions: environ["com.saddi.service.session"] = sessions def start_response( status, headers, executionInfo=None ): for key, value in headers: print ("%s: %s" % (key, value)) print () # FIXME: This is broken res = "".join(tuple(self.dispatcher(environ, start_response))) print (res) if sessions: sessions.close() # # == GEVENT, BJOERN, ROCKET & WSGI # elif method in (GEVENT, BJOERN, ROCKET, WSGI): host = config.get("host") port = config.get("port") try: import reporter as logging except: import logging def application(environ, startResponse): # Gevent needs a wrapper if "retro.app" not in environ: environ["retro.app"] = stack.app() return environ["retro.app"](environ, startResponse) def logged_application(environ, startResponse): logging.info("{0} {1}".format(environ["REQUEST_METHOD"], environ["PATH_INFO"])) if "retro.app" not in environ: environ["retro.app"] = stack.app() return environ["retro.app"](environ, startResponse) if method == "GEVENT": try: from gevent import wsgi except ImportError: raise ImportError("gevent is required to run `gevent` method") # NOTE: This starts using gevent's WSGI server (faster!) wsgi.WSGIServer((host,port), application, spawn=None).serve_forever() elif method == BJOERN: try: import bjoern except ImportError: raise ImportError("bjoern is required to run `bjoern` method") bjoern.run(logged_application, host, port) elif method == ROCKET: try: import rocket except ImportError: raise ImportError("rocket is required to run `rocket` method") rocket.Rocket((host, int(port)), "wsgi", {"wsgi_app":application}).start() elif method == WSGI: # When using standalone WSGI, we make sure to wrap RendezVous objects # that might be returned by the handlers, and make sure we wait for # them -- we could use a callback version instead for specific web # servers. def retro_rendezvous_wrapper( environ, start_response, request=None): results = stack(environ, start_response, request) for result in results: if isinstance(result, RendezVous): result.wait() continue yield result retro_rendezvous_wrapper.stack = stack return retro_rendezvous_wrapper # == STANDALONE (WSGIREF) # # elif method == STANDALONE_WSGIREF: # server_address = ( # address or app.config("address") or DEFAULT_ADDRESS, # port or app.config("port") or DEFAULT_PORT # ) # server = WSGIServer(server_address, WSGIRequestHandler) # server.set_app(stack) # socket = server.socket.getsockname() # print "WSGIREF server listening on %s:%s" % ( socket[0], socket[1]) # try: # while runCondition: server.handle_request() # except KeyboardInterrupt: # print "done" # # == STANDALONE (Retro WSGI server) # elif method in (STANDALONE, AIO): try: import reporter as logging except: import logging server_address = ( address or app.config("address") or DEFAULT_ADDRESS, int(port or app.config("port") or DEFAULT_PORT) ) stack.fromRetro = True stack.app = lambda: app if method == STANDALONE and not asynchronous: import retro.wsgi try: server = retro.wsgi.WSGIServer(server_address, stack) retro.wsgi.onError(onError) socket = server.socket.getsockname() print ("Retro embedded server listening on %s:%s" % ( socket[0], socket[1])) except Exception as e: logging.error("Retro: Cannot bind to {0}:{1}, error: {2}".format(server_address[0], server_address[1], e)) return -1 # TODO: Support runCondition try: while runCondition(): server.handle_request() except KeyboardInterrupt: print ("done") else: import retro.aio import asyncio retro.aio.run(app, server_address[0], server_address[1]) # TODO: Support runCondition else: raise Exception("Unknown retro setup method:" + method)
def handle(self, app): _production_logging(app) from flup.server.fcgi import WSGIServer sock_path = os.path.join(app.instance_path, 'fcgi.sock') server = WSGIServer(app, bindAddress=sock_path, umask=0) server.run()
# testLang = u"en"; # testItems = { # u"Luis Hernández": 1, # u"Mexikói labdarúgó-válogatott": 1, # u"Labdarúgó": 1, # u"CA Boca Juniors": 1, # u"CF Monterrey": 1 # } # testLang = u"hu"; # testItems = { # u"باشگاه فوتبال بوکا جونیورز": 1, # u"فوتبال": 1, # u"زبان اسپانیایی": 1, # u"آرژانتین": 1}; # testLang = u"fa"; # logging.basicConfig(level=logging.DEBUG) # recommender = LinkRecommender(lang=testLang, nrecs=2500, verbose=True); # recommender.connect(); # recs = recommender.get_recs(item_map=testItems, \ # param_map=dict({u'nrecs': 2500,u'lang': testLang})); # recommender.close(); # print "Received %d recommendations." % (len(recs),); # Also, comment out these if you run from command line wsgi = WSGIServer(app); wsgi.run();
def handle(self, app): from flup.server.fcgi import WSGIServer sock_path = os.path.join(app.instance_path, 'fcgi.sock') server = WSGIServer(app, bindAddress=sock_path, umask=0, maxThreads=5) server.run()