Transcript NUST_BSIT8_DC_Lecture_4

Tuesday, December 16, 2008
The practical scientist is trying
to solve tomorrow's problem
on yesterday's computer.
Computer scientists often
have it the other way around.
- Numerical Recipes, C Edition
1
Distributed Computing
Class: BSIT-8
Instructor: Raihan Ur Rasool
Chapter 04:
Inter-process Communication
Chapter 3 – SELF STUDY



Networking issues for distributed systems
Types of network
Network Principles





Internet protocols
Case Studies



3
Protocol layers
Internetworking
Routing
Ethernet
MobileLAN
ATM
Objectives of the lecture




4
To study the general characteristics of interprocess
communication and the particular characteristics of both
datagram and stream communication in the Internet.
To be able to write Java and C applications that use the
Internet protocols and Java serialization.
To be aware of the design issues for Request-Reply
protocols and how collections of data objects may be
represented in messages (RMI and language integration
are left until Chapter 5).
To be able to use the Java API to IP multicast and to
consider the main options for reliability and ordering in
group communication.
Chapter 4: Interprocess Communication







5
Introduction
The API for the Internet protocols
External data representation and marshalling
Client-Server communication
Group communication
Case study: interprocess communication in UNIX
Summary
Introduction


Middleware layer
TCP ( UDP) from a programmers point of view




Java interface, UNIX Socket
marshalling and demarshalling



6
data form translation
Client-Server communication


TCP : two way stream
UDP : datagram, message passing
Request-Reply protocols
Java RMI, RPC
Group communication
Middleware layer (1)
Applic ations, services
RMI and RPC
This
c hapter
reques t-reply protocol
marshalling and ex ternal data representation
UDP and TCP
7
Middlew are
lay ers
Middleware layer (2)
2-5

8
An adapted reference model for networked communication.
Middleware layer (3)
A software layer that




masks the heterogeneity of systems
provides a convenient programming abstraction
provides protocols for providing general-purpose services to
more specific applications, e.g. naming, security, transaction,
persistent storage and event notification
 authentication protocols
 authorization protocols
 distributed commit protocols
 distributed locking protocols
 high-level communication protocols


9
remote procedure calls (RPC)
remote method invocation (RMI)
Middleware (4)

General structure of a distributed system as middleware.
1-22
10
Middleware programming models

Remote Calls


remote Procedure Calls (RPC)
distributed objects and Remote Method Invocation (RMI)




eg. Java RMI
Group multicast protocols
Common Object Request Broker Architecture (CORBA)
Other programming models



11
remote event notification
remote SQL access
distributed transaction processing
Where are we ?







12
Introduction
The API for the Internet protocols
External data representation and marshalling
Client-Server communication
Group communication
Case study: interprocess communication in UNIX
Summary
The characteristics of inter-process communication (1)

Producer—Consumer and wait

Send and receive
Synchronous and asynchronous


a queue associated with message destination, Sending process
add message to remote queue


Synchronous:


Receiving process remove message from local queue
send and receive are blocking operations
Asynchronous:


send is nonblocking,
receive could be blocking or nonblocking


Java supports multiple threads in a single process

13
(receive notification by interrupt)
Non-blocking communication appears to be more efficient, but it involves
extra complexity in the receiving process: flow control
The characteristics of interprocess communication (2)

Message destinations:





Reliability



Internet address + local port
Port has one receiver but many senders
service name: names into server locations at run time
location independent resource identifiers, e.g. in Mach
validity: messages are guaranteed to be delivered despite a
reasonable number of packets being dropped or lost
Integrity: messages arrive uncorrupted and without duplication
Ordering

the messages be delivered in sender order


14
The order in which they were transmitted by the sender.
The delivery out of sender’s order is regarded as failure
Socket





Endpoint for communication between processes
Both forms of communication (UDP and TCP ) use the socket
abstraction
Originated from BSD Unix, present in Linux, Windows NT and
Macintosh OS etc
bound to a local port (216 possible port number) and one of the
Internet address
a process cannot share socket with other processes on the same
computer
socket
any port
agreed port
socket
message
client
server
other ports
Internet address = 138.37.94.248
15
Internet address = 138.37.88.249
Sockets

The application level API to TCP & UDP



Allows users to write application “protocol
objects” which sit on top of TCP and UDP.
Execution of TCP/UDP/IP are in kernel space.
Sockets provide the bridge to user space.
Java provides 3 types of sockets



DatagramSocket – for UDP
ServerSocket – for TCP server
Socket – endpoint of a TCP stream
App 1
App 2
App 3
socket
socket
socket
UDP
TCP
More on Sockets:
http://java.sun.com/docs/books/tutorial/networking/sockets/definition.html
16
IP
UDP datagram communication


UDP datagrams are sent without acknowledgement or
retries
Issues relating to datagram communication
 Message size: not bigger than 64k in size, otherwise
truncated on arrival
 blocking: non-blocking sends (message could be
discarded at destination if there is not a socket bound
to the port ) and blocking receives (could be timeout)
 Timeout: receiver set on socket –server blocks forever
 Receive from any: not specify an origin for messages,
but could be set to receive from or send to particular
remote port by socket connection operation
17
UDP datagram communication

Failure model
 omission failure: message be dropped due to
checksum error or no buffer space at sender
side or receiver side (send-omission, receive-omission)
 ordering: message be delivered out of sender
order
 application maintains the reliability of UDP
communication channel by itself (ACK)
 DNS & VOIP are implemented over UDP

18
UDP datagram do not suffer from overheads associated
with guaranteed message delivery
Java API for UDP datagrams
DatagramPacket
 DatagramSocket





send and receive : transmit datagram between a pair of
sockets
setSoTimeout : receive method will block for the time
specified and then throw an InterruptedIOexception
connect: connect to a particular remote port and
Internet address
Examples

acceptable to services that are liable to occasional
omission failures, e.g. DNS
19
Datagram Sockets

Creating a datagram socket


Creating a datagram packect


DatagramSocket soc = new DatagramSocket(port-no.)
DatagramPacket p = new DatagramPacket(byte[] data, int len,
InetAddress dest, int dest-port);
IP header:
Sending a packet


soc.send( p )
Receiving a packet

q = new DatagramPacket(buff, len);
soc.receive( q );
source-ip-address
destination-ip-address
protocol = 17 (udp)
UDP header:
source port-no
destination port-no
Application
Data
20
UDP client sends a message to the server and gets a reply
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);
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();}
}
}
21
UDP server repeatedly receives a request and sends it back to the
client
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];
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();}
}
}
22
TCP stream communication (1)

The API to the TCP


provide the abstraction of a stream of bytes to which data may be
written and from which data may be read
Hidden network characteristics





message sizes (how much data to write/read) (Application)
lost messages (ACK)
flow control (match the speed)
message duplication and ordering (identifier with each IP Packet)
message destinations (establish connection)
Once connection is established, no need of address & ports

While connection establishing: client/server



23
Client  Connect request, Server Accept request, becomes Peers
Client: creates stream socket, bind to a port, and makes a connect
request to server
Server: creates a listening socket, bind to a server port, and waits for
clients
TCP stream communication (2)

issues related to stream communication




Matching of data items: agree to the contents of the transmitted data
(int & double, write/ read, )
Blocking: send blocked until the data is written in the receiver’s buffer,
receive blocked until the data in the local buffer becomes available
Threads: server create a new thread for every connection
failure model


integrity and validity have been achieved by checksum, sequence
number, timeout and retransmission in TCP protocol
connection could be broken due to unknown failures
 Can’t distinguish between network failure and the destination process
failure
 Can’t tell whether its recent messages have been received or not
24
TCP byte stream sockets

Server socket – waits for connections



Client socket – connects to server


soc = new ServerSocket( port-no );
Socket newsoc = soc.accept( );
client = new Socket(server-addr, server-port);
When connected, get streams

InputStream in = client.getInputStream( );
OutputStream out = client.getOutputStream( )
Server side
Client Side
client
socket
25
1. Contact server
3. Establish stream
communication
Server
socket
New
socket
2. Create new
Stream socket
Java API for TCP Streams

ServerSocket


accept: listen for connect requests from clients
Socket

constructor



26
not only create a socket associated with a local port, but also connect it
to the specified remote computer and port number
getInputStream
getOutputStream
TCP client makes connection to server, sends
request and receives reply
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]);
// UTF is a string encoding see Sn 4.3
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());}}
}
27
}
TCP server makes a connection for each client and
then echoes the client’s request (1)
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 figure continues on the next slide
28
TCP Server (2)
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());}
}
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*/}}
}
}
29
Where are we ?







30
Introduction
The API for the Internet protocols
External data representation and marshalling
Client-Server communication
Group communication
Case study: interprocess communication in UNIX
Summary
External data representation and marshalling
introduction
[data structures and a sequence of bytes]
Why does the communication data need external data representation and
marshalling?
[data structures must be flattened]

Different data format on different computers, e.g., big-endian/little-endian
integer order, ASCII (Unix) / Unicode character coding
How to enable any two computers to exchange data values?
1.
The values be converted to an agreed external format before
transmission and converted to the local form on receipt
2.
The values are transmitted in the sender’s format, together with an
indication of the format used, and the receipt converts the value if
necessary


31
External data representation and marshalling
introduction





Why does the communication data need external data representation and marshalling?

Different data format on different computers, e.g., big-endian/little-endian integer
order, ASCII (Unix) / Unicode character coding
How to enable any two computers to exchange data values?
1.
The values be converted to an agreed external format before transmission and
converted to the local form on receipt
2.
The values are transmitted in the sender’s format, together with an indication of
the format used, and the receipt converts the value if necessary
External data representation

An agreed standard for the representation of data structures and
primitive values
Marshalling

The process of taking a collection of data items and assembling them into
a form suitable for transmission in a message

Usage: for data transmission or storing in files
Three alternative approaches to EDP

32
CORBA’s common data representation / Java’s object serialization & XML
Reading Assignment

CORBA’s Common Data Representation (CDR)
Java Object Serialization
Extensible Markup language (XML)

Next Time:




Recap
Client-server communication

33