Mon, 10 Dec 2018 17:49:51 -0800
changeset 53699 4e17679c336bc38709c32d9b8972f0e402e0057a
parent 50842 e4e8815723821db0351cbca4fb33647f50f7a9b2
permissions -rw-r--r--
remotefilelog: accepting a None node to cmp In, basefilectx.cmp explicitly calls it with None, so it has to be supported. Specifically, this breaks "hg absorb -i" currently. Differential Revision:

# - simple http repository class for mercurial
# This provides read-only repo access to repositories exported via static http
# Copyright 2005-2007 Matt Mackall <>
# This software may be used and distributed according to the terms of the
# GNU General Public License version 2 or any later version.

from __future__ import absolute_import

import errno

from .i18n import _
from . import (
    vfs as vfsmod,

urlerr = util.urlerr
urlreq = util.urlreq

class httprangereader(object):
    def __init__(self, url, opener):
        # we assume opener has HTTPRangeHandler
        self.url = url
        self.pos = 0
        self.opener = opener = url

    def __enter__(self):
        return self

    def __exit__(self, exc_type, exc_value, traceback):

    def seek(self, pos):
        self.pos = pos
    def read(self, bytes=None):
        req = urlreq.request(self.url)
        end = ''
        if bytes:
            end = self.pos + bytes - 1
        if self.pos or end:
            req.add_header('Range', 'bytes=%d-%s' % (self.pos, end))

            f =
            data =
            code = f.code
        except urlerr.httperror as inst:
            num = inst.code == 404 and errno.ENOENT or None
            raise IOError(num, inst)
        except urlerr.urlerror as inst:
            raise IOError(None, inst.reason[1])

        if code == 200:
            # HTTPRangeHandler does nothing if remote does not support
            # Range headers and returns the full entity. Let's slice it.
            if bytes:
                data = data[self.pos:self.pos + bytes]
                data = data[self.pos:]
        elif bytes:
            data = data[:bytes]
        self.pos += len(data)
        return data
    def readlines(self):
    def __iter__(self):
        return iter(self.readlines())
    def close(self):

# _RangeError and _HTTPRangeHandler were originally in,
# which was itself extracted from urlgrabber. See the last version of
# from history if you need more information.
class _RangeError(IOError):
    """Error raised when an unsatisfiable range is requested."""

class _HTTPRangeHandler(urlreq.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" response from the HTTP server is what we

    def http_error_206(self, req, fp, code, msg, hdrs):
        # 206 Partial Content Response
        r = urlreq.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')

def build_opener(ui, authinfo):
    # urllib cannot handle URLs with embedded user or passwd
    urlopener = url.opener(ui, authinfo)

    class statichttpvfs(vfsmod.abstractvfs):
        def __init__(self, base):
            self.base = base

        def __call__(self, path, mode='r', *args, **kw):
            if mode not in ('r', 'rb'):
                raise IOError('Permission denied')
            f = "/".join((self.base, urlreq.quote(path)))
            return httprangereader(f, urlopener)

        def join(self, path):
            if path:
                return pathutil.join(self.base, path)
                return self.base

    return statichttpvfs

class statichttppeer(localrepo.localpeer):
    def local(self):
        return None
    def canpush(self):
        return False

class statichttprepository(localrepo.localrepository,
    supported = localrepo.localrepository._basesupported

    def __init__(self, ui, path):
        self._url = path
        self.ui = ui

        self.root = path
        u = util.url(path.rstrip('/') + "/.hg")
        self.path, authinfo = u.authinfo()

        vfsclass = build_opener(ui, authinfo)
        self.vfs = vfsclass(self.path)
        self.cachevfs = vfsclass(self.vfs.join('cache'))
        self._phasedefaults = []

        self.names = namespaces.namespaces()
        self.filtername = None

            requirements = set('requires').splitlines())
        except IOError as inst:
            if inst.errno != errno.ENOENT:
            requirements = set()

            # check if it is a non-empty old-style repository
                fp = self.vfs("00changelog.i")
            except IOError as inst:
                if inst.errno != errno.ENOENT:
                # we do not care about empty old-style repositories here
                msg = _("'%s' does not appear to be an hg repository") % path
                raise error.RepoError(msg)

        supportedrequirements = localrepo.gathersupportedrequirements(ui)
        localrepo.ensurerequirementscompatible(ui, requirements)

        # setup store = localrepo.makestore(requirements, self.path, vfsclass)
        self.spath =
        self.svfs =
        self.sjoin =
        self._filecache = {}
        self.requirements = requirements

        rootmanifest = manifest.manifestrevlog(self.svfs)
        self.manifestlog = manifest.manifestlog(self.svfs, self, rootmanifest)
        self.changelog = changelog.changelog(self.svfs)
        self._tags = None
        self.nodetagscache = None
        self._branchcaches = {}
        self._revbranchcache = None
        self.encodepats = None
        self.decodepats = None
        self._transref = None

    def _restrictcapabilities(self, caps):
        caps = super(statichttprepository, self)._restrictcapabilities(caps)
        return caps.difference(["pushkey"])

    def url(self):
        return self._url

    def local(self):
        return False

    def peer(self):
        return statichttppeer(self)

    def wlock(self, wait=True):
        raise error.LockUnavailable(0, _('lock not available'), 'lock',
                                    _('cannot lock static-http repository'))

    def lock(self, wait=True):
        raise error.Abort(_('cannot lock static-http repository'))

    def _writecaches(self):
        pass # statichttprepository are read only

def instance(ui, path, create, intents=None, createopts=None):
    if create:
        raise error.Abort(_('cannot create new static-http repository'))
    return statichttprepository(ui, path[7:])