cmpt 401 summer 2007 dr. alexandra fedorova lecture vi: distributed objects. remote method...

CMPT 401 Summer 2007

Dr. Alexandra Fedorova

Lecture VI: Distributed Objects.Remote Method Invocation

2CMPT 401 Summer 2007 © A. Fedorova

Remote Method Invocation

• In an object-oriented language (usually Java)…• A way to call a method on an object…• That lives in another process..• Possibly on a different computer

©Pearson Education 2001


Object-Oriented Jargon Buster: Object

• Real-world objects have:– State– Behavior

• Objects in a programming language are similar:– Their state is represented by attributes– Their behavior is represented by methods


Example: Bicycle Objectclass Bicycle {

private int cadence = 0; private int speed = 0; private int gear = 1;

void changeCadence(int newValue) { cadence = newValue;

}

void changeGear(int newValue) { gear = newValue;

}

void brake(int decrement) { speed = speed -

decrement; }

}

Object definition is described in a class

attributes

method


Example: Using Bicycle

public static void main(){Bicycle myNewBike = new Bicycle();

myNewBike.changeGear(5);}

Create a new Bicycle object

Invoke a methodon an object

Cannot access private attributes directly

myNewBike.gear = 5; //Illegal!!!


Object-Oriented Jargon Buster: Interface

public interface MotorBike{ void kickStart();void squeezeClutch();void turnThrottle(int

degrees);}

• A definition of methods, • Just signatures, no

implementation


Implementing the Interfaceclass Bicycle implements MotorBike{

...private boolean engineStarted;private boolean clutchLeverSqueezed;private int throttleSettingDegrees;...

public void kickStart(){engineStarted = true;

}

public void squeezeClutch(){clutchLeverSqueezed = true;

}

public void setThrottle(int degrees){

throttleSettingDegrees = degrees;

}}

This class must provide implement methods in

this interface

some additional variables for the new

methods

implementation of the interface


Object-Oriented Jargon Buster: Exceptions

• A way to handle with errors during execution of a method• In C you usually return an error code from a function• In Java you throw an exception

public interface MotorBike{ void kickStart();void squeezeClutch();void turnThrottle(int degrees);void changeGear(int gear) throws

ClutchNotSqueezedException;}

new declaration of changeGear method that may generate an exception


Throwing an Exceptionclass Bicycle implements MotorBike{

...

public void changeGear(int newGear) throws ClutchNotSqueezed Exception{

if(!clutchLeverSqueezed)throw new

ClutchNotSqueezedException();else

gear = newGear;}

}

new implementation of changeGear that may generate an exception

Can’t change gears unless clutch is squeezedCreate an Exception object that may contain information about the error


Catching An Exception

• As you saw, is a method may throw an exception, this is specified in the method’s signature

• The code calling that method must be written to handle that exception

public static void main(){MotorBike myDirtBike = new MotorBike();

try{myDirtBike.changeGear(5);

}catch(ClutchNotSqueezedException cnse){

System.out.println(“Can’t change gears unless you squeeze the clutch!”);

}}

wrap code that might throw exception in try-catch clause

code that handles the exception


A Remote Object

©Pearson Education 2001

• A remote object will advertise and implement a remote interface• Remote invocation can only invoke methods in the remote interface


A Remote Object in Java

• Must declare a remote interface – that is the interface that extends the interface Remote

• Each method in a remote interface must be declared to throw a RemoteException

public interface BankAccount extends java.rmi.Remote {

public void deposit(float amount) throws

java.rmi.RemoteException; public void withdraw(float amount) throws

OverdrawnException, java.rmi.RemoteException;

public float getBalance() throws java.rmi.RemoteException; }

extends interface Remote

throws Remote exception


A Bird Eye’s View of RMI

• Client program knows the interface• Server program implements the interface• Client invokes remote methods described by the interface using the

RMI system


Implementation and Proxy

• The actual implementation of the interface lives on the server• There is a proxy implementation on the client• The client invokes the proxy implementation• The proxy implementation communicates with the actual implementation

and returns the result to the client

proxy createslocation transparency


RMI System

• Stub and Skeleton Layer: intercepts calls from client and redirects to Remote Reference Layer

• Remote Reference Layer interprets refenerences to remote objects, knows what to do with them. Passes messages to the Transport Layer

• Transport Layer sends messages using request-reply protocol


Stub and Skeleton Layer

• The skeleton: – Reads the parameters for the

method call from the link– Makes the call to the remote

service implementation object– Accepts the return value– Writes the return value back to

the stub.

Client Server

stub skeleton

actual implementation

• The stub: – Marshalls call parameters– Sends them to the server– Unmarshalls return parameters– Returns them to the client

program


Remote Reference Layer (RRL)

• Client RRL: – knows if the remote object (still)

exists– knows where to locate server

holding the remote object– called by the stub

• Server RRL: – knows if the local object

exists– knows where to locate the

local implementation– calls the skeleton


Transport Layer

• Manages connection between Java Virtual Machines• Used over the network and on the local host• There is a messaging protocol implemented over TCP/IP

Java Runtime Environment – code that enables JVM to run


Components of the Transport Layer

• Messaging protocol provides at-most-once semantics• Any layer can be switched by an alternative: e.g., TCP/IP with UDP/IP• Sun and IBM are working on next version of RMI that will use IIOP, the

open protocol used in CORBA• Bea Weblogic and Ninja RMI use their proprietary messaging protocols

TCP/IP

Messaging protocol (e.g., Java Remote Method

Protocol – JRMP)

UDP/IP

IIOPBEA Weblogic protocol

Ninja RMI protocol


Differences in Java 1.2

• Stubs and skeletons are not used, invocation is done using Java reflection (we will not discuss it, read about it in the book)

• In Java 1.1 you could communicate with an object only if it had been previously instantiated on the server

• In Java 1.2 you can activate a dormant object dynamically. A dormant object could be an object that existed before, then was written to disk, but currently does not exist in the server memory

• In Java 1.1 you could communicate with only one instance of remote object

• In Java 1.2 you can communicate with multiple objects via multicast• Today we assume the Java 1.1 implementation


Local vs. Remote Objects

• Remote objects are defined using a Remote interface definition• Local objects are defined using a Class definition• Why is there a difference? • A class usually has a constructor, so you can construct an object

described by a class in a local memory using the constructor• An interface does not have a constructor, which is the right thing for

the remote object• You should not be able to create a remote object in a local memory,

so you are not given a constructor


Creation of Remote Object

• Server creates an instance of remote object• Client wants to invoke a method on that remote object• But first it must obtain a reference to the remote object• How does the client obtain the remote reference?

Client Server

remote object

instanceremote object

reference


Remote Object References

Naming and Directory Service[well known DNS name and port]rmiregistry

Server 1. Create an object instance

2. Export to RMI registry

3. Create a service that listens for invocations on that object

4. Register object under public name


Server Creates and Registers Remote Object

import java.rmi.Naming;

public class BankServer {

public BankServer() {

try {

BankAccount b = new BankAccountImpl(); Naming.rebind("rmi://localhost:1099/

BankService", c);

} catch (Exception e) { System.out.println("Trouble: " + e);

}

}

public static void main(String args[]) {

new CalculatorServer();

}

}

BankAccountImpl implements BankAccount interface

Create a BankAccount object

Register object under public name


Client Obtains Remote Reference

public class BankClient {

public static void main(String[] args){

try {

BankAccount b =

(BankAccount) Naming.lookup( "rmi://localhost /BankService");

}

catch (RemoteException re) {

... //handle exception

}

}

Obtain remote object reference via rmiregistry


The Entire RMI Program

• Written by the programmer– BankAccount.java – Remote interface– BankAccountImpl.java – Implementation of

remote interface on the server– BankServer.java – The server that creates an instance of

BankAccountImpl and binds it– BankClient.java – The client that obtains remote

object reference and invokes remote methods on it• Generated by rmic compiler (rmic BankAccountImpl.java)

– BankAccount_Stub.class– BankAccount_Skel.class


Local vs. Remote Parameter Passing• For a local call

– Primitive types are passed by value - a primitive type variable is copied on the caller’s stack

– Object references are passed by value – an object reference (not the entire object) is copied on the caller’s stack

• For a remote call– Primitive types are copied to the message sent to the server– Entire object, not just the reference is copied– All objects referenced by the parameter object are copied too! (Like pointer

picking)– Java serialization is a format to convert an object and object that it references

in a linear form.– Objects are serialized before they are passed remotely and deserialized on the

other side


There’s More to RMI System

• What do you need a web server for?• Sometimes a client passes or a server returns an object whose class definition is not available

locally• In that case, the definition is downloaded from the web server


Distributed Garbage Collection

• In C you have to explicitly deallocate memory that is no longer used

• In Java, unused objects are garbage collected: local JVM automatically destroys objects that are not referenced by anyone

• Garbage collection must also work with RMI• Java RMI system implements a distributed garbage

collector


Distributed Garbage Collection (cont)

• RMI Remote Layer on the server counts the number of remote references to each remote object it exports

• When there are no more local and remote references to the object, the object is destroyed

• The client should tell the server when it no longer uses the object

• But what if it does not?


Distributed Garbage Collection (cont)

• Each remote reference has an associated “lease” time• Client RMI layer must renew the lease on the reference if

the reference is still in use on the client• When all leases expire, the server can destroy the object• Client must be prepared to deal with “disappeared”

objects


Is RMI Transparent?


RMI is Transparent

• For remote invocations a programmer uses the same syntax as for local invocations

• Hides details for argument marshalling/unmarshalling• Hides client/server communication details• Garbage collection works in a distributed manner


RMI is Not Transparent• Call invocation semantics

– Local invocation has “exactly-once” semantics– RMI has “at-most-once” semantics– If RMI had “at-least-once” semantics, programmer would need to be

sure that remote operations are idempotent• RMI is subject to partial failures

– Server, registry or network can fail independently of the client– RMI-specific failure mode is exposed to the programmer (must catch

RemoteException)• Latency of RMI is higher than that of local invocation

– Should the programmer be allowed to set a timeout or abort an RMI that’s taking too long?


Is RMI Transparent? The Verdict

• The syntax (i.e., how you call the method) is transparent• The interface is not transparent (extent Remote, throw

RemoteException)


Shouldn’t RMI Be Transparent?

• Yes, it should be– Why burden programmer with the knowledge that the method is

remote?– Any method can throw an exception. There is no need to distinguish

RemoteException

• No, it should not be– RMI is slower than local invocation. A programmer would want to use

RMI judiciously– A good program shows descriptive error messages to the user. If you hide

remoteness, you cannot give descriptive error messages for remote errors

– A programmer of remote object must guard against concurrent access by multiple clients


Summary

• Java RMI is language-specific abstraction for communication in a distributed system

• A Java program can invoke a method on an object located in another JVM on another host

• Remote objects are registered with a global naming service

• Client can obtain a remote reference by name• The syntax of calling a remote method is transparent• The interface is not transparent• It is considered a bad idea to provide full transparency

cmpt 401 summer 2007 dr. alexandra fedorova lecture vi: distributed objects. remote method...

Documents

exception slide

public void kickstart

public void squeezeclutch

exception object

interface slide

void changegearint newvalue

new bicycle object

exception class bicycle