code-c8bf4e9912ed/frontends/README.txt0000644000000000000000000000041213063371466015533 0ustar 00000000000000This directory contains alternate front-ends for Roundup. roundup.cgi This is a cgi-bin script. ZRoundup This is a simple Zope frontend that installs as a regular Zope product. See Roundup's doc/installation.txt for more info on installing these frontends. code-c8bf4e9912ed/frontends/ZRoundup/ZRoundup.py0000644000000000000000000001734213063371466017775 0ustar 00000000000000# Copyright (c) 2001 Bizar Software Pty Ltd (http://www.bizarsoftware.com.au/) # This module is free software, and you may redistribute it and/or modify # under the same terms as Python, so long as this copyright message and # disclaimer are retained in their original form. # # IN NO EVENT SHALL BIZAR SOFTWARE PTY LTD BE LIABLE TO ANY PARTY FOR # DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING # OUT OF THE USE OF THIS CODE, EVEN IF THE AUTHOR HAS BEEN ADVISED OF THE # POSSIBILITY OF SUCH DAMAGE. # # BIZAR SOFTWARE PTY LTD SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, # BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS # FOR A PARTICULAR PURPOSE. THE CODE PROVIDED HEREUNDER IS ON AN "AS IS" # BASIS, AND THERE IS NO OBLIGATION WHATSOEVER TO PROVIDE MAINTENANCE, # SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. # ''' ZRoundup module - exposes the roundup web interface to Zope This frontend works by providing a thin layer that sits between Zope and the regular CGI interface of roundup, providing the web frontend with the minimum of effort. This means that the regular CGI interface does all authentication quite independently of Zope. The roundup code is kept in memory though, and it runs in the same server as all your other Zope stuff, so it does have _some_ advantages over regular CGI :) ''' import urlparse from Globals import InitializeClass, HTMLFile from OFS.SimpleItem import Item from OFS.PropertyManager import PropertyManager from Acquisition import Explicit, Implicit from Persistence import Persistent from AccessControl import ClassSecurityInfo from AccessControl import ModuleSecurityInfo modulesecurity = ModuleSecurityInfo() import roundup.instance from roundup.cgi import client modulesecurity.declareProtected('View management screens', 'manage_addZRoundupForm') manage_addZRoundupForm = HTMLFile('dtml/manage_addZRoundupForm', globals()) modulesecurity.declareProtected('Add Z Roundups', 'manage_addZRoundup') def manage_addZRoundup(self, id, instance_home, REQUEST): """Add a ZRoundup product """ # validate the instance_home roundup.instance.open(instance_home) self._setObject(id, ZRoundup(id, instance_home)) return self.manage_main(self, REQUEST) class RequestWrapper: '''Make the Zope RESPONSE look like a BaseHTTPServer ''' def __init__(self, RESPONSE): self.RESPONSE = RESPONSE self.wfile = self.RESPONSE def send_response(self, status): self.RESPONSE.setStatus(status) def send_header(self, header, value): self.RESPONSE.addHeader(header, value) def end_headers(self): # not needed - the RESPONSE object handles this internally on write() pass def start_response(self, headers, response): self.send_response(response) for key, value in headers: self.send_header(key, value) self.end_headers() class FormItem: '''Make a Zope form item look like a cgi.py one ''' def __init__(self, value): self.value = value if hasattr(self.value, 'filename'): self.filename = self.value.filename self.value = self.value.read() class FormWrapper: '''Make a Zope form dict look like a cgi.py one ''' def __init__(self, form): self.__form = form def __getitem__(self, item): entry = self.__form[item] if isinstance(entry, type([])): entry = map(FormItem, entry) else: entry = FormItem(entry) return entry def __iter__(self): return iter(self.__form) def getvalue(self, key, default=None): if self.__form.has_key(key): return self.__form[key] else: return default def has_key(self, item): return self.__form.has_key(item) def keys(self): return self.__form.keys() def __repr__(self): return ''%self.__form class ZRoundup(Item, PropertyManager, Implicit, Persistent): '''An instance of this class provides an interface between Zope and roundup for one roundup instance ''' meta_type = 'Z Roundup' security = ClassSecurityInfo() def __init__(self, id, instance_home): self.id = id self.instance_home = instance_home # define the properties that define this object _properties = ( {'id':'id', 'type': 'string', 'mode': 'w'}, {'id':'instance_home', 'type': 'string', 'mode': 'w'}, ) property_extensible_schema__ = 0 # define the tabs for the management interface manage_options= PropertyManager.manage_options + ( {'label': 'View', 'action':'index_html'}, ) + Item.manage_options icon = "misc_/ZRoundup/icon" security.declarePrivate('roundup_opendb') def roundup_opendb(self): '''Open the roundup instance database for a transaction. ''' tracker = roundup.instance.open(self.instance_home) request = RequestWrapper(self.REQUEST['RESPONSE']) env = self.REQUEST.environ # figure out the path components to set url = urlparse.urlparse( self.absolute_url() ) path = url[2] path_components = path.split( '/' ) # special case when roundup is '/' in this virtual host, if path == "/" : env['SCRIPT_NAME'] = "/" env['TRACKER_NAME'] = '' else : # all but the last element is the path env['SCRIPT_NAME'] = '/'.join( path_components[:-1] ) # the last element is the name env['TRACKER_NAME'] = path_components[-1] form = FormWrapper(self.REQUEST.form) if hasattr(tracker, 'Client'): return tracker.Client(tracker, request, env, form) return client.Client(tracker, request, env, form) security.declareProtected('View', 'index_html') def index_html(self): '''Alias index_html to roundup's index ''' # Redirect misdirected requests -- bugs 558867 , 565992 # PATH_INFO, as defined by the CGI spec, has the *real* request path orig_path = self.REQUEST.environ['PATH_INFO'] if orig_path[-1] != '/' : url = urlparse.urlparse( self.absolute_url() ) url = list( url ) # make mutable url[2] = url[2]+'/' # patch url = urlparse.urlunparse( url ) # reassemble RESPONSE = self.REQUEST.RESPONSE RESPONSE.setStatus( "MovedPermanently" ) # 301 RESPONSE.setHeader( "Location" , url ) return RESPONSE client = self.roundup_opendb() # fake the path that roundup should use client.split_path = ['index'] return client.main() def __getitem__(self, item): '''All other URL accesses are passed throuh to roundup ''' return PathElement(self, item).__of__(self) class PathElement(Item, Implicit): def __init__(self, zr, path): self.zr = zr self.path = path def __getitem__(self, item): ''' Get a subitem. ''' return PathElement(self.zr, self.path + '/' + item).__of__(self) def index_html(self, REQUEST=None): ''' Actually call through to roundup to handle the request. ''' try: client = self.zr.roundup_opendb() # fake the path that roundup should use client.path = self.path # and call roundup to do something client.main() return '' except client.NotFound: raise 'NotFound', REQUEST.URL pass except: import traceback traceback.print_exc() # all other exceptions in roundup are valid raise InitializeClass(ZRoundup) modulesecurity.apply(globals()) # vim: set filetype=python ts=4 sw=4 et si code-c8bf4e9912ed/frontends/ZRoundup/__init__.py0000644000000000000000000000377213063371466017750 0ustar 00000000000000# Copyright (c) 2001 Bizar Software Pty Ltd (http://www.bizarsoftware.com.au/) # This module is free software, and you may redistribute it and/or modify # under the same terms as Python, so long as this copyright message and # disclaimer are retained in their original form. # # IN NO EVENT SHALL BIZAR SOFTWARE PTY LTD BE LIABLE TO ANY PARTY FOR # DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING # OUT OF THE USE OF THIS CODE, EVEN IF THE AUTHOR HAS BEEN ADVISED OF THE # POSSIBILITY OF SUCH DAMAGE. # # BIZAR SOFTWARE PTY LTD SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, # BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS # FOR A PARTICULAR PURPOSE. THE CODE PROVIDED HEREUNDER IS ON AN "AS IS" # BASIS, AND THERE IS NO OBLIGATION WHATSOEVER TO PROVIDE MAINTENANCE, # SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. # __version__='1.1' import os # figure where ZRoundup is installed here = None if os.environ.has_key('INSTANCE_HOME'): here = os.environ['INSTANCE_HOME'] path = os.path.join(here, 'Products', 'ZRoundup') if not os.path.exists(path): path = os.path.join(here, 'lib', 'python', 'Products', 'ZRoundup') if not os.path.exists(path): here = None if here is None: from __main__ import here path = os.path.join(here, 'Products', 'ZRoundup') if not os.path.exists(path): path = os.path.join(here, 'lib', 'python', 'Products', 'ZRoundup') if not os.path.exists(path): raise ValueError, "Can't determine where ZRoundup is installed" # product initialisation from ZRoundup import ZRoundup, manage_addZRoundupForm, manage_addZRoundup def initialize(context): context.registerClass( ZRoundup, meta_type = 'Z Roundup', constructors = ( manage_addZRoundupForm, manage_addZRoundup ) ) # set up the icon from ImageFile import ImageFile misc_ = { 'icon': ImageFile('icons/tick_symbol.gif', path), } # vim: set filetype=python ts=4 sw=4 et si code-c8bf4e9912ed/frontends/ZRoundup/dtml/manage_addZRoundupForm.dtml0000644000000000000000000000024313063371466024042 0ustar 00000000000000
ID:
Instance Home:
code-c8bf4e9912ed/frontends/ZRoundup/icons/tick_symbol.gif0000644000000000000000000000025713063371466021753 0ustar 00000000000000GIF89a pppSSSKKKٍ333fff{{{!, ,$#BqJ #"HbJi'iNCvrð ;code-c8bf4e9912ed/frontends/ZRoundup/refresh.txt0000644000000000000000000000020513063371466020022 0ustar 00000000000000The existence of this file enables the Zope product refresh option. Read the Zope documentation for more info about product refresh. code-c8bf4e9912ed/frontends/roundup.cgi0000755000000000000000000001674613063371466016241 0ustar 00000000000000#!/usr/bin/env python # # Copyright (c) 2001 Bizar Software Pty Ltd (http://www.bizarsoftware.com.au/) # This module is free software, and you may redistribute it and/or modify # under the same terms as Python, so long as this copyright message and # disclaimer are retained in their original form. # # IN NO EVENT SHALL BIZAR SOFTWARE PTY LTD BE LIABLE TO ANY PARTY FOR # DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING # OUT OF THE USE OF THIS CODE, EVEN IF THE AUTHOR HAS BEEN ADVISED OF THE # POSSIBILITY OF SUCH DAMAGE. # # BIZAR SOFTWARE PTY LTD SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, # BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS # FOR A PARTICULAR PURPOSE. THE CODE PROVIDED HEREUNDER IS ON AN "AS IS" # BASIS, AND THERE IS NO OBLIGATION WHATSOEVER TO PROVIDE MAINTENANCE, # SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. # python version check from roundup import version_check from roundup.i18n import _ import sys, time # ## Configuration # # Configuration can also be provided through the OS environment (or via # the Apache "SetEnv" configuration directive). If the variables # documented below are set, they _override_ any configuation defaults # given in this file. # TRACKER_HOMES is a list of trackers, in the form # "NAME=DIRNAME2=DIR2...", where is the directory path # separator (";" on Windows, ":" on Unix). # Make sure the NAME part doesn't include any url-unsafe characters like # spaces, as these confuse the cookie handling in browsers like IE. # ROUNDUP_LOG is the name of the logfile; if it's empty or does not exist, # logging is turned off (unless you changed the default below). # DEBUG_TO_CLIENT specifies whether debugging goes to the HTTP server (via # stderr) or to the web client (via cgitb). DEBUG_TO_CLIENT = False # This indicates where the Roundup tracker lives TRACKER_HOMES = { # 'example': '/path/to/example', } # Where to log debugging information to. Use an instance of DevNull if you # don't want to log anywhere. class DevNull: def write(self, info): pass def close(self): pass def flush(self): pass #LOG = open('/var/log/roundup.cgi.log', 'a') LOG = DevNull() # ## end configuration # # # Set up the error handler # try: import traceback, StringIO, cgi from roundup.cgi import cgitb except: print "Content-Type: text/plain\n" print _("Failed to import cgitb!\n\n") s = StringIO.StringIO() traceback.print_exc(None, s) print s.getvalue() # # Check environment for config items # def checkconfig(): import os, string global TRACKER_HOMES, LOG # see if there's an environment var. ROUNDUP_INSTANCE_HOMES is the # old name for it. if os.environ.has_key('ROUNDUP_INSTANCE_HOMES'): homes = os.environ.get('ROUNDUP_INSTANCE_HOMES') else: homes = os.environ.get('TRACKER_HOMES', '') if homes: TRACKER_HOMES = {} for home in string.split(homes, os.pathsep): try: name, dir = string.split(home, '=', 1) except ValueError: # ignore invalid definitions continue if name and dir: TRACKER_HOMES[name] = dir logname = os.environ.get('ROUNDUP_LOG', '') if logname: LOG = open(logname, 'a') # ROUNDUP_DEBUG is checked directly in "roundup.cgi.client" # # Provide interface to CGI HTTP response handling # class RequestWrapper: '''Used to make the CGI server look like a BaseHTTPRequestHandler ''' def __init__(self, wfile): self.rfile = sys.stdin self.wfile = wfile def write(self, data): self.wfile.write(data) def send_response(self, code): self.write('Status: %s\r\n'%code) def send_header(self, keyword, value): self.write("%s: %s\r\n" % (keyword, value)) def end_headers(self): self.write("\r\n") def start_response(self, headers, response): self.send_response(response) for key, value in headers: self.send_header(key, value) self.end_headers() # # Main CGI handler # def main(out, err): import os, string import roundup.instance path = string.split(os.environ.get('PATH_INFO', '/'), '/') request = RequestWrapper(out) request.path = os.environ.get('PATH_INFO', '/') tracker = path[1] os.environ['TRACKER_NAME'] = tracker os.environ['PATH_INFO'] = string.join(path[2:], '/') if TRACKER_HOMES.has_key(tracker): # redirect if we need a trailing '/' if len(path) == 2: request.send_response(301) # redirect if os.environ.get('HTTPS', '') == 'on': protocol = 'https' else: protocol = 'http' absolute_url = '%s://%s%s/'%(protocol, os.environ['HTTP_HOST'], os.environ.get('REQUEST_URI', '')) request.send_header('Location', absolute_url) request.end_headers() out.write('Moved Permanently') else: tracker_home = TRACKER_HOMES[tracker] tracker = roundup.instance.open(tracker_home) import roundup.cgi.client if hasattr(tracker, 'Client'): client = tracker.Client(tracker, request, os.environ) else: client = roundup.cgi.client.Client(tracker, request, os.environ) try: client.main() except roundup.cgi.client.Unauthorised: request.send_response(403) request.send_header('Content-Type', 'text/html') request.end_headers() out.write('Unauthorised') except roundup.cgi.client.NotFound: request.send_response(404) request.send_header('Content-Type', 'text/html') request.end_headers() out.write('Not found: %s'%client.path) else: import urllib request.send_response(200) request.send_header('Content-Type', 'text/html') request.end_headers() w = request.write w(_('Roundup trackers index\n')) w(_('

Roundup trackers index

    \n')) homes = TRACKER_HOMES.keys() homes.sort() for tracker in homes: w(_('
  1. %(tracker_name)s\n')%{ 'tracker_url': os.environ['SCRIPT_NAME']+'/'+ urllib.quote(tracker), 'tracker_name': cgi.escape(tracker)}) w(_('
')) # # Now do the actual CGI handling # out, err = sys.stdout, sys.stderr try: # force input/output to binary (important for file up/downloads) if sys.platform == "win32": import os, msvcrt msvcrt.setmode(sys.stdin.fileno(), os.O_BINARY) msvcrt.setmode(sys.stdout.fileno(), os.O_BINARY) checkconfig() sys.stdout = sys.stderr = LOG main(out, err) except SystemExit: pass except: sys.stdout, sys.stderr = out, err out.write('Content-Type: text/html\n\n') if DEBUG_TO_CLIENT: cgitb.handler() else: out.write(cgitb.breaker()) ts = time.ctime() out.write('''

%s: An error occurred. Please check the server log for more information.

'''%ts) print >> sys.stderr, 'EXCEPTION AT', ts traceback.print_exc(0, sys.stderr) sys.stdout.flush() sys.stdout, sys.stderr = out, err LOG.close() # vim: set filetype=python ts=4 sw=4 et si