Transcript pptx

Lecture VI: Distributed Objects.
Remote Method Invocation
CMPT 431
Dr. Alexandra 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
CMPT 431 © A. Fedorova
2
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
CMPT 431 © A. Fedorova
3
Example: Bicycle Object
attributes
class 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;
}
method
Object definition is
described in a class
void brake(int decrement) {
speed = speed - decrement;
}
}
CMPT 431 © A. Fedorova
4
Example: Using Bicycle
public static void main(){
Bicycle myNewBike = new Bicycle();
Create a new Bicycle
object
myNewBike.changeGear(5);
Invoke a method
on an object
}
Cannot access private attributes directly
myNewBike.gear = 5; //Illegal!!!
CMPT 431 © A. Fedorova
5
Object-Oriented Jargon Buster: Interface
• A definition of methods,
• Just signatures, no implementation
public interface MotorBike{
void kickStart();
void squeezeClutch();
void turnThrottle(int degrees);
}
CMPT 431 © A. Fedorova
6
Implementing the Interface
class Bicycle implements MotorBike{
...
private boolean engineStarted;
private boolean clutchLeverSqueezed;
private int throttleSettingDegrees;
...
public void kickStart(){
engineStarted = true;
}
public void squeezeClutch(){
clutchLeverSqueezed = true;
}
This class must provide
implement methods in
this interface
some additional
variables for the new
methods
implementation
of the interface
public void setThrottle(int degrees){
throttleSettingDegrees = degrees;
}
}
CMPT 431 © A. Fedorova
7
Object-Oriented Jargon Buster: Exceptions
• A way to handle 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
CMPT 431 © A. Fedorova
8
Throwing an Exception
class 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 squeezed
Create an Exception object
that may contain information
about the error
CMPT 431 © A. Fedorova
9
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 trycatch clause
code that
handles the
exception
}
CMPT 431 © A. Fedorova
10
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
CMPT 431 © A. Fedorova
11
A Remote Object in Java
extends interface
Remote
• 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
throws Remote
java.rmi.RemoteException;
exception
public void withdraw(float amount) throws
OverdrawnException,
java.rmi.RemoteException;
public float getBalance() throws java.rmi.RemoteException; }
CMPT 431 © A. Fedorova
12
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
CMPT 431 © A. Fedorova
13
Implementation and Proxy
proxy creates
location transparency
•
•
•
•
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
CMPT 431 © A. Fedorova
14
RMI System
• Stub and Skeleton Layer: intercepts calls from client and redirects to
Remote Reference Layer
• Remote Reference Layer interprets references to remote objects,
knows what to do with them. Passes messages to the Transport Layer
• Transport Layer sends messages using request-reply protocol
CMPT 431 © A. Fedorova
15
Stub and Skeleton Layer
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
CMPT 431 © A. Fedorova
• 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.
16
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
CMPT 431 © A. Fedorova
• Server RRL:
– knows if the local object
exists
– knows where to locate the
local implementation
– calls the skeleton
17
Transport Layer
Java Runtime
Environment – code
that enables JVM to
run
• Manages connection between Java Virtual Machines
• Used over the network and on the local host
• There is a messaging protocol implemented over TCP/IP
CMPT 431 © A. Fedorova
18
Components of the Transport Layer
Messaging protocol
(e.g., Java Remote Method
Protocol – JRMP)
IIOP
BEA Weblogic protocol
Ninja RMI protocol
TCP/IP
UDP/IP
• 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
CMPT 431 © A. Fedorova
19
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
CMPT 431 © A. Fedorova
20
Creation of Remote Object
Client
remote object
reference
•
•
•
•
Server
remote
object
instance
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?
CMPT 431 © A. Fedorova
21
Remote Object References
Naming and
Directory Service
[well known DNS
name and port]
rmiregistry
Server
3. Create a service that
listens for invocations on that
object
1. Create an object instance
2. Export to RMI registry
4. Register object under
public name
CMPT 431 © A. Fedorova
22
Server Creates and Registers Remote Object
BankAccountImpl implements
BankAccount interface
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);
}
}
Create a
BankAccount
object
Register object
under public
name
public static void main(String args[]) {
new CalculatorServer();
}
}
CMPT 431 © A. Fedorova
23
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
CMPT 431 © A. Fedorova
24
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
CMPT 431 © A. Fedorova
25
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 pickling)
– 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
CMPT 431 © A. Fedorova
26
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
CMPT 431 © A. Fedorova
27
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?
CMPT 431 © A. Fedorova
28
Distributed Garbage Collection: Leases
• 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
CMPT 431 © A. Fedorova
29
Is RMI Transparent?
CMPT 431 © A. Fedorova
30
RMI is Transparent
• Hides details for argument marshalling/unmarshalling
• Hides client/server communication details
• Garbage collection works in a distributed manner
CMPT 431 © A. Fedorova
31
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?
CMPT 431 © A. Fedorova
32
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
• RMI exposes “remoteness” to the programmer
CMPT 431 © A. Fedorova
33
Discussion
• RPC vs. RMI
• RPC and RMI took somewhat different approaches to
implementing remote function calls, but there are also
many similarities
• Enumerate the differences
• Are they fundamental to how we program distributed
systems?
• Which system is “better”: RMI or RPC?
CMPT 431 © A. Fedorova
34