class ModPythonGateway(WSGIGateway):
wsgi_multithread = apache.mpm_query(apache.AP_MPMQ_IS_THREADED) > 0
wsgi_multiprocess = apache.mpm_query(apache.AP_MPMQ_IS_FORKED) > 0
def __init__(self, req, options):
environ = {}
environ.update(apache.build_cgi_env(req))
environ['trac.web.frontend'] = 'mod_python'
environ['trac.web.version'] = version
if 'TracEnv' in options:
environ['trac.env_path'] = options['TracEnv']
if 'TracEnvParentDir' in options:
environ['trac.env_parent_dir'] = options['TracEnvParentDir']
if 'TracEnvIndexTemplate' in options:
environ['trac.env_index_template'] = options[
'TracEnvIndexTemplate']
if 'TracTemplateVars' in options:
environ['trac.template_vars'] = options['TracTemplateVars']
if 'TracLocale' in options:
environ['trac.locale'] = options['TracLocale']
if 'TracUriRoot' in options:
# Special handling of SCRIPT_NAME/PATH_INFO for mod_python, which
# tends to get confused for whatever reason
root_uri = options['TracUriRoot'].rstrip('/')
request_uri = environ['REQUEST_URI'].split('?', 1)[0]
if not request_uri.startswith(root_uri):
raise ValueError('TracUriRoot set to %s but request URL '
'is %s' % (root_uri, request_uri))
environ['SCRIPT_NAME'] = root_uri
environ['PATH_INFO'] = urllib.unquote(request_uri[len(root_uri):])
WSGIGateway.__init__(self, environ, InputWrapper(req),
_ErrorsWrapper(lambda x: req.log_error(x)))
self.req = req
def _send_headers(self):
assert self.headers_set, 'Response not started'
if not self.headers_sent:
status, headers = self.headers_sent = self.headers_set
self.req.status = int(status[:3])
for name, value in headers:
if name.lower() == 'content-length':
self.req.set_content_length(int(value))
elif name.lower() == 'content-type':
self.req.content_type = value
else:
self.req.headers_out.add(name, value)
def _sendfile(self, fileobj):
self._send_headers()
try:
self.req.sendfile(fileobj.name)
except IOError, e:
if 'client closed connection' not in str(e):
raise
def handler(req):
options = req.get_options()
## Process wsgi.base_uri
base_uri = options.get('wsgi.base_uri', '')
if base_uri == '/' or base_uri.endswith('/'):
req.log_error(
"WSGI handler: wsgi.base_uri (%s) must not be '/' or end with '/', declining."
% `base_uri`, apache.APLOG_WARNING)
return apache.DECLINED
if req.uri.startswith(base_uri):
req.path_info = req.uri[len(base_uri):]
else:
req.log_error(
"WSGI handler: req.uri (%s) does not start with wsgi.base_uri (%s), declining."
% (`req.uri`, `base_uri`), apache.APLOG_WARNING)
return apache.DECLINED
## Find the application callable
app = None
app_str = options.get('wsgi.application')
if app_str:
mod_str, callable_str = (app_str.split('::', 1) + [None])[0:2]
module = apache.import_module(mod_str, log=True)
app = getattr(module, callable_str or 'application')
if not app:
req.log_error(
'WSGI handler: wsgi.application (%s) not found, declining.'
% `app_str`, apache.APLOG_WARNING)
return apache.DECLINED
## Build env
req.add_cgi_vars()
env = dict(req.subprocess_env)
if req.headers_in.has_key("authorization"):
env["HTTP_AUTHORIZATION"] = req.headers_in["authorization"]
env['wsgi.input'] = req
env['wsgi.errors'] = sys.stderr
env['wsgi.version'] = (1, 0)
env['wsgi.multithread'] = apache.mpm_query(apache.AP_MPMQ_IS_THREADED)
env['wsgi.multiprocess'] = apache.mpm_query(apache.AP_MPMQ_IS_FORKED)
if env.get('HTTPS', 'off') == 'off':
env['wsgi.url_scheme'] = 'http'
else:
env['wsgi.url_scheme'] = 'https'
## Run the app
WSGIContainer(req).run(app, env)
return apache.OK
def test(self, req):
req.content_type = "text/plain"
apache.log_error("request!", apache.APLOG_NOTICE)
req.write("\nParsed URI:\n-------------\n")
req.write(dump.dump(req.parsed_uri))
req.write("\nModPython Options:\n-------------\n")
req.write(dump.dump(req.get_options()))
req.write("\nModPython Config:\n-------------\n")
req.write(dump.dump(req.get_config()))
req.write("\nOS Env:\n-------------\n")
req.write(dump.dump(os.environ))
req.write("\nProcess Env:\n-------------\n")
req.add_common_vars()
req.write(dump.dump(req.subprocess_env))
req.write("\n")
req.write("server_root=" + apache.server_root() + "\n")
req.write("document_root=" + req.document_root() + "\n")
req.write("loglevel=" + dump.dump(req.server.loglevel))
req.write("is_virtual=" + dump.dump(req.server.is_virtual))
req.write("phase=" + dump.dump(req.phase))
req.write("handler=" + dump.dump(req.handler))
req.write("uri=" + dump.dump(req.uri))
req.write("filename=" + dump.dump(req.filename))
req.write("py interpreter=" + dump.dump(req.interpreter))
req.write("\n")
req.write("__file__=" + __file__ + "\n")
req.write("dir=" + os.path.dirname(__file__) + "\n")
req.write("\n")
if apache.mpm_query(apache.AP_MPMQ_IS_THREADED):
req.write("mpm is threaded\n")
else:
req.write("mpm is NOT threaded\n")
if apache.mpm_query(apache.AP_MPMQ_IS_FORKED):
req.write("mpm is forked\n")
else:
req.write("mpm is NOT forked\n")
req.write("\n")
req.write("sys.path: %s\n" % sys.path)
req.write("\n")
req.write("POST form data:\n")
req.write("content length: " + dump.dump(req.clength))
req.write(dump.dump(req.read()))
#req.write(dump.dump(apache.config_tree()))
return apache.OK
class ModPythonGateway(WSGIGateway):
wsgi_multithread = apache.mpm_query(apache.AP_MPMQ_IS_THREADED) > 0
wsgi_multiprocess = apache.mpm_query(apache.AP_MPMQ_IS_FORKED) > 0
def __init__(self, req, options):
environ = {}
environ.update(apache.build_cgi_env(req))
environ['mod_python.options'] = options
environ['mod_python.subprocess_env'] = req.subprocess_env
WSGIGateway.__init__(self, environ, InputWrapper(req),
_ErrorsWrapper(lambda x: req.log_error(x)))
self.req = req
def _send_headers(self):
assert self.headers_set, 'Response not started'
if not self.headers_sent:
status, headers = self.headers_sent = self.headers_set
self.req.status = int(status[:3])
for name, value in headers:
if name.lower() == 'content-length':
self.req.set_content_length(int(value))
elif name.lower() == 'content-type':
self.req.content_type = value
else:
self.req.headers_out.add(name, value)
def _sendfile(self, fileobj):
self._send_headers()
self.req.sendfile(fileobj.name)
def _write(self, data):
self._send_headers()
try:
self.req.write(data)
except IOError, e:
if 'client closed connection' not in str(e):
raise
def run(self, req):
environ = dict(apache.build_cgi_env(req))
options = req.get_options()
# we define those classes here to don't
# give the user access to the mod python request
# object using environ['wsgi.input']._req or
# something similar.
class InputStream(object):
def close(self):
pass
def read(self, size=-1):
return req.read(size)
def readline(self):
return req.readline()
def readlines(self, hint=-1):
return req.readlines(hint)
def flush(self):
pass
def write(self, s):
pass
def writelines(self, seq):
pass
def __iter__(self):
while True:
line = self.readline()
if not line:
return
yield line
class ErrorStream(object):
def read(self, size=-1):
return ''
def readline(self):
return '\n'
def readlines(self, hint=-1):
return []
def flush(self):
pass
def write(self, s):
req.log_error(s)
def writelines(self, seq):
for item in seq:
req.log_error(item)
def __iter__(self):
return iter(int, 0)
try:
threaded = apache.mpm_query(apache.AP_MPMQ_IS_THREADED)
forked = apache.mpm_query(apache.AP_MPMQ_IS_FORKED)
except AttributeError:
threaded = options.get('multithread', '').lower() == 'on'
forked = options.get('multiprocess', '').lower() == 'on'
if 'SCRIPT_NAME' in options:
environ['SCRIPT_NAME'] = options['SCRIPT_NAME']
path_info = req.uri[len(options['SCRIPT_NAME']):]
if path_info:
environ['PATH_INFO'] = path_info
if environ.get('HTTPS', '').lower() in ('1', 'yes', 'on'):
url_scheme = 'https'
else:
url_scheme = 'http'
environ.update({
'wsgi.input': InputStream(),
'wsgi.error': ErrorStream(),
'wsgi.version': (1, 0),
'wsgi.run_once': False,
'wsgi.url_scheme': url_scheme,
'wsgi.multithread': threaded,
'wsgi.multiprocess': forked
})
req.content_type = 'text/plain'
headers_set = []
headers_sent = []
def write(data):
if not headers_set:
raise AssertionError('write() before start_response()')
elif not headers_sent:
status, response_headers = headers_sent[:] = headers_set
req.status = int(status[:3])
for key, value in response_headers:
if key.lower() == 'content-length':
req.set_content_length(int(value))
elif key.lower() == 'content-type':
req.content_type = value
else:
req.headers_out.add(key, value)
req.write(data)
def start_response(status, response_headers, exc_info=None):
if exc_info:
try:
if headers_sent:
raise exc_info[0], exc_info[1], exc_info[2]
finally:
exc_info = None
elif headers_set:
raise AssertionError('Headers already set!')
headers_set[:] = [status, response_headers]
return write
result = self._application(environ, start_response)
try:
for data in result:
if data:
write(data)
if not headers_sent:
write('')
finally:
if hasattr(result, 'close'):
result.close()
return apache.OK
def run(self, req):
environ = dict(apache.build_cgi_env(req))
options = req.get_options()
# we define those classes here to don't
# give the user access to the mod python request
# object using environ['wsgi.input']._req or
# something similar.
class InputStream(object):
def close(self):
pass
def read(self, size=-1):
return req.read(size)
def readline(self):
return req.readline()
def readlines(self, hint=-1):
return req.readlines(hint)
def flush(self):
pass
def write(self, s):
pass
def writelines(self, seq):
pass
def __iter__(self):
while True:
line = self.readline()
if not line:
return
yield line
class ErrorStream(object):
def read(self, size=-1):
return ''
def readline(self):
return '\n'
def readlines(self, hint=-1):
return []
def flush(self):
pass
def write(self, s):
req.log_error(s)
def writelines(self, seq):
for item in seq:
req.log_error(item)
def __iter__(self):
return iter(int, 0)
try:
threaded = apache.mpm_query(apache.AP_MPMQ_IS_THREADED)
forked = apache.mpm_query(apache.AP_MPMQ_IS_FORKED)
except AttributeError:
threaded = options.get('multithread', '').lower() == 'on'
forked = options.get('multiprocess', '').lower() == 'on'
# XXX: argh. a very stupid way for this problem but
# mod_python otherwise does everything with our
# SCRIPT_NAME/PATH_INFO but that what wsgi expects.
#
# the problem in short:
# script installed on /a using .htaccess
#
# URI SCRIPT_NAME PATH_INFO
# ----------------------------------------------------------------
# /a /a
# /a/ /a /
# /a/b /a/b
# /a/b/ /a/b /
# /a/b/c /a/b /c
# /a/b/c/d /a/b /c/d
# WTF????
#XXX: Is this right?
if not options.get('untouched_scriptname', '').lower()\
in ('1', 'on', 'yes') and environ['SCRIPT_NAME']:
path_info = None
if 'PATH_TRANSLATED' in environ:
try:
_, script_name, prefix = environ['SCRIPT_NAME'].split('/', 2)
except ValueError:
script_name, prefix = environ['SCRIPT_NAME'].split('/', 2)
script_name = '/' + script_name
path_info = '/' + prefix + environ.get('PATH_INFO', '')
elif 'PATH_INFO' not in environ:
bits = environ['SCRIPT_NAME'].split('/')
script_name = '/'.join(bits[:-1])
path_info = '/' + bits[-1]
if script_name == '/':
script_name = ''
environ['SCRIPT_NAME'] = script_name
if path_info:
environ['PATH_INFO'] = path_info
if environ.get('HTTPS', '').lower() in ('1', 'yes', 'on'):
url_scheme = 'https'
else:
url_scheme = 'http'
environ.update({
'wsgi.input': InputStream(),
'wsgi.errors': ErrorStream(),
'wsgi.version': (1, 0),
'wsgi.run_once': False,
'wsgi.url_scheme': url_scheme,
'wsgi.multithread': threaded,
'wsgi.multiprocess': forked,
})
req.content_type = 'text/plain'
headers_set = []
headers_sent = []
def write(data):
if not headers_set:
raise AssertionError('write() before start_response()')
elif not headers_sent:
status, response_headers = headers_sent[:] = headers_set
req.status = int(status[:3])
for key, value in response_headers:
if key.lower() == 'content-length':
req.set_content_length(int(value))
elif key.lower() == 'content-type':
req.content_type = value
else:
req.headers_out.add(key, value)
req.write(data)
def start_response(status, response_headers, exc_info=None):
if exc_info:
try:
if headers_sent:
raise exc_info[0], exc_info[1], exc_info[2]
finally:
exc_info = None
elif headers_set:
raise AssertionError('Headers already set!')
headers_set[:] = [status, response_headers]
return write
result = self._application(environ, start_response)
try:
for data in result:
if data:
write(data)
if not headers_sent:
write('')
finally:
if hasattr(result, 'close'):
result.close()
return apache.OK
def run(self, req):
environ = dict(apache.build_cgi_env(req))
options = req.get_options()
# we define those classes here to don't
# give the user access to the mod python request
# object using environ['wsgi.input']._req or
# something similar.
class InputStream(object):
def close(self):
pass
def read(self, size=-1):
return req.read(size)
def readline(self):
return req.readline()
def readlines(self, hint=-1):
return req.readlines(hint)
def flush(self):
pass
def write(self, s):
pass
def writelines(self, seq):
pass
def __iter__(self):
while True:
line = self.readline()
if not line:
return
yield line
class ErrorStream(object):
def read(self, size=-1):
return ''
def readline(self):
return '\n'
def readlines(self, hint=-1):
return []
def flush(self):
pass
def write(self, s):
req.log_error(s)
def writelines(self, seq):
for item in seq:
req.log_error(item)
def __iter__(self):
return iter(int, 0)
try:
threaded = apache.mpm_query(apache.AP_MPMQ_IS_THREADED)
forked = apache.mpm_query(apache.AP_MPMQ_IS_FORKED)
except AttributeError:
threaded = options.get('multithread', '').lower() == 'on'
forked = options.get('multiprocess', '').lower() == 'on'
# XXX: argh. a very stupid way for this problem but
# mod_python otherwise does everything with our
# SCRIPT_NAME/PATH_INFO but that what wsgi expects.
# the problem in short:
# script installed on /a using .htaccess
#
# URI SCRIPT_NAME PATH_INFO
# ----------------------------------------------------------------
# /a /a
# /a/ /a /
# /a/b /a/b
# /a/b/ /a/b /
# /a/b/c /a/b /c
# /a/b/c/d /a/b /c/d
# WTF????
if not options.get('untouched_scriptname', '').lower()\
in ('1', 'on', 'yes') and environ['SCRIPT_NAME']:
# Then touch the scriptname
path_info = None
if 'PATH_TRANSLATED' in environ:
try:
_, script_name, prefix = environ['SCRIPT_NAME'].split(
'/', 2)
except ValueError:
script_name, prefix = environ['SCRIPT_NAME'].split('/', 2)
script_name = '/' + script_name
path_info = '/' + prefix + environ.get('PATH_INFO', '')
elif not 'PATH_INFO' in environ:
bits = environ['SCRIPT_NAME'].split('/')
script_name = '/'.join(bits[:-1])
path_info = '/' + bits[-1]
if script_name == '/':
script_name = ''
environ['SCRIPT_NAME'] = script_name
if path_info:
environ['PATH_INFO'] = path_info
if environ.get('HTTPS', '').lower() in ('1', 'yes', 'on'):
url_scheme = 'https'
else:
url_scheme = 'http'
environ.update({
'wsgi.input': InputStream(
), # An input stream (file-like object) from which the HTTP request body can be read.
'wsgi.errors': ErrorStream(), # error log
'wsgi.version': (1, 0),
'wsgi.run_once': False,
'wsgi.url_scheme': url_scheme,
'wsgi.multithread': threaded,
'wsgi.multiprocess': forked,
"options": options, # Note: Added this
})
req.content_type = 'text/plain'
headers_set = []
headers_sent = []
def write(data):
if not headers_set:
raise AssertionError('write() before start_response()')
elif not headers_sent:
status, response_headers = headers_sent[:] = headers_set
req.status = int(status[:3])
for key, value in response_headers:
if key.lower() == 'content-length':
req.set_content_length(int(value))
elif key.lower() == 'content-type':
req.content_type = value
else:
req.headers_out.add(key, value)
req.write(data)
def start_response(status, response_headers, exc_info=None):
if exc_info:
try:
if headers_sent:
raise exc_info[0], exc_info[1], exc_info[2]
finally:
exc_info = None
elif headers_set:
raise AssertionError('Headers already set!')
headers_set[:] = [status, response_headers]
return write
# Call the application
result = self._application(environ, start_response)
try:
for data in result:
if data:
write(data)
if not headers_sent:
write('')
finally:
if hasattr(result, 'close'):
result.close()
return apache.OK
def verify_not_using_threaded_mpm(self):
if apache.mpm_query(apache.AP_MPMQ_IS_THREADED) != 0:
raise MKGeneralException(
_("You are trying to Check_MK together with a threaded Apache multiprocessing module (MPM). "
"Check_MK is only working with the prefork module. Please change the MPM module to make "
"Check_MK work."))
def handler(req):
req.form = util.FieldStorage(req)
if req.form.getfirst("view_log"):
log = open(os.path.join(apache.server_root(), req.server.error_fname), "rb")
lines = bounded_buffer(100)
for line in log:
lines.append(line)
log.close()
req.content_type = "text/plain"
for line in lines:
req.write(line)
return apache.OK
req.add_common_vars()
req.content_type = "text/html"
req.write("<html><head><title>mod_python test page</title></head><body>\n")
req.write("<h3>General information</h3>\n")
req.write('<table border="1">\n')
req.write(
"<tr><td><code>%s</code></td><td><code>%s</code></td></tr>\n"
% ("Apache version", req.subprocess_env.get("SERVER_SOFTWARE"))
)
req.write(
"<tr><td><code>%s</code></td><td><code>%s</code></td></tr>\n"
% (
"Apache threaded MPM",
(
apache.mpm_query(apache.AP_MPMQ_IS_THREADED)
and "Yes, maximum %i threads / process" % apache.mpm_query(apache.AP_MPMQ_MAX_THREADS)
)
or "No (single thread MPM)",
)
)
req.write(
"<tr><td><code>%s</code></td><td><code>%s</code></td></tr>\n"
% (
"Apache forked MPM",
(
apache.mpm_query(apache.AP_MPMQ_IS_FORKED)
and "Yes, maximum %i processes" % apache.mpm_query(apache.AP_MPMQ_MAX_DAEMONS)
)
or "No (single process MPM)",
)
)
req.write(
"<tr><td><code>%s</code></td><td><code>%s</code></td></tr>\n" % ("Apache server root", apache.server_root())
)
req.write(
"<tr><td><code>%s</code></td><td><code>%s</code></td></tr>\n" % ("Apache document root", req.document_root())
)
if req.server.error_fname:
req.write(
'<tr><td><code>%s</code></td><td><code>%s</code> (<a href="?view_log=1" target="_new">view last 100 lines</a>)</td></tr>\n'
% ("Apache error log", os.path.join(apache.server_root(), req.server.error_fname))
)
else:
req.write("<tr><td><code>%s</code></td><td><code>%s</code></td></tr>\n" % ("Apache error log", "None"))
req.write("<tr><td><code>%s</code></td><td><code>%s</code></td></tr>\n" % ("Python sys.version", sys.version))
req.write("<tr><td><code>%s</code></td><td><pre>%s</pre></td></tr>\n" % ("Python sys.path", "\n".join(sys.path)))
req.write(
"<tr><td><code>%s</code></td><td><code>%s</code></td></tr>\n" % ("Python interpreter name", req.interpreter)
)
req.write("<tr><td><code>mod_python.publisher available</code></td><td><code>")
try:
from mod_python import publisher
req.write("Yes")
except:
req.write("No")
req.write("</code></td></tr>\n")
req.write("<tr><td><code>mod_python.psp available</code></td><td><code>")
try:
from mod_python import psp
req.write("Yes")
except:
req.write("No")
req.write("</code></td></tr>\n")
req.write("</table>\n")
req.write("<h3>Request input headers</h3>\n")
write_table(req, req.headers_in)
req.write("<h3>Request environment</h3>\n")
write_table(req, req.subprocess_env)
req.write("<h3>Request configuration</h3>\n")
write_table(req, req.get_config())
req.write("<h3>Request options</h3>\n")
write_table(req, req.get_options())
req.write("<h3>Request notes</h3>\n")
write_table(req, req.notes)
req.write("<h3>Server configuration</h3>\n")
write_table(req, req.server.get_config())
req.write("<h3>Server options</h3>\n")
write_table(req, req.server.get_options())
req.write("<h3>Server configuration tree</h3>\n<pre>")
write_tree(req, apache.config_tree(), 0)
req.write("</pre>\n")
req.write("</body></html>")
return apache.OK
def handler(req):
req.form = util.FieldStorage(req)
if req.form.getfirst('view_log'):
log = file(os.path.join(apache.server_root(),req.server.error_fname),'rb')
lines = bounded_buffer(100)
for line in log:
lines.append(line)
log.close()
req.content_type='text/plain'
for line in lines:
req.write(line)
return apache.OK
req.add_common_vars()
req.content_type = 'text/html'
req.write('<html><head><title>mod_python test page</title></head><body>\n')
req.write('<h3>General information</h3>\n')
req.write('<table border="1">\n')
req.write('<tr><td><code>%s</code></td><td><code>%s</code></td></tr>\n'%(
'Apache version',
req.subprocess_env.get('SERVER_SOFTWARE')
))
req.write('<tr><td><code>%s</code></td><td><code>%s</code></td></tr>\n'%(
'Apache threaded MPM',
(
apache.mpm_query(apache.AP_MPMQ_IS_THREADED) and
'Yes, maximum %i threads / process'%
apache.mpm_query(apache.AP_MPMQ_MAX_THREADS)
) or 'No (single thread MPM)'
))
req.write('<tr><td><code>%s</code></td><td><code>%s</code></td></tr>\n'%(
'Apache forked MPM',
(
apache.mpm_query(apache.AP_MPMQ_IS_FORKED) and
'Yes, maximum %i processes'%
apache.mpm_query(apache.AP_MPMQ_MAX_DAEMONS)
) or 'No (single process MPM)'
))
req.write('<tr><td><code>%s</code></td><td><code>%s</code></td></tr>\n'%(
'Apache server root',
apache.server_root()
))
req.write('<tr><td><code>%s</code></td><td><code>%s</code></td></tr>\n'%(
'Apache document root',
req.document_root()
))
if req.server.error_fname:
req.write('<tr><td><code>%s</code></td><td><code>%s</code> (<a href="?view_log=1" target="_new">view last 100 lines</a>)</td></tr>\n'%(
'Apache error log',
os.path.join(apache.server_root(),req.server.error_fname)
))
else:
req.write('<tr><td><code>%s</code></td><td><code>%s</code></td></tr>\n'%(
'Apache error log',
'None'
))
req.write('<tr><td><code>%s</code></td><td><code>%s</code></td></tr>\n'%(
'Python sys.version',
sys.version
))
req.write('<tr><td><code>%s</code></td><td><pre>%s</pre></td></tr>\n'%(
'Python sys.path',
'\n'.join(sys.path)
))
req.write('<tr><td><code>%s</code></td><td><code>%s</code></td></tr>\n'%(
'Python interpreter name',
req.interpreter
))
req.write('<tr><td><code>mod_python.publisher available</code></td><td><code>')
try:
from mod_python import publisher
req.write('Yes')
except:
req.write('No')
req.write('</code></td></tr>\n')
req.write('<tr><td><code>mod_python.psp available</code></td><td><code>')
try:
from mod_python import psp
req.write('Yes')
except:
req.write('No')
req.write('</code></td></tr>\n')
req.write('</table>\n')
req.write('<h3>Request input headers</h3>\n')
write_table(req,req.headers_in)
req.write('<h3>Request environment</h3>\n')
write_table(req,req.subprocess_env)
req.write('<h3>Request configuration</h3>\n')
write_table(req,req.get_config())
req.write('<h3>Request options</h3>\n')
write_table(req,req.get_options())
req.write('<h3>Request notes</h3>\n')
write_table(req,req.notes)
req.write('<h3>Server configuration</h3>\n')
write_table(req,req.server.get_config())
req.write('<h3>Server options</h3>\n')
write_table(req,req.server.get_options())
req.write('<h3>Server configuration tree</h3>\n<pre>')
write_tree(req,apache.config_tree(),0)
req.write('</pre>\n')
req.write('</body></html>')
return apache.OK
def verify_not_using_threaded_mpm(self):
if apache.mpm_query(apache.AP_MPMQ_IS_THREADED) != 0:
raise MKGeneralException(
_("You are trying to Check_MK together with a threaded Apache multiprocessing module (MPM). "
"Check_MK is only working with the prefork module. Please change the MPM module to make "
"Check_MK work."))
