Programming Python (33 page)

Although sockets are
one of the most commonly used IPC tools, it’s impossible
to fully grasp their API without also seeing its role in networking.
Because of that, we’ll defer most of our socket coverage until we can
explore their use in network scripting in
Chapter 12
. This section provides a brief
introduction and preview, so you can compare with the prior section’s
named pipes (a.k.a. fifos). In short:

In addition, sockets support networking roles that go beyond
both IPC and this chapter’s scope. To illustrate the basics, though,
Example 5-25
launches a server
and 5 clients in threads running in parallel on the same machine, to
communicate over a socket—because all threads connect to the same
port, the server consumes the data added by each of the
clients.

"""
sockets for cross-task communication: start threads to communicate over sockets;
independent programs can too, because sockets are system-wide, much like fifos;
see the GUI and Internet parts of the book for more realistic socket use cases;
some socket servers may also need to talk to clients in threads or processes;
sockets pass byte strings, but can be pickled objects or encoded Unicode text;
caveat: prints in threads may need to be synchronized if their output overlaps;
"""
from socket import socket, AF_INET, SOCK_STREAM     # portable socket api
port = 50008                 # port number identifies socket on machine
host = 'localhost'           # server and client run on same local machine here
def server():
sock = socket(AF_INET, SOCK_STREAM)         # ip addresses tcp connection
sock.bind(('', port))                       # bind to port on this machine
sock.listen(5)                              # allow up to 5 pending clients
while True:
conn, addr = sock.accept()              # wait for client to connect
data = conn.recv(1024)                  # read bytes data from this client
reply = 'server got: [%s]' % data       # conn is a new connected socket
conn.send(reply.encode())               # send bytes reply back to client
def client(name):
sock = socket(AF_INET, SOCK_STREAM)
sock.connect((host, port))                  # connect to a socket port
sock.send(name.encode())                    # send bytes data to listener
reply = sock.recv(1024)                     # receive bytes data from listener
sock.close()                                # up to 1024 bytes in message
print('client got: [%s]' % reply)
if __name__ == '__main__':
from threading import Thread
sthread = Thread(target=server)
sthread.daemon = True                       # don't wait for server thread
sthread.start()                             # do wait for children to exit
for i in range(5):
Thread(target=client, args=('client%s' % i,)).start()

Study this script’s code and comments to see how the socket
objects’ methods are used to transfer data. In a nutshell, with this
type of socket the server accepts a client connection, which by
default blocks until a client requests service, and returns a new
socket connected to the client. Once connected, the client and server
transfer byte strings by using send and receive calls instead of
writes and reads, though as we’ll see later in the book, sockets can
be wrapped in file objects much as we did earlier for pipe
descriptors. Also like pipe descriptors, unwrapped sockets deal in
binary
bytes
strings, not text
str
; that’s why string formatting
results are manually encoded again here.

Here is this script’s output on Windows:

C:\...\PP4E\System\Processes>
socket_preview.py
client got: [b"server got: [b'client1']"]
client got: [b"server got: [b'client3']"]
client got: [b"server got: [b'client4']"]
client got: [b"server got: [b'client2']"]
client got: [b"server got: [b'client0']"]

This output isn’t much to look at, but each line reflects data
sent from client to server, and then back again: the server receives a
bytes string from a connected client and echoes it back in a larger
reply string. Because all threads run in parallel, the order in which
the clients are served is random on this
machine.

Although sockets
work for threads, the shared memory model of threads
often allows them to employ simpler communication devices such as
shared names and objects and queues. Sockets tend to shine brighter
when used for IPC by separate processes and independently launched
programs.
Example 5-26
, for
instance, reuses the server
and
client
functions of the prior example, but runs them in both
processes and threads of independently launched programs.

"""
same socket, but talk between independent programs too, not just threads;
server here runs in a process and serves both process and thread clients;
sockets are machine-global, much like fifos: don't require shared memory
"""
from socket_preview import server, client         # both use same port number
import sys, os
from threading import Thread
mode = int(sys.argv[1])
if mode == 1:                                     # run server in this process
server()
elif mode == 2:                                   # run client in this process
client('client:process=%s' % os.getpid())
else:                                             # run 5 client threads in process
for i in range(5):
Thread(target=client, args=('client:thread=%s' % i,)).start()

Let’s run this script on Windows, too (again, this portability
is a major advantage of sockets). First, start the server in a process
as an independently launched program in its own window; this process
runs perpetually waiting for clients to request connections (and as
for our prior pipe example you may need to use Task Manager or a
window close to kill the server process eventually):

C:\...\PP4E\System\Processes>
socket-preview-progs.py 1

Now, in another window, run a few clients in both processes and
thread, by launching them as independent programs—using 2 as the
command-line argument runs a single client process, but 3 spawns five
threads to converse with the server on parallel:

C:\...\PP4E\System\Processes>
socket-preview-progs.py 2
client got: [b"server got: [b'client:process=7384']"]
C:\...\PP4E\System\Processes>
socket-preview-progs.py 2
client got: [b"server got: [b'client:process=7604']"]
C:\...\PP4E\System\Processes>
socket-preview-progs.py 3
client got: [b"server got: [b'client:thread=1']"]
client got: [b"server got: [b'client:thread=2']"]
client got: [b"server got: [b'client:thread=0']"]
client got: [b"server got: [b'client:thread=3']"]
client got: [b"server got: [b'client:thread=4']"]
C:\..\PP4E\System\Processes>
socket-preview-progs.py 3
client got: [b"server got: [b'client:thread=3']"]
client got: [b"server got: [b'client:thread=1']"]
client got: [b"server got: [b'client:thread=2']"]
client got: [b"server got: [b'client:thread=4']"]
client got: [b"server got: [b'client:thread=0']"]
C:\...\PP4E\System\Processes>
socket-preview-progs.py 2
client got: [b"server got: [b'client:process=6428']"]

This section’s
examples illustrate the basic IPC role of sockets, but
this only hints at their full utility. Despite their seemingly limited
byte string nature, higher-order use cases for sockets are not
difficult to imagine. With a little extra work, for instance:

Plus any other context in which programs exchange data—sockets
are a general, portable, and flexible tool. For instance, they would
provide the same utility as fifos for the GUI/debugger example used
earlier, but would also work in Python on Windows and would even allow
the GUI to connect to a debugger running on a different computer
altogether. As such, they are seen by many as a more powerful IPC
tool.

Again, you should consider this section just a preview; because
the grander socket story also entails networking concepts, we’ll defer
a more in-depth look at the socket API until
Chapter 12
. We’ll also see sockets again briefly
in
Chapter 10
in the GUI stream
redirection use case listed above, and we’ll explore a variety of
additional socket use cases in the Internet part of this book. In
Part IV
, for instance, we’ll use
sockets to transfer entire files and write more robust socket servers
that spawn threads or processes to converse with clients to avoid
denying connections. For the purposes of this chapter, let’s move on
to one last traditional IPC tool—
the signal.

Example 5-27. PP4E\System\Processes\signal1.py

"""
catch signals in Python; pass signal number N as a command-line arg,
use a "kill -N pid" shell command to send this process a signal;  most
signal handlers restored by Python after caught (see network scripting
chapter for SIGCHLD details); on Windows, signal module is available,
but it defines only a few signal types there, and os.kill is missing;
"""
import sys, signal, time
def now(): return time.ctime(time.time())        # current time string
def onSignal(signum, stackframe):                # python signal handler
print('Got signal', signum, 'at', now())     # most handlers stay in effect
signum = int(sys.argv[1])
signal.signal(signum, onSignal)                  # install signal handler
while True: signal.pause()                       # wait for signals (or: pass)

signal.signal


Takes a
signal number and function object and installs that
function to handle that signal number when it is raised. Python
automatically restores most signal handlers when signals occur, so
there is no need to recall this function within the signal handler
itself to reregister the handler. That is, except for
SIGCHLD
, a signal handler remains
installed until explicitly reset (e.g., by setting the handler to
SIG_DFL
to restore default
behavior or to
SIG_IGN
to
ignore the signal).
SIGCHLD
behavior is platform specific.

signal.pause


Makes the
process sleep until the next signal is caught. A
time.sleep
call is similar but
doesn’t work with signals on my Linux box; it generates an
interrupted system call error. A busy
while True: pass
loop here would pause
the script, too, but may squander CPU resources.

Example 5-28. PP4E\System\Processes\signal2.py

"""
set and catch alarm timeout signals in Python; time.sleep doesn't play
well with alarm (or signal in general in my Linux PC), so we call
signal.pause here to do nothing until a signal is received;
"""
import sys, signal, time
def now(): return time.asctime()
def onSignal(signum, stackframe):                 # python signal handler
print('Got alarm', signum, 'at', now())       # most handlers stay in effect
while True:
print('Setting at', now())
signal.signal(signal.SIGALRM, onSignal)       # install signal handler
signal.alarm(5)                               # do signal in 5 seconds
signal.pause()                                # wait for signals