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::
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
# cycles and network bandwidth!
logger.handle(record)
- class LogRecordSocketReceiver(SocketServer.ThreadingTCPServer):
+ class LogRecordSocketReceiver(socketserver.ThreadingTCPServer):
"""simple TCP socket-based logging receiver suitable for testing.
"""
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
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
--------------------------
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.
.. seealso::
- Module :mod:`SocketServer`
+ Module :mod:`socketserver`
Classes that simplify writing network servers.
-: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
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()
import time
import socket # For gethostbyaddr()
import mimetools
-import SocketServer
+import socketserver
# Default error message template
DEFAULT_ERROR_MESSAGE = """\
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.
import xmlrpclib
from xmlrpclib import Fault
-import SocketServer
+import socketserver
import BaseHTTPServer
import sys
import os
if self.server.logRequests:
BaseHTTPServer.BaseHTTPRequestHandler.log_request(self, code, size)
-class SimpleXMLRPCServer(SocketServer.TCPServer,
+class SimpleXMLRPCServer(socketserver.TCPServer,
SimpleXMLRPCDispatcher):
"""Simple XML-RPC server.
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
has only one client per server, this was not a limitation.
+---------------------------------+ +-------------+
- | SocketServer.BaseRequestHandler | | SocketIO |
+ | socketserver.BaseRequestHandler | | SocketIO |
+---------------------------------+ +-------------+
^ | register() |
| | unregister()|
import os
import socket
import select
-import SocketServer
+import socketserver
import struct
import pickle
import threading
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"
def __init__(self, oid):
self.oid = oid
-class RPCHandler(SocketServer.BaseRequestHandler, SocketIO):
+class RPCHandler(socketserver.BaseRequestHandler, SocketIO):
debugging = False
location = "#S" # Server
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):
except ImportError:
thread = None
-from SocketServer import ThreadingTCPServer, StreamRequestHandler
+from socketserver import ThreadingTCPServer, StreamRequestHandler
DEFAULT_LOGGING_CONFIG_PORT = 9030
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")
import re
import select
import socket
-from SocketServer import ThreadingTCPServer, StreamRequestHandler
+from socketserver import ThreadingTCPServer, StreamRequestHandler
import string
import struct
import sys
"""
-Test suite for SocketServer.py.
+Test suite for socketserver.
"""
import contextlib
import threading
import time
import unittest
-import SocketServer
+import socketserver
import test.test_support
from test.test_support import reap_children, verbose, TestSkipped
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
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
# 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)
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
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.
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).
after editing, any remembered breakpoints are likely to be wrong.
Always single-steps through top-most stack frame. That is, "c" acts like "n".
-
-
projects / python / commitdiff