def __importPlugin(self,file):
target = self.__searchPlugin(file)
if target:
directory = os.path.dirname(target)
name = os.path.splitext(os.path.basename(target))[0]
return vampire.importModule(name,directory,self.req)
def handler_html(req):
directory, name = os.path.split(os.path.splitext(req.filename)[0])
module = vampire.importModule(name, directory)
if not hasattr(module, "Servlet"):
return apache.HTTP_NOT_FOUND
_servlet = module.Servlet()
_servlet.req = req
try:
_servlet.auth()
_servlet.prep()
if not _servlet.respond():
return apache.HTTP_NO_CONTENT
_servlet.wrapup()
finally:
_servlet._finally()
return apache.OK
import vampire
import sys
config = vampire.loadConfig(__req__, ".vampire")
layouts = config.get("Handlers", "layouts_root")
layout = vampire.importModule("basic", layouts, __req__)
class Template(layout.Template):
no_cache = True
def renderTemplate(self):
def renderModule(node, label):
node.label.content = label
if hasattr(sys.modules[label], "__file__"):
node.path.content = sys.modules[label].__file__
keys = sys.modules.keys()
keys.sort()
self.template.module.repeat(renderModule, keys)
handler_html = vampire.Instance(Template)
import netsvc
import netsvc.client
import vampire
import os
# Import startup code for dispatcher to ensure it is
# initialised and connection to exchange is created.
_gateway = vampire.importModule("_gateway", None, __req__)
# Handler which will attempt to log all requests with
# the remote request database service.
def loghandler(req):
# Lookup the request logging service. Abort the
# search immediately if the service isn't already
# registered by specifying a zero length timeout.
registry = netsvc.client.Registry(timeout=0)
bindings = registry.locateService("apache-logger")
# Because we are logging requests, not serious that
# service couldn't be found. Just means details about
# requests for period service is not available will
# be lost.
if bindings != []:
# We don't want to hang around for the response
import vampire
import os
# Following determines if this is being run within the
# context of the parent web site, and if it is use the
# links from the parent web site as well as any which
# have been added here.
current = os.path.dirname(__file__)
parent = os.path.join(current, "../..")
_links = []
try:
module = vampire.importModule("_links", parent)
except OSError:
pass
else:
_links = list(module._links)
_package = []
if _links == []:
_package.append(("Home", "%(ose_home)s/index.html"))
#_package.append(("Articles","%(ose_home)s/articles.html"))
_package.append(("License", "%(ose_home)s/license.html"))
#_package.append(("Examples","%(ose_home)s/examples/index.html"))
_package.append(("Installation", "%(ose_home)s/install.html"))
#_package.append(("Changes","%(ose_home)s/changes.html"))
#_package.append(("TODO","%(ose_home)s/todo.html"))
def handler(req, **fields):
# We only want to treat request as being a possible
# request for a Cheetah generated template file if
# there exists both a ".tmpl" and ".py" file.
target = os.path.splitext(req.filename)[0]
target_tmpl = target + ".tmpl"
target_py = target + ".py"
if not os.path.exists(target_tmpl) and not os.path.exists(target_py):
return apache.DECLINED
# Grab the module name to look for from the last part
# of the path. This means that pages can be spread
# across subdirectories as well.
directory, module_name = os.path.split(target)
# Import the module. Any coding error in the module
# being imported is thrown back to the user. Error
# also results if by chance the target just vanished.
module = vampire.importModule(module_name, directory, req)
# Ensure that there is a class defined in the module
# of the appropriate name.
if not hasattr(module, module_name):
return apache.DECLINED
# Create instance of the class.
tmpl = getattr(module, module_name)()
# Cache any decoded form parameters in an obvious
# place so they are available. Note that the actual
# mod_python form object is also cached as "req.form"
# but the decoded form parameters would preferably be
# used. By default decoded form parameters follow
# structured naming convention supported by Vampire.
# If this naming convention isn't wanted, it would
# need to be disabled in the Apache configuration.
req.fields = fields
# Cache the Vampire configuration object in an obvious
# place as well. Use the same one as defined the
# default handlers which would have triggered use of
# this handler in the first place.
options = req.get_options()
file = ".vampire"
if options.has_key("VampireHandlersConfig"):
file = options["VampireHandlersConfig"]
config = vampire.loadConfig(req, file)
req.config = config
# Make request object available within the template.
tmpl.req = req
# Set type of content being returned if not set.
if not req._content_type_set:
req.content_type = "text/html"
# Now generate the actual content and return it.
req.send_http_header()
req.write(tmpl.respond())
return apache.OK
def browse(req, name="", object="", **kw):
if req.vampire["handler"] != "vampire::publisher":
return apache.HTTP_NOT_IMPLEMENTED
directory = '/'.join((len(req.path_info.split('/')) - 1) * [".."])
module = os.path.splitext(os.path.split(req.filename)[1])[0]
if not directory:
directory = '.'
action = "%s/%s/browse" % (directory, module)
rules = _publisher_rules
directory = os.path.dirname(req.filename)
try:
target = vampire.importModule(os.path.split(name)[1], directory)
except OSError:
value = os.path.split(req.uri)[0]
req.headers_out["location"] = "%s" % value
req.status = apache.HTTP_MOVED_TEMPORARILY
return apache.HTTP_NOT_FOUND
root = target
req.content_type = "text/html"
req.send_http_header()
req.write("<html><body>\n")
if object != "":
for element in object.split('/'):
target = getattr(target, element)
subobjects = dir(target)
subobjects.sort()
req.write("<table>\n")
for key in subobjects:
if object != "":
subobject = object + "/" + key
else:
subobject = key
req.write("<tr>\n")
req.write("<td>\n")
req.write("<p>\n")
req.write(cgi.escape(subobject))
req.write("</p>\n")
req.write("</td>\n")
subinstance = None
typestring = ""
if hasattr(target, key):
subinstance = getattr(target, key)
typestring = cgi.escape(str(type(subinstance)))
req.write("<td>\n")
req.write("<p>%s</p>\n" % typestring)
req.write("</td>\n")
parts = subobject.split('/')
status, traverse, execute, access, subinstance = _resolve(
req, root, parts, rules)
if not traverse and not execute and not access:
req.write("<td>\n")
req.write("DENY")
req.write("</td>\n")
req.write("<td>\n")
req.write("</td>\n")
else:
req.write("<td>\n")
if execute:
req.write("CALL")
else:
req.write("TYPE")
req.write("</td>\n")
req.write("<td>\n")
if traverse:
req.write(" ")
req.write("<a href='%s" % action)
req.write("?name=%s&object=%s'>" % (name, subobject))
req.write("BROWSE")
req.write("</a>")
if execute:
req.write(" ")
url = action + '/../' + subobject
req.write("<a href='%s'>" % url)
req.write("EXEC")
req.write("</a>")
if access:
req.write(" ")
url = action + '/../' + subobject
req.write("<a href='%s'>" % url)
req.write("VIEW")
req.write("</a>")
req.write("</td>\n")
req.write("</tr>\n")
req.write("</table>\n")
req.write("</body></html>\n")
from mod_python import apache
import vampire
import cgi
import os
basic = vampire.importModule("basic",None,__req__)
PREFIX = """
<div id="pageWrapper">
<div id="masthead" class="inside">
<!-- masthead content begin -->
<h1>%(masthead)s</h1>
<!-- masthead content end -->
</div>
<!-- horizontal nav begin -->
<div class="hnav">%(navbar)s</div>
<!-- horizontal nav end -->
<div id="outerColumnContainer">
<div id="innerColumnContainer">
<div id="SOWrap">
<div id="middleColumn">
<div class="inside">
"""
SUFFIX = """
</div>
</div>
<div id="leftColumn">
<div class="inside">
<!--- left column begin -->
import vampire
import os
# Following determines if this is being run within the
# context of the parent web site, and if it is use the
# navigation bar from the parent web site.
current = os.path.dirname(__file__)
parent = os.path.join(current, "../..")
_links = []
try:
module = vampire.importModule("_navbar", parent)
except OSError:
pass
else:
_links = list(module._links)
def navbar(req):
return _links
from mod_python import apache
import os
import vampire
__psp_root__ = os.path.join(os.path.dirname(__file__), "..", "psp")
psp = vampire.importModule("_handler", __psp_root__, __req__)
class Handler(psp.Servlet):
def __call__(self, message=""):
if not message:
message = "Give Blood!"
self.vars["message"] = message
self.render()
handler_html = vampire.Instance(Handler)
from mod_python import apache
import vampire
import os
config = vampire.loadConfig(__req__, ".vampire")
cheetah = vampire.importModule("_handler",
config.get("DEFAULT", "__cheetah_root__"),
__req__)
psp = vampire.importModule("_handler", config.get("DEFAULT", "__psp_root__"),
__req__)
def handler_html(req):
# This default handler for ".html" requests provides
# support for both Cheetah templates and PSP.
target = os.path.splitext(req.filename)[0]
# First look to see if request can be handle by a
# Cheetah template. Note that the ".tmpl" file must
# have been compiled into an appropriate ".py" file.
if os.path.exists(target + ".tmpl"):
return cheetah.handler_html(req)
# Now look to see if it could instead be handled as
# PSP request.