A tutorial on Jini

Jini Federation

• A Jini federation or ``djinn'' consists of a number of clients, services and service locators
• Typically connected by TCP/IP
• Code is moved around from service to locator to client using Java 1.2 extensions to RMI

Figure 1: Components of a Jini federation

Service Registration

Figure 2: Querying for a service locator

Figure 3: Registrar returned

Figure 4: Service uploaded

Client Lookup

Figure 5: Querying for a service locator

Figure 6: Registrar returned

Figure 7: Asking for a service

Figure 8: Service returned

Support Services

Proxies

• A toaster will be controlled by some service software
• The service software will be moved across the network to the client
• The mobile code must be a proxy for the real service code
• The proxy may be explicitly written or be an RMI proxy stub
• Remote calls from the proxy may be RMI Remote calls, or by some other mechanism such as private TCP connection

Attribute Registration

Service Location

Leasing

• Because services can come and go, network connections can be lost, etc, a distributed garbage collection mechanism is needed
• Services which register are granted a lease
• Registration lasts for as long as the lease
• When the lease expires, the service is removed
• Leases can be renewed

Non-distributed Application

Distributed Version

Client Structure

Internally a client will look like

The following code is simplified from the real case. It attempts to find a FileClassifier service, calling the method getMIMEType() on this service.

public class TestUnicastFileClassifier {

    public static void main(String argv[]) {
	new TestUnicastFileClassifier();
    }

    public TestUnicastFileClassifier() {
	LookupLocator lookup = null;
	ServiceRegistrar registrar = null;
	FileClassifier classifier = null;

        // Prepare for discovery	
        lookup = new LookupLocator("jini://www.all_about_files.com");

        // Discover a lookup service
        // This uses the synchronous unicast protocol
	registrar = lookup.getRegistrar();

        // Prepare a template for lookup search
	Class[] classes = new Class[] {FileClassifier.class};
	ServiceTemplate template = new ServiceTemplate(null, classes, null);

        // Lookup a service
	classifier = (FileClassifier) registrar.lookup(template);

        // Call the service
	MIMEType type;
	type = classifier.getMIMEType("file1.txt");
        System.out.println("Type is " + type.toString());
    }
} // TestUnicastFileClassifier

Server Structure

The following code is simplified from the real case. It exports an implementation of a file classifier service, as a FileClassifierImpl object.

public class FileClassifierServer implements DiscoveryListener {
    
    protected LeaseRenewalManager leaseManager = new LeaseRenewalManager();

    public static void main(String argv[]) {
	new FileClassifierServer();

        // keep server running forever to 
	// - allow time for locator discovery and
	// - keep re-registering the lease
        Thread.currentThread().sleep(Lease.FOREVER);
    }

    public FileClassifierServer() {
	LookupDiscovery discover = null;

        // Prepare for discovery - empty here

        // Discover a lookup service
        // This uses the asynchronous multicast protocol,
        // which calls back into the discovered() method
        discover = new LookupDiscovery(LookupDiscovery.ALL_GROUPS);

        discover.addDiscoveryListener(this);
    }
    
    public void discovered(DiscoveryEvent evt) {
        ServiceRegistrar registrar = evt.getRegistrars()[0];
        // At this point we have discovered a lookup service

        // Create information about a service
	ServiceItem item = new ServiceItem(null,
         				   new FileClassifierImpl(), 
					   null);

        // Export a service
	ServiceRegistration reg = registrar.register(item, Lease.FOREVER);

	// Renew leasing
	leaseManager.renewUntil(reg.getLease(), Lease.FOREVER, this);
    }
} // FileClassifierServer