为何Python selectors模块无套接字错误事件？如何检测错误套接字？

Great question! Let's start by breaking down why selectors doesn't include a dedicated error event, then walk through practical ways to handle socket errors with the tools it does provide.

Why No Dedicated Error Event? #

Under the hood, both the classic select() system call and epoll() don't require a separate error event to detect socket issues—here's why:

• For select(), a faulty socket (e.g., one with a pending error) will show up in both the read and write ready lists.
• For epoll(), the EPOLLERR event is automatically masked into EPOLLIN or EPOLLOUT—meaning when a socket hits an error, it will trigger either the read or write event you're already listening for.

The selectors module follows this low-level design: it doesn't expose a standalone error event because errors are already signaled through the existing EVENT_READ and EVENT_WRITE triggers. Instead of checking for errors upfront, you handle them when you attempt to perform I/O on the socket.

How to Detect and Handle Faulty Sockets #

The Pythonic approach here leans into EAFP (Easier to Ask for Forgiveness than Permission): attempt the I/O operation first, then catch exceptions that indicate a socket error. Here's a step-by-step breakdown with code examples:

1. Listen for READ/WRITE Events Normally #

Register your sockets with EVENT_READ or EVENT_WRITE as you would for regular I/O. When a socket has an error, it will trigger one of these events, prompting your callback to run.

2. Perform I/O and Catch Exceptions #

When your callback executes, try the intended I/O operation (like recv() or send()). If the socket is faulty, this will raise an exception you can catch. Common socket-related exceptions to watch for include:

• ConnectionResetError: The remote side reset the connection abruptly.
• BrokenPipeError: The connection closed while you were trying to write to it.
• OSError: A generic catch-all for other socket issues (e.g., invalid file descriptor).

3. Clean Up the Faulty Socket #

Once you catch an exception (or detect a graceful close via an empty recv() return), unregister the socket from the selector and close it to free resources.

Example Code

import selectors
import socket

# Initialize the selector
sel = selectors.DefaultSelector()

def accept_new_connection(server_sock):
    conn, addr = server_sock.accept()
    print(f"New connection from {addr}")
    # Register the client socket for read events
    sel.register(conn, selectors.EVENT_READ, handle_client_data)

def handle_client_data(client_sock):
    try:
        # Attempt to read data from the client
        data = client_sock.recv(1024)
        if not data:
            # Empty response means the client closed the connection gracefully
            print("Client closed connection gracefully")
            sel.unregister(client_sock)
            client_sock.close()
            return
        
        # Process the data (echo it back in this example)
        print(f"Received: {data.decode()}")
        client_sock.sendall(data)
    
    except (ConnectionResetError, BrokenPipeError, OSError) as e:
        # Handle socket errors
        print(f"Socket error occurred: {str(e)}")
        sel.unregister(client_sock)
        client_sock.close()

# Set up the server socket
server_sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server_sock.bind(("localhost", 8000))
server_sock.listen()
sel.register(server_sock, selectors.EVENT_READ, accept_new_connection)

# Main event loop
try:
    while True:
        events = sel.select()
        for key, _ in events:
            callback = key.data
            callback(key.fileobj)
except KeyboardInterrupt:
    print("\nShutting down server...")
finally:
    sel.close()
    server_sock.close()

Key Notes #

• Don't overlook the empty recv() case: this is how clients signal a graceful connection close, and you should clean up the socket here too.
• This approach aligns with Python's core philosophy: instead of checking for potential errors before acting, you act first and handle exceptions as they arise.

内容的提问来源于stack exchange，提问作者binbin