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 functioning Web servers. See the :mod:`SimpleHTTPServer` and
:mod:`CGIHTTPServer` modules. :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 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:: 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.warning('Jail zesty vixen who grabbed pay from quack.')
logger2.error('The five boxing wizards jump quickly.') 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:: module. Here is a basic working example::
import cPickle import cPickle
import logging import logging
import logging.handlers import logging.handlers
import SocketServer import socketserver
import struct import struct
class LogRecordStreamHandler(SocketServer.StreamRequestHandler): class LogRecordStreamHandler(socketserver.StreamRequestHandler):
"""Handler for a streaming logging request. """Handler for a streaming logging request.
This basically logs the record using whatever logging policy is 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! # cycles and network bandwidth!
logger.handle(record) logger.handle(record)
class LogRecordSocketReceiver(SocketServer.ThreadingTCPServer): class LogRecordSocketReceiver(socketserver.ThreadingTCPServer):
"""simple TCP socket-based logging receiver suitable for testing. """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', def __init__(self, host='localhost',
port=logging.handlers.DEFAULT_TCP_LOGGING_PORT, port=logging.handlers.DEFAULT_TCP_LOGGING_PORT,
handler=LogRecordStreamHandler): handler=LogRecordStreamHandler):
SocketServer.ThreadingTCPServer.__init__(self, (host, port), handler) socketserver.ThreadingTCPServer.__init__(self, (host, port), handler)
self.abort = 0 self.abort = 0
self.timeout = 1 self.timeout = 1
self.logname = None 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* functions that can be called by the XML-RPC protocol. The *requestHandler*
parameter should be a factory for request handler instances; it defaults to parameter should be a factory for request handler instances; it defaults to
:class:`SimpleXMLRPCRequestHandler`. The *addr* and *requestHandler* parameters :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 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 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 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 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. 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:: .. seealso::
Module :mod:`SocketServer` Module :mod:`socketserver`
Classes that simplify writing network servers. 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. :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 There are four basic server classes: :class:`TCPServer` uses the Internet TCP
protocol, which provides for continuous streams of data between the client and 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. users of the server object.
.. XXX should the default implementations of these be documented, or should .. 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() .. function:: finish_request()

8
Lib/BaseHTTPServer.py
View File

@ -74,7 +74,7 @@ import sys
import time import time
import socket # For gethostbyaddr() import socket # For gethostbyaddr()
import mimetools import mimetools
import SocketServer import socketserver
# Default error message template # Default error message template
DEFAULT_ERROR_MESSAGE = """\ DEFAULT_ERROR_MESSAGE = """\
@ -94,19 +94,19 @@ DEFAULT_ERROR_CONTENT_TYPE = "text/html"
def _quote_html(html): def _quote_html(html):
return html.replace("&", "&amp;").replace("<", "&lt;").replace(">", "&gt;") 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 allow_reuse_address = 1 # Seems to make sense in testing environment
def server_bind(self): def server_bind(self):
"""Override server_bind to store the server name.""" """Override server_bind to store the server name."""
SocketServer.TCPServer.server_bind(self) socketserver.TCPServer.server_bind(self)
host, port = self.socket.getsockname()[:2] host, port = self.socket.getsockname()[:2]
self.server_name = socket.getfqdn(host) self.server_name = socket.getfqdn(host)
self.server_port = port self.server_port = port
class BaseHTTPRequestHandler(SocketServer.StreamRequestHandler): class BaseHTTPRequestHandler(socketserver.StreamRequestHandler):
"""HTTP request handler base class. """HTTP request handler base class.

6
Lib/SimpleXMLRPCServer.py
View File

@ -101,7 +101,7 @@ server.handle_request()
import xmlrpclib import xmlrpclib
from xmlrpclib import Fault from xmlrpclib import Fault
import SocketServer import socketserver
import BaseHTTPServer import BaseHTTPServer
import sys import sys
import os import os
@ -512,7 +512,7 @@ class SimpleXMLRPCRequestHandler(BaseHTTPServer.BaseHTTPRequestHandler):
if self.server.logRequests: if self.server.logRequests:
BaseHTTPServer.BaseHTTPRequestHandler.log_request(self, code, size) BaseHTTPServer.BaseHTTPRequestHandler.log_request(self, code, size)
class SimpleXMLRPCServer(SocketServer.TCPServer, class SimpleXMLRPCServer(socketserver.TCPServer,
SimpleXMLRPCDispatcher): SimpleXMLRPCDispatcher):
"""Simple XML-RPC server. """Simple XML-RPC server.
@ -536,7 +536,7 @@ class SimpleXMLRPCServer(SocketServer.TCPServer,
self.logRequests = logRequests self.logRequests = logRequests
SimpleXMLRPCDispatcher.__init__(self, allow_none, encoding) 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 # [Bug #1222790] If possible, set close-on-exec flag; if a
# method spawns a subprocess, the subprocess shouldn't have # 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. has only one client per server, this was not a limitation.
+---------------------------------+ +-------------+ +---------------------------------+ +-------------+
| SocketServer.BaseRequestHandler | | SocketIO | | socketserver.BaseRequestHandler | | SocketIO |
+---------------------------------+ +-------------+ +---------------------------------+ +-------------+
^ | register() | ^ | register() |
| | unregister()| | | unregister()|
@ -31,7 +31,7 @@ import sys
import os import os
import socket import socket
import select import select
import SocketServer import socketserver
import struct import struct
import cPickle as pickle import cPickle as pickle
import threading import threading
@ -66,12 +66,12 @@ copyreg.pickle(types.CodeType, pickle_code, unpickle_code)
BUFSIZE = 8*1024 BUFSIZE = 8*1024
LOCALHOST = '127.0.0.1' LOCALHOST = '127.0.0.1'
class RPCServer(SocketServer.TCPServer): class RPCServer(socketserver.TCPServer):
def __init__(self, addr, handlerclass=None): def __init__(self, addr, handlerclass=None):
if handlerclass is None: if handlerclass is None:
handlerclass = RPCHandler handlerclass = RPCHandler
SocketServer.TCPServer.__init__(self, addr, handlerclass) socketserver.TCPServer.__init__(self, addr, handlerclass)
def server_bind(self): def server_bind(self):
"Override TCPServer method, no bind() phase for connecting entity" "Override TCPServer method, no bind() phase for connecting entity"
@ -492,7 +492,7 @@ class RemoteProxy(object):
def __init__(self, oid): def __init__(self, oid):
self.oid = oid self.oid = oid
class RPCHandler(SocketServer.BaseRequestHandler, SocketIO): class RPCHandler(socketserver.BaseRequestHandler, SocketIO):
debugging = False debugging = False
location = "#S" # Server location = "#S" # Server
@ -500,10 +500,10 @@ class RPCHandler(SocketServer.BaseRequestHandler, SocketIO):
def __init__(self, sock, addr, svr): def __init__(self, sock, addr, svr):
svr.current_handler = self ## cgt xxx svr.current_handler = self ## cgt xxx
SocketIO.__init__(self, sock) SocketIO.__init__(self, sock)
SocketServer.BaseRequestHandler.__init__(self, sock, addr, svr) socketserver.BaseRequestHandler.__init__(self, sock, addr, svr)
def handle(self): def handle(self):
"handle() method required by SocketServer" "handle() method required by socketserver"
self.mainloop() self.mainloop()
def get_remote_proxy(self, oid): def get_remote_proxy(self, oid):

2
Lib/logging/config.py
View File

@ -35,7 +35,7 @@ try:
except ImportError: except ImportError:
thread = None thread = None
from SocketServer import ThreadingTCPServer, StreamRequestHandler from socketserver import ThreadingTCPServer, StreamRequestHandler
DEFAULT_LOGGING_CONFIG_PORT = 9030 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("MimeWriter")
self.check_all("Queue") self.check_all("Queue")
self.check_all("SimpleHTTPServer") self.check_all("SimpleHTTPServer")
self.check_all("SocketServer") self.check_all("socketserver")
self.check_all("StringIO") self.check_all("StringIO")
self.check_all("UserString") self.check_all("UserString")
self.check_all("aifc") self.check_all("aifc")

2
Lib/test/test_logging.py
View File

@ -33,7 +33,7 @@ import os
import re import re
import select import select
import socket import socket
from SocketServer import ThreadingTCPServer, StreamRequestHandler from socketserver import ThreadingTCPServer, StreamRequestHandler
import string import string
import struct import struct
import sys 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 import contextlib
@ -13,7 +13,7 @@ import tempfile
import threading import threading
import time import time
import unittest import unittest
import SocketServer import socketserver
import test.test_support import test.test_support
from test.test_support import reap_children, verbose, TestSkipped 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,) raise RuntimeError, "timed out on %r" % (sock,)
if HAVE_UNIX_SOCKETS: if HAVE_UNIX_SOCKETS:
class ForkingUnixStreamServer(SocketServer.ForkingMixIn, class ForkingUnixStreamServer(socketserver.ForkingMixIn,
SocketServer.UnixStreamServer): socketserver.UnixStreamServer):
pass pass
class ForkingUnixDatagramServer(SocketServer.ForkingMixIn, class ForkingUnixDatagramServer(socketserver.ForkingMixIn,
SocketServer.UnixDatagramServer): socketserver.UnixDatagramServer):
pass pass
@ -172,55 +172,55 @@ class SocketServerTest(unittest.TestCase):
s.close() s.close()
def test_TCPServer(self): def test_TCPServer(self):
self.run_server(SocketServer.TCPServer, self.run_server(socketserver.TCPServer,
SocketServer.StreamRequestHandler, socketserver.StreamRequestHandler,
self.stream_examine) self.stream_examine)
def test_ThreadingTCPServer(self): def test_ThreadingTCPServer(self):
self.run_server(SocketServer.ThreadingTCPServer, self.run_server(socketserver.ThreadingTCPServer,
SocketServer.StreamRequestHandler, socketserver.StreamRequestHandler,
self.stream_examine) self.stream_examine)
if HAVE_FORKING: if HAVE_FORKING:
def test_ForkingTCPServer(self): def test_ForkingTCPServer(self):
with simple_subprocess(self): with simple_subprocess(self):
self.run_server(SocketServer.ForkingTCPServer, self.run_server(socketserver.ForkingTCPServer,
SocketServer.StreamRequestHandler, socketserver.StreamRequestHandler,
self.stream_examine) self.stream_examine)
if HAVE_UNIX_SOCKETS: if HAVE_UNIX_SOCKETS:
def test_UnixStreamServer(self): def test_UnixStreamServer(self):
self.run_server(SocketServer.UnixStreamServer, self.run_server(socketserver.UnixStreamServer,
SocketServer.StreamRequestHandler, socketserver.StreamRequestHandler,
self.stream_examine) self.stream_examine)
def test_ThreadingUnixStreamServer(self): def test_ThreadingUnixStreamServer(self):
self.run_server(SocketServer.ThreadingUnixStreamServer, self.run_server(socketserver.ThreadingUnixStreamServer,
SocketServer.StreamRequestHandler, socketserver.StreamRequestHandler,
self.stream_examine) self.stream_examine)
if HAVE_FORKING: if HAVE_FORKING:
def test_ForkingUnixStreamServer(self): def test_ForkingUnixStreamServer(self):
with simple_subprocess(self): with simple_subprocess(self):
self.run_server(ForkingUnixStreamServer, self.run_server(ForkingUnixStreamServer,
SocketServer.StreamRequestHandler, socketserver.StreamRequestHandler,
self.stream_examine) self.stream_examine)
def test_UDPServer(self): def test_UDPServer(self):
self.run_server(SocketServer.UDPServer, self.run_server(socketserver.UDPServer,
SocketServer.DatagramRequestHandler, socketserver.DatagramRequestHandler,
self.dgram_examine) self.dgram_examine)
def test_ThreadingUDPServer(self): def test_ThreadingUDPServer(self):
self.run_server(SocketServer.ThreadingUDPServer, self.run_server(socketserver.ThreadingUDPServer,
SocketServer.DatagramRequestHandler, socketserver.DatagramRequestHandler,
self.dgram_examine) self.dgram_examine)
if HAVE_FORKING: if HAVE_FORKING:
def test_ForkingUDPServer(self): def test_ForkingUDPServer(self):
with simple_subprocess(self): with simple_subprocess(self):
self.run_server(SocketServer.ForkingUDPServer, self.run_server(socketserver.ForkingUDPServer,
SocketServer.DatagramRequestHandler, socketserver.DatagramRequestHandler,
self.dgram_examine) self.dgram_examine)
# Alas, on Linux (at least) recvfrom() doesn't return a meaningful # Alas, on Linux (at least) recvfrom() doesn't return a meaningful
@ -228,19 +228,19 @@ class SocketServerTest(unittest.TestCase):
# if HAVE_UNIX_SOCKETS: # if HAVE_UNIX_SOCKETS:
# def test_UnixDatagramServer(self): # def test_UnixDatagramServer(self):
# self.run_server(SocketServer.UnixDatagramServer, # self.run_server(socketserver.UnixDatagramServer,
# SocketServer.DatagramRequestHandler, # socketserver.DatagramRequestHandler,
# self.dgram_examine) # self.dgram_examine)
# #
# def test_ThreadingUnixDatagramServer(self): # def test_ThreadingUnixDatagramServer(self):
# self.run_server(SocketServer.ThreadingUnixDatagramServer, # self.run_server(socketserver.ThreadingUnixDatagramServer,
# SocketServer.DatagramRequestHandler, # socketserver.DatagramRequestHandler,
# self.dgram_examine) # self.dgram_examine)
# #
# if HAVE_FORKING: # if HAVE_FORKING:
# def test_ForkingUnixDatagramServer(self): # def test_ForkingUnixDatagramServer(self):
# self.run_server(SocketServer.ForkingUnixDatagramServer, # self.run_server(socketserver.ForkingUnixDatagramServer,
# SocketServer.DatagramRequestHandler, # socketserver.DatagramRequestHandler,
# self.dgram_examine) # 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 WSGIServer, WSGIRequestHandler, demo_app
from wsgiref.simple_server import make_server from wsgiref.simple_server import make_server
from StringIO import StringIO from StringIO import StringIO
from SocketServer import BaseServer from socketserver import BaseServer
import re, sys import re, sys
from test import test_support 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. sys.path.
smtplib SMTP Client class (RFC 821) smtplib SMTP Client class (RFC 821)
sndhdr Several routines that help recognizing sound. 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. stat Constants and functions for interpreting stat/lstat struct.
statcache Maintain a cache of file stats. statcache Maintain a cache of file stats.
statvfs Constants for interpreting statvfs struct as returned by 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. after editing, any remembered breakpoints are likely to be wrong.
Always single-steps through top-most stack frame. That is, "c" acts like "n". Always single-steps through top-most stack frame. That is, "c" acts like "n".