Warning: chmod(): Operation not permitted in /var/www/hopeinstoughton_www/wp-content/plugins/simple-universal-google-analytics/main.php on line 8 [0] in function chmod in /var/www/hopeinstoughton_www/wp-content/plugins/simple-universal-google-analytics/main.php on line 8 [1] in function include_once in /var/www/hopeinstoughton_www/wp-settings.php on line 560 [2] in function require_once in /var/www/hopeinstoughton_www/wp-config.php on line 85 [3] in function require_once in /var/www/hopeinstoughton_www/wp-load.php on line 50 [4] in function require_once in /var/www/hopeinstoughton_www/wp-blog-header.php on line 13 [5] in function require in /var/www/hopeinstoughton_www/index.php on line 17
| Server IP : 94.177.8.99 / Your IP : 216.73.217.165 Web Server : Apache/2.4.58 (Ubuntu) System : Linux aries 6.8.0-134-generic #134-Ubuntu SMP PREEMPT_DYNAMIC Fri Jun 26 18:43:11 UTC 2026 x86_64 User : www-data ( 33) PHP Version : 8.1.34 Disable Function : NONE MySQL : OFF | cURL : ON | WGET : ON | Perl : ON | Python : OFF | Sudo : ON | Pkexec : OFF Directory : /nuitka/eggshell.build/ |
Upload File : |
�� �request_callback�.�� �xheaders�.�� �protocol�.�� �HTTP1ConnectionParameters�.�� M.��p (�
decompress��
chunk_size��max_header_size��header_timeout��
max_body_size�� body_timeout��
no_keep_alive�t�.�� � conn_params�.��
� TCPServer�.�� �__init__�.��5 � ssl_options��max_buffer_size��read_chunk_size���.�� � _connections�.�� �trusted_downstream�.�� �
HTTPServer�.��- X& Close all open connections and asynchronously wait for them to finish.
This method is used in combination with `~.TCPServer.stop` to
support clean shutdowns (especially for unittests). Typical
usage would call ``stop()`` first to stop accepting new
connections, then ``await close_all_connections()`` to wait for
existing connections to finish.
This method does not currently close open websocket connections.
Note that this method is a coroutine and must be called with ``await``.
�.�� �self�.�� �close�.�� �close_all_connections�.��$ � HTTPServer.close_all_connections�.�� �_HTTPRequestContext�.�� �HTTP1ServerConnection�.�� �add�.�� �
start_serving�.�� �httputil�.�� � HTTPServerConnectionDelegate�.�� �
start_request�.�� �_CallableAdapter�.�� �
_ProxyAdapter�.�� � request_conn�.��
�remove�.��
�typing�.�� �cast�.�� �
connection�.�� �request�.�� �delegate�.�� �_chunks�.�� �HTTPServerRequest�.�� �RequestStartLine�.�� h(�
start_line��headers���.��
�append�.�� C �.�� �join�.�� �body�.�� � _parse_body�.�� �address�.��
�socket�.��
�family�.�� �address_family�.�� �AF_INET�.�� �AF_INET6�.�K .��
� remote_ip�.�� �0.0.0.0�.�� �iostream�.�� � SSLIOStream�.�� �https�.�� �http�.�� �_orig_remote_ip�.�� �_orig_protocol�.�� �
native_str�.�� �get�.�� �X-Forwarded-For�.�� �split�.�� �,���.��
� X-Real-Ip�.�� �ip�.�� �netutil�.�� � is_valid_ip�.�� �X-Scheme�.�� �X-Forwarded-Proto�.�� J����.�� �strip�.�� �http��https���.��6 �2Rewrite the ``remote_ip`` and ``protocol`` fields.�.��
� <genexpr>�.��: �6_HTTPRequestContext._apply_xheaders.<locals>.<genexpr>�.��� ��Undo changes from `_apply_xheaders`.
Xheaders are per-request so they should not leak to the next
request on the same connection.
�.�� �context�.�� �_apply_xheaders�.�� �headers_received�.�� �
data_received�.��
�finish�.�� �_cleanup�.�� �on_connection_close�.�� �_unapply_xheaders�.��� X� A non-blocking, single-threaded HTTP server.
Typical applications have little direct interaction with the `HTTPServer`
class except to start a server at the beginning of the process
(and even that is often done indirectly via `tornado.web.Application.listen`).
.. versionchanged:: 4.0
The ``HTTPRequest`` class that used to live in this module has been moved
to `tornado.httputil.HTTPServerRequest`. The old name remains as an alias.
�.�� �__doc__�.��@ �</usr/local/lib/python3.8/dist-packages/tornado/httpserver.py�.�� �__file__�.�� �__spec__�.��
�origin�.�� � has_location�.�� �
__cached__�.�� �ssl�.�� �tornado.escape�.�� hD��.�� �tornado.http1connection�.�� h h��.�� �tornado�.�� h ��.�� h>��.�� hL��.�� �tornado.tcpserver�.�� h
��.�� � tornado.util�.�� � Configurable���.�ht.�� �Union�.�� �Any�.�� �Dict�.�� �Callable�.�� �List�.�� �Type�.�� �Tuple�.�� �Optional�.��
� Awaitable�.��
� metaclass�.�� � __prepare__�.�� � __getitem__�.��2 �.%s.__prepare__() must return a mapping, not %s�.�� �__name__�.�� � <metaclass>�.�� �tornado.httpserver�.�� �
__module__�.��� X� A non-blocking, single-threaded HTTP server.
A server is defined by a subclass of `.HTTPServerConnectionDelegate`,
or, for backwards compatibility, a callback that takes an
`.HTTPServerRequest` as an argument. The delegate is usually a
`tornado.web.Application`.
`HTTPServer` supports keep-alive connections by default
(automatically for HTTP/1.1, or for HTTP/1.0 when the client
requests ``Connection: keep-alive``).
If ``xheaders`` is ``True``, we support the
``X-Real-Ip``/``X-Forwarded-For`` and
``X-Scheme``/``X-Forwarded-Proto`` headers, which override the
remote IP and URI scheme/protocol for all requests. These headers
are useful when running Tornado behind a reverse proxy or load
balancer. The ``protocol`` argument can also be set to ``https``
if Tornado is run behind an SSL-decoding proxy that does not set one of
the supported ``xheaders``.
By default, when parsing the ``X-Forwarded-For`` header, Tornado will
select the last (i.e., the closest) address on the list of hosts as the
remote host IP address. To select the next server in the chain, a list of
trusted downstream hosts may be passed as the ``trusted_downstream``
argument. These hosts will be skipped when parsing the ``X-Forwarded-For``
header.
To make this server serve SSL traffic, send the ``ssl_options`` keyword
argument with an `ssl.SSLContext` object. For compatibility with older
versions of Python ``ssl_options`` may also be a dictionary of keyword
arguments for the `ssl.wrap_socket` method.::
ssl_ctx = ssl.create_default_context(ssl.Purpose.CLIENT_AUTH)
ssl_ctx.load_cert_chain(os.path.join(data_dir, "mydomain.crt"),
os.path.join(data_dir, "mydomain.key"))
HTTPServer(application, ssl_options=ssl_ctx)
`HTTPServer` initialization follows one of three patterns (the
initialization methods are defined on `tornado.tcpserver.TCPServer`):
1. `~tornado.tcpserver.TCPServer.listen`: single-process::
async def main():
server = HTTPServer()
server.listen(8888)
await asyncio.Event.wait()
asyncio.run(main())
In many cases, `tornado.web.Application.listen` can be used to avoid
the need to explicitly create the `HTTPServer`.
While this example does not create multiple processes on its own, when
the ``reuse_port=True`` argument is passed to ``listen()`` you can run
the program multiple times to create a multi-process service.
2. `~tornado.tcpserver.TCPServer.add_sockets`: multi-process::
sockets = bind_sockets(8888)
tornado.process.fork_processes(0)
async def post_fork_main():
server = HTTPServer()
server.add_sockets(sockets)
await asyncio.Event().wait()
asyncio.run(post_fork_main())
The ``add_sockets`` interface is more complicated, but it can be used with
`tornado.process.fork_processes` to run a multi-process service with all
worker processes forked from a single parent. ``add_sockets`` can also be
used in single-process servers if you want to create your listening
sockets in some way other than `~tornado.netutil.bind_sockets`.
Note that when using this pattern, nothing that touches the event loop
can be run before ``fork_processes``.
3. `~tornado.tcpserver.TCPServer.bind`/`~tornado.tcpserver.TCPServer.start`:
simple **deprecated** multi-process::
server = HTTPServer()
server.bind(8888)
server.start(0) # Forks multiple sub-processes
IOLoop.current().start()
This pattern is deprecated because it requires interfaces in the
`asyncio` module that have been deprecated since Python 3.10. Support for
creating multiple processes in the ``start`` method will be removed in a
future version of Tornado.
.. versionchanged:: 4.0
Added ``decompress_request``, ``chunk_size``, ``max_header_size``,
``idle_connection_timeout``, ``body_timeout``, ``max_body_size``
arguments. Added support for `.HTTPServerConnectionDelegate`
instances as ``request_callback``.
.. versionchanged:: 4.1
`.HTTPServerConnectionDelegate.start_request` is now called with
two arguments ``(server_conn, request_conn)`` (in accordance with the
documentation) instead of one ``(request_conn)``.
.. versionchanged:: 4.2
`HTTPServer` is now a subclass of `tornado.util.Configurable`.
.. versionchanged:: 4.5
Added the ``trusted_downstream`` argument.
.. versionchanged:: 5.0
The ``io_loop`` argument has been removed.
�.�� � __qualname__�.�� �args�.��
�kwargs�.��
�return�.�� �HTTPServer.__init__�.�� (��NN�NNNNNNNt�.�h
.�� �bool�.�h.�� �str�.�� �
SSLContext�.�� �decompress_request�.�h.�� �int�.�h.�� �idle_connection_timeout�.�� �float�.�h .�h.�h.�� �
initialize�.�� �HTTPServer.initialize�.�� � classmethod�.�� �configurable_base�.�� � HTTPServer.configurable_base�.�� �configurable_default�.��# � HTTPServer.configurable_default�.�� }�h�Ns.��
�stream�.�� �IOStream�.�� �
handle_stream�.�� �HTTPServer.handle_stream�.�� � server_conn�.��
�object�.�� �HTTPConnection�.�� �HTTPMessageDelegate�.�� �HTTPServer.start_request�.�� �on_close�.�� �HTTPServer.on_close�.�� �__orig_bases__�.�� �_CallableAdapter.__init__�.�h..�� �ResponseStartLine�.�h/.�� � HTTPHeaders�.��% �!_CallableAdapter.headers_received�.�� �chunk�.�� �bytes�.��" � _CallableAdapter.data_received�.�� �_CallableAdapter.finish�.��( �$_CallableAdapter.on_connection_close�.�� �builtins��object�����.�� N��.�� � _HTTPRequestContext.__init__�.�� �__str__�.�� �_HTTPRequestContext.__str__�.��' �#_HTTPRequestContext._apply_xheaders�.��) �%_HTTPRequestContext._unapply_xheaders�.�� �_ProxyAdapter.__init__�.��" � _ProxyAdapter.headers_received�.�� �_ProxyAdapter.data_received�.�� �_ProxyAdapter.finish�.��% �!_ProxyAdapter.on_connection_close�.�� �_ProxyAdapter._cleanup�.�� � HTTPRequest�.�� �.0��cand���.�� �<module tornado.httpserver>�.�� � __class__���.�� hh�h���.�� hh*h$��.�� hh h$��.�� (hh�h6hht�.�� h��.�� (hh/hK� proto_header�t�.�� h�conn���.�� �cls���.�� hh���.�� (hh�h6hXh�t�.�� hh.h/��.�� (hh h
hhhh�hhh�h hhht�.�� hh���.�� (hh�h$h*t�.�� � �.