# -*-python-*-
#
# Copyright (C) 1999-2008 The ViewCVS Group. All Rights Reserved.
#
# By using this file, you agree to the terms and conditions set forth in
# the LICENSE.html file which can be found at the top level of the ViewVC
# distribution or at http://viewvc.org/license-1.html.
#
# For more information, visit http://viewvc.org/
#
# -----------------------------------------------------------------------
#
# viewvc: View CVS/SVN repositories via a web browser
#
# -----------------------------------------------------------------------
__version__ = '1.1-dev'
# this comes from our library; measure the startup time
import debug
debug.t_start('startup')
debug.t_start('imports')
# standard modules that we know are in the path or builtin
import sys
import os
import cgi
import gzip
import mimetypes
import re
import rfc822
import stat
import string
import struct
import tempfile
import time
import types
import urllib
# These modules come from our library (the stub has set up the path)
import accept
import compat
import config
import ezt
import popen
import sapi
import vcauth
import vclib
import vclib.ccvs
import vclib.svn
try:
import idiff
except (SyntaxError, ImportError):
idiff = None
debug.t_end('imports')
#########################################################################
checkout_magic_path = '*checkout*'
# According to RFC 1738 the '~' character is unsafe in URLs.
# But for compatibility with URLs bookmarked with old releases of ViewCVS:
oldstyle_checkout_magic_path = '~checkout~'
docroot_magic_path = '*docroot*'
viewcvs_mime_type = 'text/vnd.viewcvs-markup'
alt_mime_type = 'text/x-cvsweb-markup'
view_roots_magic = '*viewroots*'
# Put here the variables we need in order to hold our state - they
# will be added (with their current value) to (almost) any link/query
# string you construct.
_sticky_vars = [
'hideattic',
'sortby',
'sortdir',
'logsort',
'diff_format',
'search',
'limit_changes',
]
# number of extra pages of information on either side of the current
# page to fetch (see use_pagesize configuration option)
EXTRA_PAGES = 3
# for reading/writing between a couple descriptors
CHUNK_SIZE = 8192
# for rcsdiff processing of header
_RCSDIFF_IS_BINARY = 'binary-diff'
_RCSDIFF_ERROR = 'error'
# special characters that don't need to be URL encoded
_URL_SAFE_CHARS = "/*~"
class Request:
def __init__(self, server, cfg):
self.server = server
self.cfg = cfg
self.script_name = _normalize_path(server.getenv('SCRIPT_NAME', ''))
self.browser = server.getenv('HTTP_USER_AGENT', 'unknown')
# process the Accept-Language: header, and load the key/value
# files, given the selected language
hal = server.getenv('HTTP_ACCEPT_LANGUAGE','')
self.lang_selector = accept.language(hal)
self.language = self.lang_selector.select_from(cfg.general.languages)
self.kv = cfg.load_kv_files(self.language)
# check for an authenticated username
self.username = server.getenv('REMOTE_USER')
# if we allow compressed output, see if the client does too
self.gzip_compress_level = 0
if cfg.options.allow_compress:
http_accept_encoding = os.environ.get("HTTP_ACCEPT_ENCODING", "")
if "gzip" in filter(None,
map(lambda x: string.strip(x),
string.split(http_accept_encoding, ","))):
self.gzip_compress_level = 9 # make this configurable?
def run_viewvc(self):
cfg = self.cfg
# This function first parses the query string and sets the following
# variables. Then it executes the request.
self.view_func = None # function to call to process the request
self.repos = None # object representing current repository
self.rootname = None # name of current root (as used in viewvc.conf)
self.roottype = None # current root type ('svn' or 'cvs')
self.rootpath = None # physical path to current root
self.pathtype = None # type of path, either vclib.FILE or vclib.DIR
self.where = None # path to file or directory in current root
self.query_dict = {} # validated and cleaned up query options
self.path_parts = None # for convenience, equals where.split('/')
self.pathrev = None # current path revision or tag
self.auth = None # authorizer module in use
# redirect if we're loading from a valid but irregular URL
# These redirects aren't neccessary to make ViewVC work, it functions
# just fine without them, but they make it easier for server admins to
# implement access restrictions based on URL
needs_redirect = 0
# Process the query params
for name, values in self.server.params().items():
# patch up old queries that use 'cvsroot' to look like they used 'root'
if name == 'cvsroot':
name = 'root'
needs_redirect = 1
# same for 'only_with_tag' and 'pathrev'
if name == 'only_with_tag':
name = 'pathrev'
needs_redirect = 1
# validate the parameter
_validate_param(name, values[0])
# if we're here, then the parameter is okay
self.query_dict[name] = values[0]
# handle view parameter, redirecting old view=rev URLs to view=revision
if self.query_dict.get('view') == 'rev':
self.query_dict['view'] = 'revision'
needs_redirect = 1
self.view_func = _views.get(self.query_dict.get('view', None),
self.view_func)
# Process PATH_INFO component of query string
path_info = self.server.getenv('PATH_INFO', '')
# clean it up. this removes duplicate '/' characters and any that may
# exist at the front or end of the path.
### we might want to redirect to the cleaned up URL
path_parts = _path_parts(path_info)
if path_parts:
# handle magic path prefixes
if path_parts[0] == docroot_magic_path:
# if this is just a simple hunk of doc, then serve it up
self.where = _path_join(path_parts[1:])
return view_doc(self)
elif path_parts[0] in (checkout_magic_path,
oldstyle_checkout_magic_path):
path_parts.pop(0)
self.view_func = view_checkout
if not cfg.options.checkout_magic:
needs_redirect = 1
# handle tarball magic suffixes
if self.view_func is download_tarball:
if (self.query_dict.get('parent')):
del path_parts[-1]
elif path_parts[-1][-7:] == ".tar.gz":
path_parts[-1] = path_parts[-1][:-7]
# Figure out root name
self.rootname = self.query_dict.get('root')
if self.rootname == view_roots_magic:
del self.query_dict['root']
self.rootname = ""
needs_redirect = 1
elif self.rootname is None:
if cfg.options.root_as_url_component:
if path_parts:
self.rootname = path_parts.pop(0)
else:
self.rootname = ""
elif self.view_func != view_roots:
self.rootname = cfg.general.default_root
elif cfg.options.root_as_url_component:
needs_redirect = 1
self.where = _path_join(path_parts)
self.path_parts = path_parts
if self.rootname:
roottype, rootpath = locate_root(cfg, self.rootname)
if roottype:
# Setup an Authorizer for this rootname and username
self.auth = setup_authorizer(cfg, self.username, self.rootname)
# Create the repository object
try:
if roottype == 'cvs':
cfg.overlay_root_options(self.rootname)
self.rootpath = vclib.ccvs.canonicalize_rootpath(rootpath)
self.repos = vclib.ccvs.CVSRepository(self.rootname,
self.rootpath,
self.auth,
cfg.utilities,
cfg.options.use_rcsparse)
# required so that spawned rcs programs correctly expand
# $CVSHeader$
os.environ['CVSROOT'] = self.rootpath
elif roottype == 'svn':
cfg.overlay_root_options(self.rootname)
self.rootpath = vclib.svn.canonicalize_rootpath(rootpath)
self.repos = vclib.svn.SubversionRepository(self.rootname,
self.rootpath,
self.auth,
cfg.utilities,
cfg.options.svn_config_dir)
else:
raise vclib.ReposNotFound()
except vclib.ReposNotFound:
pass
if self.repos is None:
raise debug.ViewVCException(
'The root "%s" is unknown. If you believe the value is '
'correct, then please double-check your configuration.'
% self.rootname, "404 Not Found")
if self.repos:
self.repos.open()
type = self.repos.roottype()
if type == vclib.SVN:
self.roottype = 'svn'
elif type == vclib.CVS:
self.roottype = 'cvs'
else:
raise debug.ViewVCException(
'The root "%s" has an unknown type (%s).' % (self.rootname, type),
"500 Internal Server Error")
# If this is using an old-style 'rev' parameter, redirect to new hotness.
# Subversion URLs will now use 'pathrev'; CVS ones use 'revision'.
if self.repos and self.query_dict.has_key('rev'):
if self.roottype == 'svn' \
and not self.query_dict.has_key('pathrev') \
and not self.view_func == view_revision:
self.query_dict['pathrev'] = self.query_dict['rev']
del self.query_dict['rev']
else: # elif not self.query_dict.has_key('revision'): ?
self.query_dict['revision'] = self.query_dict['rev']
del self.query_dict['rev']
needs_redirect = 1
if self.repos and self.view_func is not redirect_pathrev:
# If this is an intended-to-be-hidden CVSROOT path, complain.
if cfg.options.hide_cvsroot \
and is_cvsroot_path(self.roottype, path_parts):
raise debug.ViewVCException("Unknown location: /%s" % self.where,
"404 Not Found")
# Make sure path exists
self.pathrev = pathrev = self.query_dict.get('pathrev')
self.pathtype = _repos_pathtype(self.repos, path_parts, pathrev)
if self.pathtype is None:
# Path doesn't exist, see if it could be an old-style ViewVC URL
# with a fake suffix.
result = _strip_suffix('.diff', path_parts, pathrev, vclib.FILE, \
self.repos, view_diff) or \
_strip_suffix('.tar.gz', path_parts, pathrev, vclib.DIR, \
self.repos, download_tarball) or \
_strip_suffix('root.tar.gz', path_parts, pathrev, vclib.DIR,\
self.repos, download_tarball) or \
_strip_suffix(self.rootname + '-root.tar.gz', \
path_parts, pathrev, vclib.DIR, \
self.repos, download_tarball) or \
_strip_suffix('root', \
path_parts, pathrev, vclib.DIR, \
self.repos, download_tarball) or \
_strip_suffix(self.rootname + '-root', \
path_parts, pathrev, vclib.DIR, \
self.repos, download_tarball)
if result:
self.path_parts, self.pathtype, self.view_func = result
self.where = _path_join(self.path_parts)
needs_redirect = 1
else:
raise debug.ViewVCException("Unknown location: /%s" % self.where,
"404 Not Found")
# If we have an old ViewCVS Attic URL which is still valid, redirect
if self.roottype == 'cvs':
attic_parts = None
if (self.pathtype == vclib.FILE and len(self.path_parts) > 1
and self.path_parts[-2] == 'Attic'):
attic_parts = self.path_parts[:-2] + self.path_parts[-1:]
elif (self.pathtype == vclib.DIR and len(self.path_parts) > 0
and self.path_parts[-1] == 'Attic'):
attic_parts = self.path_parts[:-1]
if attic_parts:
self.path_parts = attic_parts
self.where = _path_join(attic_parts)
needs_redirect = 1
if self.view_func is None:
# view parameter is not set, try looking at pathtype and the
# other parameters
if not self.rootname:
self.view_func = view_roots
elif self.pathtype == vclib.DIR:
# ViewCVS 0.9.2 used to put ?tarball=1 at the end of tarball urls
if self.query_dict.has_key('tarball'):
self.view_func = download_tarball
else:
self.view_func = view_directory
elif self.pathtype == vclib.FILE:
if self.query_dict.has_key('r1') and self.query_dict.has_key('r2'):
self.view_func = view_diff
elif self.query_dict.has_key('annotate'):
self.view_func = view_annotate
elif self.query_dict.has_key('graph'):
if not self.query_dict.has_key('makeimage'):
self.view_func = view_cvsgraph
else:
self.view_func = view_cvsgraph_image
elif self.query_dict.has_key('revision') \
or cfg.options.default_file_view != "log":
if cfg.options.default_file_view == "markup" \
or self.query_dict.get('content-type', None) \
in (viewcvs_mime_type, alt_mime_type):
self.view_func = view_markup
else:
self.view_func = view_checkout
else:
self.view_func = view_log
# If we've chosen the roots or revision view, our effective
# location is not really "inside" the repository, so we have no
# path and therefore no path parts or type, either.
if self.view_func is view_revision or self.view_func is view_roots:
self.where = ''
self.path_parts = []
self.pathtype = None
# if we have a directory and the request didn't end in "/", then redirect
# so that it does.
if (self.pathtype == vclib.DIR and path_info[-1:] != '/'
and self.view_func is not download_tarball
and self.view_func is not redirect_pathrev):
needs_redirect = 1
# redirect now that we know the URL is valid
if needs_redirect:
self.server.redirect(self.get_url())
# Finally done parsing query string, set mime type and call view_func
self.mime_type = None
if self.pathtype == vclib.FILE:
self.mime_type = guess_mime(self.where)
# startup is done now.
debug.t_end('startup')
self.view_func(self)
def get_url(self, escape=0, partial=0, prefix=0, **args):
"""Constructs a link to another ViewVC page just like the get_link
function except that it returns a single URL instead of a URL
split into components. If PREFIX is set, include the protocol and
server name portions of the URL."""
url, params = apply(self.get_link, (), args)
qs = compat.urlencode(params)
if qs:
result = urllib.quote(url, _URL_SAFE_CHARS) + '?' + qs
else:
result = urllib.quote(url, _URL_SAFE_CHARS)
if partial:
result = result + (qs and '&' or '?')
if escape:
result = self.server.escape(result)
if prefix:
result = '%s://%s%s' % \
(self.server.getenv("HTTPS") == "on" and "https" or "http",
self.server.getenv("HTTP_HOST"),
result)
return result
def get_form(self, **args):
"""Constructs a link to another ViewVC page just like the get_link
function except that it returns a base URL suitable for use as an
HTML form action, and an iterable object with .name and .value
attributes representing stuff that should be in tags with the link parameters."""
url, params = apply(self.get_link, (), args)
action = self.server.escape(urllib.quote(url, _URL_SAFE_CHARS))
hidden_values = []
for name, value in params.items():
hidden_values.append(_item(name=name, value=value))
return action, hidden_values
def get_link(self, view_func=None, where=None, pathtype=None, params=None):
"""Constructs a link pointing to another ViewVC page. All arguments
correspond to members of the Request object. If they are set to
None they take values from the current page. Return value is a base
URL and a dictionary of parameters"""
cfg = self.cfg
if view_func is None:
view_func = self.view_func
if params is None:
params = self.query_dict.copy()
else:
params = params.copy()
# must specify both where and pathtype or neither
assert (where is None) == (pathtype is None)
# if we are asking for the revision info view, we don't need any
# path information
if (view_func is view_revision or view_func is view_roots
or view_func is redirect_pathrev):
where = pathtype = None
elif where is None:
where = self.where
pathtype = self.pathtype
# no need to add sticky variables for views with no links
sticky_vars = not (view_func is view_checkout
or view_func is download_tarball)
# The logic used to construct the URL is an inverse of the
# logic used to interpret URLs in Request.run_viewvc
url = self.script_name
# add checkout magic if neccessary
if view_func is view_checkout and cfg.options.checkout_magic:
url = url + '/' + checkout_magic_path
# add root to url
rootname = None
if view_func is not view_roots:
if cfg.options.root_as_url_component:
# remove root from parameter list if present
try:
rootname = params['root']
except KeyError:
rootname = self.rootname
else:
del params['root']
# add root path component
if rootname is not None:
url = url + '/' + rootname
else:
# add root to parameter list
try:
rootname = params['root']
except KeyError:
rootname = params['root'] = self.rootname
# no need to specify default root
if rootname == cfg.general.default_root:
del params['root']
# add 'pathrev' value to parameter list
if (self.pathrev is not None
and not params.has_key('pathrev')
and view_func is not view_revision
and rootname == self.rootname):
params['pathrev'] = self.pathrev
# add path
if where:
url = url + '/' + where
# add trailing slash for a directory
if pathtype == vclib.DIR:
url = url + '/'
# normalize top level URLs for use in Location headers and A tags
elif not url:
url = '/'
# no need to explicitly specify directory view for a directory
if view_func is view_directory and pathtype == vclib.DIR:
view_func = None
# no need to explicitly specify roots view when in root_as_url
# mode or there's no default root
if view_func is view_roots and (cfg.options.root_as_url_component
or not cfg.general.default_root):
view_func = None
# no need to explicitly specify annotate view when
# there's an annotate parameter
if view_func is view_annotate and params.get('annotate') is not None:
view_func = None
# no need to explicitly specify diff view when
# there's r1 and r2 parameters
if (view_func is view_diff and params.get('r1') is not None
and params.get('r2') is not None):
view_func = None
# no need to explicitly specify checkout view when it's the default
# view or when checkout_magic is enabled
if view_func is view_checkout:
if ((cfg.options.default_file_view == "co" and pathtype == vclib.FILE)
or cfg.options.checkout_magic):
view_func = None
# no need to explicitly specify markup view when it's the default view
if view_func is view_markup:
if (cfg.options.default_file_view == "markup" \
and pathtype == vclib.FILE):
view_func = None
# set the view parameter
view_code = _view_codes.get(view_func)
if view_code and not (params.has_key('view') and params['view'] is None):
params['view'] = view_code
# add sticky values to parameter list
if sticky_vars:
for name in _sticky_vars:
value = self.query_dict.get(name)
if value is not None and not params.has_key(name):
params[name] = value
# remove null values from parameter list
for name, value in params.items():
if value is None:
del params[name]
return url, params
def _path_parts(path):
"""Split up a repository path into a list of path components"""
# clean it up. this removes duplicate '/' characters and any that may
# exist at the front or end of the path.
return filter(None, string.split(path, '/'))
def _normalize_path(path):
"""Collapse leading slashes in the script name
You only get multiple slashes in the script name when users accidentally
type urls like http://abc.com//viewvc.cgi/, but we correct for it
because we output the script name in links and web browsers
interpret //viewvc.cgi/ as http://viewvc.cgi/
"""
i = 0
for c in path:
if c != '/':
break
i = i + 1
if i:
return path[i-1:]
return path
def _validate_param(name, value):
"""Validate whether the given value is acceptable for the param name.
If the value is not allowed, then an error response is generated, and
this function throws an exception. Otherwise, it simply returns None.
"""
try:
validator = _legal_params[name]
except KeyError:
raise debug.ViewVCException(
'An illegal parameter name ("%s") was passed.' % name,
'400 Bad Request')
if validator is None:
return
# is the validator a regex?
if hasattr(validator, 'match'):
if not validator.match(value):
raise debug.ViewVCException(
'An illegal value ("%s") was passed as a parameter.' %
value, '400 Bad Request')
return
# the validator must be a function
validator(value)
def _validate_regex(value):
# hmm. there isn't anything that we can do here.
### we need to watch the flow of these parameters through the system
### to ensure they don't hit the page unescaped. otherwise, these
### parameters could constitute a CSS attack.
pass
# obvious things here. note that we don't need uppercase for alpha.
_re_validate_alpha = re.compile('^[a-z]+$')
_re_validate_number = re.compile('^[0-9]+$')
# when comparing two revs, we sometimes construct REV:SYMBOL, so ':' is needed
_re_validate_revnum = re.compile('^[-_.a-zA-Z0-9:~\\[\\]/]*$')
# it appears that RFC 2045 also says these chars are legal: !#$%&'*+^{|}~`
# but woah... I'll just leave them out for now
_re_validate_mimetype = re.compile('^[-_.a-zA-Z0-9/]+$')
# date time values
_re_validate_datetime = re.compile(r'^(\d\d\d\d-\d\d-\d\d(\s+\d\d:\d\d'
'(:\d\d)?)?)?$')
# the legal query parameters and their validation functions
_legal_params = {
'root' : None,
'view' : None,
'search' : _validate_regex,
'p1' : None,
'p2' : None,
'hideattic' : _re_validate_number,
'limit_changes' : _re_validate_number,
'sortby' : _re_validate_alpha,
'sortdir' : _re_validate_alpha,
'logsort' : _re_validate_alpha,
'diff_format' : _re_validate_alpha,
'pathrev' : _re_validate_revnum,
'dir_pagestart' : _re_validate_number,
'log_pagestart' : _re_validate_number,
'annotate' : _re_validate_revnum,
'graph' : _re_validate_revnum,
'makeimage' : _re_validate_number,
'r1' : _re_validate_revnum,
'tr1' : _re_validate_revnum,
'r2' : _re_validate_revnum,
'tr2' : _re_validate_revnum,
'revision' : _re_validate_revnum,
'content-type' : _re_validate_mimetype,
'simple' : _re_validate_revnum,
# for query
'branch' : _validate_regex,
'branch_match' : _re_validate_alpha,
'dir' : None,
'file' : _validate_regex,
'file_match' : _re_validate_alpha,
'who' : _validate_regex,
'who_match' : _re_validate_alpha,
'comment' : _validate_regex,
'comment_match' : _re_validate_alpha,
'querysort' : _re_validate_alpha,
'date' : _re_validate_alpha,
'hours' : _re_validate_number,
'mindate' : _re_validate_datetime,
'maxdate' : _re_validate_datetime,
'format' : _re_validate_alpha,
'limit' : _re_validate_number,
# for redirect_pathrev
'orig_path' : None,
'orig_pathtype' : None,
'orig_pathrev' : None,
'orig_view' : None,
# deprecated
'parent' : _re_validate_number,
'rev' : _re_validate_revnum,
'tarball' : _re_validate_number,
'hidecvsroot' : _re_validate_number,
}
def _path_join(path_parts):
return string.join(path_parts, '/')
def _strip_suffix(suffix, path_parts, rev, pathtype, repos, view_func):
"""strip the suffix from a repository path if the resulting path
is of the specified type, otherwise return None"""
if not path_parts:
return None
l = len(suffix)
if path_parts[-1][-l:] == suffix:
path_parts = path_parts[:]
if len(path_parts[-1]) == l:
del path_parts[-1]
else:
path_parts[-1] = path_parts[-1][:-l]
t = _repos_pathtype(repos, path_parts, rev)
if pathtype == t:
return path_parts, t, view_func
return None
def _repos_pathtype(repos, path_parts, rev):
"""Return the type of a repository path, or None if the path doesn't
exist"""
try:
return repos.itemtype(path_parts, rev)
except vclib.ItemNotFound:
return None
def _orig_path(request, rev_param='revision', path_param=None):
"Get original path of requested file at old revision before copies or moves"
# The 'pathrev' variable is interpreted by nearly all ViewVC views to
# provide a browsable snapshot of a repository at some point in its history.
# 'pathrev' is a tag name for CVS repositories and a revision number for
# Subversion repositories. It's automatically propagated between pages by
# logic in the Request.get_link() function which adds it to links like a
# sticky variable. When 'pathrev' is set, directory listings only include
# entries that exist in the specified revision or tag. Similarly, log pages
# will only show revisions preceding the point in history specified by
# 'pathrev.' Markup, checkout, and annotate pages show the 'pathrev'
# revision of files by default when no other revision is specified.
#
# In Subversion repositories, paths are always considered to refer to the
# pathrev revision. For example, if there is a "circle.jpg" in revision 3,
# which is renamed and modified as "square.jpg" in revision 4, the original
# circle image is visible at the following URLs:
#
# *checkout*/circle.jpg?pathrev=3
# *checkout*/square.jpg?revision=3
# *checkout*/square.jpg?revision=3&pathrev=4
#
# Note that the following:
#
# *checkout*/circle.jpg?rev=3
#
# now gets redirected to one of the following URLs:
#
# *checkout*/circle.jpg?pathrev=3 (for Subversion)
# *checkout*/circle.jpg?revision=3 (for CVS)
#
rev = request.query_dict.get(rev_param, request.pathrev)
path = request.query_dict.get(path_param, request.where)
if rev is not None and hasattr(request.repos, '_getrev'):
try:
pathrev = request.repos._getrev(request.pathrev)
rev = request.repos._getrev(rev)
except vclib.InvalidRevision:
raise debug.ViewVCException('Invalid revision', '404 Not Found')
return _path_parts(request.repos.get_location(path, pathrev, rev)), rev
return _path_parts(path), rev
def setup_authorizer(cfg, username, rootname):
# No configured authorizer? No problem.
if not cfg.options.authorizer:
return None
# First, try to load a module with the configured name.
try:
exec('import vcauth.%s' % (cfg.options.authorizer))
except ImportError:
raise debug.ViewVCException(
'Invalid authorizer (%s) specified for root "%s"' \
% (cfg.options.authorizer, rootname),
'500 Internal Server Error')
# Now we'll get custom parameters for our particular root.
exec('my_auth = vcauth.%s' % (cfg.options.authorizer))
params = cfg.get_authorizer_params(cfg.options.authorizer, rootname)
# Finally, instantiate our Authorizer.
return my_auth.ViewVCAuthorizer(username, params)
def check_freshness(request, mtime=None, etag=None, weak=0):
cfg = request.cfg
# See if we are supposed to disable etags (for debugging, usually)
if not cfg.options.generate_etags:
return 0
request_etag = request_mtime = None
if etag is not None:
if weak:
etag = 'W/"%s"' % etag
else:
etag = '"%s"' % etag
request_etag = request.server.getenv('HTTP_IF_NONE_MATCH')
if mtime is not None:
try:
request_mtime = request.server.getenv('HTTP_IF_MODIFIED_SINCE')
request_mtime = rfc822.mktime_tz(rfc822.parsedate_tz(request_mtime))
except:
request_mtime = None
# if we have an etag, use that for freshness checking.
# if not available, then we use the last-modified time.
# if not available, then the document isn't fresh.
if etag is not None:
isfresh = (request_etag == etag)
elif mtime is not None:
isfresh = (request_mtime >= mtime)
else:
isfresh = 0
# require revalidation after the configured amount of time
if cfg and cfg.options.http_expiration_time >= 0:
expiration = compat.formatdate(time.time() +
cfg.options.http_expiration_time)
request.server.addheader('Expires', expiration)
request.server.addheader('Cache-Control',
'max-age=%d' % cfg.options.http_expiration_time)
if isfresh:
request.server.header(status='304 Not Modified')
else:
if etag is not None:
request.server.addheader('ETag', etag)
if mtime is not None:
request.server.addheader('Last-Modified', compat.formatdate(mtime))
return isfresh
def get_view_template(cfg, view_name, language="en"):
# See if the configuration specifies a template for this view. If
# not, use the default template path for this view.
tname = vars(cfg.templates).get(view_name) or view_name + ".ezt"
# Template paths are relative to the configurated template_dir (if
# any, "templates" otherwise), so build the template path as such.
tname = os.path.join(cfg.options.template_dir or "templates", tname)
# Allow per-language template selection.
tname = string.replace(tname, '%lang%', language)
# Finally, construct the whole template path.
tname = cfg.path(tname)
debug.t_start('ezt-parse')
template = ezt.Template(tname)
debug.t_end('ezt-parse')
return template
def get_writeready_server_file(request, content_type=None):
"""Return a file handle to a response body stream, after outputting
any queued special headers (on REQUEST.server) and (optionally) a
'Content-Type' header whose value is CONTENT_TYPE. After this is
called, it is too late to add new headers to the response."""
if request.gzip_compress_level:
request.server.addheader('Content-Encoding', 'gzip')
if content_type:
request.server.header(content_type)
else:
request.server.header()
if request.gzip_compress_level:
fp = gzip.GzipFile('', 'wb', request.gzip_compress_level,
request.server.file())
else:
fp = request.server.file()
return fp
def generate_page(request, view_name, data, content_type=None):
server_fp = get_writeready_server_file(request)
template = get_view_template(request.cfg, view_name, request.language)
template.generate(server_fp, data)
def nav_path(request):
"""Return current path as list of items with "name" and "href" members
The href members are view_directory links for directories and view_log
links for files, but are set to None when the link would point to
the current view"""
if not request.repos:
return []
is_dir = request.pathtype == vclib.DIR
# add root item
items = []
root_item = _item(name=request.server.escape(request.repos.name), href=None)
if request.path_parts or request.view_func is not view_directory:
root_item.href = request.get_url(view_func=view_directory,
where='', pathtype=vclib.DIR,
params={}, escape=1)
items.append(root_item)
# add path part items
path_parts = []
for part in request.path_parts:
path_parts.append(part)
is_last = len(path_parts) == len(request.path_parts)
item = _item(name=part, href=None)
if not is_last or (is_dir and request.view_func is not view_directory):
item.href = request.get_url(view_func=view_directory,
where=_path_join(path_parts),
pathtype=vclib.DIR,
params={}, escape=1)
elif not is_dir and request.view_func is not view_log:
item.href = request.get_url(view_func=view_log,
where=_path_join(path_parts),
pathtype=vclib.FILE,
params={}, escape=1)
items.append(item)
return items
def prep_tags(request, tags):
url, params = request.get_link(params={'pathrev': None})
params = compat.urlencode(params)
if params:
url = urllib.quote(url, _URL_SAFE_CHARS) + '?' + params + '&pathrev='
else:
url = urllib.quote(url, _URL_SAFE_CHARS) + '?pathrev='
url = request.server.escape(url)
links = [ ]
for tag in tags:
links.append(_item(name=tag.name, href=url+tag.name))
links.sort(lambda a, b: cmp(a.name, b.name))
return links
def guess_mime(filename):
return mimetypes.guess_type(filename)[0]
def is_viewable_image(mime_type):
return mime_type and mime_type in ('image/gif', 'image/jpeg', 'image/png')
def is_text(mime_type):
return not mime_type or mime_type[:5] == 'text/'
def is_cvsroot_path(roottype, path_parts):
return roottype == 'cvs' and path_parts and path_parts[0] == 'CVSROOT'
def is_plain_text(mime_type):
return not mime_type or mime_type == 'text/plain'
def default_view(mime_type, cfg):
"Determine whether file should be viewed through markup page or sent raw"
# If the mime type is text/anything or a supported image format we view
# through the markup page. If the mime type is something else, we send
# it directly to the browser. That way users can see things like flash
# animations, pdfs, word documents, multimedia, etc, which wouldn't be
# very useful marked up. If the mime type is totally unknown (happens when
# we encounter an unrecognized file extension) we also view it through
# the markup page since that's better than sending it text/plain.
if ('markup' in cfg.options.allowed_views and
(is_viewable_image(mime_type) or is_text(mime_type))):
return view_markup
return view_checkout
def get_file_view_info(request, where, rev=None, mime_type=None, pathrev=-1):
"""Return common hrefs and a viewability flag used for various views
of FILENAME at revision REV whose MIME type is MIME_TYPE."""
rev = rev and str(rev) or None
mime_type = mime_type or request.mime_type
if pathrev == -1: # cheesy default value, since we need to preserve None
pathrev = request.pathrev
view_href = None
download_href = None
download_text_href = None
annotate_href = None
revision_href = None
if 'markup' in request.cfg.options.allowed_views:
view_href = request.get_url(view_func=view_markup,
where=where,
pathtype=vclib.FILE,
params={'revision': rev,
'pathrev': pathrev},
escape=1)
if 'co' in request.cfg.options.allowed_views:
download_href = request.get_url(view_func=view_checkout,
where=where,
pathtype=vclib.FILE,
params={'revision': rev,
'pathrev': pathrev},
escape=1)
if not is_plain_text(mime_type):
download_text_href = request.get_url(view_func=view_checkout,
where=where,
pathtype=vclib.FILE,
params={'content-type': 'text/plain',
'revision': rev,
'pathrev': pathrev},
escape=1)
if 'annotate' in request.cfg.options.allowed_views:
annotate_href = request.get_url(view_func=view_annotate,
where=where,
pathtype=vclib.FILE,
params={'annotate': rev,
'pathrev': pathrev},
escape=1)
if request.roottype == 'svn':
revision_href = request.get_url(view_func=view_revision,
params={'revision': rev},
escape=1)
prefer_markup = default_view(mime_type, request.cfg) == view_markup
return view_href, download_href, download_text_href, \
annotate_href, revision_href, ezt.boolean(prefer_markup)
# Regular expressions for location text that looks like URLs and email
# addresses. Note that the regexps assume the text is already HTML-encoded.
_re_rewrite_url = re.compile('((http|https|ftp|file|svn|svn\+ssh)'
'(://[-a-zA-Z0-9%.~:_/]+)((\?|\&)'
'([-a-zA-Z0-9%.~:_]+)=([-a-zA-Z0-9%.~:_])+)*'
'(#([-a-zA-Z0-9%.~:_]+)?)?)')
_re_rewrite_email = re.compile('([-a-zA-Z0-9_.\+]+)@'
'(([-a-zA-Z0-9]+\.)+[A-Za-z]{2,4})')
def mangle_email_addresses(text, style=0):
# style=2: truncation mangling
if style == 2:
return re.sub(_re_rewrite_email, r'\1@…', text)
# style=1: entity-encoding and at-wrapping
if style == 1:
def _match_replace(matchobj):
return string.join(map(lambda x: '&#%d;' % (ord(x)),
matchobj.group(1)), '') \
+ ' {at} ' + \
string.join(map(lambda x: '&#%d;' % (ord(x)),
matchobj.group(2)), '')
return re.sub(_re_rewrite_email, _match_replace, text)
# otherwise, no mangling
return text
def htmlify(html, mangle_email_addrs=0):
if not html:
return html
# html = cgi.escape(html)
# html = re.sub(_re_rewrite_url, r'\1', html)
html = mangle_email_addresses(html, mangle_email_addrs)
return html
def format_log(log, cfg, htmlize=1):
if not log:
return log
if htmlize:
s = htmlify(log[:cfg.options.short_log_len],
cfg.options.mangle_email_addresses)
else:
s = cgi.escape(log[:cfg.options.short_log_len])
if cfg.options.mangle_email_addresses == 2:
s = re.sub(_re_rewrite_email, r'\1@...', s)
if len(log) > cfg.options.short_log_len:
s = s + '...'
return s
_time_desc = {
1 : 'second',
60 : 'minute',
3600 : 'hour',
86400 : 'day',
604800 : 'week',
2628000 : 'month',
31536000 : 'year',
}
def get_time_text(request, interval, num):
"Get some time text, possibly internationalized."
### some languages have even harder pluralization rules. we'll have to
### deal with those on demand
if num == 0:
return ''
text = _time_desc[interval]
if num == 1:
attr = text + '_singular'
fmt = '%d ' + text
else:
attr = text + '_plural'
fmt = '%d ' + text + 's'
try:
fmt = getattr(request.kv.i18n.time, attr)
except AttributeError:
pass
return fmt % num
def little_time(request):
try:
return request.kv.i18n.time.little_time
except AttributeError:
return 'very little time'
def html_time(request, secs, extended=0):
secs = long(time.time()) - secs
if secs < 2:
return little_time(request)
breaks = _time_desc.keys()
breaks.sort()
i = 0
while i < len(breaks):
if secs < 2 * breaks[i]:
break
i = i + 1
value = breaks[i - 1]
s = get_time_text(request, value, secs / value)
if extended and i > 1:
secs = secs % value
value = breaks[i - 2]
ext = get_time_text(request, value, secs / value)
if ext:
### this is not i18n compatible. pass on it for now
s = s + ', ' + ext
return s
def common_template_data(request):
cfg = request.cfg
data = {
'cfg' : cfg,
'vsn' : __version__,
'kv' : request.kv,
'docroot' : cfg.options.docroot is None \
and request.script_name + '/' + docroot_magic_path \
or cfg.options.docroot,
'username' : request.username,
'where' : request.server.escape(request.where),
'roottype' : request.roottype,
'rootname' : request.rootname \
and request.server.escape(request.rootname) or None,
'rootpath' : request.rootpath,
'pathtype' : None,
'nav_path' : nav_path(request),
'view' : _view_codes[request.view_func],
'rev' : None,
'lockinfo' : None,
'view_href' : None,
'annotate_href' : None,
'download_href' : None,
'download_text_href' : None,
'revision_href' : None,
'queryform_href' : None,
'tarball_href' : None,
'up_href' : None,
'log_href' : None,
'log_href_rev': None,
'graph_href': None,
'rss_href' : None,
'roots_href' : request.get_url(view_func=view_roots, escape=1, params={}),
'prefer_markup' : ezt.boolean(0),
}
rev = request.query_dict.get('annotate')
if not rev:
rev = request.query_dict.get('revision')
if not rev and request.roottype == 'svn':
rev = request.query_dict.get('pathrev')
try:
data['rev'] = hasattr(request.repos, '_getrev') \
and request.repos._getrev(rev) or rev
except vclib.InvalidRevision:
raise debug.ViewVCException('Invalid revision', '404 Not Found')
if request.pathtype == vclib.DIR:
data['pathtype'] = 'dir'
elif request.pathtype == vclib.FILE:
data['pathtype'] = 'file'
if request.path_parts:
dir = _path_join(request.path_parts[:-1])
data['up_href'] = request.get_url(view_func=view_directory,
where=dir, pathtype=vclib.DIR,
params={}, escape=1)
if request.pathtype == vclib.FILE:
data['view_href'], data['download_href'], data['download_text_href'], \
data['annotate_href'], data['revision_href'], data['prefer_markup'] \
= get_file_view_info(request, request.where,
data['rev'], request.mime_type)
data['log_href'] = request.get_url(view_func=view_log,
params={}, escape=1)
if request.roottype == 'cvs' and cfg.options.use_cvsgraph:
data['graph_href'] = request.get_url(view_func=view_cvsgraph,
params={}, escape=1)
file_data = request.repos.listdir(request.path_parts[:-1],
request.pathrev, {})
def _only_this_file(item):
return item.name == request.path_parts[-1]
entries = filter(_only_this_file, file_data)
if len(entries) == 1:
request.repos.dirlogs(request.path_parts[:-1], request.pathrev,
entries, {})
data['lockinfo'] = entries[0].lockinfo
elif request.pathtype == vclib.DIR:
data['view_href'] = request.get_url(view_func=view_directory,
params={}, escape=1)
if 'tar' in cfg.options.allowed_views:
data['tarball_href'] = request.get_url(view_func=download_tarball,
params={},
escape=1)
if request.roottype == 'svn':
data['revision_href'] = request.get_url(view_func=view_revision,
params={'revision': data['rev']},
escape=1)
data['log_href'] = request.get_url(view_func=view_log,
params={}, escape=1)
if is_query_supported(request):
params = {}
if request.roottype == 'cvs' and request.pathrev:
params['branch'] = request.pathrev
data['queryform_href'] = request.get_url(view_func=view_queryform,
params=params,
escape=1)
if request.cfg.cvsdb.enabled and request.roottype in ['cvs', 'svn']:
if request.pathtype == vclib.DIR:
data['rss_href'] = request.get_url(view_func=view_query,
params={'date': 'month',
'format': 'rss'},
escape=1)
elif request.pathtype == vclib.FILE:
parts = _path_parts(request.where)
where = _path_join(parts[:-1])
data['rss_href'] = request.get_url(view_func=view_query,
where=where,
pathtype=request.pathtype,
params={'date': 'month',
'format': 'rss',
'file': parts[-1],
'file_match': 'exact'},
escape=1)
return data
def retry_read(src, reqlen=CHUNK_SIZE):
while 1:
chunk = src.read(CHUNK_SIZE)
if not chunk:
# need to check for eof methods because the cStringIO file objects
# returned by ccvs don't provide them
if hasattr(src, 'eof') and src.eof() is None:
time.sleep(1)
continue
return chunk
def copy_stream(src, dst, cfg, htmlize=0):
while 1:
chunk = retry_read(src)
if not chunk:
break
if htmlize:
chunk = htmlify(chunk, mangle_email_addrs=0)
dst.write(chunk)
class MarkupPipeWrapper:
"""An EZT callback that outputs a filepointer, plus some optional
pre- and post- text."""
def __init__(self, cfg, fp, pretext=None, posttext=None, htmlize=1):
self.fp = fp
self.cfg = cfg
self.pretext = pretext
self.posttext = posttext
self.htmlize = htmlize
def __call__(self, ctx):
if self.pretext:
ctx.fp.write(self.pretext)
copy_stream(self.fp, ctx.fp, self.cfg, self.htmlize)
self.fp.close()
if self.posttext:
ctx.fp.write(self.posttext)
def markup_stream_pygments(request, cfg, blame_data, fp, path_parts):
# Determine if we should use Pygments to highlight our output.
# Reasons not to include a) being told not to by the configuration,
# b) not being able to import the Pygments modules, and c) Pygments
# not having a lexer for our file's format.
blame_source = []
if blame_data:
for i in blame_data:
i.text = cgi.escape(i.text)
i.diff_href = None
if i.prev_rev:
i.diff_href = request.get_url(view_func=view_diff,
params={'r1': i.prev_rev,
'r2': i.rev},
escape=1, partial=1)
blame_source.append(i)
blame_data = blame_source
lexer = None
use_pygments = cfg.options.enable_syntax_coloration
try:
from pygments import highlight
from pygments.formatters import HtmlFormatter
from pygments.lexers import ClassNotFound, \
get_lexer_by_name, \
get_lexer_for_filename
try:
lexer = get_lexer_for_filename(path_parts[-1])
except ClassNotFound:
use_pygments = 0
except ImportError:
use_pygments = 0
# If we aren't going to be highlighting anything, just return the
# BLAME_SOURCE. If there's no blame_source, we'll generate a fake
# one from the file contents we fetch with PATH and REV.
if not use_pygments:
if blame_source:
return blame_source
else:
lines = []
line_no = 0
while 1:
line = fp.readline()
if not line:
break
line_no = line_no + 1
item = vclib.Annotation(cgi.escape(line), line_no,
None, None, None, None)
item.diff_href = None
lines.append(item)
return lines
# If we get here, we're highlighting something.
class PygmentsSink:
def __init__(self, blame_data):
if blame_data:
self.has_blame_data = 1
self.blame_data = blame_data
else:
self.has_blame_data = 0
self.blame_data = []
self.line_no = 0
def write(self, buf):
### FIXME: Don't bank on write() being called once per line
if self.has_blame_data:
self.blame_data[self.line_no].text = buf
else:
item = vclib.Annotation(buf, self.line_no + 1,
None, None, None, None)
item.diff_href = None
self.blame_data.append(item)
self.line_no = self.line_no + 1
ps = PygmentsSink(blame_source)
highlight(fp.read(), lexer,
HtmlFormatter(nowrap=True,
classprefix="pygments-",
encoding='utf-8'), ps)
return ps.blame_data
def make_time_string(date, cfg):
"""Returns formatted date string in either local time or UTC.
The passed in 'date' variable is seconds since epoch.
"""
if date is None:
return None
if cfg.options.use_localtime:
localtime = time.localtime(date)
return time.asctime(localtime) + ' ' + time.tzname[localtime[8]]
else:
return time.asctime(time.gmtime(date)) + ' UTC'
def make_rss_time_string(date, cfg):
"""Returns formatted date string in UTC, formatted for RSS.
The passed in 'date' variable is seconds since epoch.
"""
if date is None:
return None
return time.strftime("%a, %d %b %Y %H:%M:%S", time.gmtime(date)) + ' UTC'
def get_itemprops(request, path_parts, rev):
itemprops = request.repos.itemprops(path_parts, rev)
propnames = itemprops.keys()
propnames.sort()
props = []
has_binary_props = 0
for name in propnames:
value = itemprops[name]
undisplayable = ezt.boolean(0)
# skip non-utf8 property names
try:
unicode(name, 'utf8')
except:
continue
# note non-utf8 property values
try:
unicode(value, 'utf8')
except:
value = None
undisplayable = ezt.boolean(1)
props.append(_item(name=name, value=value, undisplayable=undisplayable))
return props
def markup_or_annotate(request, is_annotate):
cfg = request.cfg
path, rev = _orig_path(request, is_annotate and 'annotate' or 'revision')
data = common_template_data(request)
lines = fp = image_src_href = None
annotation = None
# Is this a viewable image type?
if is_viewable_image(request.mime_type) \
and 'co' in cfg.options.allowed_views:
fp, revision = request.repos.openfile(path, rev)
fp.close()
if check_freshness(request, None, revision, weak=1):
return
annotation = 'binary'
image_src_href = request.get_url(view_func=view_checkout,
params={'revision': rev}, escape=1)
# Not a viewable image.
else:
blame_source = None
if is_annotate:
# Try to annotate this file, but don't croak if we fail.
try:
blame_source, revision = request.repos.annotate(path, rev)
annotation = 'annotated'
if check_freshness(request, None, revision, weak=1):
return
except vclib.NonTextualFileContents:
annotation = 'binary'
except:
annotation = 'error'
fp, revision = request.repos.openfile(path, rev)
if check_freshness(request, None, revision, weak=1):
fp.close()
return
lines = markup_stream_pygments(request, cfg, blame_source, fp, path)
fp.close()
data.update({
'mime_type' : request.mime_type,
'log' : None,
'date' : None,
'ago' : None,
'author' : None,
'branches' : None,
'tags' : None,
'branch_points' : None,
'changed' : None,
'size' : None,
'state' : None,
'vendor_branch' : None,
'prev' : None,
'orig_path' : None,
'orig_href' : None,
'image_src_href' : image_src_href,
'lines' : lines,
'properties' : get_itemprops(request, path, rev),
'annotation' : annotation,
})
if cfg.options.show_log_in_markup:
options = {'svn_latest_log': 1} ### FIXME: No longer needed?
revs = request.repos.itemlog(path, revision, vclib.SORTBY_DEFAULT,
0, 1, options)
entry = revs[-1]
data.update({
'date' : make_time_string(entry.date, cfg),
'author' : entry.author,
'changed' : entry.changed,
'log' : htmlify(entry.log, cfg.options.mangle_email_addresses),
'size' : entry.size,
})
if entry.date is not None:
data['ago'] = html_time(request, entry.date, 1)
if request.roottype == 'cvs':
branch = entry.branch_number
prev = entry.prev or entry.parent
data.update({
'state' : entry.dead and 'dead',
'prev' : prev and prev.string,
'vendor_branch' : ezt.boolean(branch and branch[2] % 2 == 1),
'branches' : string.join(map(lambda x: x.name, entry.branches), ', '),
'tags' : string.join(map(lambda x: x.name, entry.tags), ', '),
'branch_points': string.join(map(lambda x: x.name,
entry.branch_points), ', ')
})
if path != request.path_parts:
orig_path = _path_join(path)
data['orig_path'] = orig_path
data['orig_href'] = request.get_url(view_func=view_log,
where=orig_path,
pathtype=vclib.FILE,
params={'pathrev': revision},
escape=1)
generate_page(request, "file", data)
def view_markup(request):
if 'markup' not in request.cfg.options.allowed_views:
raise debug.ViewVCException('Markup view is disabled',
'403 Forbidden')
markup_or_annotate(request, 0)
def view_annotate(request):
if 'annotate' not in request.cfg.options.allowed_views:
raise debug.ViewVCException('Annotation view is disabled',
'403 Forbidden')
markup_or_annotate(request, 1)
def revcmp(rev1, rev2):
rev1 = map(int, string.split(rev1, '.'))
rev2 = map(int, string.split(rev2, '.'))
return cmp(rev1, rev2)
def sort_file_data(file_data, roottype, sortdir, sortby, group_dirs):
# convert sortdir into a sign bit
s = sortdir == "down" and -1 or 1
# in cvs, revision numbers can't be compared meaningfully between
# files, so try to do the right thing and compare dates instead
if roottype == "cvs" and sortby == "rev":
sortby = "date"
def file_sort_cmp(file1, file2, sortby=sortby, group_dirs=group_dirs, s=s):
# if we're grouping directories together, sorting is pretty
# simple. a directory sorts "higher" than a non-directory, and
# two directories are sorted as normal.
if group_dirs:
if file1.kind == vclib.DIR:
if file2.kind == vclib.DIR:
# two directories, no special handling.
pass
else:
# file1 is a directory, it sorts first.
return -1
elif file2.kind == vclib.DIR:
# file2 is a directory, it sorts first.
return 1
# we should have data on these. if not, then it is because we requested
# a specific tag and that tag is not present on the file.
if file1.rev is not None and file2.rev is not None:
# sort according to sortby
if sortby == 'rev':
return s * revcmp(file1.rev, file2.rev)
elif sortby == 'date':
return s * cmp(file2.date, file1.date) # latest date is first
elif sortby == 'log':
return s * cmp(file1.log, file2.log)
elif sortby == 'author':
return s * cmp(file1.author, file2.author)
elif file1.rev is not None:
return -1
elif file2.rev is not None:
return 1
# sort by file name
return s * cmp(file1.name, file2.name)
file_data.sort(file_sort_cmp)
def icmp(x, y):
"""case insensitive comparison"""
return cmp(string.lower(x), string.lower(y))
def view_roots(request):
# add in the roots for the selection
roots = []
expand_root_parents(request.cfg)
allroots = list_roots(request)
if len(allroots):
rootnames = allroots.keys()
rootnames.sort(icmp)
for rootname in rootnames:
href = request.get_url(view_func=view_directory,
where='', pathtype=vclib.DIR,
params={'root': rootname}, escape=1)
roots.append(_item(name=request.server.escape(rootname),
type=allroots[rootname][1],
path=allroots[rootname][0],
href=href))
data = common_template_data(request)
data['roots'] = roots
generate_page(request, "roots", data)
def view_directory(request):
# For Subversion repositories, the revision acts as a weak validator for
# the directory listing (to take into account template changes or
# revision property changes).
if request.roottype == 'svn':
try:
rev = request.repos._getrev(request.pathrev)
except vclib.InvalidRevision:
raise debug.ViewVCException('Invalid revision', '404 Not Found')
tree_rev = request.repos.created_rev(request.where, rev)
if check_freshness(request, None, str(tree_rev), weak=1):
return
# List current directory
cfg = request.cfg
options = {}
if request.roottype == 'cvs':
hideattic = int(request.query_dict.get('hideattic',
cfg.options.hide_attic))
options["cvs_subdirs"] = (cfg.options.show_subdir_lastmod and
cfg.options.show_logs)
file_data = request.repos.listdir(request.path_parts, request.pathrev,
options)
# sort with directories first, and using the "sortby" criteria
sortby = request.query_dict.get('sortby', cfg.options.sort_by) or 'file'
sortdir = request.query_dict.get('sortdir', 'up')
# when paging and sorting by filename, we can greatly improve
# performance by "cheating" -- first, we sort (we already have the
# names), then we just fetch dirlogs for the needed entries.
# however, when sorting by other properties or not paging, we've no
# choice but to fetch dirlogs for everything.
debug.t_start("dirlogs")
if cfg.options.use_pagesize and sortby == 'file':
dirlogs_first = int(request.query_dict.get('dir_pagestart', 0))
if dirlogs_first > len(file_data):
dirlogs_first = 0
dirlogs_last = dirlogs_first + cfg.options.use_pagesize
for file in file_data:
file.rev = None
file.date = None
file.log = None
file.author = None
file.size = None
file.lockinfo = None
file.dead = None
sort_file_data(file_data, request.roottype, sortdir, sortby,
cfg.options.sort_group_dirs)
# request dirlogs only for the slice of files in "this page"
request.repos.dirlogs(request.path_parts, request.pathrev,
file_data[dirlogs_first:dirlogs_last], options)
else:
request.repos.dirlogs(request.path_parts, request.pathrev,
file_data, options)
sort_file_data(file_data, request.roottype, sortdir, sortby,
cfg.options.sort_group_dirs)
debug.t_end("dirlogs")
# If a regex is specified, build a compiled form thereof for filtering
searchstr = None
search_re = request.query_dict.get('search', '')
if cfg.options.use_re_search and search_re:
searchstr = re.compile(search_re)
# loop through entries creating rows and changing these values
rows = [ ]
num_displayed = 0
num_dead = 0
# set some values to be used inside loop
where = request.where
where_prefix = where and where + '/'
for file in file_data:
row = _item(author=None, log=None, short_log=None, state=None, size=None,
log_file=None, log_rev=None, graph_href=None, mime_type=None,
date=None, ago=None, view_href=None, log_href=None,
revision_href=None, annotate_href=None, download_href=None,
download_text_href=None, prefer_markup=ezt.boolean(0))
row.rev = file.rev
row.author = file.author
row.state = (request.roottype == 'cvs' and file.dead) and 'dead' or ''
if file.date is not None:
row.date = make_time_string(file.date, cfg)
row.ago = html_time(request, file.date)
if cfg.options.show_logs:
row.short_log = format_log(file.log, cfg)
row.log = htmlify(file.log, cfg.options.mangle_email_addresses)
row.lockinfo = file.lockinfo
row.anchor = request.server.escape(file.name)
row.name = request.server.escape(file.name)
row.pathtype = (file.kind == vclib.FILE and 'file') or \
(file.kind == vclib.DIR and 'dir')
row.errors = file.errors
if file.kind == vclib.DIR:
if cfg.options.hide_cvsroot \
and is_cvsroot_path(request.roottype,
request.path_parts + [file.name]):
continue
row.view_href = request.get_url(view_func=view_directory,
where=where_prefix+file.name,
pathtype=vclib.DIR,
params={},
escape=1)
if request.roottype == 'svn':
row.revision_href = request.get_url(view_func=view_revision,
params={'revision': file.rev},
escape=1)
if request.roottype == 'cvs' and file.rev is not None:
row.rev = None
if cfg.options.show_logs:
row.log_file = file.newest_file
row.log_rev = file.rev
if request.roottype == 'svn':
row.log_href = request.get_url(view_func=view_log,
where=where_prefix + file.name,
pathtype=vclib.DIR,
params={},
escape=1)
elif file.kind == vclib.FILE:
if searchstr is not None:
if request.roottype == 'cvs' and (file.errors or file.dead):
continue
if not search_file(request.repos, request.path_parts + [file.name],
request.pathrev, searchstr):
continue
if request.roottype == 'cvs' and file.dead:
num_dead = num_dead + 1
if hideattic:
continue
num_displayed = num_displayed + 1
file_where = where_prefix + file.name
if request.roottype == 'svn':
row.size = file.size
### for Subversion, we should first try to get this from the properties
row.mime_type = guess_mime(file.name)
row.view_href, row.download_href, row.download_text_href, \
row.annotate_href, row.revision_href, \
row.prefer_markup \
= get_file_view_info(request, file_where, file.rev, row.mime_type)
row.log_href = request.get_url(view_func=view_log,
where=file_where,
pathtype=vclib.FILE,
params={},
escape=1)
if cfg.options.use_cvsgraph and request.roottype == 'cvs':
row.graph_href = request.get_url(view_func=view_cvsgraph,
where=file_where,
pathtype=vclib.FILE,
params={},
escape=1)
rows.append(row)
# prepare the data that will be passed to the template
data = common_template_data(request)
data.update({
'entries' : rows,
'sortby' : sortby,
'sortdir' : sortdir,
'search_re' : search_re \
and htmlify(search_re, cfg.options.mangle_email_addresses) \
or None,
'dir_pagestart' : None,
'sortby_file_href' : request.get_url(params={'sortby': 'file',
'sortdir': None},
escape=1),
'sortby_rev_href' : request.get_url(params={'sortby': 'rev',
'sortdir': None},
escape=1),
'sortby_date_href' : request.get_url(params={'sortby': 'date',
'sortdir': None},
escape=1),
'sortby_author_href' : request.get_url(params={'sortby': 'author',
'sortdir': None},
escape=1),
'sortby_log_href' : request.get_url(params={'sortby': 'log',
'sortdir': None},
escape=1),
'files_shown' : num_displayed,
'num_dead' : num_dead,
'youngest_rev' : None,
'youngest_rev_href' : None,
'selection_form' : None,
'attic_showing' : None,
'show_attic_href' : None,
'hide_attic_href' : None,
'branch_tags': None,
'plain_tags': None,
'properties': get_itemprops(request, request.path_parts, request.pathrev),
})
# clicking on sort column reverses sort order
if sortdir == 'down':
revsortdir = None # 'up'
else:
revsortdir = 'down'
if sortby in ['file', 'rev', 'date', 'log', 'author']:
data['sortby_%s_href' % sortby] = request.get_url(params={'sortdir':
revsortdir},
escape=1)
# set cvs-specific fields
if request.roottype == 'cvs':
plain_tags = options['cvs_tags']
plain_tags.sort(icmp)
plain_tags.reverse()
branch_tags = options['cvs_branches']
branch_tags.sort(icmp)
branch_tags.reverse()
data.update({
'attic_showing' : ezt.boolean(not hideattic),
'show_attic_href' : request.get_url(params={'hideattic': 0}, escape=1),
'hide_attic_href' : request.get_url(params={'hideattic': 1}, escape=1),
'branch_tags': branch_tags,
'plain_tags': plain_tags,
})
# set svn-specific fields
elif request.roottype == 'svn':
data['tree_rev'] = tree_rev
data['tree_rev_href'] = request.get_url(view_func=view_revision,
params={'revision': tree_rev},
escape=1)
data['youngest_rev'] = request.repos.get_youngest_revision()
data['youngest_rev_href'] = request.get_url(view_func=view_revision,
params={},
escape=1)
if cfg.options.use_pagesize:
data['dir_paging_action'], data['dir_paging_hidden_values'] = \
request.get_form(params={'dir_pagestart': None})
pathrev_form(request, data)
### one day, if EZT has "or" capability, we can lose this
data['search_re_form'] = ezt.boolean(cfg.options.use_re_search)
if data['search_re_form']:
data['search_re_action'], data['search_re_hidden_values'] = \
request.get_form(params={'search': None})
if cfg.options.use_pagesize:
data['dir_pagestart'] = int(request.query_dict.get('dir_pagestart',0))
data['entries'] = paging(data, 'entries', data['dir_pagestart'], 'name',
cfg.options.use_pagesize)
generate_page(request, "directory", data)
def paging(data, key, pagestart, local_name, pagesize):
# Implement paging
# Create the picklist
picklist = data['picklist'] = []
for i in range(0, len(data[key]), pagesize):
pick = _item(start=None, end=None, count=None, more=ezt.boolean(0))
pick.start = getattr(data[key][i], local_name)
pick.count = i
pick.page = (i / pagesize) + 1
try:
pick.end = getattr(data[key][i+pagesize-1], local_name)
except IndexError:
pick.end = getattr(data[key][-1], local_name)
picklist.append(pick)
data['picklist_len'] = len(picklist)
# Need to fix
# pagestart can be greater than the length of data[key] if you
# select a tag or search while on a page other than the first.
# Should reset to the first page, this test won't do that every
# time that it is needed.
# Problem might go away if we don't hide non-matching files when
# selecting for tags or searching.
if pagestart > len(data[key]):
pagestart = 0
pageend = pagestart + pagesize
# Slice
return data[key][pagestart:pageend]
def paging_sws(data, key, pagestart, local_name, pagesize, offset):
"""Implement sliding window-style paging."""
# Create the picklist
last_requested = pagestart + (EXTRA_PAGES * pagesize)
picklist = data['picklist'] = []
has_more = ezt.boolean(0)
for i in range(0, len(data[key]), pagesize):
pick = _item(start=None, end=None, count=None, more=ezt.boolean(0))
pick.start = getattr(data[key][i], local_name)
pick.count = offset + i
pick.page = (pick.count / pagesize) + 1
try:
pick.end = getattr(data[key][i+pagesize-1], local_name)
except IndexError:
pick.end = getattr(data[key][-1], local_name)
picklist.append(pick)
if pick.count >= last_requested:
pick.more = ezt.boolean(1)
break
data['picklist_len'] = len(picklist)
first = pagestart - offset
# FIXME: first can be greater than the length of data[key] if
# you select a tag or search while on a page other than the first.
# Should reset to the first page, but this test won't do that every
# time that it is needed. Problem might go away if we don't hide
# non-matching files when selecting for tags or searching.
if first > len(data[key]):
pagestart = 0
pageend = first + pagesize
# Slice
return data[key][first:pageend]
def pathrev_form(request, data):
lastrev = None
if request.roottype == 'svn':
data['pathrev_action'], data['pathrev_hidden_values'] = \
request.get_form(view_func=redirect_pathrev,
params={'pathrev': None,
'orig_path': request.where,
'orig_pathtype': request.pathtype,
'orig_pathrev': request.pathrev,
'orig_view': _view_codes.get(request.view_func)})
if request.pathrev:
youngest = request.repos.get_youngest_revision()
lastrev = request.repos.last_rev(request.where, request.pathrev,
youngest)[0]
if lastrev == youngest:
lastrev = None
data['pathrev'] = request.pathrev
data['lastrev'] = lastrev
action, hidden_values = request.get_form(params={'pathrev': lastrev})
if request.roottype != 'svn':
data['pathrev_action'] = action
data['pathrev_hidden_values'] = hidden_values
data['pathrev_clear_action'] = action
data['pathrev_clear_hidden_values'] = hidden_values
return lastrev
def redirect_pathrev(request):
assert request.roottype == 'svn'
new_pathrev = request.query_dict.get('pathrev') or None
path = request.query_dict.get('orig_path', '')
pathtype = request.query_dict.get('orig_pathtype')
pathrev = request.query_dict.get('orig_pathrev')
view = _views.get(request.query_dict.get('orig_view'))
youngest = request.repos.get_youngest_revision()
# go out of the way to allow revision numbers higher than youngest
try:
new_pathrev = int(new_pathrev)
except ValueError:
new_pathrev = youngest
except TypeError:
pass
else:
if new_pathrev > youngest:
new_pathrev = youngest
if _repos_pathtype(request.repos, _path_parts(path), new_pathrev):
pathrev = new_pathrev
else:
pathrev, path = request.repos.last_rev(path, pathrev, new_pathrev)
# allow clearing sticky revision by submitting empty string
if new_pathrev is None and pathrev == youngest:
pathrev = None
request.server.redirect(request.get_url(view_func=view,
where=path,
pathtype=pathtype,
params={'pathrev': pathrev}))
def view_log(request):
cfg = request.cfg
diff_format = request.query_dict.get('diff_format', cfg.options.diff_format)
pathtype = request.pathtype
if pathtype is vclib.DIR and request.roottype == 'cvs':
raise debug.ViewVCException('Unsupported feature: log view on CVS '
'directory', '400 Bad Request')
options = {}
options['svn_show_all_dir_logs'] = 1 ### someday make this optional?
options['svn_cross_copies'] = cfg.options.cross_copies
logsort = request.query_dict.get('logsort', cfg.options.log_sort)
if request.roottype == "svn":
sortby = vclib.SORTBY_DEFAULT
logsort = None
else:
if logsort == 'date':
sortby = vclib.SORTBY_DATE
elif logsort == 'rev':
sortby = vclib.SORTBY_REV
else:
sortby = vclib.SORTBY_DEFAULT
first = last = 0
if cfg.options.use_pagesize:
log_pagestart = int(request.query_dict.get('log_pagestart', 0))
first = log_pagestart - min(log_pagestart,
(EXTRA_PAGES * cfg.options.use_pagesize))
last = log_pagestart + ((EXTRA_PAGES + 1) * cfg.options.use_pagesize) + 1
show_revs = request.repos.itemlog(request.path_parts, request.pathrev,
sortby, first, last - first, options)
# selected revision
selected_rev = request.query_dict.get('r1')
entries = [ ]
name_printed = { }
cvs = request.roottype == 'cvs'
for rev in show_revs:
entry = _item()
entry.rev = rev.string
entry.state = (cvs and rev.dead and 'dead')
entry.author = rev.author
entry.changed = rev.changed
entry.date = make_time_string(rev.date, cfg)
entry.ago = None
if rev.date is not None:
entry.ago = html_time(request, rev.date, 1)
entry.log = htmlify(rev.log or "", cfg.options.mangle_email_addresses)
entry.size = rev.size
entry.lockinfo = rev.lockinfo
entry.branch_point = None
entry.next_main = None
entry.orig_path = None
entry.copy_path = None
entry.view_href = None
entry.download_href = None
entry.download_text_href = None
entry.annotate_href = None
entry.revision_href = None
entry.sel_for_diff_href = None
entry.diff_to_sel_href = None
entry.diff_to_prev_href = None
entry.diff_to_branch_href = None
entry.diff_to_main_href = None
if request.roottype == 'cvs':
prev = rev.prev or rev.parent
entry.prev = prev and prev.string
branch = rev.branch_number
entry.vendor_branch = ezt.boolean(branch and branch[2] % 2 == 1)
entry.branches = prep_tags(request, rev.branches)
entry.tags = prep_tags(request, rev.tags)
entry.branch_points = prep_tags(request, rev.branch_points)
entry.tag_names = map(lambda x: x.name, rev.tags)
if branch and not name_printed.has_key(branch):
entry.branch_names = map(lambda x: x.name, rev.branches)
name_printed[branch] = 1
else:
entry.branch_names = [ ]
if rev.parent and rev.parent is not prev and not entry.vendor_branch:
entry.branch_point = rev.parent.string
# if it's the last revision on a branch then diff against the
# last revision on the higher branch (e.g. change is committed and
# brought over to -stable)
if not rev.next and rev.parent and rev.parent.next:
r = rev.parent.next
while r.next:
r = r.next
entry.next_main = r.string
elif request.roottype == 'svn':
entry.prev = rev.prev and rev.prev.string
entry.branches = entry.tags = entry.branch_points = [ ]
entry.tag_names = entry.branch_names = [ ]
entry.vendor_branch = None
if rev.filename != request.where:
entry.orig_path = rev.filename
entry.copy_path = rev.copy_path
entry.copy_rev = rev.copy_rev
if entry.orig_path:
entry.orig_href = request.get_url(view_func=view_log,
where=entry.orig_path,
pathtype=vclib.FILE,
params={'pathrev': rev.string},
escape=1)
if rev.copy_path:
entry.copy_href = request.get_url(view_func=view_log,
where=rev.copy_path,
pathtype=vclib.FILE,
params={'pathrev': rev.copy_rev},
escape=1)
# view/download links
if pathtype is vclib.FILE:
entry.view_href, entry.download_href, entry.download_text_href, \
entry.annotate_href, entry.revision_href, entry.prefer_markup \
= get_file_view_info(request, request.where, rev.string,
request.mime_type)
else:
entry.revision_href = request.get_url(view_func=view_revision,
params={'revision': rev.string},
escape=1)
entry.view_href = request.get_url(view_func=view_directory,
where=rev.filename,
pathtype=vclib.DIR,
params={'pathrev': rev.string},
escape=1)
# calculate diff links
if selected_rev != entry.rev:
entry.sel_for_diff_href = \
request.get_url(view_func=view_log,
params={'r1': entry.rev},
escape=1)
if entry.prev is not None:
entry.diff_to_prev_href = \
request.get_url(view_func=view_diff,
params={'r1': entry.prev,
'r2': entry.rev,
'diff_format': None},
escape=1)
if selected_rev and \
selected_rev != str(entry.rev) and \
selected_rev != str(entry.prev) and \
selected_rev != str(entry.branch_point) and \
selected_rev != str(entry.next_main):
entry.diff_to_sel_href = \
request.get_url(view_func=view_diff,
params={'r1': selected_rev,
'r2': entry.rev,
'diff_format': None},
escape=1)
if entry.next_main:
entry.diff_to_main_href = \
request.get_url(view_func=view_diff,
params={'r1': entry.next_main,
'r2': entry.rev,
'diff_format': None},
escape=1)
if entry.branch_point:
entry.diff_to_branch_href = \
request.get_url(view_func=view_diff,
params={'r1': entry.branch_point,
'r2': entry.rev,
'diff_format': None},
escape=1)
# Save our escaping until the end so stuff above works
if entry.orig_path:
entry.orig_path = request.server.escape(entry.orig_path)
if entry.copy_path:
entry.copy_path = request.server.escape(entry.copy_path)
entries.append(entry)
data = common_template_data(request)
data.update({
'default_branch' : None,
'mime_type' : request.mime_type,
'rev_selected' : selected_rev,
'diff_format' : diff_format,
'logsort' : logsort,
'human_readable' : ezt.boolean(diff_format in ('h', 'l')),
'log_pagestart' : None,
'entries': entries,
'head_prefer_markup' : ezt.boolean(0),
'head_view_href' : None,
'head_download_href': None,
'head_download_text_href': None,
'head_annotate_href': None,
'tag_prefer_markup' : ezt.boolean(0),
'tag_view_href' : None,
'tag_download_href': None,
'tag_download_text_href': None,
'tag_annotate_href': None,
})
lastrev = pathrev_form(request, data)
data['diff_select_action'], data['diff_select_hidden_values'] = \
request.get_form(view_func=view_diff,
params={'r1': None, 'r2': None, 'tr1': None,
'tr2': None, 'diff_format': None})
data['logsort_action'], data['logsort_hidden_values'] = \
request.get_form(params={'logsort': None})
if pathtype is vclib.FILE:
if not request.pathrev or lastrev is None:
view_href, download_href, download_text_href, \
annotate_href, revision_href, prefer_markup \
= get_file_view_info(request, request.where, None,
request.mime_type, None)
data.update({
'head_view_href': view_href,
'head_download_href': download_href,
'head_download_text_href': download_text_href,
'head_annotate_href': annotate_href,
'head_prefer_markup': prefer_markup,
})
if request.pathrev and request.roottype == 'cvs':
view_href, download_href, download_text_href, \
annotate_href, revision_href, prefer_markup \
= get_file_view_info(request, request.where, None, request.mime_type)
data.update({
'tag_view_href': view_href,
'tag_download_href': download_href,
'tag_download_text_href': download_text_href,
'tag_annotate_href': annotate_href,
'tag_prefer_markup': prefer_markup,
})
else:
data['head_view_href'] = request.get_url(view_func=view_directory,
params={}, escape=1)
taginfo = options.get('cvs_tags', {})
tagitems = taginfo.items()
tagitems.sort()
tagitems.reverse()
main = taginfo.get('MAIN')
if main:
# Default branch may have multiple names so we list them
branches = []
for branch in main.aliases:
# Don't list MAIN
if branch is not main:
branches.append(branch)
data['default_branch'] = prep_tags(request, branches)
data['tags'] = tags = [ ]
data['branch_tags'] = branch_tags = []
data['plain_tags'] = plain_tags = []
for tag, rev in tagitems:
if rev.co_rev:
tags.append(_item(rev=rev.co_rev.string, name=tag))
if rev.is_branch:
branch_tags.append(tag)
else:
plain_tags.append(tag)
if cfg.options.use_pagesize:
data['log_paging_action'], data['log_paging_hidden_values'] = \
request.get_form(params={'log_pagestart': None})
data['log_pagestart'] = int(request.query_dict.get('log_pagestart',0))
data['entries'] = paging_sws(data, 'entries', data['log_pagestart'],
'rev', cfg.options.use_pagesize, first)
generate_page(request, "log", data)
def view_checkout(request):
cfg = request.cfg
if 'co' not in cfg.options.allowed_views:
raise debug.ViewVCException('Checkout view is disabled',
'403 Forbidden')
path, rev = _orig_path(request)
fp, revision = request.repos.openfile(path, rev)
# The revision number acts as a strong validator.
if not check_freshness(request, None, revision):
mime_type = request.query_dict.get('content-type') \
or request.mime_type or 'text/plain'
server_fp = get_writeready_server_file(request, mime_type)
copy_stream(fp, server_fp, cfg)
fp.close()
def view_cvsgraph_image(request):
"output the image rendered by cvsgraph"
# this function is derived from cgi/cvsgraphmkimg.cgi
cfg = request.cfg
if not cfg.options.use_cvsgraph:
raise debug.ViewVCException('Graph view is disabled', '403 Forbidden')
# If cvsgraph can't find its supporting libraries, uncomment and set
# accordingly. Do the same in view_cvsgraph().
#os.environ['LD_LIBRARY_PATH'] = '/usr/lib:/usr/local/lib:/path/to/cvsgraph'
rcsfile = request.repos.rcsfile(request.path_parts)
fp = popen.popen(cfg.utilities.cvsgraph or 'cvsgraph',
("-c", cfg.path(cfg.options.cvsgraph_conf),
"-r", request.repos.rootpath,
rcsfile), 'rb', 0)
copy_stream(fp, get_writeready_server_file(request, 'image/png'), cfg)
fp.close()
def view_cvsgraph(request):
"output a page containing an image rendered by cvsgraph"
cfg = request.cfg
if not cfg.options.use_cvsgraph:
raise debug.ViewVCException('Graph view is disabled', '403 Forbidden')
data = common_template_data(request)
# If cvsgraph can't find its supporting libraries, uncomment and set
# accordingly. Do the same in view_cvsgraph_image().
#os.environ['LD_LIBRARY_PATH'] = '/usr/lib:/usr/local/lib:/path/to/cvsgraph'
imagesrc = request.get_url(view_func=view_cvsgraph_image, escape=1)
view = default_view(request.mime_type, cfg)
up_where = _path_join(request.path_parts[:-1])
# Create an image map
rcsfile = request.repos.rcsfile(request.path_parts)
fp = popen.popen(cfg.utilities.cvsgraph or 'cvsgraph',
("-i",
"-c", cfg.path(cfg.options.cvsgraph_conf),
"-r", request.repos.rootpath,
"-x", "x",
"-3", request.get_url(view_func=view_log, params={},
escape=1),
"-4", request.get_url(view_func=view,
params={'revision': None},
escape=1, partial=1),
"-5", request.get_url(view_func=view_diff,
params={'r1': None, 'r2': None},
escape=1, partial=1),
"-6", request.get_url(view_func=view_directory,
where=up_where,
pathtype=vclib.DIR,
params={'pathrev': None},
escape=1, partial=1),
rcsfile), 'rb', 0)
data.update({
'imagemap' : fp,
'imagesrc' : imagesrc,
})
generate_page(request, "graph", data)
def search_file(repos, path_parts, rev, search_re):
"""Return 1 iff the contents of the file at PATH_PARTS in REPOS as
of revision REV matches regular expression SEARCH_RE."""
# Read in each line of a checked-out file, and then use re.search to
# search line.
fp = repos.openfile(path_parts, rev)[0]
matches = 0
while 1:
line = fp.readline()
if not line:
break
if search_re.search(line):
matches = 1
fp.close()
break
return matches
def view_doc(request):
"""Serve ViewVC static content locally.
Using this avoids the need for modifying the setup of the web server.
"""
cfg = request.cfg
document = request.where
filename = cfg.path(os.path.join(cfg.options.template_dir,
"docroot", document))
# Stat the file to get content length and last-modified date.
try:
info = os.stat(filename)
except OSError, v:
raise debug.ViewVCException('Static file "%s" not available (%s)'
% (document, str(v)), '404 Not Found')
content_length = str(info[stat.ST_SIZE])
last_modified = info[stat.ST_MTIME]
# content_length + mtime makes a pretty good etag.
if check_freshness(request, last_modified,
"%s-%s" % (content_length, last_modified)):
return
try:
fp = open(filename, "rb")
except IOError, v:
raise debug.ViewVCException('Static file "%s" not available (%s)'
% (document, str(v)), '404 Not Found')
request.server.addheader('Content-Length', content_length)
if document[-3:] == 'png':
mime_type = 'image/png'
elif document[-3:] == 'jpg':
mime_type = 'image/jpeg'
elif document[-3:] == 'gif':
mime_type = 'image/gif'
elif document[-3:] == 'css':
mime_type = 'text/css'
else: # assume HTML:
mime_type = None
copy_stream(fp, get_writeready_server_file(request, mime_type), cfg)
fp.close()
def rcsdiff_date_reformat(date_str, cfg):
if date_str is None:
return None
try:
date = compat.cvs_strptime(date_str)
except ValueError:
return date_str
return make_time_string(compat.timegm(date), cfg)
_re_extract_rev = re.compile(r'^[-+*]{3} [^\t]+\t([^\t]+)\t((\d+\.)*\d+)$')
_re_extract_info = re.compile(r'@@ \-([0-9]+).*\+([0-9]+).*@@(.*)')
class DiffSource:
def __init__(self, fp, cfg):
self.fp = fp
self.cfg = cfg
self.save_line = None
self.line_number = None
self.prev_line_number = None
# keep track of where we are during an iteration
self.idx = -1
self.last = None
# these will be set once we start reading
self.state = 'no-changes'
self.left_col = [ ]
self.right_col = [ ]
def __getitem__(self, idx):
if idx == self.idx:
return self.last
if idx != self.idx + 1:
raise DiffSequencingError()
# keep calling _get_row until it gives us something. sometimes, it
# doesn't return a row immediately because it is accumulating changes.
# when it is out of data, _get_row will raise IndexError.
while 1:
item = self._get_row()
if item:
self.idx = idx
self.last = item
return item
def _format_text(self, text):
text = string.expandtabs(string.rstrip(text))
hr_breakable = self.cfg.options.hr_breakable
# in the code below, "\x01" will be our stand-in for "&". We don't want
# to insert "&" because it would get escaped by htmlify(). Similarly,
# we use "\x02" as a stand-in for " "
if hr_breakable > 1 and len(text) > hr_breakable:
text = re.sub('(' + ('.' * hr_breakable) + ')', '\\1\x02', text)
if hr_breakable:
# make every other space "breakable"
text = string.replace(text, ' ', ' \x01nbsp;')
else:
text = string.replace(text, ' ', '\x01nbsp;')
text = htmlify(text, mangle_email_addrs=0)
text = string.replace(text, '\x01', '&')
text = string.replace(text, '\x02',
'\ ')
return text
def _get_row(self):
if self.state[:5] == 'flush':
item = self._flush_row()
if item:
return item
self.state = 'dump'
if self.save_line:
line = self.save_line
self.save_line = None
else:
line = self.fp.readline()
if not line:
if self.state == 'no-changes':
self.state = 'done'
return _item(type='no-changes')
# see if there are lines to flush
if self.left_col or self.right_col:
# move into the flushing state
self.state = 'flush-' + self.state
return None
# nothing more to return
raise IndexError
if line[:2] == '@@':
self.state = 'dump'
self.left_col = [ ]
self.right_col = [ ]
match = _re_extract_info.match(line)
self.line_number = int(match.group(2)) - 1
self.prev_line_number = int(match.group(1)) - 1
return _item(type='header',
line_info_left=match.group(1),
line_info_right=match.group(2),
line_info_extra=match.group(3))
if line[0] == '\\':
# \ No newline at end of file
# move into the flushing state. note: it doesn't matter if we really
# have data to flush or not; that will be figured out later
self.state = 'flush-' + self.state
return None
diff_code = line[0]
output = self._format_text(line[1:])
if diff_code == '+':
if self.state == 'dump':
self.line_number = self.line_number + 1
return _item(type='add', right=output, line_number=self.line_number)
self.state = 'pre-change-add'
self.right_col.append(output)
return None
if diff_code == '-':
self.state = 'pre-change-remove'
self.left_col.append(output)
return None # early exit to avoid line in
if self.left_col or self.right_col:
# save the line for processing again later, and move into the
# flushing state
self.save_line = line
self.state = 'flush-' + self.state
return None
self.line_number = self.line_number + 1
self.prev_line_number = self.prev_line_number + 1
return _item(type='context', left=output, right=output,
line_number=self.line_number)
def _flush_row(self):
if not self.left_col and not self.right_col:
# nothing more to flush
return None
if self.state == 'flush-pre-change-remove':
self.prev_line_number = self.prev_line_number + 1
return _item(type='remove', left=self.left_col.pop(0),
line_number=self.prev_line_number)
# state == flush-pre-change-add
item = _item(type='change',
have_left=ezt.boolean(0),
have_right=ezt.boolean(0))
if self.left_col:
self.prev_line_number = self.prev_line_number + 1
item.have_left = ezt.boolean(1)
item.left = self.left_col.pop(0)
item.line_number = self.prev_line_number
if self.right_col:
self.line_number = self.line_number + 1
item.have_right = ezt.boolean(1)
item.right = self.right_col.pop(0)
item.line_number = self.line_number
return item
class DiffSequencingError(Exception):
pass
def diff_parse_headers(fp, diff_type, rev1, rev2, sym1=None, sym2=None):
date1 = date2 = log_rev1 = log_rev2 = flag = None
header_lines = []
if diff_type == vclib.UNIFIED:
f1 = '--- '
f2 = '+++ '
elif diff_type == vclib.CONTEXT:
f1 = '*** '
f2 = '--- '
else:
f1 = f2 = None
# If we're parsing headers, then parse and tweak the diff headers,
# collecting them in an array until we've read and handled them all.
if f1 and f2:
parsing = 1
len_f1 = len(f1)
len_f2 = len(f2)
while parsing:
line = fp.readline()
if not line:
break
if line[:len(f1)] == f1:
match = _re_extract_rev.match(line)
if match:
date1 = match.group(1)
log_rev1 = match.group(2)
if sym1:
line = line[:-1] + ' %s\n' % sym1
elif line[:len(f2)] == f2:
match = _re_extract_rev.match(line)
if match:
date2 = match.group(1)
log_rev2 = match.group(2)
if sym2:
line = line[:-1] + ' %s\n' % sym2
parsing = 0
elif line[:3] == 'Bin':
flag = _RCSDIFF_IS_BINARY
parsing = 0
elif (string.find(line, 'not found') != -1 or
string.find(line, 'illegal option') != -1):
flag = _RCSDIFF_ERROR
parsing = 0
header_lines.append(line)
if (log_rev1 and log_rev1 != rev1):
raise debug.ViewVCException('rcsdiff found revision %s, but expected '
'revision %s' % (log_rev1, rev1),
'500 Internal Server Error')
if (log_rev2 and log_rev2 != rev2):
raise debug.ViewVCException('rcsdiff found revision %s, but expected '
'revision %s' % (log_rev2, rev2),
'500 Internal Server Error')
return date1, date2, flag, string.join(header_lines, '')
def _get_diff_path_parts(request, query_key, rev, base_rev):
repos = request.repos
if request.query_dict.has_key(query_key):
parts = _path_parts(request.query_dict[query_key])
elif request.roottype == 'svn':
try:
parts = _path_parts(repos.get_location(request.where,
repos._getrev(base_rev),
repos._getrev(rev)))
except vclib.InvalidRevision:
raise debug.ViewVCException('Invalid path(s) or revision(s) passed '
'to diff', '400 Bad Request')
except vclib.ItemNotFound:
raise debug.ViewVCException('Invalid path(s) or revision(s) passed '
'to diff', '400 Bad Request')
else:
parts = request.path_parts
return parts
def setup_diff(request):
query_dict = request.query_dict
rev1 = r1 = query_dict['r1']
rev2 = r2 = query_dict['r2']
sym1 = sym2 = None
# hack on the diff revisions
if r1 == 'text':
rev1 = query_dict.get('tr1', None)
if not rev1:
raise debug.ViewVCException('Missing revision from the diff '
'form text field', '400 Bad Request')
else:
idx = string.find(r1, ':')
if idx == -1:
rev1 = r1
else:
rev1 = r1[:idx]
sym1 = r1[idx+1:]
if r2 == 'text':
rev2 = query_dict.get('tr2', None)
if not rev2:
raise debug.ViewVCException('Missing revision from the diff '
'form text field', '400 Bad Request')
sym2 = ''
else:
idx = string.find(r2, ':')
if idx == -1:
rev2 = r2
else:
rev2 = r2[:idx]
sym2 = r2[idx+1:]
if request.roottype == 'svn':
try:
rev1 = str(request.repos._getrev(rev1))
rev2 = str(request.repos._getrev(rev2))
except vclib.InvalidRevision:
raise debug.ViewVCException('Invalid revision(s) passed to diff',
'400 Bad Request')
p1 = _get_diff_path_parts(request, 'p1', rev1, request.pathrev)
p2 = _get_diff_path_parts(request, 'p2', rev2, request.pathrev)
try:
if revcmp(rev1, rev2) > 0:
rev1, rev2 = rev2, rev1
sym1, sym2 = sym2, sym1
p1, p2 = p2, p1
except ValueError:
raise debug.ViewVCException('Invalid revision(s) passed to diff',
'400 Bad Request')
return p1, p2, rev1, rev2, sym1, sym2
def view_patch(request):
cfg = request.cfg
query_dict = request.query_dict
p1, p2, rev1, rev2, sym1, sym2 = setup_diff(request)
# In the absence of a format dictation in the CGI params, we'll let
# use the configured diff format, allowing 'c' to mean 'c' and
# anything else to mean 'u'.
format = query_dict.get('diff_format',
cfg.options.diff_format == 'c' and 'c' or 'u')
if format == 'c':
diff_type = vclib.CONTEXT
elif format == 'u':
diff_type = vclib.UNIFIED
else:
raise debug.ViewVCException('Diff format %s not understood'
% format, '400 Bad Request')
try:
fp = request.repos.rawdiff(p1, rev1, p2, rev2, diff_type)
except vclib.InvalidRevision:
raise debug.ViewVCException('Invalid path(s) or revision(s) passed '
'to diff', '400 Bad Request')
date1, date2, flag, headers = diff_parse_headers(fp, diff_type, rev1, rev2,
sym1, sym2)
server_fp = get_writeready_server_file(request, 'text/plain')
server_fp.write(headers)
copy_stream(fp, server_fp, cfg)
fp.close()
def view_diff(request):
cfg = request.cfg
query_dict = request.query_dict
p1, p2, rev1, rev2, sym1, sym2 = setup_diff(request)
# since templates are in use and subversion allows changes to the dates,
# we can't provide a strong etag
if check_freshness(request, None, '%s-%s' % (rev1, rev2), weak=1):
return
diff_type = None
diff_options = {}
human_readable = 0
format = query_dict.get('diff_format', cfg.options.diff_format)
if format == 'c':
diff_type = vclib.CONTEXT
elif format == 's':
diff_type = vclib.SIDE_BY_SIDE
elif format == 'l':
diff_type = vclib.UNIFIED
diff_options['context'] = 15
human_readable = 1
elif format == 'f':
diff_type = vclib.UNIFIED
diff_options['context'] = None
human_readable = 1
elif format == 'h':
diff_type = vclib.UNIFIED
human_readable = 1
elif format == 'u':
diff_type = vclib.UNIFIED
else:
raise debug.ViewVCException('Diff format %s not understood'
% format, '400 Bad Request')
if human_readable:
diff_options['funout'] = cfg.options.hr_funout
diff_options['ignore_white'] = cfg.options.hr_ignore_white
diff_options['ignore_keyword_subst'] = cfg.options.hr_ignore_keyword_subst
try:
fp = sidebyside = unified = None
if (cfg.options.hr_intraline and idiff
and ((human_readable and idiff.sidebyside)
or (not human_readable and diff_type == vclib.UNIFIED))):
f1 = request.repos.openfile(p1, rev1)[0]
try:
lines_left = f1.readlines()
finally:
f1.close()
f2 = request.repos.openfile(p2, rev2)[0]
try:
lines_right = f2.readlines()
finally:
f2.close()
if human_readable:
sidebyside = idiff.sidebyside(lines_left, lines_right,
diff_options.get("context", 5))
else:
unified = idiff.unified(lines_left, lines_right,
diff_options.get("context", 2))
else:
fp = request.repos.rawdiff(p1, rev1, p2, rev2, diff_type, diff_options)
except vclib.InvalidRevision:
raise debug.ViewVCException('Invalid path(s) or revision(s) passed '
'to diff', '400 Bad Request')
path_left = _path_join(p1)
path_right = _path_join(p2)
if fp:
date1, date2, flag, headers = diff_parse_headers(fp, diff_type,
rev1, rev2,
sym1, sym2)
else:
date1 = date2 = flag = headers = None
raw_diff_fp = changes = None
if fp:
if human_readable:
if flag is not None:
changes = [ _item(type=flag) ]
else:
changes = DiffSource(fp, cfg)
else:
raw_diff_fp = MarkupPipeWrapper(cfg, fp,
htmlify(headers, mangle_email_addrs=0),
None, 1)
no_format_params = request.query_dict.copy()
no_format_params['diff_format'] = None
left = _item(date=rcsdiff_date_reformat(date1, cfg),
path=path_left, rev=rev1, tag=sym1)
left.view_href, left.download_href, left.download_text_href, \
left.annotate_href, left.revision_href, left.prefer_markup \
= get_file_view_info(request, path_left, rev1)
right = _item(date=rcsdiff_date_reformat(date2, cfg),
path=path_right, rev=rev2, tag=sym2)
right.view_href, right.download_href, right.download_text_href, \
right.annotate_href, right.revision_href, right.prefer_markup \
= get_file_view_info(request, path_right, rev2)
data = common_template_data(request)
data.update({
'left' : left,
'right' : right,
'raw_diff' : raw_diff_fp,
'changes' : changes,
'sidebyside': sidebyside,
'unified': unified,
'diff_format' : request.query_dict.get('diff_format',
cfg.options.diff_format),
'patch_href' : request.get_url(view_func=view_patch,
params=no_format_params,
escape=1),
})
data['diff_format_action'], data['diff_format_hidden_values'] = \
request.get_form(params=no_format_params)
generate_page(request, "diff", data)
def generate_tarball_header(out, name, size=0, mode=None, mtime=0,
uid=0, gid=0, typefrag=None, linkname='',
uname='viewvc', gname='viewvc',
devmajor=1, devminor=0, prefix=None,
magic='ustar', version='00', chksum=None):
if not mode:
if name[-1:] == '/':
mode = 0755
else:
mode = 0644
if not typefrag:
if name[-1:] == '/':
typefrag = '5' # directory
else:
typefrag = '0' # regular file
if not prefix:
prefix = ''
# generate a GNU tar extension header for long names.
if len(name) >= 100:
generate_tarball_header(out, '././@LongLink', len(name),
0644, 0, 0, 0, 'L')
out.write(name)
out.write('\0' * (511 - ((len(name) + 511) % 512)))
block1 = struct.pack('100s 8s 8s 8s 12s 12s',
name,
'%07o' % mode,
'%07o' % uid,
'%07o' % gid,
'%011o' % size,
'%011o' % mtime)
block2 = struct.pack('c 100s 6s 2s 32s 32s 8s 8s 155s',
typefrag,
linkname,
magic,
version,
uname,
gname,
'%07o' % devmajor,
'%07o' % devminor,
prefix)
if not chksum:
dummy_chksum = ' '
block = block1 + dummy_chksum + block2
chksum = 0
for i in range(len(block)):
chksum = chksum + ord(block[i])
block = block1 + struct.pack('8s', '%07o' % chksum) + block2
block = block + '\0' * (512 - len(block))
out.write(block)
def generate_tarball(out, request, reldir, stack, dir_mtime=None):
# get directory info from repository
rep_path = request.path_parts + reldir
entries = request.repos.listdir(rep_path, request.pathrev, {})
request.repos.dirlogs(rep_path, request.pathrev, entries, {})
entries.sort(lambda a, b: cmp(a.name, b.name))
# figure out corresponding path in tar file. everything gets put underneath
# a single top level directory named after the repository directory being
# tarred
if request.path_parts:
tar_dir = request.path_parts[-1] + '/'
else:
tar_dir = request.rootname + '/'
if reldir:
tar_dir = tar_dir + _path_join(reldir) + '/'
cvs = request.roottype == 'cvs'
# If our caller doesn't dictate a datestamp to use for the current
# directory, its datestamps will be the youngest of the datestamps
# of versioned items in that subdirectory. We'll be ignoring dead
# or busted items and, in CVS, subdirs.
if dir_mtime is None:
dir_mtime = 0
for file in entries:
if cvs and (file.kind != vclib.FILE or file.rev is None or file.dead):
continue
if (file.date is not None) and (file.date > dir_mtime):
dir_mtime = file.date
# Push current directory onto the stack.
stack.append(tar_dir)
# If this is Subversion, we generate a header for this directory
# regardless of its contents. For CVS it will only get into the
# tarball if it has files underneath it, which we determine later.
if not cvs:
generate_tarball_header(out, tar_dir, mtime=dir_mtime)
# Run through the files in this directory, skipping busted and
# unauthorized ones.
for file in entries:
if file.kind != vclib.FILE:
continue
if cvs and (file.rev is None or file.dead):
continue
# If we get here, we've seen at least one valid file in the
# current directory. For CVS, we need to make sure there are
# directory parents to contain it, so we flush the stack.
if cvs:
for dir in stack:
generate_tarball_header(out, dir, mtime=dir_mtime)
del stack[:]
# Calculate the mode for the file. Sure, we could look directly
# at the ,v file in CVS, but that's a layering violation we'd like
# to avoid as much as possible.
if request.repos.isexecutable(rep_path + [file.name], request.pathrev):
mode = 0755
else:
mode = 0644
### FIXME: Read the whole file into memory? Bad... better to do
### 2 passes.
fp = request.repos.openfile(rep_path + [file.name], request.pathrev)[0]
contents = fp.read()
fp.close()
generate_tarball_header(out, tar_dir + file.name,
len(contents), mode,
file.date is not None and file.date or 0)
out.write(contents)
out.write('\0' * (511 - ((len(contents) + 511) % 512)))
# Recurse into subdirectories, skipping busted and unauthorized (or
# configured-to-be-hidden) ones.
for file in entries:
if file.errors or file.kind != vclib.DIR:
continue
if request.cfg.options.hide_cvsroot \
and is_cvsroot_path(request.roottype, rep_path + [file.name]):
continue
mtime = request.roottype == 'svn' and file.date or None
generate_tarball(out, request, reldir + [file.name], stack, mtime)
# Pop the current directory from the stack.
del stack[-1:]
def download_tarball(request):
cfg = request.cfg
if 'tar' not in request.cfg.options.allowed_views:
raise debug.ViewVCException('Tarball generation is disabled',
'403 Forbidden')
if debug.TARFILE_PATH:
fp = open(debug.TARFILE_PATH, 'w')
else:
tarfile = request.rootname
if request.path_parts:
tarfile = "%s-%s" % (tarfile, request.path_parts[-1])
request.server.addheader('Content-Disposition',
'attachment; filename="%s.tar.gz"' % (tarfile))
server_fp = get_writeready_server_file(request, 'application/x-gzip')
request.server.flush()
# Try to use the Python gzip module, if available; otherwise,
# we'll use the configured 'gzip' binary.
fp = gzip.GzipFile('', 'wb', 9, server_fp)
### FIXME: For Subversion repositories, we can get the real mtime of the
### top-level directory here.
generate_tarball(fp, request, [], [])
fp.write('\0' * 1024)
fp.close()
if debug.TARFILE_PATH:
request.server.header('')
print """
Tarball '%s' successfully generated!
""" % (debug.TARFILE_PATH)
def view_revision(request):
if request.roottype == "cvs":
raise ViewVCException("Revision view not supported for CVS repositories "
"at this time.", "400 Bad Request")
cfg = request.cfg
data = common_template_data(request)
query_dict = request.query_dict
try:
rev = request.repos._getrev(query_dict.get('revision'))
except vclib.InvalidRevision:
raise debug.ViewVCException('Invalid revision', '404 Not Found')
youngest_rev = request.repos.get_youngest_revision()
# The revision number acts as a weak validator (but we tell browsers
# not to cache the youngest revision).
if rev != youngest_rev and check_freshness(request, None, str(rev), weak=1):
return
# Fetch the revision information.
date, author, msg, changes = request.repos.revinfo(rev)
date_str = make_time_string(date, cfg)
# Sort the changes list by path.
def changes_sort_by_path(a, b):
return cmp(a.path_parts, b.path_parts)
changes.sort(changes_sort_by_path)
# Handle limit_changes parameter
cfg_limit_changes = cfg.options.limit_changes
limit_changes = int(query_dict.get('limit_changes', cfg_limit_changes))
more_changes = None
more_changes_href = None
first_changes = None
first_changes_href = None
if limit_changes and len(changes) > limit_changes:
more_changes = len(changes) - limit_changes
params = query_dict.copy()
params['limit_changes'] = 0
more_changes_href = request.get_url(params=params, escape=1)
changes = changes[:limit_changes]
elif cfg_limit_changes and len(changes) > cfg_limit_changes:
first_changes = cfg_limit_changes
params = query_dict.copy()
params['limit_changes'] = None
first_changes_href = request.get_url(params=params, escape=1)
# Add the hrefs, types, and prev info
for change in changes:
change.view_href = change.diff_href = change.type = change.log_href = None
# If the path is newly added, don't claim text or property
# modifications.
if (change.action == vclib.ADDED or change.action == vclib.REPLACED) \
and not change.copied:
change.text_changed = 0
change.props_changed = 0
# Calculate the view link URLs (for which we must have a pathtype).
if change.pathtype:
view_func = None
if change.pathtype is vclib.FILE \
and 'markup' in cfg.options.allowed_views:
view_func = view_markup
elif change.pathtype is vclib.DIR:
view_func = view_directory
path = _path_join(change.path_parts)
base_path = _path_join(change.base_path_parts)
if change.action == vclib.DELETED:
link_rev = str(change.base_rev)
link_where = base_path
else:
link_rev = str(rev)
link_where = path
change.view_href = request.get_url(view_func=view_func,
where=link_where,
pathtype=change.pathtype,
params={'pathrev' : link_rev},
escape=1)
change.log_href = request.get_url(view_func=view_log,
where=link_where,
pathtype=change.pathtype,
params={'pathrev' : link_rev},
escape=1)
if change.pathtype is vclib.FILE and change.text_changed:
change.diff_href = request.get_url(view_func=view_diff,
where=path,
pathtype=change.pathtype,
params={'pathrev' : str(rev),
'r1' : str(rev),
'r2' : str(change.base_rev),
},
escape=1)
# use same variable names as the log template
change.path = _path_join(change.path_parts)
change.copy_path = _path_join(change.base_path_parts)
change.copy_rev = change.base_rev
change.text_mods = ezt.boolean(change.text_changed)
change.prop_mods = ezt.boolean(change.props_changed)
change.is_copy = ezt.boolean(change.copied)
change.pathtype = (change.pathtype == vclib.FILE and 'file') \
or (change.pathtype == vclib.DIR and 'dir') \
or None
del change.path_parts
del change.base_path_parts
del change.base_rev
del change.text_changed
del change.props_changed
del change.copied
prev_rev_href = next_rev_href = None
if rev > 0:
prev_rev_href = request.get_url(view_func=view_revision,
where=None,
pathtype=None,
params={'revision': str(rev - 1)},
escape=1)
if rev < request.repos.get_youngest_revision():
next_rev_href = request.get_url(view_func=view_revision,
where=None,
pathtype=None,
params={'revision': str(rev + 1)},
escape=1)
data.update({
'rev' : str(rev),
'author' : author,
'date' : date_str,
'log' : msg and htmlify(msg, cfg.options.mangle_email_addresses) or None,
'ago' : None,
'changes' : changes,
'prev_href' : prev_rev_href,
'next_href' : next_rev_href,
'limit_changes': limit_changes,
'more_changes': more_changes,
'more_changes_href': more_changes_href,
'first_changes': first_changes,
'first_changes_href': first_changes_href,
})
if date is not None:
data['ago'] = html_time(request, date, 1)
data['jump_rev_action'], data['jump_rev_hidden_values'] = \
request.get_form(params={'revision': None})
if rev == youngest_rev:
request.server.addheader("Cache-control", "no-store")
if request.query_dict.get('simple'):
generate_page(request, "revision_simple", data)
else:
generate_page(request, "revision", data)
def is_query_supported(request):
"""Returns true if querying is supported for the given path."""
return request.cfg.cvsdb.enabled \
and request.pathtype == vclib.DIR \
and request.roottype in ['cvs', 'svn']
def view_queryform(request):
if not is_query_supported(request):
raise debug.ViewVCException('Can not query project root "%s" at "%s".'
% (request.rootname, request.where),
'403 Forbidden')
data = common_template_data(request)
data['query_action'], data['query_hidden_values'] = \
request.get_form(view_func=view_query, params={'limit_changes': None})
# default values ...
data['branch'] = request.query_dict.get('branch', '')
data['branch_match'] = request.query_dict.get('branch_match', 'exact')
data['dir'] = request.query_dict.get('dir', '')
data['file'] = request.query_dict.get('file', '')
data['file_match'] = request.query_dict.get('file_match', 'exact')
data['who'] = request.query_dict.get('who', '')
data['who_match'] = request.query_dict.get('who_match', 'exact')
data['comment'] = request.query_dict.get('comment', '')
data['comment_match'] = request.query_dict.get('comment_match', 'exact')
data['querysort'] = request.query_dict.get('querysort', 'date')
data['date'] = request.query_dict.get('date', 'hours')
data['hours'] = request.query_dict.get('hours', '2')
data['mindate'] = request.query_dict.get('mindate', '')
data['maxdate'] = request.query_dict.get('maxdate', '')
data['limit_changes'] = int(request.query_dict.get('limit_changes',
request.cfg.options.limit_changes))
data['dir_href'] = request.get_url(view_func=view_directory, params={},
escape=1)
generate_page(request, "query_form", data)
def parse_date(datestr):
"""Parse a date string from the query form."""
match = re.match(r'^(\d\d\d\d)-(\d\d)-(\d\d)(?:\ +'
'(\d\d):(\d\d)(?::(\d\d))?)?$', datestr)
if match:
year = int(match.group(1))
month = int(match.group(2))
day = int(match.group(3))
hour = match.group(4)
if hour is not None:
hour = int(hour)
else:
hour = 0
minute = match.group(5)
if minute is not None:
minute = int(minute)
else:
minute = 0
second = match.group(6)
if second is not None:
second = int(second)
else:
second = 0
# return a "seconds since epoch" value assuming date given in UTC
tm = (year, month, day, hour, minute, second, 0, 0, 0)
return compat.timegm(tm)
else:
return None
def english_query(request):
"""Generate a sentance describing the query."""
cfg = request.cfg
ret = [ 'Checkins ' ]
dir = request.query_dict.get('dir', '')
if dir:
ret.append('to ')
if ',' in dir:
ret.append('subdirectories')
else:
ret.append('subdirectory')
ret.append(' %s ' % request.server.escape(dir))
file = request.query_dict.get('file', '')
if file:
if len(ret) != 1:
ret.append('and ')
ret.append('to file %s ' % request.server.escape(file))
who = request.query_dict.get('who', '')
branch = request.query_dict.get('branch', '')
if branch:
ret.append('on branch %s ' % request.server.escape(branch))
else:
ret.append('on all branches ')
comment = request.query_dict.get('comment', '')
if comment:
ret.append('with comment %s '
% htmlify(comment, mangle_email_addrs=0))
if who:
ret.append('by %s ' % request.server.escape(who))
date = request.query_dict.get('date', 'hours')
if date == 'hours':
ret.append('in the last %s hours' \
% request.server.escape(request.query_dict.get('hours', '2')))
elif date == 'day':
ret.append('in the last day')
elif date == 'week':
ret.append('in the last week')
elif date == 'month':
ret.append('in the last month')
elif date == 'all':
ret.append('since the beginning of time')
elif date == 'explicit':
mindate = request.query_dict.get('mindate', '')
maxdate = request.query_dict.get('maxdate', '')
if mindate and maxdate:
w1, w2 = 'between', 'and'
else:
w1, w2 = 'since', 'before'
if mindate:
mindate = make_time_string(parse_date(mindate), cfg)
ret.append('%s %s ' % (w1, mindate))
if maxdate:
maxdate = make_time_string(parse_date(maxdate), cfg)
ret.append('%s %s ' % (w2, maxdate))
return string.join(ret, '')
def prev_rev(rev):
"""Returns a string representing the previous revision of the argument."""
r = string.split(rev, '.')
# decrement final revision component
r[-1] = str(int(r[-1]) - 1)
# prune if we pass the beginning of the branch
if len(r) > 2 and r[-1] == '0':
r = r[:-2]
return string.join(r, '.')
def build_commit(request, files, max_files, dir_strip, format):
"""Return a commit object build from the information in FILES, or
None if no allowed files are present in the set. DIR_STRIP is the
path prefix to remove from the commit object's set of files. If
MAX_FILES is non-zero, it is used to limit the number of files
returned in the commit object. FORMAT is the requested output
format of the query request."""
cfg = request.cfg
author = files[0].GetAuthor()
date = files[0].GetTime()
desc = files[0].GetDescription()
commit_rev = files[0].GetRevision()
len_strip = len(dir_strip)
commit_files = []
num_allowed = 0
plus_count = 0
minus_count = 0
for f in files:
commit_time = f.GetTime()
if commit_time:
commit_time = make_time_string(commit_time, cfg)
change_type = f.GetTypeString()
rev = f.GetRevision()
rev_prev = prev_rev(rev)
dirname = f.GetDirectory()
filename = f.GetFile()
if dir_strip:
assert dirname[:len_strip] == dir_strip
assert len(dirname) == len_strip or dirname[len(dir_strip)] == '/'
dirname = dirname[len_strip+1:]
where = dirname and ("%s/%s" % (dirname, filename)) or filename
# In CVS, we can actually look at deleted revisions; in Subversion
# we can't -- we'll look at the previous revision instead.
if request.roottype == 'svn':
if change_type == 'Remove':
params = { 'pathrev': rev_prev }
else:
params = { 'pathrev': rev }
else:
params = { 'revision': rev, 'pathrev': f.GetBranch() or None }
dir_href = request.get_url(view_func=view_directory,
where=dirname, pathtype=vclib.DIR,
params=params, escape=1)
log_href = request.get_url(view_func=view_log,
where=where, pathtype=vclib.FILE,
params=params, escape=1)
diff_href = view_href = download_href = None
if 'markup' in cfg.options.allowed_views:
view_href = request.get_url(view_func=view_markup,
where=where, pathtype=vclib.FILE,
params=params, escape=1)
if 'co' in cfg.options.allowed_views:
download_href = request.get_url(view_func=view_checkout,
where=where, pathtype=vclib.FILE,
params=params, escape=1)
if change_type == 'Change':
diff_href_params = params.copy()
diff_href_params.update({
'r1': rev_prev,
'r2': rev,
'diff_format': None
})
diff_href = request.get_url(view_func=view_diff,
where=where, pathtype=vclib.FILE,
params=diff_href_params, escape=1)
prefer_markup = ezt.boolean(default_view(guess_mime(filename),
cfg) == view_markup)
# Skip files in hidden modules.
path_parts = _path_parts(filename)
if path_parts:
if cfg.options.hide_cvsroot \
and is_cvsroot_path(request.roottype, path_parts):
continue
# We have to do a rare authz check here because this data comes
# from the CVSdb, not from the vclib providers.
if not vclib.check_path_access(request.repos, path_parts,
vclib.FILE, rev):
continue
# Update plus/minus line change count.
plus = int(f.GetPlusCount())
minus = int(f.GetMinusCount())
plus_count = plus_count + plus
minus_count = minus_count + minus
num_allowed = num_allowed + 1
if max_files and num_allowed > max_files:
continue
commit_files.append(_item(date=commit_time,
dir=request.server.escape(dirname),
file=request.server.escape(filename),
author=request.server.escape(f.GetAuthor()),
rev=rev,
branch=f.GetBranch(),
plus=plus,
minus=minus,
type=change_type,
dir_href=dir_href,
log_href=log_href,
view_href=view_href,
download_href=download_href,
prefer_markup=prefer_markup,
diff_href=diff_href))
# No files survived forbiddenness checks? Let's just pretend this
# little commit didn't happen, shall we?
if not len(commit_files):
return None
commit = _item(num_files=len(commit_files), files=commit_files,
plus=plus_count, minus=minus_count)
commit.limited_files = ezt.boolean(num_allowed > len(commit_files))
commit.log = htmlify(desc)
commit.short_log = format_log(desc, cfg, format != 'rss')
commit.author = request.server.escape(author)
commit.rss_date = make_rss_time_string(date, request.cfg)
if request.roottype == 'svn':
commit.rev = commit_rev
commit.rss_url = '%s://%s%s' % \
(request.server.getenv("HTTPS") == "on" and "https" or "http",
request.server.getenv("HTTP_HOST"),
request.get_url(view_func=view_revision,
params={'revision': commit.rev},
escape=1))
else:
commit.rev = None
commit.rss_url = None
return commit
def query_backout(request, commits):
request.server.header('text/plain')
if commits:
print '# This page can be saved as a shell script and executed.'
print '# It should be run at the top of your work area. It will update'
print '# your working copy to back out the changes selected by the'
print '# query.'
print
else:
print '# No changes were selected by the query.'
print '# There is nothing to back out.'
return
for commit in commits:
for fileinfo in commit.files:
if request.roottype == 'cvs':
print 'cvs update -j %s -j %s %s/%s' \
% (fileinfo.rev, prev_rev(fileinfo.rev),
fileinfo.dir, fileinfo.file)
elif request.roottype == 'svn':
print 'svn merge -r %s:%s %s/%s' \
% (fileinfo.rev, prev_rev(fileinfo.rev),
fileinfo.dir, fileinfo.file)
def view_query(request):
if not is_query_supported(request):
raise debug.ViewVCException('Can not query project root "%s" at "%s".'
% (request.rootname, request.where),
'403 Forbidden')
cfg = request.cfg
# get form data
branch = request.query_dict.get('branch', '')
branch_match = request.query_dict.get('branch_match', 'exact')
dir = request.query_dict.get('dir', '')
file = request.query_dict.get('file', '')
file_match = request.query_dict.get('file_match', 'exact')
who = request.query_dict.get('who', '')
who_match = request.query_dict.get('who_match', 'exact')
comment = request.query_dict.get('comment', '')
comment_match = request.query_dict.get('comment_match', 'exact')
querysort = request.query_dict.get('querysort', 'date')
date = request.query_dict.get('date', 'hours')
hours = request.query_dict.get('hours', '2')
mindate = request.query_dict.get('mindate', '')
maxdate = request.query_dict.get('maxdate', '')
format = request.query_dict.get('format')
limit = int(request.query_dict.get('limit', 0))
limit_changes = int(request.query_dict.get('limit_changes',
cfg.options.limit_changes))
match_types = { 'exact':1, 'like':1, 'glob':1, 'regex':1, 'notregex':1 }
sort_types = { 'date':1, 'author':1, 'file':1 }
date_types = { 'hours':1, 'day':1, 'week':1, 'month':1,
'all':1, 'explicit':1 }
# parse various fields, validating or converting them
if not match_types.has_key(branch_match): branch_match = 'exact'
if not match_types.has_key(file_match): file_match = 'exact'
if not match_types.has_key(who_match): who_match = 'exact'
if not match_types.has_key(comment_match): comment_match = 'exact'
if not sort_types.has_key(querysort): querysort = 'date'
if not date_types.has_key(date): date = 'hours'
mindate = parse_date(mindate)
maxdate = parse_date(maxdate)
global cvsdb
import cvsdb
db = cvsdb.ConnectDatabaseReadOnly(cfg)
repos_root, repos_dir = cvsdb.FindRepository(db, request.rootpath)
if not repos_root:
raise debug.ViewVCException(
"The root '%s' was not found in the commit database "
% request.rootname)
# create the database query from the form data
query = cvsdb.CreateCheckinQuery()
query.SetRepository(repos_root)
# treat "HEAD" specially ...
if branch_match == 'exact' and branch == 'HEAD':
query.SetBranch('')
elif branch:
query.SetBranch(branch, branch_match)
if dir:
for subdir in string.split(dir, ','):
path = (_path_join(repos_dir + request.path_parts
+ _path_parts(string.strip(subdir))))
query.SetDirectory(path, 'exact')
query.SetDirectory('%s/%%' % cvsdb.EscapeLike(path), 'like')
else:
where = _path_join(repos_dir + request.path_parts)
if where: # if we are in a subdirectory ...
query.SetDirectory(where, 'exact')
query.SetDirectory('%s/%%' % cvsdb.EscapeLike(where), 'like')
if file:
query.SetFile(file, file_match)
if who:
query.SetAuthor(who, who_match)
if comment:
query.SetComment(comment, comment_match)
query.SetSortMethod(querysort)
if date == 'hours':
query.SetFromDateHoursAgo(int(hours))
elif date == 'day':
query.SetFromDateDaysAgo(1)
elif date == 'week':
query.SetFromDateDaysAgo(7)
elif date == 'month':
query.SetFromDateDaysAgo(31)
elif date == 'all':
pass
elif date == 'explicit':
if mindate is not None:
query.SetFromDateObject(mindate)
if maxdate is not None:
query.SetToDateObject(maxdate)
if limit:
query.SetLimit(limit)
elif format == 'rss':
query.SetLimit(cfg.cvsdb.rss_row_limit)
# run the query
db.RunQuery(query)
sql = request.server.escape(db.CreateSQLQueryString(query))
# gather commits
commits = []
plus_count = 0
minus_count = 0
mod_time = -1
if query.commit_list:
files = []
limited_files = 0
current_desc = query.commit_list[0].GetDescriptionID()
current_rev = query.commit_list[0].GetRevision()
dir_strip = _path_join(repos_dir)
for commit in query.commit_list:
commit_desc = commit.GetDescriptionID()
commit_rev = commit.GetRevision()
# base modification time on the newest commit
if commit.GetTime() > mod_time:
mod_time = commit.GetTime()
# For CVS, group commits with the same commit message.
# For Subversion, group them only if they have the same revision number
if request.roottype == 'cvs':
if current_desc == commit_desc:
files.append(commit)
continue
else:
if current_rev == commit_rev:
files.append(commit)
continue
# append this grouping
commit_item = build_commit(request, files, limit_changes,
dir_strip, format)
if commit_item:
# update running plus/minus totals
plus_count = plus_count + commit_item.plus
minus_count = minus_count + commit_item.minus
commits.append(commit_item)
files = [ commit ]
limited_files = 0
current_desc = commit_desc
current_rev = commit_rev
# we need to tack on our last commit grouping, if any
commit_item = build_commit(request, files, limit_changes,
dir_strip, format)
if commit_item:
# update running plus/minus totals
plus_count = plus_count + commit_item.plus
minus_count = minus_count + commit_item.minus
commits.append(commit_item)
# only show the branch column if we are querying all branches
# or doing a non-exact branch match on a CVS repository.
show_branch = ezt.boolean(request.roottype == 'cvs' and
(branch == '' or branch_match != 'exact'))
# backout link
params = request.query_dict.copy()
params['format'] = 'backout'
backout_href = request.get_url(params=params,
escape=1)
# link to zero limit_changes value
params = request.query_dict.copy()
params['limit_changes'] = 0
limit_changes_href = request.get_url(params=params, escape=1)
# if we got any results, use the newest commit as the modification time
if mod_time >= 0:
if check_freshness(request, mod_time):
return
if format == 'backout':
query_backout(request, commits)
return
data = common_template_data(request)
data.update({
'sql': sql,
'english_query': english_query(request),
'queryform_href': request.get_url(view_func=view_queryform, escape=1),
'backout_href': backout_href,
'plus_count': plus_count,
'minus_count': minus_count,
'show_branch': show_branch,
'querysort': querysort,
'commits': commits,
'limit_changes': limit_changes,
'limit_changes_href': limit_changes_href,
'rss_link_href': request.get_url(view_func=view_query,
params={'date': 'month'},
escape=1,
prefix=1),
})
if format == 'rss':
generate_page(request, "rss", data, "application/rss+xml")
else:
generate_page(request, "query_results", data)
_views = {
'annotate': view_annotate,
'co': view_checkout,
'diff': view_diff,
'dir': view_directory,
'graph': view_cvsgraph,
'graphimg': view_cvsgraph_image,
'log': view_log,
'markup': view_markup,
'patch': view_patch,
'query': view_query,
'queryform': view_queryform,
'revision': view_revision,
'roots': view_roots,
'tar': download_tarball,
'redirect_pathrev': redirect_pathrev,
}
_view_codes = {}
for code, view in _views.items():
_view_codes[view] = code
def list_roots(request):
cfg = request.cfg
allroots = { }
# Add the viewable Subversion roots
for root in cfg.general.svn_roots.keys():
auth = setup_authorizer(cfg, request.username, root)
try:
vclib.svn.SubversionRepository(root, cfg.general.svn_roots[root], auth,
cfg.utilities, cfg.options.svn_config_dir)
except vclib.ReposNotFound:
continue
allroots[root] = [cfg.general.svn_roots[root], 'svn']
# Add the viewable CVS roots
for root in cfg.general.cvs_roots.keys():
auth = setup_authorizer(cfg, request.username, root)
try:
vclib.ccvs.CVSRepository(root, cfg.general.cvs_roots[root], auth,
cfg.utilities, cfg.options.use_rcsparse)
except vclib.ReposNotFound:
continue
allroots[root] = [cfg.general.cvs_roots[root], 'cvs']
return allroots
def expand_root_parents(cfg):
"""Expand the configured root parents into individual roots."""
# Each item in root_parents is a "directory : repo_type" string.
for pp in cfg.general.root_parents:
pos = string.rfind(pp, ':')
if pos < 0:
raise debug.ViewVCException(
"The path '%s' in 'root_parents' does not include a "
"repository type." % (pp))
repo_type = string.strip(pp[pos+1:])
pp = os.path.normpath(string.strip(pp[:pos]))
if repo_type == 'cvs':
roots = vclib.ccvs.expand_root_parent(pp)
if cfg.options.hide_cvsroot and roots.has_key('CVSROOT'):
del roots['CVSROOT']
cfg.general.cvs_roots.update(roots)
elif repo_type == 'svn':
roots = vclib.svn.expand_root_parent(pp)
cfg.general.svn_roots.update(roots)
else:
raise debug.ViewVCException(
"The path '%s' in 'root_parents' has an unrecognized "
"repository type." % (pp))
def find_root_in_parents(cfg, rootname, roottype):
"""Return the rootpath for configured ROOTNAME of ROOTTYPE."""
# Easy out: caller wants rootname "CVSROOT", and we're hiding those.
if rootname == 'CVSROOT' and cfg.options.hide_cvsroot:
return None
for pp in cfg.general.root_parents:
pos = string.rfind(pp, ':')
if pos < 0:
continue
repo_type = string.strip(pp[pos+1:])
if repo_type != roottype:
continue
pp = os.path.normpath(string.strip(pp[:pos]))
if roottype == 'cvs':
roots = vclib.ccvs.expand_root_parent(pp)
elif roottype == 'svn':
roots = vclib.svn.expand_root_parent(pp)
else:
roots = {}
if roots.has_key(rootname):
return roots[rootname]
return None
def locate_root(cfg, rootname):
"""Return a 2-tuple ROOTTYPE, ROOTPATH for configured ROOTNAME."""
if cfg.general.cvs_roots.has_key(rootname):
return 'cvs', cfg.general.cvs_roots[rootname]
path_in_parent = find_root_in_parents(cfg, rootname, 'cvs')
if path_in_parent:
cfg.general.cvs_roots[rootname] = path_in_parent
return 'cvs', path_in_parent
if cfg.general.svn_roots.has_key(rootname):
return 'svn', cfg.general.svn_roots[rootname]
path_in_parent = find_root_in_parents(cfg, rootname, 'svn')
if path_in_parent:
cfg.general.svn_roots[rootname] = path_in_parent
return 'svn', path_in_parent
return None, None
def load_config(pathname=None, server=None):
debug.t_start('load-config')
if pathname is None:
pathname = (os.environ.get("VIEWVC_CONF_PATHNAME")
or os.environ.get("VIEWCVS_CONF_PATHNAME")
or os.path.join(os.path.dirname(os.path.dirname(__file__)),
"viewvc.conf"))
cfg = config.Config()
cfg.set_defaults()
cfg.load_config(pathname, server and server.getenv("HTTP_HOST"))
# load mime types file
if cfg.general.mime_types_file:
mimetypes.init([cfg.general.mime_types_file])
debug.t_end('load-config')
return cfg
def view_error(server, cfg):
exc_dict = debug.GetExceptionData()
status = exc_dict['status']
if exc_dict['msg']:
exc_dict['msg'] = htmlify(exc_dict['msg'], mangle_email_addrs=0)
if exc_dict['stacktrace']:
exc_dict['stacktrace'] = htmlify(exc_dict['stacktrace'],
mangle_email_addrs=0)
handled = 0
# use the configured error template if possible
try:
if cfg and not server.headerSent:
server.header(status=status)
template = get_view_template(cfg, "error")
template.generate(server.file(), exc_dict)
handled = 1
except:
pass
# but fallback to the old exception printer if no configuration is
# available, or if something went wrong
if not handled:
debug.PrintException(server, exc_dict)
def main(server, cfg):
try:
debug.t_start('main')
try:
# build a Request object, which contains info about the HTTP request
request = Request(server, cfg)
request.run_viewvc()
except SystemExit, e:
return
except:
view_error(server, cfg)
finally:
debug.t_end('main')
debug.dump()
debug.DumpChildren(server)
class _item:
def __init__(self, **kw):
vars(self).update(kw)