Advanced Java RMI Features for Distributed Computing

1. Advanced Remote Method Invocations M. L. Liu Distributed Computing, M. L. Liu

2. RMI – Advanced topics • The Java RMI API has a rich collection of features. • We will look at some of RMI’s more interesting advanced features, namely: • stub downloading • security manager • client callback. • Although these features are not inherent to the distributed object paradigm, they are helpful mechanisms and can be useful to application developers. Distributed Computing, M. L. Liu

3. The Java RMI Architecture Distributed Computing, M. L. Liu

4. Java RMI Client Server Interaction Distributed Computing, M. L. Liu

5. RMI Stub Downloading • RMI is designed to allow stubs to be made available to the client dynamically. Doing so allows changes to be made in the remote methods without affecting the client program. • The stub can be filed with an web server and be downloaded using HTTP. • Security measures are needed to prevent both the client side and the server side: • A java security policy file needs to be set on the server host and also on the client host. • A Java Security Manager should be instantiated in both the client and server programs. Distributed Computing, M. L. Liu

6. Stub downloading • If the stub is to be downloaded from a remote server, transfer the stub class to the appropriate directory on that server, e.g., www.csc.calpoly.edu/~mliu/www, and make sure that the access permission to the file is set. • When activating the server, specify command options: Distributed Computing, M. L. Liu

7. The java.policy file • The RMI security manager does not permit network access. Exceptions can be made via the specification in a java.policy file. grant { // permits socket access to all common TCP ports, including the default // RMI registry port (1099) – need for both the client and the server. permission java.net.SocketPermission "*:1024-65535", "connect,accept,resolve"; // permits socket access to port 80, the default HTTP port – needed // by client to contact an HTTP server for stub downloading permission java.net.SocketPermission "*:80", "connect"; }; • This file can be filed in the same directory as the server class file. • When activiating the client, a java.policy file also should be specified: java -Djava.security.policy=java.policy SomeClient • See http://java.sun.com/products/jdk/1.2/docs/guide/security/PolicyFiles.html and http://java.sun.com/products/jdk/1.2/docs/guide/security/permissions.html Distributed Computing, M. L. Liu

8. File Placements Distributed Computing, M. L. Liu

9. RMI Security Manager • Since RMI involves access to/from a foreign host, and possibly object downloading, it is important for both the server and the client to protect its system from malicious access. • The RMISecurityManager is a class provided Java, and can be instantiated in both the client and the server for limiting access priviledges. • You can write your own security manager, if so desired. try { System.setSecurityManager(new RMISecurityManager( )); } catch { …} Distributed Computing, M. L. Liu

10. Algorithm for building an RMI Application Server side: • Open a directory for all the files to be generated for this application. • Specify the remote-server interface, and compile it to generate the interface class file. • Build the remote server class by implementing the interface, and compile it using javac. • Use rmic to process the server class to generate a stub.class file and a skelton.class file: rmic SomeServer • If stub downloading is desired, copy the stub file to an appropriate directory on the HTTP host. • Activate the RMIRegistry, if it has not already been activated. • Set up a java.policy file. • Activate the server, specifying (i) the codebase if stub downloading is desired, (ii) the server host name, and (iii) the security policy file. Distributed Computing, M. L. Liu

11. Alogorithm for building an RMI Application Client side: • Open a directory for all the files to be generated for this application. • Implement the client program or applet, and compile it to generate the client class. • If stub downloading is not in effect, copy the server interface stub class file by hand. • Set up a java.policy file. • Activate the client, specifying (i) the server host name, and (ii) the security policy file. Distributed Computing, M. L. Liu

12. RMI Callbacks Distributed Computing, M. L. Liu

13. Introduction • In the client server model, the server is passive: the IPC is initiated by the client; the server waits for the arrival of requests and provides responses. • Some applications require the server to initiate communication upon certain events. Examples applications are: • monitoring • games • auctioning • voting/polling • chat-toom • message/bulletin board • groupware Distributed Computing, M. L. Liu

14. Polling vs. Callback In the absence of callback, a client will have to poll a passive server repeatedly if it needs to be notified that an event has occurred at the server end. Distributed Computing, M. L. Liu

15. Two-way communications • Some applications require that both sides may initiate IPC. • Using sockets, duplex communication can be achieved by using two sockets on either side. • With connection-oriented sockets, each side acts as both a client and a server. Distributed Computing, M. L. Liu

16. RMI Callbacks • A callback client registers itself with an RMI server. • The server makes a callback to each registered client upon the occurrence of a certain event. Distributed Computing, M. L. Liu

17. Callback Client-Server Interactions Distributed Computing, M. L. Liu

18. Callback application files Distributed Computing, M. L. Liu

19. RMI Callback file placements Distributed Computing, M. L. Liu

20. The Hello Application with Callback Distributed Computing, M. L. Liu

21. RMI Callback Interface • The server provides a remote method which allows a client to register itself for callbacks. • A Remote interface for the callback is needed, in addition to the server-side interface. • The interface specifies a method for accepting a callback from the server. • The client program is a subclass of RemoteObject and implements the callback interface, including the callback method. • The client registers itself for callback in its main method. • The server invokes the client’s remote method upon the occurrence of the anticipated event. Distributed Computing, M. L. Liu

22. Remote Interface for Server public interface HelloInterface extends Remote { // remote method public String sayHello() throws java.rmi.RemoteException; // method to be invoked by a client to add itself to the callback list public void addCallback( HelloCallbackInterface CallbackObject) throws java.rmi.RemoteException; } Distributed Computing, M. L. Liu

23. Remote Interface for Callback Client // an interface specifying a callback method public interface HelloCallbackInterface extends java.rmi.Remote { // method to be called by the server on callback public void callMe ( String message ) throws java.rmi.RemoteException; } Distributed Computing, M. L. Liu

24. HelloServer, with callback public class HelloServer extends UnicastRemoteObject implements HelloInterface { static int RMIPort; // vector for store list of callback objects private static Vector callbackObjects; public HelloServer() throws RemoteException { super(); // instantiate a Vector object for storing callback objects callbackObjects = new Vector(); } // method for client to call to add itself to its callback public void addCallback( HelloCallbackInterface CallbackObject) { // store the callback object into the vector System.out.println("Server got an 'addCallback' call."); callbackObjects.addElement (CallbackObject); } Distributed Computing, M. L. Liu

25. HelloServer, with callback - 2 public static void main(String args[]) { … registry = LocateRegistry.createRegistry(RMIPort); … callback( ); … } // end main private static void callback( ) { … for (int i = 0; i < callbackObjects.size(); i++) { System.out.println("Now performing the "+ i +"th callback\n"); // convert the vector object to a callback object HelloCallbackInterface client = (HelloCallbackInterface) callbackObjects.elementAt(i); … client.callMe ( "Server calling back to client " + i); … Distributed Computing, M. L. Liu

26. Alogorithm for building an RMI Callback Application Server side: • Open a directory for all the files to be generated for this application. • Specify the remote-server interface, and compile it to generate the interface class file. • Build the remote server class by implementing the interface, and compile it using javac. • Use rmic to process the server class to generate a stub.class file and a skelton.class file: rmic SomeServer • If stub downloading is desired, copy the stub file to an appropriate directory on the HTTP host. • Activate the RMIRegistry, if it has not already been activated. • Set up a java.policy file. • Activate the server, specifying (i) the codebase if stub downloading is desired, (ii) the server host name, and (iii) the security policy file. • Obtain the CallbackInterface. Compile it with javac, then use rmic to generate the stub file for the callback. Distributed Computing, M. L. Liu

27. Alogorithm for building an RMI Callback Application Client side: • Open a directory for all the files to be generated for this application. • Implement the client program or applet, and compile it to generate the client class. • If stub downloading is not in effect, copy the server interface stub class file by hand. • Implement the callback interface. Compile it using javac, then using rmic to generate a stub class and a skeleton class for it. • Set up a java.policy file. • Activate the client, specifying (i) the server host name, and (ii) the security policy file. Distributed Computing, M. L. Liu

28. HelloClient, with callback HelloClient() { // constructor System.setSecurityManager(new RMISecurityManager()); // export this object as a remote object UnicastRemoteObject.exportObject(this); // … Registry registry = LocateRegistry.getRegistry("localhost", RMIPort); h = (HelloInterface) registry.lookup("helloLiu"); h.addCallback(this); // … } // end constructor // call back method - this displays the message sent by the server public void callMe (String message) { System.out.println( "Call back received: " + message ); } public static void main(String args[]) { // … HelloClient client = new HelloClient(); // … while (true){ ; } // end while } // end main } // end HelloClient class Distributed Computing, M. L. Liu

29. StatsServer, StatsClient Distributed Computing, M. L. Liu

30. Summary-1 • Client callback: • Client callback is useful for an application where the clients desire to be notified by the server of the occurrence of some event. • Client callback allows an object server to make remote method call to a client via a reference to a client remote interface. Distributed Computing, M. L. Liu

31. Summary-2 • Client callback: • To provide client callback, the client-side software • supplies a remote interface, • instantiate an object which implements the interface, • passes a reference to the object to the server via a remote method call to the server. • The object server: • collects these client references in a data structure. • when the awaited event occurs, the object server invokes the callback method (defined in the client remote interface) to pass data to the client. Two sets of stub-skeletons are needed: one for the server remote interface, the other one for the client remote interface. • Two sets of stub-skeletons are needed: one for the server remote interface, the other one for the client remote interface. Distributed Computing, M. L. Liu

32. Summary-3 • Stub downloading allows a stub class to be loaded to an object client at runtime, thereby allowing a remote object’s implementation to be modified and its stub class regenerated without affecting the software on the client host. • A security manager oversees access restrictions specified in a Java security policy file, which can be a system-wide policy file, or a policy file applied to an individual application only. • For security protection, the use of security managers is recommended in all RMI applications, regardless of whether stub downloading is involved. Distributed Computing, M. L. Liu