def __init__(self):
log.debug("WSGIHandler created %d" % os.getpid())
self.settings = Settings()
if hasattr(self.settings, "syslog"):
if self.settings.syslog:
self._initSyslog()
self.settings.require("urls",
'urls = [(r"/$", StaticFileHandler, {"path": "/files/path")}), ]')
if hasattr(self.settings, "favicon"):
self.favicon = self.settings.favicon
else:
self.favicon = None
# Send instanciated signal
application_instanciated.send(self.__class__,
application=self)
self.factories = []
for url in self.settings.urls:
self.createFactory(url)
if hasattr(self.settings, "working_dir"):
log.info("Set workingdir to %s" % self.settings.working_dir)
os.chdir(self.settings.working_dir)
def create(self):
settings = Settings()
settings.require("memstorage_address",
"memstorage_address = (\"127.0.0.1\", 54678)")
settings.require("memstorage_authkey",
"memstorage_authkey = \"my_secret_key\"")
settings.require(
"memstorage_objects", "memstorage_objects = "
"{\"my_dict\": dict, "
"\"my_list\": list, "
"\"my_object\": my_custom_class}")
address = settings.memstorage_address
authkey = settings.memstorage_authkey
objs = settings.memstorage_objects
class MemstorageManager(BaseManager):
pass
for name in objs.iterkeys():
log.info("Register object %s" % name)
MemstorageManager.register(name)
self.manager = MemstorageManager(address=address, authkey=authkey)
# Make references of the manager-objects to this object
for name in objs.iterkeys():
setattr(self, name, getattr(self.manager, name))
def __init__(self):
settings = Settings()
settings.require("memstorage_address",
"memstorage_address = (\"127.0.0.1\", 54678)")
settings.require("memstorage_authkey",
"memstorage_authkey = \"my_secret_key\"")
settings.require(
"memstorage_objects", "memstorage_objects = {\"my_dict\": dict,"
"\"my_list\": list,"
"\"my_object\": my_custom_class}")
self.address = settings.memstorage_address
self.authkey = settings.memstorage_authkey
self.objs = settings.memstorage_objects
def __init__(self):
settings = Settings()
if hasattr(settings, "httpserver_address"):
self.server_address = settings.httpserver_address
else:
self.server_address = ("127.0.0.1", 8080)
log.info("Start server %s:%d [%d]" % (self.server_address[0],
self.server_address[1],
os.getpid()))
self.ssl = False
if hasattr(settings, "httpserver_ssl"):
self.ssl = settings.httpserver_ssl
if settings.httpserver_ssl:
settings.require("httpserver_certfile",
'httpserver_certfile = "/path/to/certfile"')
settings.require("httpserver_keyfile",
'httpserver_keyfile = "/path/to/keyfile"')
self.certfile = settings.httpserver_certfile
self.keyfile = settings.httpserver_keyfile
self.app = WSGIHandler()
def __init__(self):
self._settings = Settings()
if hasattr(self._settings, "encoding"):
self._encoding = self._settings.encoding
else:
self._encoding = "utf-8"
try:
self._secret = self._settings.cookie_secret
except:
log.warning("Missing cookie_secret in settings!")
self._secret = u"levitas_cookie_secret"
if isinstance(self._secret, STR):
self._secret = self._secret.encode(self._encoding)
def __init__(self):
settings = Settings()
settings.require("memstorage_address",
"memstorage_address = (\"127.0.0.1\", 54678)")
settings.require("memstorage_authkey",
"memstorage_authkey = \"my_secret_key\"")
settings.require("memstorage_objects",
"memstorage_objects = {\"my_dict\": dict,"
"\"my_list\": list,"
"\"my_object\": my_custom_class}")
self.address = settings.memstorage_address
self.authkey = settings.memstorage_authkey
self.objs = settings.memstorage_objects
def __init__(self, root_directory=None, file_extensions=["py"]):
"""
Monitoring and reloading file modifications.
Example settings (optional):
# Which directory is the root of the source files?
# Default current working directory.
modificationmonitor_root_directory = "/root/path"
# Which files should be monitored for modification?
# Default *.py files.
modificationmonitor_file_extensions = ["py"]
# How often should we check for changes (in seconds)?
# Default one second.
modificationmonitor_poll_interval = 1
"""
settings = Settings()
if hasattr(settings, "modificationmonitor_root_directory"):
self._root_directory = settings.modificationmonitor_root_directory
else:
self._root_directory = os.getcwd()
if hasattr(settings, "modificationmonitor_file_extensions"):
extensions = settings.modificationmonitor_file_extensions
self._file_patterns = [r"[!.]*.%s" % ext for ext in extensions]
else:
self._file_patterns = [r"[!.]*.py"]
self._file_extensions = ["py"]
if hasattr(settings, "modificationmonitor_poll_interval"):
self._poll_interval = settings.modificationmonitor_poll_interval
else:
self._poll_interval = 1
self.files = self.get_files()
log.info("Root directory: %s" % self._root_directory)
self.setsignals()
self.start_program()
while True:
time.sleep(self._poll_interval)
if self.poll():
log.info("Noticed a change in program source. Restarting...")
self.start_program()
def __init__(self):
settings = Settings()
if hasattr(settings, "httpserver_address"):
self.server_address = settings.httpserver_address
else:
self.server_address = ("127.0.0.1", 8080)
log.info("Start server %s:%d [%d]" %
(self.server_address[0], self.server_address[1], os.getpid()))
self.ssl = False
if hasattr(settings, "httpserver_ssl"):
self.ssl = settings.httpserver_ssl
if settings.httpserver_ssl:
settings.require("httpserver_certfile",
'httpserver_certfile = "/path/to/certfile"')
settings.require("httpserver_keyfile",
'httpserver_keyfile = "/path/to/keyfile"')
self.certfile = settings.httpserver_certfile
self.keyfile = settings.httpserver_keyfile
self.app = WSGIHandler()
def get(self):
settings = Settings()
settings.require("custom_attr", example="custom_attr = 'Some string'")
return settings.custom_attr
def init_settings(SETTINGS):
module = imp.new_module("SETTINGS")
exec(SETTINGS, module.__dict__)
sys.modules["SETTINGS"] = module
os.environ["LEVITAS_SETTINGS"] = "SETTINGS"
Settings().import_module()
def __init__(self, *args, **kwargs):
self.settings = Settings()
""" Settings-Object """
self.re_match = None
""" match object for regular expression of the request path """
self.request_method = None
""" HTTP-Request method """
self.request_headers = {}
"""Headers from the request """
self.response_headers = []
""" Headers for the response """
self.response_code = 200
""" Response-code """
self.path = None
""" path info """
self.request_data = None
""" Request data """
self.remote_host = None
""" Remote host of the request """
self.remote_address = None
""" Remote address of the request """
self.user_agent = None
""" User agent of the request """
self.url_scheme = None
""" Url scheme (http or https) """
self.server_name = None
""" Server name """
self.server_port = None
""" Server port """
self.query_string = None
""" Query string """
self.cookies = Cookie.BaseCookie()
""" Cookies for the request """
self._new_cookies = []
""" New cookies for the response """
self.__responseStarted = False
if hasattr(self.settings, "encoding"):
self._encoding = self.settings.encoding
else:
self._encoding = "utf-8"
if hasattr(self.settings, "fieldstorage_class"):
self._fieldstorage_class = self.settings.fieldstorage_class
else:
self._fieldstorage_class = cgi.FieldStorage
# Send instanciated signal
middleware_instanciated.send(self.__class__, middleware=self)
class WSGIHandler(object):
"""
WSGIHandler for the levitas application.
Example settings
================
A url definition is a tuple with three parts:
(r"/.*$", MiddlewareClass, {"arg": "value"})
1. regular expression of the request path.
2. middleware class.
3. Arguments to instantiate the class.
Example:
urls = [
# (regular expression of the request path, middleware class,
(r"^/json", JSONMiddleware, {"service_class": MyService}),
(r"(?!/json/.*)^/.*$", AppMiddleware, {"path": "/path/to/app"})
]
# Working directory of the wsgi application
working_dir = "/path/to/working directory"
# Custom path to the favicon
favicon = "/path/to/favicon.ico"
# Log to syslog
syslog = True
syslog_verbose = True
sysloghandler_kwargs = {"address": "/dev/log"}
WSGI capable webservers
========================
Apache:
http://code.google.com/p/modwsgi/
uwsgi:
http://projects.unbit.it/uwsgi/
uwsgi application server can also used with Apache and
also with Nginx and others.
Example wsgi script
===================
import os
from levitas.handler import WSGIHandler
# Pythonpath to your settings module
os.environ["LEVITAS_SETTINGS"] = "my_module.my_settings"
application = WSGIHandler()
"""
def __init__(self):
log.debug("WSGIHandler created %d" % os.getpid())
self.settings = Settings()
if hasattr(self.settings, "syslog"):
if self.settings.syslog:
self._initSyslog()
self.settings.require("urls",
'urls = [(r"/$", StaticFileHandler, {"path": "/files/path")}), ]')
if hasattr(self.settings, "favicon"):
self.favicon = self.settings.favicon
else:
self.favicon = None
# Send instanciated signal
application_instanciated.send(self.__class__,
application=self)
self.factories = []
for url in self.settings.urls:
self.createFactory(url)
if hasattr(self.settings, "working_dir"):
log.info("Set workingdir to %s" % self.settings.working_dir)
os.chdir(self.settings.working_dir)
def addURLs(self, urls):
if not isinstance(urls, list):
urls = [urls]
for url in urls:
self.createFactory(url)
def createFactory(self, url):
regex = url[0]
middleware_class = url[1]
args = []
kwargs = {}
for p in url[2:]:
if isinstance(p, (list, tuple)):
args.extend(p)
elif isinstance(p, dict):
kwargs.update(p)
else:
args.append(p)
log.debug("MiddlewareFactory: %s, %s, %s, %s" % (regex,
middleware_class.__name__,
str(args),
str(kwargs)))
factory = MiddlewareFactory(regex, middleware_class, *args, **kwargs)
self.factories.append(factory)
def _error(self, environ, _startResponse, code):
middleware = Middleware()
middleware.initEnviron(environ, _startResponse)
return middleware.responseError(code)
def _initSyslog(self):
from logging.handlers import SysLogHandler
log = logging.getLogger()
formatter = logging.Formatter("%(asctime)s - %(name)s "
"- %(levelname)s - %(message)s")
if hasattr(self.settings, "sysloghandler_kwargs"):
kwargs = self.settings.sysloghandler_kwargs
else:
kwargs = {"address": "/dev/log"}
handler = SysLogHandler(**kwargs)
if hasattr(self.settings, "syslog_verbose"):
if self.settings.syslog_verbose:
log.setLevel(logging.DEBUG)
else:
log.setLevel(logging.INFO)
handler.setFormatter(formatter)
log.addHandler(handler)
def __call__(self, environ, _startResponse):
#log.debug("Application call %d" % os.getpid())
# Send called signal
application_called.send(self.__class__,
application=self,
environ=environ)
# Send favicon
if self.favicon:
self.send_response(200)
self.end_headers()
try:
f = open(self.settings.favicon)
_startResponse("200 OK", [("Content-type", "image/x-icon")])
return f
except:
return self._error(environ, _startResponse, 404)
# Look up factory for current path and call it.
path = os.path.normpath(environ["PATH_INFO"])
log.debug("Handling path %s" % path)
for factory in self.factories:
m = factory.match(path)
if m is not None:
try:
log.debug("Url match pattern: %s" % factory.pattern)
return factory(environ, _startResponse, m)
except Exception as err:
log.error(str(err), exc_info=True)
return self._error(environ, _startResponse, 500)
break
else:
log.error("No factory found for %s" % path, exc_info=True)
return self._error(environ, _startResponse, 404)