Jini: Building Distributed Systems with Federations of Services

1. Outline • Week 1: Survey on various distributed Systems • Week 2: Web Services Using JEE 5 or Glassfish • Week 3: Multicast • Week 3: RMI Callback, Security Manager, Stub Download • Week 4: CORBA Using JavaIDL, CORBA Callback • Week 5: Serialize and Secure Sockets (Digital signature) • Week 6: JSSE, SSL, HTTP, HTTPS • Week 7: Java Message Service (JMS) • Week 8: Jini, JavaSpaces (TupleSpace, Object Space) • Week 9: Peer-to-Peer (JXTA) • Week 10: Mobile Agent: No Voyager or Aglet, Use JADE • Implement our own agent platform using RMI • Week 11: Globus Toolkit • Week 12: MIDlet, JMF, SIP (Audio-Video Streaming) • Exercises: Week 1 survey, Multicast, RMI, CORBA, Digital Signature, UBD Browser, HTTPS CO 4307 – Tutorial Slides

2. Jini • Jini is not an acronym. Jini is a set of APIs and network protocols that help programmers build and deploy distributed systems that are organized as federations of services. • Jini has three protocols • Allows service provider to register its service • Allows Client to search for a service • Allows client and service provider to discover the Jini lookup server. • Jini lookup server • Coordinates the discovery and registration of Jini objects • Discovery is centralized through lookup service but communication is direct between client and server, and thus jini runs as a brokered architecture. • Jini provides programmers easy option to get their devices talk to each other. • Jini can work on XML-based message passing; But generically, Jini requires Java SDK (Java RMI and Serialization). CO 4307 – Tutorial Slides

3. Week 8 - Jini • Jini Architecture does not expect a centralized controlling authority. • Lookup Service (LUS) stores a directory of currently available services. • Jini is independent on network protocols, but currently only TCP/IP implementation exists. • Jini can also form communities, called as groups. • Allows services to find each other without any knowledge about their names or locations. • Program can provide a service without knowing who is managing the service offers and where this takes place. • A service user can look for a service and only needs to know which Java interface the service should implement. • Services which are both hardware and software could be identified in Jini. Such services can be dynamically added to and removed from a system without having to be managed by users or administrators as in the old days. CO 4307 – Tutorial Slides

4. Week 8 - Jini • Lookup service • Services are registered here with a lease period, which could be extended. • Users can search for services matching his requests. • All services in Java are represented by objects, no matter whether they are devices or programs. Jini uses RMI for remote communication. • Each service is assigned a unique identification. This is assigned at registration time by the lookup server and returned to a ServiceIDListener by calling the listener's serviceIdNotify() method. CO 4307 – Tutorial Slides

5. Week 8 - Jini • Jini defines Discovery and Join protocols. • Discovery protocol is used by the clients to identify the lookup server. It is to be noted that the clients don't know the IP address of the lookup server. • Join protocol is used by the clients to register with the lookup server. During registration, it provides necessary information like the interface the service implements and the service attributes which additionally describe the service. • Jini requires Java SDK. While referring the JVM, you need to refer to java.exe in JRE folder. CO 4307 – Tutorial Slides

6. Week 8 - Jini • Jini works as below: • Jini service uses discovery to locate the LUS and then registers its service with LUS. • Jini client uses discovery to locate the LUS and then uses the LUS to find the particular Jini service it wishes to use. The lookup service provides information to client so that client could contact the service directly. • Client and service talk to each other directly. • Jini interactions: • Similar to applet, the proxy provided by the LUS could do the job locally at the client. • The proxy could act as a STUB like in RMI and thus help client contact the service to do the task. • Proxy can act as a smart adapter. Proxy decides on how to execute the functionality. It could select JXTA or sockets or CORBA or others to do handle the task. CO 4307 – Tutorial Slides

7. Week 8 - Jini • Discovery Service is handled in three ways: • New service sends UDP packets using Multicast Request Protocol on 224.0.1.85:4160 and awaits an answer. The lookup server listens at the specified address and reports to the new service. • Multicast Announcement Protocol announces the availability of lookup server, using 224.0.1.84:4160. • Identifying a lookup server using a unicast address (Unicast Discovery Protocol). But, we need to know the IP address in advance. • Services can be grouped in logical manner. CO 4307 – Tutorial Slides

8. Week 8 - Jini • JoinManager(java.lang.Object obj, Entry[] attrSets, ServiceIDListener callback, LeaseRenewalManager leaseMgr) • JoinManager(java.lang.Object obj, Entry[] attrSets, java.lang.String[] groups, LookupLocator[] locators, ServiceIDListener callback, LeaseRenewalManager leaseMgr) • The lookup server contains the collection of all existing services and their descriptions, and can answer queries regarding a specific type of service and, if possible, return matching services. CO 4307 – Tutorial Slides

9. Week 8 - Jini • A service is an object that implements a service API. • A client looks up a service that supports an API. • A discovered service object is sent to the client. • The client and the service only have to agree on the API, and not how requests and responses are transmitted. • Jini is to network services what universal plug-and-play is to system devices: it allows interoperability of clients and services regardless of transport and “wire” protocols. CO 4307 – Tutorial Slides

10. Week 8 - Jini • Each federation of client and service(s): • is independent of other federations and may co-exist with other federations. • is transient: the union lasts only for as long as the service(s) is/are needed. • There is no centralized control system: • There is no centralized administration of available services • There are no policies that restrict federation between client and services. • ServiceRegistrar: Defines the interface to the lookup service. The interface is not a remote interface; each implementation of the lookup service exports proxy objects that implement the ServiceRegistrar interface local to the client, using an implementation-specific protocol to communicate with the actual remote server. CO 4307 – Tutorial Slides

11. Week 8 - Jini • LookupLocator: A utility class that performs unicast discovery, using version 1 of the unicast discovery protocol. • ServiceItem: Items are stored in and retrieved from the lookup service using instances of this class. • getRegistrar(): Perform unicast discovery and return the ServiceRegistrar object for the given lookup service. • register(): Register a new service or re-register an existing service. • ServiceTemplate: Items in the lookup service are matched using instance of this class. A service item (item) matches a service template (tmpl) if: item.serviceID equals tmpl.serviceID (or if tmpl.serviceID is null); and item.service is an instance of every type in tmpl.serviceTypes; and item.attributeSets contains at least one matching entry for each entry template in tmpl.attributeSetTemplates. • Entry: An entry is a typed set of objects, each of which may be tested for exact match with a template. An entry is a typed group of object references represented by a class that implements the marker interface net.jini.core.entry.Entry. CO 4307 – Tutorial Slides

12. Week 8 - Jini • net.jini.core.discovery.LookupLocator • A utility class that performs unicast discovery for a Lookup service • Constructors • LookupLocator(String url) • LookupLocator(String host, int port) • The URL type is jini;Default port for a lookup service is 4160; Translate CAFE-BABE from hex to decimal to get 4160 • String getHost() • int getPort() • ServiceRegistrar getRegistrar() • ServiceRegistrar getRegistrar(int timeout) • Perform unicast discovery and return the ServiceRegistrar object for the given lookup service. CO 4307 – Tutorial Slides

13. Week 8 - Jini • Interface net.jini.core.lookup.ServiceRegistrar • Methods: Information about available services • Class[] getEntryClasses(ServiceTemplate tmpl) Object[] • getFieldValues(ServiceTemplate, int setIndex, String field) Class[] • getServiceTypes(ServiceTemplate, String prefix) • Object lookup(ServiceTemplate tmpl) ServiceMatches • lookup(ServiceTemplate tmpl, int maxMatches) • Returns the service object from an item matching the template • Information about Lookup service: String[] getGroups() • Returns the groups that this lookup service is a member of. • LookupLocator getLocator() • LookupLocator for unicast discovery of lookup service. • ServiceID getServiceID() • Notifcation, Registration • EventRegistration notify(ServiceTemplate tmpl, int transitions, RemoteEventListener listener, MarshalledObject handback, long leaseDuration) ServiceRegistration register(ServiceItem item, long leaseDuration) CO 4307 – Tutorial Slides

14. Week 8 - Jini • Interface net.jini.core.entry.Entry • Entry subclasses: • Are used in identifying and matching services • Contains public fields of non-primitive types • Must have no-argument constructor • All fields must be serializable • Each field is serialized separately, so references between two fields of an entry will not be reconstituted to be shared references, but instead to separate copies of the original object • If a field of an entry being fetched is cannot be deserialized for any reason then net.jini.core.entry.UnusableEntryException will be thrown when • Entry is a marker interface, it has no methods CO 4307 – Tutorial Slides

15. Week 8 - Jini • net.jini.core.lookup.ServiceID • Each service has a unique service id. The id is unique over time and space with respect to all other service ids generated by all lookup services. The id is a 128-bit value, to insure this uniqueness. • It is to be set by the lookup service. To re-register an existing service, or to register the service in any other lookup service, item.serviceID should be set to the same service id that was returned by the initial registration. • com.sun.jini.lookup.ServiceIDListener • Contains one method, serviceIDNotify. The lookup service calls this method to provide the service its service ID. • com.sun.jini.lookup.JoinManager • This class manages the join protocol for a service. It discovers and keeps track of which lookup services to join, registers with them, keeps the registration leases renewed, and keeps the attributes up to date. • JoinManager(Object service, Entry[] attrSets,ServiceIDListener callback, LeaseRenewalManager leaseMgr) • JoinManager Methods • addAttributes(Entry[] attrSets) addAttributes(Entry[] attrSets, boolean checkSC) addGroups(String[] groups) addLocators(LookupLocator[] locators) Entry[] getAttributes() String[] getGroups() ServiceRegistrar[] getJoinSet() CO 4307 – Tutorial Slides

16. Week 8 - Jini • Get the list of lookup services that have currently been joined. • LookupLocator[] getLocators() • Get the list of locators of specific lookup services to join. • modifyAttributes(Entry[] attrSetTemplates, Entry[] attrSets) • modifyAttributes(Entry[] attrSetTemplates, Entry[] attrSets, boolean checkSC) • removeGroups(String[] groups) • removeLocators(LookupLocator[] locators) • setAttributes(Entry[] attrSets) • setGroups(String[] groups) • setLocators(LookupLocator[] locators) • terminate() CO 4307 – Tutorial Slides

17. Week 8 – Jini Operation • Jini Service uses discovery to locate the LUS, either by using multicast or unicast discovery • LUS returns a ServiceRegistrar object • Jini Service can now use the ServiceRegistrar’s register() function to register its service with LUS • Jini client uses discovery to locate the LUS, either by using multicast or unicast discovery • LUS returns a ServiceRegistrar object • Client uses the ServiceRegistrar’s lookup() function to search for specific service required • Client receives the Java Proxy (RequiredService Interface) • Client executes the RequiredService through RMI. CO 4307 – Tutorial Slides

18. Week 8 – Jini – ServiceInterface and Server • MyServiceInterface.java import java.rmi.Remote; import java.rmi.RemoteException; public interface MyServerInterface extends Remote { public String sayHello () throws RemoteException; } • MyService.java import net.jini.lookup.entry.Name; import net.jini.lookup.ServiceIDListener; import net.jini.core.lookup.ServiceID; import net.jini.core.lookup.ServiceRegistrar; import net.jini.core.lookup.ServiceItem; import net.jini.core.discovery.LookupLocator; import net.jini.core.entry.Entry; import net.jini.core.lease.Lease; import java.rmi.server.UnicastRemoteObject; import java.rmi.RemoteException; CO 4307 – Tutorial Slides

19. Week 8 – Jini - Server import java.rmi.RMISecurityManager; public class MyService extends UnicastRemoteObject implements MyServerInterface { public MyService () throws RemoteException { super (); } public String sayHello () throws RemoteException { // MyServiceInterface System.out.println ("server: The method sayHello() in MyService was " + "called"); return ("Hello World from MyService!"); } public static void main (String[] args) { MyServerInterface myServer; LookupLocator lookup; ServiceRegistrar registrar; ServiceItem serviceItem; try { /* Set the security manager to allow the RMI class loader to go to the codebase for classes that are not available locally. */ System.setSecurityManager (new RMISecurityManager ()); CO 4307 – Tutorial Slides

20. Week 8 – Jini - Server /* Create the attributes (an array of entry objects) that describe this server and use it to register this server with the lookup service. JoinManager finds and registers with the lookup service */ Entry[] attr = new Entry[1]; attr[0] = new Name("HelloWorldServer"); myServer = new MyService (); // ServiceItem needs ServiceID, object of service and Attributes as parameters serviceItem = new ServiceItem(null, myServer, attr); lookup = new LookupLocator ("jini://localhost"); registrar = lookup.getRegistrar(); // register needs the ServiceItem and Lease (Lease.ANY [asks LUS to decide the time] or Lease.FOREVER [lease never expires]) // the copy of the ServiceItem object is send to LUS using RMI service and is stored there registrar.register(serviceItem, Lease.FOREVER); System.out.println("Service Ready ..."); } catch (Exception e) { System.out.println("server: MyService.main(): Exception " + e); } } } CO 4307 – Tutorial Slides

21. Week 8 – Jini - Client import net.jini.core.entry.Entry; import net.jini.core.discovery.LookupLocator; import net.jini.core.lookup.ServiceRegistrar; import net.jini.core.lookup.ServiceTemplate; import net.jini.lookup.entry.Name; import java.rmi.RMISecurityManager; public class MyClient { public static void main (String[] args) { Entry[] aeAttributes; LookupLocator lookup; ServiceRegistrar registrar; ServiceTemplate template; MyServerInterface myServerInterface; try { /* Set the security manager to allow the RMI class loader to access the codebase for classes that are not available locally */ System.setSecurityManager (new RMISecurityManager ()); /* Find the Jini lookup service (reggie) and print its location */ lookup = new LookupLocator ("jini://localhost"); CO 4307 – Tutorial Slides

22. Week 8 – Jini - Client /* Get the lookup service's ServiceRegistrar and perform a search to find the service that has the name attribute name of "HelloWorldServer". The lookup service returns an Proxy object to the service */ registrar = lookup.getRegistrar(); aeAttributes = new Entry[1]; aeAttributes[0] = new Name ("HelloWorldServer"); // ServiceTemplate contains the search criteria. Wildcards can be used. // ServiceTemplate might include a ServiceID or attributes template = new ServiceTemplate (null, null, aeAttributes); // lookup needs the ServiceTemplate myServerInterface = (MyServerInterface) registrar.lookup (template); System.out.println ("Calling sayHello()->" + myServerInterface.sayHello () + "<-"); } catch (Exception e) { System.out.println ("client: MyClient.main() exception: " + e); } } } CO 4307 – Tutorial Slides

23. Week 8 - Jini • Compiling and Running the Application • Install the Jini Technology Starter Kit. • jini2_1.exe for Windows or jini2_1.bin for Linux • Double-click the exe file OR ./jini2_1.bin for Linux • Provide folder for jini to install as C:\jini2_1 or /home/student/jini2_1 • If you face problems (libc.so.6 or libdl.so.2 not found) when installing jini on Linux • Install hexadecimal editor on Linux (ghex2 in OpenSuse using YaST) • Open the jini2_1.bin file using ghex: ghex2 jini2_1.bin • Click Edit and Find export LD_ASSUME_KERNEL=2.2.5 and replace it as #xport LD_ASSUME_KERNEL=2.2.5 • Click File and Save. Then, run the jini2_1.bin file. • You must as java SDK already installed for Jini to install (/home/student/SDK/jdk/bin/java). • To start the Jini Service, run Launch-All, which is in the installverify directory of your Jini installation directory. This will start a service browser and six contributed Jini network technology services. • On Windows: If the services does not start, check the Registrar option present in the Service Browser CO 4307 – Tutorial Slides

24. Week 8 - Jini • On Linux: If Launch-All complains libc.20.6 and other errors, use ghex2 and change export LD_ASSUME_KERNEL to #xport LD_ASSUME_KERNEL • On Linux: If you find no service is being run on the Service Browser, click on File and select Find By Address and type 127.0.0.1 or localhost. Then click on Registrar and click on the machine name given. Also, if only one service is running that means the firewall is blocking. Disable firewall so that all the required services start to run. • On the Service Browser, we should be able to see • Lookup Service (Service Registrar): reggie • Persistence Service (JavaSpaces): outrigger • Transaction Service: mahalo • Lookup Discovery Service: fiddler • Lease Renewal Service: norm • Event Mailbox Service: mercury CO 4307 – Tutorial Slides

25. Week 8 - Jini • Compiling and Running the Application • MyServerInterface.java is needed by both the MyService.java and MyClient.java • Compile the MyServerInterface.java, MyService.java and MyClient.java [which are present in c:\mibuhari\practice\jini or /home/student/jini folder] • javac MyServerInterface.java • javac –classpath c:\jini2_1\classes;. MyService.java • javac –classpath c:\jini2_1\classes;. MyClient.java • javac –classpath /home/student/jini2_1/classes:. MyService.java • javac –classpath /home/student/jini2_1/classes:. MyClient.java • We need to generate the stub and skeleton files using • rmic MyService • Without the Service being enabled (using Launch-All), running MyService will generate a Connection Exception. CO 4307 – Tutorial Slides

26. Week 8 - Jini • Run MyService and MyClient (which in c:\mibuhari\practice\jini /home/student/jini folder) as • java -classpath c:\jini2_1\lib\jini-ext.jar;c:\jini2_1\lib\reggie.jar;. MyService • java -classpath ../jini2_1/lib/jini-ext.jar:../jini2_1/lib/reggie.jar:. MyService OR • java -classpath c:\jini2_1\classes;. MyService • java -classpath c:\jini2_1\classes;. MyClient • java -classpath ../jini2_1/classes:. MyService • java -classpath ../jini2_1/classes:. MyClient • The policy file is needed if the RMISecurityManager is used in both the client and server programs. This policy file should be needed for both the client and server. • Lets have a policy file (jini.policy in c:\mibuhari\practice\jini) • grant { permission java.security.AllPermission; }; • Run MyService and MyClient (which in c:\mibuhari\practice\jini folder) as • java –Djava.security.policy=jini.policy -classpath c:\jini2_1\lib\jini-ext.jar;c:\jini2_1\lib\reggie.jar;. MyService • java –Djava.security.policy=jini.policy -classpath ../jini2_1/lib/jini-ext.jar:../jini2_1/lib/reggie.jar:. MyService OR • java –Djava.security.policy=jini.policy -classpath c:\jini2_1\classes;. MyService • java –Djava.security.policy=jini.policy -classpath c:\jini2_1\classes;. MyClient • java –Djava.security.policy=jini.policy -classpath ../jini2_1/classes:. MyService • java –Djava.security.policy=jini.policy -classpath ../jini2_1/classes:. MyClient CO 4307 – Tutorial Slides

27. Week 8 - Jini • Running the Server, adds a service to the Service Browser of Jini. • Running client and server on a single machine: If the Client program is in c:\mibuhari\practice\jini\client folder and Server program is in c:\mibuhari\practice\jini\server • Run MyService (which in c:\mibuhari\practice\jini\server or /home/student/jini folder) as • java –Djava.security.policy=jini.policy -classpath c:\jini2_1\classes;. MyService • java –Djava.security.policy=jini.policy -classpath ../jini2_1/classes:. MyService • Run MyClient (which in c:\mibuhari\practice\jini\client folder) as • java –Djava.security.policy=jini.policy -classpath c:\jini2_1\classes;..\server;. MyClient • java –Djava.security.policy=jini.policy -classpath ../jini2_1/classes:../server:. MyClient • ..\server is a must to indicate the path to the Server. Otherwise ClassNotFoundException: MyService will be reported. CO 4307 – Tutorial Slides

28. Week 8 - Jini • Running client and server at different machines: Client requires the Implementation and the stub be available for usage through HTTP (We use J2EE here). • Copy the MyService.class and MyService_Stub.class into the C:\Sun\SDK\domains\domain1\docroot or /src/www/htdocs folder. • Then run the server and client as: • java –Djava.security.policy=jini.policy -classpath c:\jini2_1\classes;. MyService • java –Djava.rmi.server.codebase=http://202.160.5.155:8080/ –Djava.security.policy=jini.policy -classpath c:\jini2_1\classes;. MyClient • java –Djava.security.policy=jini.policy -classpath ../jini2_1/classes:. MyService • java –Djava.rmi.server.codebase=http://202.160.5.155:8080/ –Djava.security.policy=jini.policy -classpath ../jini2_1/classes:. MyClient • Where, 202.160.0.155 is the IP address of the server. CO 4307 – Tutorial Slides

29. Week 8 - Jini • Jini Starter Kit is made up of many jar files. Here are few important ones: • jini-core.jar, core Jini functionality • jini-ext.jar, Jini lookup functionality (from client) • reggie.jar, Jini Lookup service • reggie-dl.jar, Jini lookup service • tools.jar, HTTP server • Jini Starts three services • An HTTP server: for accessing the remote class files • RMID Daemon: which starts on machines where you want to host the remote Java objects • Reggie: the default Jini lookup server CO 4307 – Tutorial Slides

30. Week 8 –JavaSpaces • The JavaSpaces technology is a simple and powerful high-level tool for building distributed and collaborative applications. • Based on the concept of shared network-based space that serves as both object storage and exchange area, it provides a simple API that is easy to learn and yet expressive for building sophisticated distributed applications. • The JavaSpaces technology model is different in that it provides persistent object exchange areas (or spaces) through which remote Java technology processes coordinate actions and exchange data. • A marked departure from classic distributed models that rely on message passing or RMI, the JavaSpaces model views a distributed application as a collection of processes that cooperate through the flow of objects into and out of one or more spaces. This programming model has its roots in Linda, a coordination language developed by Dr. David Gelernter at Yale University. CO 4307 – Tutorial Slides

31. Week 8 - JavaSpaces • Relational databases understand the data they store and manipulate it directly through query languages such as SQL. JavaSpaces services, on the other hand, store entries that they understand only by type and the serialized form of each field. • As a result, IN JavaSpaces: • there are no general queries • Only "exact match" or "don't care" for a given field is allowed. • Object databases provide an object-oriented image of stored data that can be modified and used, almost as if it were transient memory. JavaSpaces systems do not provide a nearly transparent persistent or transient layer, and they work only on copies of entries. CO 4307 – Tutorial Slides

32. Week 8 - JavaSpaces • Operations used in JavaSpaces are: • write(): Writes new objects into a space • take(): Retrieves objects from a space • read(): Makes a copy of objects in a space • notify: Notifies a specified object when entries that match the given template are written into a space • Both the read() and take() methods have variants: readIfExists() and takeIfExists(). If they are called with a zero timeout, then they are equivalent to their counterpart. The timeout parameter comes into effect only when a transaction is used. • Unlike conventional object stores, objects are passive data. Therefore, processes do not modify objects in the space or invoke their methods directly. In order to modify an object, a process must explicitly remove, update, and reinsert it into the space. CO 4307 – Tutorial Slides

33. Week 8 - JavaSpaces • Once an entry is written into a JavaSpaces service, it can be used in future look-up operations. Looking up entries is performed using templates, which are entry objects that have some or all of their fields set to specified values that must be matched exactly. All remaining fields, which are not used in the lookup, are left as wildcards. • The read() method returns either an entry that matches the template or an indication that no match was found. The take() method operates like read(), but if a match is found, the entry is removed from the space. CO 4307 – Tutorial Slides

34. Week 8 - JavaSpaces • A client can interact with as many JavaSpaces services as needed. Clients perform operations that map entries to templates onto JavaSpaces services. • In a Chat example, participants write message objects into the space, while other members wait for new message objects to appear, then read them out and display their contents. The list of participants can be kept in the space and updated whenever someone joins or leaves the discussion. Because the space is persistent, a new member can read and view the entire discussion CO 4307 – Tutorial Slides

35. Week 8 - JavaSpaces • JavaSpaces is part of Jini and is used for management and retrieval of matching services in the lookup service, so that services and service attributes are described in the JavaSpaces way in the first place. • public ServiceTemplate(ServiceID serviceID, Class[] serviceTypes, Entry[] attributeSetTemplate) • Proxy of the requested service will be transmitted, which in this case corresponds to an RMI stub, and which can be used to issue remote calls to the service via RMI • Remaining lease time in milliseconds: getExpiration() • Extending leases: renew(long duration) • User of a lease can terminate a lease prematurely by calling cancel() CO 4307 – Tutorial Slides

36. Week 8 - JavaSpaces • A space is a shared, network-accessible repository for objects. Instead of communicating with each other, processes coordinate by exchanging objects through one or more spaces. • A space may be transient, or it may be persistent. • An object may be identified using properties lookup; if a desired object is not currently available, a process can wait until one arrives. • Objects deposited in a space are passive. Unlike other models, processes don’t modify objects in the space or invoke an object’s methods directly. • To modify an object, a process must explicitly remove it, update it, and reinsert it into the space. CO 4307 – Tutorial Slides

37. Week 8 - JavaSpaces • To build applications based on object spaces, one designs distributed data structures and distributed protocols that operate over the object spaces. • A distributed data structure is composed of multiple objects that are stored in one or more spaces. • A distributed protocol defines the way participants share and modify these data structures in a coordinated way. • JavaSpaces API has an interface named Entry, which can be used to write or read from a space. CO 4307 – Tutorial Slides

38. Week 8 - JavaSpaces • JavaSpace runs over Jini. • To run JavaSpace, you need an infrastructure in place: • An HTTP server, used to download code to JavaSpaces clients. • An RMI Activation Daemon, for managing the states of Jini services. • A Lookup service: for Jini service location. • A JavaSpaces service. • Optionally, a transaction manager. CO 4307 – Tutorial Slides

39. Week 8 - JavaSpaces • Simplicity. • Expressive: “Using a small set of operations, we can build a large class of distributed applications without writing a lot of code.” • It supports loosely coupled protocols. • It eases the burden of writing client/server systems: the functionalities of the server are provided for free, via the spaces; in most cases only the client code needs to be written. CO 4307 – Tutorial Slides

40. Week 8 - JavaSpaces • All operations are invoked on an object that implements the net.jini.space.JavaSpace interface • JavaSpace space = getSpace(); • MessageEntry msg = new MessageEntry(); • msg.content = "Hello there"; • space.write(msg, null, Lease.FOREVER); • The null field indicates that no Transaction object is managing the operation. • The write() operation places a copy of an entry into the given JavaSpace service, and the Entry passed is not affected by the operation. Each write() operation places a new Entry into the space even if the same Entry object is used in more than one write(). CO 4307 – Tutorial Slides

41. Week 8 - JavaSpaces • Entries written in a space are governed by a renewable lease. You can change the lease (when the write() operation is invoked) to one hour as follows • space.write(msg, null, 60 * 60 * 1000); • A write() operation returns a Lease object that is milliseconds long. If the requested time is longer than the space is willing to grant, you will get a lease with a reduced time. In addition, when the lease expires, the entry is removed from the space. • To read an entry, a template is used, which is an entry that may have one or more of its fields set to null. An entry matches a template if (a) the entry has the same type as or is a subtype of the template and (b) if for every specified non-null field in the template, their fields match exactly. The null fields act as wildcards and match any value. CO 4307 – Tutorial Slides

42. Week 8 - JavaSpaces • MessageEntry template = new MessageEntry(); • MessageEntry output = (MessageEntry) space.read(template, null, Long.MAX_VALUE); • The Long.MAX_VALUE is a timeout value that specifies how long the client is willing to wait for a matching entry to appear, even if there is no hint of an entry appearing. The read() and take() operations would block on a completely empty space. But if the timeout value was readIfExists(), then it would be how long the client was willing to wait for interfering transactions to settle. CO 4307 – Tutorial Slides

43. Week 8 - JavaSpaces • Transactions • The JavaSpaces API uses the package net.jini.core.transaction to provide basic atomic transactions that group multiple operations across multiple JavaSpaces services into a bundle that acts as a single atomic operation. Either all modifications within the transactions will be applied or none will, regardless of whether the transaction spans one or more operations or one or more JavaSpaces services. • Transactions can span multiple spaces and participants in general. CO 4307 – Tutorial Slides

44. Week 8 - JavaSpaces • The Jini Technology Starter Kit comes with the package com.sun.jini.outrigger, which provides an implementation of a JavaSpaces technology-enabled service. You can run it two ways: • As a transient space that loses its state between executions: Use com.sun.jini.outrigger.TransientOutriggerImpl. • As a persistent space that maintains state between executions: Use com.sun.jini.outrigger.PersistentOutriggerImpl. • The TransientOutriggerImpl can be run only as a nonactivatable server, but the PersistentOutriggerImpl can be run as either an activatable or nonactivatable server CO 4307 – Tutorial Slides

45. Week 8 - JavaSpaces • Compiling and Running the Application • Install the Jini Technology Starter Kit. • Compile the MessageEntry.java [which is present in c:\mibuhari\javaspaces or /home/student/javaspaces folder] • javac –classpath c:\jini2_1\classes MessageEntry.java • javac –classpath /home/student/jini2_1/classes MessageEntry.java • To start the JavaSpace Service, run Launch-All, which is in the installverify directory of your Jini installation directory. This will start a service browser and six contributed Jini network technology services. • Check if the firewall is disabled or not. • If the services does not start, check the Registrar option present in the Service Browser. You might need to use File  Find by Address and type 127.0.0.1 and then select the Registrar option. • Compile the Lookup.java • javac –classpath c:\jini2_1\classes Lookup.java • javac –classpath /home/student/jini2_1/classes Lookup.java • Note that Lookup.java and MessageEntry.java don’t have main method and both are needed for SpaceClient.java program CO 4307 – Tutorial Slides

46. Week 8 - JavaSpaces • Compiling and Running the Application • Compile the SpaceClient.java (. Indicates current folder) • javac –classpath c:\jini2_1\classes;. SpaceClient.java • javac –classpath /home/student/jini2_1/classes:. SpaceClient.java • Run the SpaceClient (which in c:\mibuhari\javaspaces or /home/student/javaspaces folder) as • java -classpath c:\jini2_1\lib\jini-ext.jar;c:\jini2_1\lib\reggie.jar;c:\jini2_1\lib\outrigger.jar;c:\mibuhari\javaspaces SpaceClient • java -classpath /home/student/jini2_1/lib/jini-ext.jar:/home/student/jini2_1/lib/reggie.jar:/home/student/jini2_1/lib/outrigger.jar:. SpaceClient • If the SpaceClient did not respond, make sure the firewall is disabled. CO 4307 – Tutorial Slides