CMSC 433 Programming Language

Technologies and Paradigms

Java RMI

Distributed Computing
Programs that cooperate and communicate
over a network
E-mail
Web server and web client
SETI @Home

Distributed Computing
Machines are not all the same
But all adhere to same communication protocol

Network is slow
Sending a message takes a lot of time

Network is unreliable
Machines may join and leave with no warning
Part of the network may fail

Distributing Computations
Connecting via sockets
e.g., Logging Server examples
Custom protocols for each application

RPC/DCOM/CORBA/RMI
Make what looks like a normal function call
Function actually invoked on another machine
Arguments/return values are marshalled /
unmarshalled for transport across the network

Remote Method Invocation

Easy way to get distributed computation
Create proxies for remote objects
Calls to proxy get translated into network calls
Implemented on top of sockets

Arguments and return values are passed

over network
Java takes care of the details

A Simplified Example
// runs on one mach.
class ChatServerImpl implements ChatServer ... {
public void say(String s) {
System.out.println(s);
}
...
}
class Chatter { // runs on another mach.
public static void main(String args[]) {
ChatServer c = // get remote object;
BufferedReader br = new BufferedReader(new
InputStreamReader(System.in));
while (true) {
System.out.print(> );
c.say(br.readLine());
}
}
}

Remote Objects
Objects implement a Remote interface
A Remote interface extends java.rmi.Remote
All Remote interface methods throw
RemoteException
Constructor throws RemoteException
RemoteException means something bad
happened on the network

Remote Interfaces

Stubs
Client only sees the RemoteInterface
ConcreteObject can have other methods

Remote objects represented using stub

Stub sends arguments over network
Stub receives result back from network

Passing Arguments
To pass an argument to a Remote method or
return a result from a Remote method,
object/value must be either
A primitive type (int, double, etc.),
Serializable (e.g., String), or
Remote (i.e., implement a sub-interface of
Remote)

Primitives passed as youd expect

Passing Serializable vs. Remote

Serializable objects passed by value
Same Serializable object in different calls
materializes different objects at receiver

Remote objects passed by reference

Same Remote object in different calls yields
same stub object, which passes arguments back
to same remote object

Stub Code
Classes contain both data and code
When you receive a Remote object, you need
the stub for that object

Where does it come from?

Solution #1: Make all clients have the stub
code on their classpath
Or stub code for another class with same
remote interface

Downloading Code
Solution #2: Provide a codebase where stub
code for objects can be downloaded
java -Djava.rmi.server.codebase=<url> ...
Specifies location of code for classes that
originate in this JVM
URL - can be http://, file:/, etc.

Getting the First Remote Object

Can publish objects to an RMI registry
Each object has a name (that you specify)
Registry listens on a port (1099 default)

Naming.lookup(url) gets object from registry

e.g., Naming.lookup(rmi://localhost/Chat);
Used to get first reference to Remote object
Dont need to lookup objects returned by Remote
methods

Starting an RMI Registry

Method 1: Separate RMI registry process
Command rmiregistry
Run with stubs in classpath, or specify codebase

Listens on port 1099 by default

Pros: Registry doesnt die when your program dies
Multiple applications can share registry

Method 2: Start registry in same JVM

LocateRegistry.createRegistry(int port)
Pros: Registry dies when your program dies
No registries lying around on machine

Exporting the Remote Object

UnicastRemoteObject.exportObject(Remote, int) exports
(activates) the Remote object so that it can receive
invocations of its remote methods from Remote clients
The second argument specifies which TCP port to listen on
for incoming remote invocation requests for the object.
The value zero specifies the use of an anonymous port
Use anonymous ports for your class projects
In practice, might use a different port to avoid firewalled ports

Exporting the Remote Object

Method returns a stub for the exported Remote object
Dont have to call this method if your class extends
java.rmi.server.UnicastRemoteObject

Advertising Remote Objects

Call Naming.{bind/unbind/rebind} to
manipulate objects in registry
E.g., Naming.bind(rmi://localhost/Chat);

Can bind/unbind/rebind name only on

localhost
Can lookup name on any host

Example: RMI Chat Server

Server
Runs the chat room

Client
Represents a participant in chat room
Receives messages from others in room

Connection
Links client to Server
Used to speak in chat room

Server
interface Server extends Remote {
Connection logon(String name, Client c)
throws RemoteException;
public Map<String,Client> getUsers()
throws RemoteException;
}

Connection
interface Connection extends Remote {
/** Say to everyone */
void say(String msg)
throws RemoteException;
/ ** Say to one person */
void say(String who, String msg)
throws RemoteException;
String [] getUsers()
throws RemoteException;
void logoff()
throws RemoteException;
}

Client
interface Client extends Remote {
void wasSaid(String who, String msg)
throws RemoteException;
void usersChanged(String [] who)
throws RemoteException;
}

Servers Remote Object Creation

Server s = new ServerImpl();
Hosted
Remote
Objects

ServerImpl

Server

Object added to table

because it implements
subclass of the Remote
interface

Remote Object Registry

Naming.rebind(ChatServer, s);
Hosted
Remote
Objects

ChatServer

ServerImpl
Stub

ServerImpl

Server

RMI Registry

Clients Remote Object Creation

Client c = new ClientImpl();

Client

ClientImpl

Hosted
Remote
Objects

Client object also

implements a subclass
of the Remote interface

Client Looks Up Server

Server s = (Server)
Naming.lookup
(//host/ChatServer);

returns
stub

lookup

ChatServer

Hosted
Remote
Objects

ServerImpl
Stub

ServerImpl
s

Client

ServerImpl
Stub

RMI Registry

Server

After Lookup Finished

Hosted
Remote
Objects
c

Hosted
Remote
Objects

ClientImpl

ServerImpl
s

Client

ServerImpl
Stub

Server

Client Invokes Remote Method

Connection conn = s.logon(Adam, c);
remote
logon call

ClientImpl

marshalled args
to server process
Method: logon
Stub for c
String Adam

Client

ServerImpl
Stub

logon

Server Receives Remote Call

remote
logon call

Hosted
Remote
Objects

Method: logon
Stub for c
String Bill

from client process

ClientImpl
Bill
Stub c

Server

unmarshalled arguments

ServerImpl

Server Executes the Call

create new Connection object

Hosted
Remote
Objects

ConnectionImpl

call logon

ClientImpl
Bill
Stub c

Server

ServerImpl

Server Returns the Result

return stub for this as the result

Hosted
Remote
Objects

ConnectionImpl

Return value:
Stub for conn

to client process

Server

remote
logon result

ServerImpl

Client Receives the Result

Stub code
for remote
logon call

conn

from server process

Return value:
Stub for conn

Client

ServerImpl
Stub

logon

Conn Stub
unmarshalled return value

Security Manager
When using a codebase, we must download stub
code from a remote site. This is potentially risky
Need to limit what downloaded code could do
Must install a Security Manager before you download
any code from RMI codebases

Can use
System.setSecurityManager(
new RMISecurityManager());

Policy Files
In addition to security manager, need to
specify a security policy, e.g.,
grant {
permission java.net.SocketPermission *:
1024-65535, connect,accept;
permission java.net.SocketPermission *:80,
connect;
};

Set security policy when JVM started

java -Djava.security.policy==<file name>

Note above: behavior when using == is
different from just using =

Debugging Tips
See:
http://docs.oracle.com/javase/7/docs/technotes/guides/rmi/
logging.html

-Djava.rmi.server.logCalls=true
-Dsun.rmi.server.logLevel=VERBOSE
-Dsun.rmi.loader.logLevel=VERBOSE