Lib.modjy.modjy_wsgi.py Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of jython Show documentation
Show all versions of jython Show documentation
Jython is an implementation of the high-level, dynamic, object-oriented
language Python written in 100% Pure Java, and seamlessly integrated with
the Java platform. It thus allows you to run Python on any Java platform.
###
#
# Copyright Alan Kennedy.
#
# You may contact the copyright holder at this uri:
#
# http://www.xhaus.com/contact/modjy
#
# The licence under which this code is released is the Apache License v2.0.
#
# The terms and conditions of this license are listed in a file contained
# in the distribution that also contained this file, under the name
# LICENSE.txt.
#
# You may also read a copy of the license at the following web address.
#
# http://modjy.xhaus.com/LICENSE.txt
#
###
from java.lang import System
try:
from org.python.core.util import FileUtil
create_py_file = FileUtil.wrap
except ImportError:
from org.python.core import PyFile
create_py_file = PyFile
from modjy_exceptions import *
from modjy_input import modjy_input_object
server_name = "modjy"
server_param_prefix = "%s.param" % server_name
j2ee_ns_prefix = "j2ee"
cgi_var_char_encoding = "iso-8859-1"
class modjy_wsgi:
#
# WSGI constants
#
empty_pystring = u""
wsgi_version = (1,0)
#
# Container-specific constants
#
modjy_version = (0, 25, 3)
def set_string_envvar(self, dict, name, value):
if value is None:
value = self.empty_pystring
value = value.encode(cgi_var_char_encoding)
dict[name] = value
def set_string_envvar_optional(self, dict, name, value, default_value):
if value != default_value:
self.set_string_envvar(dict, name, value)
def set_int_envvar(self, dict, name, value, default_value):
if value == default_value:
value = self.empty_pystring
else:
value = unicode(value)
self.set_string_envvar(dict, name, value)
def set_container_specific_wsgi_vars(self, req, resp, dict, params):
dict["%s.version" % server_name] = self.modjy_version
for pname in params.keys():
dict["%s.%s" % (server_param_prefix, pname)] = params[pname]
def set_j2ee_specific_wsgi_vars(self, dict, j2ee_ns):
for p in j2ee_ns.keys():
dict["%s.%s" % (j2ee_ns_prefix, p)] = j2ee_ns[p]
def set_required_cgi_environ (self, req, resp, dict):
self.set_string_envvar(dict, "REQUEST_METHOD", req.getMethod())
self.set_string_envvar(dict, "QUERY_STRING", req.getQueryString())
self.set_string_envvar(dict, "CONTENT_TYPE", req.getContentType())
self.set_int_envvar(dict, "CONTENT_LENGTH", req.getContentLength(), -1)
self.set_string_envvar(dict, "SERVER_NAME", req.getLocalName())
self.set_int_envvar(dict, "SERVER_PORT", req.getLocalPort(), 0)
def set_other_cgi_environ (self, req, resp, dict):
if req.isSecure():
self.set_string_envvar(dict, "HTTPS", 'on')
else:
self.set_string_envvar(dict, "HTTPS", 'off')
self.set_string_envvar(dict, "SERVER_PROTOCOL", req.getProtocol())
self.set_string_envvar(dict, "REMOTE_HOST", req.getRemoteHost())
self.set_string_envvar(dict, "REMOTE_ADDR", req.getRemoteAddr())
self.set_int_envvar(dict, "REMOTE_PORT", req.getRemotePort(), -1)
self.set_string_envvar_optional(dict, "AUTH_TYPE", req.getAuthType(), None)
self.set_string_envvar_optional(dict, "REMOTE_USER", req.getRemoteUser(), None)
def set_http_header_environ(self, req, resp, dict):
header_name_enum = req.getHeaderNames()
while header_name_enum.hasMoreElements():
curr_header_name = header_name_enum.nextElement()
values = None
values_enum = req.getHeaders(curr_header_name)
while values_enum.hasMoreElements():
next_value = values_enum.nextElement().encode(cgi_var_char_encoding)
if values is None:
values = next_value
else:
if isinstance(values, list):
values.append(next_value)
else:
values = [values]
dict["HTTP_%s" % str(curr_header_name).replace('-', '_').upper()] = values
def set_required_wsgi_vars(self, req, resp, dict):
dict["wsgi.version"] = self.wsgi_version
dict["wsgi.url_scheme"] = req.getScheme()
dict["wsgi.multithread"] = \
int(dict["%s.cache_callables" % server_param_prefix]) \
and \
int(dict["%s.multithread" % server_param_prefix])
dict["wsgi.multiprocess"] = self.wsgi_multiprocess = 0
dict["wsgi.run_once"] = not(dict["%s.cache_callables" % server_param_prefix])
def set_wsgi_streams(self, req, resp, dict):
try:
dict["wsgi.input"] = modjy_input_object(req.getInputStream())
dict["wsgi.errors"] = create_py_file(System.err)
except IOException, iox:
raise ModjyIOException(iox)
def set_wsgi_classes(self, req, resp, dict):
# dict["wsgi.file_wrapper"] = modjy_file_wrapper
pass
def set_user_specified_environment(self, req, resp, wsgi_environ, params):
if not params.has_key('initial_env') or not params['initial_env']:
return
user_env_string = params['initial_env']
for l in user_env_string.split('\n'):
l = l.strip()
if l:
name, value = l.split(':', 1)
wsgi_environ[name.strip()] = value.strip()
def set_wsgi_environment(self, req, resp, wsgi_environ, params, j2ee_ns):
self.set_container_specific_wsgi_vars(req, resp, wsgi_environ, params)
self.set_j2ee_specific_wsgi_vars(wsgi_environ, j2ee_ns)
self.set_required_cgi_environ(req, resp, wsgi_environ)
self.set_other_cgi_environ(req, resp, wsgi_environ)
self.set_http_header_environ(req, resp, wsgi_environ)
self.set_required_wsgi_vars(req, resp, wsgi_environ)
self.set_wsgi_streams(req, resp, wsgi_environ)
self.set_wsgi_classes(req, resp, wsgi_environ)
self.set_user_specified_environment(req, resp, wsgi_environ, params)