def handle_interactive_request(self, environ):
code = environ['wsgi.input'].read().replace('\r\n', '\n')
user_environ = self.get_user_environ(environ)
if 'HTTP_CONTENT_LENGTH' in user_environ:
del user_environ['HTTP_CONTENT_LENGTH']
user_environ['REQUEST_METHOD'] = 'GET'
url = 'http://%s:%s%s?%s' % (user_environ['SERVER_NAME'],
user_environ['SERVER_PORT'],
urllib.quote(environ['PATH_INFO']),
environ['QUERY_STRING'])
results_io = cStringIO.StringIO()
old_sys_stdout = sys.stdout
try:
error = logservice.LogsBuffer()
request_environment.current_request.Init(error, user_environ)
url = urlparse.urlsplit(url)
environ.update(runtime.CgiDictFromParsedUrl(url))
sys.stdout = results_io
try:
compiled_code = compile(code, '<string>', 'exec')
exec(compiled_code, self._command_globals)
except:
traceback.print_exc(file=results_io)
return {'error': 0,
'response_code': 200,
'headers': [('Content-Type', 'text/plain')],
'body': results_io.getvalue(),
'logs': error.parse_logs()}
finally:
request_environment.current_request.Clear()
sys.stdout = old_sys_stdout
def _bootstrap(target, args, kwargs=None):
"""Helper to start a thread."""
if kwargs is None:
kwargs = {}
errors = logservice.LogsBuffer()
environ = dict(_original_environ)
if _filtered_environ:
environ.update(_filtered_environ)
try:
request_environment.current_request.Init(errors, environ)
target(*args, **kwargs)
finally:
request_environment.current_request.Reset()
def Handle(environ):
"""Handles a background request.
This function is called by the runtime in response to an /_ah/background
request.
Args:
environ: A dict containing the environ for this request (i.e. for
os.environ).
Returns:
A dict containing:
error: App Engine error code. 0 if completed successfully, 1 otherwise.
response_code: The HTTP response code. 200 if completed successfully, 500
otherwise.
logs: A list of tuples (timestamp_usec, severity, message) of log
entries. timestamp_usec is a long, severity is int and message is
str. Severity levels are 0..4 for Debug, Info, Warning, Error,
Critical.
"""
error = logservice.LogsBuffer()
request_environment.current_request.Init(error, environ)
response = {'error': 0, 'response_code': 200}
try:
request_id = environ[BACKGROUND_REQUEST_ID]
_pending_background_threads.RunBackgroundThread(request_id)
return response
except:
exception = sys.exc_info()
tb = exception[2].tb_next
if tb:
tb = tb.tb_next
message = ''.join(traceback.format_exception(exception[0], exception[1],
tb))
logging.error(message)
response['response_code'] = 500
response['error'] = 1
return response
finally:
request_environment.current_request.Clear()
response['logs'] = error.parse_logs()
def Handle(environ):
"""Handles a shutdown request.
Args:
environ: A dict containing the environ for this request (i.e. for
os.environ).
Returns:
A tuple with:
A dict containing:
error: App Engine error code. Always 0 for OK.
response_code: The HTTP response code. Always 200.
logs: A list of tuples (timestamp_usec, severity, message) of log
entries. timestamp_usec is a long, severity is int and message is
str. Severity levels are 0..4 for Debug, Info, Warning, Error,
Critical.
A tuple containing the result of sys.exc_info() if an exception occured,
or None.
"""
response = {}
response['error'] = 0
response['response_code'] = 200
exc = None
try:
error = logservice.LogsBuffer()
request_environment.current_request.Init(error, environ)
getattr(runtime_api, '__BeginShutdown')()
except:
exc = sys.exc_info()
message = ''.join(
traceback.format_exception(exc[0], exc[1], exc[2].tb_next))
logging.info('Raised exception in shutdown handler:\n' + message)
finally:
request_environment.current_request.Clear()
response['logs'] = error.parse_logs()
return (response, exc)
def HandleRequest(environ,
handler_name,
url,
post_data,
application_root,
python_lib,
import_hook=None):
"""Handles a single request.
Handles a single request for handler_name by dispatching to the appropriate
server interface implementation (CGI or WSGI) depending on the form of
handler_name. The arguments are processed to fill url and post-data related
environ members.
Args:
environ: A dict containing the environ for this request (i.e. for
os.environ).
handler_name: A str containing the user-specified handler to use for this
request, i.e. the script parameter for a handler in app.yaml; e.g.
'package.module.application' for a WSGI handler or 'path/to/handler.py'
for a CGI handler.
url: The requested url.
post_data: The post data for this request.
application_root: A str containing the root path of the application.
python_lib: A str containing the root the Python App Engine library.
import_hook: Optional import hook (PEP 302 style loader).
Returns:
A dict containing:
error: App Engine error code. 0 for OK, 1 for error.
response_code: The HTTP response code.
headers: A list of str tuples (key, value) of HTTP headers.
body: A str of the body of the response
logs: A list of tuples (timestamp_usec, severity, message) of log entries.
timestamp_usec is a long, severity is int and message is str. Severity
levels are 0..4 for Debug, Info, Warning, Error, Critical.
stats: A list of strings, for internal stats collection.
"""
try:
error = logservice.LogsBuffer()
runtime_stats = {
'ssl_cert_verify_result': {},
}
request_environment.current_request.Init(error, environ, runtime_stats)
url = urlparse.urlsplit(url)
environ.update(CgiDictFromParsedUrl(url))
if post_data:
environ['CONTENT_LENGTH'] = str(len(post_data))
if 'HTTP_CONTENT_TYPE' in environ:
environ['CONTENT_TYPE'] = environ['HTTP_CONTENT_TYPE']
else:
environ['CONTENT_TYPE'] = 'application/x-www-form-urlencoded'
post_data = cStringIO.StringIO(post_data)
if '/' in handler_name or handler_name.endswith('.py'):
response = cgi.HandleRequest(environ, handler_name, url, post_data,
error, application_root, python_lib,
import_hook)
else:
response = wsgi.HandleRequest(environ, handler_name, url,
post_data, error)
response['logs'] = error.parse_logs()
response['runtime_stats'] = (
request_environment.current_request.runtime_stats)
return response
finally:
request_environment.current_request.Clear()
