[Python-3000-checkins] r63140 - in python/branches/py3k: Doc/library/basehttpserver.rst Doc/library/logging.rst Doc/library/simplexmlrpcserver.rst Doc/library/socket.rst Doc/library/socketserver.rst Lib/BaseHTTPServer.py Lib/SimpleXMLRPCServer.py Lib/SocketServer.py Lib/idlelib/rpc.py Lib/logging/config.py Lib/socketserver.py Lib/test/test___all__.py Lib/test/test_logging.py Lib/test/test_socketserver.py Lib/test/test_wsgiref.py Misc/NEWS Misc/cheatsheet
alexandre.vassalotti
python-3000-checkins at python.org
Mon May 12 04:31:52 CEST 2008
Author: alexandre.vassalotti
Date: Mon May 12 04:31:37 2008
New Revision: 63140
Log:
Renamed the SocketServer module to 'socketserver'.
Merged revisions 63132 via svnmerge from
svn+ssh://pythondev@svn.python.org/python/trunk
........
r63132 | alexandre.vassalotti | 2008-05-11 22:11:22 -0400 (Sun, 11 May 2008) | 4 lines
Updated all import statements to use the new socketserver module name.
Renamed socketserver module in its own documentation.
Renamed documentation references.
........
Added:
python/branches/py3k/Lib/socketserver.py
- copied unchanged from r63138, /python/branches/py3k/Lib/SocketServer.py
Removed:
python/branches/py3k/Lib/SocketServer.py
Modified:
python/branches/py3k/ (props changed)
python/branches/py3k/Doc/library/basehttpserver.rst
python/branches/py3k/Doc/library/logging.rst
python/branches/py3k/Doc/library/simplexmlrpcserver.rst
python/branches/py3k/Doc/library/socket.rst
python/branches/py3k/Doc/library/socketserver.rst
python/branches/py3k/Lib/BaseHTTPServer.py
python/branches/py3k/Lib/SimpleXMLRPCServer.py
python/branches/py3k/Lib/idlelib/rpc.py
python/branches/py3k/Lib/logging/config.py
python/branches/py3k/Lib/test/test___all__.py
python/branches/py3k/Lib/test/test_logging.py
python/branches/py3k/Lib/test/test_socketserver.py
python/branches/py3k/Lib/test/test_wsgiref.py
python/branches/py3k/Misc/NEWS
python/branches/py3k/Misc/cheatsheet
Modified: python/branches/py3k/Doc/library/basehttpserver.rst
==============================================================================
--- python/branches/py3k/Doc/library/basehttpserver.rst (original)
+++ python/branches/py3k/Doc/library/basehttpserver.rst Mon May 12 04:31:37 2008
@@ -21,7 +21,7 @@
functioning Web servers. See the :mod:`SimpleHTTPServer` and
:mod:`CGIHTTPServer` modules.
-The first class, :class:`HTTPServer`, is a :class:`SocketServer.TCPServer`
+The first class, :class:`HTTPServer`, is a :class:`socketserver.TCPServer`
subclass. It creates and listens at the HTTP socket, dispatching the requests
to a handler. Code to create and run the server looks like this::
Modified: python/branches/py3k/Doc/library/logging.rst
==============================================================================
--- python/branches/py3k/Doc/library/logging.rst (original)
+++ python/branches/py3k/Doc/library/logging.rst Mon May 12 04:31:37 2008
@@ -1274,17 +1274,17 @@
logger2.warning('Jail zesty vixen who grabbed pay from quack.')
logger2.error('The five boxing wizards jump quickly.')
-At the receiving end, you can set up a receiver using the :mod:`SocketServer`
+At the receiving end, you can set up a receiver using the :mod:`socketserver`
module. Here is a basic working example::
import cPickle
import logging
import logging.handlers
- import SocketServer
+ import socketserver
import struct
- class LogRecordStreamHandler(SocketServer.StreamRequestHandler):
+ class LogRecordStreamHandler(socketserver.StreamRequestHandler):
"""Handler for a streaming logging request.
This basically logs the record using whatever logging policy is
@@ -1326,7 +1326,7 @@
# cycles and network bandwidth!
logger.handle(record)
- class LogRecordSocketReceiver(SocketServer.ThreadingTCPServer):
+ class LogRecordSocketReceiver(socketserver.ThreadingTCPServer):
"""simple TCP socket-based logging receiver suitable for testing.
"""
@@ -1335,7 +1335,7 @@
def __init__(self, host='localhost',
port=logging.handlers.DEFAULT_TCP_LOGGING_PORT,
handler=LogRecordStreamHandler):
- SocketServer.ThreadingTCPServer.__init__(self, (host, port), handler)
+ socketserver.ThreadingTCPServer.__init__(self, (host, port), handler)
self.abort = 0
self.timeout = 1
self.logname = None
Modified: python/branches/py3k/Doc/library/simplexmlrpcserver.rst
==============================================================================
--- python/branches/py3k/Doc/library/simplexmlrpcserver.rst (original)
+++ python/branches/py3k/Doc/library/simplexmlrpcserver.rst Mon May 12 04:31:37 2008
@@ -20,7 +20,7 @@
functions that can be called by the XML-RPC protocol. The *requestHandler*
parameter should be a factory for request handler instances; it defaults to
:class:`SimpleXMLRPCRequestHandler`. The *addr* and *requestHandler* parameters
- are passed to the :class:`SocketServer.TCPServer` constructor. If *logRequests*
+ are passed to the :class:`socketserver.TCPServer` constructor. If *logRequests*
is true (the default), requests will be logged; setting this parameter to false
will turn off logging. The *allow_none* and *encoding* parameters are passed
on to :mod:`xmlrpclib` and control the XML-RPC responses that will be returned
@@ -50,7 +50,7 @@
--------------------------
The :class:`SimpleXMLRPCServer` class is based on
-:class:`SocketServer.TCPServer` and provides a means of creating simple, stand
+:class:`socketserver.TCPServer` and provides a means of creating simple, stand
alone XML-RPC servers.
Modified: python/branches/py3k/Doc/library/socket.rst
==============================================================================
--- python/branches/py3k/Doc/library/socket.rst (original)
+++ python/branches/py3k/Doc/library/socket.rst Mon May 12 04:31:37 2008
@@ -453,7 +453,7 @@
.. seealso::
- Module :mod:`SocketServer`
+ Module :mod:`socketserver`
Classes that simplify writing network servers.
Modified: python/branches/py3k/Doc/library/socketserver.rst
==============================================================================
--- python/branches/py3k/Doc/library/socketserver.rst (original)
+++ python/branches/py3k/Doc/library/socketserver.rst Mon May 12 04:31:37 2008
@@ -1,12 +1,11 @@
-:mod:`SocketServer` --- A framework for network servers
+:mod:`socketserver` --- A framework for network servers
=======================================================
-.. module:: SocketServer
+.. module:: socketserver
:synopsis: A framework for network servers.
-
-The :mod:`SocketServer` module simplifies the task of writing network servers.
+The :mod:`socketserver` module simplifies the task of writing network servers.
There are four basic server classes: :class:`TCPServer` uses the Internet TCP
protocol, which provides for continuous streams of data between the client and
@@ -213,7 +212,7 @@
users of the server object.
.. XXX should the default implementations of these be documented, or should
- it be assumed that the user will look at SocketServer.py?
+ it be assumed that the user will look at socketserver.py?
.. function:: finish_request()
Modified: python/branches/py3k/Lib/BaseHTTPServer.py
==============================================================================
--- python/branches/py3k/Lib/BaseHTTPServer.py (original)
+++ python/branches/py3k/Lib/BaseHTTPServer.py Mon May 12 04:31:37 2008
@@ -75,7 +75,7 @@
import time
import socket # For gethostbyaddr()
import mimetools
-import SocketServer
+import socketserver
# Default error message template
DEFAULT_ERROR_MESSAGE = """\
@@ -95,19 +95,19 @@
def _quote_html(html):
return html.replace("&", "&").replace("<", "<").replace(">", ">")
-class HTTPServer(SocketServer.TCPServer):
+class HTTPServer(socketserver.TCPServer):
allow_reuse_address = 1 # Seems to make sense in testing environment
def server_bind(self):
"""Override server_bind to store the server name."""
- SocketServer.TCPServer.server_bind(self)
+ socketserver.TCPServer.server_bind(self)
host, port = self.socket.getsockname()[:2]
self.server_name = socket.getfqdn(host)
self.server_port = port
-class BaseHTTPRequestHandler(SocketServer.StreamRequestHandler):
+class BaseHTTPRequestHandler(socketserver.StreamRequestHandler):
"""HTTP request handler base class.
Modified: python/branches/py3k/Lib/SimpleXMLRPCServer.py
==============================================================================
--- python/branches/py3k/Lib/SimpleXMLRPCServer.py (original)
+++ python/branches/py3k/Lib/SimpleXMLRPCServer.py Mon May 12 04:31:37 2008
@@ -100,7 +100,7 @@
import xmlrpclib
from xmlrpclib import Fault
-import SocketServer
+import socketserver
import BaseHTTPServer
import sys
import os
@@ -494,7 +494,7 @@
if self.server.logRequests:
BaseHTTPServer.BaseHTTPRequestHandler.log_request(self, code, size)
-class SimpleXMLRPCServer(SocketServer.TCPServer,
+class SimpleXMLRPCServer(socketserver.TCPServer,
SimpleXMLRPCDispatcher):
"""Simple XML-RPC server.
@@ -518,7 +518,7 @@
self.logRequests = logRequests
SimpleXMLRPCDispatcher.__init__(self, allow_none, encoding)
- SocketServer.TCPServer.__init__(self, addr, requestHandler, bind_and_activate)
+ socketserver.TCPServer.__init__(self, addr, requestHandler, bind_and_activate)
# [Bug #1222790] If possible, set close-on-exec flag; if a
# method spawns a subprocess, the subprocess shouldn't have
Deleted: python/branches/py3k/Lib/SocketServer.py
==============================================================================
--- python/branches/py3k/Lib/SocketServer.py Mon May 12 04:31:37 2008
+++ (empty file)
@@ -1,675 +0,0 @@
-"""Generic socket server classes.
-
-This module tries to capture the various aspects of defining a server:
-
-For socket-based servers:
-
-- address family:
- - AF_INET{,6}: IP (Internet Protocol) sockets (default)
- - AF_UNIX: Unix domain sockets
- - others, e.g. AF_DECNET are conceivable (see <socket.h>
-- socket type:
- - SOCK_STREAM (reliable stream, e.g. TCP)
- - SOCK_DGRAM (datagrams, e.g. UDP)
-
-For request-based servers (including socket-based):
-
-- client address verification before further looking at the request
- (This is actually a hook for any processing that needs to look
- at the request before anything else, e.g. logging)
-- how to handle multiple requests:
- - synchronous (one request is handled at a time)
- - forking (each request is handled by a new process)
- - threading (each request is handled by a new thread)
-
-The classes in this module favor the server type that is simplest to
-write: a synchronous TCP/IP server. This is bad class design, but
-save some typing. (There's also the issue that a deep class hierarchy
-slows down method lookups.)
-
-There are five classes in an inheritance diagram, four of which represent
-synchronous servers of four types:
-
- +------------+
- | BaseServer |
- +------------+
- |
- v
- +-----------+ +------------------+
- | TCPServer |------->| UnixStreamServer |
- +-----------+ +------------------+
- |
- v
- +-----------+ +--------------------+
- | UDPServer |------->| UnixDatagramServer |
- +-----------+ +--------------------+
-
-Note that UnixDatagramServer derives from UDPServer, not from
-UnixStreamServer -- the only difference between an IP and a Unix
-stream server is the address family, which is simply repeated in both
-unix server classes.
-
-Forking and threading versions of each type of server can be created
-using the ForkingMixIn and ThreadingMixIn mix-in classes. For
-instance, a threading UDP server class is created as follows:
-
- class ThreadingUDPServer(ThreadingMixIn, UDPServer): pass
-
-The Mix-in class must come first, since it overrides a method defined
-in UDPServer! Setting the various member variables also changes
-the behavior of the underlying server mechanism.
-
-To implement a service, you must derive a class from
-BaseRequestHandler and redefine its 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 request handler
-subclasses StreamRequestHandler or DatagramRequestHandler.
-
-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 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 avoid two requests that come in nearly simultaneous to apply
-conflicting changes to the server state.
-
-On the other hand, if you are building e.g. an HTTP server, where all
-data is stored externally (e.g. 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 reqd all the data it has requested. Here a threading or forking
-server is appropriate.
-
-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
-handle() method.
-
-Another approach to handling multiple simultaneous requests in an
-environment that supports neither threads nor 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 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).
-
-Future work:
-- Standard classes for Sun RPC (which uses either UDP or TCP)
-- Standard mix-in classes to implement various authentication
- and encryption schemes
-- Standard framework for select-based multiplexing
-
-XXX Open problems:
-- What to do with out-of-band data?
-
-BaseServer:
-- split generic "request" functionality out into BaseServer class.
- Copyright (C) 2000 Luke Kenneth Casson Leighton <lkcl at samba.org>
-
- example: read entries from a SQL database (requires overriding
- get_request() to return a table entry from the database).
- entry is processed by a RequestHandlerClass.
-
-"""
-
-# Author of the BaseServer patch: Luke Kenneth Casson Leighton
-
-# XXX Warning!
-# There is a test suite for this module, but it cannot be run by the
-# standard regression test.
-# To run it manually, run Lib/test/test_socketserver.py.
-
-__version__ = "0.4"
-
-
-import socket
-import select
-import sys
-import os
-try:
- import threading
-except ImportError:
- import dummy_threading as threading
-
-__all__ = ["TCPServer","UDPServer","ForkingUDPServer","ForkingTCPServer",
- "ThreadingUDPServer","ThreadingTCPServer","BaseRequestHandler",
- "StreamRequestHandler","DatagramRequestHandler",
- "ThreadingMixIn", "ForkingMixIn"]
-if hasattr(socket, "AF_UNIX"):
- __all__.extend(["UnixStreamServer","UnixDatagramServer",
- "ThreadingUnixStreamServer",
- "ThreadingUnixDatagramServer"])
-
-class BaseServer:
-
- """Base class for server classes.
-
- Methods for the caller:
-
- - __init__(server_address, RequestHandlerClass)
- - serve_forever(poll_interval=0.5)
- - shutdown()
- - handle_request() # if you do not use serve_forever()
- - fileno() -> int # for select()
-
- Methods that may be overridden:
-
- - server_bind()
- - server_activate()
- - get_request() -> request, client_address
- - handle_timeout()
- - verify_request(request, client_address)
- - server_close()
- - process_request(request, client_address)
- - close_request(request)
- - handle_error()
-
- Methods for derived classes:
-
- - finish_request(request, client_address)
-
- Class variables that may be overridden by derived classes or
- instances:
-
- - timeout
- - address_family
- - socket_type
- - allow_reuse_address
-
- Instance variables:
-
- - RequestHandlerClass
- - socket
-
- """
-
- timeout = None
-
- def __init__(self, server_address, RequestHandlerClass):
- """Constructor. May be extended, do not override."""
- self.server_address = server_address
- self.RequestHandlerClass = RequestHandlerClass
- self.__is_shut_down = threading.Event()
- self.__serving = False
-
- def server_activate(self):
- """Called by constructor to activate the server.
-
- May be overridden.
-
- """
- pass
-
- def serve_forever(self, poll_interval=0.5):
- """Handle one request at a time until shutdown.
-
- Polls for shutdown every poll_interval seconds. Ignores
- self.timeout. If you need to do periodic tasks, do them in
- another thread.
- """
- self.__serving = True
- self.__is_shut_down.clear()
- while self.__serving:
- # XXX: Consider using another file descriptor or
- # connecting to the socket to wake this up instead of
- # polling. Polling reduces our responsiveness to a
- # shutdown request and wastes cpu at all other times.
- r, w, e = select.select([self], [], [], poll_interval)
- if r:
- self._handle_request_noblock()
- self.__is_shut_down.set()
-
- def shutdown(self):
- """Stops the serve_forever loop.
-
- Blocks until the loop has finished. This must be called while
- serve_forever() is running in another thread, or it will
- deadlock.
- """
- self.__serving = False
- self.__is_shut_down.wait()
-
- # The distinction between handling, getting, processing and
- # finishing a request is fairly arbitrary. Remember:
- #
- # - handle_request() is the top-level call. It calls
- # select, get_request(), verify_request() and process_request()
- # - get_request() is different for stream or datagram sockets
- # - process_request() is the place that may fork a new process
- # or create a new thread to finish the request
- # - finish_request() instantiates the request handler class;
- # this constructor will handle the request all by itself
-
- def handle_request(self):
- """Handle one request, possibly blocking.
-
- Respects self.timeout.
- """
- # Support people who used socket.settimeout() to escape
- # handle_request before self.timeout was available.
- timeout = self.socket.gettimeout()
- if timeout is None:
- timeout = self.timeout
- elif self.timeout is not None:
- timeout = min(timeout, self.timeout)
- fd_sets = select.select([self], [], [], timeout)
- if not fd_sets[0]:
- self.handle_timeout()
- return
- self._handle_request_noblock()
-
- def _handle_request_noblock(self):
- """Handle one request, without blocking.
-
- I assume that select.select has returned that the socket is
- readable before this function was called, so there should be
- no risk of blocking in get_request().
- """
- try:
- request, client_address = self.get_request()
- except socket.error:
- return
- if self.verify_request(request, client_address):
- try:
- self.process_request(request, client_address)
- except:
- self.handle_error(request, client_address)
- self.close_request(request)
-
- def handle_timeout(self):
- """Called if no new request arrives within self.timeout.
-
- Overridden by ForkingMixIn.
- """
- pass
-
- def verify_request(self, request, client_address):
- """Verify the request. May be overridden.
-
- Return True if we should proceed with this request.
-
- """
- return True
-
- def process_request(self, request, client_address):
- """Call finish_request.
-
- Overridden by ForkingMixIn and ThreadingMixIn.
-
- """
- self.finish_request(request, client_address)
- self.close_request(request)
-
- def server_close(self):
- """Called to clean-up the server.
-
- May be overridden.
-
- """
- pass
-
- def finish_request(self, request, client_address):
- """Finish one request by instantiating RequestHandlerClass."""
- self.RequestHandlerClass(request, client_address, self)
-
- def close_request(self, request):
- """Called to clean up an individual request."""
- pass
-
- def handle_error(self, request, client_address):
- """Handle an error gracefully. May be overridden.
-
- The default is to print a traceback and continue.
-
- """
- print('-'*40)
- print('Exception happened during processing of request from', end=' ')
- print(client_address)
- import traceback
- traceback.print_exc() # XXX But this goes to stderr!
- print('-'*40)
-
-
-class TCPServer(BaseServer):
-
- """Base class for various socket-based server classes.
-
- Defaults to synchronous IP stream (i.e., TCP).
-
- Methods for the caller:
-
- - __init__(server_address, RequestHandlerClass, bind_and_activate=True)
- - serve_forever(poll_interval=0.5)
- - shutdown()
- - handle_request() # if you don't use serve_forever()
- - fileno() -> int # for select()
-
- Methods that may be overridden:
-
- - server_bind()
- - server_activate()
- - get_request() -> request, client_address
- - handle_timeout()
- - verify_request(request, client_address)
- - process_request(request, client_address)
- - close_request(request)
- - handle_error()
-
- Methods for derived classes:
-
- - finish_request(request, client_address)
-
- Class variables that may be overridden by derived classes or
- instances:
-
- - timeout
- - address_family
- - socket_type
- - request_queue_size (only for stream sockets)
- - allow_reuse_address
-
- Instance variables:
-
- - server_address
- - RequestHandlerClass
- - socket
-
- """
-
- address_family = socket.AF_INET
-
- socket_type = socket.SOCK_STREAM
-
- request_queue_size = 5
-
- allow_reuse_address = False
-
- def __init__(self, server_address, RequestHandlerClass, bind_and_activate=True):
- """Constructor. May be extended, do not override."""
- BaseServer.__init__(self, server_address, RequestHandlerClass)
- self.socket = socket.socket(self.address_family,
- self.socket_type)
- if bind_and_activate:
- self.server_bind()
- self.server_activate()
-
- def server_bind(self):
- """Called by constructor to bind the socket.
-
- May be overridden.
-
- """
- if self.allow_reuse_address:
- self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
- self.socket.bind(self.server_address)
- self.server_address = self.socket.getsockname()
-
- def server_activate(self):
- """Called by constructor to activate the server.
-
- May be overridden.
-
- """
- self.socket.listen(self.request_queue_size)
-
- def server_close(self):
- """Called to clean-up the server.
-
- May be overridden.
-
- """
- self.socket.close()
-
- def fileno(self):
- """Return socket file number.
-
- Interface required by select().
-
- """
- return self.socket.fileno()
-
- def get_request(self):
- """Get the request and client address from the socket.
-
- May be overridden.
-
- """
- return self.socket.accept()
-
- def close_request(self, request):
- """Called to clean up an individual request."""
- request.close()
-
-
-class UDPServer(TCPServer):
-
- """UDP server class."""
-
- allow_reuse_address = False
-
- socket_type = socket.SOCK_DGRAM
-
- max_packet_size = 8192
-
- def get_request(self):
- data, client_addr = self.socket.recvfrom(self.max_packet_size)
- return (data, self.socket), client_addr
-
- def server_activate(self):
- # No need to call listen() for UDP.
- pass
-
- def close_request(self, request):
- # No need to close anything.
- pass
-
-class ForkingMixIn:
-
- """Mix-in class to handle each request in a new process."""
-
- timeout = 300
- active_children = None
- max_children = 40
-
- def collect_children(self):
- """Internal routine to wait for children that have exited."""
- if self.active_children is None: return
- while len(self.active_children) >= self.max_children:
- # XXX: This will wait for any child process, not just ones
- # spawned by this library. This could confuse other
- # libraries that expect to be able to wait for their own
- # children.
- try:
- pid, status = os.waitpid(0, options=0)
- except os.error:
- pid = None
- if pid not in self.active_children: continue
- self.active_children.remove(pid)
-
- # XXX: This loop runs more system calls than it ought
- # to. There should be a way to put the active_children into a
- # process group and then use os.waitpid(-pgid) to wait for any
- # of that set, but I couldn't find a way to allocate pgids
- # that couldn't collide.
- for child in self.active_children:
- try:
- pid, status = os.waitpid(child, os.WNOHANG)
- except os.error:
- pid = None
- if not pid: continue
- try:
- self.active_children.remove(pid)
- except ValueError as e:
- raise ValueError('%s. x=%d and list=%r' % (e.message, pid,
- self.active_children))
-
- def handle_timeout(self):
- """Wait for zombies after self.timeout seconds of inactivity.
-
- May be extended, do not override.
- """
- self.collect_children()
-
- def process_request(self, request, client_address):
- """Fork a new subprocess to process the request."""
- self.collect_children()
- pid = os.fork()
- if pid:
- # Parent process
- if self.active_children is None:
- self.active_children = []
- self.active_children.append(pid)
- self.close_request(request)
- return
- else:
- # Child process.
- # This must never return, hence os._exit()!
- try:
- self.finish_request(request, client_address)
- os._exit(0)
- except:
- try:
- self.handle_error(request, client_address)
- finally:
- os._exit(1)
-
-
-class ThreadingMixIn:
- """Mix-in class to handle each request in a new thread."""
-
- # Decides how threads will act upon termination of the
- # main process
- daemon_threads = False
-
- def process_request_thread(self, request, client_address):
- """Same as in BaseServer but as a thread.
-
- In addition, exception handling is done here.
-
- """
- try:
- self.finish_request(request, client_address)
- self.close_request(request)
- except:
- self.handle_error(request, client_address)
- self.close_request(request)
-
- def process_request(self, request, client_address):
- """Start a new thread to process the request."""
- t = threading.Thread(target = self.process_request_thread,
- args = (request, client_address))
- if self.daemon_threads:
- t.setDaemon (1)
- t.start()
-
-
-class ForkingUDPServer(ForkingMixIn, UDPServer): pass
-class ForkingTCPServer(ForkingMixIn, TCPServer): pass
-
-class ThreadingUDPServer(ThreadingMixIn, UDPServer): pass
-class ThreadingTCPServer(ThreadingMixIn, TCPServer): pass
-
-if hasattr(socket, 'AF_UNIX'):
-
- class UnixStreamServer(TCPServer):
- address_family = socket.AF_UNIX
-
- class UnixDatagramServer(UDPServer):
- address_family = socket.AF_UNIX
-
- class ThreadingUnixStreamServer(ThreadingMixIn, UnixStreamServer): pass
-
- class ThreadingUnixDatagramServer(ThreadingMixIn, UnixDatagramServer): pass
-
-class BaseRequestHandler:
-
- """Base class for request handler classes.
-
- This class is instantiated for each request to be handled. The
- constructor sets the instance variables request, client_address
- and server, and then calls the handle() method. To implement a
- specific service, all you need to do is to derive a class which
- defines a handle() method.
-
- The handle() method can find the request as self.request, the
- client address as self.client_address, and the server (in case it
- needs access to per-server information) as self.server. Since a
- separate instance is created for each request, the handle() method
- can define arbitrary other instance variariables.
-
- """
-
- def __init__(self, request, client_address, server):
- self.request = request
- self.client_address = client_address
- self.server = server
- self.setup()
- self.handle()
- self.finish()
-
- def setup(self):
- pass
-
- def handle(self):
- pass
-
- def finish(self):
- pass
-
-
-# The following two classes make it possible to use the same service
-# class for stream or datagram servers.
-# Each class sets up these instance variables:
-# - rfile: a file object from which receives the request is read
-# - wfile: a file object to which the reply is written
-# When the handle() method returns, wfile is flushed properly
-
-
-class StreamRequestHandler(BaseRequestHandler):
-
- """Define self.rfile and self.wfile for stream sockets."""
-
- # Default buffer sizes for rfile, wfile.
- # We default rfile to buffered because otherwise it could be
- # really slow for large data (a getc() call per byte); we make
- # wfile unbuffered because (a) often after a write() we want to
- # read and we need to flush the line; (b) big writes to unbuffered
- # files are typically optimized by stdio even when big reads
- # aren't.
- rbufsize = -1
- wbufsize = 0
-
- def setup(self):
- self.connection = self.request
- self.rfile = self.connection.makefile('rb', self.rbufsize)
- self.wfile = self.connection.makefile('wb', self.wbufsize)
-
- def finish(self):
- if not self.wfile.closed:
- self.wfile.flush()
- self.wfile.close()
- self.rfile.close()
-
-
-class DatagramRequestHandler(BaseRequestHandler):
-
- # XXX Regrettably, I cannot get this working on Linux;
- # s.recvfrom() doesn't return a meaningful client address.
-
- """Define self.rfile and self.wfile for datagram sockets."""
-
- def setup(self):
- from io import BytesIO
- self.packet, self.socket = self.request
- self.rfile = BytesIO(self.packet)
- self.wfile = BytesIO()
-
- def finish(self):
- self.socket.sendto(self.wfile.getvalue(), self.client_address)
Modified: python/branches/py3k/Lib/idlelib/rpc.py
==============================================================================
--- python/branches/py3k/Lib/idlelib/rpc.py (original)
+++ python/branches/py3k/Lib/idlelib/rpc.py Mon May 12 04:31:37 2008
@@ -5,7 +5,7 @@
has only one client per server, this was not a limitation.
+---------------------------------+ +-------------+
- | SocketServer.BaseRequestHandler | | SocketIO |
+ | socketserver.BaseRequestHandler | | SocketIO |
+---------------------------------+ +-------------+
^ | register() |
| | unregister()|
@@ -31,7 +31,7 @@
import os
import socket
import select
-import SocketServer
+import socketserver
import struct
import pickle
import threading
@@ -66,12 +66,12 @@
BUFSIZE = 8*1024
LOCALHOST = '127.0.0.1'
-class RPCServer(SocketServer.TCPServer):
+class RPCServer(socketserver.TCPServer):
def __init__(self, addr, handlerclass=None):
if handlerclass is None:
handlerclass = RPCHandler
- SocketServer.TCPServer.__init__(self, addr, handlerclass)
+ socketserver.TCPServer.__init__(self, addr, handlerclass)
def server_bind(self):
"Override TCPServer method, no bind() phase for connecting entity"
@@ -492,7 +492,7 @@
def __init__(self, oid):
self.oid = oid
-class RPCHandler(SocketServer.BaseRequestHandler, SocketIO):
+class RPCHandler(socketserver.BaseRequestHandler, SocketIO):
debugging = False
location = "#S" # Server
@@ -500,10 +500,10 @@
def __init__(self, sock, addr, svr):
svr.current_handler = self ## cgt xxx
SocketIO.__init__(self, sock)
- SocketServer.BaseRequestHandler.__init__(self, sock, addr, svr)
+ socketserver.BaseRequestHandler.__init__(self, sock, addr, svr)
def handle(self):
- "handle() method required by SocketServer"
+ "handle() method required by socketserver"
self.mainloop()
def get_remote_proxy(self, oid):
Modified: python/branches/py3k/Lib/logging/config.py
==============================================================================
--- python/branches/py3k/Lib/logging/config.py (original)
+++ python/branches/py3k/Lib/logging/config.py Mon May 12 04:31:37 2008
@@ -32,7 +32,7 @@
except ImportError:
thread = None
-from SocketServer import ThreadingTCPServer, StreamRequestHandler
+from socketserver import ThreadingTCPServer, StreamRequestHandler
DEFAULT_LOGGING_CONFIG_PORT = 9030
Modified: python/branches/py3k/Lib/test/test___all__.py
==============================================================================
--- python/branches/py3k/Lib/test/test___all__.py (original)
+++ python/branches/py3k/Lib/test/test___all__.py Mon May 12 04:31:37 2008
@@ -38,7 +38,7 @@
self.check_all("Cookie")
self.check_all("Queue")
self.check_all("SimpleHTTPServer")
- self.check_all("SocketServer")
+ self.check_all("socketserver")
self.check_all("aifc")
self.check_all("base64")
self.check_all("bdb")
Modified: python/branches/py3k/Lib/test/test_logging.py
==============================================================================
--- python/branches/py3k/Lib/test/test_logging.py (original)
+++ python/branches/py3k/Lib/test/test_logging.py Mon May 12 04:31:37 2008
@@ -33,7 +33,7 @@
import re
import select
import socket
-from SocketServer import ThreadingTCPServer, StreamRequestHandler
+from socketserver import ThreadingTCPServer, StreamRequestHandler
import string
import struct
import sys
Modified: python/branches/py3k/Lib/test/test_socketserver.py
==============================================================================
--- python/branches/py3k/Lib/test/test_socketserver.py (original)
+++ python/branches/py3k/Lib/test/test_socketserver.py Mon May 12 04:31:37 2008
@@ -1,5 +1,5 @@
"""
-Test suite for SocketServer.py.
+Test suite for socketserver.
"""
import contextlib
@@ -13,7 +13,7 @@
import threading
import time
import unittest
-import SocketServer
+import socketserver
import test.test_support
from test.test_support import reap_children, verbose, TestSkipped
@@ -40,12 +40,12 @@
raise RuntimeError("timed out on %r" % (sock,))
if HAVE_UNIX_SOCKETS:
- class ForkingUnixStreamServer(SocketServer.ForkingMixIn,
- SocketServer.UnixStreamServer):
+ class ForkingUnixStreamServer(socketserver.ForkingMixIn,
+ socketserver.UnixStreamServer):
pass
- class ForkingUnixDatagramServer(SocketServer.ForkingMixIn,
- SocketServer.UnixDatagramServer):
+ class ForkingUnixDatagramServer(socketserver.ForkingMixIn,
+ socketserver.UnixDatagramServer):
pass
@@ -172,55 +172,55 @@
s.close()
def test_TCPServer(self):
- self.run_server(SocketServer.TCPServer,
- SocketServer.StreamRequestHandler,
+ self.run_server(socketserver.TCPServer,
+ socketserver.StreamRequestHandler,
self.stream_examine)
def test_ThreadingTCPServer(self):
- self.run_server(SocketServer.ThreadingTCPServer,
- SocketServer.StreamRequestHandler,
+ self.run_server(socketserver.ThreadingTCPServer,
+ socketserver.StreamRequestHandler,
self.stream_examine)
if HAVE_FORKING:
def test_ForkingTCPServer(self):
with simple_subprocess(self):
- self.run_server(SocketServer.ForkingTCPServer,
- SocketServer.StreamRequestHandler,
+ self.run_server(socketserver.ForkingTCPServer,
+ socketserver.StreamRequestHandler,
self.stream_examine)
if HAVE_UNIX_SOCKETS:
def test_UnixStreamServer(self):
- self.run_server(SocketServer.UnixStreamServer,
- SocketServer.StreamRequestHandler,
+ self.run_server(socketserver.UnixStreamServer,
+ socketserver.StreamRequestHandler,
self.stream_examine)
def test_ThreadingUnixStreamServer(self):
- self.run_server(SocketServer.ThreadingUnixStreamServer,
- SocketServer.StreamRequestHandler,
+ self.run_server(socketserver.ThreadingUnixStreamServer,
+ socketserver.StreamRequestHandler,
self.stream_examine)
if HAVE_FORKING:
def test_ForkingUnixStreamServer(self):
with simple_subprocess(self):
self.run_server(ForkingUnixStreamServer,
- SocketServer.StreamRequestHandler,
+ socketserver.StreamRequestHandler,
self.stream_examine)
def test_UDPServer(self):
- self.run_server(SocketServer.UDPServer,
- SocketServer.DatagramRequestHandler,
+ self.run_server(socketserver.UDPServer,
+ socketserver.DatagramRequestHandler,
self.dgram_examine)
def test_ThreadingUDPServer(self):
- self.run_server(SocketServer.ThreadingUDPServer,
- SocketServer.DatagramRequestHandler,
+ self.run_server(socketserver.ThreadingUDPServer,
+ socketserver.DatagramRequestHandler,
self.dgram_examine)
if HAVE_FORKING:
def test_ForkingUDPServer(self):
with simple_subprocess(self):
- self.run_server(SocketServer.ForkingUDPServer,
- SocketServer.DatagramRequestHandler,
+ self.run_server(socketserver.ForkingUDPServer,
+ socketserver.DatagramRequestHandler,
self.dgram_examine)
# Alas, on Linux (at least) recvfrom() doesn't return a meaningful
@@ -228,19 +228,19 @@
# if HAVE_UNIX_SOCKETS:
# def test_UnixDatagramServer(self):
- # self.run_server(SocketServer.UnixDatagramServer,
- # SocketServer.DatagramRequestHandler,
+ # self.run_server(socketserver.UnixDatagramServer,
+ # socketserver.DatagramRequestHandler,
# self.dgram_examine)
#
# def test_ThreadingUnixDatagramServer(self):
- # self.run_server(SocketServer.ThreadingUnixDatagramServer,
- # SocketServer.DatagramRequestHandler,
+ # self.run_server(socketserver.ThreadingUnixDatagramServer,
+ # socketserver.DatagramRequestHandler,
# self.dgram_examine)
#
# if HAVE_FORKING:
# def test_ForkingUnixDatagramServer(self):
- # self.run_server(SocketServer.ForkingUnixDatagramServer,
- # SocketServer.DatagramRequestHandler,
+ # self.run_server(socketserver.ForkingUnixDatagramServer,
+ # socketserver.DatagramRequestHandler,
# self.dgram_examine)
Modified: python/branches/py3k/Lib/test/test_wsgiref.py
==============================================================================
--- python/branches/py3k/Lib/test/test_wsgiref.py (original)
+++ python/branches/py3k/Lib/test/test_wsgiref.py Mon May 12 04:31:37 2008
@@ -8,7 +8,7 @@
from wsgiref.simple_server import WSGIServer, WSGIRequestHandler, demo_app
from wsgiref.simple_server import make_server
from io import StringIO, BytesIO, BufferedReader
-from SocketServer import BaseServer
+from socketserver import BaseServer
import re, sys
from test import test_support
Modified: python/branches/py3k/Misc/NEWS
==============================================================================
--- python/branches/py3k/Misc/NEWS (original)
+++ python/branches/py3k/Misc/NEWS Mon May 12 04:31:37 2008
@@ -21,6 +21,8 @@
Library
-------
+- The SocketServer module has been renamed to socketserver.
+
- Fix the __all__ setting on 'collections' to include UserList and UserString.
- The sre module has been removed.
Modified: python/branches/py3k/Misc/cheatsheet
==============================================================================
--- python/branches/py3k/Misc/cheatsheet (original)
+++ python/branches/py3k/Misc/cheatsheet Mon May 12 04:31:37 2008
@@ -1919,7 +1919,7 @@
sys.path.
smtplib SMTP Client class (RFC 821)
sndhdr Several routines that help recognizing sound.
-SocketServer Generic socket server classes.
+socketserver Generic socket server classes.
stat Constants and functions for interpreting stat/lstat struct.
statvfs Constants for interpreting statvfs struct as returned by
os.statvfs()and os.fstatvfs() (if they exist).
@@ -2211,5 +2211,3 @@
after editing, any remembered breakpoints are likely to be wrong.
Always single-steps through top-most stack frame. That is, "c" acts like "n".
-
-
More information about the Python-3000-checkins
mailing list