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
66 :ref:`setting a custom event loop policy <asyncio-policies>`.
90 .. _asyncio-event-loop:
95 Event loops have **low-level** APIs for the following:
200 An optional keyword-only *context* argument allows specifying a
207 This method is not thread-safe.
211 A thread-safe variant of :meth:`call_soon`. Must be used to
214 See the :ref:`concurrency and multithreading <asyncio-multithreading>`
218 The *context* keyword-only parameter was added. See :pep:`567`
221 .. _asyncio-pass-keywords:
237 .. _asyncio-delayed-calls:
263 An optional keyword-only *context* argument allows specifying a
268 The *context* keyword-only parameter was added. See :pep:`567`
288 The *context* keyword-only parameter was added. See :pep:`567`
319 third-party event loops provide alternative implementations of
329 Third-party event loops can use their own subclass of :class:`Task`
348 must return a :class:`asyncio.Future`-compatible object.
375 :ref:`asyncio protocol <asyncio-protocol>` implementation.
382 #. The connection is established and a :ref:`transport <asyncio-transport>`
386 return a :ref:`protocol <asyncio-protocol>` instance.
393 The created transport is an implementation-dependent bidirectional
404 .. seealso:: :ref:`SSL/TLS security considerations <ssl-security>`
406 * *server_hostname* sets or overrides the hostname that the target
412 risk, allowing for potential man-in-the-middle attacks).
421 be a floating-point number representing the amount of time in seconds
454 Happy Eyeballs Algorithm: Success with Dual-Stack Hosts.
456 IPv6 path and protocol are not working, a dual-stack client
458 IPv4-only client. This is undesirable because it causes the dual-
460 specifies requirements for algorithms that reduce this user-visible
480 The :func:`open_connection` function is a high-level alternative
514 :ref:`protocol <asyncio-protocol>` implementation.
547 See :ref:`UDP echo client protocol <asyncio-udp-echo-client-protocol>` and
548 :ref:`UDP echo server protocol <asyncio-udp-echo-server-protocol>` examples.
588 The *path* parameter can now be a :term:`path-like object`.
610 :ref:`protocol <asyncio-protocol>` implementation.
615 - If *host* is a string, the TCP server is bound to a single network
618 - If *host* is a sequence of strings, the TCP server is bound to all
621 - If *host* is an empty string or ``None``, all interfaces are
623 one for IPv4 and another one for IPv6).
626 :data:`~socket.AF_INET6` to force the socket to use IPv4 or IPv6.
680 The :func:`start_server` function is a higher-level alternative API
721 :ref:`protocol <asyncio-protocol>` implementation.
751 The method uses high-performance :meth:`os.sendfile` if available.
779 Upgrade an existing transport-based connection to TLS.
793 * *server_side* pass ``True`` when a server-side connection is being
796 * *server_hostname*: sets or overrides the host name that the target
826 <asyncio-pass-keywords>` to *callback*.
832 See also :ref:`Platform Support <asyncio-platform-support>` section
839 In general, protocol implementations that use transport-based APIs
853 *sock* must be a non-blocking socket.
867 *sock* must be a non-blocking socket.
882 *sock* must be a non-blocking socket.
895 *sock* must be a non-blocking socket.
921 *sock* must be a non-blocking socket.
935 Send a file using high-performance :mod:`os.sendfile` if possible.
940 *sock* must be a non-blocking :const:`socket.SOCK_STREAM`
959 *sock* must be a non-blocking socket.
991 :ref:`asyncio protocol <asyncio-protocol>` implementation.
993 *pipe* is a :term:`file-like object <file object>`.
1000 non-blocking mode.
1007 :ref:`asyncio protocol <asyncio-protocol>` implementation.
1009 *pipe* is :term:`file-like object <file object>`.
1016 non-blocking mode.
1045 <asyncio-pass-keywords>` to *callback*.
1086 # CPU-bound operations will block the event loop:
1118 <asyncio-pass-keywords>` to *func*.
1188 * 'protocol' (optional): :ref:`Protocol <asyncio-protocol>` instance;
1189 * 'transport' (optional): :ref:`Transport <asyncio-transport>` instance;
1206 :envvar:`PYTHONASYNCIODEBUG` is set to a non-empty string, ``False``
1220 The :ref:`debug mode of asyncio <asyncio-debug-mode>`.
1226 Methods described in this subsections are low-level. In regular
1227 async/await code consider using the high-level
1235 <asyncio-windows-subprocess>` for details.
1248 :ref:`filesystem encoding <filesystem-encoding>`.
1257 a single argument which is list of strings, *subprocess_exec*
1267 * a file-like object representing a pipe to be connected to the
1279 * a file-like object representing a pipe to be connected to the
1291 * a file-like object representing a pipe to be connected to the
1325 :ref:`filesystem encoding <filesystem-encoding>`,
1402 srv = await loop.create_server(...)
1404 async with srv:
1407 # At this point, srv is closed and no longer accepts new connections.
1437 The *start_serving* keyword-only parameter to
1464 srv = await asyncio.start_server(
1466 await srv.serve_forever()
1492 .. _asyncio-event-loops:
1532 <https://docs.microsoft.com/en-ca/windows/desktop/FileIO/i-o-completion-ports>`_.
1537 Abstract base class for asyncio-compliant event loops.
1539 The :ref:`Event Loop Methods <asyncio-event-loop>` section lists all
1548 to use the low-level event loop APIs, such as :meth:`loop.run_forever`
1550 need to be written this way; consider using the high-level functions
1671 * Another similar :ref:`example <asyncio_example_create_connection-streams>`
1672 using the high-level :func:`asyncio.open_connection` function