|
from __future__ import absolute_import |
|
|
|
from .packages.six.moves.http_client import IncompleteRead as httplib_IncompleteRead |
|
|
|
|
|
|
|
|
|
class HTTPError(Exception): |
|
"""Base exception used by this module.""" |
|
|
|
pass |
|
|
|
|
|
class HTTPWarning(Warning): |
|
"""Base warning used by this module.""" |
|
|
|
pass |
|
|
|
|
|
class PoolError(HTTPError): |
|
"""Base exception for errors caused within a pool.""" |
|
|
|
def __init__(self, pool, message): |
|
self.pool = pool |
|
HTTPError.__init__(self, "%s: %s" % (pool, message)) |
|
|
|
def __reduce__(self): |
|
|
|
return self.__class__, (None, None) |
|
|
|
|
|
class RequestError(PoolError): |
|
"""Base exception for PoolErrors that have associated URLs.""" |
|
|
|
def __init__(self, pool, url, message): |
|
self.url = url |
|
PoolError.__init__(self, pool, message) |
|
|
|
def __reduce__(self): |
|
|
|
return self.__class__, (None, self.url, None) |
|
|
|
|
|
class SSLError(HTTPError): |
|
"""Raised when SSL certificate fails in an HTTPS connection.""" |
|
|
|
pass |
|
|
|
|
|
class ProxyError(HTTPError): |
|
"""Raised when the connection to a proxy fails.""" |
|
|
|
def __init__(self, message, error, *args): |
|
super(ProxyError, self).__init__(message, error, *args) |
|
self.original_error = error |
|
|
|
|
|
class DecodeError(HTTPError): |
|
"""Raised when automatic decoding based on Content-Type fails.""" |
|
|
|
pass |
|
|
|
|
|
class ProtocolError(HTTPError): |
|
"""Raised when something unexpected happens mid-request/response.""" |
|
|
|
pass |
|
|
|
|
|
|
|
ConnectionError = ProtocolError |
|
|
|
|
|
|
|
|
|
|
|
class MaxRetryError(RequestError): |
|
"""Raised when the maximum number of retries is exceeded. |
|
|
|
:param pool: The connection pool |
|
:type pool: :class:`~urllib3.connectionpool.HTTPConnectionPool` |
|
:param string url: The requested Url |
|
:param exceptions.Exception reason: The underlying error |
|
|
|
""" |
|
|
|
def __init__(self, pool, url, reason=None): |
|
self.reason = reason |
|
|
|
message = "Max retries exceeded with url: %s (Caused by %r)" % (url, reason) |
|
|
|
RequestError.__init__(self, pool, url, message) |
|
|
|
|
|
class HostChangedError(RequestError): |
|
"""Raised when an existing pool gets a request for a foreign host.""" |
|
|
|
def __init__(self, pool, url, retries=3): |
|
message = "Tried to open a foreign host with url: %s" % url |
|
RequestError.__init__(self, pool, url, message) |
|
self.retries = retries |
|
|
|
|
|
class TimeoutStateError(HTTPError): |
|
"""Raised when passing an invalid state to a timeout""" |
|
|
|
pass |
|
|
|
|
|
class TimeoutError(HTTPError): |
|
"""Raised when a socket timeout error occurs. |
|
|
|
Catching this error will catch both :exc:`ReadTimeoutErrors |
|
<ReadTimeoutError>` and :exc:`ConnectTimeoutErrors <ConnectTimeoutError>`. |
|
""" |
|
|
|
pass |
|
|
|
|
|
class ReadTimeoutError(TimeoutError, RequestError): |
|
"""Raised when a socket timeout occurs while receiving data from a server""" |
|
|
|
pass |
|
|
|
|
|
|
|
|
|
class ConnectTimeoutError(TimeoutError): |
|
"""Raised when a socket timeout occurs while connecting to a server""" |
|
|
|
pass |
|
|
|
|
|
class NewConnectionError(ConnectTimeoutError, PoolError): |
|
"""Raised when we fail to establish a new connection. Usually ECONNREFUSED.""" |
|
|
|
pass |
|
|
|
|
|
class EmptyPoolError(PoolError): |
|
"""Raised when a pool runs out of connections and no more are allowed.""" |
|
|
|
pass |
|
|
|
|
|
class ClosedPoolError(PoolError): |
|
"""Raised when a request enters a pool after the pool has been closed.""" |
|
|
|
pass |
|
|
|
|
|
class LocationValueError(ValueError, HTTPError): |
|
"""Raised when there is something wrong with a given URL input.""" |
|
|
|
pass |
|
|
|
|
|
class LocationParseError(LocationValueError): |
|
"""Raised when get_host or similar fails to parse the URL input.""" |
|
|
|
def __init__(self, location): |
|
message = "Failed to parse: %s" % location |
|
HTTPError.__init__(self, message) |
|
|
|
self.location = location |
|
|
|
|
|
class URLSchemeUnknown(LocationValueError): |
|
"""Raised when a URL input has an unsupported scheme.""" |
|
|
|
def __init__(self, scheme): |
|
message = "Not supported URL scheme %s" % scheme |
|
super(URLSchemeUnknown, self).__init__(message) |
|
|
|
self.scheme = scheme |
|
|
|
|
|
class ResponseError(HTTPError): |
|
"""Used as a container for an error reason supplied in a MaxRetryError.""" |
|
|
|
GENERIC_ERROR = "too many error responses" |
|
SPECIFIC_ERROR = "too many {status_code} error responses" |
|
|
|
|
|
class SecurityWarning(HTTPWarning): |
|
"""Warned when performing security reducing actions""" |
|
|
|
pass |
|
|
|
|
|
class SubjectAltNameWarning(SecurityWarning): |
|
"""Warned when connecting to a host with a certificate missing a SAN.""" |
|
|
|
pass |
|
|
|
|
|
class InsecureRequestWarning(SecurityWarning): |
|
"""Warned when making an unverified HTTPS request.""" |
|
|
|
pass |
|
|
|
|
|
class SystemTimeWarning(SecurityWarning): |
|
"""Warned when system time is suspected to be wrong""" |
|
|
|
pass |
|
|
|
|
|
class InsecurePlatformWarning(SecurityWarning): |
|
"""Warned when certain TLS/SSL configuration is not available on a platform.""" |
|
|
|
pass |
|
|
|
|
|
class SNIMissingWarning(HTTPWarning): |
|
"""Warned when making a HTTPS request without SNI available.""" |
|
|
|
pass |
|
|
|
|
|
class DependencyWarning(HTTPWarning): |
|
""" |
|
Warned when an attempt is made to import a module with missing optional |
|
dependencies. |
|
""" |
|
|
|
pass |
|
|
|
|
|
class ResponseNotChunked(ProtocolError, ValueError): |
|
"""Response needs to be chunked in order to read it as chunks.""" |
|
|
|
pass |
|
|
|
|
|
class BodyNotHttplibCompatible(HTTPError): |
|
""" |
|
Body should be :class:`http.client.HTTPResponse` like |
|
(have an fp attribute which returns raw chunks) for read_chunked(). |
|
""" |
|
|
|
pass |
|
|
|
|
|
class IncompleteRead(HTTPError, httplib_IncompleteRead): |
|
""" |
|
Response length doesn't match expected Content-Length |
|
|
|
Subclass of :class:`http.client.IncompleteRead` to allow int value |
|
for ``partial`` to avoid creating large objects on streamed reads. |
|
""" |
|
|
|
def __init__(self, partial, expected): |
|
super(IncompleteRead, self).__init__(partial, expected) |
|
|
|
def __repr__(self): |
|
return "IncompleteRead(%i bytes read, %i more expected)" % ( |
|
self.partial, |
|
self.expected, |
|
) |
|
|
|
|
|
class InvalidChunkLength(HTTPError, httplib_IncompleteRead): |
|
"""Invalid chunk length in a chunked response.""" |
|
|
|
def __init__(self, response, length): |
|
super(InvalidChunkLength, self).__init__( |
|
response.tell(), response.length_remaining |
|
) |
|
self.response = response |
|
self.length = length |
|
|
|
def __repr__(self): |
|
return "InvalidChunkLength(got length %r, %i bytes read)" % ( |
|
self.length, |
|
self.partial, |
|
) |
|
|
|
|
|
class InvalidHeader(HTTPError): |
|
"""The header provided was somehow invalid.""" |
|
|
|
pass |
|
|
|
|
|
class ProxySchemeUnknown(AssertionError, URLSchemeUnknown): |
|
"""ProxyManager does not support the supplied scheme""" |
|
|
|
|
|
|
|
def __init__(self, scheme): |
|
|
|
|
|
if scheme == "localhost": |
|
scheme = None |
|
if scheme is None: |
|
message = "Proxy URL had no scheme, should start with http:// or https://" |
|
else: |
|
message = ( |
|
"Proxy URL had unsupported scheme %s, should use http:// or https://" |
|
% scheme |
|
) |
|
super(ProxySchemeUnknown, self).__init__(message) |
|
|
|
|
|
class ProxySchemeUnsupported(ValueError): |
|
"""Fetching HTTPS resources through HTTPS proxies is unsupported""" |
|
|
|
pass |
|
|
|
|
|
class HeaderParsingError(HTTPError): |
|
"""Raised by assert_header_parsing, but we convert it to a log.warning statement.""" |
|
|
|
def __init__(self, defects, unparsed_data): |
|
message = "%s, unparsed data: %r" % (defects or "Unknown", unparsed_data) |
|
super(HeaderParsingError, self).__init__(message) |
|
|
|
|
|
class UnrewindableBodyError(HTTPError): |
|
"""urllib3 encountered an error when trying to rewind a body""" |
|
|
|
pass |
|
|