# $Id: component.py 2133 2006-09-06 18:52:56Z dairiki $ # component.py - component base classes for Myghty # 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 component package defines the Component class and several subclasses. FileComponent serves as the base class for template style-components, and ModuleComponent the base for module-based components.""" from myghty import exception from myghty.util import * from myghty.args import * import myghty.request import myghty.csource import weakref, string import posixpath as unixpath import sys, inspect, types __all__ = ['Component', 'ModuleComponent', 'HTTPModuleComponent', 'FileComponent', 'SubComponent'] argtypes = ( (RequestArg, True, 'required_request_args'), (RequestArg, False, 'request_args'), (SubRequestArg, True, 'required_subrequest_args'), (SubRequestArg, False, 'subrequest_args'), (LocalArg, True, 'required_args'), (LocalArg, False, 'args'), (DynamicArg, True, 'required_dynamic_args'), (DynamicArg, False, 'dynamic_args'), ) class Component(object): """Base class for all components. the primary method is the run() method which executes the Component in the context of a particular request. A Component instance is usually cached in memory based on its component ID and can execute many requests simultaneously.""" def __init__(self, interpreter, component_source, **params): """initializes a new Component. this method is called by the Interpreter.""" self.filter = None self.owner = self.parent_component = None self.flags = {} self.attr = {} self.arguments = [] self.component_source = component_source self.is_method = self.is_file = self.is_subcomponent = self.is_module = False self.size = 0 self.use_count = 0 self.interpreter = interpreter self.threads_init = ThreadLocal() id = property(lambda self: self.component_source.id, doc="unique identifier for this component") source_id = property(lambda self: self.component_source.id, doc="unique identifier for the ComponentSource of this component") name = property(lambda self: self.component_source.name, doc="name of this component") dir_name = property(lambda self: self.component_source.dir_name, doc="relative directory name of the component") path = property(lambda self: self.component_source.path, doc="relative full path of the component") file = property(lambda self: self.component_source.file_path, doc="the actual filename of the component, if one exists") def _parentattr(self): if self.parent_component is not None: return self.parent_component.attributes else: return None attributes = property(lambda self: InheritedDict(self.attr, lambda: self._parentattr())) def component_init(self): """initializes the component after construction. Calls the do_component_init() method before setting up the component's arguments.""" self.do_component_init() self._convert_component_args() def _convert_component_args(self): # the args system has been overhauled to be just a list of # ComponentArgs objects, which come straight from the compiled # component file. # but try to do some compatibility, for older compiled components # and module components that have all the separate ***_args arrays # attached to them. we generate the _args if it doesnt exist, # and then recreate the ***_args arrays in all cases. for argtype in argtypes: self.arguments += [argtype[0](arg, argtype[1]) for arg in getattr(self, argtype[2], [])] # TODO: try to use property() for this setattr(self, argtype[2], [arg.name for arg in self.arguments if arg.__class__ == argtype[0] and arg.required == argtype[1]]) def do_component_init(self): """overridden by subclasses to perform per-instance initialization steps.""" raise NotImplementedError() def run(self, request, **params): """runs this component in the context of the given request. **params are the arguments sent to the component, which become ARGS in the context of the component's runtime environment.""" self.use_count += 1 compparams = {} for arg in self.arguments: arg.get_arg(request, compparams, **params) compparams.update(request.global_args) if not self.threads_init.exists(): self.do_thread_init() self.threads_init.assign(True) return self.do_run_component(m = request, ARGS = params, **compparams) def has_filter(self): """returns True if this component defines a <%filter> section.""" return self.filter != None def _init_filter_func(self, d = None): if self.flags.has_key('trim'): # the 'trim' flag implies that the component is # buffered as well self.flags['autoflush'] = False try: func = {'left':string.lstrip, 'right':string.rstrip, 'both':string.strip}[self.flags['trim']] if d is not None: return lambda f, **kwargs: d(func(f), **kwargs) else: return lambda f, **kwargs: func(f) except KeyError, e: raise exception.Interpreter("invalid 'trim' argument '%s'" % e) elif d is not None: return d def get_flag(self, key, inherit = False): """returns a flag defines in this component's <%flags> section.""" if self.flags.has_key(key): return self.flags[key] elif inherit: parent = self.parent_component if parent is not None: return parent.get_flag(key, True) return None def get_sub_component(self, name): """returns a SubComponent of the given name, represented within the source of this Component.""" return None def do_run_component(self, m, ARGS, **params): """overridden by subclasses to provide the main execution body of the component.""" raise NotImplementedError() def do_thread_init(self): """overridden by subclasses to provide a per-thread initialization routine.""" pass def locate_inherited_method(self, method_name): """returns a method SubComponent of the given name, represented either within the source of this Component or within the source of an inherited Component, i.e. the inheritance hierarchy will be searched for the approrpriate method call.""" raise NotImplementedError() def call_method(self, method_name, **params): """calls a method SubComponent of the given name on this component. This amounts to locating it via locate_inherited_method, retrieving the current request via request.instance(), and then calling execute_component on that request. See also m.comp("component:methodname") """ method_component = self.locate_inherited_method(method_name) return myghty.request.instance().execute_component(method_component, args = params, base_component = self) def scall_method(self, method_name, **params): """same as call_method, but returns the component output as a string See also m.scomp("component:methodname") """ method_component = self.locate_inherited_method(method_name) buffer = StringIO() myghty.request.instance().execute_component(method_component, args = params, base_component = self, store = buffer) return buffer.getvalue() def use_auto_flush(self): """returns True if this component defines the "autoflush" flag as True, or if an inherited component defines this flag.""" return self.get_flag('autoflush', inherit = True) # these are all deprecated def get_attribute(self, key, inherit = True): return self.attributes(key) def set_attribute(self, key, value): self.attributes(key, value) def get_attributes(self): return self.attributes def attribute_exists(self, key): return self.attributes.has_key(key) def get_owner(self): return self.owner def get_parent_component(self): return self.parent_component def get_id(self): return self.id def get_name(self): return self.name def get_source_id(self): return self.source_id def get_file(self): return self.file def get_path(self): return self.path def get_dir_name(self): return self.dir_name def is_method_component(self): return self.is_method def is_module_component(self): return self.is_module def is_file_component(self): return self.is_file def is_sub_component(self): return self.is_subcomponent class FileComponent(Component): "a component that corresponds to a Myghty template file" def __init__(self, interpreter, component_source, **params): Component.__init__(self, interpreter, component_source, **params) self.defs = None self.methods = None self.inherit_path = None self.inherit_start_path = None self.is_file = True self.size = component_source.modulesize self.component_init() if self.uses_thread_local(): self.thread_local = ThreadLocal(creator = self.thread_local_initializer) if self.uses_request_local(): self.request_local = weakref.WeakKeyDictionary() self.subcomponents = self.defs.copy() self.subcomponents.update(self.methods) self._determine_inheritance() def uses_thread_local(self):raise NotImplementedError() def uses_request_local(self):raise NotImplementedError() def is_file_component(self):return True def get_sub_component(self, name): if self.subcomponents.has_key(name): return self.subcomponents[name] else: return None def _call_dynamic(self, key, m, ARGS, **params): """handles components with %threadlocal and/or %requestlocal sections""" context = None if self.uses_thread_local(): if self.uses_request_local(): if self.request_local.has_key(m): context = self.request_local[m] else: initializer = self.thread_local.get(self, m, ARGS, **params) context = initializer(self, m, ARGS, **params) self.request_local[m] = context else: context = self.thread_local.get(self, m, ARGS, **params) elif self.uses_request_local(): if self.request_local.has_key(m): context = self.request_local[m] else: context = self.request_local_initializer(self, m, ARGS, **params) self.request_local[m] = context if context is None: raise exception.Error("dynamic method context not found") else: return context[key](m, ARGS, **params) def locate_inherited_method(self, method_name): component = self while component: if component.methods.has_key(method_name): return component.methods[method_name] component = component.parent_component raise exception.MethodNotFound("no such method '%s' found" % method_name) def _determine_inheritance(self): interpreter = self.interpreter source = self.component_source if self.flags.has_key('inherit'): if self.flags['inherit'] is None: pass else: self.inherit_path = unixpath.normpath(unixpath.join(source.dir_name, self.flags['inherit'])) elif interpreter.use_auto_handlers: if source.name == interpreter.auto_handler_name: if source.dir_name and source.dir_name != '/': self.inherit_start_path = unixpath.dirname(source.dir_name) else: # we are the autohandler in the root directory pass else: self.inherit_start_path = self.component_source.dir_name def _parent_component(self): """returns the parent component of this component, taking into account the component's inherit flag as well as the interpreter's autohandler properties""" try: request = myghty.request.instance() # optional - cache results of this function on the request #try: # return request.attributes['_parent_comp_%s' % self.id] #except KeyError: pass except KeyError: # no current request for whatever reason, so call # load() off the interpreter request = None if self.inherit_path is not None: if request is not None: component = request.load_component(self.inherit_path, resolver_context = 'inherit') else: component = self.interpreter.load(self.inherit_path, resolver_context = 'inherit') elif self.inherit_start_path is not None: if request is not None: component = request.load_component(unixpath.join(self.inherit_start_path, self.interpreter.auto_handler_name), search_upwards = True, raise_error = False, resolver_context = 'inherit') else: component = self.interpreter.load(unixpath.join(self.inherit_start_path, self.interpreter.auto_handler_name), search_upwards = True, raise_error = False, resolver_context = 'inherit') else: component = None #if request is not None: # request.attributes['_parent_comp_%s' % self.id] = component return component parent_component = property(_parent_component, lambda s, p: None) class SubComponent(Component): """a component that corresponds to a <%def> or <%method> tag inside a file-based component.""" def __init__(self, name, owner, is_method, **params): Component.__init__(self, owner.interpreter, owner.component_source, **params) self.__name = name self.__owner = owner self.is_method = is_method self.is_subcomponent = True self.component_init() def _call_dynamic(self, key, m, ARGS, **params): return self.owner._call_dynamic(key, m, ARGS, **params) id = property(lambda self: self.owner.id + ":" + self.name) parent_component = property(lambda self: self.owner.parent_component, lambda s, p:None) name = property(lambda self: self.__name, lambda s,p:None) owner = property(lambda self: self.__owner, lambda s,p:None) def get_sub_component(self, name):return self.owner.get_sub_component(name) def locate_inherited_method(self, method_name):return self.owner.locate_inherited_method(method_name) def call_method(self, *args, **params):return self.owner.call_method(*args, **params) def scall_method(self, *args, **params):return self.owner.scall_method(*args, **params) class ModuleComponent(Component): """A component that is a regular Python class inside of a plain Python module.""" def __init__(self, interp, component_source, owner = None, do_init = True): Component.__init__(self, interp, component_source) self.__name = self.__class__.__name__ self.is_method = True self.creationtime = component_source.last_modified self.methods = Registry() if owner is None: self.__owner = self else: self.__owner = owner if do_init: self.component_init() owner = property(lambda self: self.__owner, lambda s, p:None) name = property(lambda self: self.__name, lambda s, p:None) def _inspect_args(self, function): csource = self.component_source argspec = inspect.getargspec(function) argnames = argspec[0] or [] defaultvalues = argspec[3] or [] d = dict([(a, True) for a in self.interpreter.compiler().allow_globals + ['m', 'ARGS', 'self']]) (self.required_args, self.args) = ( [a for a in argnames[0:len(argnames) - len(defaultvalues)] if not d.has_key(a)], [a for a in argnames[len(argnames) - len(defaultvalues):] if not d.has_key(a)] ) self._allargs = argnames self._has_params = argspec[2] is not None def component_init(self): self.do_component_init() # if no new-style argument list has been set up if len(self.arguments) == 0: # and no old-style argument lists have been added for argtype in argtypes: if hasattr(self, argtype[2]): break else: # then inspect the do_component_init function and figure out the args # that way. self._inspect_args(self.do_run_component.im_func) # tell base class to set up arguments list self._convert_component_args() def do_component_init(self):pass def do_run_component(self, m, ARGS, **params):raise NotImplementedError() def is_module_component(self):return True def _find_method(self, method_name): if self.__class__.__name__ == method_name: return self return self.interpreter.load_module_component(self.__module__ + ":" + method_name) def locate_inherited_method(self, method_name): if self.owner is self: return self.methods.get(method_name, createfunc = lambda: ModuleComponent._find_method(self, method_name)) else: return self.owner.locate_inherited_method(method_name) class HTTPModuleComponent(ModuleComponent): """A ModuleComponent that contains methods specific to a generic HTTP request.""" def do_post(self, m, r, **params): # 'method not allowed', unless this is overridden m.abort(405) def do_get(self, m, r, **params): # 'method not allowed', unless this is overridden m.abort(405) def do_run_component(self, m, r, **params): methods = { 'GET': HTTPModuleComponent.do_get, 'POST': HTTPModuleComponent.do_post, } try: f = methods[r.method] return f(self, m, r, **params) except KeyError: m.abort(405) class FunctionComponent(ModuleComponent): """a module component that "wraps" a regular Python function or method, including introspection of its signature to automatically produce the required_args and args lists """ def do_component_init(self): csource = self.component_source self._inspect_args(csource.callable_) # if we are linked to a method off of an object instance, # see if the object instance has a do_component_init method and if the object instance # does not have a _component_init attribute. call do_component_init() and # set the _component_init attribute to True if self.component_source.has_method: target = self.component_source.callable_.im_self if hasattr(target, 'do_component_init') and not hasattr(target, '_component_init'): try: getattr(target, 'do_component_init')(self) finally: target._component_init = True def do_run_component(self, **params): if self._has_params: return self.component_source.callable_(**params) else: d = {} for a in self._allargs: if params.has_key(a): d[a] = params[a] return self.component_source.callable_(**d) def get_method_csource(self, name): if not self.component_source.has_method: return None obj = self.component_source.callable_.im_self meth = getattr(obj, name) return myghty.csource.ModuleComponentSource(module=self.component_source.module, callable_=meth, name="method:" + meth.im_func.__name__) def get_method(self, m, name): cs = self.get_method_csource(name) return m.interpreter.load_component(cs)