Mirror
/
cpython
mirror of https://github.com/python/cpython
4
1
Fork 0
Code Issues Releases Wiki Activity

Updated all import statements to use the new socketserver module name. 

Renamed socketserver module in its own documentation.
Renamed documentation references.
This commit is contained in:
Alexandre Vassalotti 2008-05-12 02:11:22 +00:00
parent fb9ce65a91
commit d192c925ac
14 changed files with 61 additions and 64 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Doc/library/basehttpserver.rst
View File

@ -21,7 +21,7 @@ Usually, this module isn't used directly, but is used as a basis for building
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::

10
Doc/library/logging.rst
View File

@ -1299,17 +1299,17 @@ the receiving end. A simple way of doing this is attaching a
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
@ -1351,7 +1351,7 @@ module. Here is a basic working example::
# cycles and network bandwidth!
logger.handle(record)
class LogRecordSocketReceiver(SocketServer.ThreadingTCPServer):
class LogRecordSocketReceiver(socketserver.ThreadingTCPServer):
"""simple TCP socket-based logging receiver suitable for testing.
"""
@ -1360,7 +1360,7 @@ module. Here is a basic working example::
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

4
Doc/library/simplexmlrpcserver.rst
View File

@ -22,7 +22,7 @@ XML-RPC servers written in Python. Servers can either be free standing, using
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
@ -63,7 +63,7 @@ SimpleXMLRPCServer Objects
--------------------------
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.

2
Doc/library/socket.rst
View File

@ -481,7 +481,7 @@ The module :mod:`socket` exports the following constants and functions:
.. seealso::
Module :mod:`SocketServer`
Module :mod:`socketserver`
Classes that simplify writing network servers.

9
Doc/library/socketserver.rst
View File

@ -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 @@ server classes like :class:`TCPServer`; these methods aren't useful to external
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()

8
Lib/BaseHTTPServer.py
View File

@ -74,7 +74,7 @@ import sys
import time
import socket # For gethostbyaddr()
import mimetools
import SocketServer
import socketserver
# Default error message template
DEFAULT_ERROR_MESSAGE = """\
@ -94,19 +94,19 @@ DEFAULT_ERROR_CONTENT_TYPE = "text/html"
def _quote_html(html):
return html.replace("&", "&amp;").replace("<", "&lt;").replace(">", "&gt;")
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.

6
Lib/SimpleXMLRPCServer.py
View File

@ -101,7 +101,7 @@ server.handle_request()
import xmlrpclib
from xmlrpclib import Fault
import SocketServer
import socketserver
import BaseHTTPServer
import sys
import os
@ -512,7 +512,7 @@ class SimpleXMLRPCRequestHandler(BaseHTTPServer.BaseHTTPRequestHandler):
if self.server.logRequests:
BaseHTTPServer.BaseHTTPRequestHandler.log_request(self, code, size)
class SimpleXMLRPCServer(SocketServer.TCPServer,
class SimpleXMLRPCServer(socketserver.TCPServer,
SimpleXMLRPCDispatcher):
"""Simple XML-RPC server.
@ -536,7 +536,7 @@ class SimpleXMLRPCServer(SocketServer.TCPServer,
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

14
Lib/idlelib/rpc.py
View File

@ -5,7 +5,7 @@ connect to the Idle process, which listens for the connection. Since Idle has
has only one client per server, this was not a limitation.
+---------------------------------+ +-------------+
| SocketServer.BaseRequestHandler | | SocketIO |
| socketserver.BaseRequestHandler | | SocketIO |
+---------------------------------+ +-------------+
^ | register() |
| | unregister()|
@ -31,7 +31,7 @@ import sys
import os
import socket
import select
import SocketServer
import socketserver
import struct
import cPickle as pickle
import threading
@ -66,12 +66,12 @@ copyreg.pickle(types.CodeType, pickle_code, unpickle_code)
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 @@ class RemoteProxy(object):
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 @@ class RPCHandler(SocketServer.BaseRequestHandler, SocketIO):
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):

2
Lib/logging/config.py
View File

@ -35,7 +35,7 @@ try:
except ImportError:
thread = None
from SocketServer import ThreadingTCPServer, StreamRequestHandler
from socketserver import ThreadingTCPServer, StreamRequestHandler
DEFAULT_LOGGING_CONFIG_PORT = 9030

2
Lib/test/test___all__.py
View File

@ -42,7 +42,7 @@ class AllTest(unittest.TestCase):
self.check_all("MimeWriter")
self.check_all("Queue")
self.check_all("SimpleHTTPServer")
self.check_all("SocketServer")
self.check_all("socketserver")
self.check_all("StringIO")
self.check_all("UserString")
self.check_all("aifc")

2
Lib/test/test_logging.py
View File

@ -33,7 +33,7 @@ import os
import re
import select
import socket
from SocketServer import ThreadingTCPServer, StreamRequestHandler
from socketserver import ThreadingTCPServer, StreamRequestHandler
import string
import struct
import sys

58
Lib/test/test_socketserver.py
View File

@ -1,5 +1,5 @@
"""
Test suite for SocketServer.py.
Test suite for socketserver.
"""
import contextlib
@ -13,7 +13,7 @@ import tempfile
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 @@ def receive(sock, n, timeout=20):
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 @@ class SocketServerTest(unittest.TestCase):
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 @@ class SocketServerTest(unittest.TestCase):
# 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)

2
Lib/test/test_wsgiref.py
View File

@ -8,7 +8,7 @@ from wsgiref.validate import validator
from wsgiref.simple_server import WSGIServer, WSGIRequestHandler, demo_app
from wsgiref.simple_server import make_server
from StringIO import StringIO
from SocketServer import BaseServer
from socketserver import BaseServer
import re, sys
from test import test_support

4
Misc/cheatsheet
View File

@ -1973,7 +1973,7 @@ site Append module search paths for third-party packages to
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.
statcache Maintain a cache of file stats.
statvfs Constants for interpreting statvfs struct as returned by
@ -2271,5 +2271,3 @@ Breakpoints are stored as filename, line number tuples. If a module is reloaded
after editing, any remembered breakpoints are likely to be wrong.
Always single-steps through top-most stack frame. That is, "c" acts like "n".