Core Jini

I. FOUNDATIONS.

1. A New Computing Paradigm.


Jini History. The Jini Vision. Not Just for Consumer Electronics. Jini Becomes Public. Licensees. Community Source Licensing. Getting and Installing Jini. Installing Java 2. Downloading the JDK from Sun. Unpacking the Distribution. Examining the Distribution. Installing Jini. Downloading Jini from Sun. Unpacking the Distribution. Examining the Distribution. Set Up Your Environment. Setting Your PATH. Start the Jini Run-time Services. Starting Required Services via the GUI. Running the GUI. Starting Required Services via the Command Line. Start the Web Server. Start the RMI Activation Daemon. Start the Lookup Service. Running the Sample Program. Further Reading and Resources.

2. Distributed Systems.


What's So Hard about the Network? Classical Networked Systems. The Network Is Not Transparent. Performance and Latency. New Failure Modes. Concurrency and Consistency. New Paradigms in Distributed Computing. The Need for Strong Typing. Practical Remote Polymorphism. Remoteness Is Part of the Interface, Not the Implementation. Further Reading.

3. The Jini Model.


Jini Design Center. Simplicity. Reliability. Scalability. Device Agnosticism. What Jini Is Not. Jini Is Not a Name Server. Jini Is Not JavaBeans. Jini Is Not Enterprise JavaBeans. Jini Is Not RMI. Jini Is Not a Distributed Operating System. What Jini Is. Services Carry the Code Needed to Use Them. A "Meta Service" Provides Access to All Other Services. A Bootstrapping Process is Used to Find Proxies for the Lookup Service. Fleshing Out the Key Ideas. Downloadable Proxies. Using Lookup Services. Publishing a Service. Finding a Service. Common Interfaces, Divergent Implementations. Discovery. The Discovery Protocols. Supporting Multiple Communities. Supporting Technology. Leasing. Time-Based Resource Reservation. Remote Events. How Jini Uses Events. Remote vs. Local Events. Distributed Transactions. Ensuring Data Integrity. Transactions In Jini. What's Next?

4. Deployment Scenarios.


What Does It Mean to Be a Jini Service? How to Use Jini for Your Devices and Services. Jini on General-Purpose Computers. Jini on Java-Enabled Devices. Limited Java Environments. Versioning. Jini Using Device Proxies. Requirements for Jini Infrastructure Services. When Does Jini Make Sense? When Is Jini Not Appropriate? Further Reading. What's Next?

II. BUILDING WITH JINI.

5. Getting Started with Jini.


Running the Jini Services. Developing with Deployment in Mind. Run Multiple HTTP Servers. Watch Out for Codebase Problems. Always Set a Security Manager. Pay Attention to Security Policies. Take Care with CLASSPATH. Consider Bundling Downloadable Code into a JAR File. Summary. A First Jini Program: Hello, World. Writing the Service Proxy. The "Wrapper" Application. Using Discovery and Lookup. Last Details. Using Service Templates to Search for a Service. Looking Up a Service. Compiling and Running the Examples. Compiling. Start an HTTP Server for the Service. Set Up a Security Policy File. Running. Extending Hello World with Events. Writing a Remote Event Listener. Soliciting Events via Notify(). Compiling and Running the Code. Compiling. Generating the RMI Stubs. Start an HTTP Server to Export the Client's Downloadable Code. Running. Hello World with Leasing. A Simple Approach. Compiling and Running the Code. Compiling. Running. Using an Activatable Back-End Process. Defining the Remote Protocol. Defining a New Network-Aware Proxy. Defining the New Service Wrapper. Compiling and Running the Example. Compiling. Generating the RMI Stubs. Running. One Final Iteration. What's Next?

6. In Depth: Discovery.


What's Discovery? Groups Partition the Community Namespace. Types of Discovery. An Overview of Discovery. An IP Multicast Primer. Service-Initiated Discovery. Lookup Service-Initiated Discovery. "Direct" Discovery. Using Discovery in Applications. DiscoveryListeners Are Informed of Discoveries. DiscoveryChange Listeners Are Informed of Changes in Group Membership of Lookup Services. DiscoveryEvents Encapsulate Discovery Information. Using LookupDiscovery to Control Multicast Discovery. An Example. Security and LookupDiscovery. Compiling and Running the Program. Common Interfaces for Controlling Discovery. Other Discovery Classes. Using LookupLocator to Control UnicastDiscovery. An Example. Compiling and Running the Program. Under the Hood: The Discovery Protocols. The Multicast Request Protocol. Communication Flow. Packet Format. Using the Multicast Request Protocol. The Multicast Announcement Protocol. Communication Flow. Packet Format. Using the Multicast Announcement Protocol. The Unicast Discovery Protocol. Communication Flow. Packet Format. Using Unicast Discovery. An Example. Compiling and Running the Program. Other Internal Discovery Issues. Multicast Restrictions and Guidelines. Multicast Routing Infrastructure. Security. Host and Network Requirements. Interfaces for Discovery Implementors. Summary. What's Next?

7. Attributes, Templates, and Service Matching.


Attributes Basics. What Are Attributes? Search Using Attributes. The Special Semantics of Attributes? Who Changes Attributes? The Standard Attributes. Writing New Attributes. An Example: A Capacity Attribute. Attributes and Beans. Using Entry Beans to Map Entries to Beans. How Are Entry Beans Found? The Entry Bean Class. The Standard Entry Beans. An Example: A Capacity Bean. A Second Bean Example: Using GUI Beans. Matching using Service Templates. An Example of Matching Multiple Attributes. Further Reading.

8. IThe Service Join Protocol.


Overview of Lookup. Publishing a Service Proxy: The Join Protocol. The JoinManager Class. Managing Service Ids. Using the JoinManager in Applications. Compiling and Running the Example. Using Attributes through the JoinManager. Restricting Changes to ServiceControlled Attributes. Further Reading. Summary. What's Next?

9. Using Low-Level Service Interfaces.


How Clients Use Lookup. Using the ServiceRegistrar Interface. Searching for Services. The Search APIs. An Example: Searching for Service Information. Compiling and Running the Example. Soliciting Events from a Lookup Service. Specifying When Events Should Be Sent. Using Notify() to Ask for Events. Receiving Events. An Example: Using Events to Find Services. Compiling and Running. Other Client Issues. You Cannot Change a Service's Attributes Without Going through the Service. Downloaded Service Proxies Are Not Leased. Service IDs Are Unique Across Lookup Services. "Browser-Oriented" Lookup APIs. Federating and Administering Lookup Services. A Quick Overview of Service Administration. Lookup Administrative Interfaces. Administering the Reggie Lookup Service Implementation. Federating Lookup Services. Compiling and Running. Example: A Lookup Service Tunnel. Compiling and Running. Summary. What's Next?

10. Using the ServiceDiscovery Manager.


Higher Level APIs for Client Lookup. The ServiceDiscoveryManager. A Word on Usage Patterns. Creating Lookup Caches. New Versions of Lookup(). Miscellaneous Methods. Receiving Remote Events. Supporting Classes. LookupCache. ServiceItemFilter. ServiceDiscoveryListener. ServiceDiscoveryEvent. A Basic Example. Compiling and Running the Example. Using Filters. Compiling and Running the Example. Using Events. Compiling and Running the Example. Summary. What's Next?

11. A Jini Lookup Service Brower.


What Does a Browser Do? Using the Browser. Building Administration Components. DestroyAdminPanel. StorageLocationAdminPanel. A ListBox for Managing Sets. DiscoveryAdminPanel. JoinAdminPanel. AdminPanel. JList Cell Renderers for Common Jini Types. LookupCellRenderer. ServiceCellRenderer. AttrCellRenderer. The Core Browser Framework. Storing Data in Lists. Using Discovery. Receiving Service Events. Handling List Events. The Browser Class. Building and Running the Browser. What's Next?

12. Leasing.


Reliability in Distributed Systems. The Need for Self-Healing. The Need for Evolvability. Leasing as a Solution. The Leasing Approach. Issues in Leasing. Relative vs. Absolute Time. Lease Negotiation. Leasing Done by Third Parties. The Cost of Leasing. Building Lease Consumers. The Lease Interface. Determining When a Lease Expires. Canceling a Lease. Renewing a Lease. Ensuring That Leases are Serialized Correctly. Batching Leases for Performance. The LeaseMap Interface. Higher Level APIs for Lease Consumers. A Leasing Service. An Overview of a Leasing Service. Remote Leasing APIs. Events and Listeners for Remote Leasing. Leasing Service Implementation. Compiling and Running the Example. Leasing in Practice. Who Handles Lease Renewals? The Perils of Leasing. Delegation to an External JVM vs. Delegation to an Internal Class. Leasing vs. Garbage Collection. Summary. What's Next?

13. Exporting Leased Resources.


Leasing Interfaces and Implementations. The Landlord Paradigm. Identifying Leased Resources. Implementing the Landlord Interface. An Example. Compiling and Running the Examples. Summary. What's Next?

14. The Well-Behaved Service.


The Responsibilities of a Service. Service Administration. Administration through Delegation. Administrative Interfaces. Implementation of Administrative Delegates. An Example: Administering the LeaseService. Providing User Interfaces for Services. Several Approaches to Providing Uis. A Simple Example: User Interfaces as Attributes. The ServiceUI Approach. The Jini Community at Work. ServiceUI Essentials. UI Factories. UI Roles. Where to Go Next. Summary. Related Reading. What's Next?

15. The Complete Example: The Print Service.


Requirements for a Printing Service. A Service Writer's Toolkit. A Superclass for Services. A Tool for Administration. Defining the Print Service API. Communicating with Clients: Events and Listeners. The Remote Printing Interface. The Print Service Proxy. Printer Administration APIs and Uis. Internals of the Print Service. Printing. Persistent Data Formats. Implementing Print Service Administration. A Print Client. Compiling and Running the Examples. Ideas for Future Work. Summary. Related Reading. What's Next?

16. In Depth: Remote Events.


The Need for Notifications. Jini Event Design Center. How Remote Events Differ from Local Events. Out of Order Delivery. Partial Failures. Latency Versus Computation. Addressing Application Semantics. The Jini Event Programming Model. The RemoteEvent Class. Event Types. Sequence Numbers, Idempotency, and Ordering. Application-Specified Return Data. The RemoteEventListener Interface. Dealing with Errors. Other Event Interfaces. An Example: Heartbeat Events. A Toolkit for Event Registrations. A Simple Event Generator. Event Types and Sequence Numbers. Defining a Cookie Type. Persistent Data. Registering for and Sending Events. A Client to Test the HeartbeatGenerator. Compiling and Running the Heartbeat Examples. Third-Party Event Delegates. Designing for Composition. Composition in Practice. How Events Are Delivered through the Pipeline. Setting up the Pipeline. Pipelines from the Generator Perspective. Pipelines from the Listener Perspective. Leasing across Delegates. An Example: An Event Mailbox. The EventMailbox Service. A Mailbox Client. Compiling and Running the Examples. Summary. What's Next?

17. JavaSpaces.


What Is JavaSpaces? A Filesystem for Objects. Attribute-Based Search. Predecessors to JavaSpaces. Configuring and Running JavaSpaces. Start the Run-Time Services. Starting Required Services via the GUI. Starting the Required Services via the Command Line. Transient and Persistent JavaSpaces. The JavaSpaces Programming Model. Transactions, in Brief. JavaSpaces APIs. Write(). Read() and ReadIfExists(). Take() and TakeIfExists(). Notify(). Snapshot(). An Example: Persistent Event Logging with JavaSpaces. Design for Searchability. A Community Watcher. A Consumer of Logged Event Data. Compiling and Running the Programs. Applying JavaSpaces to Distributed Computing Problems. Further Reading. What's Next?

18. Distributed Applications.


Consistency and the Evils of Partial Failure. A Classical Transaction Model. Two-Phase Commit. Transactions in Jini. The Players in Jini Transactions. Programming with Jini Transactions. The Transaction Manager. Creating Transactions. The Transaction Interface. Transaction Participants. Using Transactions with JavaSpaces. Compiling and Running the EntryMover. Other Transaction Issues and Idioms. Transactions and Visibility. Nesting Transactions. Events and Sequence Numbers. Using Transactions to Hide Data. Summary.

19. The Jini Utility Services.


Why the Utility Services? Configuring and Running the Utility Services. A Refresher: The Lifecycle of Activatable Services. Starting the LookupDiscoveryService. Starting the LeaseRenewalService. Starting the EventMailbox. The LookupDiscoveryService. Other Situations. The LookupDiscoveryService Programming Model. RemoteDiscoveryEvents. LookupDiscoveryRegistrations. The LeaseRenewalService. The LeaseRenewalService Programming Model. The LeaseRenewalSet Interface. Exception Classes. Event Classes. The EventMailbox. An Example. Compiling and Running the Example. Summary.

III. APPENDICES.

Appendix A. An RMI Primer.


Overview of RMI. Remote Interfaces. Stubs and Skeletons. Serialization. Parameters and Return Values. Dynamic Code Loading. Security Implications. Marshalled Objects. Building with RMI. Compiling the Example. Running the Programs. The Activation Framework. Players in Activation. Using the Activation Framework. An Example. Compiling and Running the Example. Compiling. Running. Fully Utilizing Activation in a Jini Service. Other Activation Topics. "Lazy" References. Deactivation. Getting the Most from the Activation Daemon. Further Reading.

Appendix B. Common Java and Jini System Properties.
Index.