Transcript receive - Nipissing University Word

Lecture 4:
Interprocess Communication
Haibin Zhu, PhD.
Assistant Professor
Department of Computer Science
Nipissing University
© 2002
1
Figure 4.1 Middleware layers
Applic ations, services
RMI and RPC
This
c hapter
reques t-reply protocol
Middlew are
lay ers
marshalling and ex ternal data representation
UDP and TCP
2
Message Passing
• The primitives:
send expression_list to destination_identifier;
receive variable_list from source_identifier;
• Variations:
guarded receive:
receive variable_list from source_id when B;
selective receive:
select
• receive var_list from source_id1;
• |receive var_list from source_id2;
• |receive var_list from source_id3;
end
3
Sockets and ports
Socket is a communication mechanism that contains two endpoints.
Each point belongs to one of the processes involved.
socket
any port
agreed port
socket
message
client
server
other ports
Internet address = 138.37.94.248
Internet address = 138.37.88.249
4
Semantics of Message-Passing Primitives
• blocking vs. non-blocking
• buffered vs. unbuffered
• reliablevs. unreliable
• fixed-size vs. variable-size messages
• direct vs. indirect communication
5
Blocking vs. Non-Blocking Primitives
Client blocked
Client running
Trap to kernel,
process blocked
Blocking
Client running
Message being sent
Return from kernel,
Process released
Client
blocked
Client running
Non-Blocking
Client running
Trap
Return
Message
copied to
kernel
buffer
Message being sent
6
Blocking vs. Non-Blocking Primitives
blocking
non-blocking
send
Returns control to user only after
message has been sent, or until
acknowledgment has been
received.
Returns control as soon
as message queued or
copied.
receive
Returns only after message
has been received.
Signals willingness to
receive message.
Buffer is ready.
problems
•Reduces concurrency.
•Need buffering:
•still blocking
•deadlocks!
•Tricky to program.
7
Buffered vs. Unbuffered Primitives
Clien
t
Server
A
Address refers
to a process
kernel
Clien
t
kernel
Server
Address refers
to a mailbox
A
8
9
10
11
12
13
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);
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();}
}
14
}
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];
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();}
}
}
15
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]);
// UTF is a string encoding Universal Transfer Format
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());}}
}
}
16
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 figure continues on the next slide
17
TCP server (continued)
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*/}
}
}
}
18
External Data Representation and Marshalling
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.
19
CORBA CDR(Common Data Representation) for
constructed types
15 primitive types: short, long, unsigned short, …
Type
Representation
sequence
length (unsigned long) f llowed by elements in order
o
length (unsigned long) followed by characters in order (can also
string
can have wide characters)
array
array elements in order (no length specified because it is fixed)
struct
in the order of declaration of the components
enumerated
unsigned long (the values are specified by the order declared)
union
type tag followed by the selected member
20
CORBA CDR message
index in
sequence of bytes
0–3
4–7
8–11
12–15
16–19
20-23
24–27
4 bytes
5
"Smit"
"h___"
6
"Lond"
"on__"
1934
notes
on representation
length of string
‘Smith’
Padded with 0s
length of string
‘London’
Padded with 0s
unsigned long
The flattened form represents a Person struct with value: {‘Smith’, ‘London’, 1934}
21
Indication of Java serialized form
Person p = new Person(”Smith”, “London”, 1934);
Explanation
Serialized values
Person
8-byte version number
h0
class name, version number
3
int year
java.lang.String java.lang.String number, type and name of
name:
place:
instance variables
1934
5 Smith
6 London
h1
values of instance variables
The true serialized form contains additional type markers; h0 and h1 are handles
22
Representation of a remote object reference
An identifier for a remote object that is valid
throughout a distributed system
32 bits
32 bits
Internet address
port number
32 bits
time
32 bits
object number
interface of
remote object
23
C/S communication: The request-reply protocol
Client
doOperation
Server
Request
message
(wait)
Reply
message
getRequest
select object
execute
method
sendReply
(continuation)
24
Operations of the request-reply protocol
public byte[] doOperation (RemoteObjectRef o, int methodId, byte[]
arguments)
sends a request message to the remote object and returns the reply.
The arguments specify the remote object, the method to be invoked
and the arguments of that method.
public byte[] getRequest ();
acquires a client request via the server port.
public void sendReply (byte[] reply, InetAddress clientHost, int
clientPort);
sends the reply message reply to the client at its Internet address
and port.
25
Request-reply message structure
messageType
int (0=Request, 1= Reply)
requestId
int
objectReference
RemoteObjectRef
methodId
int or Method
arguments
array of bytes
26
RPC exchange protocols
Name
M es sag es sent b y
Client
Serve r
R
Requ es t
RR
Requ es t
Reply
RRA
Requ es t
Reply
Client
A ck no wledg e re ply
27
HTTP messages
Get
Head
Post
Put
Delete
Options
Trace
---------------Page 152
Connection (port)
Send a request
Send a reply
Close connection
method
GET
URL or pathname
HTTP version
headers message body
//www.nipissingu.ca/faculty/haibinz HTTP/ 1.1
HTTP version
HTTP/1.1
status code reason headers message body
200
OK
resource data
28
Group Communication
Multicast Messages:
Fault Tolerance based on replicated services
Finding the discovery servers in spontaneous networking:
Better performance through replicated data:
Propagation of event notifications
29
IP Multicast (Class D)
IPv4:
Multicast routers
Multicast address allocation
Java Multicast:
Multicastsocket
joinGroup()
leaveGroup()
Reliability:
Omission Failure
Ordering
30
Multicast peer joins a group and sends and
receives datagrams
import java.net.*;
import java.io.*;
public class MulticastPeer{
public static void main(String args[]){
// args give message contents & destination multicast group (e.g. "228.5.6.7")
MulticastSocket s =null;
try {
InetAddress group = InetAddress.getByName(args[1]);
s = new MulticastSocket(6789);
s.joinGroup(group);
byte [] m = args[0].getBytes();
DatagramPacket messageOut =
new DatagramPacket(m, m.length, group, 6789);
s.send(messageOut);
// this figure continued on the next slide
31
Figure 4.17 continued
// get messages from others in group
byte[] buffer = new byte[1000];
for(int i=0; i< 3; i++) {
DatagramPacket messageIn =
new DatagramPacket(buffer, buffer.length);
s.receive(messageIn);
System.out.println("Received:" + new String(messageIn.getData()));
}
s.leaveGroup(group);
}
catch (SocketException e){System.out.println("Socket: " + e.getMessage());}
catch (IOException e){System.out.println("IO: " + e.getMessage());}
finally {if(s != null) s.close();}
}
}
32
UNIX Sockets
#include <sys/type.h>
#include <sys/socket.h>
int socket (int domain, int type; int protocal);
int bind (int s, const struct sockaddr * address, size_t
address_len);
int listen (int s, int backlog_size);
int accept (int s, struct sockaddr * address, size_t address_len);
struct hostent *gethostbyaddr(const void *addr, size_t len, int
type);
int send (int s, const char* buf, int len, int flag);
int recv (int s, const char* buf, int len, int flag);
int close(int s);
33
Sockets used for datagrams
Sending a message
Receiving a message
s = socket(AF_INET, SOCK_DGRAM, 0)
s = socket(AF_INET, SOCK_DGRAM, 0)
bind(s, ClientAddress)
bind(s, ServerAddress)
sendto(s, "message", ServerAddress)
amount = recvfrom(s, buffer, from)
ServerAddress and ClientAddress are socket addresses
34
Sockets used for streams
Requesting a connection
s = socket(AF_INET, SOCK_STREAM,0)
connect(s, ServerAddress)
Listening and accepting a connection
s = socket(AF_INET, SOCK_STREAM,0)
bind(s, ServerAddress);
listen(s,5);
sNew = accept(s, ClientAddress);
write(s, "message", length)
n = read(sNew, buffer, amount)
ServerAddress and ClientAddress are socket addresses
35
Summary
Messages
Different primitives
Communication
UDP Datagram
TCP Stream
EDR and Marshalling
Request-reply-protocol
Group Communication
UNIX Socket
36