mercurial/urllibcompat.py

errors: catch urllib errors specifically instead of using safehasattr()

Before this patch, we would catch `IOError` and `OSError` and check if
the instance had a `.code` member (indicates `HTTPError`) or a
`.reason` member (indicates the more generic `URLError`). It seems to
me that can simply catch those exception specifically instead, so
that's what this code does. The existing code is from fbe8834923c5
(commands: report http exceptions nicely, 2005-06-17), so I suspect
it's just that there was no `urllib2` (where `URLError` lives) back
then.

The old code mentioned `SSLError` in a comment. The new code does
*not* try to catch that. The documentation for `ssl.SSLError` says
that it has a `.reason` property, but `python -c 'import ssl;
print(dir(ssl.SSLError("foo", Exception("bar"))))` doesn't mention
that property on either Python 2 or Python 3 on my system. It also
seems that `sslutil` is pretty careful about converting `ssl.SSLError`
to `error.Abort`. It also is carefult to not assume that instances of
the exception have a `.reason`. So I at least don't want to catch
`ssl.SSLError` and handle it the same way as `URLError` because that
would likely result in a crash. I also wonder if we don't need to
handle it at all (because `sslutil` might handle all the cases). It's
now early in the release cycle, so perhaps we can just see how it
goes?

Differential Revision: https://phab.mercurial-scm.org/D9318

# urllibcompat.py - adapters to ease using urllib2 on Py2 and urllib on Py3
#
# Copyright 2017 Google, Inc.
#
# 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

from .pycompat import getattr
from . import pycompat

_sysstr = pycompat.sysstr


class _pycompatstub(object):
    def __init__(self):
        self._aliases = {}

    def _registeraliases(self, origin, items):
        """Add items that will be populated at the first access"""
        items = map(_sysstr, items)
        self._aliases.update(
            (item.replace('_', '').lower(), (origin, item)) for item in items
        )

    def _registeralias(self, origin, attr, name):
        """Alias ``origin``.``attr`` as ``name``"""
        self._aliases[_sysstr(name)] = (origin, _sysstr(attr))

    def __getattr__(self, name):
        try:
            origin, item = self._aliases[name]
        except KeyError:
            raise AttributeError(name)
        self.__dict__[name] = obj = getattr(origin, item)
        return obj


httpserver = _pycompatstub()
urlreq = _pycompatstub()
urlerr = _pycompatstub()

if pycompat.ispy3:
    import urllib.parse

    urlreq._registeraliases(
        urllib.parse,
        (
            b"splitattr",
            b"splitpasswd",
            b"splitport",
            b"splituser",
            b"urlparse",
            b"urlunparse",
        ),
    )
    urlreq._registeralias(urllib.parse, b"parse_qs", b"parseqs")
    urlreq._registeralias(urllib.parse, b"parse_qsl", b"parseqsl")
    urlreq._registeralias(urllib.parse, b"unquote_to_bytes", b"unquote")
    import urllib.request

    urlreq._registeraliases(
        urllib.request,
        (
            b"AbstractHTTPHandler",
            b"BaseHandler",
            b"build_opener",
            b"FileHandler",
            b"FTPHandler",
            b"ftpwrapper",
            b"HTTPHandler",
            b"HTTPSHandler",
            b"install_opener",
            b"pathname2url",
            b"HTTPBasicAuthHandler",
            b"HTTPDigestAuthHandler",
            b"HTTPPasswordMgrWithDefaultRealm",
            b"ProxyHandler",
            b"Request",
            b"url2pathname",
            b"urlopen",
        ),
    )
    import urllib.response

    urlreq._registeraliases(urllib.response, (b"addclosehook", b"addinfourl",))
    import urllib.error

    urlerr._registeraliases(urllib.error, (b"HTTPError", b"URLError",))
    import http.server

    httpserver._registeraliases(
        http.server,
        (
            b"HTTPServer",
            b"BaseHTTPRequestHandler",
            b"SimpleHTTPRequestHandler",
            b"CGIHTTPRequestHandler",
        ),
    )

    # urllib.parse.quote() accepts both str and bytes, decodes bytes
    # (if necessary), and returns str. This is wonky. We provide a custom
    # implementation that only accepts bytes and emits bytes.
    def quote(s, safe='/'):
        # bytestr has an __iter__ that emits characters. quote_from_bytes()
        # does an iteration and expects ints. We coerce to bytes to appease it.
        if isinstance(s, pycompat.bytestr):
            s = bytes(s)
        s = urllib.parse.quote_from_bytes(s, safe=safe)
        return s.encode('ascii', 'strict')

    # urllib.parse.urlencode() returns str. We use this function to make
    # sure we return bytes.
    def urlencode(query, doseq=False):
        s = urllib.parse.urlencode(query, doseq=doseq)
        return s.encode('ascii')

    urlreq.quote = quote
    urlreq.urlencode = urlencode

    def getfullurl(req):
        return req.full_url

    def gethost(req):
        return req.host

    def getselector(req):
        return req.selector

    def getdata(req):
        return req.data

    def hasdata(req):
        return req.data is not None


else:
    import BaseHTTPServer
    import CGIHTTPServer
    import SimpleHTTPServer
    import urllib2
    import urllib
    import urlparse

    urlreq._registeraliases(
        urllib,
        (
            b"addclosehook",
            b"addinfourl",
            b"ftpwrapper",
            b"pathname2url",
            b"quote",
            b"splitattr",
            b"splitpasswd",
            b"splitport",
            b"splituser",
            b"unquote",
            b"url2pathname",
            b"urlencode",
        ),
    )
    urlreq._registeraliases(
        urllib2,
        (
            b"AbstractHTTPHandler",
            b"BaseHandler",
            b"build_opener",
            b"FileHandler",
            b"FTPHandler",
            b"HTTPBasicAuthHandler",
            b"HTTPDigestAuthHandler",
            b"HTTPHandler",
            b"HTTPPasswordMgrWithDefaultRealm",
            b"HTTPSHandler",
            b"install_opener",
            b"ProxyHandler",
            b"Request",
            b"urlopen",
        ),
    )
    urlreq._registeraliases(urlparse, (b"urlparse", b"urlunparse",))
    urlreq._registeralias(urlparse, b"parse_qs", b"parseqs")
    urlreq._registeralias(urlparse, b"parse_qsl", b"parseqsl")
    urlerr._registeraliases(urllib2, (b"HTTPError", b"URLError",))
    httpserver._registeraliases(
        BaseHTTPServer, (b"HTTPServer", b"BaseHTTPRequestHandler",)
    )
    httpserver._registeraliases(
        SimpleHTTPServer, (b"SimpleHTTPRequestHandler",)
    )
    httpserver._registeraliases(CGIHTTPServer, (b"CGIHTTPRequestHandler",))

    def gethost(req):
        return req.get_host()

    def getselector(req):
        return req.get_selector()

    def getfullurl(req):
        return req.get_full_url()

    def getdata(req):
        return req.get_data()

    def hasdata(req):
        return req.has_data()