Classnote12 RMI 1 RMI RMI applications are often

Classnote#12 RMI 1

RMI • RMI applications are often comprised of two separate programs: – a server and a client. • A typical server application – creates some remote objects, – makes references to them accessible, and – waits for clients to invoke methods on these remote objects. 2

RMI • A typical client application – gets a remote reference to one or more remote objects in the server and then – invokes methods on them. • RMI provides the mechanism by which the server and the client communicate and pass information back and forth. • Such an application is sometimes referred to as a distributed object application. 3

Distributed object applications need to • Locate remote objects: – Applications can use one of two mechanisms to obtain references to remote objects. – An application can register its remote objects with RMI's simple naming facility, the rmiregistry, or – the application can pass and return remote object references as part of its normal operation. 4

Distributed object applications need to (cont. ) • Communicate with remote objects: – Details of communication between remote objects are handled by RMI; to the programmer, remote communication looks like a standard Java method invocation. • Load class bytecodes for objects that are passed around: – Because RMI allows a caller to pass objects to remote objects, RMI provides the necessary mechanisms for loading an object's code, as well as for transmitting its data. 5

RMI • The following illustration depicts an RMI distributed application that uses the registry to obtain a reference to a remote object. • The server calls the registry to associate (or bind) a name with a remote object. • The client looks up the remote object by its name in the server's registry and then invokes a method on it. 6

The illustration also shows that the RMI system uses an existing Web server to load class bytecodes, from server to client and from client to server, for objects when needed. 7

Advantages of Dynamic Code Loading • One of the central and unique features of RMI is its ability to download the bytecodes (or simply code) of an object's class if the class is not defined in the receiver's virtual machine. • The types and the behavior of an object, previously available only in a single virtual machine, can be transmitted to another, possibly remote, virtual machine. • RMI passes objects by their true type, so the behavior of those objects is not changed when they are sent to another virtual machine. • This allows new types to be introduced into a remote virtual machine, thus extending the behavior of an application dynamically. • The compute engine example in this chapter uses RMI's capability to introduce new behavior to a distributed 8 program.

Remote Interfaces, Objects, and Methods • Like any other application, a distributed application built using Java RMI is made up of interfaces and classes. • The interfaces define methods, and the classes implement the methods defined in the interfaces and, perhaps, define additional methods as well. • In a distributed application some of the implementations are assumed to reside in different virtual machines. • Objects that have methods that can be called across virtual machines are remote objects. 9

Remote Interfaces, Objects, and Methods • An object becomes remote by implementing a remote interface, which has the following characteristics. – A remote interface extends the interface java. rmi. Remote. – Each method of the interface declares java. rmi. Remote. Exception in its throws clause, in addition to any application-specific exceptions. 10

Remote Interfaces, Objects, and Methods • RMI treats a remote object differently from a nonremote object when the object is passed from one virtual machine to another. • Rather than making a copy of the implementation object in the receiving virtual machine, RMI passes a remote stub for a remote • The stub acts as the local representative, or proxy, for the remote object and basically is, to the caller, the remote reference. • The caller invokes a method on the local stub, which is responsible for carrying out the method call on the remote object. 11

Remote Interfaces, Objects, and Methods • A stub for a remote object implements the same set of remote interfaces that the remote object implements. • This allows a stub to be cast to any of the interfaces that the remote object implements. • However, this also means that only those methods defined in a remote interface are available to be called in the receiving virtual machine. 12

Creating Distributed Applications Using RMI • When you use RMI to develop a distributed application, you follow these general steps. 1. Design and implement the components of your distributed application. 2. Compile sources and generate stubs. 3. Make classes network accessible. 4. Start the application. 13

Design and Implement the Application Components • First, decide on your application architecture and determine which components are local objects and which ones should be remotely accessible. This step includes: Defining the remote interfaces: • – – A remote interface specifies the methods that can be invoked remotely by a client. Clients program to remote interfaces, not to the implementation classes of those interfaces. Part of the design of such interfaces is the determination of any local objects that will be used as parameters and return values for these methods; if any of these interfaces or classes do not yet exist, you need to define them as well. 14

Design and Implement the Application Components • Implementing the remote objects: – – – • Remote objects must implement one or more remote interfaces. The remote object class may include implementations of other interfaces (either local or remote) and other methods (which are available only locally). If any local classes are to be used as parameters or return values to any of these methods, they must be implemented as well. Implementing the clients: – Clients that use remote objects can be implemented at any time after the remote interfaces are defined, including after the remote objects have been deployed. 15

Compile Sources and Generate Stubs • This is a two-step process. – – In the first step you use the javac compiler to compile the source files, which contain the implementation of the remote interfaces and implementations, the server classes, and the client classes. In the second step you use the rmic compiler to create stubs for the remote objects. RMI uses a remote object's stub class as a proxy in clients so that clients can communicate with a particular remote object. 16

Make Classes Network Accessible • In this step you make everything--the class files associated with the remote interfaces, stubs, and other classes that need to be downloaded to clients-accessible via a Web server. 17

Start the Application • Starting the application includes running the RMI remote object registry, the server, and the client. 18

Building a Generic Compute Engine • • • This trail focuses on a simple yet powerful distributed application called a compute engine. The compute engine, a remote object in the server, takes tasks from clients, runs them, and returns any results. The tasks are run on the machine where the server is running. This sort of distributed application could allow a number of client machines to make use of a particularly powerful machine or one that has specialized hardware. The novel aspect of the compute engine is that the tasks it runs do not need to be defined when the compute engine is written. 19

Building a Generic Compute Engine • • New kinds of tasks can be created at any time and then given to the compute engine to be run. All that is required of a task is that its class implement a particular interface. Such a task can be submitted to the compute engine and run, even if the class that defines that task was written long after the compute engine was written and started. The code needed to accomplish the task can be downloaded by the RMI system to the compute engine, and then the engine runs the task, using the resources on the machine on which the compute engine is running. 20

Building a Generic Compute Engine • • • The ability to perform arbitrary tasks is enabled by the dynamic nature of the Java platform, which is extended to the network by RMI dynamically loads the task code into the compute engine's Java virtual machine and runs the task without prior knowledge of the class that implements the task. An application like this, which has the ability to download code dynamically, is often called a behavior-based application. Such applications usually require full agentenabled infrastructures. With RMI such applications are part of the basic mechanisms for distributed computing on the Java 21 platform.

Writing an RMI Server • • • The compute engine server accepts tasks from clients, runs the tasks, and returns any results. The server is comprised of an interface and a class. The interface provides the definition for the methods that can be called from the client. Essentially the interface defines the client's view of the remote object. The class provides the implementation. 22

Designing a Remote Interface • At the heart of the compute engine is a protocol that allows jobs to be submitted to the compute engine, the compute engine to run those jobs, and the results of the job to be returned to the client. • This protocol is expressed in interfaces supported by the compute engine and by the objects that are submitted to the compute engine, as shown in the following figure. Each of the interfaces contains a single method. The compute engine's interface, • Compute, allows jobs to be submitted to the engine; the client interface, • Task, defines how the compute engine executes a submitted task. 23

Designing a Remote Interface (compute. java) package compute; import java. rmi. Remote. Exception; public interface Compute extends Remote { Object execute. Task(Task t) throws Remote. Exception; } 24

Designing a Remote Interface • • • By extending the interface java. rmi. Remote, this interface marks itself as one whose methods can be called from any virtual machine. Any object that implements this interface becomes a remote object. As a member of a remote interface, the execute. Task method is a remote method. Therefore the method must be defined as being capable of throwing a java. rmi. Remote. Exception. This exception is thrown by the RMI system during a remote method call to indicate that either a communication failure or a protocol error has occurred. A Remote. Exception is a checked exception, so any code making a call to a remote method needs to handle this exception by either catching it or declaring it in its throws clause. 25

Designing a Remote Interface • • • The second interface needed for the compute engine defines the type Task. This type is used as the argument to the execute. Task method in the Compute interface. The compute. Task interface defines the interface between the compute engine and the work that it needs to do, providing the way to start the work. 26

Designing a Remote Interface (Task. java) package compute; import java. io. Serializable; public interface Task extends Serializable { Object execute(); } 27

Designing a Remote Interface • • The Task interface defines a single method, execute, which returns an Object, has no parameters, and throws no exceptions. Since the interface does not extend Remote, the method in this interface doesn't need to list java. rmi. Remote. Exception in its throws clause. The return value for the Compute's execute. Task and Task's execute methods is declared to be of type Object. This means that any task that wants to return a value of one of the primitive types, such as an int or a float, needs to create an instance of the equivalent wrapper class for that type, such as an Integer or a Float, and return that object instead. 28

Designing a Remote Interface • • • Note that the Task interface extends the java. io. Serializable interface. RMI uses the object serialization mechanism to transport objects by value between Java virtual machines. Implementing Serializable marks the class as being capable of conversion into a self-describing byte stream that can be used to reconstruct an exact copy of the serialized object when the object is read back from the stream. 29

Designing a Remote Interface • • Different kinds of tasks can be run by a Compute object as long as they are implementations of the Task type. The classes that implement this interface can contain any data needed for the computation of the task and any other methods needed for the computation. Here is how RMI makes this simple compute engine possible. Since RMI can assume that the Task objects are written in the Java programming language, implementations of the Task object that were previously unknown to the compute engine are downloaded by RMI into the compute engine's virtual machine as needed. 30

Designing a Remote Interface • • This allows clients of the compute engine to define new kinds of tasks to be run on the server machine without needing the code to be explicitly installed on that machine. In addition, because the execute. Task method returns a java. lang. Object, any type of object can be passed as a return value in the remote call. The compute engine, implemented by the Compute. Engine class, implements the Compute interface, allowing different tasks to be submitted to it by calls to its execute. Task method. These tasks are run using the task's implementation of the execute method. The compute engine reports results to the caller through its return value: an Object. 31

Implementing a Remote Interface • • Let's turn now to the task of implementing a class for the compute engine. In general the implementation class of a remote interface should at least – – – Declare the remote interfaces being implemented Define the constructor for the remote object Provide an implementation for each remote method in the remote interfaces 32

Implementing a Remote Interface • • The server needs to create and to install the remote objects. This setup procedure can be encapsulated in a main method in the remote object implementation class itself, or it can be included in another class entirely. The setup procedure should – – – Create and install a security manager Create one or more instances of a remote object Register at least one of the remote objects with the RMI remote object registry (or another naming service such as one that uses JNDI), for bootstrapping purposes 33

engine. Compute. Engine import java. rmi. *; import java. rmi. server. *; import compute. *; public class Compute. Engine extends Unicast. Remote. Object implements Compute { public Compute. Engine() throws Remote. Exception { super(); } public Object execute. Task(Task t) { return t. execute(); } public static void main(String[] args) { if (System. get. Security. Manager() == null) { System. set. Security. Manager(new RMISecurity. Manager()); } 34

engine. Compute. Engine (cont. ) String name = "Compute"; try { Compute engine = new Compute. Engine(); Naming. rebind(name, engine); System. out. println("Compute. Engine bound"); } catch (Exception e) { System. err. println("Compute. Engine exception: " + e. get. Message()); e. print. Stack. Trace(); } } } 35

client. Compute. Pi package client; import java. rmi. *; import java. math. *; import compute. *; public class Compute. Pi { public static void main(String args[]) { if (System. get. Security. Manager() == null) { System. set. Security. Manager(new RMISecurity. Manager()); } 36

client. Compute. Pi (cont. ) try { String name = "//" + args[0] + "/Compute"; Compute comp = (Compute) Naming. lookup(name); Pi task = new Pi(Integer. parse. Int(args[1])); Big. Decimal pi = (Big. Decimal) (comp. execute. Task(task)); System. out. println(pi); } catch (Exception e) { System. err. println("Compute. Pi exception: " + e. get. Message()); e. print. Stack. Trace(); } } } 37

client. Pi, package client; import compute. *; import java. math. *; public class Pi implements Task { /** constants used in pi computation */ private static final Big. Decimal ZERO = Big. Decimal. value. Of(0); private static final Big. Decimal ONE = Big. Decimal. value. Of(1); private static final Big. Decimal FOUR = Big. Decimal. value. Of(4); /** rounding mode to use during pi computation */ private static final int rounding. Mode = Big. Decimal. ROUND_HALF_EVEN; /** digits of precision after the decimal point */ private int digits; 38

client. Pi (cont. ) /** * Construct a task to calculate pi to the specified * precision. */ public Pi(int digits) { this. digits = digits; } /** * Calculate pi. */ public Object execute() { return compute. Pi(digits); } 39

/** client. Pi (cont. ) * Compute the value of pi to the specified number of * digits after the decimal point. The value is * computed using Machin's formula: * pi/4 = 4*arctan(1/5) - arctan(1/239) * and a power series expansion of arctan(x) to * sufficient precision. */ public static Big. Decimal compute. Pi(int digits) { int scale = digits + 5; Big. Decimal arctan 1_5 = arctan(5, scale); Big. Decimal arctan 1_239 = arctan(239, scale); Big. Decimal pi = arctan 1_5. multiply(FOUR). subtract( arctan 1_239). multiply(FOUR); return pi. set. Scale(digits, 40 Big. Decimal. ROUND_HALF_UP);

/** client. Pi(cont. ) * Compute the value, in radians, of the arctangent of * the inverse of the supplied integer to the speficied * number of digits after the decimal point. The value * is computed using the power series expansion for the * arc tangent: * arctan(x) = x - (x^3)/3 + (x^5)/5 - (x^7)/7 + * (x^9)/9. . . */ public static Big. Decimal arctan (int inverse. X, int scale) { Big. Decimal result, numer, term; Big. Decimal inv. X = Big. Decimal. value. Of(inverse. X); Big. Decimal inv. X 2 = Big. Decimal. value. Of(inverse. X * inverse. X); numer = ONE. divide(inv. X, scale, rounding. Mode); 41

client. Pi (cont. ) result = numer; int i = 1; do { numer = numer. divide(inv. X 2, scale, rounding. Mode); int denom = 2 * i + 1; term = numer. divide(Big. Decimal. value. Of(denom), scale, rounding. Mode); 42

client. Pi (cont. ) if ((i % 2) != 0) { result = result. subtract(term); } else { result = result. add(term); } i++; } while (term. compare. To(ZERO) != 0); return result; } } 43

Create directory and save the files • Microsoft Windows: – – – – C: iqbalmscs 237rmiapp Create directory ‘engine’ Save Compute. Engine. java from the website Create directory ‘compute’ Save Compute. java and Task. java from the website Create directory ‘client’ Save Compute. Pi. java and Pi. java from the website – javac computeCompute. java – javac computeTask. java – jar cvf compute. jar compute*. class 44

To create environment for compiling and executing the java programs: env. bat • Microsoft Windows: Your current directory is : C: iqbalmscs 237rmiapp Contents of env. bat is set path=%. %; c: j 2 sdk 1. 4. 2bin set classpath=. 45

Execute env. bat to create environment • Microsoft Windows: Your current directory is : C: iqbalmscs 237rmiapp To run type: env. bat 46

Create directory and save the files • Microsoft Windows: – – – – Your current directory is C: iqbalmscs 237rmiapp Now, Create a directory ‘engine’ in app Save Compute. Engine. java from the website Create a directory ‘compute’ in app Save Compute. java and Task. java from the website Create a directory ‘client’ in app Save Compute. Pi. java and Pi. java from the website 47

Compiling the Programs • Microsoft Windows: – javac computeCompute. java – javac computeTask. java Or – javac compute*. java 48

Compiling the Server Programs and creating stub and skeleton • Microsoft Windows: – javac engineCompute. Engine. java – rmic -d. engine. Compute. Engine (If you use Java 1. 5, you can skip the later step) 49

Compiling the client Programs • Microsoft Windows: – javac client*. java 50

51

Content of the policy file name of the file: policy grant { // Allow everything for now permission java. security. All. Permission; }; 52

Create a batch file to run the server runserver. bat The contents of the batch file in one line: java -Djava. rmi. server. codebase=file: /c: iqbalmscs 237rmiappengine -Djava. security. policy=file: ///C: iqbalmscs 237rmiapppolicy engine. Compute. Engine 53

Create a batch file to run the client. bat java -Djava. rmi. server. codebase=file: /c: iqbalmscs 237rmiappengine/ -Djava. security. policy=file: ///C: iqbalmscs 237rmiapppolicy client. Compute. Pi localhost 30 54

Executing the Example Programs Your current directory is C: iqbalmscs 237rmiapp Step 1) Start the name server: start rmiregistry Step 2) Start the server: start runserver Step 3)Start the client: client 55

Reference for the Pi program • http: //java. sun. com/docs/books/tutorial/rmi/ index. html 56

Another Example (Helloserver) • Client is an Applet 57

Applet using RMI • Second example • Hello server • http: //java. sun. com/j 2 se/1. 4. 2/docs/guide/r mi/getstart. doc. html 58

Hello Interface (hello. java) package examples. hello; import java. rmi. Remote. Exception; public interface Hello extends Remote { String say. Hello() throws Remote. Exception; } 59

Server(Hello. Impl. java) package examples. hello; import java. rmi. Naming; import java. rmi. Remote. Exception; import java. rmi. RMISecurity. Manager; import java. rmi. server. Unicast. Remote. Object; public class Hello. Impl extends Unicast. Remote. Object implements Hello { public Hello. Impl() throws Remote. Exception { super(); } public String say. Hello() { return "Hello World!"; } 60

Server(Hello. Impl. java) public static void main(String args[]) { // Create and install a security manager if (System. get. Security. Manager() == null) { System. set. Security. Manager(new RMISecurity. Manager()); } try { Hello. Impl obj = new Hello. Impl(); // Bind this object instance to the name "Hello. Server" Naming. rebind("Hello. Server", obj); System. out. println("Hello. Server bound in registry"); } catch (Exception e) { System. out. println("Hello. Impl err: " + e. get. Message()); e. print. Stack. Trace(); } } } 61

Client Applet (Hello. Applet. java) package examples. hello; import java. applet. Applet; import java. awt. Graphics; import java. rmi. Naming; import java. rmi. Remote. Exception; public class Hello. Applet extends Applet { String message = "blank"; // "obj" is the identifier that we'll use to refer // to the remote object that implements the "Hello" // interface Hello obj = null; 62

Client Applet (Hello. Applet. java) public void init() { try { obj = (Hello)Naming. lookup("//" + get. Code. Base(). get. Host() + "/Hello. Server"); message = obj. say. Hello(); } catch (Exception e) { System. out. println("Hello. Applet exception: " + e. get. Message()); e. print. Stack. Trace(); } } public void paint(Graphics g) { g. draw. String(message, 25, 50); } } 63

How to compile? • How to compile the java files? • C: iqbalmscs 237rmiapplet>javac -d C: iqbalmscs 237rmiapplet *. java • How to create stub and skeleton? • C: iqbalmscs 237rmiapplet>rmic -d C: iqbalmscs 237rmiapplet examples. hello. Hello. Impl 64

How to run? • Step 1: run the name server • start rmiregistry • Step 2: run the server (change directory according to your directory) java -Djava. rmi. server. codebase=file: ///C: iqbalmscs 237rmiapplet -Djava. security. policy=file: ///C: iqbalmscs 237rmiappletpolicy examples. hello. Hello. Impl • Step 3: run the applet • appletviewer hello 1. html 65

hello 1. html <HTML> <title>Hello World</title> <center> <h 1>Hello World</h 1> </center> The message from the Hello. Server is: <p> <applet codebase="file: ///C: iqbalmscs 237rmiapplet" code="examples. hello. Hello. Applet" width=500 height=120> </applet> </HTML> 66

policy grant { // Allow everything for now permission java. security. All. Permission; }; 67