Figure 15.1 A distributed multimedia system

Week 2
Interprocess Communication
Reference:
Chapter 4
Distributed Systems: Concepts and Design
Coulouris, Dollimore, Kindberg and Blair
Edition 5, © Addison Wesley 2011

Learning Objectives

Recognise characteristics of interprocess communication
Interpret UDP datagram communication
Interpret TCP stream communication
Describe external data representation and marshalling
Explain request-reply communication protocol.
Identify features of HTTP as a request-reply protocol

Characteristics of Interprocess Communication

The interprocess communication involves the activities to communicate data from the sending process to the receiving process and may involve the synchronisation of the two processes.
The fundamental elements of any communication are:
Send operation is used by a process to send a message to a destination.
Receive operation is used by another process at the destination to receive the message.

Characteristics of Interprocess Communication
Communication types include:
Synchronous
The sender and receiver are synchronised.
Both send and receive are blocking operations.
Asynchronous
The send operation is non-blocking.
The sender is allowed to proceed as soon as the message has been copied to a local buffer.
Transmission continues in parallel with other processing.
In this case the receive operation may be blocking or non-blocking.

Characteristics of Interprocess Communication

Message destinations
In distributed systems, a process is identified by:
Internet address: the location of the node that a process resides.
Port: the unique number (0~216) corresponding to a single sending/receiving process.
Sockets
Sockets are a software abstraction which provides a communication endpoint for processes.
A socket encapsulates:
An IP address
A Port number
A protocol, e,g, UDP or TCP

Characteristics of Interprocess Communication

Client/Server communication via sockets

message
agreed port

any port

socket
socket
Internet address = 138.37.88.249
Internet address = 138.37.94.248
other ports

client
server

UDP Datagram Communication

UDP communication is unacknowledged and unreliable.
A datagram is transmitted between processes when one process sends it and the other receives it.
Sending is non-blocking but receiving is blocking although timeouts can be set.
Arriving messages are placed in a queue bound to the receiver’s port.

UDP Datagram Communication

The receive method returns the Internet address and port number of the sender.
Issues relating to UDP communication include:
Message size
IP has a limit of 64kbytes on packets and a UDP datagram must fit into this size.
Typical applications use limit of 8kbytes.
Omission Failures
Datagrams can be dropped because of full buffers, checksum failure, either send-omission or receive-omission.
Ordering
Messages can arrive out of order because the underlying IP routes packets independently.

UDP Datagram Communication

Overheads relating to reliable message delivery are costly.
The need to store state information at sender or receiver.
The need to retransmit messages.
Latency for the sender.
It is acceptable by applications where failures are tolerable but overheads are not tolerable.
Domain Naming Service
Voice over IP

Java APIs for UDP Communication

Class DatagramPacket encapsulate:
A message and the length of the message
The internet address and the port number of the receiver.
Class DatagramSocket
Supports for sending and receiving UDP datagrams.
Can be bound to a particular port or allow to choose a free local port.
Throw SocketException or IOException to reflect omission failure.

An Example of Java UDP Client

import java.net.*;
import java.io.*;
public class UDPClient{
public static void main(String args[]){
//args give message contents and server hostname
DatagramSocket aSocket = null;
try{
aSocket=new DatagramSocket();
byte[] m=args[0].getBytes();
InetAddress aHost=InetAddress.getByName(args[1]);
int serverPort=6789;
DatagramPacket request=new DatagramPacket(m,
args[0].length(), aHost, serverPort);
aSocket.send(request);

This program continues on the next slide

An Example of Java UDP Client

byte[] buffer=new byte[1000];
DatagramPacket reply=new DatagramPacket(buffer,
buffer.length);
aSocket.receive(reply);
System.out.println(“Reply: ” + new
String(reply.getData()));
}catch (SocketException e)
{System.out.println(“Socket: ” + e.getMessage());
}catch (IOException e)
{System.out.println(“IO: ” + e.getMessage());}
}finally {if(aSocket != null) aSocket.close();}
}
}

The end of this program
*

An Example of Java UDP Server

import java.net.*;
import java.io.*;
public class UDPServer{
public static void main(String args[]){
DatagramSocket aSocket = null;
try{
aSocket = new DatagramSocket(6789);
byte[] buffer = new byte[1000];

This program continues on the next slide

An Example of Java UDP Server

while(true){
DatagramPacket request=new DatagramPacket
(buffer, buffer.length);
aSocket.receive(request);
DatagramPacket reply=new DatagramPacket
(request.getData(), request.getLength(),
request.getAddress(), request.getPort());
aSocket.send(reply);
}
}catch (SocketException e)
{System.out.println(“Socket: ” + e.getMessage());
}catch (IOException e)
{System.out.println(“IO: ” + e.getMessage());}
}finally {if(aSocket != null) aSocket.close();}
}
}

The end of this program
*

An Example of Java UDP communication

Outputs of the DUPClient and the UDPServer

TCP Stream Communication
TCP uses a stream of bytes to effect communication.
To enable reliable communication, TCP uses:
Checksums to detect and reject corrupt packets.
Acknowledgements to confirm the arrivals of valid messages.
Sequence numbers to detect and reject duplicated packets (from retransmission).
Timeouts and retransmissions to deal with lost packets.

TCP Stream Communication

TCP hides the networking issues:
Message sizes
Lost messages
Duplicated and incorrectly ordered messages
Flow control issues
Message destinations (after initial setup)
TCP tries best effort to reliably deliver messages even if some packets are lost.
TCP has no guarantee to message delivery only when connection is broken or processes crash.

Java APIs for TCP Communication

Distinction is made between a client (using Socket) and a server (using ServerSocket).
Connection must first be established, and the client sends a connect request.
When the server accepts the request, a new stream Socket is created for communication with this client.
The ServerSocket keeps listening for new connect requests.

Java APIs for TCP Communication

The established pair of sockets then support streams in both directions.
The sender writes onto its output stream via its socket and the receiver reads from its input stream via its socket.
When a process closes a socket, any remaining data is transmitted together with an indicator that the connection is now broken.
Throw UnknownHostException, EOFException and IOException to reflect omission failure.

An Example of Java TCP Client

import java.net.*;
import java.io.*;
public class TCPClient {
public static void main (String args[]) {
//arguments supply message and hostname of destination
Socket s=null;
try{
int serverPort=7896;
s=new Socket(args[1], serverPort);
DataInputStream in=new
DataInputStream(s.getInputStream());
DataOutputStream out=new
DataOutputStream(s.getOutputStream());
out.writeUTF(args[0]);

This program continues on the next slide

An Example of Java TCP Client

String data = in.readUTF();
System.out.println(“Received: “+ data) ;
}catch (UnknownHostException e){
System.out.println(“Sock:”+e.getMessage());
}catch (EOFException e){
System.out.println(“EOF:”+e.getMessage());
}catch (IOException e){
System.out.println(“IO:”+e.getMessage());}
}finally {
if(s!=null)
try {s.close();}
catch (IOException e){
System.out.println(“close:”+e.getMessage());}}
}
}

The end of this program
*

An Example of Java TCP Server

import java.net.*;
import java.io.*;
public class TCPServer {
public static void main (String args[]) {
try{
int serverPort=7896;
ServerSocket listenSocket=new
ServerSocket(serverPort);
while(true) {
Socket clientSocket=listenSocket.accept();
Connection c = new Connection(clientSocket);
}
} catch(IOException e) {
System.out.println(“Listen :”+e.getMessage());}
}
}

This program continues on the next slide

An Example of Java TCP Server

class Connection extends Thread {
DataInputStream in;
DataOutputStream out;
Socket clientSocket;
public Connection (Socket aClientSocket) {
try {
clientSocket = aClientSocket;
in=new DataInputStream(
clientSocket.getInputStream());
out=new DataOutputStream(
clientSocket.getOutputStream());
this.start();
} catch(IOException e){
System.out.println(“Connection:“
+e.getMessage());}
}
This program continues on the next slide

An Example of Java TCP Server

public void run(){
try { // an echo server
String data = in.readUTF();
out.writeUTF(data);
}
catch(EOFException e) {
System.out.println(“EOF:”+e.getMessage());}
catch(IOException e){
System.out.println(“IO:”+e.getMessage());}
}
finally {
try {clientSocket.close();}
catch(IOException e){/*close failed*/}}
}
}
The end of this program
*

An Example of Java TCP Communication
Outputs of the TCPClient and the TCPServer

TCP Applications

Where overheads can be tolerated, TCP is used to ensure high level of reliability.
HTTP is used for communication between web browsers and web servers.
FTP allows directories on a remote computer to be browsed and files to be transferred from one computer to another.
Telnet provides access by means of a terminal session to a remote computer.
SMTP is used to send mails between computers.

External Data Representation

Information stored in processes is represented in memory as interconnected data structures e.g. arrays, objects etc.
Different platforms/environments use different representations for primitive data types such as integers (big/little endian), floating point numbers, characters.
Information in messages is represented as a flat sequence of bytes.
Agreement is needed on the format for the data on the wire.

public class Person implements java.io.Serializable {
private String name;
private String address;
private int year;
public Person(String aName, String aPlace, int aYear)
{
this.name = aName;
this.place = aPlace;
this.year = aYear;
}
…………
………… //methods for accessing the instance variables
}

External Data Representation
The Person structure defined in Java.

External Data Marshalling

Marshalling is the process of taking a collection of data items and assembling them into a form suitable for transmission in a message.
Unmarshalling is the complementary process of re-assembling the data structure at the destination.
Three alternative approaches to external data representation and marshalling are:
CORBA’s CDR (Common Data Representation)
Java’s Object Serialization
XML (eXtensible Markup Language)

External Data Marshalling
The Person structure expressed in XML

Smith London 1934

This definition continues on the next slide

External Data Marshalling
The Person structure expressed in XML

The end of definition
*

External Data Marshalling
Marshalling or unmarshalling requires the consideration of all the finest details and is error-prone if carried out manually.
Software for marshalling and unmarshalling is available for all commonly used platforms and programming environment.
Java Serialization and Deserialization are examples of automated Marshalling or unmarshalling techniques.

Java Object Serialization
The Java interface Serializable has no methods but is used to mark classes which may be serialized and deserialized: that is converted into a format suitable for transmission or for storing on disk, and back.
Serialization is achieved by creating an instance of the class ObjectOutputStream and invoke its writeObject method passing the object concerned as an argument.
Deserialization is achieved by creating an instance of the class ObjectInputStream and using its readObject method to reconstruct the object.

Java Object Serialization
String filename=”person”;
Person person1 = new Person(“Smith”, “London”, 1934);
FileOutputStream fos = null;
ObjectOutputStream out = null;
try {
fos = new FileOutputStream(filename);
out = new ObjectOutputStream(fos);
out.writeObject(person1);
out.close();
System.out.println(“Object Persisted”);
}catch(IOException ex)
{ex.printStackTrace();}
Java Object Serialization

Java Object Serialization
String filename=”person”;
Person person1 = null;
FileInputStream fis = null;
ObjectInputStream in = null;
try {
fis = new FileInputStream(filename);
in = new ObjectInputStream(fis);
person1 = (Person)in.readObject();
in.close();
}catch(IOException ex) { ex.printStackTrace();
}catch(ClassNotFoundException ex){ex.printStackTrace();}
System.out.println(“Person Name: ” + person1.getName());
System.out.println(“Person Place: “+ person1.getPlace());
System.out.println(“Person Year: ” + person1.getYear());
}
Java Object Deserialization

Java Object Serialization
Screenshots of the example