"For the 1.1 release, we put together some utility classes to make writing a Jini service or a Jini client easier. Some of these were actually included in the first Jini release. We tried to apply to them the same careful design effort that we put in the earlier interfaces that define Jini as whole, mainly to make these utilities easier to use and more robust. Mostly, people can use these utility classes -- yet they don't have to -- to write their services. We make a distinction between utilities, which are classes, and services that are real Jini services living out on the network. This time around, we put in a lease-renewal service, a lookup discovery service, and an event mailbox."
"Regardless of specific invariables, you can use the Jini transaction coordinator to arrange your transaction's commitment, employing the two-phase commit protocol. In Part 2 of this series, I described how you use that coordinator as a client for the two-phase commit protocol. In this article, I will focus on techniques for writing transaction participant Jini services."
"Bill Venners recently spoke with Dr. Achacoso about the current state and future demands of enterprise software. In this interview, Dr. Achacoso explains why he feels enterprise applications need to be more network-aware, and how Jini can help. He suggests an impedance mismatch exists between the architecture of Web services and the predominately client/server architectures used to implement them. He further discusses how Jini can be leveraged in implementing Web services, and suggests ways in which he believes enterprise developers will need to evolve their thinking in the years to come."
"Jim Waldo: Mobility is an interesting new wrinkle in our networks. We have always built networks with the idea that the things the network hooks together don't move around much. If you move your machine from one place to another, it essentially becomes a different machine. It's hard to convince the network that it's the same. Your identity may be the same if you have certificates issued by a certificate authority, or if you can log in through some network-wide login mechanism. But, say, if you take your laptop from one office to another, your machine gets a new IP address through DHCP (Dynamic Host Configuration Protocol) or some other mechanism. As far as the network is concerned, it's a different machine."
"To interact with the lookup service, the client must first obtain a service registrar object via discovery, a network-level protocol used by Jini's runtime infrastructure. Discovery enables clients and services to locate lookup services. (For more information on discovery, see Resources.) The service registrar object, which implements the net.jini.core.lookup.ServiceRegistrar interface, enables the client to interact with the lookup service. To find desired services, clients build a ServiceTemplate, an instance of class net.jini.core.lookup.ServiceTemplate, and pass it to one of two lookup() methods declared in the ServiceRegistrar interface. Each lookup() method sends the service template to the lookup service, which performs the query and returns matching service objects to the client."
"Rob Gingell (pronounced "jingle") is Sun Microsystems' chief engineer, a position that gives him oversight of all of Sun's developments and directions. Born in the Washington, D.C. area, he pursued his studies at Case Western Reserve University in Cleveland, Ohio, where he worked on projects for the US government's Advanced Research Projects Agency (ARPA), an early sponsor of the Unix operating system and the Internet. Upon graduation, he continued his work at the university for eight more years when, in 1985, Gingell moved to the West Coast to work for Sun on the company's next-generation operating system. In that capacity, he developed a new dynamic linking mechanism and contributed to defining the ELF (executable and linking format) object format, which has since become the standard binary file format on most Unix operating systems, as well as on Linux. Much of that work led to the definition of the Solaris ABI (application binary interface), which guarantees that a binary program runs on different versions of Solaris, as long as that program conforms to the Solaris ABI. (By contrast, an API guarantees a developer's access to a library's function and method definitions, as long as that library conforms to an API.)"
"In this article, I'll explain how to attach an interface to a simple Jini service, and then walk you through building an application to browse those services using Swing components and the ServiceUI framework."
"While no special contract or license prescribes the use of the new security model, many in the Jini community believe that security-conscious Jini projects will use these new specifications and APIs. The new specifications form the key innovations in Sun's Jini Starter Kit (JSK) 2.0. Thus, I refer to the security framework in Sun Microsystems' JSK 2.0 as "the" Jini security framework, even though other security-related Jini projects may spring up in the future. In this article, I describe the Jini security model and give you a taste of the new security-related APIs."
"JW hot topic: Tech careers in a slump Seems like new layoffs are announced every week, projects are dying and software developers are feeling the IT budget squeeze. Being nervous isn't a crime, but you're better off with information, advice, and a plan."
"Taking a similar approach to building Jini-based distributed systems might be helpful. We cannot make a large network, such as the Internet, more reliable. But we can make the computations we wish to perform over that network as reliable as possible. Your users -- whether people or other Jini services -- are primarily interested in the computations your service provides. Ensuring the reliability of those computations in the presence of network and component failures will likely lead to your service's longevity."
"I first heard this warning against writing Java programs that depend on "timely" finalization from Tim Lindolm, who was responsible for thread and garbage-collection mechanisms of Sun's original Java virtual machine (JVM). Tim gave this warning at the JVM Birds-of-a-Feather session at the first JavaOne conference in 1996. The problem with depending on timely finalization for program correctness is that you generally don't know how garbage collection will be performed inside a JVM. Therefore, since you don't know when (or even if) any particular object will be garbage collected, you don't know when or if it will be finalized."
"An important Jini promise is to disrupt this trend. As Jini architect Jim Waldo put it: "I dream of a world in which my children will never have to use InstallShield." In a recent JavaWorldinterview (see Resources), Waldo referred to Java's ability to download code and objects on an as-needed basis from anywhere on the network."
"Jim Waldo: Mobility is an interesting new wrinkle in our networks. We have always built networks with the idea that the things the network hooks together don't move around much. If you move your machine from one place to another, it essentially becomes a different machine. It's hard to convince the network that it's the same. Your identity may be the same if you have certificates issued by a certificate authority, or if you can log in through some network-wide login mechanism. But, say, if you take your laptop from one office to another, your machine gets a new IP address through DHCP (Dynamic Host Configuration Protocol) or some other mechanism. As far as the network is concerned, it's a different machine."
"If Activatable.inactive() succeeds, and if the group has no more active objects and is not activating objects, the activation system will shut down the group's Java VM. If an object fails to call Activatable.inactive(), it will never be garbage-collected because the activation group holds strong references to every object it creates. (Hence, if that object is the last one running in the Java VM, the Java VM will not shut down either.) The rules for garbage collection still hold, though: the object needs to make sure that it has no nondaemon threads running, and that it nulls out enough references to be eligible for garbage collection."
"Coming back to her office, Sal picks up a tab and "waves" it to her friend Joe in the design group, with whom she is sharing a virtual office for a few weeks. They have a joint assignment on her latest project. Virtual office sharing can take many forms -- in this case, the two have given each other access to their location detectors and to each other's screen contents and location ... A blank tab on Sal's desk beeps, and displays the word "Joe" on it. She picks it up and gestures with it towards her liveboard. Joe wants to discuss a document with her, and now it shows up on the wall as she hears Joe's voice ..."
"In Part 1 of this interview, Sun Microsystems Fellow and Chief Engineer Rob Gingell discussed the role of Jini in Sun's new software organization, the relationship between Jini, Web services, and the Sun ONE (Open Network Environment) initiative, and the rationale for document-centered Web services versus mobile object systems. He concludes his discussion by comparing Jini with Web services, questioning Jini's role in the JDK, and sharing his summer vacation plans."
"HTTP servers, by themselves, are of course not Jini-specific; they are familiar from the World Wide Web. On the Web, the deployment scenario is simple: the clients make HTTP requests from the server. In a Jini system, though, any component may need code served on its behalf, and so we may have to set up many HTTP servers for even the simplest systems. As the Jini Testing Handbook at Jini.org puts it:"
"On May 19, I flew to Aspen, CO, to attend the first Jini Community Summit. I went to Aspen to learn more about Jini, to see what other people are doing with it, and to attempt to figure out what the Jini community is all about. The first person I met was Torin Sarasas, with whom I had agreed over e-mail to share the expenses of a hotel room. At 6:30 that evening, Torin and I walked over to the community center for an informal cocktail reception. Being rather hungry, I dragged Torin over to a table of cheese, crackers, and vegetables, where I filled up a plate. Then we set out to mingle."
"As a follow-up to the ONJava feature, Jini as an Enterprise Solution, Dave Sag proposes Crudlets as a compromise to the extreme Jini and XML communities' perspectives, as evidenced by his use of Jini-Fascists and XML geeks. Crudlets is an open source architecture essentially based on an Apache Cocoon and XSP Tag Library that maps to seven fundamental events performed by Jini agents. It's his view that Crudlets should be a mutually beneficial architecture that combines Jini and XML. For commonality and simplicity, these two technologies are compatible as enterprise development alternatives to the complex, sometimes proprietary and expensive EJB and, at times, problematic JSP. Therefore, Jini and XML should be a happy medium that can appease both sides. Enjoy."
"Once the shock of the event had passed, the implications for the work we at Pronoic Ltd. had been doing became evident. As I will go on to discuss, we had been very focussed on using Jini to build ultra-high avaliability applications for the insurance industry. Well, Sept. 11 killed the insurance sector, but brought the advantages of self-healing, distributed applications into clear focus. (For more on self-healing, distributed systems see the O'Reilly Network's interview with IBM's Robert Morris.)"
"In April 2000, I was asked to develop an enterprise, web-based Business to Business (b2b) exchange for the Facultative Reinsurance industry. Prior to this, I'd worked with many teams using Enterprise JavaBeans (EJB), CORBA, and JSP solutions, all of which had been found lacking in terms of development complexity and cost. I decided to deploy a Jini-based solution. I thought Jini, and JavaSpaces in particular, would provide a natural fit for a dynamic trading exchange. This turned out to be the case, while providing other benefits that only became apparent during the development process."
"So while the other approaches to service definition are being satisfied through agreed-upon XML schemas, Jini discovery and lookup provides a dynamic alternative to finding and interacting with B2B service providers. Jini itself could be used to bootstrap the process of finding UDDI and ebXML registries."
"The answer is Jini. Jini has service producers, service consumers, and a service registry. It provides the natural infrastructure to support Web services. When Jini came out, the architecture of our RMIEngine was so similar to Jini that it only took us six weeks to convert the RMIEngine modules into Jini services. When Web services came out, we immediately saw its similarity to Jini. We knew then and there that Jini should be the underlying infrastructure for Web services."
"In the first part of this series, I discussed the technologies underlying an application that could resist the impact of a 767. I called this system Corporate Operating System, or COS. The need for such systems has forced the emergence of many new layers in application development, above and beyond the traditional n-tier structure. We have the Java Virtual Machine layer as a substrata, followed by a Service Container layer, in parallel with a basic set of ensemble provisioning services, such as those provided by Rio. Above that you now have a couple of application layers."
"Editor's Note: Daniel Steinberg gave a presentation at the recent 10th Jini Community Meeting on Jini's aspirations, limitations, and perception. In "Beyond the Choir," he looked at the assumptions behind the perceptions and realities of successful technologies, and prodded the Jini community to start asking itself some new questions about where it wants to go and how to get there."
"For the technology to succeed, it needs a strong developer community: A strong community will give Jini technology the critical mass it needs to establish ubiquity while accelerating the development of innovative Jini services. Just as Jini's core strength lies in spontaneous assembly of distributed networks of clients and services. Sun hopes a core strength of the Jini community will be self assembly of developers and industry around mutually beneficial development projects. See Jini Technology in the Home and Enterprise for some examples of how this might work and benefit consumers as well as enterprises."
"In recent years, Jini technology has receded in public awareness, leaving in its wake lingering questions: What is the promise of Jini technology? How is it currently being used? Will Moore's law lead to the demise of distributed computing? And what is happening with the "networked home"?"
"This article gives you a glimpse of the Jini community in action and looks at what the serviceui project from Jini.org has proposed for a standard way to attach a user interface to a Jini service."
"Jini technology redefines the concept of a client. Instead of a fixed set of "local" devices, Jini technology supplies the Java client with a federation of remote "plug and play" devices in a dynamic configuration (the Jini Federation) that is personalized for each client. With Jini technology, the network truly becomes the client computer!"
"Learn the unique value of this new networking technology and what the visionary of Jini Technology Bill Joy had to say about it at the recent Jini Community Summit"
"The Overview page is the front page of this API document and provides a list of all packages with a summary for each. This page can also contain an overall description of the set of packages."
"Due to the number of requests, attached is the TimeService example converted to work with the latest Jini release. The alterations were simple package renaming, so all my comments from the original post (below) are still valid."
"The story of the four generals, inspired by Leslie Lamport's "Byzantine Generals," illustrates the kind of guarantees distributed transactions must promise, and the way participants in it might communicate. In this example, the generals and their armies are metaphors for distributed services, and carrying out their battle plan is analogous to a distributed computation. This scenario is known as the coordinated attack problem."
"However, a quiet revolution is changing all that, making high-availability systems a reality even for the smallest enterprises. This article describes a high-availability, scalable clustering technique using Jini technology. As a tool for dynamic networking, Jini technology found a niche as middleware in support of highly available and scalable enterprise systems that operate on clusters built on commodity hardware. The architecture presented in this article, and developed by Boomi Software, uses Jini technology in that manner, and forms the core of that company's system integration server product."
"The Jini lookup service, the central component of Jini's runtime infrastructure, offers Jini clients a flexible and powerful way to find Jini services. It enables service providers to advertise their services and enables clients to locate and enlist the help of those services."
"The intention is that secure JERI supports the constraint model that we have defined for remote calls. If you want a service that actually obeys this network security model, then you need something that is actually going to meet the requirements of these constraints. The easiest way to do that is to pick up a protocol stack that will do it for you. Secure JERI is an instance of a protocol stack that will do that for you."
"I want to again thank the Jini team for making time to discuss the Place API. It had been about one year since I first spent time in the bean bag room during the Service UI design review. It was great to see everyone in Burlington again. The visit was very stimulating and productive. I was asked a lot of hard questions which made me think and gave me ideas for further exploration. If this document has stimulated ideas or questions in your mind, please post them to the cyberspace@jini.org mailing list."
"Neat as this arrangement appears, the Jini federation cannot ensure a purely serial transaction execution. Doing so requires a central controller -- a transaction scheduler -- that tracks the beginnings and ends of transactions, causing others to wait to begin until a transaction executes all its steps. In addition, forcing serial transaction execution severely limits the network's ability to execute transactions on time -- the network's transaction throughput -- as most transactions are delayed. Transactions that don't execute sequentially can easily violate the consistency of shared data. To see how this could happen, we must first change our vantage point of what occurs inside a transaction."
"Rubean's service installation is based on Java WebStart. A user with a banking device connected to his PC visits a Web page, and invokes on that page a WebStart application. The application commences an installation wizard that interrogates the local PCs serial and parallel ports and tries to determine the kind of device connected to those ports. If a device does not support automated querying, the user is given an opportunity to enter configuration data. Next, the installation program installs an operating system service suitable for running RMI-based remote object services. That RMI daemon - RMID -- is part of the J2SE distribution, and Rubean's installer sets RMID up as an OS service."
"To access the source and binary files for Artima Software, Inc.'s implementation of the Jini Service UI API, which is now released under the Sun Community Source License (SCSL), you must visit the Jini ServiceUI API Download page at www.jini.org at the following URL:"
"Note that this is not a full specification of the net.jini.lookup.entry package. When the packages were chosen for the service UI API during the design review with the Jini architects, UIDescriptor was placed in an already-existing package in the Jini APIs. UIDescriptorBean was added in serviceUI version 1.1."
"Sean Neville: Certain situations do come to mind. Jini may make sense when you start doing wild things with JNDI. Jini may make sense if you find yourself doing a lot of static lookups, then storing the names that you looked up. The Jini lookup service is an option if you want to do something more dynamic in terms of JNDI lookup, which is fundamentally a static mechanism."
"The ServiceUI project at jini.org is attempting to define a recommended or standard way of attaching a user interface (UI) to a Jini service. In this month's Jiniology I give a short history of the ServiceUI project (a glimpse glimpse of the Jini community process in action) and present ServiceUI's current working proposal."
"A new computer is on the horizon, a meta-computer made of up every computer connected to every other computer. As embedded devices with high bandwidth network connections become increasingly common, this new meta-computer may gradually supplant the desktop PC as the primary computer people use. The coming change in the hardware status quo provides an opportunity to rethink the basic user-interface metaphors by which people use software. This Jini Place API proposes a simple "space metaphor" by which users could relate to and use the services offered by the emerging meta-computer."
"Jini's infrastructure is designed to actually encourage eliminating unreliable services. First, a service participates in the Jini federation based on a lease. The service's implementation must renew the lease periodically, or it will expire and no longer be advertised in lookup services. Even if a lease is kept current, a client might experience network or other communication problems with the service's implementation. A Jini client could eliminate such a service's proxy from its lookup cache. Further, it could record service implementations that often produce errors, and upon subsequent lookup, exclude them from future lookup requests."
"Audience: This course is designed for Java programmers who want to come up to speed on distributed computing with Java in general, and using mobile objects in distributed systems with RMI and Jini in particular."
"Modify your batch script once again, so that after RMID gets going, your batch script fires up the Jini lookup service. Before starting the lookup service, you'll want to remove its log files:"
"To access the source and binary files for Artima Software, Inc.'s implementation of the Jini Place API, Montage Browser, and BasicPlace service, which are now released under the Sun Community Source License (SCSL), you must visit the Jini Place API Download page at www.jini.org at the following URL:"
"The Overview page is the front page of this API document and provides a list of all packages with a summary for each. This page can also contain an overall description of the set of packages."
"You can download a zip file of the example code from the Jini lecture, which have been updated to work with the 1.0 Jini release that works with the JDK1.2FCS release. The zip file contains the following .java files along with their .class counterparts:"
"The serviceui project at jini.org is currently working to define a well-known way for UIs to be attached to services. To find out more, join the serviceui mailing list at:"
"BasicPlace is a concrete class that implements Place. Place is a Jini service interface that contains one method, getLinkMap(), which returns a LinkMap. BasicPlace's constructor merely accepts a LinkMap and uses it to initialize an instance variable named links. When BasicPlace's getLinkMap() method is invoked, it simply returns the links reference. Here's a UML diagram for BasicPlace:"
"A new computer is on the horizon, a meta-computer made of up every computer connected to every other computer. As embedded devices with high bandwidth network connections become increasingly common, this new meta-computer may gradually supplant the desktop PC as the primary computer people use. The coming change in the hardware status quo provides an opportunity to rethink the basic user-interface metaphors by which people use software. The Jini Place API proposes a simple "space metaphor" by which users could relate to and use the services offered by the emerging meta-computer."
"In the RuntimeInfa/ex2 directory, write a Jini chat client. The chat client will participate with other chat clients by reading and writing entries to a JavaSpace. While you are developing your chat client, you should make certain that you are actually using your own JavaSpace for testing, the one that is registered with "YOUR_NAME_HERE". (In the rest of the exercises, I'll call your "YOUR_NAME_HERE" space your "test space." If you end up messing inadvertently with someone else's JavaSpace, you will likely interfere with their work in ways that won't leave them very happy with you. Ultimately, once you get your program debugged, you can switch to using a shared JavaSpace and actually chat with others in the class through the shared space."
"The Jini surrogate project defines an architecture that allows devices that otherwise wouldn't be able to participate in a Jini network to do so. Most mobile and wireless devices fall into this category, specifically those used for PvC. It involves bridging the device and its environment with one object capable of interacting with the Jini network. To do this, an object (or surrogate) is created to act on behalf of the device. The device finds a surrogate host in its "native" network environment and registers with it, providing the surrogate host with either a JAR file or the location of a JAR file. The surrogate host instantiates a surrogate object, which is obtained from the JAR file. The surrogate object then becomes the device's representative on the Jini network."
"Waldo, chief architect for Jini technology, pointed out that even though Sun first began saying "The network is the computer" back in 1986, many people -- both inside and outside of Sun -- weren't quite sure what that meant. He reviewed the ISO seven layers and noted that there is agreement on the Network and Transport layers. IP is pervasive and plenty of people are making money on it, so he doesn't see IP going away."
""ObjectSpace is going to aggregate the Jini concept and make it available to all object models, not just Java." said J.P. Morgenthal, principal at NC.Focus, a network computing research firm in Hewlett, N.Y. "This is one of their key challenges, to dynamically bridge access to Jini services from CORBA and COM through their technology.""
"It's been a while since Sun Microsystems launched its technology for creating software to make devices work together as a "community". The kick-off for Jini was sufficient to put it at the heart of any discussion of the future of network software. It had its share of questionable concerns, but these were met with the assurance that time would provide solutions. Three years and counting, though, the question in the mind of developers today is: "Whatever happened to Jini?""
"There is a chicken-and-egg problem with the lookup service: clients use lookup to find Jini services, but how do they find the lookup service itself? The answer is through the discovery protocol. Discovery is implemented through multicast and unicast requests, as well as multicast announcements."
"Norris: Right now, since we're really implementing our own support for Jini, the experience that we've had with the Jini group has more to do with the specifications than actual code. We're running our own support for it. Our only issues have to do with the availability of the specification and the ability to get support from Sun."
"When two programs start communicating over a network there is the potential for problems. Jini does not hide the fact you are using distributed objects. All distributed objects at least throw the Remote exception. This means you have to explicitly handle failure conditions when trying to create and access remote objects. Also, all services are leased. Leasing means services are requested for a certain period of time. If a program needs more time, it can request to renew its lease. Leasing allows object to handle failures of remote objects more gracefully. For example a service provider can clean up after a lease expires. Also leases keep the Lookup service from getting stale. All entries in the Lookup service are leased, so as devices are unplugged from the network they eventually disappear from the Lookup service."
"We've heard the hype. We are struggling to absorb every last buzzword in the media. We've sat through all the high-level marketing. We've tried to envision the vision. Jini has definitely had its day in the Sun, but let's look at Jini from a practical perspective. Cut out all the vision, marketing, press, hype, and 'top of the head' stuff. Here, we'll give you an objective view of this subjective technology."
