Transcript Creating a Distributed System with RMI B.Ramamurthy 5/25/2016

Creating a Distributed System
with RMI
B.Ramamurthy
5/25/2016
B.Ramamurthy
1
Remote Method Invocation
Remote Method Invocation (RMI) is Java’s
implementation of object-to-object
communication among Java objects to realize
a distributed computing model.
RMI allows us to distribute our objects on
various machines, and invoke methods on the
objects located on remote sites.
Source code for the demo is a modified
version of code in Chapter 20 of Deitel &
Deitel’s text Java : How to Program.
5/25/2016
B.Ramamurthy
2
RMI-based Distributed System
4.
5.
3.
XYZ
Client
3.
1.
XYZ
interface
Client Host
5/25/2016
XYZ
Implementation
Stub
Stub
uses
2.
implements
Server Host
B.Ramamurthy
3
Steps in RMI-based
Application
1. Design the interface for the service.
2. Implement the methods specified in
the interface.
3. Generate the stub and the skeleton.
4. Register the service by name and
location.
5. Use the service in an application.
5/25/2016
B.Ramamurthy
4
Compile and Register
Commands
Finds object by name
5.
rmiregistry
rmic
3.
XYZ
Client
3.
1.
XYZ
interface
Client Host
5/25/2016
2.
Skeleton
Stub
uses
Stores object by name
XYZ
Implementation
implements
Server Host
B.Ramamurthy
5
More Details
Once the object (or service) is registered, a
client can look up that service.
A client (application) receives a reference that
allows the client to use the service (call the
method).
Syntax of calling is identical to a call to a
method of another object in the same
program.
5/25/2016
B.Ramamurthy
6
Parameter Marshalling
Transfer of parameters (or marshalling)
is done by the RMI.
Complex objects are streamed using
Serialization.
RMI model of networking for distributed
system involves only Java.
No need to learn IDL or any other
language.
5/25/2016
B.Ramamurthy
7
Case Study : Temperature
Service
Lets create a distributed system using
RMI model for networking (remote
access).
Basically this program will download the
weather (temperature) information from
the site:
http://iwin.nws.noaa.gov/iwin/us/traveler.html
5/25/2016
B.Ramamurthy
8
Temperature Client/Server
Distributed Application
rmic
4
compiles
5.
3.
TempClient
TempImpl_Stub
uses
generates
uses
3.
2.
TempImpl_Stub
TempServerImpl
1.
implements
TempServer
Client Host
5/25/2016
Server Host
B.Ramamurthy
9
Defining Remote Interface
import java.rmi.*;
// the interface extends Remote interface
// any class implementing Remote can be
accessed remotely security permitting
public interface TemperatureServer extends
Remote
{ // specify methods that can be called
remotely
// each method “throws RemoteException”
}
5/25/2016
B.Ramamurthy
10
RemoteException
Any time you depend on outside entities
there is a potential for problems in
communication, networking, server crash etc.
Any exception due to these should be
handled by the services.
This feature imparts robustness to the
application.
Java mandates this feature for any RMI
service.
5/25/2016
B.Ramamurthy
11
Implementing the Remote
Interface
import java.rmi.*;
import java.rmi.server.*;
import java.net.*;
// others as needed
TemperatureServerImpl
extends UnicastRemoteObject
implements TemperatureServer {
5/25/2016
B.Ramamurthy
12
TemperatureServerImpl
This class’s constructor calls a private method
which in turn:
1. Connects to the url specified
2. Streams into a buffer the page referenced.
3. Parses the buffer to get the required data.
4. Creates an array of weather information.
5/25/2016
B.Ramamurthy
13
TemperatureServerImpl
(contd.)
It implements the service method
getWeatherInfo which simply returns
the weather data gathered.
The main method instantiates an object
for the service, and registers it with
rmiregistry.
5/25/2016
B.Ramamurthy
14
Streaming URLs
Using the openStream of java.net.URL class
you can stream in the file spefied by an
universal resource locator(url).
It can be streamed into a buffer where it can
be analyzed for information.
Any number of urls can be streamed in.
Unicast Communication : When you are
interested in a particular remote site you will
direct your net connection to that particular
site using unicast.
5/25/2016
B.Ramamurthy
15
Server Object Name
Syntax for the server object name is:
//host:port/remoteObjectName
Default port number for rmiregistry is 1099
For local host the object name:
//localhost/TempServer
For a remote host
//127.0.0.1/TempServer
5/25/2016
B.Ramamurthy
16
Name Binding
rebind method binds a server’s object
name to the object’s name as it is in the
registry.
Clients use the name in the registry.
There is also a bind() method.
But rebind is better since it binds the
most recently registered object.
5/25/2016
B.Ramamurthy
17
WeatherInfo class
It is very traditional class for keeping
the information about the temperature
at a single location.
It has data fields : cityName,
temperature, and description and get
methods for these.
An array of objects of this class is used
in the server implementation.
5/25/2016
B.Ramamurthy
18
Temperature Client
import java.rmi.*;
// import other packages
constructor calls a private method
getRemoteTemp which takes care of
lookup of remote object and access.
In this application it also displays the
information.
5/25/2016
B.Ramamurthy
19
Temperature Client (contd.)
The main method in this client can get
the IP address of the remote host as a
command line argument.
Command line argument is an array of
String of items in the command line
after the name of the application.
5/25/2016
B.Ramamurthy
20
Client Details
The name of the server object along with the
IP of the remote location is used in Naming
class’s lookup method to get an object
reference.
This object reference is then used for remote
method calls.
Observe that there is no difference between
the local and remote call.
WeatherItem class used in the Graphical
display of the weather information.
5/25/2016
B.Ramamurthy
21
Preparing the Application
1. Compile all the class using javac.
2. Generate the stub and the skeleton:
rmic -v1.2 TemperatureServerImpl
3. Then start the registry (this will be
running as a daemon)
rmiregistry &
5/25/2016
B.Ramamurthy
22
Preparing the Application
4. Run the server which will register with the
RMI registry.
Java TemperatureServerImpl &
5. Run the client.
Java TemperatureClient &
or
java TemperatureClient {IPAddress}
java TemperatureClient 192.168.0.150
5/25/2016
B.Ramamurthy
23
Inside RMI
http://java.sun.com/j2se/1.5.0/docs/index.html
Basic RMI classes: /usr/java1.1/src/java/rmi
 java.rmi.registry.*
 java.rmi.Naming class (static/class methods)
 java.rmi.Remote interface (marker interface)
 java.rmi.server.*
 Default RMI port 1099
 Both lookup from local and remote are acceptable.
5/25/2016
B.Ramamurthy
24
Implementation of RMI (5.2.5)
AccessException.java
RemoteException.java
AlreadyBoundException.java
ConnectException.java
ServerException.java
ConnectIOException.java
ServerRuntimeException.java
MarshalException.java
StubNotFoundException.java
UnexpectedException.jav
ServerError.java
UnknownHostException.java
NoSuchObjectException.java
UnmarshalException.java
NotBoundException.java
RMISecurityException.java
RMISecurityManager.java
5/25/2016
Remote.java
MarshalledObject.java
Naming.java
activation
dgc
Registry
server
B.Ramamurthy
25
The role of proxy and skeleton
in remote method invocation
server
client
object A proxy for B
Request
skeleton
& dispatcher
for B’s class
remote
object B
Reply
Remote Communication
reference module module
servant
CommunicationRemote reference
module
module
Object A invokes a remote object in Object B for which it holds a remote object
reference.
“System Model”
5/25/2016
B.Ramamurthy
26
RMI Internals: Communication
Module
Carries out request-reply protocol;
On the client side {message type, message
id, remote reference to object} are gathered
and sent out. At most once invocation
semantics;
On the server side, it gets local reference for
remote reference from remote reference
module, invokes a dispatcher with this
reference.
See UnicastRemote (implements
UnicastRemote)
5/25/2016
B.Ramamurthy
27
RMi Internals: Remote
Reference module
Responsible for translating between
local and remote object references and
for creating remote object references.
A remote object table has a mapping
between local and remote references. A
table at server (entry for object ref for
B) and a table at client (entry for object
ref for proxy B).
5/25/2016
B.Ramamurthy
28
RMI Internals: Remote
References
Action of remote reference module: See
RemoteRef.java interface


5/25/2016
When a remote object is to be passed as
argument or result for the first time, the remote
ref is asked to create a remote ref object which is
added to the table.
When a remote object reference arrives in a
request or reply, the remote ref module is asked
for corresponding local object ref, which may
either a proxy or remote object. If it is not in the
table RMI runtime creates it and asks remote ref
module to add it to the table.
B.Ramamurthy
29
RMI Internals: RMI software
Layer of software between application level objects and communication and
remote reference modules: “Middleware”
Proxy: provides remote access transparency. One proxy for every remote object
in the client.
Dispatcher: A server has one dispatcher and skeleton for each class
representing a remote object.
It receives request message from comm. Module
 It used MessageId to select appropriate method in skeleton.
 Proxy and dispatcher use same MessageId.
Skeleton: A class of remote object has a skeleton that implements of the
remote interface. All the access dependencies are hidden in this class. A remote
object has a servant that directly implements the methods. Java 5 creates this

dynamically.
Proxies, dispatcher and skeleton are automatically generated by interface
compiler.
Binder: binds textual names to remote object references. RMIRegistry is a
binder; Naming class; see fig.5.13
Server Threads: one thread per invocation
Distributed garbage collection: See Andrew Birell’s paper [1995].
5/25/2016
B.Ramamurthy
30
RMI Internals: Distributed
Garbage Collection
Based on reference counts.
Local garbage collectors and a distributed support.
Each server holds the list of processes that hold remote object references: for
example, B.Holders
When a client C first receives a remote reference to a particular remote object,
say B, it makes a addRef(B) invocation to server of that remote object and then
creates proxy; server adds C to B.Holders.
When client C’s garbage collector finds that proxy is no longer reachable (ref
count), it makes a removeRef(B) invocation to server and then deletes proxy;
the server removes C from B.Holders.
When B.Holders is empty, server’s local garbage collector will reclaim the space
occupied B unless there are any local holders.
These extra calls for updates occur during proxy creation and deletion and do
not affect normal opertion.
Tolerates communication failures: addRef() and removeRef() are idempotent:
effects of N > 0 identical requests is the same as for a single request.
If addRef() fails with an exception, proxy is not created, removeRef() is
transmitted; removeRef() failures are dealt with by “leases” (Jini kind).
5/25/2016
B.Ramamurthy
31
RMI Internals: Use of
Reflection
What is reflection? See Reflection package
Reflection enables Java code to discover information
about the fields, methods and constructors of loaded
classes, and
To use reflected fields, methods, and constructors to
operate on their underlying counterparts on objects,
within security restrictions.
http://java.sun.com/docs/books/tutorial/reflect/class/index.html
Reflection feature allowed for dynamic creation of skeleton and proxy
in Java 2 version onwards.
Read more about reflection model of computing.
5/25/2016
B.Ramamurthy
32
A Little bit of Reflection
Method class, invoke method
Invoke method requires two
parameters: first the object to receive
invocation, second an array of Object
parameters.
Invoke executes the method on the
object and returns result as Object.
Method m;
Object result = M.invoke(String, Args);
5/25/2016
B.Ramamurthy
33
Using Reflection in RMI
Proxy has to marshal info. about a method and its
arguments into a request message.
For a method it marshals an object of class Method
into the request. It then adds an array of objects for
the method’s arguments.
The dispatcher unmarshals the Method object and its
arguments from request message.
The remote object reference is obtained from remote
ref. table.
The dispatcher then calls the “invoke” method on the
object reference and array of arguments values.
After the method execution the dispatcher marshals
the result or any exceptions into the reply message.
5/25/2016
B.Ramamurthy
34
Summary
We discussed designing a distributed
system using RMI
We also looked at RMI internal
We also learned about marker interface,
distributed garbage collection, object
marshalling, registry, server-port
binding, Naming class of RMI, …
5/25/2016
B.Ramamurthy
35