Programming Python (108 page)

"""
###############################################################################
Tools for connecting standard streams of non-GUI programs to sockets that
a GUI (or other) program can use to interact with the non-GUI program.
###############################################################################
"""
import sys
from socket import *
port = 50008            # pass in different port if multiple dialogs on machine
host = 'localhost'      # pass in different host to connect to remote listeners
def initListenerSocket(port=port):
"""
initialize connected socket for callers that listen in server mode
"""
sock = socket(AF_INET, SOCK_STREAM)
sock.bind(('', port))                     # listen on this port number
sock.listen(5)                            # set pending queue length
conn, addr = sock.accept()                # wait for client to connect
return conn                               # return connected socket
def redirectOut(port=port, host=host):
"""
connect caller's standard output stream to a socket for GUI to listen
start caller after listener started, else connect fails before accept
"""
sock = socket(AF_INET, SOCK_STREAM)
sock.connect((host, port))                # caller operates in client mode
file = sock.makefile('w')                 # file interface: text, buffered
sys.stdout = file                         # make prints go to sock.send
return sock                               # if caller needs to access it raw
def redirectIn(port=port, host=host):
"""
connect caller's standard input stream to a socket for GUI to provide
"""
sock = socket(AF_INET, SOCK_STREAM)
sock.connect((host, port))
file = sock.makefile('r')                 # file interface wrapper
sys.stdin = file                          # make input come from sock.recv
return sock                               # return value can be ignored
def redirectBothAsClient(port=port, host=host):
"""
connect caller's standard input and output stream to same socket
in this mode, caller is client to a server: sends msg, receives reply
"""
sock = socket(AF_INET, SOCK_STREAM)
sock.connect((host, port))                # or open in 'rw' mode
ofile = sock.makefile('w')                # file interface: text, buffered
ifile = sock.makefile('r')                # two file objects wrap same socket
sys.stdout = ofile                        # make prints go to sock.send
sys.stdin  = ifile                        # make input come from sock.recv
return sock
def redirectBothAsServer(port=port, host=host):
"""
connect caller's standard input and output stream to same socket
in this mode, caller is server to a client: receives msg, send reply
"""
sock = socket(AF_INET, SOCK_STREAM)
sock.bind((host, port))                   # caller is listener here
sock.listen(5)
conn, addr = sock.accept()
ofile = conn.makefile('w')                # file interface wrapper
ifile = conn.makefile('r')                # two file objects wrap same socket
sys.stdout = ofile                        # make prints go to sock.send
sys.stdin  = ifile                        # make input come from sock.recv
return conn

"""
###############################################################################
test the socket_stream_redirection.py modes
###############################################################################
"""
import sys, os, multiprocessing
from socket_stream_redirect import *
###############################################################################
# redirected client output
###############################################################################
def server1():
mypid = os.getpid()
conn  = initListenerSocket()                     # block till client connect
file  = conn.makefile('r')
for i in range(3):                               # read/recv client's prints
data = file.readline().rstrip()              # block till data ready
print('server %s got [%s]' % (mypid, data))  # print normally to terminal
def client1():
mypid = os.getpid()
redirectOut()
for i in range(3):
print('client %s: %s' % (mypid, i))          # print to socket
sys.stdout.flush()                           # else buffered till exits!
###############################################################################
# redirected client input
###############################################################################
def server2():
mypid = os.getpid()                              # raw socket not buffered
conn  = initListenerSocket()                     # send to client's input
for i in range(3):
conn.send(('server %s: %s\n' % (mypid, i)).encode())
def client2():
mypid = os.getpid()
redirectIn()
for i in range(3):
data = input()                               # input from socket
print('client %s got [%s]' % (mypid, data))  # print normally to terminal
###############################################################################
# redirect client input + output, client is socket client
###############################################################################
def server3():
mypid = os.getpid()
conn  = initListenerSocket()                     # wait for client connect
file  = conn.makefile('r')                       # recv print(), send input()
for i in range(3):                               # readline blocks till data
data = file.readline().rstrip()
conn.send(('server %s got [%s]\n' % (mypid, data)).encode())
def client3():
mypid = os.getpid()
redirectBothAsClient()
for i in range(3):
print('client %s: %s' % (mypid, i))          # print to socket
data = input()                               # input from socket: flushes!
sys.stderr.write('client %s got [%s]\n' % (mypid, data))  # not redirected
###############################################################################
# redirect client input + output, client is socket server
###############################################################################
def server4():
mypid = os.getpid()
sock  = socket(AF_INET, SOCK_STREAM)
sock.connect((host, port))
file  = sock.makefile('r')
for i in range(3):
sock.send(('server %s: %s\n' % (mypid, i)).encode())   # send to input()
data = file.readline().rstrip()                        # recv from print()
print('server %s got [%s]' % (mypid, data))            # result to terminal
def client4():
mypid = os.getpid()
redirectBothAsServer()         # I'm actually the socket server in this mode
for i in range(3):
data = input()                               # input from socket: flushes!
print('client %s got [%s]' % (mypid, data))  # print to socket
sys.stdout.flush()                           # else last buffered till exit!
###############################################################################
# redirect client input + output, client is socket client, server xfers first
###############################################################################
def server5():
mypid = os.getpid()                              # test 4, but server accepts
conn  = initListenerSocket()                     # wait for client connect
file  = conn.makefile('r')                       # send input(), recv print()
for i in range(3):
conn.send(('server %s: %s\n' % (mypid, i)).encode())
data = file.readline().rstrip()
print('server %s got [%s]' % (mypid, data))
def client5():
mypid = os.getpid()
s = redirectBothAsClient()     # I'm the socket client in this mode
for i in range(3):
data = input()                               # input from socket: flushes!
print('client %s got [%s]' % (mypid, data))  # print to socket
sys.stdout.flush()                           # else last buffered till exit!
###############################################################################
# test by number on command-line
###############################################################################
if __name__ == '__main__':
server = eval('server' + sys.argv[1])
client = eval('client' + sys.argv[1])               # client in this process
multiprocessing.Process(target=server).start()      # server in new process
client()                                            # reset streams in client
#import time; time.sleep(5)                         # test effect of exit flush

Binary to text translations

Raw sockets transfer binary byte strings, but by opening
the wrapper files in text mode, their content is automatically
translated to text strings on input and output. Text-mode file
wrappers are required if accessed through standard stream tools
such as the
print
built-in
that writes text strings (as we’ve learned, binary mode files
require byte strings instead). When dealing with the raw socket
directly, though, text must still be manually encoded to byte
strings, as shown in most of
Example 12-11
’s tests.

Buffered streams, program output, and deadlock

As we learned in Chapters
5
and
10
, standard streams are
normally buffered, and printed text may need to be flushed so
that it appears on a socket connected to a process’s output
stream. Indeed, some of this example’s tests require explicit or
implicit flush calls to work properly at all; otherwise their
output is either incomplete or absent altogether until program
exit. In pathological cases, this can lead to deadlock, with a
process waiting for output from another that never appears. In
other configurations, we may also get socket errors in a reader
if a writer exits too soon, especially in two-way
dialogs.

For example, if
client1
and
client4
did not flush
periodically as they do, the only reason that they would work is
because output streams are automatically flushed when their
process exits. Without manual flushes,
client1
transfers no data until
process exit (at which point all its output is sent at once in a
single message), and
client4
’s data is incomplete till exit
(its last printed message is delayed).

Even more subtly, both
client3
and
client4
rely on the fact that the
input
built-in first
automatically flushes
sys.stdout
internally for its prompt
option, thereby sending data from preceding
print
calls. Without this implicit
flush (or the addition of manual flushes),
client3
would experience
deadlock
immediately, as would
client4
if its manual flush call was
removed (even with
input
’s
flush, removing
client4
’s
manual flush causes its final
print
message to not be transferred
until process exit).
client5
has this same behavior as
client4
, because it simply swaps which
process binds and accepts and which connects.

In the general case, if we wish to read a program’s output
as it is produced, instead of all at once when it exits or as
its buffers fill, the program must either call
sys.stdout.flush
periodically, or be
run with unbuffered streams by using
Python’s
-u
command-line argument of
Chapter 5
if applicable.

Although we can open socket wrapper files in
unbuffered mode
with a second
makefile
argument of zero (like normal
open
), this does not allow
the wrapper to run in the text mode required for
print
and desired for
input
. In fact, attempting to make a
socket wrapper file both text mode and unbuffered this way fails
with an exception, because Python 3.X no longer supports
unbuffered mode for text files (it is allowed for binary mode
only today). In other words, because
print
requires text mode, buffered
mode is also implied for output stream files. Moreover,
attempting to open a socket file wrapper in
line-buffered
mode appears to not be
supported in Python 3.X (more on this ahead).

While some buffering behavior may be library and platform
dependent, manual flush calls or direct socket access might
sometimes still be required. Note that sockets can also be made
nonblocking with the
setblocking(0)
method, but this only
avoids wait states for transfer calls and does not address the
data producer’s failure to send buffered output.