Distributed Objects and Remote

Invocation: RMI & CORBA

http://java.sun.com/docs/books/tutorial/rmi/
Outline

 Introduction to RMI
 RMI Architecture
 RMI Programming and a Sample Example:
 Server-Side RMI programming
 Client-Side RMI programming
 Advanced RMI Concepts
 Security Policies
 Exceptions
 Dynamic Loading
 A more advanced RMI application
 File Server

2
What is Java RMI?

 Java Remote Method Invocation (Java RMI) enables

the programmer to create distributed Java
technology-based applications, in which the methods
of remote Java objects can be invoked from other
Java virtual machines*, possibly on different hosts.
 RMI uses object serialization to marshal and
unmarshal parameters and does not truncate types,
supporting true object-oriented polymorphism.
 Releases of Java RMI
 Java RMI is available for Java Standard Edition (JSE) and
Java Micro Edition (JME).

3
RMI Architecture & Components
 Remote reference module is responsible for providing addressing to the
proxy (stub) object
 Proxy is used to implement a stub and provide transparency to the client. It is
invoked directly by the client (as if the proxy itself was the remote object),
and then marshal the invocation into a request
 Communication module is responsible for networking
 Dispatcher selects the proper skeleton and forward message to it
 Skeleton un-marshals the request and calls the remote object

client server
remote
skeleton object B
object Aproxy for B Request & dispatcher
for B’s class

Reply

servant
Remote Communication CommunicationRemote reference
4 module module module
reference module
Invocation Lifecycle

Client Server

Client Code RMI Object

Invoke Returns Calls actual Returns
method via
stub 1 8 response method
with args 4 5
response /
exception

Stub Skeleton
Serializes Receives, Receives, Serialises
arguments, deserialises deserialises response,
transmit
2 7
response arguments
3 6 transmit

Network
5
Steps of implementing an RMI application

 Design and implement the components of your

distributed application

Remote interface

Servant program

Server program

Client program
 Compile source and generate stubs

Client proxy stub

Server dispatcher and skeleton
 Make classes network accessible

Distribute the application on server side
 Start the application

6
RMI Programming and Examples

 Application Design

Remote Interface
 Exposes the set of methods and properties available
 Defines the contract between the client and the server
 Constitutes the root for both stub and skeleton

Servant component
 Represents the remote object (skeleton)
 Implements the remote interface

Server component
 Main driver that makes available the servant
 It usually registers with the naming service

Client component

7
Example application – Hello World

 Server side
 Create a HelloWorld interface
 Implement HelloWorld interface with methods
 Create a main method to register the HelloWorld
service in the RMI Name Registry
 Generate Stubs and Start RMI registry
 Start Server
 Client side
 Write a simple Client with main to lookup
HelloWorld Service and invoke the methods

8
Explanation: Server Side

 Restrictions on the Remote interface

 User defined interface must extend java.rmi.Remote interface
 Methods inside the remote interface must throw java.rmi.RemoteException
 Servant class is recommended to extend java.rmi.server.UnicastRemoteObject
 Servant that does not extend UnicastRemoteObject need to export explicitly

UnicastRemoteObject.export(Remote remoteObj);
 Name Service: RMI Registry
 Bind, unbind and rebind remote object to specified name
 All the classes required need to be on rmiregistry classpath
 java.rmi.Naming is an interface for binding object name (URL) to the registry
 Format of object URL
 //host:port/objectname (implicit declaration of RMI protocol for name)

Eg. //localhost/HelloWorldService or rmi://localhost/HelloWorldService
 Default port is 1099
 For security reason, a server program can bind, unbind and rebind only on its same host
 Prevent any binding from the remote clients
 Lookup can be invoked everywhere
 After the binding, the remote object will not be reclaimed in garbage collection until the
server unbinds it
 Because it is remotely referred by the registry (running in a separate JVM)

9
Server Side : Define an interface
(cs652/HelloWorld.java)

package cs652;

import java.rmi.Remote;
import java.rmi.RemoteException;

public interface HelloWorld extends Remote {

public String sayHello(String who) throws
RemoteException;
}

10
Implementing a remote
interface(cs652/HelloWorldImpl.java)
package cs652;
import java.rmi.Naming;
import java.rmi.Remote;
import java.rmi.RemoteException;
import java.rmi.server.UnicastRemoteObject;
public class HelloWorldImpl extends UnicastRemoteObject implements HelloWorld {
public HelloWorldImpl() throws RemoteException {
super();
}
public String sayHello(String who) throws RemoteException {
return "Hello "+who+" from your friend RMI 433-652 :-)";
}
public static void main(String[] args) {
String hostName = "localhost";
String serviceName = "HelloWorldService";
if(args.length == 2){
hostName = args[0];
serviceName = args[1];
}
try{
HelloWorld hello = new HelloWorldImpl();
Naming.rebind("rmi://"+hostName+"/"+serviceName, hello);
System.out.println("HelloWorld RMI Server is running...");
}catch(Exception e){}
}
}11
Generate Stubs and Start RMI registry

 Compile

javac cs652/HelloWorld.java

javac cs652/HelloWorldImpl.java
 Generate Stubs

rmic cs652.HelloWorldImpl
 Start RMI registry

start rmiregistry (windows)

rmiregistry 10000 & (unix)
 Start HelloWorld Server

java cs652.HelloWorldImpl

java cs652.HelloWorldImpl localhost:10000
HelloWorldService

12
Explanation: Client Side

RMI Registry RMI Service

Get
Lookup Service
Service Reference

Client
Invoke RMI Remote Object
Service

 Look up the server registry

 Based on the targeting object URL
 Get the remote object reference from the Registry
 Invoke the methods on the remote object reference

13
Client Side : A Simple Client
(cs652/RMIClient.java)

package cs652;
import java.rmi.Naming;
public class RMIClient {
public static void main(String[] args) {
String hostName = "localhost";
String serviceName = "HelloWorldService";
String who = "Raj";
if(args.length == 3){
hostName = args[0];
serviceName = args[1];
who = args[2];
}else if(args.length == 1){
who = args[0];
}
try{
HelloWorld hello = (HelloWorld)Naming.lookup("rmi://"+hostName+"/"+serviceName);
System.out.println(hello.sayHello(who));
}catch(Exception e){
e.printStackTrace();
}
}
}

14
Compile and Run

 Compile
 javac cs652/RMIClient.java
 Run it
 java cs652.RMIClient
 java cs652.RMIClient localhost HelloWorldService
Raj
 java cs652.RMIClient manjra.cs.mu.oz.au:10000
HelloWorldService Raj

15
Security Manager

 Java’s security framework

 java.security.-

 Permissions, Principle, Domain etc.

 Security manager, for access control (file, socket, class load,

remote code etc)

 $JAVA_HOME/jre/lib/security/java.policy

 Use security manager in RMI

 RMI recommends to install a security manager, or RMI may not

work properly while encountering security constraints.

 A security manager ensures that the operations performed by

downloaded code go through a set of security checks.


Eg. Connect and accept ports for RMI socket and allowing code
downloading

16
Security Manager (cont.)

 Two ways to declare security manager

 Use System property java.security.manager
java –Djava.security.manager cs652.HelloWorldImpl
 Explicit declare in the source code
public static void main(String[]args){
//check current security manager
if(System.getSecurityManager()==null){
System.setSecurityManager(new RMISecurityManager());
}
…
//lookup remote object and invoke methods.
}
 Use customized policy file instead of java.policy
 Usage
java -Djava.security.manager -Djava.security.policy=local.policy
cs652.HelloWorldImpl

17
File: “local.policy” contents

Specific permissions:

grant {
permission java.net.SocketPermission "*:1024-65535","connect,accept";
permission java.io.FilePermission "/home/globus/RMITutorial/-", "read";
};

Grant all permissions:

grant {
permission java.security.AllPermission;
};

18
Exceptions

 The only exception that could be thrown out is

RemoteException
 All RMI remote methods have to throw this exception
 The embedded exceptions could be:
 java.net.UnknownHostException or
java.net.ConnectException: if the client can’t connect to the
server using the given hostname. Server may not be running
at the moment
 java.rmi.UnmarshalException: if some classes not found.
This may because the codebase has not been properly set
 Java.security.AccessControlException: if the security policy
file java.policy has not been properly configured

19
Passing objects

 Restrictions on exchanging objects

 Implementing java.io.serializable
 All the fields in a serializable object must be also
serializable
 Primitives are serializable
 System related features (e.g. Thread, File) are non-
serializable
 How about the socket programming issues?
 Where are sockets and corresponding input, output
streams?
 How to handle object passing?
 Who does all the magic?

20
RMI Dynamic Class Loading

 Ability to download bytecode (classes) from

Remote JVM
 New types can be introduced into a remote
virtual machine without informing the client
 Extend the behavior of an application dynamically
 Removes the need to deploy stubs manually
 Explicit set property to support dynamic class
load
 Specify system property java.rmi.server.codebase
to tell the program where to download classes

21
Sample scenario : File Server

Unix File Server

Windows File Server

Mac File Server

User
File Server Scenario

 Basic Requirements ( File Server )


Get the files from the File Server on specific directory

Create new files on the File Server

Create new directories on the File Server

Delete files or directory on the File Server
 Client

A File Browser to explore the file system on the File Server
supporting view, create and delete functionalities.
22
Programming File Server
 Create RMI remote interface
public interface FileServer extends Remote {
public Map getFiles(String baseDir) throws RemoteException;
public Map getFiles(String baseDir,boolean upper) throws RemoteException;
public void createFile(String filename,boolean isDir) throws RemoteException;
public void deleteFile(String filename) throws RemoteException;
}
 Implement the Servant

FileServerImpl.java [FileServerImpl implements FileServer]
 Implement the Server
public class RMIFileServer{
public static void main(String [] args){
try{
String host = "localhost";
if(args.length == 1){
host = args[0];
}
Naming.rebind("//"+host+"/FileServer",new FileServerImpl());
}catch(Exception e){}
}
}
 Generate Stub

rmic –keep cs652.rmi.server.FileServerImpl (keep option is to keep the generated java file)

23
Programming File Browser

 Create a Subclass of JFrame

 RMIFileBrowser.java

 Locate the FileServer Object

private FileServer findFileServer(String serviceURI)throws Exception{
return (FileServer)Naming.lookup("rmi://"+serviceURI);
}
 Invoke the appropriate methods
Get Files : Map result = getFileServer().getFiles(dir,upper);
Create File: getFileServer().createFile(absoluteFilePath,false/*isDir=false*/);
Create Dir: getFileServer().createFile(absoluteFilePath,true/*isDir=true*/);
Delete File: getFileServer().deleteFile(absoluteFilePath);
 Write a local policy file
Grant{
java.security.AllPermission;
};

24
Run it!

 Two steps
 Start the server


start rmiregistry (be aware of your classpath)

java cs652.rmi.server.RMIFileServer
 Start the client

java -Djava.security.manager -Djava.security.policy=local.policy
cs652.demo.RMIFileBrowser
Note: Required classes including the generated stubs must be visible
by java classloader.

25
Potential error - no security manager!

26
Successful execution

27
Summary: RMI Programming

 RMI greatly simplifies creation of distributed

applications (e.g., compare RMI code with socket-
based apps)
 Server Side

Define interface that extend java.rmi.Remote

Servant class both implements the interface and extends
java.rmi.server.UnicastRemoteObject

Register the remote object into RMI registry

Ensure both rmiregistry and the server is running
 Client Side

No restriction on client implementation, both thin and rich
client can be used. (Console, Swing, or Web client such as
servlet and JSP)

28