Transcript Creating a Distributed System with RMI

Creating a Distributed System
with RMI
B.Ramamurthy
3/26/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.
3/26/2016
B.Ramamurthy
2
RMI-based Distributed System
4.
5.
3.
XYZ
Client
3.
1.
XYZ
interface
Client Host
3/26/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.
3/26/2016
B.Ramamurthy
4
Compile and Register
Commands
Finds object by name
5.
rmiregistry
rmic
Compile
3.
XYZ
Client
1.
XYZ
interface
Client Host
3/26/2016
3.
2.
XYZ
Implementation
Stub
Stub
uses
Stores object by name
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.
3/26/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.
3/26/2016
B.Ramamurthy
7
Case Study
Take a look at:
http://download.oracle.com/javase/6/d
ocs/technotes/guides/rmi/hello/helloworld.html
3/26/2016
B.Ramamurthy
8
Defining Remote Interface
import java.rmi.*;
// the interface extends Remote interface
// any class implementing Remote can be
accessed remotely security permitting
public interface XYZ extends Remote
{ // specify methods that can be called
remotely
// each method “throws RemoteException”
}
3/26/2016
B.Ramamurthy
9
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.
3/26/2016
B.Ramamurthy
10
Implementing the Remote
Interface
import java.rmi.*;
import java.rmi.server.*;
import java.net.*;
// others as needed
XYZImpl
implements TemperatureServer {
The main method instantiates an object for
the service, and registers it with rmiregistry.
3/26/2016
B.Ramamurthy
11
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/XYZServer
For a remote host
//127.0.0.1/XYZServer
3/26/2016
B.Ramamurthy
12
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.
3/26/2016
B.Ramamurthy
13
The Client
import java.rmi.*;
// import other packages
constructor takes care of lookup of
remote object and access.
3/26/2016
B.Ramamurthy
14
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.
3/26/2016
B.Ramamurthy
15
Preparing the Application
1. Compile all the class using javac.
2. Then start the registry (this will be
running as a daemon)
rmiregistry &
3/26/2016
B.Ramamurthy
16
Preparing the Application
4. Run the server which will register with
the RMI registry.
Java XYZServerImpl &
5. Run the client.
Java XYZClient parameters&
3/26/2016
B.Ramamurthy
17
Inside RMI
http://download.oracle.com/javase/6/docs/
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.
3/26/2016
B.Ramamurthy
18
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
3/26/2016
Remote.java
MarshalledObject.java
Naming.java
activation
dgc
Registry
server
B.Ramamurthy
19
The role of proxy and skeleton (stub) 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”
3/26/2016
B.Ramamurthy
20
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.
3/26/2016
B.Ramamurthy
21
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).
3/26/2016
B.Ramamurthy
22
RMI Internals: Remote
References
Action of remote reference module: See
RemoteRef.java interface


3/26/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
23
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 RemoteStub for each
class representing a remote object.
 It receives request message from comm. module
 It used MessageId to select appropriate method in RemoteStub.
 RemoteStub and dispatcher use same MessageId.
RemoteStub: A class of remote object has a that stands for 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.
Binder: binds textual names to remote object references. RMIRegistry
is a binder; Naming class; see fig.5.13 We will discuss this next.
Server Threads: one thread per invocation
Distributed garbage collection: See Andrew Birell’s paper [1995].
3/26/2016
B.Ramamurthy
24
Reference
Java.rmi The remote method invocation
guide, by E. Pitt and K. Mcniff, Addison
Wesley, ISBN: 0-201-700043-3, 2001
3/26/2016
B.Ramamurthy
25
Simple RMI System Model
Host M/C
Registry
Client M/C
JVM
server
JVM
server
ClientApp
Remote interface
3/26/2016
B.Ramamurthy
26
Registry (singleton – per
system - during production)
Name
Reference
Mortgage
Tempertur
3/26/2016
B.Ramamurthy
27
Semantics of remote method
invocation
•
•
•
•
•
•
•
•
•
•
A remote method has to be declared to throw a remote exception.
Clients of a remote method should try, catch and deal with remote exceptions.
Arguments of object type to the remote method are passed by deep copy and
not by reference
Any results of object type returned by deep copy, not by reference
Any exception (object) thrown is also returned as deep copy
Java.lang.Object is specialized for remote objects and remote references
“At most once” semantics: idempotent: very important for transactional systems
Remote objects are subject to distributed garbage collection via reference
counting, before local garbage collection is applied.
To be accessible, a remote object must implement “remote” interface (or the
interface marked as Remote by the marker interface) and be exported to the
RMI system.
Execution of remote object is asynchronous but synchronicity is realized using
the underlying network.
3/26/2016
B.Ramamurthy
28
Serialization
Serialization is a the operation of encoding objects
into stream of bytes: bytification.
De-serialization is taking the bytes and constructing
objects out of the byte stream.
Is used to marshal and unmarshal arguments and
results.
If serialization is not addressed your distributed
system will not work: whether it be your mobile
systems or land networked system. A stumbling block
for many who are new to DS.
3/26/2016
B.Ramamurthy
29
Serialization (contd.)
In order for an object to be passed
around in a DS it must implement
Serializable interface (another marker
interface: Remote was the first one we
saw)
For performance reasons you may want
to specify the serialization version
(though not required) serialVersionUID
3/26/2016
B.Ramamurthy
30
Serialization (contd.) (not UML
diagram)
A
A
A
A
B
B
B
C
C
C
A
Incorrectly de-serialized
B
C1
3/26/2016
C2
B.Ramamurthy
Once an object is serialized,
serialized object is reused
31
Reference
http://download.oracle.com/javase/6/d
ocs/technotes/guides/rmi/index.html
3/26/2016
B.Ramamurthy
32
RMI package: Registry
Naming is class that provided lookup, bind, unbind,
rebind and list for remote object references: higher
level
Registry for a Registry interface: with the above
methods at a lower level: you have to locate the
registry object and then invoke the methods
rmi://host:port/name
Fully qualified identification/reference for a remote
object.
3/26/2016
B.Ramamurthy
33
Registry
You can create a registry
Start a registry
Get registry location: LocateRegistry
class
Then do binding, lookup etc.
3/26/2016
B.Ramamurthy
34
UnicastRemoteObject
UnicastRemoteObject is a base for your
remote object that provides simple
transient point-point RMI servers.
There are other features that we have
not covered such as security model
using policy files that is in the demo
that we posted in handout#1
3/26/2016
B.Ramamurthy
35
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://download.oracle.com/javase/tutorial/reflect/ind
ex.html
Reflection feature allowed for dynamic creation of
stubs in Java 2 version onwards.
Read more about reflection model in computing.
3/26/2016
B.Ramamurthy
36
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).
3/26/2016
B.Ramamurthy
37
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);
3/26/2016
B.Ramamurthy
38
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.
3/26/2016
B.Ramamurthy
39
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, …
3/26/2016
B.Ramamurthy
40