send conservatively capitalized HTTP headers

mercurial/byterange.py

@@ -1,469 +1,469
 #   This library is free software; you can redistribute it and/or
 #   modify it under the terms of the GNU Lesser General Public
 #   License as published by the Free Software Foundation; either
 #   version 2.1 of the License, or (at your option) any later version.
 #
 #   This library is distributed in the hope that it will be useful,
 #   but WITHOUT ANY WARRANTY; without even the implied warranty of
 #   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 #   Lesser General Public License for more details.
 #
 #   You should have received a copy of the GNU Lesser General Public
 #   License along with this library; if not, write to the
 #      Free Software Foundation, Inc.,
 #      59 Temple Place, Suite 330,
 #      Boston, MA  02111-1307  USA
 
 # This file is part of urlgrabber, a high-level cross-protocol url-grabber
 # Copyright 2002-2004 Michael D. Stenner, Ryan Tomayko
 
 # $Id: byterange.py,v 1.9 2005/02/14 21:55:07 mstenner Exp $
 
 import os
 import stat
 import urllib
 import urllib2
 import rfc822
 
 try:
     from cStringIO import StringIO
 except ImportError, msg:
     from StringIO import StringIO
 
 class RangeError(IOError):
     """Error raised when an unsatisfiable range is requested."""
     pass
 
 class HTTPRangeHandler(urllib2.BaseHandler):
     """Handler that enables HTTP Range headers.
 
     This was extremely simple. The Range header is a HTTP feature to
     begin with so all this class does is tell urllib2 that the
     "206 Partial Content" reponse from the HTTP server is what we
     expected.
 
     Example:
         import urllib2
         import byterange
 
         range_handler = range.HTTPRangeHandler()
         opener = urllib2.build_opener(range_handler)
 
         # install it
         urllib2.install_opener(opener)
 
         # create Request and set Range header
         req = urllib2.Request('http://www.python.org/')
         req.header['Range'] = 'bytes=30-50'
         f = urllib2.urlopen(req)
     """
 
     def http_error_206(self, req, fp, code, msg, hdrs):
         # 206 Partial Content Response
         r = urllib.addinfourl(fp, hdrs, req.get_full_url())
         r.code = code
         r.msg = msg
         return r
 
     def http_error_416(self, req, fp, code, msg, hdrs):
         # HTTP's Range Not Satisfiable error
         raise RangeError('Requested Range Not Satisfiable')
 
 class RangeableFileObject:
     """File object wrapper to enable raw range handling.
     This was implemented primarilary for handling range
     specifications for file:// urls. This object effectively makes
     a file object look like it consists only of a range of bytes in
     the stream.
 
     Examples:
         # expose 10 bytes, starting at byte position 20, from
         # /etc/aliases.
         >>> fo = RangeableFileObject(file('/etc/passwd', 'r'), (20,30))
         # seek seeks within the range (to position 23 in this case)
         >>> fo.seek(3)
         # tell tells where your at _within the range_ (position 3 in
         # this case)
         >>> fo.tell()
         # read EOFs if an attempt is made to read past the last
         # byte in the range. the following will return only 7 bytes.
         >>> fo.read(30)
     """
 
     def __init__(self, fo, rangetup):
         """Create a RangeableFileObject.
         fo       -- a file like object. only the read() method need be
                     supported but supporting an optimized seek() is
                     preferable.
         rangetup -- a (firstbyte,lastbyte) tuple specifying the range
                     to work over.
         The file object provided is assumed to be at byte offset 0.
         """
         self.fo = fo
         (self.firstbyte, self.lastbyte) = range_tuple_normalize(rangetup)
         self.realpos = 0
         self._do_seek(self.firstbyte)
 
     def __getattr__(self, name):
         """This effectively allows us to wrap at the instance level.
         Any attribute not found in _this_ object will be searched for
         in self.fo.  This includes methods."""
         if hasattr(self.fo, name):
             return getattr(self.fo, name)
         raise AttributeError, name
 
     def tell(self):
         """Return the position within the range.
         This is different from fo.seek in that position 0 is the
         first byte position of the range tuple. For example, if
         this object was created with a range tuple of (500,899),
         tell() will return 0 when at byte position 500 of the file.
         """
         return (self.realpos - self.firstbyte)
 
     def seek(self, offset, whence=0):
         """Seek within the byte range.
         Positioning is identical to that described under tell().
         """
         assert whence in (0, 1, 2)
         if whence == 0:   # absolute seek
             realoffset = self.firstbyte + offset
         elif whence == 1: # relative seek
             realoffset = self.realpos + offset
         elif whence == 2: # absolute from end of file
             # XXX: are we raising the right Error here?
             raise IOError('seek from end of file not supported.')
 
         # do not allow seek past lastbyte in range
         if self.lastbyte and (realoffset >= self.lastbyte):
             realoffset = self.lastbyte
 
         self._do_seek(realoffset - self.realpos)
 
     def read(self, size=-1):
         """Read within the range.
         This method will limit the size read based on the range.
         """
         size = self._calc_read_size(size)
         rslt = self.fo.read(size)
         self.realpos += len(rslt)
         return rslt
 
     def readline(self, size=-1):
         """Read lines within the range.
         This method will limit the size read based on the range.
         """
         size = self._calc_read_size(size)
         rslt = self.fo.readline(size)
         self.realpos += len(rslt)
         return rslt
 
     def _calc_read_size(self, size):
         """Handles calculating the amount of data to read based on
         the range.
         """
         if self.lastbyte:
             if size > -1:
                 if ((self.realpos + size) >= self.lastbyte):
                     size = (self.lastbyte - self.realpos)
             else:
                 size = (self.lastbyte - self.realpos)
         return size
 
     def _do_seek(self, offset):
         """Seek based on whether wrapped object supports seek().
         offset is relative to the current position (self.realpos).
         """
         assert offset >= 0
         if not hasattr(self.fo, 'seek'):
             self._poor_mans_seek(offset)
         else:
             self.fo.seek(self.realpos + offset)
         self.realpos += offset
 
     def _poor_mans_seek(self, offset):
         """Seek by calling the wrapped file objects read() method.
         This is used for file like objects that do not have native
         seek support. The wrapped objects read() method is called
         to manually seek to the desired position.
         offset -- read this number of bytes from the wrapped
                   file object.
         raise RangeError if we encounter EOF before reaching the
         specified offset.
         """
         pos = 0
         bufsize = 1024
         while pos < offset:
             if (pos + bufsize) > offset:
                 bufsize = offset - pos
             buf = self.fo.read(bufsize)
             if len(buf) != bufsize:
                 raise RangeError('Requested Range Not Satisfiable')
             pos += bufsize
 
 class FileRangeHandler(urllib2.FileHandler):
     """FileHandler subclass that adds Range support.
     This class handles Range headers exactly like an HTTP
     server would.
     """
     def open_local_file(self, req):
         import mimetypes
         import mimetools
         host = req.get_host()
         file = req.get_selector()
         localfile = urllib.url2pathname(file)
         stats = os.stat(localfile)
         size = stats[stat.ST_SIZE]
         modified = rfc822.formatdate(stats[stat.ST_MTIME])
         mtype = mimetypes.guess_type(file)[0]
         if host:
             host, port = urllib.splitport(host)
             if port or socket.gethostbyname(host) not in self.get_names():
                 raise urllib2.URLError('file not on local host')
         fo = open(localfile,'rb')
         brange = req.headers.get('Range', None)
         brange = range_header_to_tuple(brange)
         assert brange != ()
         if brange:
             (fb, lb) = brange
             if lb == '':
                 lb = size
             if fb < 0 or fb > size or lb > size:
                 raise RangeError('Requested Range Not Satisfiable')
             size = (lb - fb)
             fo = RangeableFileObject(fo, (fb, lb))
         headers = mimetools.Message(StringIO(
-            'Content-Type: %s\nContent-Length: %d\nLast-modified: %s\n' %
+            'Content-Type: %s\nContent-Length: %d\nLast-Modified: %s\n' %
             (mtype or 'text/plain', size, modified)))
         return urllib.addinfourl(fo, headers, 'file:'+file)
 
 
 # FTP Range Support
 # Unfortunately, a large amount of base FTP code had to be copied
 # from urllib and urllib2 in order to insert the FTP REST command.
 # Code modifications for range support have been commented as
 # follows:
 # -- range support modifications start/end here
 
 from urllib import splitport, splituser, splitpasswd, splitattr, \
                    unquote, addclosehook, addinfourl
 import ftplib
 import socket
 import sys
 import mimetypes
 import mimetools
 
 class FTPRangeHandler(urllib2.FTPHandler):
     def ftp_open(self, req):
         host = req.get_host()
         if not host:
             raise IOError, ('ftp error', 'no host given')
         host, port = splitport(host)
         if port is None:
             port = ftplib.FTP_PORT
 
         # username/password handling
         user, host = splituser(host)
         if user:
             user, passwd = splitpasswd(user)
         else:
             passwd = None
         host = unquote(host)
         user = unquote(user or '')
         passwd = unquote(passwd or '')
 
         try:
             host = socket.gethostbyname(host)
         except socket.error, msg:
             raise urllib2.URLError(msg)
         path, attrs = splitattr(req.get_selector())
         dirs = path.split('/')
         dirs = map(unquote, dirs)
         dirs, file = dirs[:-1], dirs[-1]
         if dirs and not dirs[0]:
             dirs = dirs[1:]
         try:
             fw = self.connect_ftp(user, passwd, host, port, dirs)
             type = file and 'I' or 'D'
             for attr in attrs:
                 attr, value = splitattr(attr)
                 if attr.lower() == 'type' and \
                    value in ('a', 'A', 'i', 'I', 'd', 'D'):
                     type = value.upper()
 
             # -- range support modifications start here
             rest = None
             range_tup = range_header_to_tuple(req.headers.get('Range', None))
             assert range_tup != ()
             if range_tup:
                 (fb, lb) = range_tup
                 if fb > 0:
                     rest = fb
             # -- range support modifications end here
 
             fp, retrlen = fw.retrfile(file, type, rest)
 
             # -- range support modifications start here
             if range_tup:
                 (fb, lb) = range_tup
                 if lb == '':
                     if retrlen is None or retrlen == 0:
                         raise RangeError('Requested Range Not Satisfiable due to unobtainable file length.')
                     lb = retrlen
                     retrlen = lb - fb
                     if retrlen < 0:
                         # beginning of range is larger than file
                         raise RangeError('Requested Range Not Satisfiable')
                 else:
                     retrlen = lb - fb
                     fp = RangeableFileObject(fp, (0, retrlen))
             # -- range support modifications end here
 
             headers = ""
             mtype = mimetypes.guess_type(req.get_full_url())[0]
             if mtype:
                 headers += "Content-Type: %s\n" % mtype
             if retrlen is not None and retrlen >= 0:
                 headers += "Content-Length: %d\n" % retrlen
             sf = StringIO(headers)
             headers = mimetools.Message(sf)
             return addinfourl(fp, headers, req.get_full_url())
         except ftplib.all_errors, msg:
             raise IOError, ('ftp error', msg), sys.exc_info()[2]
 
     def connect_ftp(self, user, passwd, host, port, dirs):
         fw = ftpwrapper(user, passwd, host, port, dirs)
         return fw
 
 class ftpwrapper(urllib.ftpwrapper):
     # range support note:
     # this ftpwrapper code is copied directly from
     # urllib. The only enhancement is to add the rest
     # argument and pass it on to ftp.ntransfercmd
     def retrfile(self, file, type, rest=None):
         self.endtransfer()
         if type in ('d', 'D'):
             cmd = 'TYPE A'
             isdir = 1
         else:
             cmd = 'TYPE ' + type
             isdir = 0
         try:
             self.ftp.voidcmd(cmd)
         except ftplib.all_errors:
             self.init()
             self.ftp.voidcmd(cmd)
         conn = None
         if file and not isdir:
             # Use nlst to see if the file exists at all
             try:
                 self.ftp.nlst(file)
             except ftplib.error_perm, reason:
                 raise IOError, ('ftp error', reason), sys.exc_info()[2]
             # Restore the transfer mode!
             self.ftp.voidcmd(cmd)
             # Try to retrieve as a file
             try:
                 cmd = 'RETR ' + file
                 conn = self.ftp.ntransfercmd(cmd, rest)
             except ftplib.error_perm, reason:
                 if str(reason).startswith('501'):
                     # workaround for REST not supported error
                     fp, retrlen = self.retrfile(file, type)
                     fp = RangeableFileObject(fp, (rest,''))
                     return (fp, retrlen)
                 elif not str(reason).startswith('550'):
                     raise IOError, ('ftp error', reason), sys.exc_info()[2]
         if not conn:
             # Set transfer mode to ASCII!
             self.ftp.voidcmd('TYPE A')
             # Try a directory listing
             if file:
                 cmd = 'LIST ' + file
             else:
                 cmd = 'LIST'
             conn = self.ftp.ntransfercmd(cmd)
         self.busy = 1
         # Pass back both a suitably decorated object and a retrieval length
         return (addclosehook(conn[0].makefile('rb'),
                             self.endtransfer), conn[1])
 
 
 ####################################################################
 # Range Tuple Functions
 # XXX: These range tuple functions might go better in a class.
 
 _rangere = None
 def range_header_to_tuple(range_header):
     """Get a (firstbyte,lastbyte) tuple from a Range header value.
 
     Range headers have the form "bytes=<firstbyte>-<lastbyte>". This
     function pulls the firstbyte and lastbyte values and returns
     a (firstbyte,lastbyte) tuple. If lastbyte is not specified in
     the header value, it is returned as an empty string in the
     tuple.
 
     Return None if range_header is None
     Return () if range_header does not conform to the range spec
     pattern.
 
     """
     global _rangere
     if range_header is None:
         return None
     if _rangere is None:
         import re
         _rangere = re.compile(r'^bytes=(\d{1,})-(\d*)')
     match = _rangere.match(range_header)
     if match:
         tup = range_tuple_normalize(match.group(1, 2))
         if tup and tup[1]:
             tup = (tup[0], tup[1]+1)
         return tup
     return ()
 
 def range_tuple_to_header(range_tup):
     """Convert a range tuple to a Range header value.
     Return a string of the form "bytes=<firstbyte>-<lastbyte>" or None
     if no range is needed.
     """
     if range_tup is None:
         return None
     range_tup = range_tuple_normalize(range_tup)
     if range_tup:
         if range_tup[1]:
             range_tup = (range_tup[0], range_tup[1] - 1)
         return 'bytes=%s-%s' % range_tup
 
 def range_tuple_normalize(range_tup):
     """Normalize a (first_byte,last_byte) range tuple.
     Return a tuple whose first element is guaranteed to be an int
     and whose second element will be '' (meaning: the last byte) or
     an int. Finally, return None if the normalized tuple == (0,'')
     as that is equivelant to retrieving the entire file.
     """
     if range_tup is None:
         return None
     # handle first byte
     fb = range_tup[0]
     if fb in (None, ''):
         fb = 0
     else:
         fb = int(fb)
     # handle last byte
     try:
         lb = range_tup[1]
     except IndexError:
         lb = ''
     else:
         if lb is None:
             lb = ''
         elif lb != '':
             lb = int(lb)
     # check if range is over the entire file
     if (fb, lb) == (0, ''):
         return None
     # check that the range is valid
     if lb < fb:
         raise RangeError('Invalid byte range: %s-%s' % (fb, lb))
     return (fb, lb)

mercurial/hgweb/common.py

@@ -1,108 +1,110
 # hgweb/common.py - Utility functions needed by hgweb_mod and hgwebdir_mod
 #
 # Copyright 21 May 2005 - (c) 2005 Jake Edge <[e-mail]>
 # Copyright 2005, 2006 Matt Mackall <[e-mail]>
 #
 # This software may be used and distributed according to the terms
 # of the GNU General Public License, incorporated herein by reference.
 
 import errno, mimetypes, os
 
 class ErrorResponse(Exception):
     def __init__(self, code, message=None):
         Exception.__init__(self)
         self.code = code
         if message:
             self.message = message
         else:
             self.message = _statusmessage(code)
 
 def _statusmessage(code):
     from BaseHTTPServer import BaseHTTPRequestHandler
     responses = BaseHTTPRequestHandler.responses
     return responses.get(code, ('Error', 'Unknown error'))[0]
 
 def statusmessage(code):
     return '%d %s' % (code, _statusmessage(code))
 
 def get_mtime(repo_path):
     store_path = os.path.join(repo_path, ".hg")
     if not os.path.isdir(os.path.join(store_path, "data")):
         store_path = os.path.join(store_path, "store")
     cl_path = os.path.join(store_path, "00changelog.i")
     if os.path.exists(cl_path):
         return os.stat(cl_path).st_mtime
     else:
         return os.stat(store_path).st_mtime
 
 def staticfile(directory, fname, req):
-    """return a file inside directory with guessed content-type header
+    """return a file inside directory with guessed Content-Type header
 
     fname always uses '/' as directory separator and isn't allowed to
     contain unusual path components.
-    Content-type is guessed using the mimetypes module.
+    Content-Type is guessed using the mimetypes module.
     Return an empty string if fname is illegal or file not found.
 
     """
     parts = fname.split('/')
     path = directory
     for part in parts:
         if (part in ('', os.curdir, os.pardir) or
             os.sep in part or os.altsep is not None and os.altsep in part):
             return ""
         path = os.path.join(path, part)
     try:
         os.stat(path)
         ct = mimetypes.guess_type(path)[0] or "text/plain"
-        req.header([('Content-type', ct),
-                    ('Content-length', str(os.path.getsize(path)))])
+        req.header([
+            ('Content-Type', ct),
+            ('Content-Length', str(os.path.getsize(path)))
+        ])
         return file(path, 'rb').read()
     except TypeError:
         raise ErrorResponse(500, 'illegal file name')
     except OSError, err:
         if err.errno == errno.ENOENT:
             raise ErrorResponse(404)
         else:
             raise ErrorResponse(500, err.strerror)
 
 def style_map(templatepath, style):
     """Return path to mapfile for a given style.
 
     Searches mapfile in the following locations:
     1. templatepath/style/map
     2. templatepath/map-style
     3. templatepath/map
     """
     locations = style and [os.path.join(style, "map"), "map-"+style] or []
     locations.append("map")
     for location in locations:
         mapfile = os.path.join(templatepath, location)
         if os.path.isfile(mapfile):
             return mapfile
     raise RuntimeError("No hgweb templates found in %r" % templatepath)
 
 def paritygen(stripecount, offset=0):
     """count parity of horizontal stripes for easier reading"""
     if stripecount and offset:
         # account for offset, e.g. due to building the list in reverse
         count = (stripecount + offset) % stripecount
         parity = (stripecount + offset) / stripecount & 1
     else:
         count = 0
         parity = 0
     while True:
         yield parity
         count += 1
         if stripecount and count >= stripecount:
             parity = 1 - parity
             count = 0
 
 def get_contact(config):
     """Return repo contact information or empty string.
 
     web.contact is the primary source, but if that is not set, try
     ui.username or $EMAIL as a fallback to display something useful.
     """
     return (config("web", "contact") or
             config("ui", "username") or
             os.environ.get("EMAIL") or "")

mercurial/hgweb/hgweb_mod.py

@@ -1,906 +1,908
 # hgweb/hgweb_mod.py - Web interface for a repository.
 #
 # Copyright 21 May 2005 - (c) 2005 Jake Edge <[e-mail]>
 # Copyright 2005-2007 Matt Mackall <[e-mail]>
 #
 # This software may be used and distributed according to the terms
 # of the GNU General Public License, incorporated herein by reference.
 
 import os, mimetypes, re
 from mercurial.node import *
 from mercurial import mdiff, ui, hg, util, archival, patch, hook
 from mercurial import revlog, templater
 from common import ErrorResponse, get_mtime, style_map, paritygen, get_contact
 from request import wsgirequest
 import webcommands, protocol
 
 shortcuts = {
     'cl': [('cmd', ['changelog']), ('rev', None)],
     'sl': [('cmd', ['shortlog']), ('rev', None)],
     'cs': [('cmd', ['changeset']), ('node', None)],
     'f': [('cmd', ['file']), ('filenode', None)],
     'fl': [('cmd', ['filelog']), ('filenode', None)],
     'fd': [('cmd', ['filediff']), ('node', None)],
     'fa': [('cmd', ['annotate']), ('filenode', None)],
     'mf': [('cmd', ['manifest']), ('manifest', None)],
     'ca': [('cmd', ['archive']), ('node', None)],
     'tags': [('cmd', ['tags'])],
     'tip': [('cmd', ['changeset']), ('node', ['tip'])],
     'static': [('cmd', ['static']), ('file', None)]
 }
 
 def _up(p):
     if p[0] != "/":
         p = "/" + p
     if p[-1] == "/":
         p = p[:-1]
     up = os.path.dirname(p)
     if up == "/":
         return "/"
     return up + "/"
 
 def revnavgen(pos, pagelen, limit, nodefunc):
     def seq(factor, limit=None):
         if limit:
             yield limit
             if limit >= 20 and limit <= 40:
                 yield 50
         else:
             yield 1 * factor
             yield 3 * factor
         for f in seq(factor * 10):
             yield f
 
     def nav(**map):
         l = []
         last = 0
         for f in seq(1, pagelen):
             if f < pagelen or f <= last:
                 continue
             if f > limit:
                 break
             last = f
             if pos + f < limit:
                 l.append(("+%d" % f, hex(nodefunc(pos + f).node())))
             if pos - f >= 0:
                 l.insert(0, ("-%d" % f, hex(nodefunc(pos - f).node())))
 
         try:
             yield {"label": "(0)", "node": hex(nodefunc('0').node())}
 
             for label, node in l:
                 yield {"label": label, "node": node}
 
             yield {"label": "tip", "node": "tip"}
         except hg.RepoError:
             pass
 
     return nav
 
 class hgweb(object):
     def __init__(self, repo, name=None):
         if isinstance(repo, str):
             parentui = ui.ui(report_untrusted=False, interactive=False)
             self.repo = hg.repository(parentui, repo)
         else:
             self.repo = repo
 
         hook.redirect(True)
         self.mtime = -1
         self.reponame = name
         self.archives = 'zip', 'gz', 'bz2'
         self.stripecount = 1
         # a repo owner may set web.templates in .hg/hgrc to get any file
         # readable by the user running the CGI script
         self.templatepath = self.config("web", "templates",
                                         templater.templatepath(),
                                         untrusted=False)
 
     # The CGI scripts are often run by a user different from the repo owner.
     # Trust the settings from the .hg/hgrc files by default.
     def config(self, section, name, default=None, untrusted=True):
         return self.repo.ui.config(section, name, default,
                                    untrusted=untrusted)
 
     def configbool(self, section, name, default=False, untrusted=True):
         return self.repo.ui.configbool(section, name, default,
                                        untrusted=untrusted)
 
     def configlist(self, section, name, default=None, untrusted=True):
         return self.repo.ui.configlist(section, name, default,
                                        untrusted=untrusted)
 
     def refresh(self):
         mtime = get_mtime(self.repo.root)
         if mtime != self.mtime:
             self.mtime = mtime
             self.repo = hg.repository(self.repo.ui, self.repo.root)
             self.maxchanges = int(self.config("web", "maxchanges", 10))
             self.stripecount = int(self.config("web", "stripes", 1))
             self.maxshortchanges = int(self.config("web", "maxshortchanges", 60))
             self.maxfiles = int(self.config("web", "maxfiles", 10))
             self.allowpull = self.configbool("web", "allowpull", True)
             self.encoding = self.config("web", "encoding", util._encoding)
 
     def run(self):
         if not os.environ.get('GATEWAY_INTERFACE', '').startswith("CGI/1."):
             raise RuntimeError("This function is only intended to be called while running as a CGI script.")
         import mercurial.hgweb.wsgicgi as wsgicgi
         wsgicgi.launch(self)
 
     def __call__(self, env, respond):
         req = wsgirequest(env, respond)
         self.run_wsgi(req)
         return req
 
     def run_wsgi(self, req):
 
         self.refresh()
 
         # expand form shortcuts
 
         for k in shortcuts.iterkeys():
             if k in req.form:
                 for name, value in shortcuts[k]:
                     if value is None:
                         value = req.form[k]
                     req.form[name] = value
                 del req.form[k]
 
         # work with CGI variables to create coherent structure
         # use SCRIPT_NAME, PATH_INFO and QUERY_STRING as well as our REPO_NAME
 
         req.url = req.env['SCRIPT_NAME']
         if not req.url.endswith('/'):
             req.url += '/'
         if 'REPO_NAME' in req.env:
             req.url += req.env['REPO_NAME'] + '/'
 
         if req.env.get('PATH_INFO'):
             parts = req.env.get('PATH_INFO').strip('/').split('/')
             repo_parts = req.env.get('REPO_NAME', '').split('/')
             if parts[:len(repo_parts)] == repo_parts:
                 parts = parts[len(repo_parts):]
             query = '/'.join(parts)
         else:
             query = req.env['QUERY_STRING'].split('&', 1)[0]
             query = query.split(';', 1)[0]
 
         # translate user-visible url structure to internal structure
 
         args = query.split('/', 2)
         if 'cmd' not in req.form and args and args[0]:
 
             cmd = args.pop(0)
             style = cmd.rfind('-')
             if style != -1:
                 req.form['style'] = [cmd[:style]]
                 cmd = cmd[style+1:]
 
             # avoid accepting e.g. style parameter as command
             if hasattr(webcommands, cmd) or hasattr(protocol, cmd):
                 req.form['cmd'] = [cmd]
 
             if args and args[0]:
                 node = args.pop(0)
                 req.form['node'] = [node]
             if args:
                 req.form['file'] = args
 
             if cmd == 'static':
                 req.form['file'] = req.form['node']
             elif cmd == 'archive':
                 fn = req.form['node'][0]
                 for type_, spec in self.archive_specs.iteritems():
                     ext = spec[2]
                     if fn.endswith(ext):
                         req.form['node'] = [fn[:-len(ext)]]
                         req.form['type'] = [type_]
 
         # actually process the request
 
         try:
 
             cmd = req.form.get('cmd', [''])[0]
             if hasattr(protocol, cmd):
                 method = getattr(protocol, cmd)
                 method(self, req)
             else:
 
                 tmpl = self.templater(req)
                 if cmd == '':
                     req.form['cmd'] = [tmpl.cache['default']]
                     cmd = req.form['cmd'][0]
 
                 if cmd == 'file' and 'raw' in req.form.get('style', []):
                     webcommands.rawfile(self, req, tmpl)
                 else:
                     getattr(webcommands, cmd)(self, req, tmpl)
 
                 del tmpl
 
         except revlog.LookupError, err:
             req.respond(404, tmpl(
                         'error', error='revision not found: %s' % err.name))
         except (hg.RepoError, revlog.RevlogError), inst:
             req.respond('500 Internal Server Error',
                         tmpl('error', error=str(inst)))
         except ErrorResponse, inst:
             req.respond(inst.code, tmpl('error', error=inst.message))
         except AttributeError:
             req.respond(400, tmpl('error', error='No such method: ' + cmd))
 
     def templater(self, req):
 
         # determine scheme, port and server name
         # this is needed to create absolute urls
 
         proto = req.env.get('wsgi.url_scheme')
         if proto == 'https':
             proto = 'https'
             default_port = "443"
         else:
             proto = 'http'
             default_port = "80"
 
         port = req.env["SERVER_PORT"]
         port = port != default_port and (":" + port) or ""
         urlbase = '%s://%s%s' % (proto, req.env['SERVER_NAME'], port)
         staticurl = self.config("web", "staticurl") or req.url + 'static/'
         if not staticurl.endswith('/'):
             staticurl += '/'
 
         # some functions for the templater
 
         def header(**map):
             ctype = tmpl('mimetype', encoding=self.encoding)
             req.httphdr(templater.stringify(ctype))
             yield tmpl('header', encoding=self.encoding, **map)
 
         def footer(**map):
             yield tmpl("footer", **map)
 
         def motd(**map):
             yield self.config("web", "motd", "")
 
         def sessionvars(**map):
             fields = []
             if 'style' in req.form:
                 style = req.form['style'][0]
                 if style != self.config('web', 'style', ''):
                     fields.append(('style', style))
 
             separator = req.url[-1] == '?' and ';' or '?'
             for name, value in fields:
                 yield dict(name=name, value=value, separator=separator)
                 separator = ';'
 
         # figure out which style to use
 
         style = self.config("web", "style", "")
         if 'style' in req.form:
             style = req.form['style'][0]
         mapfile = style_map(self.templatepath, style)
 
         if not self.reponame:
             self.reponame = (self.config("web", "name")
                              or req.env.get('REPO_NAME')
                              or req.url.strip('/') or self.repo.root)
 
         # create the templater
 
         tmpl = templater.templater(mapfile, templater.common_filters,
                                    defaults={"url": req.url,
                                              "staticurl": staticurl,
                                              "urlbase": urlbase,
                                              "repo": self.reponame,
                                              "header": header,
                                              "footer": footer,
                                              "motd": motd,
                                              "sessionvars": sessionvars
                                             })
         return tmpl
 
     def archivelist(self, nodeid):
         allowed = self.configlist("web", "allow_archive")
         for i, spec in self.archive_specs.iteritems():
             if i in allowed or self.configbool("web", "allow" + i):
                 yield {"type" : i, "extension" : spec[2], "node" : nodeid}
 
     def listfilediffs(self, tmpl, files, changeset):
         for f in files[:self.maxfiles]:
             yield tmpl("filedifflink", node=hex(changeset), file=f)
         if len(files) > self.maxfiles:
             yield tmpl("fileellipses")
 
     def siblings(self, siblings=[], hiderev=None, **args):
         siblings = [s for s in siblings if s.node() != nullid]
         if len(siblings) == 1 and siblings[0].rev() == hiderev:
             return
         for s in siblings:
             d = {'node': hex(s.node()), 'rev': s.rev()}
             if hasattr(s, 'path'):
                 d['file'] = s.path()
             d.update(args)
             yield d
 
     def renamelink(self, fl, node):
         r = fl.renamed(node)
         if r:
             return [dict(file=r[0], node=hex(r[1]))]
         return []
 
     def nodetagsdict(self, node):
         return [{"name": i} for i in self.repo.nodetags(node)]
 
     def nodebranchdict(self, ctx):
         branches = []
         branch = ctx.branch()
         # If this is an empty repo, ctx.node() == nullid,
         # ctx.branch() == 'default', but branchtags() is
         # an empty dict. Using dict.get avoids a traceback.
         if self.repo.branchtags().get(branch) == ctx.node():
             branches.append({"name": branch})
         return branches
 
     def showtag(self, tmpl, t1, node=nullid, **args):
         for t in self.repo.nodetags(node):
             yield tmpl(t1, tag=t, **args)
 
     def diff(self, tmpl, node1, node2, files):
         def filterfiles(filters, files):
             l = [x for x in files if x in filters]
 
             for t in filters:
                 if t and t[-1] != os.sep:
                     t += os.sep
                 l += [x for x in files if x.startswith(t)]
             return l
 
         parity = paritygen(self.stripecount)
         def diffblock(diff, f, fn):
             yield tmpl("diffblock",
                        lines=prettyprintlines(diff),
                        parity=parity.next(),
                        file=f,
                        filenode=hex(fn or nullid))
 
         def prettyprintlines(diff):
             for l in diff.splitlines(1):
                 if l.startswith('+'):
                     yield tmpl("difflineplus", line=l)
                 elif l.startswith('-'):
                     yield tmpl("difflineminus", line=l)
                 elif l.startswith('@'):
                     yield tmpl("difflineat", line=l)
                 else:
                     yield tmpl("diffline", line=l)
 
         r = self.repo
         c1 = r.changectx(node1)
         c2 = r.changectx(node2)
         date1 = util.datestr(c1.date())
         date2 = util.datestr(c2.date())
 
         modified, added, removed, deleted, unknown = r.status(node1, node2)[:5]
         if files:
             modified, added, removed = map(lambda x: filterfiles(files, x),
                                            (modified, added, removed))
 
         diffopts = patch.diffopts(self.repo.ui, untrusted=True)
         for f in modified:
             to = c1.filectx(f).data()
             tn = c2.filectx(f).data()
             yield diffblock(mdiff.unidiff(to, date1, tn, date2, f, f,
                                           opts=diffopts), f, tn)
         for f in added:
             to = None
             tn = c2.filectx(f).data()
             yield diffblock(mdiff.unidiff(to, date1, tn, date2, f, f,
                                           opts=diffopts), f, tn)
         for f in removed:
             to = c1.filectx(f).data()
             tn = None
             yield diffblock(mdiff.unidiff(to, date1, tn, date2, f, f,
                                           opts=diffopts), f, tn)
 
     def changelog(self, tmpl, ctx, shortlog=False):
         def changelist(limit=0,**map):
             cl = self.repo.changelog
             l = [] # build a list in forward order for efficiency
             for i in xrange(start, end):
                 ctx = self.repo.changectx(i)
                 n = ctx.node()
 
                 l.insert(0, {"parity": parity.next(),
                              "author": ctx.user(),
                              "parent": self.siblings(ctx.parents(), i - 1),
                              "child": self.siblings(ctx.children(), i + 1),
                              "changelogtag": self.showtag("changelogtag",n),
                              "desc": ctx.description(),
                              "date": ctx.date(),
                              "files": self.listfilediffs(tmpl, ctx.files(), n),
                              "rev": i,
                              "node": hex(n),
                              "tags": self.nodetagsdict(n),
                              "branches": self.nodebranchdict(ctx)})
 
             if limit > 0:
                 l = l[:limit]
 
             for e in l:
                 yield e
 
         maxchanges = shortlog and self.maxshortchanges or self.maxchanges
         cl = self.repo.changelog
         count = cl.count()
         pos = ctx.rev()
         start = max(0, pos - maxchanges + 1)
         end = min(count, start + maxchanges)
         pos = end - 1
         parity = paritygen(self.stripecount, offset=start-end)
 
         changenav = revnavgen(pos, maxchanges, count, self.repo.changectx)
 
         return tmpl(shortlog and 'shortlog' or 'changelog',
                     changenav=changenav,
                     node=hex(cl.tip()),
                     rev=pos, changesets=count,
                     entries=lambda **x: changelist(limit=0,**x),
                     latestentry=lambda **x: changelist(limit=1,**x),
                     archives=self.archivelist("tip"))
 
     def search(self, tmpl, query):
 
         def changelist(**map):
             cl = self.repo.changelog
             count = 0
             qw = query.lower().split()
 
             def revgen():
                 for i in xrange(cl.count() - 1, 0, -100):
                     l = []
                     for j in xrange(max(0, i - 100), i):
                         ctx = self.repo.changectx(j)
                         l.append(ctx)
                     l.reverse()
                     for e in l:
                         yield e
 
             for ctx in revgen():
                 miss = 0
                 for q in qw:
                     if not (q in ctx.user().lower() or
                             q in ctx.description().lower() or
                             q in " ".join(ctx.files()).lower()):
                         miss = 1
                         break
                 if miss:
                     continue
 
                 count += 1
                 n = ctx.node()
 
                 yield tmpl('searchentry',
                            parity=parity.next(),
                            author=ctx.user(),
                            parent=self.siblings(ctx.parents()),
                            child=self.siblings(ctx.children()),
                            changelogtag=self.showtag("changelogtag",n),
                            desc=ctx.description(),
                            date=ctx.date(),
                            files=self.listfilediffs(tmpl, ctx.files(), n),
                            rev=ctx.rev(),
                            node=hex(n),
                            tags=self.nodetagsdict(n),
                            branches=self.nodebranchdict(ctx))
 
                 if count >= self.maxchanges:
                     break
 
         cl = self.repo.changelog
         parity = paritygen(self.stripecount)
 
         return tmpl('search',
                     query=query,
                     node=hex(cl.tip()),
                     entries=changelist,
                     archives=self.archivelist("tip"))
 
     def changeset(self, tmpl, ctx):
         n = ctx.node()
         parents = ctx.parents()
         p1 = parents[0].node()
 
         files = []
         parity = paritygen(self.stripecount)
         for f in ctx.files():
             files.append(tmpl("filenodelink",
                               node=hex(n), file=f,
                               parity=parity.next()))
 
         def diff(**map):
             yield self.diff(tmpl, p1, n, None)
 
         return tmpl('changeset',
                     diff=diff,
                     rev=ctx.rev(),
                     node=hex(n),
                     parent=self.siblings(parents),
                     child=self.siblings(ctx.children()),
                     changesettag=self.showtag("changesettag",n),
                     author=ctx.user(),
                     desc=ctx.description(),
                     date=ctx.date(),
                     files=files,
                     archives=self.archivelist(hex(n)),
                     tags=self.nodetagsdict(n),
                     branches=self.nodebranchdict(ctx))
 
     def filelog(self, tmpl, fctx):
         f = fctx.path()
         fl = fctx.filelog()
         count = fl.count()
         pagelen = self.maxshortchanges
         pos = fctx.filerev()
         start = max(0, pos - pagelen + 1)
         end = min(count, start + pagelen)
         pos = end - 1
         parity = paritygen(self.stripecount, offset=start-end)
 
         def entries(limit=0, **map):
             l = []
 
             for i in xrange(start, end):
                 ctx = fctx.filectx(i)
                 n = fl.node(i)
 
                 l.insert(0, {"parity": parity.next(),
                              "filerev": i,
                              "file": f,
                              "node": hex(ctx.node()),
                              "author": ctx.user(),
                              "date": ctx.date(),
                              "rename": self.renamelink(fl, n),
                              "parent": self.siblings(fctx.parents()),
                              "child": self.siblings(fctx.children()),
                              "desc": ctx.description()})
 
             if limit > 0:
                 l = l[:limit]
 
             for e in l:
                 yield e
 
         nodefunc = lambda x: fctx.filectx(fileid=x)
         nav = revnavgen(pos, pagelen, count, nodefunc)
         return tmpl("filelog", file=f, node=hex(fctx.node()), nav=nav,
                     entries=lambda **x: entries(limit=0, **x),
                     latestentry=lambda **x: entries(limit=1, **x))
 
     def filerevision(self, tmpl, fctx):
         f = fctx.path()
         text = fctx.data()
         fl = fctx.filelog()
         n = fctx.filenode()
         parity = paritygen(self.stripecount)
 
         mt = mimetypes.guess_type(f)[0]
         rawtext = text
         if util.binary(text):
             mt = mt or 'application/octet-stream'
             text = "(binary:%s)" % mt
         mt = mt or 'text/plain'
 
         def lines():
             for l, t in enumerate(text.splitlines(1)):
                 yield {"line": t,
                        "linenumber": "% 6d" % (l + 1),
                        "parity": parity.next()}
 
         return tmpl("filerevision",
                     file=f,
                     path=_up(f),
                     text=lines(),
                     raw=rawtext,
                     mimetype=mt,
                     rev=fctx.rev(),
                     node=hex(fctx.node()),
                     author=fctx.user(),
                     date=fctx.date(),
                     desc=fctx.description(),
                     parent=self.siblings(fctx.parents()),
                     child=self.siblings(fctx.children()),
                     rename=self.renamelink(fl, n),
                     permissions=fctx.manifest().flags(f))
 
     def fileannotate(self, tmpl, fctx):
         f = fctx.path()
         n = fctx.filenode()
         fl = fctx.filelog()
         parity = paritygen(self.stripecount)
 
         def annotate(**map):
             last = None
             for f, l in fctx.annotate(follow=True):
                 fnode = f.filenode()
                 name = self.repo.ui.shortuser(f.user())
 
                 if last != fnode:
                     last = fnode
 
                 yield {"parity": parity.next(),
                        "node": hex(f.node()),
                        "rev": f.rev(),
                        "author": name,
                        "file": f.path(),
                        "line": l}
 
         return tmpl("fileannotate",
                     file=f,
                     annotate=annotate,
                     path=_up(f),
                     rev=fctx.rev(),
                     node=hex(fctx.node()),
                     author=fctx.user(),
                     date=fctx.date(),
                     desc=fctx.description(),
                     rename=self.renamelink(fl, n),
                     parent=self.siblings(fctx.parents()),
                     child=self.siblings(fctx.children()),
                     permissions=fctx.manifest().flags(f))
 
     def manifest(self, tmpl, ctx, path):
         mf = ctx.manifest()
         node = ctx.node()
 
         files = {}
         parity = paritygen(self.stripecount)
 
         if path and path[-1] != "/":
             path += "/"
         l = len(path)
         abspath = "/" + path
 
         for f, n in mf.items():
             if f[:l] != path:
                 continue
             remain = f[l:]
             if "/" in remain:
                 short = remain[:remain.index("/") + 1] # bleah
                 files[short] = (f, None)
             else:
                 short = os.path.basename(remain)
                 files[short] = (f, n)
 
         if not files:
             raise ErrorResponse(404, 'Path not found: ' + path)
 
         def filelist(**map):
             fl = files.keys()
             fl.sort()
             for f in fl:
                 full, fnode = files[f]
                 if not fnode:
                     continue
 
                 fctx = ctx.filectx(full)
                 yield {"file": full,
                        "parity": parity.next(),
                        "basename": f,
                        "date": fctx.changectx().date(),
                        "size": fctx.size(),
                        "permissions": mf.flags(full)}
 
         def dirlist(**map):
             fl = files.keys()
             fl.sort()
             for f in fl:
                 full, fnode = files[f]
                 if fnode:
                     continue
 
                 yield {"parity": parity.next(),
                        "path": "%s%s" % (abspath, f),
                        "basename": f[:-1]}
 
         return tmpl("manifest",
                     rev=ctx.rev(),
                     node=hex(node),
                     path=abspath,
                     up=_up(abspath),
                     upparity=parity.next(),
                     fentries=filelist,
                     dentries=dirlist,
                     archives=self.archivelist(hex(node)),
                     tags=self.nodetagsdict(node),
                     branches=self.nodebranchdict(ctx))
 
     def tags(self, tmpl):
         i = self.repo.tagslist()
         i.reverse()
         parity = paritygen(self.stripecount)
 
         def entries(notip=False,limit=0, **map):
             count = 0
             for k, n in i:
                 if notip and k == "tip":
                     continue
                 if limit > 0 and count >= limit:
                     continue
                 count = count + 1
                 yield {"parity": parity.next(),
                        "tag": k,
                        "date": self.repo.changectx(n).date(),
                        "node": hex(n)}
 
         return tmpl("tags",
                     node=hex(self.repo.changelog.tip()),
                     entries=lambda **x: entries(False,0, **x),
                     entriesnotip=lambda **x: entries(True,0, **x),
                     latestentry=lambda **x: entries(True,1, **x))
 
     def summary(self, tmpl):
         i = self.repo.tagslist()
         i.reverse()
 
         def tagentries(**map):
             parity = paritygen(self.stripecount)
             count = 0
             for k, n in i:
                 if k == "tip": # skip tip
                     continue;
 
                 count += 1
                 if count > 10: # limit to 10 tags
                     break;
 
                 yield tmpl("tagentry",
                            parity=parity.next(),
                            tag=k,
                            node=hex(n),
                            date=self.repo.changectx(n).date())
 
 
         def branches(**map):
             parity = paritygen(self.stripecount)
 
             b = self.repo.branchtags()
             l = [(-self.repo.changelog.rev(n), n, t) for t, n in b.items()]
             l.sort()
 
             for r,n,t in l:
                 ctx = self.repo.changectx(n)
 
                 yield {'parity': parity.next(),
                        'branch': t,
                        'node': hex(n),
                        'date': ctx.date()}
 
         def changelist(**map):
             parity = paritygen(self.stripecount, offset=start-end)
             l = [] # build a list in forward order for efficiency
             for i in xrange(start, end):
                 ctx = self.repo.changectx(i)
                 n = ctx.node()
                 hn = hex(n)
 
                 l.insert(0, tmpl(
                    'shortlogentry',
                     parity=parity.next(),
                     author=ctx.user(),
                     desc=ctx.description(),
                     date=ctx.date(),
                     rev=i,
                     node=hn,
                     tags=self.nodetagsdict(n),
                     branches=self.nodebranchdict(ctx)))
 
             yield l
 
         cl = self.repo.changelog
         count = cl.count()
         start = max(0, count - self.maxchanges)
         end = min(count, start + self.maxchanges)
 
         return tmpl("summary",
                     desc=self.config("web", "description", "unknown"),
                     owner=get_contact(self.config) or "unknown",
                     lastchange=cl.read(cl.tip())[2],
                     tags=tagentries,
                     branches=branches,
                     shortlog=changelist,
                     node=hex(cl.tip()),
                     archives=self.archivelist("tip"))
 
     def filediff(self, tmpl, fctx):
         n = fctx.node()
         path = fctx.path()
         parents = fctx.parents()
         p1 = parents and parents[0].node() or nullid
 
         def diff(**map):
             yield self.diff(tmpl, p1, n, [path])
 
         return tmpl("filediff",
                     file=path,
                     node=hex(n),
                     rev=fctx.rev(),
                     parent=self.siblings(parents),
                     child=self.siblings(fctx.children()),
                     diff=diff)
 
     archive_specs = {
         'bz2': ('application/x-tar', 'tbz2', '.tar.bz2', None),
         'gz': ('application/x-tar', 'tgz', '.tar.gz', None),
         'zip': ('application/zip', 'zip', '.zip', None),
         }
 
     def archive(self, tmpl, req, key, type_):
         reponame = re.sub(r"\W+", "-", os.path.basename(self.reponame))
         cnode = self.repo.lookup(key)
         arch_version = key
         if cnode == key or key == 'tip':
             arch_version = short(cnode)
         name = "%s-%s" % (reponame, arch_version)
         mimetype, artype, extension, encoding = self.archive_specs[type_]
-        headers = [('Content-type', mimetype),
-                   ('Content-disposition', 'attachment; filename=%s%s' %
-                    (name, extension))]
+        headers = [
+            ('Content-Type', mimetype),
+            ('Content-Disposition', 'attachment; filename=%s%s' %
+                (name, extension))
+        ]
         if encoding:
-            headers.append(('Content-encoding', encoding))
+            headers.append(('Content-Encoding', encoding))
         req.header(headers)
         archival.archive(self.repo, req, cnode, artype, prefix=name)
 
     # add tags to things
     # tags -> list of changesets corresponding to tags
     # find tag, changeset, file
 
     def cleanpath(self, path):
         path = path.lstrip('/')
         return util.canonpath(self.repo.root, '', path)
 
     def changectx(self, req):
         if 'node' in req.form:
             changeid = req.form['node'][0]
         elif 'manifest' in req.form:
             changeid = req.form['manifest'][0]
         else:
             changeid = self.repo.changelog.count() - 1
 
         try:
             ctx = self.repo.changectx(changeid)
         except hg.RepoError:
             man = self.repo.manifest
             mn = man.lookup(changeid)
             ctx = self.repo.changectx(man.linkrev(mn))
 
         return ctx
 
     def filectx(self, req):
         path = self.cleanpath(req.form['file'][0])
         if 'node' in req.form:
             changeid = req.form['node'][0]
         else:
             changeid = req.form['filenode'][0]
         try:
             ctx = self.repo.changectx(changeid)
             fctx = ctx.filectx(path)
         except hg.RepoError:
             fctx = self.repo.filectx(path, fileid=changeid)
 
         return fctx
 
     def check_perm(self, req, op, default):
         '''check permission for operation based on user auth.
         return true if op allowed, else false.
         default is policy to use if no config given.'''
 
         user = req.env.get('REMOTE_USER')
 
         deny = self.configlist('web', 'deny_' + op)
         if deny and (not user or deny == ['*'] or user in deny):
             return False
 
         allow = self.configlist('web', 'allow_' + op)
         return (allow and (allow == ['*'] or user in allow)) or default

mercurial/hgweb/request.py

@@ -1,102 +1,102
 # hgweb/request.py - An http request from either CGI or the standalone server.
 #
 # Copyright 21 May 2005 - (c) 2005 Jake Edge <[e-mail]>
 # Copyright 2005, 2006 Matt Mackall <[e-mail]>
 #
 # This software may be used and distributed according to the terms
 # of the GNU General Public License, incorporated herein by reference.
 
 import socket, cgi, errno
 from mercurial.i18n import gettext as _
 from common import ErrorResponse, statusmessage
 
 class wsgirequest(object):
     def __init__(self, wsgienv, start_response):
         version = wsgienv['wsgi.version']
         if (version < (1, 0)) or (version >= (2, 0)):
             raise RuntimeError("Unknown and unsupported WSGI version %d.%d"
                                % version)
         self.inp = wsgienv['wsgi.input']
         self.server_write = None
         self.err = wsgienv['wsgi.errors']
         self.threaded = wsgienv['wsgi.multithread']
         self.multiprocess = wsgienv['wsgi.multiprocess']
         self.run_once = wsgienv['wsgi.run_once']
         self.env = wsgienv
         self.form = cgi.parse(self.inp, self.env, keep_blank_values=1)
         self._start_response = start_response
         self.headers = []
 
     def __iter__(self):
         return iter([])
 
     def read(self, count=-1):
         return self.inp.read(count)
 
     def start_response(self, status):
         if self._start_response is not None:
             if not self.headers:
                 raise RuntimeError("request.write called before headers sent")
 
             for k, v in self.headers:
                 if not isinstance(v, str):
                     raise TypeError('header value must be string: %r' % v)
 
             if isinstance(status, ErrorResponse):
                 status = statusmessage(status.code)
             elif isinstance(status, int):
                 status = statusmessage(status)
 
             self.server_write = self._start_response(status, self.headers)
             self._start_response = None
             self.headers = []
 
     def respond(self, status, *things):
         if not things:
             self.start_response(status)
         for thing in things:
             if hasattr(thing, "__iter__"):
                 for part in thing:
                     self.respond(status, part)
             else:
                 thing = str(thing)
                 self.start_response(status)
                 try:
                     self.server_write(thing)
                 except socket.error, inst:
                     if inst[0] != errno.ECONNRESET:
                         raise
 
     def write(self, *things):
         self.respond('200 Script output follows', *things)
 
     def writelines(self, lines):
         for line in lines:
             self.write(line)
 
     def flush(self):
         return None
 
     def close(self):
         return None
 
-    def header(self, headers=[('Content-type','text/html')]):
+    def header(self, headers=[('Content-Type','text/html')]):
         self.headers.extend(headers)
 
     def httphdr(self, type, filename=None, length=0, headers={}):
         headers = headers.items()
-        headers.append(('Content-type', type))
+        headers.append(('Content-Type', type))
         if filename:
-            headers.append(('Content-disposition', 'inline; filename=%s' %
+            headers.append(('Content-Disposition', 'inline; filename=%s' %
                             filename))
         if length:
-            headers.append(('Content-length', str(length)))
+            headers.append(('Content-Length', str(length)))
         self.header(headers)
 
 def wsgiapplication(app_maker):
     '''For compatibility with old CGI scripts. A plain hgweb() or hgwebdir()
     can and should now be used as a WSGI application.'''
     application = app_maker()
     def run_wsgi(env, respond):
         return application(env, respond)
     return run_wsgi

mercurial/httprepo.py

@@ -1,462 +1,462
 # httprepo.py - HTTP repository proxy classes for mercurial
 #
 # Copyright 2005, 2006 Matt Mackall <[e-mail]>
 # Copyright 2006 Vadim Gelfer <[e-mail]>
 #
 # This software may be used and distributed according to the terms
 # of the GNU General Public License, incorporated herein by reference.
 
 from node import *
 from remoterepo import *
 from i18n import _
 import repo, os, urllib, urllib2, urlparse, zlib, util, httplib
 import errno, keepalive, tempfile, socket, changegroup
 
 class passwordmgr(urllib2.HTTPPasswordMgrWithDefaultRealm):
     def __init__(self, ui):
         urllib2.HTTPPasswordMgrWithDefaultRealm.__init__(self)
         self.ui = ui
 
     def find_user_password(self, realm, authuri):
         authinfo = urllib2.HTTPPasswordMgrWithDefaultRealm.find_user_password(
             self, realm, authuri)
         user, passwd = authinfo
         if user and passwd:
             return (user, passwd)
 
         if not self.ui.interactive:
             raise util.Abort(_('http authorization required'))
 
         self.ui.write(_("http authorization required\n"))
         self.ui.status(_("realm: %s\n") % realm)
         if user:
             self.ui.status(_("user: %s\n") % user)
         else:
             user = self.ui.prompt(_("user:"), default=None)
 
         if not passwd:
             passwd = self.ui.getpass()
 
         self.add_password(realm, authuri, user, passwd)
         return (user, passwd)
 
 def netlocsplit(netloc):
     '''split [user[:passwd]@]host[:port] into 4-tuple.'''
 
     a = netloc.find('@')
     if a == -1:
         user, passwd = None, None
     else:
         userpass, netloc = netloc[:a], netloc[a+1:]
         c = userpass.find(':')
         if c == -1:
             user, passwd = urllib.unquote(userpass), None
         else:
             user = urllib.unquote(userpass[:c])
             passwd = urllib.unquote(userpass[c+1:])
     c = netloc.find(':')
     if c == -1:
         host, port = netloc, None
     else:
         host, port = netloc[:c], netloc[c+1:]
     return host, port, user, passwd
 
 def netlocunsplit(host, port, user=None, passwd=None):
     '''turn host, port, user, passwd into [user[:passwd]@]host[:port].'''
     if port:
         hostport = host + ':' + port
     else:
         hostport = host
     if user:
         if passwd:
             userpass = urllib.quote(user) + ':' + urllib.quote(passwd)
         else:
             userpass = urllib.quote(user)
         return userpass + '@' + hostport
     return hostport
 
 # work around a bug in Python < 2.4.2
 # (it leaves a "\n" at the end of Proxy-authorization headers)
 class request(urllib2.Request):
     def add_header(self, key, val):
         if key.lower() == 'proxy-authorization':
             val = val.strip()
         return urllib2.Request.add_header(self, key, val)
 
 class httpsendfile(file):
     def __len__(self):
         return os.fstat(self.fileno()).st_size
 
 def _gen_sendfile(connection):
     def _sendfile(self, data):
         # send a file
         if isinstance(data, httpsendfile):
             # if auth required, some data sent twice, so rewind here
             data.seek(0)
             for chunk in util.filechunkiter(data):
                 connection.send(self, chunk)
         else:
             connection.send(self, data)
     return _sendfile
 
 class httpconnection(keepalive.HTTPConnection):
     # must be able to send big bundle as stream.
     send = _gen_sendfile(keepalive.HTTPConnection)
 
 class basehttphandler(keepalive.HTTPHandler):
     def http_open(self, req):
         return self.do_open(httpconnection, req)
 
 has_https = hasattr(urllib2, 'HTTPSHandler')
 if has_https:
     class httpsconnection(httplib.HTTPSConnection):
         response_class = keepalive.HTTPResponse
         # must be able to send big bundle as stream.
         send = _gen_sendfile(httplib.HTTPSConnection)
 
     class httphandler(basehttphandler, urllib2.HTTPSHandler):
         def https_open(self, req):
             return self.do_open(httpsconnection, req)
 else:
     class httphandler(basehttphandler):
         pass
 
 # In python < 2.5 AbstractDigestAuthHandler raises a ValueError if
 # it doesn't know about the auth type requested.  This can happen if
 # somebody is using BasicAuth and types a bad password.
 class httpdigestauthhandler(urllib2.HTTPDigestAuthHandler):
     def http_error_auth_reqed(self, auth_header, host, req, headers):
         try:
             return urllib2.HTTPDigestAuthHandler.http_error_auth_reqed(
                         self, auth_header, host, req, headers)
         except ValueError, inst:
             arg = inst.args[0]
             if arg.startswith("AbstractDigestAuthHandler doesn't know "):
                 return
             raise
 
 def zgenerator(f):
     zd = zlib.decompressobj()
     try:
         for chunk in util.filechunkiter(f):
             yield zd.decompress(chunk)
     except httplib.HTTPException, inst:
         raise IOError(None, _('connection ended unexpectedly'))
     yield zd.flush()
 
 _safe = ('abcdefghijklmnopqrstuvwxyz'
          'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
          '0123456789' '_.-/')
 _safeset = None
 _hex = None
 def quotepath(path):
     '''quote the path part of a URL
 
     This is similar to urllib.quote, but it also tries to avoid
     quoting things twice (inspired by wget):
 
     >>> quotepath('abc def')
     'abc%20def'
     >>> quotepath('abc%20def')
     'abc%20def'
     >>> quotepath('abc%20 def')
     'abc%20%20def'
     >>> quotepath('abc def%20')
     'abc%20def%20'
     >>> quotepath('abc def%2')
     'abc%20def%252'
     >>> quotepath('abc def%')
     'abc%20def%25'
     '''
     global _safeset, _hex
     if _safeset is None:
         _safeset = util.set(_safe)
         _hex = util.set('abcdefABCDEF0123456789')
     l = list(path)
     for i in xrange(len(l)):
         c = l[i]
         if c == '%' and i + 2 < len(l) and (l[i+1] in _hex and l[i+2] in _hex):
             pass
         elif c not in _safeset:
             l[i] = '%%%02X' % ord(c)
     return ''.join(l)
 
 class httprepository(remoterepository):
     def __init__(self, ui, path):
         self.path = path
         self.caps = None
         self.handler = None
         scheme, netloc, urlpath, query, frag = urlparse.urlsplit(path)
         if query or frag:
             raise util.Abort(_('unsupported URL component: "%s"') %
                              (query or frag))
         if not urlpath:
             urlpath = '/'
         urlpath = quotepath(urlpath)
         host, port, user, passwd = netlocsplit(netloc)
 
         # urllib cannot handle URLs with embedded user or passwd
         self._url = urlparse.urlunsplit((scheme, netlocunsplit(host, port),
                                          urlpath, '', ''))
         self.ui = ui
         self.ui.debug(_('using %s\n') % self._url)
 
         proxyurl = ui.config("http_proxy", "host") or os.getenv('http_proxy')
         # XXX proxyauthinfo = None
         self.handler = httphandler()
         handlers = [self.handler]
 
         if proxyurl:
             # proxy can be proper url or host[:port]
             if not (proxyurl.startswith('http:') or
                     proxyurl.startswith('https:')):
                 proxyurl = 'http://' + proxyurl + '/'
             snpqf = urlparse.urlsplit(proxyurl)
             proxyscheme, proxynetloc, proxypath, proxyquery, proxyfrag = snpqf
             hpup = netlocsplit(proxynetloc)
 
             proxyhost, proxyport, proxyuser, proxypasswd = hpup
             if not proxyuser:
                 proxyuser = ui.config("http_proxy", "user")
                 proxypasswd = ui.config("http_proxy", "passwd")
 
             # see if we should use a proxy for this url
             no_list = [ "localhost", "127.0.0.1" ]
             no_list.extend([p.lower() for
                             p in ui.configlist("http_proxy", "no")])
             no_list.extend([p.strip().lower() for
                             p in os.getenv("no_proxy", '').split(',')
                             if p.strip()])
             # "http_proxy.always" config is for running tests on localhost
             if (not ui.configbool("http_proxy", "always") and
                 host.lower() in no_list):
                 # avoid auto-detection of proxy settings by appending
                 # a ProxyHandler with no proxies defined.
                 handlers.append(urllib2.ProxyHandler({}))
                 ui.debug(_('disabling proxy for %s\n') % host)
             else:
                 proxyurl = urlparse.urlunsplit((
                     proxyscheme, netlocunsplit(proxyhost, proxyport,
                                                proxyuser, proxypasswd or ''),
                     proxypath, proxyquery, proxyfrag))
                 handlers.append(urllib2.ProxyHandler({scheme: proxyurl}))
                 ui.debug(_('proxying through http://%s:%s\n') %
                           (proxyhost, proxyport))
 
         # urllib2 takes proxy values from the environment and those
         # will take precedence if found, so drop them
         for env in ["HTTP_PROXY", "http_proxy", "no_proxy"]:
             try:
                 if env in os.environ:
                     del os.environ[env]
             except OSError:
                 pass
 
         passmgr = passwordmgr(ui)
         if user:
             ui.debug(_('http auth: user %s, password %s\n') %
                      (user, passwd and '*' * len(passwd) or 'not set'))
             netloc = host
             if port:
                 netloc += ':' + port
             # Python < 2.4.3 uses only the netloc to search for a password
             passmgr.add_password(None, (self._url, netloc), user, passwd or '')
 
         handlers.extend((urllib2.HTTPBasicAuthHandler(passmgr),
                          httpdigestauthhandler(passmgr)))
         opener = urllib2.build_opener(*handlers)
 
         # 1.0 here is the _protocol_ version
         opener.addheaders = [('User-agent', 'mercurial/proto-1.0')]
         urllib2.install_opener(opener)
 
     def __del__(self):
         if self.handler:
             self.handler.close_all()
             self.handler = None
 
     def url(self):
         return self.path
 
     # look up capabilities only when needed
 
     def get_caps(self):
         if self.caps is None:
             try:
                 self.caps = util.set(self.do_read('capabilities').split())
             except repo.RepoError:
                 self.caps = util.set()
             self.ui.debug(_('capabilities: %s\n') %
                           (' '.join(self.caps or ['none'])))
         return self.caps
 
     capabilities = property(get_caps)
 
     def lock(self):
         raise util.Abort(_('operation not supported over http'))
 
     def do_cmd(self, cmd, **args):
         data = args.pop('data', None)
         headers = args.pop('headers', {})
         self.ui.debug(_("sending %s command\n") % cmd)
         q = {"cmd": cmd}
         q.update(args)
         qs = '?%s' % urllib.urlencode(q)
         cu = "%s%s" % (self._url, qs)
         try:
             if data:
                 self.ui.debug(_("sending %s bytes\n") % len(data))
             resp = urllib2.urlopen(request(cu, data, headers))
         except urllib2.HTTPError, inst:
             if inst.code == 401:
                 raise util.Abort(_('authorization failed'))
             raise
         except httplib.HTTPException, inst:
             self.ui.debug(_('http error while sending %s command\n') % cmd)
             self.ui.print_exc()
             raise IOError(None, inst)
         except IndexError:
             # this only happens with Python 2.3, later versions raise URLError
             raise util.Abort(_('http error, possibly caused by proxy setting'))
         # record the url we got redirected to
         resp_url = resp.geturl()
         if resp_url.endswith(qs):
             resp_url = resp_url[:-len(qs)]
         if self._url != resp_url:
             self.ui.status(_('real URL is %s\n') % resp_url)
             self._url = resp_url
         try:
             proto = resp.getheader('content-type')
         except AttributeError:
             proto = resp.headers['content-type']
 
         # accept old "text/plain" and "application/hg-changegroup" for now
         if not (proto.startswith('application/mercurial-') or
                 proto.startswith('text/plain') or
                 proto.startswith('application/hg-changegroup')):
             self.ui.debug(_("Requested URL: '%s'\n") % cu)
             raise repo.RepoError(_("'%s' does not appear to be an hg repository")
                                % self._url)
 
         if proto.startswith('application/mercurial-'):
             try:
                 version = proto.split('-', 1)[1]
                 version_info = tuple([int(n) for n in version.split('.')])
             except ValueError:
-                raise repo.RepoError(_("'%s' sent a broken Content-type "
+                raise repo.RepoError(_("'%s' sent a broken Content-Type "
                                      "header (%s)") % (self._url, proto))
             if version_info > (0, 1):
                 raise repo.RepoError(_("'%s' uses newer protocol %s") %
                                    (self._url, version))
 
         return resp
 
     def do_read(self, cmd, **args):
         fp = self.do_cmd(cmd, **args)
         try:
             return fp.read()
         finally:
             # if using keepalive, allow connection to be reused
             fp.close()
 
     def lookup(self, key):
         self.requirecap('lookup', _('look up remote revision'))
         d = self.do_cmd("lookup", key = key).read()
         success, data = d[:-1].split(' ', 1)
         if int(success):
             return bin(data)
         raise repo.RepoError(data)
 
     def heads(self):
         d = self.do_read("heads")
         try:
             return map(bin, d[:-1].split(" "))
         except:
             raise util.UnexpectedOutput(_("unexpected response:"), d)
 
     def branches(self, nodes):
         n = " ".join(map(hex, nodes))
         d = self.do_read("branches", nodes=n)
         try:
             br = [ tuple(map(bin, b.split(" "))) for b in d.splitlines() ]
             return br
         except:
             raise util.UnexpectedOutput(_("unexpected response:"), d)
 
     def between(self, pairs):
         n = "\n".join(["-".join(map(hex, p)) for p in pairs])
         d = self.do_read("between", pairs=n)
         try:
             p = [ l and map(bin, l.split(" ")) or [] for l in d.splitlines() ]
             return p
         except:
             raise util.UnexpectedOutput(_("unexpected response:"), d)
 
     def changegroup(self, nodes, kind):
         n = " ".join(map(hex, nodes))
         f = self.do_cmd("changegroup", roots=n)
         return util.chunkbuffer(zgenerator(f))
 
     def changegroupsubset(self, bases, heads, source):
         self.requirecap('changegroupsubset', _('look up remote changes'))
         baselst = " ".join([hex(n) for n in bases])
         headlst = " ".join([hex(n) for n in heads])
         f = self.do_cmd("changegroupsubset", bases=baselst, heads=headlst)
         return util.chunkbuffer(zgenerator(f))
 
     def unbundle(self, cg, heads, source):
         # have to stream bundle to a temp file because we do not have
         # http 1.1 chunked transfer.
 
         type = ""
         types = self.capable('unbundle')
         # servers older than d1b16a746db6 will send 'unbundle' as a
         # boolean capability
         try:
             types = types.split(',')
         except AttributeError:
             types = [""]
         if types:
             for x in types:
                 if x in changegroup.bundletypes:
                     type = x
                     break
 
         tempname = changegroup.writebundle(cg, None, type)
         fp = httpsendfile(tempname, "rb")
         try:
             try:
                 rfp = self.do_cmd(
                     'unbundle', data=fp,
-                    headers={'content-type': 'application/octet-stream'},
+                    headers={'Content-Type': 'application/octet-stream'},
                     heads=' '.join(map(hex, heads)))
                 try:
                     ret = int(rfp.readline())
                     self.ui.write(rfp.read())
                     return ret
                 finally:
                     rfp.close()
             except socket.error, err:
                 if err[0] in (errno.ECONNRESET, errno.EPIPE):
                     raise util.Abort(_('push failed: %s') % err[1])
                 raise util.Abort(err[1])
         finally:
             fp.close()
             os.unlink(tempname)
 
     def stream_out(self):
         return self.do_cmd('stream_out')
 
 class httpsrepository(httprepository):
     def __init__(self, ui, path):
         if not has_https:
             raise util.Abort(_('Python support for SSL and HTTPS '
                                'is not installed'))
         httprepository.__init__(self, ui, path)
 
 def instance(ui, path, create):
     if create:
         raise util.Abort(_('cannot create new http repository'))
     if path.startswith('https:'):
         return httpsrepository(ui, path)
     return httprepository(ui, path)

tests/test-hgweb-no-request-uri.out

@@ -1,72 +1,72
 changeset:   0:4cbec7e6f8c4
 tag:         tip
 user:        Testing
 date:        Thu Jan 01 00:00:00 1970 +0000
 summary:     test
 
 ---- HEADERS
 200 Script output follows
 ---- DATA
-[('Content-type', 'application/atom+xml; charset=ascii')]
+[('Content-Type', 'application/atom+xml; charset=ascii')]
 <?xml version="1.0" encoding="ascii"?>
 <feed xmlns="http://www.w3.org/2005/Atom">
  <!-- Changelog -->
  <id>http://127.0.0.1/</id>
  <link rel="self" href="http://127.0.0.1/atom-log"/>
  <link rel="alternate" href="http://127.0.0.1/"/>
  <title>repo Changelog</title>
  <updated>1970-01-01T00:00:00+00:00</updated>
 
  <entry>
   <title>test</title>
   <id>http://www.selenic.com/mercurial/#changeset-4cbec7e6f8c42eb52b6b52670e1f7560ae9a101e</id>
   <link href="http://127.0.0.1/rev/4cbec7e6f8c42eb52b6b52670e1f7560ae9a101e"/>
   <author>
    <name>Testing</name>
    <email>&#84;&#101;&#115;&#116;&#105;&#110;&#103;</email>
   </author>
   <updated>1970-01-01T00:00:00+00:00</updated>
   <published>1970-01-01T00:00:00+00:00</published>
   <content type="xhtml">
    <div xmlns="http://www.w3.org/1999/xhtml">
     <pre xml:space="preserve">test</pre>
    </div>
   </content>
  </entry>
 
 </feed>
 
 ---- ERRORS
 
 ---- HEADERS
 200 Script output follows
 ---- DATA
-[('Content-type', 'text/plain; charset=ascii')]
+[('Content-Type', 'text/plain; charset=ascii')]
 
 -rw-r--r-- 4 bar
 
 
 
 ---- ERRORS
 
 ---- HEADERS
 200 Script output follows
 ---- DATA
-[('Content-type', 'text/plain; charset=ascii')]
+[('Content-Type', 'text/plain; charset=ascii')]
 
 /repo/
 
 
 ---- ERRORS
 
 ---- HEADERS
 200 Script output follows
 ---- DATA
-[('Content-type', 'text/plain; charset=ascii')]
+[('Content-Type', 'text/plain; charset=ascii')]
 
 -rw-r--r-- 4 bar
 
 
 
 ---- ERRORS
 

tests/test-non-interactive-wsgi.out

@@ -1,12 +1,12
 changeset:   0:61c9426e69fe
 tag:         tip
 user:        test
 date:        Thu Jan 01 00:00:00 1970 +0000
 summary:     test
 
 ---- HEADERS
 200 Script output follows
 ---- DATA
-[('Content-type', 'text/html; charset=ascii')]
+[('Content-Type', 'text/html; charset=ascii')]
 ---- ERRORS