Unix domain sockets (UDS) are sometimes used as a convenient way to communicate between two processes. As in Unix, everything is conceptually a file. If you need an example of such an IPC action, this can be useful.
We launch a UDS server that binds to a filesystem path, and a UDS client uses the same path to communicate with the server.
Listing 3.9a shows a Unix domain socket server, as follows:
#!/usr/bin/env python
# Python Network Programming Cookbook -- Chapter – 3
# This program is optimized for Python 2.7.
# It may run on any other version with/without modifications.
import socket
import os
import time
SERVER_PATH = "/tmp/python_unix_socket_server"
def run_unix_domain_socket_server():
if os.path.exists(SERVER_PATH):
os.remove( SERVER_PATH )
print "starting unix domain socket server."
server = socket.socket( socket.AF_UNIX, socket.SOCK_DGRAM )
server.bind(SERVER_PATH)
print "Listening on path: %s" %SERVER_PATH
while True:
datagram = server.recv( 1024 )
if not datagram:
break
else:
print "-" * 20
print datagram
if "DONE" == datagram:
break
print "-" * 20
print "Server is shutting down now..."
server.close()
os.remove(SERVER_PATH)
print "Server shutdown and path removed."
if __name__ == '__main__':
run_unix_domain_socket_server()Listing 3.9b shows a UDS client, as follows:
#!/usr/bin/env python
# Python Network Programming Cookbook -- Chapter - 3
# This program is optimized for Python 2.7.
# It may run on any other version with/without modifications.
import socket
import sys
SERVER_PATH = "/tmp/python_unix_socket_server"
def run_unix_domain_socket_client():
""" Run "a Unix domain socket client """
sock = socket.socket(socket.AF_UNIX, socket.SOCK_DGRAM)
# Connect the socket to the path where the server is listening
server_address = SERVER_PATH
print "connecting to %s" % server_address
try:
sock.connect(server_address)
except socket.error, msg:
print >>sys.stderr, msg
sys.exit(1)
try:
message = "This is the message. This will be echoed back!"
print "Sending [%s]" %message
sock.sendall(message)
amount_received = 0
amount_expected = len(message)
while amount_received < amount_expected:
data = sock.recv(16)
amount_received += len(data)
print >>sys.stderr, "Received [%s]" % data
finally:
print "Closing client"
sock.close()
if __name__ == '__main__':
run_unix_domain_socket_client()The server output is as follows:
$ python 3_9a_unix_domain_socket_server.py starting unix domain socket server. Listening on path: /tmp/python_unix_socket_server -------------------- This is the message. This will be echoed back!
The client output is as follows:
$ python 3_9b_unix_domain_socket_client.py connecting to /tmp/python_unix_socket_server Sending [This is the message. This will be echoed back!]
A common path is defined for a UDS client/server to interact. Both the client and server use the same path to connect and listen to.
In a server code, we remove the path if it exists from the previous run of this script. It then creates a Unix datagram socket and binds it to the specified path. It then listens for incoming connections. In the data processing loop, it uses the recv() method to get data from the client and prints that information on screen.
The client-side code simply opens a Unix datagram socket and connects to the shared server address. It sends a message to the server using sendall(). It then waits for the message to be echoed back to itself and prints that message.