mirror of
https://github.com/janeczku/calibre-web
synced 2024-12-27 02:20:31 +00:00
bbf6d9b026
Bugfix for feeds
- removed categories related and up
- load new books now working
- category random now working
login page is free of non accessible elements
boolean custom column is vivible in UI
books with only with certain languages can be shown
book shelfs can be deleted from UI
Anonymous user view is more resticted
Added browse of series in sidebar
Dependencys in vendor folder are updated to newer versions (licencs files are now present)
Bugfix editing Authors names
Made upload on windows working
650 lines
26 KiB
Python
650 lines
26 KiB
Python
"""Blocking and non-blocking HTTP client interfaces.
|
|
|
|
This module defines a common interface shared by two implementations,
|
|
``simple_httpclient`` and ``curl_httpclient``. Applications may either
|
|
instantiate their chosen implementation class directly or use the
|
|
`AsyncHTTPClient` class from this module, which selects an implementation
|
|
that can be overridden with the `AsyncHTTPClient.configure` method.
|
|
|
|
The default implementation is ``simple_httpclient``, and this is expected
|
|
to be suitable for most users' needs. However, some applications may wish
|
|
to switch to ``curl_httpclient`` for reasons such as the following:
|
|
|
|
* ``curl_httpclient`` has some features not found in ``simple_httpclient``,
|
|
including support for HTTP proxies and the ability to use a specified
|
|
network interface.
|
|
|
|
* ``curl_httpclient`` is more likely to be compatible with sites that are
|
|
not-quite-compliant with the HTTP spec, or sites that use little-exercised
|
|
features of HTTP.
|
|
|
|
* ``curl_httpclient`` is faster.
|
|
|
|
* ``curl_httpclient`` was the default prior to Tornado 2.0.
|
|
|
|
Note that if you are using ``curl_httpclient``, it is highly
|
|
recommended that you use a recent version of ``libcurl`` and
|
|
``pycurl``. Currently the minimum supported version of libcurl is
|
|
7.21.1, and the minimum version of pycurl is 7.18.2. It is highly
|
|
recommended that your ``libcurl`` installation is built with
|
|
asynchronous DNS resolver (threaded or c-ares), otherwise you may
|
|
encounter various problems with request timeouts (for more
|
|
information, see
|
|
http://curl.haxx.se/libcurl/c/curl_easy_setopt.html#CURLOPTCONNECTTIMEOUTMS
|
|
and comments in curl_httpclient.py).
|
|
|
|
To select ``curl_httpclient``, call `AsyncHTTPClient.configure` at startup::
|
|
|
|
AsyncHTTPClient.configure("tornado.curl_httpclient.CurlAsyncHTTPClient")
|
|
"""
|
|
|
|
from __future__ import absolute_import, division, print_function, with_statement
|
|
|
|
import functools
|
|
import time
|
|
import weakref
|
|
|
|
from tornado.concurrent import TracebackFuture
|
|
from tornado.escape import utf8, native_str
|
|
from tornado import httputil, stack_context
|
|
from tornado.ioloop import IOLoop
|
|
from tornado.util import Configurable
|
|
|
|
|
|
class HTTPClient(object):
|
|
"""A blocking HTTP client.
|
|
|
|
This interface is provided for convenience and testing; most applications
|
|
that are running an IOLoop will want to use `AsyncHTTPClient` instead.
|
|
Typical usage looks like this::
|
|
|
|
http_client = httpclient.HTTPClient()
|
|
try:
|
|
response = http_client.fetch("http://www.google.com/")
|
|
print response.body
|
|
except httpclient.HTTPError as e:
|
|
# HTTPError is raised for non-200 responses; the response
|
|
# can be found in e.response.
|
|
print("Error: " + str(e))
|
|
except Exception as e:
|
|
# Other errors are possible, such as IOError.
|
|
print("Error: " + str(e))
|
|
http_client.close()
|
|
"""
|
|
def __init__(self, async_client_class=None, **kwargs):
|
|
self._io_loop = IOLoop()
|
|
if async_client_class is None:
|
|
async_client_class = AsyncHTTPClient
|
|
self._async_client = async_client_class(self._io_loop, **kwargs)
|
|
self._closed = False
|
|
|
|
def __del__(self):
|
|
self.close()
|
|
|
|
def close(self):
|
|
"""Closes the HTTPClient, freeing any resources used."""
|
|
if not self._closed:
|
|
self._async_client.close()
|
|
self._io_loop.close()
|
|
self._closed = True
|
|
|
|
def fetch(self, request, **kwargs):
|
|
"""Executes a request, returning an `HTTPResponse`.
|
|
|
|
The request may be either a string URL or an `HTTPRequest` object.
|
|
If it is a string, we construct an `HTTPRequest` using any additional
|
|
kwargs: ``HTTPRequest(request, **kwargs)``
|
|
|
|
If an error occurs during the fetch, we raise an `HTTPError` unless
|
|
the ``raise_error`` keyword argument is set to False.
|
|
"""
|
|
response = self._io_loop.run_sync(functools.partial(
|
|
self._async_client.fetch, request, **kwargs))
|
|
response.rethrow()
|
|
return response
|
|
|
|
|
|
class AsyncHTTPClient(Configurable):
|
|
"""An non-blocking HTTP client.
|
|
|
|
Example usage::
|
|
|
|
def handle_request(response):
|
|
if response.error:
|
|
print "Error:", response.error
|
|
else:
|
|
print response.body
|
|
|
|
http_client = AsyncHTTPClient()
|
|
http_client.fetch("http://www.google.com/", handle_request)
|
|
|
|
The constructor for this class is magic in several respects: It
|
|
actually creates an instance of an implementation-specific
|
|
subclass, and instances are reused as a kind of pseudo-singleton
|
|
(one per `.IOLoop`). The keyword argument ``force_instance=True``
|
|
can be used to suppress this singleton behavior. Unless
|
|
``force_instance=True`` is used, no arguments other than
|
|
``io_loop`` should be passed to the `AsyncHTTPClient` constructor.
|
|
The implementation subclass as well as arguments to its
|
|
constructor can be set with the static method `configure()`
|
|
|
|
All `AsyncHTTPClient` implementations support a ``defaults``
|
|
keyword argument, which can be used to set default values for
|
|
`HTTPRequest` attributes. For example::
|
|
|
|
AsyncHTTPClient.configure(
|
|
None, defaults=dict(user_agent="MyUserAgent"))
|
|
# or with force_instance:
|
|
client = AsyncHTTPClient(force_instance=True,
|
|
defaults=dict(user_agent="MyUserAgent"))
|
|
|
|
.. versionchanged:: 4.1
|
|
The ``io_loop`` argument is deprecated.
|
|
"""
|
|
@classmethod
|
|
def configurable_base(cls):
|
|
return AsyncHTTPClient
|
|
|
|
@classmethod
|
|
def configurable_default(cls):
|
|
from tornado.simple_httpclient import SimpleAsyncHTTPClient
|
|
return SimpleAsyncHTTPClient
|
|
|
|
@classmethod
|
|
def _async_clients(cls):
|
|
attr_name = '_async_client_dict_' + cls.__name__
|
|
if not hasattr(cls, attr_name):
|
|
setattr(cls, attr_name, weakref.WeakKeyDictionary())
|
|
return getattr(cls, attr_name)
|
|
|
|
def __new__(cls, io_loop=None, force_instance=False, **kwargs):
|
|
io_loop = io_loop or IOLoop.current()
|
|
if force_instance:
|
|
instance_cache = None
|
|
else:
|
|
instance_cache = cls._async_clients()
|
|
if instance_cache is not None and io_loop in instance_cache:
|
|
return instance_cache[io_loop]
|
|
instance = super(AsyncHTTPClient, cls).__new__(cls, io_loop=io_loop,
|
|
**kwargs)
|
|
# Make sure the instance knows which cache to remove itself from.
|
|
# It can't simply call _async_clients() because we may be in
|
|
# __new__(AsyncHTTPClient) but instance.__class__ may be
|
|
# SimpleAsyncHTTPClient.
|
|
instance._instance_cache = instance_cache
|
|
if instance_cache is not None:
|
|
instance_cache[instance.io_loop] = instance
|
|
return instance
|
|
|
|
def initialize(self, io_loop, defaults=None):
|
|
self.io_loop = io_loop
|
|
self.defaults = dict(HTTPRequest._DEFAULTS)
|
|
if defaults is not None:
|
|
self.defaults.update(defaults)
|
|
self._closed = False
|
|
|
|
def close(self):
|
|
"""Destroys this HTTP client, freeing any file descriptors used.
|
|
|
|
This method is **not needed in normal use** due to the way
|
|
that `AsyncHTTPClient` objects are transparently reused.
|
|
``close()`` is generally only necessary when either the
|
|
`.IOLoop` is also being closed, or the ``force_instance=True``
|
|
argument was used when creating the `AsyncHTTPClient`.
|
|
|
|
No other methods may be called on the `AsyncHTTPClient` after
|
|
``close()``.
|
|
|
|
"""
|
|
if self._closed:
|
|
return
|
|
self._closed = True
|
|
if self._instance_cache is not None:
|
|
if self._instance_cache.get(self.io_loop) is not self:
|
|
raise RuntimeError("inconsistent AsyncHTTPClient cache")
|
|
del self._instance_cache[self.io_loop]
|
|
|
|
def fetch(self, request, callback=None, raise_error=True, **kwargs):
|
|
"""Executes a request, asynchronously returning an `HTTPResponse`.
|
|
|
|
The request may be either a string URL or an `HTTPRequest` object.
|
|
If it is a string, we construct an `HTTPRequest` using any additional
|
|
kwargs: ``HTTPRequest(request, **kwargs)``
|
|
|
|
This method returns a `.Future` whose result is an
|
|
`HTTPResponse`. By default, the ``Future`` will raise an `HTTPError`
|
|
if the request returned a non-200 response code. Instead, if
|
|
``raise_error`` is set to False, the response will always be
|
|
returned regardless of the response code.
|
|
|
|
If a ``callback`` is given, it will be invoked with the `HTTPResponse`.
|
|
In the callback interface, `HTTPError` is not automatically raised.
|
|
Instead, you must check the response's ``error`` attribute or
|
|
call its `~HTTPResponse.rethrow` method.
|
|
"""
|
|
if self._closed:
|
|
raise RuntimeError("fetch() called on closed AsyncHTTPClient")
|
|
if not isinstance(request, HTTPRequest):
|
|
request = HTTPRequest(url=request, **kwargs)
|
|
# We may modify this (to add Host, Accept-Encoding, etc),
|
|
# so make sure we don't modify the caller's object. This is also
|
|
# where normal dicts get converted to HTTPHeaders objects.
|
|
request.headers = httputil.HTTPHeaders(request.headers)
|
|
request = _RequestProxy(request, self.defaults)
|
|
future = TracebackFuture()
|
|
if callback is not None:
|
|
callback = stack_context.wrap(callback)
|
|
|
|
def handle_future(future):
|
|
exc = future.exception()
|
|
if isinstance(exc, HTTPError) and exc.response is not None:
|
|
response = exc.response
|
|
elif exc is not None:
|
|
response = HTTPResponse(
|
|
request, 599, error=exc,
|
|
request_time=time.time() - request.start_time)
|
|
else:
|
|
response = future.result()
|
|
self.io_loop.add_callback(callback, response)
|
|
future.add_done_callback(handle_future)
|
|
|
|
def handle_response(response):
|
|
if raise_error and response.error:
|
|
future.set_exception(response.error)
|
|
else:
|
|
future.set_result(response)
|
|
self.fetch_impl(request, handle_response)
|
|
return future
|
|
|
|
def fetch_impl(self, request, callback):
|
|
raise NotImplementedError()
|
|
|
|
@classmethod
|
|
def configure(cls, impl, **kwargs):
|
|
"""Configures the `AsyncHTTPClient` subclass to use.
|
|
|
|
``AsyncHTTPClient()`` actually creates an instance of a subclass.
|
|
This method may be called with either a class object or the
|
|
fully-qualified name of such a class (or ``None`` to use the default,
|
|
``SimpleAsyncHTTPClient``)
|
|
|
|
If additional keyword arguments are given, they will be passed
|
|
to the constructor of each subclass instance created. The
|
|
keyword argument ``max_clients`` determines the maximum number
|
|
of simultaneous `~AsyncHTTPClient.fetch()` operations that can
|
|
execute in parallel on each `.IOLoop`. Additional arguments
|
|
may be supported depending on the implementation class in use.
|
|
|
|
Example::
|
|
|
|
AsyncHTTPClient.configure("tornado.curl_httpclient.CurlAsyncHTTPClient")
|
|
"""
|
|
super(AsyncHTTPClient, cls).configure(impl, **kwargs)
|
|
|
|
|
|
class HTTPRequest(object):
|
|
"""HTTP client request object."""
|
|
|
|
# Default values for HTTPRequest parameters.
|
|
# Merged with the values on the request object by AsyncHTTPClient
|
|
# implementations.
|
|
_DEFAULTS = dict(
|
|
connect_timeout=20.0,
|
|
request_timeout=20.0,
|
|
follow_redirects=True,
|
|
max_redirects=5,
|
|
decompress_response=True,
|
|
proxy_password='',
|
|
allow_nonstandard_methods=False,
|
|
validate_cert=True)
|
|
|
|
def __init__(self, url, method="GET", headers=None, body=None,
|
|
auth_username=None, auth_password=None, auth_mode=None,
|
|
connect_timeout=None, request_timeout=None,
|
|
if_modified_since=None, follow_redirects=None,
|
|
max_redirects=None, user_agent=None, use_gzip=None,
|
|
network_interface=None, streaming_callback=None,
|
|
header_callback=None, prepare_curl_callback=None,
|
|
proxy_host=None, proxy_port=None, proxy_username=None,
|
|
proxy_password=None, allow_nonstandard_methods=None,
|
|
validate_cert=None, ca_certs=None,
|
|
allow_ipv6=None,
|
|
client_key=None, client_cert=None, body_producer=None,
|
|
expect_100_continue=False, decompress_response=None):
|
|
r"""All parameters except ``url`` are optional.
|
|
|
|
:arg string url: URL to fetch
|
|
:arg string method: HTTP method, e.g. "GET" or "POST"
|
|
:arg headers: Additional HTTP headers to pass on the request
|
|
:type headers: `~tornado.httputil.HTTPHeaders` or `dict`
|
|
:arg body: HTTP request body as a string (byte or unicode; if unicode
|
|
the utf-8 encoding will be used)
|
|
:arg body_producer: Callable used for lazy/asynchronous request bodies.
|
|
It is called with one argument, a ``write`` function, and should
|
|
return a `.Future`. It should call the write function with new
|
|
data as it becomes available. The write function returns a
|
|
`.Future` which can be used for flow control.
|
|
Only one of ``body`` and ``body_producer`` may
|
|
be specified. ``body_producer`` is not supported on
|
|
``curl_httpclient``. When using ``body_producer`` it is recommended
|
|
to pass a ``Content-Length`` in the headers as otherwise chunked
|
|
encoding will be used, and many servers do not support chunked
|
|
encoding on requests. New in Tornado 4.0
|
|
:arg string auth_username: Username for HTTP authentication
|
|
:arg string auth_password: Password for HTTP authentication
|
|
:arg string auth_mode: Authentication mode; default is "basic".
|
|
Allowed values are implementation-defined; ``curl_httpclient``
|
|
supports "basic" and "digest"; ``simple_httpclient`` only supports
|
|
"basic"
|
|
:arg float connect_timeout: Timeout for initial connection in seconds
|
|
:arg float request_timeout: Timeout for entire request in seconds
|
|
:arg if_modified_since: Timestamp for ``If-Modified-Since`` header
|
|
:type if_modified_since: `datetime` or `float`
|
|
:arg bool follow_redirects: Should redirects be followed automatically
|
|
or return the 3xx response?
|
|
:arg int max_redirects: Limit for ``follow_redirects``
|
|
:arg string user_agent: String to send as ``User-Agent`` header
|
|
:arg bool decompress_response: Request a compressed response from
|
|
the server and decompress it after downloading. Default is True.
|
|
New in Tornado 4.0.
|
|
:arg bool use_gzip: Deprecated alias for ``decompress_response``
|
|
since Tornado 4.0.
|
|
:arg string network_interface: Network interface to use for request.
|
|
``curl_httpclient`` only; see note below.
|
|
:arg callable streaming_callback: If set, ``streaming_callback`` will
|
|
be run with each chunk of data as it is received, and
|
|
``HTTPResponse.body`` and ``HTTPResponse.buffer`` will be empty in
|
|
the final response.
|
|
:arg callable header_callback: If set, ``header_callback`` will
|
|
be run with each header line as it is received (including the
|
|
first line, e.g. ``HTTP/1.0 200 OK\r\n``, and a final line
|
|
containing only ``\r\n``. All lines include the trailing newline
|
|
characters). ``HTTPResponse.headers`` will be empty in the final
|
|
response. This is most useful in conjunction with
|
|
``streaming_callback``, because it's the only way to get access to
|
|
header data while the request is in progress.
|
|
:arg callable prepare_curl_callback: If set, will be called with
|
|
a ``pycurl.Curl`` object to allow the application to make additional
|
|
``setopt`` calls.
|
|
:arg string proxy_host: HTTP proxy hostname. To use proxies,
|
|
``proxy_host`` and ``proxy_port`` must be set; ``proxy_username`` and
|
|
``proxy_pass`` are optional. Proxies are currently only supported
|
|
with ``curl_httpclient``.
|
|
:arg int proxy_port: HTTP proxy port
|
|
:arg string proxy_username: HTTP proxy username
|
|
:arg string proxy_password: HTTP proxy password
|
|
:arg bool allow_nonstandard_methods: Allow unknown values for ``method``
|
|
argument?
|
|
:arg bool validate_cert: For HTTPS requests, validate the server's
|
|
certificate?
|
|
:arg string ca_certs: filename of CA certificates in PEM format,
|
|
or None to use defaults. See note below when used with
|
|
``curl_httpclient``.
|
|
:arg bool allow_ipv6: Use IPv6 when available? Default is false in
|
|
``simple_httpclient`` and true in ``curl_httpclient``
|
|
:arg string client_key: Filename for client SSL key, if any. See
|
|
note below when used with ``curl_httpclient``.
|
|
:arg string client_cert: Filename for client SSL certificate, if any.
|
|
See note below when used with ``curl_httpclient``.
|
|
:arg bool expect_100_continue: If true, send the
|
|
``Expect: 100-continue`` header and wait for a continue response
|
|
before sending the request body. Only supported with
|
|
simple_httpclient.
|
|
|
|
.. note::
|
|
|
|
When using ``curl_httpclient`` certain options may be
|
|
inherited by subsequent fetches because ``pycurl`` does
|
|
not allow them to be cleanly reset. This applies to the
|
|
``ca_certs``, ``client_key``, ``client_cert``, and
|
|
``network_interface`` arguments. If you use these
|
|
options, you should pass them on every request (you don't
|
|
have to always use the same values, but it's not possible
|
|
to mix requests that specify these options with ones that
|
|
use the defaults).
|
|
|
|
.. versionadded:: 3.1
|
|
The ``auth_mode`` argument.
|
|
|
|
.. versionadded:: 4.0
|
|
The ``body_producer`` and ``expect_100_continue`` arguments.
|
|
"""
|
|
# Note that some of these attributes go through property setters
|
|
# defined below.
|
|
self.headers = headers
|
|
if if_modified_since:
|
|
self.headers["If-Modified-Since"] = httputil.format_timestamp(
|
|
if_modified_since)
|
|
self.proxy_host = proxy_host
|
|
self.proxy_port = proxy_port
|
|
self.proxy_username = proxy_username
|
|
self.proxy_password = proxy_password
|
|
self.url = url
|
|
self.method = method
|
|
self.body = body
|
|
self.body_producer = body_producer
|
|
self.auth_username = auth_username
|
|
self.auth_password = auth_password
|
|
self.auth_mode = auth_mode
|
|
self.connect_timeout = connect_timeout
|
|
self.request_timeout = request_timeout
|
|
self.follow_redirects = follow_redirects
|
|
self.max_redirects = max_redirects
|
|
self.user_agent = user_agent
|
|
if decompress_response is not None:
|
|
self.decompress_response = decompress_response
|
|
else:
|
|
self.decompress_response = use_gzip
|
|
self.network_interface = network_interface
|
|
self.streaming_callback = streaming_callback
|
|
self.header_callback = header_callback
|
|
self.prepare_curl_callback = prepare_curl_callback
|
|
self.allow_nonstandard_methods = allow_nonstandard_methods
|
|
self.validate_cert = validate_cert
|
|
self.ca_certs = ca_certs
|
|
self.allow_ipv6 = allow_ipv6
|
|
self.client_key = client_key
|
|
self.client_cert = client_cert
|
|
self.expect_100_continue = expect_100_continue
|
|
self.start_time = time.time()
|
|
|
|
@property
|
|
def headers(self):
|
|
return self._headers
|
|
|
|
@headers.setter
|
|
def headers(self, value):
|
|
if value is None:
|
|
self._headers = httputil.HTTPHeaders()
|
|
else:
|
|
self._headers = value
|
|
|
|
@property
|
|
def body(self):
|
|
return self._body
|
|
|
|
@body.setter
|
|
def body(self, value):
|
|
self._body = utf8(value)
|
|
|
|
@property
|
|
def body_producer(self):
|
|
return self._body_producer
|
|
|
|
@body_producer.setter
|
|
def body_producer(self, value):
|
|
self._body_producer = stack_context.wrap(value)
|
|
|
|
@property
|
|
def streaming_callback(self):
|
|
return self._streaming_callback
|
|
|
|
@streaming_callback.setter
|
|
def streaming_callback(self, value):
|
|
self._streaming_callback = stack_context.wrap(value)
|
|
|
|
@property
|
|
def header_callback(self):
|
|
return self._header_callback
|
|
|
|
@header_callback.setter
|
|
def header_callback(self, value):
|
|
self._header_callback = stack_context.wrap(value)
|
|
|
|
@property
|
|
def prepare_curl_callback(self):
|
|
return self._prepare_curl_callback
|
|
|
|
@prepare_curl_callback.setter
|
|
def prepare_curl_callback(self, value):
|
|
self._prepare_curl_callback = stack_context.wrap(value)
|
|
|
|
|
|
class HTTPResponse(object):
|
|
"""HTTP Response object.
|
|
|
|
Attributes:
|
|
|
|
* request: HTTPRequest object
|
|
|
|
* code: numeric HTTP status code, e.g. 200 or 404
|
|
|
|
* reason: human-readable reason phrase describing the status code
|
|
|
|
* headers: `tornado.httputil.HTTPHeaders` object
|
|
|
|
* effective_url: final location of the resource after following any
|
|
redirects
|
|
|
|
* buffer: ``cStringIO`` object for response body
|
|
|
|
* body: response body as string (created on demand from ``self.buffer``)
|
|
|
|
* error: Exception object, if any
|
|
|
|
* request_time: seconds from request start to finish
|
|
|
|
* time_info: dictionary of diagnostic timing information from the request.
|
|
Available data are subject to change, but currently uses timings
|
|
available from http://curl.haxx.se/libcurl/c/curl_easy_getinfo.html,
|
|
plus ``queue``, which is the delay (if any) introduced by waiting for
|
|
a slot under `AsyncHTTPClient`'s ``max_clients`` setting.
|
|
"""
|
|
def __init__(self, request, code, headers=None, buffer=None,
|
|
effective_url=None, error=None, request_time=None,
|
|
time_info=None, reason=None):
|
|
if isinstance(request, _RequestProxy):
|
|
self.request = request.request
|
|
else:
|
|
self.request = request
|
|
self.code = code
|
|
self.reason = reason or httputil.responses.get(code, "Unknown")
|
|
if headers is not None:
|
|
self.headers = headers
|
|
else:
|
|
self.headers = httputil.HTTPHeaders()
|
|
self.buffer = buffer
|
|
self._body = None
|
|
if effective_url is None:
|
|
self.effective_url = request.url
|
|
else:
|
|
self.effective_url = effective_url
|
|
if error is None:
|
|
if self.code < 200 or self.code >= 300:
|
|
self.error = HTTPError(self.code, message=self.reason,
|
|
response=self)
|
|
else:
|
|
self.error = None
|
|
else:
|
|
self.error = error
|
|
self.request_time = request_time
|
|
self.time_info = time_info or {}
|
|
|
|
def _get_body(self):
|
|
if self.buffer is None:
|
|
return None
|
|
elif self._body is None:
|
|
self._body = self.buffer.getvalue()
|
|
|
|
return self._body
|
|
|
|
body = property(_get_body)
|
|
|
|
def rethrow(self):
|
|
"""If there was an error on the request, raise an `HTTPError`."""
|
|
if self.error:
|
|
raise self.error
|
|
|
|
def __repr__(self):
|
|
args = ",".join("%s=%r" % i for i in sorted(self.__dict__.items()))
|
|
return "%s(%s)" % (self.__class__.__name__, args)
|
|
|
|
|
|
class HTTPError(Exception):
|
|
"""Exception thrown for an unsuccessful HTTP request.
|
|
|
|
Attributes:
|
|
|
|
* ``code`` - HTTP error integer error code, e.g. 404. Error code 599 is
|
|
used when no HTTP response was received, e.g. for a timeout.
|
|
|
|
* ``response`` - `HTTPResponse` object, if any.
|
|
|
|
Note that if ``follow_redirects`` is False, redirects become HTTPErrors,
|
|
and you can look at ``error.response.headers['Location']`` to see the
|
|
destination of the redirect.
|
|
"""
|
|
def __init__(self, code, message=None, response=None):
|
|
self.code = code
|
|
message = message or httputil.responses.get(code, "Unknown")
|
|
self.response = response
|
|
Exception.__init__(self, "HTTP %d: %s" % (self.code, message))
|
|
|
|
|
|
class _RequestProxy(object):
|
|
"""Combines an object with a dictionary of defaults.
|
|
|
|
Used internally by AsyncHTTPClient implementations.
|
|
"""
|
|
def __init__(self, request, defaults):
|
|
self.request = request
|
|
self.defaults = defaults
|
|
|
|
def __getattr__(self, name):
|
|
request_attr = getattr(self.request, name)
|
|
if request_attr is not None:
|
|
return request_attr
|
|
elif self.defaults is not None:
|
|
return self.defaults.get(name, None)
|
|
else:
|
|
return None
|
|
|
|
|
|
def main():
|
|
from tornado.options import define, options, parse_command_line
|
|
define("print_headers", type=bool, default=False)
|
|
define("print_body", type=bool, default=True)
|
|
define("follow_redirects", type=bool, default=True)
|
|
define("validate_cert", type=bool, default=True)
|
|
args = parse_command_line()
|
|
client = HTTPClient()
|
|
for arg in args:
|
|
try:
|
|
response = client.fetch(arg,
|
|
follow_redirects=options.follow_redirects,
|
|
validate_cert=options.validate_cert,
|
|
)
|
|
except HTTPError as e:
|
|
if e.response is not None:
|
|
response = e.response
|
|
else:
|
|
raise
|
|
if options.print_headers:
|
|
print(response.headers)
|
|
if options.print_body:
|
|
print(native_str(response.body))
|
|
client.close()
|
|
|
|
if __name__ == "__main__":
|
|
main()
|