socketserver.po

# Copyright (C) 2001-2024, Python Software Foundation
# This file is distributed under the same license as the Python package.
#
# Translators:
msgid ""
msgstr ""
"Project-Id-Version: Python 3.13\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2025-02-07 00:13+0000\n"
"PO-Revision-Date: 2018-05-23 16:10+0000\n"
"Last-Translator: Adrian Liaw <adrianliaw2000@gmail.com>\n"
"Language-Team: Chinese - TAIWAN (https://github.com/python/python-docs-zh-"
"tw)\n"
"Language: zh_TW\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Plural-Forms: nplurals=1; plural=0;\n"

#: ../../library/socketserver.rst:2
msgid ":mod:`!socketserver` --- A framework for network servers"
msgstr ":mod:`!socketserver` --- 用於網路伺服器的框架"

#: ../../library/socketserver.rst:7
msgid "**Source code:** :source:`Lib/socketserver.py`"
msgstr "**原始碼：**\\ :source:`Lib/socketserver.py`"

#: ../../library/socketserver.rst:11
msgid ""
"The :mod:`socketserver` module simplifies the task of writing network "
"servers."
msgstr ""

#: ../../includes/wasm-notavail.rst:3
msgid "Availability"
msgstr ""

#: ../../includes/wasm-notavail.rst:5
msgid ""
"This module does not work or is not available on WebAssembly. See :ref:`wasm-"
"availability` for more information."
msgstr ""
"此模組在 WebAssembly 平台上不起作用或無法使用。更多資訊請參閱 :ref:`wasm-"
"availability`。"

#: ../../library/socketserver.rst:15
msgid "There are four basic concrete server classes:"
msgstr ""

#: ../../library/socketserver.rst:20
msgid ""
"This uses the internet TCP protocol, which provides for continuous streams "
"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 ""

#: ../../library/socketserver.rst:30
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 ""

#: ../../library/socketserver.rst:38
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 ""

#: ../../library/socketserver.rst:44
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 ""

#: ../../library/socketserver.rst:52
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 :keyword:`!with` statement)."
msgstr ""

#: ../../library/socketserver.rst:64
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 ""

#: ../../library/socketserver.rst:73
msgid ""
"Server classes have the same external methods and attributes, no matter what "
"network protocol they use."
msgstr ""

#: ../../library/socketserver.rst:78
msgid "Server Creation Notes"
msgstr ""

#: ../../library/socketserver.rst:80
msgid ""
"There are five classes in an inheritance diagram, four of which represent "
"synchronous servers of four types::"
msgstr ""

#: ../../library/socketserver.rst:83
msgid ""
"+------------+\n"
"| BaseServer |\n"
"+------------+\n"
"      |\n"
"      v\n"
"+-----------+        +------------------+\n"
"| TCPServer |------->| UnixStreamServer |\n"
"+-----------+        +------------------+\n"
"      |\n"
"      v\n"
"+-----------+        +--------------------+\n"
"| UDPServer |------->| UnixDatagramServer |\n"
"+-----------+        +--------------------+"
msgstr ""
"+------------+\n"
"| BaseServer |\n"
"+------------+\n"
"      |\n"
"      v\n"
"+-----------+        +------------------+\n"
"| TCPServer |------->| UnixStreamServer |\n"
"+-----------+        +------------------+\n"
"      |\n"
"      v\n"
"+-----------+        +--------------------+\n"
"| UDPServer |------->| UnixDatagramServer |\n"
"+-----------+        +--------------------+"

#: ../../library/socketserver.rst:97
msgid ""
"Note that :class:`UnixDatagramServer` derives from :class:`UDPServer`, not "
"from :class:`UnixStreamServer` --- the only difference between an IP and a "
"Unix server is the address family."
msgstr ""

#: ../../library/socketserver.rst:105
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 ""

#: ../../library/socketserver.rst:109
msgid ""
"class ThreadingUDPServer(ThreadingMixIn, UDPServer):\n"
"    pass"
msgstr ""
"class ThreadingUDPServer(ThreadingMixIn, UDPServer):\n"
"    pass"

#: ../../library/socketserver.rst:112
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 ""

#: ../../library/socketserver.rst:116
msgid ""
":class:`ForkingMixIn` and the Forking classes mentioned below are only "
"available on POSIX platforms that support :func:`~os.fork`."
msgstr ""

#: ../../library/socketserver.rst:121
msgid ""
":meth:`ForkingMixIn.server_close <BaseServer.server_close>` waits until all "
"child processes complete, except if :attr:`block_on_close` attribute is "
"``False``."
msgstr ""

#: ../../library/socketserver.rst:125
msgid ""
":meth:`ThreadingMixIn.server_close <BaseServer.server_close>` waits until "
"all non-daemon threads complete, except if :attr:`block_on_close` attribute "
"is ``False``."
msgstr ""

#: ../../library/socketserver.rst:131
msgid ""
"For :class:`ThreadingMixIn` use daemonic threads by "
"setting :data:`ThreadingMixIn.daemon_threads <daemon_threads>` to ``True`` "
"to not wait until threads complete."
msgstr ""

#: ../../library/socketserver.rst:137
msgid ""
":meth:`ForkingMixIn.server_close <BaseServer.server_close>` "
"and :meth:`ThreadingMixIn.server_close <BaseServer.server_close>` now waits "
"until all child processes and non-daemonic threads complete. Add a "
"new :attr:`ForkingMixIn.block_on_close <block_on_close>` class attribute to "
"opt-in for the pre-3.7 behaviour."
msgstr ""

#: ../../library/socketserver.rst:153
msgid "These classes are pre-defined using the mix-in classes."
msgstr ""

#: ../../library/socketserver.rst:155
msgid ""
"The ``ForkingUnixStreamServer`` and ``ForkingUnixDatagramServer`` classes "
"were added."
msgstr ""

#: ../../library/socketserver.rst:159
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 ""

#: ../../library/socketserver.rst:167
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 ""

#: ../../library/socketserver.rst:174
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 ""

#: ../../library/socketserver.rst:180
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 ""

#: ../../library/socketserver.rst:185
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 "
"subprocesses cannot be used)."
msgstr ""

#: ../../library/socketserver.rst:198
msgid "Server Objects"
msgstr ""

#: ../../library/socketserver.rst:202
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 ""

#: ../../library/socketserver.rst:210
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 ""

#: ../../library/socketserver.rst:217
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 ""

#: ../../library/socketserver.rst:229
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 ""

#: ../../library/socketserver.rst:237
msgid "Added ``service_actions`` call to the ``serve_forever`` method."
msgstr ""

#: ../../library/socketserver.rst:243
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 ""

#: ../../library/socketserver.rst:251
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."
msgstr ""

#: ../../library/socketserver.rst:258
msgid "Clean up the server. May be overridden."
msgstr ""

#: ../../library/socketserver.rst:263
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 ""

#: ../../library/socketserver.rst:269
msgid ""
"The user-provided request handler class; an instance of this class is "
"created for each request."
msgstr ""

#: ../../library/socketserver.rst:275
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:`socket` module for details.  For internet protocols, this is a "
"tuple containing a string giving the address, and an integer port number: "
"``('127.0.0.1', 80)``, for example."
msgstr ""

#: ../../library/socketserver.rst:284
msgid ""
"The socket object on which the server will listen for incoming requests."
msgstr ""

#: ../../library/socketserver.rst:287
msgid "The server classes support the following class variables:"
msgstr ""

#: ../../library/socketserver.rst:293
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 ""

#: ../../library/socketserver.rst:299
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 ""

#: ../../library/socketserver.rst:308
msgid ""
"The type of socket used by the server; :const:`socket.SOCK_STREAM` "
"and :const:`socket.SOCK_DGRAM` are two common values."
msgstr ""

#: ../../library/socketserver.rst:314
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 ""

#: ../../library/socketserver.rst:319
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 ""

#: ../../library/socketserver.rst:328
msgid ""
"Actually processes the request by instantiating :attr:`RequestHandlerClass` "
"and calling its :meth:`~BaseRequestHandler.handle` method."
msgstr ""

#: ../../library/socketserver.rst:334
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 ""

#: ../../library/socketserver.rst:341
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 ""

#: ../../library/socketserver.rst:346
msgid "Now only called for exceptions derived from the :exc:`Exception` class."
msgstr ""

#: ../../library/socketserver.rst:353
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 ""

#: ../../library/socketserver.rst:362
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 ""

#: ../../library/socketserver.rst:374
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 ""

#: ../../library/socketserver.rst:381
msgid ""
"Called by the server's constructor to bind the socket to the desired "
"address. May be overridden."
msgstr ""

#: ../../library/socketserver.rst:387
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 ""

#: ../../library/socketserver.rst:393
msgid ""
"Support for the :term:`context manager` protocol was added.  Exiting the "
"context manager is equivalent to calling :meth:`server_close`."
msgstr ""

#: ../../library/socketserver.rst:399
msgid "Request Handler Objects"
msgstr ""

#: ../../library/socketserver.rst:403
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 ""

#: ../../library/socketserver.rst:412
msgid ""
"Called before the :meth:`handle` method to perform any initialization "
"actions required.  The default implementation does nothing."
msgstr ""

#: ../../library/socketserver.rst:418
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:`request`; the client "
"address as :attr:`client_address`; and the server instance "
"as :attr:`server`, in case it needs access to per-server information."
msgstr ""

#: ../../library/socketserver.rst:424
msgid ""
"The type of :attr:`request` is different for datagram or stream services.  "
"For stream services, :attr:`request` is a socket object; for datagram "
"services, :attr:`request` is a pair of string and socket."
msgstr ""

#: ../../library/socketserver.rst:431
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 ""

#: ../../library/socketserver.rst:438
msgid ""
"The *new* :class:`socket.socket` object to be used to communicate with the "
"client."
msgstr ""

#: ../../library/socketserver.rst:444
msgid "Client address returned by :meth:`BaseServer.get_request`."
msgstr ""

#: ../../library/socketserver.rst:449
msgid ":class:`BaseServer` object used for handling the request."
msgstr ""

#: ../../library/socketserver.rst:455
msgid ""
"These :class:`BaseRequestHandler` subclasses override "
"the :meth:`~BaseRequestHandler.setup` and :meth:`~BaseRequestHandler.finish` "
"methods, and provide :attr:`rfile` and :attr:`wfile` attributes."
msgstr ""

#: ../../library/socketserver.rst:461
msgid ""
"A file object from which receives the request is read. Support "
"the :class:`io.BufferedIOBase` readable interface."
msgstr ""

#: ../../library/socketserver.rst:466
msgid ""
"A file object to which the reply is written. Support "
"the :class:`io.BufferedIOBase` writable interface"
msgstr ""

#: ../../library/socketserver.rst:470
msgid ""
":attr:`wfile` also supports the :class:`io.BufferedIOBase` writable "
"interface."
msgstr ""

#: ../../library/socketserver.rst:476
msgid "Examples"
msgstr "範例"

#: ../../library/socketserver.rst:479
msgid ":class:`socketserver.TCPServer` Example"
msgstr ":class:`socketserver.TCPServer` 範例"

#: ../../library/socketserver.rst:481 ../../library/socketserver.rst:592
msgid "This is the server side::"
msgstr ""

#: ../../library/socketserver.rst:483
msgid ""
"import socketserver\n"
"\n"
"class MyTCPHandler(socketserver.BaseRequestHandler):\n"
"    \"\"\"\n"
"    The request handler class for our server.\n"
"\n"
"    It is instantiated once per connection to the server, and must\n"
"    override the handle() method to implement communication to the\n"
"    client.\n"
"    \"\"\"\n"
"\n"
"    def handle(self):\n"
"        # self.request is the TCP socket connected to the client\n"
"        pieces = [b'']\n"
"        total = 0\n"
"        while b'\\n' not in pieces[-1] and total < 10_000:\n"
"            pieces.append(self.request.recv(2000))\n"
"            total += len(pieces[-1])\n"
"        self.data = b''.join(pieces)\n"
"        print(f\"Received from {self.client_address[0]}:\")\n"
"        print(self.data.decode(\"utf-8\"))\n"
"        # just send back the same data, but upper-cased\n"
"        self.request.sendall(self.data.upper())\n"
"        # after we return, the socket will be closed.\n"
"\n"
"if __name__ == \"__main__\":\n"
"    HOST, PORT = \"localhost\", 9999\n"
"\n"
"    # Create the server, binding to localhost on port 9999\n"
"    with socketserver.TCPServer((HOST, PORT), MyTCPHandler) as server:\n"
"        # Activate the server; this will keep running until you\n"
"        # interrupt the program with Ctrl-C\n"
"        server.serve_forever()"
msgstr ""

#: ../../library/socketserver.rst:517
msgid ""
"An alternative request handler class that makes use of streams (file-like "
"objects that simplify communication by providing the standard file "
"interface)::"
msgstr ""

#: ../../library/socketserver.rst:520
msgid ""
"class MyTCPHandler(socketserver.StreamRequestHandler):\n"
"\n"
"    def handle(self):\n"
"        # self.rfile is a file-like object created by the handler.\n"
"        # We can now use e.g. readline() instead of raw recv() calls.\n"
"        # We limit ourselves to 10000 bytes to avoid abuse by the sender.\n"
"        self.data = self.rfile.readline(10000).rstrip()\n"
"        print(f\"{self.client_address[0]} wrote:\")\n"
"        print(self.data.decode(\"utf-8\"))\n"
"        # Likewise, self.wfile is a file-like object used to write back\n"
"        # to the client\n"
"        self.wfile.write(self.data.upper())"
msgstr ""

#: ../../library/socketserver.rst:533
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 the first handler had to use a ``recv()`` loop to accumulate data "
"until a newline itself.  If it had just used a single ``recv()`` without the "
"loop it would just have returned what has been received so far from the "
"client. TCP is stream based: data arrives in the order it was sent, but "
"there no correlation between client ``send()`` or ``sendall()`` calls and "
"the number of ``recv()`` calls on the server required to receive it."
msgstr ""

#: ../../library/socketserver.rst:543 ../../library/socketserver.rst:616
msgid "This is the client side::"
msgstr ""

#: ../../library/socketserver.rst:545
msgid ""
"import socket\n"
"import sys\n"
"\n"
"HOST, PORT = \"localhost\", 9999\n"
"data = \" \".join(sys.argv[1:])\n"
"\n"
"# Create a socket (SOCK_STREAM means a TCP socket)\n"
"with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:\n"
"    # Connect to server and send data\n"
"    sock.connect((HOST, PORT))\n"
"    sock.sendall(bytes(data, \"utf-8\"))\n"
"    sock.sendall(b\"\\n\")\n"
"\n"
"    # Receive data from the server and shut down\n"
"    received = str(sock.recv(1024), \"utf-8\")\n"
"\n"
"print(\"Sent:    \", data)\n"
"print(\"Received:\", received)"
msgstr ""

#: ../../library/socketserver.rst:565 ../../library/socketserver.rst:691
msgid "The output of the example should look something like this:"
msgstr ""

#: ../../library/socketserver.rst:567
msgid "Server:"
msgstr ""

#: ../../library/socketserver.rst:569
msgid ""
"$ python TCPServer.py\n"
"127.0.0.1 wrote:\n"
"b'hello world with TCP'\n"
"127.0.0.1 wrote:\n"
"b'python is nice'"
msgstr ""
"$ python TCPServer.py\n"
"127.0.0.1 wrote:\n"
"b'hello world with TCP'\n"
"127.0.0.1 wrote:\n"
"b'python is nice'"

#: ../../library/socketserver.rst:577
msgid "Client:"
msgstr ""

#: ../../library/socketserver.rst:579
msgid ""
"$ python TCPClient.py hello world with TCP\n"
"Sent:     hello world with TCP\n"
"Received: HELLO WORLD WITH TCP\n"
"$ python TCPClient.py python is nice\n"
"Sent:     python is nice\n"
"Received: PYTHON IS NICE"
msgstr ""
"$ python TCPClient.py hello world with TCP\n"
"Sent:     hello world with TCP\n"
"Received: HELLO WORLD WITH TCP\n"
"$ python TCPClient.py python is nice\n"
"Sent:     python is nice\n"
"Received: PYTHON IS NICE"

#: ../../library/socketserver.rst:590
msgid ":class:`socketserver.UDPServer` Example"
msgstr ":class:`socketserver.UDPServer` 範例"

#: ../../library/socketserver.rst:594
msgid ""
"import socketserver\n"
"\n"
"class MyUDPHandler(socketserver.BaseRequestHandler):\n"
"    \"\"\"\n"
"    This class works similar to the TCP handler class, except that\n"
"    self.request consists of a pair of data and client socket, and since\n"
"    there is no connection the client address must be given explicitly\n"
"    when sending data back via sendto().\n"
"    \"\"\"\n"
"\n"
"    def handle(self):\n"
"        data = self.request[0].strip()\n"
"        socket = self.request[1]\n"
"        print(f\"{self.client_address[0]} wrote:\")\n"
"        print(data)\n"
"        socket.sendto(data.upper(), self.client_address)\n"
"\n"
"if __name__ == \"__main__\":\n"
"    HOST, PORT = \"localhost\", 9999\n"
"    with socketserver.UDPServer((HOST, PORT), MyUDPHandler) as server:\n"
"        server.serve_forever()"
msgstr ""

#: ../../library/socketserver.rst:618
msgid ""
"import socket\n"
"import sys\n"
"\n"
"HOST, PORT = \"localhost\", 9999\n"
"data = \" \".join(sys.argv[1:])\n"
"\n"
"# SOCK_DGRAM is the socket type to use for UDP sockets\n"
"sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)\n"
"\n"
"# As you can see, there is no connect() call; UDP has no connections.\n"
"# Instead, data is directly sent to the recipient via sendto().\n"
"sock.sendto(bytes(data + \"\\n\", \"utf-8\"), (HOST, PORT))\n"
"received = str(sock.recv(1024), \"utf-8\")\n"
"\n"
"print(\"Sent:    \", data)\n"
"print(\"Received:\", received)"
msgstr ""

#: ../../library/socketserver.rst:635
msgid ""
"The output of the example should look exactly like for the TCP server "
"example."
msgstr ""

#: ../../library/socketserver.rst:639
msgid "Asynchronous Mixins"
msgstr ""

#: ../../library/socketserver.rst:641
msgid ""
"To build asynchronous handlers, use the :class:`ThreadingMixIn` "
"and :class:`ForkingMixIn` classes."
msgstr ""

#: ../../library/socketserver.rst:644
msgid "An example for the :class:`ThreadingMixIn` class::"
msgstr ""

#: ../../library/socketserver.rst:646
msgid ""
"import socket\n"
"import threading\n"
"import socketserver\n"
"\n"
"class ThreadedTCPRequestHandler(socketserver.BaseRequestHandler):\n"
"\n"
"    def handle(self):\n"
"        data = str(self.request.recv(1024), 'ascii')\n"
"        cur_thread = threading.current_thread()\n"
"        response = bytes(\"{}: {}\".format(cur_thread.name, data), 'ascii')\n"
"        self.request.sendall(response)\n"
"\n"
"class ThreadedTCPServer(socketserver.ThreadingMixIn, "
"socketserver.TCPServer):\n"
"    pass\n"
"\n"
"def client(ip, port, message):\n"
"    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:\n"
"        sock.connect((ip, port))\n"
"        sock.sendall(bytes(message, 'ascii'))\n"
"        response = str(sock.recv(1024), 'ascii')\n"
"        print(\"Received: {}\".format(response))\n"
"\n"
"if __name__ == \"__main__\":\n"
"    # Port 0 means to select an arbitrary unused port\n"
"    HOST, PORT = \"localhost\", 0\n"
"\n"
"    server = ThreadedTCPServer((HOST, PORT), ThreadedTCPRequestHandler)\n"
"    with server:\n"
"        ip, port = server.server_address\n"
"\n"
"        # Start a thread with the server -- that thread will then start one\n"
"        # more thread for each request\n"
"        server_thread = threading.Thread(target=server.serve_forever)\n"
"        # Exit the server thread when the main thread terminates\n"
"        server_thread.daemon = True\n"
"        server_thread.start()\n"
"        print(\"Server loop running in thread:\", server_thread.name)\n"
"\n"
"        client(ip, port, \"Hello World 1\")\n"
"        client(ip, port, \"Hello World 2\")\n"
"        client(ip, port, \"Hello World 3\")\n"
"\n"
"        server.shutdown()"
msgstr ""

#: ../../library/socketserver.rst:693
msgid ""
"$ python ThreadedTCPServer.py\n"
"Server loop running in thread: Thread-1\n"
"Received: Thread-2: Hello World 1\n"
"Received: Thread-3: Hello World 2\n"
"Received: Thread-4: Hello World 3"
msgstr ""
"$ python ThreadedTCPServer.py\n"
"Server loop running in thread: Thread-1\n"
"Received: Thread-2: Hello World 1\n"
"Received: Thread-3: Hello World 2\n"
"Received: Thread-4: Hello World 3"

#: ../../library/socketserver.rst:702
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 ""