# $Id: request.py 2133 2006-09-06 18:52:56Z dairiki $ # request.py - handles component calls for Myghty templates # Copyright (C) 2004, 2005 Michael Bayer mike_mp@zzzcomputing.com # Original Perl code and documentation copyright (c) 1998-2003 by Jonathan Swartz. # # This module is part of Myghty and is released under # the MIT License: http://www.opensource.org/licenses/mit-license.php # """The request package and its primary class, Request, provide the "m" object in Myghty templates. The Request is instantiated by the Interpreter and handles component execution state as well as buffered state. It provides the interface to all actions taken by components, such as writing output, calling other components, calling subrequests, and controllling request state. Also provides the programmatic interface to key objects such as caches and sessions. """ from myghty.util import * import myghty.buffer from myghty import exception import sys, string, re, StringIO, types, os, time, warnings import posixpath as unixpath from myghty.container import CreationAbortedError import myghty.escapes as escapes import myghty.csource as csource from myghty.requestbuffer import UnicodeRequestBuffer, StrRequestBuffer DEFAULT_OUTPUT_ENCODING = sys.getdefaultencoding() DEFAULT_ENCODING_ERRORS = 'strict' # current instance of Request for this thread. # this is flaky as the request module seems to get reimported when it is # first imported within a generated component reqinstance = ThreadLocal() __all__ = ['Request', 'instance', 'threadlocal'] class Request(object): """request object, calls components and directs output. also is the primary programmatic interface presented to a template's environment.""" def __init__(self, interpreter, component = None, request_impl = None, max_recursion = 32, auto_flush = False, use_dhandlers = True, dont_auto_flush_filters = False, resolver_context = 'request', parent_request = None, request_depth = 0, request_path = None, raise_error = False, disable_wrapping = False, output_encoding = DEFAULT_OUTPUT_ENCODING, encoding_errors = DEFAULT_ENCODING_ERRORS, disable_unicode = False, **params ): """init is called internally by the Interpreter.""" self.component = component self.auto_flush = auto_flush self.executed = False self.interpreter = interpreter self.execution_stack = [] self.max_recursion = max_recursion self.dont_auto_flush_filters = dont_auto_flush_filters self.use_dhandlers = use_dhandlers self.disable_wrapping = disable_wrapping self.raise_error = raise_error self.parent_request = parent_request self._attributes = {} self.request_depth = request_depth self.current_csource = None self.starttime = time.time() self.comphash = {} self.compcaches = {} self.request_path = request_path self.resolver_context = resolver_context if parent_request is not None: self.root_request = parent_request.root_request self.declined_components = parent_request.declined_components self.dhandler_path = parent_request.dhandler_path else: self.declined_components = {} self.root_request = self self.dhandler_path = None if request_impl: self.request_impl = request_impl else: self.request_impl = DefaultRequestImpl(**params) self.buffer = None self.__output_encoding = output_encoding, encoding_errors self.disable_unicode = bool(disable_unicode) notes = property(lambda self: self.attributes, doc="""A synonym for m.attributes""") root_request_path = property(lambda self:self.root_request.request_path, doc="""\ The URI sent to the ultimate root request of this Request. """) root_request_args = property(lambda self:self.root_request.request_args, doc="""\ The request argument dictionary sent to the ultimate root request of this Request. """) def _parentattr(self): if self.parent_request is not None: return self.parent_request.attributes else: return None attributes = property(lambda self:InheritedDict(self._attributes, lambda: self._parentattr()), doc="""\ A dictionary where arbitrary attributes can be stored and retrieved. Inherits data from its parent request, if any. """) def is_subrequest(self): """returns True if this request is a subrequest.""" return self.parent_request is not None def clone(self, **params): """creates a copy of this Request. Normally used to create subrequests.""" if not params.has_key('request_impl'): params['request_impl'] = self.request_impl.clone(**params) clone = ConstructorClone(self, **params) return clone.clone() class StackFrame: """data object representing the currently executing component context. gets pushed and popped to/from the execution_stack instance variable. """ def __init__(self, request, component, args, base_component, content, is_call_self): self.component = component self.args = args self.base_component = base_component self.content = content self.is_call_self = is_call_self self.content_args = None # set up an indirect filter function that is passed to output # buffers, etc. allows the filtering function can be dynamically # reset to a no-op, in the case that the component calls call_self # or cache_self, which should disable the final output filtering if isinstance(component, myghty.component.Component) and component.has_filter(): def filt(f): return component.filter(f, m = request, ARGS = args, **request.global_args) self._filter = filt self.filter = lambda f: self._filter(f) def reset_filter(self): self._filter = lambda f: f def out(self, string): """a synonym for write""" self.write(string) def write(self, string): """writes textual content to the current output buffer.""" self.buffer.write(string) def flush_buffer(self): """flushes the current output buffer to its destination.""" self.buffer.flush() def clear_buffer(self): """clears all content from the current output buffer.""" self.buffer.clear() def execute(self): """executes this request after constructed. This is the first method called, and can only be called once per request.""" if self.executed: self._raise_error("Can only call execute() once per request") self.executed = True if reqinstance.exists(): existing_request = reqinstance.get() else: existing_request = None reqinstance.put(self) # Divert python warnings to log file saved_showwarning = warnings.showwarning warnings.showwarning = self.__showwarning if self.parent_request is None \ or isinstance(self.request_impl, CapturingRequestImpl): # top-level request (or subrequest with output captured to # out_buffer): set up buffer if self.disable_unicode: self.buffer = StrRequestBuffer(self.request_impl.buffer) else: self.buffer = UnicodeRequestBuffer(self.request_impl.buffer, self.output_encoding, self.encoding_errors) else: # use parent's request buffer self.buffer = self.parent_request.buffer self.out = self.write = self.buffer.write # optimization self.request_args = self.request_impl.request_args self.global_args = self.request_impl.global_args [self.global_args.setdefault(k, v) for k,v in self.interpreter.global_args.iteritems()] [self.global_args.setdefault(k, None) for k in self.interpreter.compiler().allow_globals] component = self.component # current request-clearing try/finally try: # exception handling try/except try: if type(component) == types.StringType: component = self.fetch_lead_component(component) elif component.is_file_component(): self.request_path = component.path self.request_component = component depth = 0 self.wrapper_chain = [] while (component): self.wrapper_chain.append(component) if not component.is_file: break component = component.parent_component depth += 1 if depth >= self.max_recursion: self._raise_error("Max %d levels deep in determining inheritance chain (recursive inheritance pattern?)" % depth); if self.disable_wrapping: first_component = self.wrapper_chain[0] else: first_component = self.wrapper_chain[-1] result = None try: result = self.execute_component(first_component, base_component = self.request_component, args = self.request_args) except exception.Abort: raise except exception.Decline, d: result = d.declined_value except exception.AbortRequest: pass return result except exception.Redirected, e: self.request_impl.send_redirect(e.path) except exception.Abort, e: self.request_impl.send_abort(e.aborted_value, e.reason) except exception.Error, e: error = e except Exception, e: error = exception.Error(wrapped = e) except: e = sys.exc_info()[0] error = exception.Error(wrapped = e) if error: error.initTraceback(self.interpreter) if self.parent_request is not None: raise error else: if self.raise_error: raise error else: self.request_impl.handle_error(error, self) finally: # before we leave the execute method, remove all # buffers and restore the request threadlocal del self.write, self.out self.buffer = None warnings.showwarning = saved_showwarning if existing_request: reqinstance.put(existing_request) else: reqinstance.remove() def comp(self, component, **params): """component calling method which takes a simple parameter list. this method is meant to be the default method to call when calling components programmatically. compare to scomp().""" return self.execute_component(component = component, args = params) def scomp(self, component, **params): """component calling method which returns output as a string""" self.buffer.push_capture_buffer() self.execute_component(component = component, args = params, store = None) return self.buffer.pop_capture_buffer().getvalue() def subexec(self, component, **params): """creates a subrequest with the given component and request parameters and executes it. see create_subrequest().""" self.make_subrequest(component, **params).execute() def execute_component(self, component, args = {}, base_component = None, content = None, store = None, is_call_self = False): """component calling method which takes parameter list as a dictionary, and allows special execution options. This method is used by component call tags and internally within the Request object.""" path = None if type(component) == types.StringType: path = component component = self.fetch_component(path) if self.depth >= self.max_recursion: self._raise_error("%d levels deep in component stack (infinite recursive call?)" % self.depth) # if base component was set, use that # otherwise, figure it out if not base_component: # however, for method and file components, we might have to figure # the appropriate base class if there is a colon in the path if ( (component.is_method_component() or not component.is_sub_component()) and path and not component.is_module_component() and not re.match(r"(?:SELF|PARENT|REQUEST)(?:\:..*)?$", path)): match = re.match(r"(.*):", path) if match: base_component = self.fetch_component(match.group(1)) else: base_component = component if base_component.is_sub_component(): base_component = base_component.owner elif len(self.execution_stack): # base_component defaults to that of the top of the execution stack base_component = self.execution_stack[-1].base_component frame = Request.StackFrame(self, component, args, base_component, content, is_call_self) self.execution_stack.append(frame) initial_buffer_state = self.buffer.get_state() # if they requested to store the output, push that buffer onto the stack if store: self.buffer.push_capture_buffer(store) if component.has_filter(): self.buffer.push_filter(frame.filter) # Figure out if buffering is needed. do_auto_flush = component.use_auto_flush() if component.has_filter(): # If filtering, auto_flush defaults to False if do_auto_flush is None or self.dont_auto_flush_filters: do_auto_flush = False # If this is the top-level component, auto_flush defaults to config val if do_auto_flush is None and len(self.execution_stack) == 1: do_auto_flush = self.auto_flush if not do_auto_flush: self.buffer.push_buffer() discard_buffered_output = True try: if component.flags.setdefault('use_cache', False): retval = value() if self.cache_self(retval = retval, **component.flags): discard_buffered_output = False return retval() result = component.run(self, **args) discard_buffered_output = False finally: self.execution_stack.pop() # Warning: pop_to_state can raise UnicodeError self.buffer.pop_to_state(initial_buffer_state, discard=discard_buffered_output) return result def fetch_lead_component(self, path): """fetches the top level (initial) component to be executed by this request. Differs from fetch_component in that the resolver context is "request" or "subrequest" and the dhandler flag is enabled when resolving. Also does not support method calls. """ path = re.sub(r"/+", "/", path) request_path = path try: resolution = self.interpreter.resolve_component(path, resolver_context = self.resolver_context, enable_dhandler = self.use_dhandlers, declined_components = self.declined_components) except exception.ComponentNotFound, cfound: raise cfound.create_toplevel() # set up a pointer to the current component source, in case # the initialization of this component wants to do a fetch_component csource = resolution.csource self.current_csource = csource self.resolution = resolution component = self.interpreter.load_component(csource) if hasattr(resolution, 'dhandler_path'): self.dhandler_path = resolution.dhandler_path if self.request_path is None: self.request_path = request_path return component def fetch_component(self, path, resolver_context = 'component', **params): """ Given a component path (absolute or relative), returns a component. Handles SELF, PARENT, REQUEST, comp:method, relative->absolute conversion, MODULE, and local subcomponents. """ hascolon = (string.find(path, ':') != -1) if not hascolon: if path == 'SELF': return self.base_component elif path == 'PARENT': comp = self.current_component.parent_component if not comp: self._raise_error("PARENT designator used from component with no parent") else: return comp elif path == 'REQUEST': return self.request_component elif path == 'MODULE': self._raise_error("MODULE designator requires module name") if self.has_current_component(): if hascolon: (owner_path, argument) = re.split(':', path, 1) if owner_path == 'MODULE': return self.fetch_module_component(argument, **params) elif owner_path[0]=='@': return self.fetch_module_component(path[1:], **params) owner_component = self.fetch_component(owner_path, resolver_context = resolver_context, **params) method_component = owner_component.locate_inherited_method(argument) return method_component if not hascolon: subcomp = self.current_component.get_sub_component(path) if subcomp: return subcomp # adjust requested path to the path of the current component path = unixpath.join(self.current_component.dir_name, path) else: # no current component. current csource ? if self.current_csource is not None: path = unixpath.join(self.current_csource.dir_name, path) return self.load_component(path, resolver_context = resolver_context, **params) def fetch_module_component(self, moduleorpath, classname = None, raise_error = True): """fetches a module-based component. Usually called by fetch_component when the 'MODULE' keyword is given as a prefix. """ module = None modulename = None if type(moduleorpath) == types.StringType: if classname is None: (modulename, classname) = moduleorpath.split(':') else: modulename = moduleorpath else: module = moduleorpath modulename = moduleorpath.__name__ if classname is None: self._raise_error("classname is required with component module") key = "module:" + modulename + ":" + classname if self.comphash.has_key(key): return self.comphash[key] component = self.interpreter.load_module_component(arg = modulename + ":" + classname) self.comphash[key] = component if raise_error and component is None: raise exception.ComponentNotFound("Cant locate component %s" % key) return component def load_component(self, path, raise_error = True, resolver_context = None, **params): """a mirror of interpreter.load() which caches its results in a request-local dictionary, thereby bypassing all the filesystem checks that interp does for a repeated file-based request.""" # since different contexts can come in here, cache based on that key as well # technically, all the other context-specific stuff, like dhandler, search upwards # etc., should be built into the key as well key = "%s_%s" % (str(resolver_context), path) if self.comphash.has_key(key): # get the component from the hash...might be None component = self.comphash[key] else: component = self.interpreter.load(path, raise_error = raise_error, resolver_context = resolver_context, **params) self.comphash[key] = component if raise_error and component is None: raise exception.ComponentNotFound("Cant locate component %s" % path) return component def make_subrequest(self, component, **params): """creates a subrequest with the given component and request parameters. see create_subrequest().""" return self.create_subrequest(component, request_args = params) def create_subrequest(self, component, resolver_context = 'subrequest', **params): """base subrequest-creation method. A subrequest is a request that is a child to this one, enabling execution of a component and its full inheritance chain within this request.""" if type(component) == types.StringType and self.has_current_component(): component = unixpath.join(self.current_component.dir_name, component) params['component'] = component params['parent_request'] = self if params.get('out_buffer'): params['request_impl'] = CapturingRequestImpl(self.request_impl, **params) params.setdefault('output_encoding', DEFAULT_OUTPUT_ENCODING) params.setdefault('encoding_errors', DEFAULT_ENCODING_ERRORS) request = self.clone(resolver_context = resolver_context, **params) request.request_depth = self.request_depth + 1 if request.request_depth > self.max_recursion: raise exception.Error("recursion limit exceeded") return request def cache(self, **params): """a synonym for get_cache().""" return self.get_cache(**params) def get_cache(self, component = None, **params): """returns the given component's cache. **params is a dictionary of options used as the default options for individually cached elements.""" if component is None: component = self.current_comp() elif type(component) == types.StringType: component = self.fetch_component(component) if not self.compcaches.has_key(component.id): self.compcaches[component.id] = self.interpreter.cache_args.get_cache(component = component, starttime = component.creationtime, **params) return self.compcaches[component.id] def cache_self(self, key = '_self', component = None, retval = None, **params): """caches this component's output. this is called in a "reentrant" fashion; if it returns False, component execution should continue. If it returns True, component execution should cease.""" cache = self.get_cache(component = component, **params) def getself(): rv = value() buf = StringIO.StringIO() ret = self.call_self(buf, rv) if not ret: raise CreationAbortedError() else: return (buf, rv()) try: (buf, ret) = cache.get_value(key, cache_createfunc = getself) if retval is not None: retval.assign(ret) # turn off output filtering for the currently # executing stack frame self.execution_stack[-1].reset_filter() self.buffer.write(buf.getvalue()) return True except CreationAbortedError: return False def call_self(self, output_buffer, return_buffer): """calls this component and places its output and return value in the given buffers. This component is called in a "reentrant" fashion, where a return value of False means to continue component execution and a return value of True means to halt execution and return. """ if self.execution_stack[-1].is_call_self: return False # turn off output filtering for the currently # executing stack frame self.execution_stack[-1].reset_filter() result = self.execute_component(self.current_component, args = self.component_args, store = output_buffer, is_call_self = True) return_buffer.assign(result) return True def get_session(self, *args, **params): """returns the Session object used by this request. If the session has not been created it will be created when this method is called. Once the session is created, this method will return the same session object repeatedly. **params is a dictionary of options used when the session is first constructed; if it already exists, the parameters are ignored.""" return self.request_impl.get_session(*args, **params) def has_current_component(self): """returns if this request has a currently executing component. This could return false if the request's top-level-component is in the loading stage.""" return len(self.execution_stack) > 0 def component_exists(self, path, **params): """returns True if the given component path exists.""" return self.interpreter.component_exists(path, **params) def apply_escapes(self, text, escapes): """applies the given escape flags to the given text. escapes is a list of escape flags, such as 'h', 'u', and 'x'.""" # XXX: If you change this string coercion code, you should also # make matching changes to {Unicode,Str}RequestBuffer.write() if text is None: text = '' elif self.disable_unicode: text = str(text) else: text = unicode(text) esctable = self.interpreter.escapes try: escfuncs = [ esctable[esc] for esc in escapes ] except KeyError, k: self._raise_error("no such escape '%s'" % k) for f in escfuncs: text = f(text) return text def _get_status(self): """debugging method that returns the current execution stack entry""" return ("Base Comp: %s\n_request Comp: %s\n_current Comp: %s\n" % (self.base_component.id, self.request_component.id, self.current_component.id())) def abort(self, status_code=None, reason=None): """raises an abort exception. """ if status_code is None: raise exception.AbortRequest() else: raise exception.Abort(aborted_value=status_code, reason=reason) def decline(self, returnval = None): """used by dhandlers to decline handling the current request. Control will be passed to the next enclosing dhandler, or if none is found a ComponentNotFound (and possibly 404 error) is raised.""" self.buffer.clear() subreq = self.make_subrequest(component=self.request_path, request_args = self.request_args) subreq.declined_components[self.request_component.id] = self.request_component ret = subreq.execute() raise exception.Decline(declined_value = ret) def callers(self, index = None): """returns the list of components in the current call stack. if an integer index is given, returns the component at that position in the current call stack.""" if index is None: return map(lambda f: f.component, self.execution_stack) else: return self.execution_stack[index].component def caller_args(self, index = None): """returns the list of component arguments in the current call stack. if an integer index is given, returns the component arguments at that position in the current call stack.""" if index is None: return map(lambda f: f.args, self.execution_stack) else: return self.execution_stack[index].args def call_stack(self, index = None): """returns the current execution stack, which consists of StackFrame objects. if an integer index is given, returns the StackFrame object at that position in the current call stack.""" if index is None: return self.execution_stack else: return self.execution_stack[index] def call_next(self, **params): """used within an inheritance chain to call the next component in the chain. If **params are given, each parameter will override the arguments sent to this component when calling the next component.""" comp = self.fetch_next() args = {} args.update(self.request_args) args.update(params) return self.comp(comp, **args) def fetch_next(self): """in an inheritance chain (i.e. of autohandlers), returns the next component in the chain""" try: self.wrapper_chain.pop() return self.wrapper_chain[-1] except IndexError: self._raise_error("No component available for fetch_next()") def fetch_all(self): """pops off the entire remaining list of components in the inheritance chain.""" ret = [] while len(self.wrapper_chain): ret.append(self.wrapper_chain.pop()) return ret def send_redirect(self, path, hard=True): """sends a redirect to the given path. If hard is True, sends an HTTP 302 redirect via the underlying RequestImpl being used. If False, clears out the current output buffer and executes a subrequest with the given path. The path can also contain url encoded query string arguments with a question mark which will be converted to key/value arguments for the next request, even if hard=False.""" if hard: raise exception.Redirected(path) else: if re.search(r'\?', path): (path, query) = path.split('?') args = dict([(escapes.url_unescape(m.group(1)), escapes.url_unescape(m.group(2))) for m in re.finditer(r'([^=&]*)=([^=&]*)', query)]) else: args = {} self.buffer.clear() req = self.create_subrequest(path, resolver_context = self.resolver_context, request_args = args) req.execute() self.buffer.flush() raise exception.AbortRequest() def has_content(self): """returns whether or not the current component call was called with captured content specified""" return self.execution_stack[-1].content != None def call_content(self, **kwargs): """calls the "captured content" function within a component call with content""" if not self.execution_stack[-1].content: return frame = self.execution_stack.pop() try: self.execution_stack[-1].content_args = kwargs frame.content() finally: self.execution_stack[-1].content_args = None self.execution_stack.append(frame) def content(self, **kwargs): """when inside a component call with content, this method calls the "captured content" function and buffers the content, returning the string value.""" self.buffer.push_capture_buffer() try: self.call_content(**kwargs) finally: buffer = self.buffer.pop_capture_buffer() return buffer.getvalue() def closure_with_content(self, func, content=None, args=None): """given a function, will execute it with the given arguments, after pushing the given content function onto the call stack via a new StackFrame, enabling the function to call it via the content() method.""" frame = Request.StackFrame(self, func, args, self.base_component, content, False) if args is None: args = {} self.execution_stack.append(frame) try: func(**args) finally: self.execution_stack.pop() def _raise_error(self, error): self.interpreter.raise_error(error) def log(self, message): """writes a message to the request log. The log is RequestImpl-specific and can be standard error, a webserver error log, or a user-defined file object.""" self.request_impl.log(message) def __showwarning(self, message, category, filename, lineno): """A custom warnings handler. """ interpreter = self.interpreter try: # Try to map (filename, lineno) back to original try: comprec = interpreter.reverse_lookup[filename] except KeyError: comprec = interpreter.reverse_lookup['memory:' + filename] reversefile = exception.Error.ReverseFile(interpreter, comprec) csource = comprec.csource filename, lineno = \ csource.file_path, reversefile.get_line_number(lineno) except: pass mesg = warnings.formatwarning(message, category, filename, lineno) if mesg.endswith('\n'): mesg = mesg[:-1] self.log(mesg) # property accessors logger = property(lambda self: _Logger(self), doc="""\ returns the logger for this Request, which is a file-like object. """) depth = property(lambda self: len(self.execution_stack), doc="""\ Returns the current depth of the execution stack. """) base_component = property(lambda self: self.execution_stack[-1].base_component, doc="""\ Returns the "base component" for the current stack frame, which is either the top level component or the owning component of a method component. """) component_args = property(lambda self: self.execution_stack[-1].args, doc="""\ returns the argument dictionary from the current stack frame, corresponding to the arguments sent to the currently executing component. """) content_args = property(lambda self:self.execution_stack[-1].content_args, doc="""\ returns the component-call-with-content argument dictionary from the current stack frame, corresponding to the arguments sent in an m.content() call. """) caller = property(lambda self: self.execution_stack[-2].component, doc="""\ returns the calling component for the currently executing component. """) dhandler_argument = property(lambda self: self.dhandler_path, doc="""\ returns the current dhandler_argument, which corresopnds to the remaining path tokens in the request URI when executing a dhandler. """) current_component = property(lambda self: self.execution_stack[-1].component, doc="""\ returns the component currently executing from the current stack frame. """) def get_output_encoding(self): if self.buffer: return self.buffer.encoding else: return self.__output_encoding[0] output_encoding = property( get_output_encoding, doc="""The ouput encoding for the request This is the encoding of the output written to the output buffer of the top-level request. (I.e. the encoding delivered to the user.) This is a read-only attribute, though you can change its value using the `set_output_encoding`_ method. """) def get_encoding_errors(self): if self.buffer: return self.buffer.errors else: return self.__output_encoding[1] encoding_errors = property( get_encoding_errors, doc="""The encoding error handling strategy for the request This is the error handling strategy used when encoding text writtent to the output buffer of the top-level request. This is a read-only attribute, though you can change its value using the `set_output_encoding`_ method. """) def set_output_encoding(self, encoding, errors='strict'): """Change the output_encoding. Note that in most cases you do not want to change it after you have written any output (as then your output will be in two different encodings --- probably not what you wanted unless, perhaps, you are generating Mime multipart output.) """ if self.buffer: self.buffer.set_encoding(encoding, errors) self.__output_encoding = self.buffer.encoding, self.buffer.errors else: self.__output_encoding = encoding, errors # deprecated getter methods ! def get_attribute(self, key): """deprecated. use the attributes property.""" return self.notes(key) def set_attribute(self, key, value): """deprecated. use the attributes property.""" self.notes(key, value) def get_attributes(self): """deprecated. use the attributes property.""" return self.notes def get_depth(self): """deprecated. use the depth property.""" return self.depth def get_log(self): """deprecated. use the logger property.""" return self.logger def get_start_time(self): """deprecated. use the starttime property.""" return self.starttime def get_request_args(self): """deprecated. use the request_args property.""" return self.request_args def get_base_component(self): """deprecated. use the base_component property.""" return self.base_component def base_comp(self): """deprecated. use the base_component property.""" return self.base_component def get_request_component(self): """deprecated. use the request_component property.""" return self.request_component def request_comp(self): """deprecated. use the request_component property.""" return self.request_component def get_component_args(self): """deprecated. use the component_args property.""" return self.component_args def get_dhandler_argument(self): """deprecated. use the request_path or dhandler_argument property.""" return self.request_path def dhandler_arg(self): """deprecated. use the request_path or dhandler_argument property.""" return self.request_path def get_request_path(self): """deprecated. use the request_path property.""" return self.request_path def get_interpreter(self): """deprecated. use the interpreter property.""" return self.interpreter def get_current_component(self): """deprecated. use the current_component property.""" return self.current_component def current_comp(self): """deprecated. use the current_component property.""" return self.current_component def instance(): """returns the Request instance corresponding to the current thread""" return reqinstance.get() def threadlocal(value = None): """returns a thread local container, with initial value that of the given variable""" return ThreadLocal(value) def value(value = None): """returns a value container object. useful for mutating data that was instantiated in a requestonce or shared block""" return Value(value) class AbstractRequestImpl(object): def clone(self):raise NotImplementedError() def handle_error(self, e, m, **params):raise NotImplementedError() def get_session(self, **params):raise NotImplementedError() def send_redirect(self, path):raise NotImplementedError() def send_abort(self, ret, reason):raise NotImplementedError() def log(self, message):raise NotImplementedError() def _run_error_handler(self, handler, logger, error, m, **params): err = None try: if handler: return handler(error, m, **params) except exception.Error, e: err = e except Exception, e: err = exception.Error(wrapped = e) except: e = sys.exc_info()[0] err = exception.Error(wrapped = e) if err: err.initTraceback(m.interpreter) logger.write("Custom error handler had an error:") logger.writelines(string.split(err.format(), "\n")) return False def __init__(self): self.global_args = None self.request_args = None self.logger = None self.buffer = None self.request = None class DefaultRequestImpl(AbstractRequestImpl): def __init__(self, out_buffer = None, global_args = None, request_args = None, error_handler = None, **params): if out_buffer: self.out_buffer = out_buffer else: self.out_buffer = sys.__stdout__ self.error_handler = error_handler if request_args is None: request_args = {} self.request_args = request_args if global_args is None: self.global_args = {} else: # copy the global_args in case they are synonymous with those given to the # interpreter self.global_args = global_args.copy() self.logger = sys.stderr self.buffer = self.out_buffer def handle_error(self, error, m, **params): if self._run_error_handler(self.error_handler, self.logger, error, m, **params): return sys.stderr.write(error.format()) def log(self, message):self.logger.write(message + "\n") def clone(self, **params): cloner = ConstructorClone(self, **params) return cloner.clone() class _Logger: '''A file-like object which "writes" to an object ``log()`` method. ''' def __init__(self, impl): self.impl = impl def write(self, text): self.impl.log(text) def writelines(self, lines): for text in lines: self.write(text) class CapturingRequestImpl(AbstractRequestImpl): def __init__(self, parent_request_impl, out_buffer, request_args=None, global_args=None, error_handler=None, **params): self.buffer = self.out_buffer = out_buffer self.parent_request_impl = parent_request_impl if request_args is None: request_args = parent_request_impl.request_args.copy() self.request_args = request_args # XXX: No .copy() here, subrequest can change parent requests # global_args. Is that correct? if global_args is None: global_args = parent_request_impl.global_args self.global_args = global_args self.error_handler = error_handler logger = property(lambda self: _Logger(self)) def handle_error(self, error, m, **params): if self.error_handler: self._run_error_handler(self.error_handler, self.logger, error, m, **params) else: self.parent_request_impl.handle_error(error, m, **params) def log(self, message): self.parent_request_impl.log(message)