Lines Matching +full:srv +full:- +full:ipv6 +full:- +full:single +full:- +full:target
11 ------------------------------------
19 Application developers should typically use the high-level asyncio functions,
22 of lower-level code, libraries, and frameworks, who need finer control over
27 The following low-level functions can be used to get, set, or create
71 :ref:`setting a custom event loop policy <asyncio-policies>`.
95 .. _asyncio-event-loop:
100 Event loops have **low-level** APIs for the following:
205 An optional keyword-only *context* argument allows specifying a
212 This method is not thread-safe.
216 A thread-safe variant of :meth:`call_soon`. Must be used to
223 See the :ref:`concurrency and multithreading <asyncio-multithreading>`
227 The *context* keyword-only parameter was added. See :pep:`567`
230 .. _asyncio-pass-keywords:
246 .. _asyncio-delayed-calls:
272 An optional keyword-only *context* argument allows specifying a
277 The *context* keyword-only parameter was added. See :pep:`567`
297 The *context* keyword-only parameter was added. See :pep:`567`
328 third-party event loops provide alternative implementations of
338 Third-party event loops can use their own subclass of :class:`Task`
357 must return a :class:`asyncio.Future`-compatible object.
384 :ref:`asyncio protocol <asyncio-protocol>` implementation.
391 #. The connection is established and a :ref:`transport <asyncio-transport>`
395 return a :ref:`protocol <asyncio-protocol>` instance.
402 The created transport is an implementation-dependent bidirectional
413 .. seealso:: :ref:`SSL/TLS security considerations <ssl-security>`
415 * *server_hostname* sets or overrides the hostname that the target
421 risk, allowing for potential man-in-the-middle attacks).
430 be a floating-point number representing the amount of time in seconds
463 Happy Eyeballs Algorithm: Success with Dual-Stack Hosts.
465 IPv6 path and protocol are not working, a dual-stack client
467 IPv4-only client. This is undesirable because it causes the dual-
469 specifies requirements for algorithms that reduce this user-visible
489 The :func:`open_connection` function is a high-level alternative
523 :ref:`protocol <asyncio-protocol>` implementation.
556 See :ref:`UDP echo client protocol <asyncio-udp-echo-client-protocol>` and
557 :ref:`UDP echo server protocol <asyncio-udp-echo-server-protocol>` examples.
597 The *path* parameter can now be a :term:`path-like object`.
619 :ref:`protocol <asyncio-protocol>` implementation.
624 - If *host* is a string, the TCP server is bound to a single network
627 - If *host* is a sequence of strings, the TCP server is bound to all
630 - If *host* is an empty string or ``None``, all interfaces are
632 one for IPv4 and another one for IPv6).
640 :data:`~socket.AF_INET6` to force the socket to use IPv4 or IPv6.
694 The :func:`start_server` function is a higher-level alternative API
735 :ref:`protocol <asyncio-protocol>` implementation.
765 The method uses high-performance :meth:`os.sendfile` if available.
793 Upgrade an existing transport-based connection to TLS.
807 * *server_side* pass ``True`` when a server-side connection is being
810 * *server_hostname*: sets or overrides the host name that the target
840 <asyncio-pass-keywords>` to *callback*.
846 See also :ref:`Platform Support <asyncio-platform-support>` section
853 In general, protocol implementations that use transport-based APIs
867 *sock* must be a non-blocking socket.
881 *sock* must be a non-blocking socket.
896 *sock* must be a non-blocking socket.
909 *sock* must be a non-blocking socket.
935 *sock* must be a non-blocking socket.
949 Send a file using high-performance :mod:`os.sendfile` if possible.
954 *sock* must be a non-blocking :const:`socket.SOCK_STREAM`
973 *sock* must be a non-blocking socket.
1005 :ref:`asyncio protocol <asyncio-protocol>` implementation.
1007 *pipe* is a :term:`file-like object <file object>`.
1014 non-blocking mode.
1021 :ref:`asyncio protocol <asyncio-protocol>` implementation.
1023 *pipe* is :term:`file-like object <file object>`.
1030 non-blocking mode.
1059 <asyncio-pass-keywords>` to *callback*.
1100 # CPU-bound operations will block the event loop:
1132 <asyncio-pass-keywords>` to *func*.
1203 * 'protocol' (optional): :ref:`Protocol <asyncio-protocol>` instance;
1204 * 'transport' (optional): :ref:`Transport <asyncio-transport>` instance;
1223 :envvar:`PYTHONASYNCIODEBUG` is set to a non-empty string, ``False``
1237 The :ref:`debug mode of asyncio <asyncio-debug-mode>`.
1243 Methods described in this subsections are low-level. In regular
1244 async/await code consider using the high-level
1252 :ref:`Subprocess Support on Windows <asyncio-windows-subprocess>` for
1266 :ref:`filesystem encoding <filesystem-encoding>`.
1275 a single argument which is list of strings, *subprocess_exec*
1285 * a file-like object representing a pipe to be connected to the
1297 * a file-like object representing a pipe to be connected to the
1309 * a file-like object representing a pipe to be connected to the
1343 :ref:`filesystem encoding <filesystem-encoding>`,
1420 srv = await loop.create_server(...)
1422 async with srv:
1425 # At this point, srv is closed and no longer accepts new connections.
1455 The *start_serving* keyword-only parameter to
1482 srv = await asyncio.start_server(
1484 await srv.serve_forever()
1510 .. _asyncio-event-loops:
1550 <https://docs.microsoft.com/en-ca/windows/desktop/FileIO/i-o-completion-ports>`_.
1555 Abstract base class for asyncio-compliant event loops.
1557 The :ref:`Event Loop Methods <asyncio-event-loop>` section lists all
1566 to use the low-level event loop APIs, such as :meth:`loop.run_forever`
1568 need to be written this way; consider using the high-level functions
1689 * Another similar :ref:`example <asyncio_example_create_connection-streams>`
1690 using the high-level :func:`asyncio.open_connection` function