2018-07-04 09:06:45 +00:00
|
|
|
|
# Copyright (C) 2001-2018, Python Software Foundation
|
2018-07-04 09:08:42 +00:00
|
|
|
|
# For licence information, see README file.
|
2016-10-30 09:46:26 +00:00
|
|
|
|
#
|
|
|
|
|
msgid ""
|
|
|
|
|
msgstr ""
|
2019-12-05 22:15:54 +00:00
|
|
|
|
"Project-Id-Version: Python 3\n"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
"Report-Msgid-Bugs-To: \n"
|
2023-07-21 12:56:20 +00:00
|
|
|
|
"POT-Creation-Date: 2023-07-21 14:55+0200\n"
|
2022-05-21 11:03:47 +00:00
|
|
|
|
"PO-Revision-Date: 2022-05-19 21:40-0400\n"
|
|
|
|
|
"Last-Translator: Nicolas Haller <python@haller.im>\n"
|
2018-07-04 09:14:25 +00:00
|
|
|
|
"Language-Team: FRENCH <traductions@lists.afpy.org>\n"
|
2017-05-23 22:40:56 +00:00
|
|
|
|
"Language: fr\n"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
"MIME-Version: 1.0\n"
|
|
|
|
|
"Content-Type: text/plain; charset=UTF-8\n"
|
|
|
|
|
"Content-Transfer-Encoding: 8bit\n"
|
2022-05-21 11:03:47 +00:00
|
|
|
|
"X-Generator: Poedit 3.0.1\n"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/socketserver.rst:2
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ":mod:`socketserver` --- A framework for network servers"
|
2022-05-21 11:03:47 +00:00
|
|
|
|
msgstr ":mod:`socketserver` — Cadriciel pour serveurs réseaux"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/socketserver.rst:7
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "**Source code:** :source:`Lib/socketserver.py`"
|
2022-05-21 11:03:47 +00:00
|
|
|
|
msgstr "**Code source :** :source:`Lib/socketserver.py`"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2020-07-20 08:45:25 +00:00
|
|
|
|
#: library/socketserver.rst:11
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"The :mod:`socketserver` module simplifies the task of writing network "
|
|
|
|
|
"servers."
|
|
|
|
|
msgstr ""
|
2022-05-21 11:03:47 +00:00
|
|
|
|
"Le module :mod:`socketserver` permet de simplifier le développement de "
|
|
|
|
|
"serveurs réseaux."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-18 15:22:28 +00:00
|
|
|
|
#: includes/wasm-notavail.rst:3
|
2023-01-15 21:42:07 +00:00
|
|
|
|
msgid ":ref:`Availability <availability>`: not Emscripten, not WASI."
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
|
|
#: includes/wasm-notavail.rst:5
|
|
|
|
|
msgid ""
|
|
|
|
|
"This module does not work or is not available on WebAssembly platforms "
|
|
|
|
|
"``wasm32-emscripten`` and ``wasm32-wasi``. See :ref:`wasm-availability` for "
|
|
|
|
|
"more information."
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
|
|
#: library/socketserver.rst:15
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "There are four basic concrete server classes:"
|
2022-05-21 11:03:47 +00:00
|
|
|
|
msgstr "Il existe quatre classes concrètes fondamentales :"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-01-15 21:42:07 +00:00
|
|
|
|
#: library/socketserver.rst:20
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
2021-09-24 08:20:01 +00:00
|
|
|
|
"This uses the internet TCP protocol, which provides for continuous streams "
|
2016-10-30 09:46:26 +00:00
|
|
|
|
"of data between the client and server. If *bind_and_activate* is true, the "
|
|
|
|
|
"constructor automatically attempts to invoke :meth:`~BaseServer.server_bind` "
|
|
|
|
|
"and :meth:`~BaseServer.server_activate`. The other parameters are passed to "
|
|
|
|
|
"the :class:`BaseServer` base class."
|
|
|
|
|
msgstr ""
|
2022-05-21 11:03:47 +00:00
|
|
|
|
"Cette classe permet de créer des flux continus de données entre un client et "
|
|
|
|
|
"un serveur en utilisant le protocole internet TCP. Si *bind_and_activate* "
|
|
|
|
|
"est vrai, le constructeur tente automatiquement d'invoquer :meth:"
|
|
|
|
|
"`~BaseServer.server_bind` et :meth:`~BaseServer.server_activate`. Les autres "
|
|
|
|
|
"paramètres sont passés à la classe de base :class:`BaseServer`."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-01-15 21:42:07 +00:00
|
|
|
|
#: library/socketserver.rst:30
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"This uses datagrams, which are discrete packets of information that may "
|
|
|
|
|
"arrive out of order or be lost while in transit. The parameters are the "
|
|
|
|
|
"same as for :class:`TCPServer`."
|
|
|
|
|
msgstr ""
|
2022-05-21 11:03:47 +00:00
|
|
|
|
"Cette classe utilise des datagrammes, qui sont des paquets d'information "
|
|
|
|
|
"pouvant arriver dans le désordre, voire être perdus, durant le transport. "
|
|
|
|
|
"Les paramètres sont identiques à :class:`TCPServer`."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-01-15 21:42:07 +00:00
|
|
|
|
#: library/socketserver.rst:38
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"These more infrequently used classes are similar to the TCP and UDP classes, "
|
|
|
|
|
"but use Unix domain sockets; they're not available on non-Unix platforms. "
|
|
|
|
|
"The parameters are the same as for :class:`TCPServer`."
|
|
|
|
|
msgstr ""
|
2022-05-21 11:03:47 +00:00
|
|
|
|
"Ces classes, moins fréquemment utilisées, sont similaires aux classes pour "
|
|
|
|
|
"TCP et UDP mais utilisent des connecteurs UNIX ; ces connecteurs ne sont "
|
|
|
|
|
"disponibles que sur les plateformes UNIX. Les paramètres sont identiques à :"
|
|
|
|
|
"class:`TCPServer`."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-01-15 21:42:07 +00:00
|
|
|
|
#: library/socketserver.rst:44
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"These four classes process requests :dfn:`synchronously`; each request must "
|
|
|
|
|
"be completed before the next request can be started. This isn't suitable if "
|
|
|
|
|
"each request takes a long time to complete, because it requires a lot of "
|
|
|
|
|
"computation, or because it returns a lot of data which the client is slow to "
|
|
|
|
|
"process. The solution is to create a separate process or thread to handle "
|
|
|
|
|
"each request; the :class:`ForkingMixIn` and :class:`ThreadingMixIn` mix-in "
|
|
|
|
|
"classes can be used to support asynchronous behaviour."
|
|
|
|
|
msgstr ""
|
2022-05-21 11:03:47 +00:00
|
|
|
|
"Ces quatre classes traitent les requêtes de façon :dfn:`synchrone` : chaque "
|
|
|
|
|
"requête doit être terminée avant de pouvoir traiter la suivante. Cette "
|
|
|
|
|
"méthode n'est pas adaptée si les requêtes prennent beaucoup de temps à être "
|
|
|
|
|
"traitées. Cela peut arriver si les requêtes demandent beaucoup de calcul, ou "
|
|
|
|
|
"si elles renvoient beaucoup de données que le client peine à traiter. Dans "
|
|
|
|
|
"ce cas, la solution est de créer un processus ou un fil d’exécution séparé "
|
|
|
|
|
"pour chaque requête ; les classes de mélange :class:`ForkingMixIn` et :class:"
|
|
|
|
|
"`ThreadingMixIn` peuvent être utilisées pour réaliser ce comportement "
|
|
|
|
|
"asynchrone."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-01-15 21:42:07 +00:00
|
|
|
|
#: library/socketserver.rst:52
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Creating a server requires several steps. First, you must create a request "
|
|
|
|
|
"handler class by subclassing the :class:`BaseRequestHandler` class and "
|
|
|
|
|
"overriding its :meth:`~BaseRequestHandler.handle` method; this method will "
|
|
|
|
|
"process incoming requests. Second, you must instantiate one of the server "
|
|
|
|
|
"classes, passing it the server's address and the request handler class. It "
|
|
|
|
|
"is recommended to use the server in a :keyword:`with` statement. Then call "
|
|
|
|
|
"the :meth:`~BaseServer.handle_request` or :meth:`~BaseServer.serve_forever` "
|
|
|
|
|
"method of the server object to process one or many requests. Finally, call :"
|
|
|
|
|
"meth:`~BaseServer.server_close` to close the socket (unless you used a :"
|
2018-12-24 13:20:55 +00:00
|
|
|
|
"keyword:`!with` statement)."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgstr ""
|
2022-05-21 11:03:47 +00:00
|
|
|
|
"La création d'un serveur requiert plusieurs étapes. Premièrement, vous devez "
|
|
|
|
|
"créer une classe pour gérer les requêtes en héritant de :class:"
|
|
|
|
|
"`BaseRequestHandler` et surcharger sa méthode :meth:`~BaseRequestHandler."
|
|
|
|
|
"handle`, laquelle traitera les requêtes entrantes. Deuxièmement, vous devez "
|
|
|
|
|
"instancier l'une des classes serveurs et lui passer l’adresse du serveur "
|
|
|
|
|
"ainsi que la classe gérant les requêtes. Il est recommandé de faire ceci "
|
|
|
|
|
"dans une instruction :keyword:`with`. Ensuite, appelez la méthode :meth:"
|
|
|
|
|
"`~BaseServer.handle_request` ou :meth:`~BaseServer.serve_forever` de l'objet "
|
|
|
|
|
"serveur afin de traiter une ou plusieurs requêtes. Enfin, appelez la "
|
|
|
|
|
"méthode :meth:`~BaseServer.server_close` pour fermer le connecteur (à moins "
|
|
|
|
|
"que vous n'ayez utilisé une instruction :keyword:`!with`)."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-01-15 21:42:07 +00:00
|
|
|
|
#: library/socketserver.rst:64
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"When inheriting from :class:`ThreadingMixIn` for threaded connection "
|
|
|
|
|
"behavior, you should explicitly declare how you want your threads to behave "
|
|
|
|
|
"on an abrupt shutdown. The :class:`ThreadingMixIn` class defines an "
|
|
|
|
|
"attribute *daemon_threads*, which indicates whether or not the server should "
|
|
|
|
|
"wait for thread termination. You should set the flag explicitly if you "
|
|
|
|
|
"would like threads to behave autonomously; the default is :const:`False`, "
|
|
|
|
|
"meaning that Python will not exit until all threads created by :class:"
|
|
|
|
|
"`ThreadingMixIn` have exited."
|
|
|
|
|
msgstr ""
|
2022-05-21 11:03:47 +00:00
|
|
|
|
"Lorsque vous héritez de :class:`ThreadingMixIn` pour déléguer les connexions "
|
|
|
|
|
"à différent fils d’exécution, vous devez déclarer explicitement comment les "
|
|
|
|
|
"fils d’exécution doivent se comporter en cas d'arrêt abrupt. La classe :"
|
|
|
|
|
"class:`ThreadingMixIn` définit un attribut *daemon_threads*, indiquant si le "
|
|
|
|
|
"serveur doit attendre la fin des fils d’exécution ou non. Vous pouvez "
|
|
|
|
|
"utiliser cet attribut si vous souhaitez que les fils d’exécution soient "
|
|
|
|
|
"autonomes. La valeur par défaut est :const:`False`, indiquant que Python ne "
|
|
|
|
|
"doit pas quitter avant que tous les fils d'exécution créés par :class:"
|
|
|
|
|
"`ThreadingMixIn` ne soient terminés."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-01-15 21:42:07 +00:00
|
|
|
|
#: library/socketserver.rst:73
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Server classes have the same external methods and attributes, no matter what "
|
|
|
|
|
"network protocol they use."
|
|
|
|
|
msgstr ""
|
2022-05-21 11:03:47 +00:00
|
|
|
|
"Toutes les classes de serveurs exposent les mêmes méthodes et attributs, peu "
|
|
|
|
|
"importe le protocole réseau utilisé."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-01-15 21:42:07 +00:00
|
|
|
|
#: library/socketserver.rst:78
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Server Creation Notes"
|
2022-05-21 11:03:47 +00:00
|
|
|
|
msgstr "Notes sur la création de serveurs"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-01-15 21:42:07 +00:00
|
|
|
|
#: library/socketserver.rst:80
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"There are five classes in an inheritance diagram, four of which represent "
|
|
|
|
|
"synchronous servers of four types::"
|
|
|
|
|
msgstr ""
|
2022-05-21 11:03:47 +00:00
|
|
|
|
"Il y a cinq classes dans la hiérarchie. Quatre d'entre elles représentent "
|
|
|
|
|
"des serveurs synchrones de quatre types différents ::"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-01-15 21:42:07 +00:00
|
|
|
|
#: library/socketserver.rst:97
|
|
|
|
|
#, fuzzy
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Note that :class:`UnixDatagramServer` derives from :class:`UDPServer`, not "
|
|
|
|
|
"from :class:`UnixStreamServer` --- the only difference between an IP and a "
|
2023-01-15 21:42:07 +00:00
|
|
|
|
"Unix server is the address family."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgstr ""
|
2022-05-21 11:03:47 +00:00
|
|
|
|
"Notez que la classe :class:`UnixDatagramServer` hérite de :class:`UDPServer` "
|
|
|
|
|
"et pas de :class:`UnixStreamServer` — la seule différente entre un serveur à "
|
|
|
|
|
"flux de données IP et Unix est la famille d’adresse, qui est simplement "
|
|
|
|
|
"répétée dans les deux classes serveur Unix."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-01-15 21:42:07 +00:00
|
|
|
|
#: library/socketserver.rst:105
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Forking and threading versions of each type of server can be created using "
|
|
|
|
|
"these mix-in classes. For instance, :class:`ThreadingUDPServer` is created "
|
|
|
|
|
"as follows::"
|
|
|
|
|
msgstr ""
|
2022-05-21 11:03:47 +00:00
|
|
|
|
"Des versions utilisant des fils d’exécution ou des processus peuvent être "
|
|
|
|
|
"créées pour chaque type de serveur, en utilisant ces classes de mélange. Par "
|
|
|
|
|
"exemple, :class:`ThreadingUDPServer` est créé comme suit ::"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-01-15 21:42:07 +00:00
|
|
|
|
#: library/socketserver.rst:112
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"The mix-in class comes first, since it overrides a method defined in :class:"
|
|
|
|
|
"`UDPServer`. Setting the various attributes also changes the behavior of "
|
|
|
|
|
"the underlying server mechanism."
|
|
|
|
|
msgstr ""
|
2022-05-21 11:03:47 +00:00
|
|
|
|
"La classe de mélange est en premier car elle surcharge une méthode définie "
|
|
|
|
|
"dans :class:`UDPServer`. Configurer les différents attributs changera "
|
|
|
|
|
"également le comportement du serveur."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-01-15 21:42:07 +00:00
|
|
|
|
#: library/socketserver.rst:116
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
":class:`ForkingMixIn` and the Forking classes mentioned below are only "
|
|
|
|
|
"available on POSIX platforms that support :func:`~os.fork`."
|
|
|
|
|
msgstr ""
|
2022-05-21 11:03:47 +00:00
|
|
|
|
"La classe :class:`ForkingMixIn` et les classes créant des processus "
|
|
|
|
|
"mentionnées ci-dessous sont uniquement disponibles sur les plateformes POSIX "
|
|
|
|
|
"prenant en charge :func:`~os.fork`."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-01-15 21:42:07 +00:00
|
|
|
|
#: library/socketserver.rst:119
|
2018-06-28 13:32:56 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
":meth:`socketserver.ForkingMixIn.server_close` waits until all child "
|
|
|
|
|
"processes complete, except if :attr:`socketserver.ForkingMixIn."
|
|
|
|
|
"block_on_close` attribute is false."
|
|
|
|
|
msgstr ""
|
2022-05-21 11:03:47 +00:00
|
|
|
|
"La méthode :meth:`socketserver.ForkingMixIn.server_close` attend jusqu'à ce "
|
|
|
|
|
"que tous les processus enfants soient terminés, sauf si l'attribut :attr:"
|
|
|
|
|
"`socketserver.ForkingMixIn.block_on_close` est faux."
|
2018-06-28 13:32:56 +00:00
|
|
|
|
|
2023-01-15 21:42:07 +00:00
|
|
|
|
#: library/socketserver.rst:123
|
2018-06-28 13:32:56 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
":meth:`socketserver.ThreadingMixIn.server_close` waits until all non-daemon "
|
|
|
|
|
"threads complete, except if :attr:`socketserver.ThreadingMixIn."
|
|
|
|
|
"block_on_close` attribute is false. Use daemonic threads by setting :data:"
|
|
|
|
|
"`ThreadingMixIn.daemon_threads` to ``True`` to not wait until threads "
|
|
|
|
|
"complete."
|
|
|
|
|
msgstr ""
|
2022-05-21 11:03:47 +00:00
|
|
|
|
"La méthode :meth:`socketserver.ThreadingMixIn.server_close` attend que tous "
|
|
|
|
|
"les fils d'exécution non-*daemon* soit terminés, sauf si l'attribut :attr:"
|
|
|
|
|
"`socketserver.ThreadingMixIn.block_on_close` est faux. Utilisez des fils "
|
|
|
|
|
"d'exécution *daemon* en réglant :data:`ThreadingMixIn.daemon_threads` à "
|
|
|
|
|
"``True`` afin de ne pas attendre que les fils d’exécution soit terminés."
|
2018-06-28 13:32:56 +00:00
|
|
|
|
|
2023-01-15 21:42:07 +00:00
|
|
|
|
#: library/socketserver.rst:132
|
2018-06-28 13:32:56 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
":meth:`socketserver.ForkingMixIn.server_close` and :meth:`socketserver."
|
|
|
|
|
"ThreadingMixIn.server_close` now waits until all child processes and non-"
|
|
|
|
|
"daemonic threads complete. Add a new :attr:`socketserver.ForkingMixIn."
|
|
|
|
|
"block_on_close` class attribute to opt-in for the pre-3.7 behaviour."
|
|
|
|
|
msgstr ""
|
2022-05-21 11:03:47 +00:00
|
|
|
|
"Désormais, :meth:`socketserver.ForkingMixIn.server_close` et :meth:"
|
|
|
|
|
"`socketserver.ThreadingMixIn.server_close` attendent que tous les processus "
|
|
|
|
|
"enfants et les fils d’exécution non-*daemon* soit terminés. Ajout de :attr:"
|
|
|
|
|
"`socketserver.ForkingMixIn.block_on_close`, un nouvel attribut de classe "
|
|
|
|
|
"permettant de conserver le comportement pré-3.7."
|
2018-06-28 13:32:56 +00:00
|
|
|
|
|
2023-07-21 12:56:20 +00:00
|
|
|
|
#: library/socketserver.rst:144
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "These classes are pre-defined using the mix-in classes."
|
2022-05-21 11:03:47 +00:00
|
|
|
|
msgstr "Ces classes sont prédéfinies en utilisant les classes de mélange."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-21 12:56:20 +00:00
|
|
|
|
#: library/socketserver.rst:147
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"To implement a service, you must derive a class from :class:"
|
|
|
|
|
"`BaseRequestHandler` and redefine its :meth:`~BaseRequestHandler.handle` "
|
|
|
|
|
"method. You can then run various versions of the service by combining one of "
|
|
|
|
|
"the server classes with your request handler class. The request handler "
|
|
|
|
|
"class must be different for datagram or stream services. This can be hidden "
|
|
|
|
|
"by using the handler subclasses :class:`StreamRequestHandler` or :class:"
|
|
|
|
|
"`DatagramRequestHandler`."
|
|
|
|
|
msgstr ""
|
2022-05-21 11:03:47 +00:00
|
|
|
|
"Pour implémenter un service, vous devez créer une classe héritant de :class:"
|
|
|
|
|
"`BaseRequestHandler` et redéfinir sa méthode :meth:`~BaseRequestHandler."
|
|
|
|
|
"handle`. Ensuite, vous pourrez créer différentes versions de votre service "
|
|
|
|
|
"en combinant les classes serveurs avec votre classe de gestion des requêtes. "
|
|
|
|
|
"Cette classe de gestion des requêtes doit être différente pour les services "
|
|
|
|
|
"utilisant des datagrammes ou des flux de données. Cette contrainte peut être "
|
|
|
|
|
"dissimulée en utilisant les classes de gestion dérivées :class:"
|
|
|
|
|
"`StreamRequestHandler` ou :class:`DatagramRequestHandler`."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-21 12:56:20 +00:00
|
|
|
|
#: library/socketserver.rst:155
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Of course, you still have to use your head! For instance, it makes no sense "
|
|
|
|
|
"to use a forking server if the service contains state in memory that can be "
|
|
|
|
|
"modified by different requests, since the modifications in the child process "
|
|
|
|
|
"would never reach the initial state kept in the parent process and passed to "
|
|
|
|
|
"each child. In this case, you can use a threading server, but you will "
|
|
|
|
|
"probably have to use locks to protect the integrity of the shared data."
|
|
|
|
|
msgstr ""
|
2022-05-21 11:03:47 +00:00
|
|
|
|
"Bien entendu, vous devrez toujours utiliser votre tête ! Par exemple, "
|
|
|
|
|
"utiliser un serveur utilisant des processus clonés (*forking*) n'aurait "
|
|
|
|
|
"aucun sens si le serveur garde en mémoire des états pouvant être modifiés "
|
|
|
|
|
"par les requêtes reçues. En effet, un processus enfant traitant une requête "
|
|
|
|
|
"n'aurait alors aucun moyen de propager le nouvel état à son parent. Dans ce "
|
|
|
|
|
"cas, vous devez utiliser un serveur utilisant des fils d'exécution, mais "
|
|
|
|
|
"cela demande probablement d'utiliser des verrous pour protéger l’intégrité "
|
|
|
|
|
"des données partagées."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-21 12:56:20 +00:00
|
|
|
|
#: library/socketserver.rst:162
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"On the other hand, if you are building an HTTP server where all data is "
|
|
|
|
|
"stored externally (for instance, in the file system), a synchronous class "
|
|
|
|
|
"will essentially render the service \"deaf\" while one request is being "
|
|
|
|
|
"handled -- which may be for a very long time if a client is slow to receive "
|
|
|
|
|
"all the data it has requested. Here a threading or forking server is "
|
|
|
|
|
"appropriate."
|
|
|
|
|
msgstr ""
|
2022-05-21 11:03:47 +00:00
|
|
|
|
"D'un autre côté, si vous développez un serveur HTTP qui a toutes ses données "
|
|
|
|
|
"stockées hors de la mémoire (sur un système de fichiers par exemple), une "
|
|
|
|
|
"classe synchrone rendrait le service sourd à toute nouvelle requête aussi "
|
|
|
|
|
"longtemps qu'une précédente soit en cours de traitement. Cette situation "
|
|
|
|
|
"pourrait perdurer pendant un long moment si le client prend du temps à "
|
|
|
|
|
"recevoir toutes les données demandées. Dans ce cas, un serveur utilisant des "
|
|
|
|
|
"processus ou des fils d'exécutions est approprié."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-21 12:56:20 +00:00
|
|
|
|
#: library/socketserver.rst:168
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"In some cases, it may be appropriate to process part of a request "
|
|
|
|
|
"synchronously, but to finish processing in a forked child depending on the "
|
|
|
|
|
"request data. This can be implemented by using a synchronous server and "
|
|
|
|
|
"doing an explicit fork in the request handler class :meth:"
|
|
|
|
|
"`~BaseRequestHandler.handle` method."
|
|
|
|
|
msgstr ""
|
2022-05-21 11:03:47 +00:00
|
|
|
|
"Dans certains cas, il peut être judicieux de commencer à traiter une requête "
|
|
|
|
|
"de façon synchrone mais de pouvoir déléguer le reste du traitement à un "
|
|
|
|
|
"processus enfant si besoin. Ce comportement peut être implémenté en "
|
|
|
|
|
"utilisant un serveur synchrone et en laissant à la méthode :meth:"
|
|
|
|
|
"`~BaseRequestHandler.handle`, de la classe gérant les requêtes, le soin de "
|
|
|
|
|
"créer le processus enfant explicitement."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-21 12:56:20 +00:00
|
|
|
|
#: library/socketserver.rst:173
|
2023-07-18 15:22:28 +00:00
|
|
|
|
#, fuzzy
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Another approach to handling multiple simultaneous requests in an "
|
|
|
|
|
"environment that supports neither threads nor :func:`~os.fork` (or where "
|
|
|
|
|
"these are too expensive or inappropriate for the service) is to maintain an "
|
|
|
|
|
"explicit table of partially finished requests and to use :mod:`selectors` to "
|
|
|
|
|
"decide which request to work on next (or whether to handle a new incoming "
|
|
|
|
|
"request). This is particularly important for stream services where each "
|
|
|
|
|
"client can potentially be connected for a long time (if threads or "
|
2023-07-21 12:56:20 +00:00
|
|
|
|
"subprocesses cannot be used). See :mod:`asyncore` for another way to manage "
|
|
|
|
|
"this."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgstr ""
|
2022-05-21 11:03:47 +00:00
|
|
|
|
"Une autre méthode pour gérer plusieurs requêtes simultanément dans un "
|
|
|
|
|
"environnement ne prenant en charge ni les fils d’exécution ni :func:`~os."
|
|
|
|
|
"fork` (ou si cela est trop coûteux ou inapproprié compte tenu de la nature "
|
|
|
|
|
"du service) est de maintenir une table des requêtes en cours de traitement "
|
|
|
|
|
"et d’utiliser :mod:`selectors` pour décider sur quelle requête travailler "
|
|
|
|
|
"(et quand accepter une nouvelle requête). Cela est particulièrement "
|
|
|
|
|
"important pour les services utilisant des flux de données où chaque client "
|
|
|
|
|
"peut rester connecté pour longtemps. Pour une autre façon de gérer cela, "
|
|
|
|
|
"voir :mod:`asyncore`."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-21 12:56:20 +00:00
|
|
|
|
#: library/socketserver.rst:187
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Server Objects"
|
2022-05-21 11:03:47 +00:00
|
|
|
|
msgstr "Objets serveur"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-21 12:56:20 +00:00
|
|
|
|
#: library/socketserver.rst:191
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"This is the superclass of all Server objects in the module. It defines the "
|
|
|
|
|
"interface, given below, but does not implement most of the methods, which is "
|
|
|
|
|
"done in subclasses. The two parameters are stored in the respective :attr:"
|
|
|
|
|
"`server_address` and :attr:`RequestHandlerClass` attributes."
|
|
|
|
|
msgstr ""
|
2022-05-21 11:03:47 +00:00
|
|
|
|
"Il s'agit de la classe parente de tous les objets serveur du module. Elle "
|
|
|
|
|
"déclare l'interface, définie ci-dessous, mais laisse aux classes filles le "
|
|
|
|
|
"soin d'implémenter la plupart des méthodes. Les deux paramètres sont stockés "
|
|
|
|
|
"respectivement dans les attributs :attr:`server_address` et :attr:"
|
|
|
|
|
"`RequestHandlerClass`."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-21 12:56:20 +00:00
|
|
|
|
#: library/socketserver.rst:199
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Return an integer file descriptor for the socket on which the server is "
|
|
|
|
|
"listening. This function is most commonly passed to :mod:`selectors`, to "
|
|
|
|
|
"allow monitoring multiple servers in the same process."
|
|
|
|
|
msgstr ""
|
2022-05-21 11:03:47 +00:00
|
|
|
|
"Renvoie un entier représentant le descripteur de fichier pour le connecteur "
|
|
|
|
|
"que le serveur écoute. Cette fonction est, la plupart du temps, passée à :"
|
|
|
|
|
"mod:`selectors` afin de pouvoir surveiller plusieurs serveurs dans le même "
|
|
|
|
|
"processus."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-21 12:56:20 +00:00
|
|
|
|
#: library/socketserver.rst:206
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Process a single request. This function calls the following methods in "
|
|
|
|
|
"order: :meth:`get_request`, :meth:`verify_request`, and :meth:"
|
|
|
|
|
"`process_request`. If the user-provided :meth:`~BaseRequestHandler.handle` "
|
|
|
|
|
"method of the handler class raises an exception, the server's :meth:"
|
|
|
|
|
"`handle_error` method will be called. If no request is received within :"
|
|
|
|
|
"attr:`timeout` seconds, :meth:`handle_timeout` will be called and :meth:"
|
|
|
|
|
"`handle_request` will return."
|
|
|
|
|
msgstr ""
|
2022-05-21 11:03:47 +00:00
|
|
|
|
"Traite une seule requête. Cette fonction appelle, dans l'ordre, les "
|
|
|
|
|
"méthodes :meth:`get_request`, :meth:`verify_request` et :meth:"
|
|
|
|
|
"`process_request`. Si la méthode :meth:`~BaseRequestHandler.handle` de la "
|
|
|
|
|
"classe de gestion des requêtes lève une exception, alors la méthode :meth:"
|
|
|
|
|
"`handle_error` du serveur est appelée. Si aucune requête n'est reçue avant "
|
|
|
|
|
"« :attr:`timeout` » secondes, :meth:`handle_timeout` est appelée et :meth:"
|
|
|
|
|
"`handle_request` rend la main."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-21 12:56:20 +00:00
|
|
|
|
#: library/socketserver.rst:218
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Handle requests until an explicit :meth:`shutdown` request. Poll for "
|
|
|
|
|
"shutdown every *poll_interval* seconds. Ignores the :attr:`timeout` "
|
|
|
|
|
"attribute. It also calls :meth:`service_actions`, which may be used by a "
|
|
|
|
|
"subclass or mixin to provide actions specific to a given service. For "
|
|
|
|
|
"example, the :class:`ForkingMixIn` class uses :meth:`service_actions` to "
|
|
|
|
|
"clean up zombie child processes."
|
|
|
|
|
msgstr ""
|
2022-05-21 11:03:47 +00:00
|
|
|
|
"Gère les requêtes indéfiniment jusqu'à ce que :meth:`shutdown` soit appelée. "
|
|
|
|
|
"Vérifie si une demande d’arrêt (*shutdown*) a été émise toutes les "
|
|
|
|
|
"*poll_interval* secondes. Ignore l'attribut :attr:`timeout`. Appelle "
|
|
|
|
|
"également :meth:`service_actions`, qui peut être utilisée par une classe "
|
|
|
|
|
"enfant ou une classe de mélange afin d'implémenter une action spécifique "
|
|
|
|
|
"pour un service donné. Par exemple, la classe :class:`ForkingMixIn` utilise :"
|
|
|
|
|
"meth:`service_actions` pour supprimer les processus enfants zombies."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-21 12:56:20 +00:00
|
|
|
|
#: library/socketserver.rst:226
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Added ``service_actions`` call to the ``serve_forever`` method."
|
2022-05-21 11:03:47 +00:00
|
|
|
|
msgstr "La méthode ``serve_forever`` appelle dorénavant ``service_actions``."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-21 12:56:20 +00:00
|
|
|
|
#: library/socketserver.rst:232
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"This is called in the :meth:`serve_forever` loop. This method can be "
|
|
|
|
|
"overridden by subclasses or mixin classes to perform actions specific to a "
|
|
|
|
|
"given service, such as cleanup actions."
|
|
|
|
|
msgstr ""
|
2022-05-21 11:03:47 +00:00
|
|
|
|
"Cette méthode est appelée dans la boucle de :meth:`serve_forever`. Cette "
|
|
|
|
|
"méthode peut être surchargée par une classe fille ou une classe de mélange "
|
|
|
|
|
"afin d'effectuer une action spécifique à un service donné, comme une action "
|
|
|
|
|
"de nettoyage."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-21 12:56:20 +00:00
|
|
|
|
#: library/socketserver.rst:240
|
2020-05-24 14:31:50 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Tell the :meth:`serve_forever` loop to stop and wait until it does. :meth:"
|
|
|
|
|
"`shutdown` must be called while :meth:`serve_forever` is running in a "
|
|
|
|
|
"different thread otherwise it will deadlock."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgstr ""
|
2022-05-21 11:03:47 +00:00
|
|
|
|
"Demande l'arrêt de la boucle de :meth:`serve_forever` et attend jusqu'à ce "
|
|
|
|
|
"que ce soit fait. :meth:`shutdown` doit être appelée dans un fil d’exécution "
|
|
|
|
|
"différent de :meth:`serve_forever` sous peine d'interblocage."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-21 12:56:20 +00:00
|
|
|
|
#: library/socketserver.rst:247
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Clean up the server. May be overridden."
|
2022-05-21 11:03:47 +00:00
|
|
|
|
msgstr "Nettoie le serveur. Peut être surchargée."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-21 12:56:20 +00:00
|
|
|
|
#: library/socketserver.rst:252
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"The family of protocols to which the server's socket belongs. Common "
|
|
|
|
|
"examples are :const:`socket.AF_INET` and :const:`socket.AF_UNIX`."
|
|
|
|
|
msgstr ""
|
2022-05-21 11:03:47 +00:00
|
|
|
|
"La famille de protocoles auquel le connecteur appartient. Les exemples les "
|
|
|
|
|
"plus communs sont :const:`socket.AF_INET` et :const:`socket.AF_UNIX`."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-21 12:56:20 +00:00
|
|
|
|
#: library/socketserver.rst:258
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"The user-provided request handler class; an instance of this class is "
|
|
|
|
|
"created for each request."
|
|
|
|
|
msgstr ""
|
2022-05-21 11:03:47 +00:00
|
|
|
|
"La classe de gestion des requêtes, fournie par l'utilisateur. Une instance "
|
|
|
|
|
"de cette classe est créée pour chaque requête."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-21 12:56:20 +00:00
|
|
|
|
#: library/socketserver.rst:264
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"The address on which the server is listening. The format of addresses "
|
|
|
|
|
"varies depending on the protocol family; see the documentation for the :mod:"
|
2021-09-24 08:20:01 +00:00
|
|
|
|
"`socket` module for details. For internet protocols, this is a tuple "
|
2016-10-30 09:46:26 +00:00
|
|
|
|
"containing a string giving the address, and an integer port number: "
|
|
|
|
|
"``('127.0.0.1', 80)``, for example."
|
|
|
|
|
msgstr ""
|
2022-05-21 11:03:47 +00:00
|
|
|
|
"Renvoie l’adresse sur laquelle le serveur écoute. Le format de l’adresse "
|
|
|
|
|
"dépend de la famille de protocoles utilisée ; pour plus de détails, voir la "
|
|
|
|
|
"documentation du module :mod:`socket`. Pour les protocoles Internet, cette "
|
|
|
|
|
"valeur est une paire formée d'une chaine de caractère pour l’adresse et d'un "
|
|
|
|
|
"entier pour le port. Exemple : ``('127.0.0.1', 80)``."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-21 12:56:20 +00:00
|
|
|
|
#: library/socketserver.rst:273
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"The socket object on which the server will listen for incoming requests."
|
|
|
|
|
msgstr ""
|
2022-05-21 11:03:47 +00:00
|
|
|
|
"L'objet connecteur utilisé par le serveur pour écouter les nouvelles "
|
|
|
|
|
"requêtes."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-21 12:56:20 +00:00
|
|
|
|
#: library/socketserver.rst:276
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "The server classes support the following class variables:"
|
|
|
|
|
msgstr ""
|
2022-05-21 11:03:47 +00:00
|
|
|
|
"Les classes serveurs prennent en charge les variables de classe suivantes :"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-21 12:56:20 +00:00
|
|
|
|
#: library/socketserver.rst:282
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Whether the server will allow the reuse of an address. This defaults to :"
|
|
|
|
|
"const:`False`, and can be set in subclasses to change the policy."
|
|
|
|
|
msgstr ""
|
2022-05-21 11:03:47 +00:00
|
|
|
|
"Indique si le serveur autorise la réutilisation d'une adresse. La valeur par "
|
|
|
|
|
"défaut est :const:`False` mais cela peut être changé dans les classes "
|
|
|
|
|
"enfants."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-21 12:56:20 +00:00
|
|
|
|
#: library/socketserver.rst:288
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"The size of the request queue. If it takes a long time to process a single "
|
|
|
|
|
"request, any requests that arrive while the server is busy are placed into a "
|
|
|
|
|
"queue, up to :attr:`request_queue_size` requests. Once the queue is full, "
|
|
|
|
|
"further requests from clients will get a \"Connection denied\" error. The "
|
|
|
|
|
"default value is usually 5, but this can be overridden by subclasses."
|
|
|
|
|
msgstr ""
|
2022-05-21 11:03:47 +00:00
|
|
|
|
"La taille de la file des requêtes. Lorsque traiter une requête prend du "
|
|
|
|
|
"temps, toute nouvelle requête arrivant pendant que le serveur est occupé est "
|
|
|
|
|
"placé dans une file jusqu'à atteindre « :attr:`request_queue_size` » "
|
|
|
|
|
"requêtes. Si la queue est pleine, les nouvelles requêtes clientes se voient "
|
|
|
|
|
"renvoyer une erreur *Connection denied*. La valeur par défaut est "
|
|
|
|
|
"habituellement 5 mais peut être changée par les classes filles."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-21 12:56:20 +00:00
|
|
|
|
#: library/socketserver.rst:297
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"The type of socket used by the server; :const:`socket.SOCK_STREAM` and :"
|
|
|
|
|
"const:`socket.SOCK_DGRAM` are two common values."
|
|
|
|
|
msgstr ""
|
2022-05-21 11:03:47 +00:00
|
|
|
|
"Le type de connecteur utilisé par le serveur ; :const:`socket.SOCK_STREAM` "
|
|
|
|
|
"et :const:`socket.SOCK_DGRAM` sont deux valeurs usuelles."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-21 12:56:20 +00:00
|
|
|
|
#: library/socketserver.rst:303
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Timeout duration, measured in seconds, or :const:`None` if no timeout is "
|
|
|
|
|
"desired. If :meth:`handle_request` receives no incoming requests within the "
|
|
|
|
|
"timeout period, the :meth:`handle_timeout` method is called."
|
|
|
|
|
msgstr ""
|
2022-05-21 11:03:47 +00:00
|
|
|
|
"Délai d'attente en secondes, ou :const:`None` si aucune limite n'est "
|
|
|
|
|
"demandée. Si :meth:`handle_request` ne reçoit aucune requête entrante "
|
|
|
|
|
"pendant le délai d'attente, la méthode :meth:`handle_timeout` est appelée."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-21 12:56:20 +00:00
|
|
|
|
#: library/socketserver.rst:308
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"There are various server methods that can be overridden by subclasses of "
|
|
|
|
|
"base server classes like :class:`TCPServer`; these methods aren't useful to "
|
|
|
|
|
"external users of the server object."
|
|
|
|
|
msgstr ""
|
2022-05-21 11:03:47 +00:00
|
|
|
|
"Il existe plusieurs méthodes serveur pouvant être surchargées par des "
|
|
|
|
|
"classes dérivant de classes de base comme :class:`TCPServer` ; ces méthodes "
|
|
|
|
|
"ne sont pas utiles aux utilisateurs externes de l'objet serveur."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-21 12:56:20 +00:00
|
|
|
|
#: library/socketserver.rst:317
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Actually processes the request by instantiating :attr:`RequestHandlerClass` "
|
|
|
|
|
"and calling its :meth:`~BaseRequestHandler.handle` method."
|
|
|
|
|
msgstr ""
|
2022-05-21 11:03:47 +00:00
|
|
|
|
"Méthode en charge de traiter la requête en instanciant :attr:"
|
|
|
|
|
"`RequestHandlerClass` et en appelant sa méthode :meth:`~BaseRequestHandler."
|
|
|
|
|
"handle`."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-21 12:56:20 +00:00
|
|
|
|
#: library/socketserver.rst:323
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Must accept a request from the socket, and return a 2-tuple containing the "
|
|
|
|
|
"*new* socket object to be used to communicate with the client, and the "
|
|
|
|
|
"client's address."
|
|
|
|
|
msgstr ""
|
2022-05-21 11:03:47 +00:00
|
|
|
|
"Accepte obligatoirement une requête depuis le connecteur et renvoie une "
|
|
|
|
|
"paire contenant le *nouvel* objet connecteur utilisé pour communiquer avec "
|
|
|
|
|
"le client et l'adresse du client."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-21 12:56:20 +00:00
|
|
|
|
#: library/socketserver.rst:330
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"This function is called if the :meth:`~BaseRequestHandler.handle` method of "
|
|
|
|
|
"a :attr:`RequestHandlerClass` instance raises an exception. The default "
|
|
|
|
|
"action is to print the traceback to standard error and continue handling "
|
|
|
|
|
"further requests."
|
|
|
|
|
msgstr ""
|
2022-05-21 11:03:47 +00:00
|
|
|
|
"Cette fonction est appelée si la méthode :meth:`~BaseRequestHandler.handle` "
|
|
|
|
|
"de l'objet :attr:`RequestHandlerClass` lève une exception. Par défaut, la "
|
|
|
|
|
"méthode imprime la trace d'appels sur la sortie d'erreur standard et "
|
|
|
|
|
"continue de traiter les requêtes suivantes."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-21 12:56:20 +00:00
|
|
|
|
#: library/socketserver.rst:335
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Now only called for exceptions derived from the :exc:`Exception` class."
|
|
|
|
|
msgstr ""
|
2022-05-21 11:03:47 +00:00
|
|
|
|
"N'est maintenant appelée que sur les exceptions dérivant de la classe :exc:"
|
|
|
|
|
"`Exception`."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-21 12:56:20 +00:00
|
|
|
|
#: library/socketserver.rst:342
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"This function is called when the :attr:`timeout` attribute has been set to a "
|
|
|
|
|
"value other than :const:`None` and the timeout period has passed with no "
|
|
|
|
|
"requests being received. The default action for forking servers is to "
|
|
|
|
|
"collect the status of any child processes that have exited, while in "
|
|
|
|
|
"threading servers this method does nothing."
|
|
|
|
|
msgstr ""
|
2022-05-21 11:03:47 +00:00
|
|
|
|
"Cette fonction est appelée lorsque l'attribut :attr:`timeout` est réglé à "
|
|
|
|
|
"autre chose que :const:`None` et que le délai d'attente expire sans "
|
|
|
|
|
"qu'aucune requête ne soit reçue. Par défaut, cette fonction récupère le "
|
|
|
|
|
"statut de tous les processus enfants ayant terminé pour les serveurs "
|
|
|
|
|
"utilisant des processus ou ne fait rien pour le cas des serveurs utilisant "
|
|
|
|
|
"des fils d’exécution."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-21 12:56:20 +00:00
|
|
|
|
#: library/socketserver.rst:351
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Calls :meth:`finish_request` to create an instance of the :attr:"
|
|
|
|
|
"`RequestHandlerClass`. If desired, this function can create a new process "
|
|
|
|
|
"or thread to handle the request; the :class:`ForkingMixIn` and :class:"
|
|
|
|
|
"`ThreadingMixIn` classes do this."
|
|
|
|
|
msgstr ""
|
2022-05-21 11:03:47 +00:00
|
|
|
|
"Appelle :meth:`finish_request` pour instancier :attr:`RequestHandlerClass`. "
|
|
|
|
|
"Si désiré, cette fonction peut créer des processus fils ou des fils "
|
|
|
|
|
"d’exécution pour traiter les requêtes ; les classes de mélange :class:"
|
|
|
|
|
"`ForkingMixIn` et :class:`ThreadingMixIn` implémentent cela."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-21 12:56:20 +00:00
|
|
|
|
#: library/socketserver.rst:363
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Called by the server's constructor to activate the server. The default "
|
|
|
|
|
"behavior for a TCP server just invokes :meth:`~socket.socket.listen` on the "
|
|
|
|
|
"server's socket. May be overridden."
|
|
|
|
|
msgstr ""
|
2022-05-21 11:03:47 +00:00
|
|
|
|
"Appelée par le constructeur du serveur afin de l'activer. Le comportement "
|
|
|
|
|
"par défaut pour un serveur TCP est de seulement invoquer :meth:`~socket."
|
|
|
|
|
"socket.listen` sur le connecteur du serveur. Peut être surchargée."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-21 12:56:20 +00:00
|
|
|
|
#: library/socketserver.rst:370
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Called by the server's constructor to bind the socket to the desired "
|
|
|
|
|
"address. May be overridden."
|
|
|
|
|
msgstr ""
|
2022-05-21 11:03:47 +00:00
|
|
|
|
"Appelée par le constructeur du serveur afin d'assigner (*bind*) l'adresse "
|
|
|
|
|
"requise au connecteur du serveur. Peut être surchargée."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-21 12:56:20 +00:00
|
|
|
|
#: library/socketserver.rst:376
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Must return a Boolean value; if the value is :const:`True`, the request will "
|
|
|
|
|
"be processed, and if it's :const:`False`, the request will be denied. This "
|
|
|
|
|
"function can be overridden to implement access controls for a server. The "
|
|
|
|
|
"default implementation always returns :const:`True`."
|
|
|
|
|
msgstr ""
|
2022-05-21 11:03:47 +00:00
|
|
|
|
"Doit renvoyer un booléen. Si la valeur est :const:`True`, la requête sera "
|
|
|
|
|
"traitée. Si la valeur est :const:`False`, la requête sera refusée. Cette "
|
|
|
|
|
"fonction peut être surchargée afin d'implémenter une stratégie de contrôle "
|
|
|
|
|
"d'accès au serveur. L'implémentation par défaut renvoie toujours :const:"
|
|
|
|
|
"`True`."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-21 12:56:20 +00:00
|
|
|
|
#: library/socketserver.rst:382
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Support for the :term:`context manager` protocol was added. Exiting the "
|
|
|
|
|
"context manager is equivalent to calling :meth:`server_close`."
|
|
|
|
|
msgstr ""
|
2022-05-21 11:03:47 +00:00
|
|
|
|
"La gestion du protocole :term:`context manager` a été ajoutée. Sortir du "
|
|
|
|
|
"gestionnaire de contexte revient à appeler :meth:`server_close`."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-21 12:56:20 +00:00
|
|
|
|
#: library/socketserver.rst:388
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Request Handler Objects"
|
2022-05-21 11:03:47 +00:00
|
|
|
|
msgstr "Objets gestionnaire de requêtes"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-21 12:56:20 +00:00
|
|
|
|
#: library/socketserver.rst:392
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"This is the superclass of all request handler objects. It defines the "
|
|
|
|
|
"interface, given below. A concrete request handler subclass must define a "
|
|
|
|
|
"new :meth:`handle` method, and can override any of the other methods. A new "
|
|
|
|
|
"instance of the subclass is created for each request."
|
|
|
|
|
msgstr ""
|
2022-05-21 11:03:47 +00:00
|
|
|
|
"Classe de base de tous les objets gestionnaire de requêtes. Elle déclare "
|
|
|
|
|
"l'interface, définie ci-dessous, pour tous les gestionnaires. Une "
|
|
|
|
|
"implémentation concrète doit définir une nouvelle méthode :meth:`handle` et "
|
|
|
|
|
"peut surcharger n'importe quelle autre méthode. Cette classe concrète est "
|
|
|
|
|
"instanciée pour chaque requête."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-21 12:56:20 +00:00
|
|
|
|
#: library/socketserver.rst:401
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Called before the :meth:`handle` method to perform any initialization "
|
|
|
|
|
"actions required. The default implementation does nothing."
|
|
|
|
|
msgstr ""
|
2022-05-21 11:03:47 +00:00
|
|
|
|
"Appelée avant la méthode :meth:`handle` afin d'effectuer toutes les "
|
|
|
|
|
"opérations d'initialisation requises. L'implémentation par défaut ne fait "
|
|
|
|
|
"rien."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-21 12:56:20 +00:00
|
|
|
|
#: library/socketserver.rst:407
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"This function must do all the work required to service a request. The "
|
|
|
|
|
"default implementation does nothing. Several instance attributes are "
|
|
|
|
|
"available to it; the request is available as :attr:`self.request`; the "
|
|
|
|
|
"client address as :attr:`self.client_address`; and the server instance as :"
|
|
|
|
|
"attr:`self.server`, in case it needs access to per-server information."
|
|
|
|
|
msgstr ""
|
2022-05-21 11:03:47 +00:00
|
|
|
|
"Cette fonction doit faire tout le nécessaire pour traiter une requête. "
|
|
|
|
|
"L'implémentation par défaut ne fait rien. La fonction peut accéder à "
|
|
|
|
|
"plusieurs attributs d'instance : la requête elle-même se trouve dans :attr:"
|
|
|
|
|
"`self.request`, l'adresse du client dans :attr:`self.client_address` et "
|
|
|
|
|
"l'instance du serveur dans :attr:`self.server` (dans le cas où il aurait "
|
|
|
|
|
"besoin d'accéder aux informations du serveur)."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-21 12:56:20 +00:00
|
|
|
|
#: library/socketserver.rst:413
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"The type of :attr:`self.request` is different for datagram or stream "
|
|
|
|
|
"services. For stream services, :attr:`self.request` is a socket object; for "
|
|
|
|
|
"datagram services, :attr:`self.request` is a pair of string and socket."
|
|
|
|
|
msgstr ""
|
2022-05-21 11:03:47 +00:00
|
|
|
|
"Le type de :attr:`self.request` est différent pour les services utilisant "
|
|
|
|
|
"des datagrammes ou des flux de données. Pour les services à flux de "
|
|
|
|
|
"données, :attr:`self.request` renvoie l'objet connecteur ; pour les services "
|
|
|
|
|
"à datagrammes, :attr:`self.request` est une paire constituée d'une chaîne de "
|
|
|
|
|
"caractères et du connecteur."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-21 12:56:20 +00:00
|
|
|
|
#: library/socketserver.rst:420
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Called after the :meth:`handle` method to perform any clean-up actions "
|
|
|
|
|
"required. The default implementation does nothing. If :meth:`setup` raises "
|
|
|
|
|
"an exception, this function will not be called."
|
|
|
|
|
msgstr ""
|
2022-05-21 11:03:47 +00:00
|
|
|
|
"Appelée après la méthode :meth:`handle` pour effectuer les opérations de "
|
|
|
|
|
"nettoyage requises. L'implémentation par défaut ne fait rien. Si :meth:"
|
|
|
|
|
"`setup` lève une exception, cette méthode n'est pas appelée."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-21 12:56:20 +00:00
|
|
|
|
#: library/socketserver.rst:428
|
2023-01-15 21:42:07 +00:00
|
|
|
|
#, fuzzy
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"These :class:`BaseRequestHandler` subclasses override the :meth:"
|
|
|
|
|
"`~BaseRequestHandler.setup` and :meth:`~BaseRequestHandler.finish` methods, "
|
|
|
|
|
"and provide :attr:`self.rfile` and :attr:`self.wfile` attributes. The :attr:"
|
|
|
|
|
"`self.rfile` and :attr:`self.wfile` attributes can be read or written, "
|
2023-01-15 21:42:07 +00:00
|
|
|
|
"respectively, to get the request data or return data to the client. The :"
|
|
|
|
|
"attr:`!rfile` attributes support the :class:`io.BufferedIOBase` readable "
|
|
|
|
|
"interface, and :attr:`!wfile` attributes support the :class:`!io."
|
|
|
|
|
"BufferedIOBase` writable interface."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgstr ""
|
2022-05-21 11:03:47 +00:00
|
|
|
|
"Ces classes, héritant de :class:`BaseRequestHandler`, redéfinissent les "
|
|
|
|
|
"méthodes :meth:`~BaseRequestHandler.setup` et :meth:`~BaseRequestHandler."
|
|
|
|
|
"finish` et fournissent les attributs :attr:`self.rfile` et :attr:`self."
|
|
|
|
|
"wfile`. Les deux attributs :attr:`self.rfile` et :attr:`self.wfile` peuvent "
|
|
|
|
|
"être respectivement lus ou écrits, afin de récupérer les données de la "
|
|
|
|
|
"requête ou d'envoyer des données au client."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-21 12:56:20 +00:00
|
|
|
|
#: library/socketserver.rst:437
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
":attr:`StreamRequestHandler.wfile` also supports the :class:`io."
|
|
|
|
|
"BufferedIOBase` writable interface."
|
|
|
|
|
msgstr ""
|
2022-05-21 11:03:47 +00:00
|
|
|
|
":attr:`StreamRequestHandler.wfile` prend également en charge l'interface "
|
|
|
|
|
"d'écriture de :class:`io.BufferedIOBase`."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-21 12:56:20 +00:00
|
|
|
|
#: library/socketserver.rst:443
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Examples"
|
|
|
|
|
msgstr "Exemples"
|
|
|
|
|
|
2023-07-21 12:56:20 +00:00
|
|
|
|
#: library/socketserver.rst:446
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ":class:`socketserver.TCPServer` Example"
|
2022-05-21 11:03:47 +00:00
|
|
|
|
msgstr "Exemple pour :class:`socketserver.TCPServer`"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-21 12:56:20 +00:00
|
|
|
|
#: library/socketserver.rst:547
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "This is the server side::"
|
2022-05-21 11:03:47 +00:00
|
|
|
|
msgstr "Implémentation côté serveur ::"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-21 12:56:20 +00:00
|
|
|
|
#: library/socketserver.rst:478
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"An alternative request handler class that makes use of streams (file-like "
|
|
|
|
|
"objects that simplify communication by providing the standard file "
|
|
|
|
|
"interface)::"
|
|
|
|
|
msgstr ""
|
2022-05-21 11:03:47 +00:00
|
|
|
|
"Une implémentation alternative du gestionnaire de requêtes utilisant les "
|
|
|
|
|
"flux de données (avec des objets fichier-compatibles simplifiant la "
|
|
|
|
|
"communication en fournissant l'interface fichier standard) ::"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-21 12:56:20 +00:00
|
|
|
|
#: library/socketserver.rst:493
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"The difference is that the ``readline()`` call in the second handler will "
|
|
|
|
|
"call ``recv()`` multiple times until it encounters a newline character, "
|
|
|
|
|
"while the single ``recv()`` call in the first handler will just return what "
|
|
|
|
|
"has been sent from the client in one ``sendall()`` call."
|
|
|
|
|
msgstr ""
|
2022-05-21 11:03:47 +00:00
|
|
|
|
"La différence est que l'appel à ``readline()`` dans le second gestionnaire "
|
|
|
|
|
"permet d'appeler ``recv()`` jusqu'à rencontrer un caractère de fin de ligne "
|
|
|
|
|
"alors que dans le premier gestionnaire appelle directement ``recv()``, "
|
|
|
|
|
"renvoyant toutes les données envoyées par le client en un seul appel à "
|
|
|
|
|
"``sendall()``."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-21 12:56:20 +00:00
|
|
|
|
#: library/socketserver.rst:571
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "This is the client side::"
|
2022-05-21 11:03:47 +00:00
|
|
|
|
msgstr "Implémentation côté client ::"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-21 12:56:20 +00:00
|
|
|
|
#: library/socketserver.rst:646
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "The output of the example should look something like this:"
|
2022-05-21 11:03:47 +00:00
|
|
|
|
msgstr "La sortie de cet exemple devrait ressembler à ça :"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-21 12:56:20 +00:00
|
|
|
|
#: library/socketserver.rst:522
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Server:"
|
2022-05-21 11:03:47 +00:00
|
|
|
|
msgstr "Serveur :"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-21 12:56:20 +00:00
|
|
|
|
#: library/socketserver.rst:532
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Client:"
|
2022-05-21 11:03:47 +00:00
|
|
|
|
msgstr "Client :"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-21 12:56:20 +00:00
|
|
|
|
#: library/socketserver.rst:545
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ":class:`socketserver.UDPServer` Example"
|
2022-05-21 11:03:47 +00:00
|
|
|
|
msgstr "Exemple pour :class:`socketserver.UDPServer`"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-21 12:56:20 +00:00
|
|
|
|
#: library/socketserver.rst:590
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"The output of the example should look exactly like for the TCP server "
|
|
|
|
|
"example."
|
|
|
|
|
msgstr ""
|
2022-05-21 11:03:47 +00:00
|
|
|
|
"La sortie de cet exemple devrait ressembler exactement à la sortie de "
|
|
|
|
|
"l'exemple pour le serveur TCP."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-21 12:56:20 +00:00
|
|
|
|
#: library/socketserver.rst:594
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Asynchronous Mixins"
|
2022-05-21 11:03:47 +00:00
|
|
|
|
msgstr "Classes de mélange asynchrone"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-21 12:56:20 +00:00
|
|
|
|
#: library/socketserver.rst:596
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"To build asynchronous handlers, use the :class:`ThreadingMixIn` and :class:"
|
|
|
|
|
"`ForkingMixIn` classes."
|
|
|
|
|
msgstr ""
|
2022-05-21 11:03:47 +00:00
|
|
|
|
"Pour développer des gestionnaires asynchrones, utilisez les classes :class:"
|
|
|
|
|
"`ThreadingMixIn` et :class:`ForkingMixIn`."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-21 12:56:20 +00:00
|
|
|
|
#: library/socketserver.rst:599
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "An example for the :class:`ThreadingMixIn` class::"
|
2022-05-21 11:03:47 +00:00
|
|
|
|
msgstr "Exemple pour :class:`ThreadingMixIn` ::"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2023-07-21 12:56:20 +00:00
|
|
|
|
#: library/socketserver.rst:657
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"The :class:`ForkingMixIn` class is used in the same way, except that the "
|
|
|
|
|
"server will spawn a new process for each request. Available only on POSIX "
|
|
|
|
|
"platforms that support :func:`~os.fork`."
|
|
|
|
|
msgstr ""
|
2022-05-21 11:03:47 +00:00
|
|
|
|
"La classe :class:`ForkingMixIn` est utilisable de la même façon à la "
|
|
|
|
|
"différence près que le serveur crée un nouveau processus fils pour chaque "
|
|
|
|
|
"requête. Disponible uniquement sur les plateformes POSIX prenant en charge :"
|
|
|
|
|
"func:`~os.fork`."
|
2023-01-15 21:42:07 +00:00
|
|
|
|
|
|
|
|
|
#~ msgid ""
|
|
|
|
|
#~ "The :attr:`rfile` attributes of both classes support the :class:`io."
|
|
|
|
|
#~ "BufferedIOBase` readable interface, and :attr:`DatagramRequestHandler."
|
|
|
|
|
#~ "wfile` supports the :class:`io.BufferedIOBase` writable interface."
|
|
|
|
|
#~ msgstr ""
|
|
|
|
|
#~ "L'attribut :attr:`rfile` des deux classes prend en charge l'interface de "
|
|
|
|
|
#~ "lecture de :class:`io.BufferedIOBase`. L'attribut :attr:"
|
|
|
|
|
#~ "`DatagramRequestHandler.wfile` sait gérer l'interface d'écriture de :"
|
|
|
|
|
#~ "class:`io.BufferedIOBase`."
|