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
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
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):
_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 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()
