Changeset 391 for python/trunk/Doc/library/socketserver.rst

Timestamp:

Mar 19, 2014, 11:31:01 PM (11 years ago)

Author:

dmik

Message:

python: Merge vendor 2.7.6 to trunk.

Location:

python/trunk

Files:

• . (modified) (1 prop)
• Doc/library/socketserver.rst (modified) (16 diffs)

python/trunk/Doc/library/socketserver.rst

@@ -1 @@
-
 :mod:`SocketServer` --- A framework for network servers
 =======================================================
@@ -9 +8 @@
 
    The :mod:`SocketServer` module has been renamed to :mod:`socketserver` in
-   Python 3.0.  The :term:`2to3` tool will automatically adapt imports when
-   converting your sources to 3.0.
-
+   Python 3.  The :term:`2to3` tool will automatically adapt imports when
+   converting your sources to Python 3.
+
+**Source code:** :source:`Lib/SocketServer.py`
+
+--------------
 
 The :mod:`SocketServer` module simplifies the task of writing network servers.
@@ -86 +88 @@
 
 The mix-in class must come first, since it overrides a method defined in
-:class:`UDPServer`.  Setting the various member variables also changes the
+:class:`UDPServer`.  Setting the various attributes also change the
 behavior of the underlying server mechanism.
 
@@ -115 +117 @@
 
 Another approach to handling multiple simultaneous requests in an environment
-that supports neither threads nor :func:`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 :func:`select` 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). See :mod:`asyncore` for
-another way to manage this.
+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 :func:`~select.select` 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). See
+:mod:`asyncore` for another way to manage this.
 
 .. XXX should data and methods be intermingled, or separate?
@@ -157 +159 @@
 .. method:: BaseServer.serve_forever(poll_interval=0.5)
 
-   Handle requests until an explicit :meth:`shutdown` request.  Polls for
-   shutdown every *poll_interval* seconds.
+   Handle requests until an explicit :meth:`shutdown` request.
+   Poll for shutdown every *poll_interval* seconds. Ignores :attr:`self.timeout`.
+   If you need to do periodic tasks, do them in another thread.
 
 
 .. method:: BaseServer.shutdown()
 
-   Tells the :meth:`serve_forever` loop to stop and waits until it does.
+   Tell the :meth:`serve_forever` loop to stop and wait until it does.
 
    .. versionadded:: 2.6
@@ -304 +307 @@
 
    Called after the :meth:`handle` method to perform any clean-up actions
-   required.  The default implementation does nothing.  If :meth:`setup` or
-   :meth:`handle` raise an exception, this function will not be called.
+   required.  The default implementation does nothing.  If :meth:`setup`
+   raises an exception, this function will not be called.
 
 
@@ -355 +358 @@
            # self.request is the TCP socket connected to the client
            self.data = self.request.recv(1024).strip()
-           print "%s wrote:" % self.client_address[0]
+           print "{} wrote:".format(self.client_address[0])
            print self.data
            # just send back the same data, but upper-cased
-           self.request.send(self.data.upper())
+           self.request.sendall(self.data.upper())
 
    if __name__ == "__main__":
@@ -379 +382 @@
            # we can now use e.g. readline() instead of raw recv() calls
            self.data = self.rfile.readline().strip()
-           print "%s wrote:" % self.client_address[0]
+           print "{} wrote:".format(self.client_address[0])
            print self.data
            # Likewise, self.wfile is a file-like object used to write back
@@ -388 +391 @@
 ``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 ``send()`` call.
+from the client in one ``sendall()`` call.
 
 
@@ -402 +405 @@
    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
 
-   # Connect to server and send data
-   sock.connect((HOST, PORT))
-   sock.send(data + "\n")
-
-   # Receive data from the server and shut down
-   received = sock.recv(1024)
-   sock.close()
-
-   print "Sent:     %s" % data
-   print "Received: %s" % received
+   try:
+       # Connect to server and send data
+       sock.connect((HOST, PORT))
+       sock.sendall(data + "\n")
+
+       # Receive data from the server and shut down
+       received = sock.recv(1024)
+   finally:
+       sock.close()
+
+   print "Sent:     {}".format(data)
+   print "Received: {}".format(received)
 
 
@@ -452 +457 @@
            data = self.request[0].strip()
            socket = self.request[1]
-           print "%s wrote:" % self.client_address[0]
+           print "{} wrote:".format(self.client_address[0])
            print data
            socket.sendto(data.upper(), self.client_address)
 
    if __name__ == "__main__":
-      HOST, PORT = "localhost", 9999
-      server = SocketServer.UDPServer((HOST, PORT), MyUDPHandler)
-      server.serve_forever()
+       HOST, PORT = "localhost", 9999
+       server = SocketServer.UDPServer((HOST, PORT), MyUDPHandler)
+       server.serve_forever()
 
 This is the client side::
@@ -477 +482 @@
    received = sock.recv(1024)
 
-   print "Sent:     %s" % data
-   print "Received: %s" % received
+   print "Sent:     {}".format(data)
+   print "Received: {}".format(received)
 
 The output of the example should look exactly like for the TCP server example.
@@ -499 +504 @@
        def handle(self):
            data = self.request.recv(1024)
-           cur_thread = threading.currentThread()
-           response = "%s: %s" % (cur_thread.getName(), data)
-           self.request.send(response)
+           cur_thread = threading.current_thread()
+           response = "{}: {}".format(cur_thread.name, data)
+           self.request.sendall(response)
 
    class ThreadedTCPServer(SocketServer.ThreadingMixIn, SocketServer.TCPServer):
@@ -509 +514 @@
        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        sock.connect((ip, port))
-       sock.send(message)
-       response = sock.recv(1024)
-       print "Received: %s" % response
-       sock.close()
+       try:
+           sock.sendall(message)
+           response = sock.recv(1024)
+           print "Received: {}".format(response)
+       finally:
+           sock.close()
 
    if __name__ == "__main__":
@@ -525 +532 @@
        server_thread = threading.Thread(target=server.serve_forever)
        # Exit the server thread when the main thread terminates
-       server_thread.setDaemon(True)
+       server_thread.daemon = True
        server_thread.start()
-       print "Server loop running in thread:", server_thread.getName()
+       print "Server loop running in thread:", server_thread.name
 
        client(ip, port, "Hello World 1")
@@ -534 +541 @@
 
        server.shutdown()
+
 
 The output of the example should look something like this::