genshi/mirror: examples/trac/trac/web/api.py comparison

comparison examples/trac/trac/web/api.py @ 39:93b4dcbafd7b trunk

Copy Trac to main branch.

author	cmlenz
date	Mon, 03 Jul 2006 18:53:27 +0000
parents
children	f8a5a6ee2097

comparison

equal deleted inserted replaced

-:ee669cb9cccc
+:93b4dcbafd7b
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2005 Edgewall Software
+# Copyright (C) 2005 Christopher Lenz <cmlenz@gmx.de>
+# All rights reserved.
+#
+# This software is licensed as described in the file COPYING, which
+# you should have received as part of this distribution. The terms
+# are also available at http://trac.edgewall.com/license.html.
+#
+# This software consists of voluntary contributions made by many
+# individuals. For the exact contribution history, see the revision
+# history and logs, available at http://projects.edgewall.com/trac/.
+#
+# Author: Christopher Lenz <cmlenz@gmx.de>
+from BaseHTTPServer import BaseHTTPRequestHandler
+from Cookie import SimpleCookie as Cookie
+import cgi
+import mimetypes
+import os
+from StringIO import StringIO
+import sys
+import urlparse
+from trac.core import Interface
+from trac.util import get_last_traceback
+from trac.util.datefmt import http_date
+from trac.web.href import Href
+HTTP_STATUS = dict([(code, reason.title()) for code, (reason, description)
+in BaseHTTPRequestHandler.responses.items()])
+class HTTPException(Exception):
+"""Exception representing a HTTP status code."""
+def __init__(self, code):
+self.code = code
+self.reason = HTTP_STATUS.get(self.code, 'Unknown')
+self.__doc__ = 'Exception for HTTP %d %s' % (self.code, self.reason)
+def __call__(self, message, *args):
+self.message = message
+if args:
+self.message = self.message % args
+Exception.__init__(self, '%s %s (%s)' % (self.code, self.reason,
+message))
+return self
+def __str__(self):
+return '%s %s (%s)' % (self.code, self.reason, self.message)
+for code in [code for code in HTTP_STATUS if code >= 400]:
+exc_name = HTTP_STATUS[code].replace(' ', '')
+if exc_name.lower().startswith('http'):
+exc_name = exc_name[4:]
+setattr(sys.modules[__name__], 'HTTP' + exc_name, HTTPException(code))
+del code, exc_name
+class _RequestArgs(dict):
+"""Dictionary subclass that provides convenient access to request
+parameters that may contain multiple values."""
+def getfirst(self, name, default=None):
+"""Return the first value for the specified parameter, or `default` if
+the parameter was not provided.
+"""
+if name not in self:
+return default
+val = self[name]
+if isinstance(val, list):
+val = val[0]
+return val
+def getlist(self, name):
+"""Return a list of values for the specified parameter, even if only
+one value was provided.
+"""
+if name not in self:
+return []
+val = self[name]
+if not isinstance(val, list):
+val = [val]
+return val
+class RequestDone(Exception):
+"""Marker exception that indicates whether request processing has completed
+and a response was sent.
+"""
+class Request(object):
+"""Represents a HTTP request/response pair.
+This class provides a convenience API over WSGI.
+"""
+args = None
+hdf = None
+authname = None
+perm = None
+session = None
+def __init__(self, environ, start_response):
+"""Create the request wrapper.
+@param environ: The WSGI environment dict
+@param start_response: The WSGI callback for starting the response
+"""
+self.environ = environ
+self._start_response = start_response
+self._write = None
+self._status = '200 OK'
+self._response = None
+self._inheaders = [(name[5:].replace('_', '-').lower(), value)
+for name, value in environ.items()
+if name.startswith('HTTP_')]
+if 'CONTENT_LENGTH' in environ:
+self._inheaders.append(('content-length',
+environ['CONTENT_LENGTH']))
+if 'CONTENT_TYPE' in environ:
+self._inheaders.append(('content-type', environ['CONTENT_TYPE']))
+self._outheaders = []
+self._outcharset = None
+self.incookie = Cookie()
+cookie = self.get_header('Cookie')
+if cookie:
+self.incookie.load(cookie)
+self.outcookie = Cookie()
+self.base_url = self.environ.get('trac.base_url')
+if not self.base_url:
+self.base_url = self._reconstruct_url()
+self.href = Href(self.base_path)
+self.abs_href = Href(self.base_url)
+self.args = self._parse_args()
+def _parse_args(self):
+"""Parse the supplied request parameters into a dictionary."""
+args = _RequestArgs()
+fp = self.environ['wsgi.input']
+ctype = self.get_header('Content-Type')
+if ctype:
+# Avoid letting cgi.FieldStorage consume the input stream when the
+# request does not contain form data
+ctype, options = cgi.parse_header(ctype)
+if ctype not in ('application/x-www-form-urlencoded',
+'multipart/form-data'):
+fp = StringIO('')
+fs = cgi.FieldStorage(fp, environ=self.environ, keep_blank_values=True)
+if fs.list:
+for name in fs.keys():
+values = fs[name]
+if not isinstance(values, list):
+values = [values]
+for value in values:
+if not value.filename:
+value = unicode(value.value, 'utf-8')
+if name in args:
+if isinstance(args[name], list):
+args[name].append(value)
+else:
+args[name] = [args[name], value]
+else:
+args[name] = value
+return args
+def _reconstruct_url(self):
+"""Reconstruct the absolute base URL of the application."""
+host = self.get_header('Host')
+if not host:
+# Missing host header, so reconstruct the host from the
+# server name and port
+default_port = {'http': 80, 'https': 443}
+if self.server_port and self.server_port != default_port[self.scheme]:
+host = '%s:%d' % (self.server_name, self.server_port)
+else:
+host = self.server_name
+return urlparse.urlunparse((self.scheme, host, self.base_path, None,
+None, None))
+method = property(fget=lambda self: self.environ['REQUEST_METHOD'],
+doc='The HTTP method of the request')
+path_info = property(fget=lambda self: self.environ.get('PATH_INFO', '').decode('utf-8'),
+doc='Path inside the application')
+remote_addr = property(fget=lambda self: self.environ.get('REMOTE_ADDR'),
+doc='IP address of the remote user')
+remote_user = property(fget=lambda self: self.environ.get('REMOTE_USER'),
+doc='Name of the remote user, `None` if the user'
+'has not logged in using HTTP authentication')
+scheme = property(fget=lambda self: self.environ['wsgi.url_scheme'],
+doc='The scheme of the request URL')
+base_path = property(fget=lambda self: self.environ.get('SCRIPT_NAME', ''),
+doc='The root path of the application')
+server_name = property(fget=lambda self: self.environ['SERVER_NAME'],
+doc='Name of the server')
+server_port = property(fget=lambda self: int(self.environ['SERVER_PORT']),
+doc='Port number the server is bound to')
+def get_header(self, name):
+"""Return the value of the specified HTTP header, or `None` if there's
+no such header in the request.
+"""
+name = name.lower()
+for key, value in self._inheaders:
+if key == name:
+return value
+return None
+def send_response(self, code=200):
+"""Set the status code of the response."""
+self._status = '%s %s' % (code, HTTP_STATUS.get(code, 'Unknown'))
+def send_header(self, name, value):
+"""Send the response header with the specified name and value.
+`value` must either be an `unicode` string or can be converted to one
+(e.g. numbers, ...)
+"""
+if name.lower() == 'content-type':
+ctpos = value.find('charset=')
+if ctpos >= 0:
+self._outcharset = value[ctpos + 8:].strip()
+self._outheaders.append((name, unicode(value).encode('utf-8')))
+def _send_cookie_headers(self):
+for name in self.outcookie.keys():
+path = self.outcookie[name].get('path')
+if path:
+path = path.replace(' ', '%20') \
+.replace(';', '%3B') \
+.replace(',', '%3C')
+self.outcookie[name]['path'] = path
+cookies = self.outcookie.output(header='')
+for cookie in cookies.splitlines():
+self._outheaders.append(('Set-Cookie', cookie.strip()))
+def end_headers(self):
+"""Must be called after all headers have been sent and before the actual
+content is written.
+"""
+self._send_cookie_headers()
+self._write = self._start_response(self._status, self._outheaders)
+def check_modified(self, timesecs, extra=''):
+"""Check the request "If-None-Match" header against an entity tag.
+The entity tag is generated from the specified last modified time
+in seconds (`timesecs`), optionally appending an `extra` string to
+indicate variants of the requested resource.
+That `extra` parameter can also be a list, in which case the MD5 sum
+of the list content will be used.
+If the generated tag matches the "If-None-Match" header of the request,
+this method sends a "304 Not Modified" response to the client.
+Otherwise, it adds the entity tag as an "ETag" header to the response
+so that consecutive requests can be cached.
+"""
+if isinstance(extra, list):
+import md5
+m = md5.new()
+for elt in extra:
+m.update(repr(elt))
+extra = m.hexdigest()
+etag = 'W"%s/%d/%s"' % (self.authname, timesecs, extra)
+inm = self.get_header('If-None-Match')
+if (not inm or inm != etag):
+self.send_header('ETag', etag)
+else:
+self.send_response(304)
+self.end_headers()
+raise RequestDone
+def redirect(self, url, permanent=False):
+"""Send a redirect to the client, forwarding to the specified URL. The
+`url` may be relative or absolute, relative URLs will be translated
+appropriately.
+"""
+if self.session:
+self.session.save() # has to be done before the redirect is sent
+if permanent:
+status = 301 # 'Moved Permanently'
+elif self.method == 'POST':
+status = 303 # 'See Other' -- safe to use in response to a POST
+else:
+status = 302 # 'Found' -- normal temporary redirect
+self.send_response(status)
+if not url.startswith('http://') and not url.startswith('https://'):
+# Make sure the URL is absolute
+url = urlparse.urlunparse((self.scheme,
+urlparse.urlparse(self.base_url)[1],
+url, None, None, None))
+self.send_header('Location', url)
+self.send_header('Content-Type', 'text/plain')
+self.send_header('Pragma', 'no-cache')
+self.send_header('Cache-control', 'no-cache')
+self.send_header('Expires', 'Fri, 01 Jan 1999 00:00:00 GMT')
+self.end_headers()
+if self.method != 'HEAD':
+self.write('Redirecting...')
+raise RequestDone
+def display(self, template, content_type='text/html', status=200):
+"""Render the response using the ClearSilver template given by the
+`template` parameter, which can be either the name of the template file,
+or an already parsed `neo_cs.CS` object.
+"""
+assert self.hdf, 'HDF dataset not available'
+if self.args.has_key('hdfdump'):
+# FIXME: the administrator should probably be able to disable HDF
+#        dumps
+content_type = 'text/plain'
+data = str(self.hdf)
+else:
+data = self.hdf.render(template)
+self.send_response(status)
+self.send_header('Cache-control', 'must-revalidate')
+self.send_header('Expires', 'Fri, 01 Jan 1999 00:00:00 GMT')
+self.send_header('Content-Type', content_type + ';charset=utf-8')
+self.send_header('Content-Length', len(data))
+self.end_headers()
+if self.method != 'HEAD':
+self.write(data)
+raise RequestDone
+def send_error(self, exc_info, template='error.cs',
+content_type='text/html', status=500):
+if self.hdf:
+if self.args.has_key('hdfdump'):
+# FIXME: the administrator should probably be able to disable HDF
+#        dumps
+content_type = 'text/plain'
+data = str(self.hdf)
+else:
+data = self.hdf.render(template)
+else:
+content_type = 'text/plain'
+data = get_last_traceback()
+self.send_response(status)
+self._outheaders = []
+self.send_header('Cache-control', 'must-revalidate')
+self.send_header('Expires', 'Fri, 01 Jan 1999 00:00:00 GMT')
+self.send_header('Content-Type', content_type + ';charset=utf-8')
+self.send_header('Content-Length', len(data))
+self._send_cookie_headers()
+self._write = self._start_response(self._status, self._outheaders,
+exc_info)
+if self.method != 'HEAD':
+self.write(data)
+raise RequestDone
+def send_file(self, path, mimetype=None):
+"""Send a local file to the browser.
+This method includes the "Last-Modified", "Content-Type" and
+"Content-Length" headers in the response, corresponding to the file
+attributes. It also checks the last modification time of the local file
+against the "If-Modified-Since" provided by the user agent, and sends a
+"304 Not Modified" response if it matches.
+"""
+if not os.path.isfile(path):
+raise HTTPNotFound("File %s not found" % path)
+stat = os.stat(path)
+last_modified = http_date(stat.st_mtime)
+if last_modified == self.get_header('If-Modified-Since'):
+self.send_response(304)
+self.end_headers()
+raise RequestDone
+if not mimetype:
+mimetype = mimetypes.guess_type(path)[0] or \
+'application/octet-stream'
+self.send_response(200)
+self.send_header('Content-Type', mimetype)
+self.send_header('Content-Length', stat.st_size)
+self.send_header('Last-Modified', last_modified)
+self.end_headers()
+if self.method != 'HEAD':
+self._response = file(path, 'rb')
+file_wrapper = self.environ.get('wsgi.file_wrapper')
+if file_wrapper:
+self._response = file_wrapper(self._response, 4096)
+raise RequestDone
+def read(self, size=None):
+"""Read the specified number of bytes from the request body."""
+fileobj = self.environ['wsgi.input']
+if size is None:
+size = int(self.get_header('Content-Length', -1))
+data = fileobj.read(size)
+return data
+def write(self, data):
+"""Write the given data to the response body.
+`data` can be either a `str` or an `unicode` string.
+If it's the latter, the unicode string will be encoded
+using the charset specified in the ''Content-Type'' header
+or 'utf-8' otherwise.
+"""
+if not self._write:
+self.end_headers()
+if isinstance(data, unicode):
+data = data.encode(self._outcharset or 'utf-8')
+self._write(data)
+class IAuthenticator(Interface):
+"""Extension point interface for components that can provide the name
+of the remote user."""
+def authenticate(req):
+"""Return the name of the remote user, or `None` if the identity of the
+user is unknown."""
+class IRequestHandler(Interface):
+"""Extension point interface for request handlers."""
+# implementing classes should set this property to `True` if they
+# don't need session and authentication related information
+anonymous_request = False
+# implementing classes should set this property to `False` if they
+# don't need the HDF data and don't produce content using a template
+use_template = True
+def match_request(req):
+"""Return whether the handler wants to process the given request."""
+def process_request(req):
+"""Process the request. Should return a (template_name, content_type)
+tuple, where `template` is the ClearSilver template to use (either
+a `neo_cs.CS` object, or the file name of the template), and
+`content_type` is the MIME type of the content. If `content_type` is
+`None`, "text/html" is assumed.
+Note that if template processing should not occur, this method can
+simply send the response itself and not return anything.
+"""
+class IRequestFilter(Interface):
+"""Extension point interface for components that want to filter HTTP
+requests, before and/or after they are processed by the main handler."""
+def pre_process_request(req, handler):
+"""Do any pre-processing the request might need; typically adding
+values to req.hdf, or redirecting.
+Always returns the request handler, even if unchanged.
+"""
+def post_process_request(req, template, content_type):
+"""Do any post-processing the request might need; typically adding
+values to req.hdf, or changing template or mime type.
+Always returns a tuple of (template, content_type), even if
+unchanged.
+"""

Mercurial > genshi > mirror

comparison examples/trac/trac/web/api.py @ 39:93b4dcbafd7b trunk