Socket servers are integral for real-time applications, and building one with Python is both powerful and straightforward. This article delves into the creation of a socket server using Python’s built-in socket module.

Scripting is where Python really pays off. The Python Scripting Essentials Bundle has the kind of small automation projects you would build for work.

A socket server listens on a port and waits for clients to connect. Each client gets its own socket, and the server reads and writes on it. This is the base of every network program: web servers, chat, games and file transfer all start here.

Understanding the Socket Server in Python
When creating a socket server in Python, you’re essentially developing a means for multiple clients to connect and exchange data. It can be tailored for your specific application or even adapted for existing apps.

Step-by-Step Guide to Building a Socket Server

Here’s a comprehensive algorithm detailing the process to set up a socket server:

  • Sockets operate at the application layer. Hence, while they don’t bind you to any specific protocol, you often need to define your application protocol.
  • To set up a socket server, follow these essential steps:
    • Bind the socket to a port.
    • Initiate listening mode.
    • Wait for a client connection.
    • Receive data from the connected client.

Python Socket Server Example

Let’s explore a hands-on example to give you a clearer understanding. The following code establishes a socket server on port 7000. For connection purposes, tools like telnet or a dedicated socket client can be employed.

import socket
import sys

HOST = ''  
PORT = 7000

s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
print('# Socket created')

# Establish socket on the desired port
try:
    s.bind((HOST, PORT))
except socket.error as msg:
    print('# Bind failed. ')
    sys.exit()

print('# Socket bind successful')

# Begin listening on the socket
s.listen(10)
print('# Socket now in listening mode')

# Awaiting client connection
conn, addr = s.accept()
print('# Established connection with ' + addr[0] + ':' + str(addr[1]))

# Process data from the client
while True:     
    data = conn.recv(1024)
    line = data.decode('UTF-8')    # convert to string (Python 3 only)
    line = line.replace("\n","")   # remove newline character
    print( line )     

s.close()

Once executed, the server will be actively listening on localhost port 7000. The displayed messages will guide you through the various stages:

# Socket successfully created
# Socket binding completed
# Socket now awaits connections
# Connection established with 127.0.0.1:40499

After initializing, the server will continuously await messages. To interact with it, consider using telnet or adapting the socket client from an earlier section.

The steps

  • server = socket.socket(socket.AF_INET, socket.SOCK_STREAM) creates the socket.
  • server.bind(('localhost', 8000)) picks the address and the port.
  • server.listen(1) starts listening. The 1 is how many connections can wait.
  • conn, addr = server.accept() waits for a client and hands back its socket.
  • conn.recv(1024) reads up to 1024 bytes. It returns empty bytes when the client closes.
  • conn.sendall(data) sends back, and it keeps going until everything is written.
  • conn.close() ends that client. Close the listening socket at the end too.

Put the accept and the reading in a loop to serve more than one client.

A real server also needs a timeout so it does not block forever, and a way to run the accept loop in its own thread so the program stays responsive. Twisted does all of this for you if you do not want to write it.

If you want to try this yourself, the exercises on PyChallenge turn the same idea into a few short problems with instant feedback.