Transcript Lecture6-DistObjects..

Lecture VI: Distributed Objects.
Remote Method Invocation
CMPT 401 Summer 2007
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 401 Summer 2007 © 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 401 Summer 2007 © 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;
}
Object definition is
described in a class
CMPT 401 Summer 2007 © A. Fedorova
void changeGear(int newValue) {
gear = newValue;
method
}
void brake(int decrement) {
speed = speed decrement;
}
}
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 401 Summer 2007 © 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 401 Summer 2007 © 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;
}
public void setThrottle(int
degrees){
throttleSettingDegrees =
degrees;
}
CMPT 401 Summer 2007 © A. Fedorova
}
This class must provide
implement methods in
this interface
some additional
variables for the new
methods
implementation
of the interface
7
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
CMPT 401 Summer 2007 © 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 401 Summer 2007 © 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!”);
}
}
CMPT 401 Summer 2007 © A. Fedorova
wrap code that
might throw
exception in trycatch clause
code that
handles the
exception
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 401 Summer 2007 © 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;
public void withdraw(float amount) throws
OverdrawnException,
java.rmi.RemoteException;
exception
public float getBalance() throws
java.rmi.RemoteException; }
CMPT 401 Summer 2007 © 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 401 Summer 2007 © 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 401 Summer 2007 © A. Fedorova
14
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
CMPT 401 Summer 2007 © 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 401 Summer 2007 © 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 401 Summer 2007 © 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 401 Summer 2007 © 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 401 Summer 2007 © A. Fedorova
19
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
CMPT 401 Summer 2007 © A. Fedorova
20
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 401 Summer 2007 © A. Fedorova
21
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 401 Summer 2007 © A. Fedorova
22
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 401 Summer 2007 © A. Fedorova
23
Server Creates and Registers Remote Object
BankAccountImpl implements
BankAccount interface
import java.rmi.Naming;
public class BankServer {
public BankServer() {
try {
Create a
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();
CMPT 401 Summer}2007 © A. Fedorova
BankAccount
object
Register object
under public
name
24
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 401 Summer 2007 © A. Fedorova
25
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 401 Summer 2007 © A. Fedorova
26
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
CMPT 401 Summer 2007 © A. Fedorova
27
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
CMPT 401 Summer 2007 © A. Fedorova
28
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 401 Summer 2007 © A. Fedorova
29
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 401 Summer 2007 © A. Fedorova
30
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
CMPT 401 Summer 2007 © A. Fedorova
31
Is RMI Transparent?
CMPT 401 Summer 2007 © A. Fedorova
32
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
CMPT 401 Summer 2007 © A. Fedorova
33
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 401 Summer 2007 © A. Fedorova
34
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)
CMPT 401 Summer 2007 © A. Fedorova
35
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
CMPT 401 Summer 2007 © A. Fedorova
36
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 © A. Fedorova
37