1. Communication between distributed objects Remote procedure call
Chapter 5: Distributed objects and remote invocation
Introduction
Communication between distributed objects
Remote procedure call
Events and notifications
Java RMI case study
Summary

2. Provide a programming model Provide transparence
Middleware
Layers of Middleware
Provide a programming model
Provide transparence
Location
Communication protocols
Computer hardware
Operating systems
Programming languages

3. Distributed programming model
Remote procedure call (RPC)
call procedure in separate process
Remote method invocation (RMI)
extension of local method invocation in OO model
invoke the methods of an object of another process
Event-based model
Register interested events of other objects
Receive notification of the events at other objects

4. Interface in distributed system
Interfaces
Interface
Specifies accessible procedures and variables
Inner alteration won’t affect the user of the interface
Interface in distributed system
Can’t access variables directly
Input argument and output argument
Pointers can’t be passed as arguments or returned results

5. RPC’s Service interface
Interface cases
RPC’s Service interface
specification of the procedures of the server
input and output arguments of each procedure
RMI’s Remote interface
Specification of the methods of an object that are available for objects in other processes
may pass objects or remote object references as arguments or returned result
Interface definition languages
program language, e.g. Java RMI
Interface definition language (IDL), e.g. CORBA IDL, DCE IDL and DCOM IDL

6. Communication between distributed objects Remote procedure call
Chapter 5: Distributed objects and remote invocation
Introduction
Communication between distributed objects
Remote procedure call
Events and notifications
Java RMI case study
Summary

7. Discuss RMI under following headings
The object model
Distributed objects
The distributed object model
Design issues
semantics of remote invocations
Implementation
RMI above the request-reply protocol
Distributed garbage collections

8. The object model Object references Interfaces Actions
Objects can be accessed via object references
First-class values
Interfaces
A definition of the signatures of a set of methods
No constructers
A class can implement several interfaces, e.g. Java
Actions
Initiated by an object invoking a method in another object
Two affects
Change the state of the receiver
Further invocations on methods in other objects

9. The object model … continued
Exceptions mechanism
A clean way to deal with error conditions
List exceptions at the method head
throw user know exceptions
Catch exceptions
Garbage collection
Freeing the space occupied by cancelled objects
C++: collected by programmers
Java: collected by JVM

10. Benefits of distributed objects
Natural extension
physical distribution of objects into different processes or computers in a distributed system
Benefits of distributed objects
Enforce encapsulation
can’t access variables directly
Support heterogeneous systems
Local object cache
Assume other architectural models
Replicated objects
Migrated objects

11. The distributed objects model
Remote object reference
An unique identifier in a distributed system
May be passed as arguments and results of remote method invocation
Remote interface
remote object class implements the methods of its remote interface
Actions in a distributed system
may incur a chain of invocations on different computers
Garbage collection
Usually based on reference counting
Exception
notify the client and the client handle exceptions

12. Design Issues – Invocation semantics
Choices for different delivery guarantees
retry request message
duplicate filtering
retransmission of results
Three different semantics
Fault tolerance measures
Invocation
semantics
Retransmit request
message
Duplicate
filtering
Re-execute procedure
or retransmit reply No
Yes
Not applicable
Retransmit reply
At-most-once
At-least-once
Maybe

13. Different invocation semantics
Maybe
For invoker: executed once, or not at all ???
Suffer from: (1) message lost; (2) server crash
Useful for app. in which occasional failed invocation are acceptable
At least once
For invoker: execute at least once, or an exception
Suffer from: (1) server crash; (2) arbitrary failures for non-idempotent method
At most once
For invoker: receives result, or an exception
Prevent: omission failures by retrying, arbitrary failures

14. Design Issues - Transparency
What can be made transparent
marshal
message passing
object locating and contacting
What can’t be made transparent
vulnerable to failure
latency
Current consensus
transparent in syntax
different in expression

15. Remote reference module
Implementation of RMI
The inner scene of RMI
Communication module
Request/reply between client and server
Select dispatcher at server side
Remote reference module
Translate between local and remote object reference
Create remote object reference
Remote object table
entries for remote objects held by the process
entries for local proxies

16. Implementation of RMI – RMI software
Proxy
forward invocation to remote object
one remote object one proxy
Skeleton
implement the method in the remote interface
unmarshal the arguments in the request
invoke the corresponding method in the remote object
wait for the invocation complete
marshal the result in the reply message
Dispatcher
select appropriate method in the skeleton
one dispatcher and skeleton for one remote object

17. Implementation of RMI - execution
The classes for proxies, dispatchers and skeletons
generated automatically by an interface compiler, e.g. rmic
Server program
create and initialize at least one of the remote objects
register
Client program
look up the remote object references
invoke
The binder
Maintain mapping information of textual names to remote object references

18. Implementation of RMI - Object state
Activation of remote objects
to avoid resource waste, the servers can be started whenever they are needed
a remote object could be active or passive
Persistent object stores
Persistent object
an object that is guaranteed to live between activations of processes
different passivate strategies
at the end of a transaction
when the program exit
E.g., Persistent Java, PerDiS

19. Distributed garbage collection
The aim of a distributed garbage collector
Retain the object (local&remote) when it is still be referenced
Collect the object when none holds reference to it
Java distributed garbage collection algorithm
based on reference counting
server maintain processes set that hold remote object references to it
client notify server to modify the process set
when the process set becomes empty, server local garbage collector reclaims the space
Leases in Jini
lease: the granting of the use of a resource for a period of time
avoid to discover whether the resource users are still interested or their programs have not exited

20. Communication between distributed objects Remote procedure call
Chapter 5: Distributed objects and remote invocation
Introduction
Communication between distributed objects
Remote procedure call
Events and notifications
Java RMI case study
Summary

21. RPC is very similar to RMI
Service interface: the procedures that are available for remote calling
Invocation semantics choice: at-least-once or at-most-once
Generally implemented over request-reply protocol
Building blocks
Communication module
Client stub procedure (as proxy in RMI): marshalling, sending, unmarshalling
Dispatcher: select one of the server stub procedures
Server stub procedure (as skeleton in RMI): unmarshalling, calling, marshalling
client
Request
Reply
Communication
module
dispatcher
service
client stub
server stub
procedure
client process
server process
program

22. XDR - Interface definition language
Sun RPC case study
Designed for NFS
at-least-once semantics
XDR - Interface definition language
Interface name: Program number, version number
Procedure identifier: procedure number
Rpcgen – generator of RPC components
client stub procedure
server main procedure
Dispatcher
server stub procedure
marshalling and unmarshalling procedure

23. Sun RPC case study …continued
Binding – portmapper
Server: register ((program number, version number), port number)
Client: request port number by (program number, version number)
Authentication
Each request contains the credentials of the user, e.g. uid and gid of the user
Access control according to the credential information

24. Communication between distributed objects Remote procedure call
Chapter 5: Distributed objects and remote invocation
Introduction
Communication between distributed objects
Remote procedure call
Events and notifications
Java RMI case study
Summary

25. Event-notification model
Idea
one object react to a change occurring in another object
Event examples
modification of a document
an electronically tagged book being at a new location
Publish/subscribe paradigm
event generator publish the type of events
event receiver subscribe to the types of events that are interest to them
When event occur, notify the receiver
Distributed event-based system – two characteristics
Heterogeneous
asynchronous

26. Example - dealing room system
Requirements
allow dealers to see the latest market price information
System components
Information provider
receive new trading information
publish stocks prices event
stock price update notification
Dealer process
subscribe stocks prices event
System architecture

27. Architecture for distributed event notification
Event service: maintain a database of published events and of subscribers’ interests
decouple the publishers from the subscribers
subscriber
observer
object of interest
Event service 3. 1. 2.
notification

28. The roles of the participating objects
The object of interest
its changes of state might be of interest to other objects
Event
the completion of a method execution
Notification
an object that contains information about an event
Subscriber
an object that has subscribed to some type of events in another object
Observer objects
the main purpose is to decouple an object of interest from its subscribers
Publisher
an object that declares that it will generate notifications of particular types of event

29. Notification delivery
Delivery semantics
Unreliable
Reliable
real-time
Roles for observers
Forwarding
send notifications to subscribers on behalf of one or more objects of interests
Filtering of notifications
Patterns of events
Notification mailboxes
notification be delayed until subscriber being ready to receive

30. Jini distributed event specification
EventGenerator interface
Provide register method
Event generator implement it
Subscriber invoke it to subscribe to the interested events
RemoteEventListener interface
Provide notify method
subscriber implement it
receive notifications when the notify method is invoked
RemoteEvent
a notification that is passed as argument to the notify method
Third-party agents
interpose between an object of interest and a subscriber
equivalent of observer

31. Communication between distributed objects Remote procedure call
Chapter 5: Distributed objects and remote invocation
Introduction
Communication between distributed objects
Remote procedure call
Events and notifications
Java RMI case study
Summary

32. Arguments and return results of remote method
Java RMI introduction
Remote object
Must implement the remote interface
must handle remote exceptions
Arguments and return results of remote method
Must be serializable
All primitive types serializable
remote objects are serializable
File handles are unserializable
Remote objects are passed as remote object reference, non-remote serializable objects are copied and passed by value
RMIregistry
access by the Naming class

33. Example: shared whiteboard
Remote Interface
Server program and Client program
Callbacks
A server’s action of notifying clients about an event
Implementation
Client create a remote object
Client pass the remote object reference to server
Whenever an event occurs, server call client via the remote object
Advantage
Improve performance by avoid constant polling
Delivery information in a timely manner

34. Java classes supporting RMI
Design and implementation of Java RMI
Java classes supporting RMI
RemoteServer
UnicastRemoteObject
<servant class>
Activatable
RemoteObject

35. Communication between distributed objects Remote procedure call
Chapter 5: Distributed objects and remote invocation
Introduction
Communication between distributed objects
Remote procedure call
Events and notifications
Java RMI case study
Summary

36. Summary Two paradigms for distributed programming RMI Sun RPC
RMI(RPC)/Event notification: sync./async.
RMI
Distributed object model
Remote interface, remote exception, naming service
Remote invocation semantics
Once, at-least-once, at-most-once
Example: whiteboard based on Java RMI
Sun RPC
Event-notification
Publish/subscribe
Event service
Example: dealing room

37. Middleware layers Applications RMI, RPC and events Middleware
Request reply protocol
External data representation
Operating System
RMI, RPC and events

38. CORBA IDL example // In file Person.idl struct Person { string name;
string place;
long year;
} ;
interface PersonList {
readonly attribute string listname;
void addPerson(in Person p) ;
void getPerson(in string name, out Person p);
long number(); };

39. { A remote object and its remote interface object Data remote
implementation
object {
of methods

40. Remote and local method invocationsB C D E F

41. The role of proxy and skeleton in remote method invocation
object A
object B
skeleton
Request
proxy for B
Reply
Communication
Remote
Remote reference
module
reference module
for B’s class
& dispatcher
remote
client
server

42. Files interface in Sun XDR
const MAX = 1000;
typedef int FileIdentifier;
typedef int FilePointer;
typedef int Length;
struct Data {
int length;
char buffer[MAX]; };
struct writeargs {
FileIdentifier f;
FilePointer position;
Data data;
struct readargs {
Length length;
program FILEREADWRITE {
version VERSION {
void WRITE(writeargs)=1; 1
Data READ(readargs)=2; 2
}=2;
} = 9999;

43. Dealing room system Dealer’s computer Information provider Dealer
External
source
Notification

44. The Naming class of Java RMIregistry
void rebind (String name, Remote obj)
This method is used by a server to register the identifier of a remote object by name, as shown in Figure 15.13, line 3.
void bind (String name, Remote obj)
This method can alternatively be used by a server to register a remote object by name, but if the name is already bound to a remote object reference an exception is thrown.
void unbind (String name, Remote obj)
This method removes a binding.
Remote lookup(String name)
This method is used by clients to look up a remote object by name, as shown in Figure line 1. A remote object reference is returned.
String [] list()
This method returns an array of Strings containing the names bound in the registry.

45. Java Remote interfaces Shape and ShapeList
import java.rmi.*;
import java.util.Vector;
public interface Shape extends Remote {
int getVersion() throws RemoteException;
GraphicalObject getAllState() throws RemoteException; 1 }
public interface ShapeList extends Remote {
Shape newShape(GraphicalObject g) throws RemoteException; 2
Vector allShapes() throws RemoteException;

46. Java class ShapeListServant implements interface ShapeList
import java.rmi.*;
import java.rmi.server.UnicastRemoteObject;
import java.util.Vector;
public class ShapeListServant extends UnicastRemoteObject implements ShapeList {
private Vector theList; // contains the list of Shapes 1
private int version;
public ShapeListServant()throws RemoteException{...}
public Shape newShape(GraphicalObject g) throws RemoteException { 2
version++;
Shape s = new ShapeServant( g, version); 3
theList.addElement(s);
return s; }
public Vector allShapes()throws RemoteException{...}
public int getVersion() throws RemoteException { ... }

47. Java class ShapeListServer with main method
import java.rmi.*;
public class ShapeListServer{
public static void main(String args[]){
System.setSecurityManager(new RMISecurityManager());
try{
ShapeList aShapeList = new ShapeListServant(); 1
Naming.rebind("Shape List", aShapeList ); 2
System.out.println("ShapeList server ready");
}catch(Exception e) {
System.out.println("ShapeList server main " + e.getMessage());} }

48. Java client of ShapeList
import java.rmi.*;
import java.rmi.server.*;
import java.util.Vector;
public class ShapeListClient{
public static void main(String args[]){
System.setSecurityManager(new RMISecurityManager());
ShapeList aShapeList = null;
try{
aShapeList = (ShapeList) Naming.lookup("//bruno.ShapeList") ; 1
Vector sList = aShapeList.allShapes(); 2
} catch(RemoteException e) {System.out.println(e.getMessage());
}catch(Exception e) {System.out.println("Client: " + e.getMessage());} }

49. Callback mechanism in the whiteboard system
Client created remote object:
Public interface WhiteboardCallback implements Remote{
void callback(int version) throws RemoteException; }
Methods added in Shapelist interface:
Int register(WhiteboardCallback callback) throws RemoteException;
Void deregister(int callbackID) throws RemoteException;