Skip to content

G
gevent
Commit 1b34995e authored by Jason Madden's avatar Jason Madden
Browse files
Options

Make the dnspython resolver errors more consistent. 

Share quite a bit more code between the ares and dnspython resolver.
parent 0377d3a4
Hide whitespace changes
Inline Side-by-side
Showing with 307 additions and 191 deletions
docs/changes/1459.bugfix
View file @ 1b34995e
The c-ares resolver now raises exceptions much more consistently with
the standard resolver. Types and errnos are more likely to match.
The c-ares and DNSPython resolvers now raise exceptions much more
consistently with the standard resolver. Types and errnos are more
likely to match.
In addition, several other small discrepancies were addressed,
including handling of localhost and broadcast host names.
src/gevent/_compat.py
View file @ 1b34995e
......@@ -43,6 +43,8 @@ else:
native_path_types = string_types
thread_mod_name = 'thread'
hostname_types = tuple(set(string_types + (bytearray, bytes)))
def NativeStrIO():
import io
return io.BytesIO() if str is bytes else io.StringIO()
......
src/gevent/resolver/__init__.py
View file @ 1b34995e
# Copyright (c) 2018 gevent contributors. See LICENSE for details.
from _socket import gaierror
from _socket import error
from _socket import getservbyname as native_getservbyname
from _socket import getaddrinfo as native_getaddrinfo
from _socket import SOCK_STREAM
from _socket import SOCK_DGRAM
from _socket import SOL_TCP
from _socket import AI_CANONNAME
from _socket import EAI_SERVICE
import _socket
from _socket import AF_INET
from _socket import AF_UNSPEC
from _socket import AI_CANONNAME
from _socket import AI_PASSIVE
from _socket import AI_NUMERICHOST
from _socket import EAI_NONAME
from _socket import EAI_SERVICE
from _socket import SOCK_DGRAM
from _socket import SOCK_STREAM
from _socket import SOL_TCP
from _socket import error
from _socket import gaierror
from _socket import getaddrinfo as native_getaddrinfo
from _socket import getnameinfo as native_getnameinfo
from _socket import gethostbyaddr as native_gethostbyaddr
from _socket import gethostbyname as native_gethostbyname
from _socket import gethostbyname_ex as native_gethostbyname_ex
from _socket import getservbyname as native_getservbyname
from _socket import herror
from gevent._compat import string_types
from gevent._compat import text_type
from gevent._compat import hostname_types
from gevent._compat import integer_types
from gevent._compat import PY3
from gevent._compat import MAC
from gevent.resolver._addresses import is_ipv6_addr
# Nothing public here.
__all__ = ()
......@@ -68,7 +81,7 @@ def _lookup_port(port, socktype):
socktypes.append(socktype)
return port, socktypes
hostname_types = tuple(set(string_types + (bytearray, bytes)))
def _resolve_special(hostname, family):
if not isinstance(hostname, hostname_types):
......@@ -84,14 +97,84 @@ def _resolve_special(hostname, family):
class AbstractResolver(object):
HOSTNAME_ENCODING = 'idna' if PY3 else 'ascii'
_LOCAL_HOSTNAMES = (
b'localhost',
b'ip6-localhost',
b'::1',
b'127.0.0.1',
)
_LOCAL_AND_BROADCAST_HOSTNAMES = _LOCAL_HOSTNAMES + (
b'255.255.255.255',
b'<broadcast>',
)
EAI_NONAME_MSG = (
'nodename nor servname provided, or not known'
if MAC else
'Name or service not known'
)
EAI_FAMILY_MSG = (
'ai_family not supported'
)
_KNOWN_ADDR_FAMILIES = {
v
for k, v in vars(_socket).items()
if k.startswith('AF_')
}
_KNOWN_SOCKTYPES = {
v
for k, v in vars(_socket).items()
if k.startswith('SOCK_')
and k not in ('SOCK_CLOEXEC', 'SOCK_MAX_SIZE')
}
@staticmethod
def fixup_gaierror(func):
import functools
@functools.wraps(func)
def resolve(self, *args, **kwargs):
try:
return func(self, *args, **kwargs)
except gaierror as ex:
if ex.args[0] == EAI_NONAME and len(ex.args) == 1:
# dnspython doesn't set an error message
ex.args = (EAI_NONAME, self.EAI_NONAME_MSG)
ex.errno = EAI_NONAME
raise
return resolve
def _hostname_to_bytes(self, hostname):
if isinstance(hostname, text_type):
hostname = hostname.encode(self.HOSTNAME_ENCODING)
elif not isinstance(hostname, (bytes, bytearray)):
raise TypeError('Expected str, bytes or bytearray, not %s' % type(hostname).__name__)
return bytes(hostname)
def gethostbyname(self, hostname, family=AF_INET):
# The native ``gethostbyname`` and ``gethostbyname_ex`` have some different
# behaviour with special names. Notably, ``gethostbyname`` will handle
# both "<broadcast>" and "255.255.255.255", while ``gethostbyname_ex`` refuses to
# handle those; they result in different errors, too. So we can't
# pass those throgh.
hostname = self._hostname_to_bytes(hostname)
if hostname in self._LOCAL_AND_BROADCAST_HOSTNAMES:
return native_gethostbyname(hostname)
hostname = _resolve_special(hostname, family)
return self.gethostbyname_ex(hostname, family)[-1][0]
def gethostbyname_ex(self, hostname, family=AF_INET):
aliases = self._getaliases(hostname, family)
def _gethostbyname_ex(self, hostname_bytes, family):
"""Raise an ``herror`` or a ``gaierror``."""
aliases = self._getaliases(hostname_bytes, family)
addresses = []
tuples = self.getaddrinfo(hostname, 0, family,
tuples = self.getaddrinfo(hostname_bytes, 0, family,
SOCK_STREAM,
SOL_TCP, AI_CANONNAME)
canonical = tuples[0][3]
......@@ -100,9 +183,90 @@ class AbstractResolver(object):
# XXX we just ignore aliases
return (canonical, aliases, addresses)
def gethostbyname_ex(self, hostname, family=AF_INET):
hostname = self._hostname_to_bytes(hostname)
if hostname in self._LOCAL_AND_BROADCAST_HOSTNAMES:
# The broadcast specials aren't handled here, but they may produce
# special errors that are hard to replicate across all systems.
return native_gethostbyname_ex(hostname)
return self._gethostbyname_ex(hostname, family)
def _getaddrinfo(self, host_bytes, port, family, socktype, proto, flags):
raise NotImplementedError
def getaddrinfo(self, host, port, family=0, socktype=0, proto=0, flags=0):
raise NotImplementedError()
host = self._hostname_to_bytes(host) if host is not None else None
if (
not isinstance(host, bytes) # 1, 2
or (flags & AI_NUMERICHOST) # 3
or host in self._LOCAL_HOSTNAMES # 4
or (is_ipv6_addr(host) and host.startswith(b'fe80')) # 5
):
# This handles cases which do not require network access
# 1) host is None
# 2) host is of an invalid type
# 3) AI_NUMERICHOST flag is set
# 4) It's a well-known alias. TODO: This is special casing for c-ares that we don't
# really want to do. It's here because it resolves a discrepancy with the system
# resolvers caught by test cases. In gevent 20.4.0, this only worked correctly on
# Python 3 and not Python 2, by accident.
# 5) host is a link-local ipv6; dnspython returns the wrong
# scope-id for those.
return native_getaddrinfo(host, port, family, socktype, proto, flags)
return self._getaddrinfo(host, port, family, socktype, proto, flags)
def _getaliases(self, hostname, family):
# pylint:disable=unused-argument
return []
def _gethostbyaddr(self, ip_address_bytes):
"""Raises herror."""
raise NotImplementedError
def gethostbyaddr(self, ip_address):
ip_address = _resolve_special(ip_address, AF_UNSPEC)
ip_address = self._hostname_to_bytes(ip_address)
if ip_address in self._LOCAL_AND_BROADCAST_HOSTNAMES:
return native_gethostbyaddr(ip_address)
return self._gethostbyaddr(ip_address)
def _getnameinfo(self, address_bytes, port, sockaddr, flags):
raise NotImplementedError
def getnameinfo(self, sockaddr, flags):
if not isinstance(flags, integer_types):
raise TypeError('an integer is required')
if not isinstance(sockaddr, tuple):
raise TypeError('getnameinfo() argument 1 must be a tuple')
address = sockaddr[0]
address = self._hostname_to_bytes(sockaddr[0])
if address in self._LOCAL_HOSTNAMES:
return native_getnameinfo(sockaddr, flags)
port = sockaddr[1]
if not isinstance(port, integer_types):
raise TypeError('port must be an integer, not %s' % type(port))
if port >= 65536:
# System resolvers do different things with an
# out-of-bound port; macOS CPython 3.8 raises ``gaierror: [Errno 8]
# nodename nor servname provided, or not known``, while
# manylinux CPython 2.7 appears to ignore it and raises ``error:
# sockaddr resolved to multiple addresses``. TravisCI, at least ot
# one point, successfully resolved www.gevent.org to ``(readthedocs.org, '0')``.
# But c-ares 1.16 would raise ``gaierror(25, 'ARES_ESERVICE: unknown')``.
# Doing this appears to get the expected results.
port = 0
if len(sockaddr) > 2:
# Must be IPv6: (host, port, [flowinfo, [scopeid]])
flowinfo = sockaddr[2]
if flowinfo > 0xfffff:
raise OverflowError("getnameinfo(): flowinfo must be 0-1048575.")
return self._getnameinfo(address, port, sockaddr, flags)
src/gevent/resolver/ares.py
View file @ 1b34995e
......@@ -5,10 +5,6 @@ c-ares based hostname resolver.
from __future__ import absolute_import, print_function, division
import os
from _socket import getaddrinfo as native_getaddrinfo
from _socket import gethostbyname_ex as native_gethostbyname_ex
from _socket import gethostbyname as native_gethostbyname
from _socket import gethostbyaddr as native_gethostbyaddr
from _socket import gaierror
from _socket import herror
from _socket import error
......@@ -17,7 +13,6 @@ from _socket import EAI_NONAME
from gevent._compat import text_type
from gevent._compat import integer_types
from gevent._compat import PY3
from gevent._compat import MAC
from gevent.hub import Waiter
from gevent.hub import get_hub
......@@ -29,14 +24,13 @@ from gevent.socket import SOCK_DGRAM
from gevent.socket import SOCK_STREAM
from gevent.socket import SOL_TCP
from gevent.socket import SOL_UDP
from gevent.socket import AI_NUMERICHOST
from gevent._config import config
from gevent._config import AresSettingMixin
from .cares import channel, InvalidIP # pylint:disable=import-error,no-name-in-module
from . import _lookup_port as lookup_port
from . import _resolve_special
from . import AbstractResolver
__all__ = ['Resolver']
......@@ -76,11 +70,11 @@ class Resolver(AbstractResolver):
if they are listed in the hosts file.
- c-ares will not resolve ``broadcasthost``, even if listed in
the hosts file.
the hosts file prior to 2020-04-30.
- This implementation may raise ``gaierror(4)`` where the
system implementation would raise ``herror(1)`` or vice versa,
with different error numbers. However, after 2020-04, this should be
with different error numbers. However, after 2020-04-30, this should be
much reduced.
- The results for ``localhost`` may be different. In
......@@ -117,8 +111,10 @@ class Resolver(AbstractResolver):
from c-ares 1.16 or newer.
.. versionchanged:: NEXT
Now ``herror`` and ``gaierror`` are raised more consistently with
the standard library resolver, and have more consistent errno values.
Now ``herror`` and ``gaierror`` are raised more consistently with
the standard library resolver, and have more consistent errno values.
Handling of localhost and broadcast names is now more consistent.
.. _c-ares: http://c-ares.haxx.se
"""
......@@ -158,55 +154,12 @@ class Resolver(AbstractResolver):
self.cares = None
self.fork_watcher.stop()
def gethostbyname(self, hostname, family=AF_INET):
# The native ``gethostbyname`` and ``gethostbyname_ex`` have some different
# behaviour with special names. Notably, ``gethostbyname`` will handle
# both "<broadcast>" and "255.255.255.255", while ``gethostbyname_ex`` refuses to
# handle those; they result in different errors, too. So we can't
# pass those throgh.
hostname = self._hostname_to_bytes(hostname)
if hostname in self._LOCAL_AND_BROADCAST_HOSTNAMES:
return native_gethostbyname(hostname)
hostname = _resolve_special(hostname, family)
return self.gethostbyname_ex(hostname, family)[-1][0]
HOSTNAME_ENCODING = 'idna' if PY3 else 'ascii'
_LOCAL_HOSTNAMES = (
b'localhost',
b'ip6-localhost',
)
_LOCAL_AND_BROADCAST_HOSTNAMES = _LOCAL_HOSTNAMES + (
b'255.255.255.255',
b'<broadcast>',
)
EAI_NONAME_MSG = (
'nodename nor servname provided, or not known'
if MAC else
'Name or service not known'
)
def _hostname_to_bytes(self, hostname):
if isinstance(hostname, text_type):
hostname = hostname.encode(self.HOSTNAME_ENCODING)
elif not isinstance(hostname, (bytes, bytearray)):
raise TypeError('Expected str, bytes or bytearray, not %s' % type(hostname).__name__)
return bytes(hostname)
def gethostbyname_ex(self, hostname, family=AF_INET):
hostname = self._hostname_to_bytes(hostname)
if hostname in self._LOCAL_AND_BROADCAST_HOSTNAMES:
# The broadcast specials aren't handled here, but they may produce
# special errors that are hard to replicate across all systems.
return native_gethostbyname_ex(hostname)
def _gethostbyname_ex(self, hostname_bytes, family):
while True:
ares = self.cares
try:
waiter = Waiter(self.hub)
ares.gethostbyname(waiter, hostname, family)
ares.gethostbyname(waiter, hostname_bytes, family)
result = waiter.get()
if not result[-1]:
raise herror(EAI_NONAME, self.EAI_NONAME_MSG)
......@@ -225,7 +178,7 @@ class Resolver(AbstractResolver):
def _lookup_port(self, port, socktype):
return lookup_port(port, socktype)
def _getaddrinfo(
def __getaddrinfo(
self, host, port,
family=0, socktype=0, proto=0, flags=0,
fill_in_type_proto=True
......@@ -239,19 +192,6 @@ class Resolver(AbstractResolver):
if isinstance(host, text_type):
host = host.encode('idna')
if not isinstance(host, bytes) or (flags & AI_NUMERICHOST) or host in self._LOCAL_HOSTNAMES:
# XXX: Now that we're using ares_getaddrinfo, how much of this is still
# necessary?
# this handles cases which do not require network access
# 1) host is None
# 2) host is of an invalid type
# 3) AI_NUMERICHOST flag is set
# 4) It's a well-known alias. TODO: This is special casing that we don't
# really want to do. It's here because it resolves a discrepancy with the system
# resolvers caught by test cases. In gevent 20.4.0, this only worked correctly on
# Python 3 and not Python 2, by accident.
return native_getaddrinfo(host, port, family, socktype, proto, flags)
if isinstance(port, text_type):
port = port.encode('ascii')
......@@ -315,25 +255,24 @@ class Resolver(AbstractResolver):
]
return result
def getaddrinfo(self, host, port, family=0, socktype=0, proto=0, flags=0):
def _getaddrinfo(self, host_bytes, port, family, socktype, proto, flags):
while True:
ares = self.cares
try:
return self._getaddrinfo(host, port, family, socktype, proto, flags)
return self.__getaddrinfo(host_bytes, port, family, socktype, proto, flags)
except gaierror:
if ares is self.cares:
raise
def _gethostbyaddr(self, ip_address):
if ip_address in self._LOCAL_AND_BROADCAST_HOSTNAMES:
return native_gethostbyaddr(ip_address)
def __gethostbyaddr(self, ip_address):
waiter = Waiter(self.hub)
try:
self.cares.gethostbyaddr(waiter, ip_address)
return waiter.get()
except InvalidIP:
result = self._getaddrinfo(ip_address, None, family=AF_UNSPEC, socktype=SOCK_DGRAM)
result = self._getaddrinfo(ip_address, None,
family=AF_UNSPEC, socktype=SOCK_DGRAM,
proto=0, flags=0)
if not result:
raise
_ip_address = result[0][-1][0]
......@@ -345,21 +284,21 @@ class Resolver(AbstractResolver):
self.cares.gethostbyaddr(waiter, _ip_address)
return waiter.get()
def gethostbyaddr(self, ip_address):
ip_address = _resolve_special(ip_address, AF_UNSPEC)
ip_address = self._hostname_to_bytes(ip_address)
def _gethostbyaddr(self, ip_address_bytes):
while True:
ares = self.cares
try:
return self._gethostbyaddr(ip_address)
return self.__gethostbyaddr(ip_address_bytes)
except herror:
if ares is self.cares:
raise
def _getnameinfo(self, hostname, port, sockaddr, flags):
result = self._getaddrinfo(hostname, port,
family=AF_UNSPEC, socktype=SOCK_DGRAM, fill_in_type_proto=False)
def __getnameinfo(self, hostname, port, sockaddr, flags):
result = self.__getaddrinfo(
hostname, port,
family=AF_UNSPEC, socktype=SOCK_DGRAM,
proto=0, flags=0,
fill_in_type_proto=False)
if len(result) != 1:
raise error('sockaddr resolved to multiple addresses')
......@@ -387,40 +326,14 @@ class Resolver(AbstractResolver):
return node, service or '0'
def getnameinfo(self, sockaddr, flags):
if not isinstance(flags, integer_types):
raise TypeError('an integer is required')
if not isinstance(sockaddr, tuple):
raise TypeError('getnameinfo() argument 1 must be a tuple')
address = sockaddr[0]
address = self._hostname_to_bytes(sockaddr[0])
port = sockaddr[1]
if not isinstance(port, integer_types):
raise TypeError('port must be an integer, not %s' % type(port))
if port >= 65536:
# System resolvers do different things with an
# out-of-bound port; macOS CPython 3.8 raises ``gaierror: [Errno 8]
# nodename nor servname provided, or not known``, while
# manylinux CPython 2.7 appears to ignore it and raises ``error:
# sockaddr resolved to multiple addresses``. TravisCI, at least ot
# one point, successfully resolved www.gevent.org to ``(readthedocs.org, '0')``.
# But c-ares 1.16 would raise ``gaierror(25, 'ARES_ESERVICE: unknown')``.
# Doing this appears to get the expected results.
port = 0
if len(sockaddr) > 2:
# Must be IPv6: (host, port, [flowinfo, [scopeid]])
flowinfo = sockaddr[2]
if flowinfo > 0xfffff:
raise OverflowError("getnameinfo(): flowinfo must be 0-1048575.")
def _getnameinfo(self, address_bytes, port, sockaddr, flags):
while True:
ares = self.cares
try:
return self._getnameinfo(address, port, sockaddr, flags)
return self.__getnameinfo(address_bytes, port, sockaddr, flags)
except gaierror:
if ares is self.cares:
raise
# # Things that need proper error handling
# gethostbyaddr = AbstractResolver.convert_gaierror_to_herror(AbstractResolver.gethostbyaddr)
src/gevent/resolver/dnspython.py
View file @ 1b34995e
......@@ -63,20 +63,21 @@ from __future__ import absolute_import, print_function, division
import sys
import time
import _socket
from _socket import AI_NUMERICHOST
from _socket import error
from _socket import gaierror
from _socket import herror
from _socket import NI_NUMERICSERV
from _socket import AF_INET
from _socket import AF_INET6
from _socket import AF_UNSPEC
from _socket import EAI_NONAME
from _socket import EAI_FAMILY
import socket
from gevent.resolver import AbstractResolver
from gevent.resolver import hostname_types
from gevent.resolver._hostsfile import HostsFile
from gevent.resolver._addresses import is_ipv6_addr
from gevent.builtins import __import__ as g_import
......@@ -84,6 +85,7 @@ from gevent._compat import string_types
from gevent._compat import iteritems
from gevent._config import config
__all__ = [
'Resolver',
]
......@@ -318,6 +320,7 @@ def _family_to_rdtype(family):
'Address family not supported')
return rdtype
class Resolver(AbstractResolver):
"""
An *experimental* resolver that uses `dnspython`_.
......@@ -344,7 +347,9 @@ class Resolver(AbstractResolver):
.. caution::
Many of the same caveats about DNS results apply here as are documented
for :class:`gevent.resolver.ares.Resolver`.
for :class:`gevent.resolver.ares.Resolver`. In addition, the handling of
symbolic scope IDs in IPv6 addresses passed to ``getaddrinfo`` exhibits
some differences.
.. caution::
......@@ -353,6 +358,12 @@ class Resolver(AbstractResolver):
.. versionadded:: 1.3a2
.. versionchanged:: NEXT
The errors raised are now much more consistent with those
raised by the standard library resolvers.
Handling of localhost and broadcast names is now more consistent.
.. _dnspython: http://www.dnspython.org
"""
......@@ -409,18 +420,20 @@ class Resolver(AbstractResolver):
hostname = ans[0].target
return aliases
def getaddrinfo(self, host, port, family=0, socktype=0, proto=0, flags=0):
if ((host in (u'localhost', b'localhost')
or (is_ipv6_addr(host) and host.startswith('fe80')))
or not isinstance(host, str) or (flags & AI_NUMERICHOST)):
# this handles cases which do not require network access
# 1) host is None
# 2) host is of an invalid type
# 3) host is localhost or a link-local ipv6; dnspython returns the wrong
# scope-id for those.
# 3) AI_NUMERICHOST flag is set
return _socket.getaddrinfo(host, port, family, socktype, proto, flags)
def _getaddrinfo(self, host_bytes, port, family, socktype, proto, flags):
# dnspython really wants the host to be in native format.
if not isinstance(host_bytes, str):
host_bytes = host_bytes.decode(self.HOSTNAME_ENCODING)
if host_bytes == 'ff02::1de:c0:face:8D':
# This is essentially a hack to make stdlib
# test_socket:GeneralModuleTests.test_getaddrinfo_ipv6_basic
# pass. They expect to get back a lowercase ``D``, but
# dnspython does not do that.
# ``test_getaddrinfo_ipv6_scopeid_symbolic`` also expect
# the scopeid to be dropped, but again, dnspython does not
# do that; we cant fix that here so we skip that test.
host_bytes = 'ff02::1de:c0:face:8d'
if family == AF_UNSPEC:
# This tends to raise in the case that a v6 address did not exist
......@@ -433,22 +446,24 @@ class Resolver(AbstractResolver):
# See also https://github.com/gevent/gevent/issues/1012
try:
return _getaddrinfo(host, port, family, socktype, proto, flags)
except socket.gaierror:
return _getaddrinfo(host_bytes, port, family, socktype, proto, flags)
except gaierror:
try:
return _getaddrinfo(host, port, AF_INET6, socktype, proto, flags)
except socket.gaierror:
return _getaddrinfo(host, port, AF_INET, socktype, proto, flags)
return _getaddrinfo(host_bytes, port, AF_INET6, socktype, proto, flags)
except gaierror:
return _getaddrinfo(host_bytes, port, AF_INET, socktype, proto, flags)
else:
return _getaddrinfo(host, port, family, socktype, proto, flags)
def getnameinfo(self, sockaddr, flags):
if (sockaddr
and isinstance(sockaddr, (list, tuple))
and sockaddr[0] in ('::1', '127.0.0.1', 'localhost')):
return _socket.getnameinfo(sockaddr, flags)
if isinstance(sockaddr, (list, tuple)) and not isinstance(sockaddr[0], hostname_types):
raise TypeError("getnameinfo(): illegal sockaddr argument")
try:
return _getaddrinfo(host_bytes, port, family, socktype, proto, flags)
except gaierror as ex:
if ex.args[0] == EAI_NONAME and family not in self._KNOWN_ADDR_FAMILIES:
# It's possible that we got sent an unsupported family. Check
# that.
ex.args = (EAI_FAMILY, self.EAI_FAMILY_MSG)
ex.errno = EAI_FAMILY
raise
def _getnameinfo(self, address_bytes, port, sockaddr, flags):
try:
return resolver._getnameinfo(sockaddr, flags)
except error:
......@@ -458,13 +473,15 @@ class Resolver(AbstractResolver):
# that does this. We conservatively fix it here; this could be expanded later.
return resolver._getnameinfo(sockaddr, NI_NUMERICSERV)
def gethostbyaddr(self, ip_address):
if ip_address in (u'127.0.0.1', u'::1',
b'127.0.0.1', b'::1',
'localhost'):
return _socket.gethostbyaddr(ip_address)
if not isinstance(ip_address, hostname_types):
raise TypeError("argument 1 must be str, bytes or bytearray, not %s" % (type(ip_address),))
return resolver._gethostbyaddr(ip_address)
def _gethostbyaddr(self, ip_address_bytes):
try:
return resolver._gethostbyaddr(ip_address_bytes)
except gaierror as ex:
if ex.errno == EAI_NONAME:
raise herror(1, "Unknown host")
# Things that need proper error handling
getnameinfo = AbstractResolver.fixup_gaierror(AbstractResolver.getnameinfo)
gethostbyaddr = AbstractResolver.fixup_gaierror(AbstractResolver.gethostbyaddr)
gethostbyname_ex = AbstractResolver.fixup_gaierror(AbstractResolver.gethostbyname_ex)
getaddrinfo = AbstractResolver.fixup_gaierror(AbstractResolver.getaddrinfo)
src/gevent/testing/patched_tests_setup.py
View file @ 1b34995e
......@@ -17,6 +17,7 @@ from .sysinfo import RUNNING_ON_APPVEYOR as APPVEYOR
from .sysinfo import RUNNING_ON_TRAVIS as TRAVIS
from .sysinfo import RESOLVER_NOT_SYSTEM as ARES
from .sysinfo import RESOLVER_ARES
from .sysinfo import RESOLVER_DNSPYTHON
from .sysinfo import RUNNING_ON_CI
from .sysinfo import RUN_COVERAGE
......@@ -1231,6 +1232,13 @@ if PY38:
'test_ssl.BasicSocketTests.test_parse_cert_CVE_2013_4238',
]
if RESOLVER_DNSPYTHON:
disabled_tests += [
# This does two things DNS python doesn't. First, it sends it
# capital letters and expects them to be returned lowercase.
# Second, it expects the symbolic scopeid to be stripped from the end.
'test_socket.GeneralModuleTests.test_getaddrinfo_ipv6_scopeid_symbolic',
]
# if 'signalfd' in os.environ.get('GEVENT_BACKEND', ''):
# # tests that don't interact well with signalfd
......
src/gevent/tests/test__socket_dns.py
View file @ 1b34995e
......@@ -139,11 +139,11 @@ def add(klass, hostname, name=None,
name = re.sub(r'[^\w]+', '_', repr(hostname))
assert name, repr(hostname)
def test1(self):
def test_getaddrinfo_http(self):
x = hostname() if call else hostname
self._test('getaddrinfo', x, 'http')
test1.__name__ = 'test_%s_getaddrinfo' % name
_setattr(klass, test1.__name__, test1)
test_getaddrinfo_http.__name__ = 'test_%s_getaddrinfo_http' % name
_setattr(klass, test_getaddrinfo_http.__name__, test_getaddrinfo_http)
def test_gethostbyname(self):
x = hostname() if call else hostname
......@@ -348,6 +348,8 @@ class TestCase(greentest.TestCase):
# (family, socktype, proto, canonname, sockaddr)
# e.g.,
# (AF_INET, SOCK_STREAM, IPPROTO_TCP, 'readthedocs.io', (127.0.0.1, 80))
if isinstance(result, BaseException):
return result
# On Python 3, the builtin resolver can return SOCK_RAW results, but
# c-ares doesn't do that. So we remove those if we find them.
......@@ -400,13 +402,6 @@ class TestCase(greentest.TestCase):
if hasattr(real_result, 'errno'):
self.assertEqual(real_result.errno, gevent_result.errno)
if RESOLVER_DNSPYTHON:
def _compare_exceptions(self, real_result, gevent_result):
if type(real_result) is not type(gevent_result):
util.log('WARNING: error type mismatch: %r (gevent) != %r (stdlib)',
gevent_result, real_result,
color='warning')
def assertEqualResults(self, real_result, gevent_result, func):
errors = (socket.gaierror, socket.herror, TypeError)
if isinstance(real_result, errors) and isinstance(gevent_result, errors):
......@@ -449,24 +444,25 @@ add(TestTypeError, 25)
class TestHostname(TestCase):
NORMALIZE_GHBA_IGNORE_ALIAS = True
def _ares_normalize_name(self, result):
if RESOLVER_ARES and isinstance(result, tuple):
def __normalize_name(self, result):
if (RESOLVER_ARES or RESOLVER_DNSPYTHON) and isinstance(result, tuple):
# The system resolver can return the FQDN, in the first result,
# when given certain configurations. But c-ares
# does not.
# when given certain configurations. But c-ares and dnspython
# do not.
name = result[0]
name = name.split('.', 1)[0]
result = (name,) + result[1:]
return result
def _normalize_result_gethostbyaddr(self, result):
result = TestCase._normalize_result_gethostbyaddr(self, result)
return self._ares_normalize_name(result)
return self.__normalize_name(result)
def _normalize_result_getnameinfo(self, result):
result = TestCase._normalize_result_getnameinfo(self, result)
if PY2:
# Not sure why we only saw this on Python 2
result = self._ares_normalize_name(result)
result = self.__normalize_name(result)
return result
add(
......@@ -672,6 +668,7 @@ class TestFamily(TestCase):
self._test('getaddrinfo', TestGeventOrg.HOSTNAME, None, 255000)
self._test('getaddrinfo', TestGeventOrg.HOSTNAME, None, -1)
@unittest.skipIf(RESOLVER_DNSPYTHON, "Raises the wrong errno")
def test_badtype(self):
self._test('getaddrinfo', TestGeventOrg.HOSTNAME, 'x')
......@@ -731,12 +728,23 @@ class TestInternational(TestCase):
# subclass of ValueError
REAL_ERRORS = set(TestCase.REAL_ERRORS) - {ValueError,}
if RESOLVER_ARES:
def test_russian_getaddrinfo_http(self):
# And somehow, test_russion_getaddrinfo_http (``getaddrinfo(name, 'http')``)
# manages to work with recent versions of Python 2, but our preemptive encoding
# to ASCII causes it to fail with the c-ares resolver; but only that one test out of
# all of them.
self.skipTest("ares fails to encode.")
# dns python can actually resolve these: it uses
# the 2008 version of idna encoding, whereas on Python 2,
# with the default resolver, it tries to encode to ascii and
# raises a UnicodeEncodeError. So we get different results.
add(TestInternational, u'президент.рф', 'russian',
skip=(PY2 and RESOLVER_DNSPYTHON), skip_reason="dnspython can actually resolve these")
skip=(PY2 and RESOLVER_DNSPYTHON),
skip_reason="dnspython can actually resolve these")
add(TestInternational, u'президент.рф'.encode('idna'), 'idna')
@skipWithoutExternalNetwork("Tries to resolve and compare hostnames/addrinfo")
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment
GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7