`
`The Jini” Specification
`
` 1
`
`APPLE 1009
`
`APPLE 1009
`
`1
`
`

`

`The Jini” Technology Series
`Lisa Friendly, Series Editor
`Ken Arnold, Technical Editor
`For more information see: http:h’javasuncom/docsfbooksfjini/
`
`This series, written by those who design, implement, and document the J inf" technology,
`shows how to use, deploy, and create Jini applications. Jini technology aims to erase the
`hardware/software distinction, to foster spontaneous networking among devices, and to
`make pervasive a service-based architecture. In doing so, the Jini architecture is radically
`changing the way we think about computing. Books in The Jini Technology Series are
`aimed at serious developers looking for accurate, insightful, thorough, and practical
`material on Jim technology.
`
`The Jini Technology Series web site contains detailed information on the Series,
`including existing and upcoming titles, updates, errata, sour-ees, sample code, and
`other Series-related resources.
`
`Ken Arnold, Bryan O’ Sullivan, Robert W. Scheifler, Jim Waldo, Ann Wollralh. The Jim” Specification
`ISBN 0-201-61634—3
`
`Eric Freeman, Susanne Hupfct‘, and Ken Arnold, Javab'pac‘es""Principles. Patterns, and Practice
`ISBN 07201-309536
`
`
`
`2
`
`

`

`The Jini”‘ Specification
`
`(it)?!
`
`Ken Arnold
`
`Bryan O’Sullivan
`Robert W. Scheifler
`
`Jim Waldo
`
`Ann Wollrath
`
`LV
`
`7
`ADDISON-WESLEY
`
`An imprint of Addison Wesleyr Longman, Inc.
`Reading, Massachusetts - Harlow, England - Menlo Park California
`Berkeley, California ' Don Mills. Ontario - Sydney
`Bonn - Amsterdam - Tokyo - Mexico City
`
`
`
`3
`
`

`

`This book is dedicated to the J ini team
`
`without whom this book
`
`would not have been necessary
`
`
`
`4
`
`

`

`
`
`
`
`
`
`Contents
`
`Foreword .................................................. xvii
`
`Preface ..................................................... xix
`
`
`
`p A R T 1
`Overview and Examples
`
`
`The Jini Architecture: An Introduction .................. 3
`
`1
`
`Overview ................................................ 3
`1.1
`Goals .............................................. 4
`1.2
`Architecture ......................................... 5
`
`1.3
`1.4
`1.5
`
`What the Jini Architecture Depends Upon ................. 7
`The Value of a Proxy ..... I ............................. 7
`The Lookup Service ................................... 9
`l .5.1
`Attributes ................................. 10
`
`1.5.2
`1.5.3
`1.5.4
`
`Membership Management .................... 1 1
`Lookup Groups ............................. 12
`Lookup Service Compared to Naming/Directory
`Services .................................. 1 3
`
`2
`
`1.6
`
`Conclusion ......................................... 14'
`
`1.7
`
`Notes on the Example Code ............... , ........... 16
`1.7.1
`Package Structure ........................... 16
`Writing a Client ........................................ 19
`2.1
`The MessageStream Interface ......................... '19
`2.2
`The Client ......................................... 20
`2.3
`In Conclusion ....................................... 27
`
`vii
`
`
`
`5
`
`

`

`viii
`
`3
`
`Writing a Service ....................................... 29
`3.1
`Good Lookup Citizenship ............................. 29
`3.1.1
`The 301' nManager Utility .................... 30
`The FortuneStream Service .......................... 30
`
`3.2
`
`3.3
`
`The Implementation Design .................. 32
`3.2.1
`Creating the Service ......................... .32
`3.2.2
`The Running Service ........................ 34
`3.2.3
`The ChatSt ream Service ............................. 37
`3.3.1
`“Service” versus “Server” .................... 41
`
`3.3.2
`3.3.3
`
`3.3.4
`3.3.5
`3.3.6
`
`Creating the 8621vice ......................... 41
`The Chat Server ............................ 43
`
`Implementing nextInLi ne ................... 50
`Notes on Improving ChatServerImp'l .......... 51
`The Clients ................................ 52
`
`4
`
`The Rest of This Book .................................. 57
`
`
`
`P A R T 2
`The Jilli Specification
`
`
`AR The Jini Architecture Specification ..................... 61
`AR.1 Introduction ............................................ 61
`AR.1.1 Goals ofthe System ................................. 61
`AR.1.2 Environmental Assumptions ........................... 63
`AR.2 System Overview ....................................... 65
`AR.2.1 Key Concepts ...................................... 65
`AR.2.1.1 Services .................................. 65
`
`AR.2.1.2 Looknp Service ............................ 66
`AR.2.1v3 Java Remote Method Invocation (RMI) ......... 66
`AR.2.1.4 Security .................................. 67
`AR.2.1.S Leasing ................................... 67
`AR.2.1.6 Transactions ............................... 67
`AR.2.1.7 Events ................................... 67
`
`AR.2.2 Component Overview ................................ 68
`AR22.1
`Inf1astrueturc .............................. 69
`
`AR.2.2. 2 Programming Model ........................ 69
`AR.2.2. 3 Services .................................. 71
`AR.2.3 Service A1chiteeture ................................. 72
`
`AR.2.3.1 Discovery and Lookup Protocols .............. 72
`AR.2.3.2 Service Implementation ...................... 75
`AR.3 An Example ............................................ 77
`AR.3.1 Registering the Printer Service ......................... 77
`AR.3.1.1 Discovering the Lookup Service ............... 77
`
`
`
`6
`
`

`

`
`
`ix
`
`AR.3.I.2 Joining the Lookup Service ................... 77
`AR.3.I.3 Optional Configuration ....................... 78
`AR.3.I.4 Staying Alive .............................. 78
`AR.3.2 Printing ........................................... 78
`AR.3.2_'I Locate the Lookup Service .................... 78
`AR.3.2.2 Search for Printing Services ................... 79
`AR.3.2.3 Configuring the Printer ....................... 79
`AR.3.2.4 Requesting That. the Image Be Printed ........... 79
`AR.3.2.5 Registering for Notification ................... 80
`AR.3.2.6 Receiving Notification ....................... 80
`
`ARA For More Information .................................. 81
`
`DJ The Jini Discovery and Join Specification ............. 83
`
`DJ.1
`
`Introduction ............................................ 83
`DJ .1 .l Terminology ....................................... 83
`DJ. 1.2 Host Requirements .................................. 84
`DJ.1.2.1 Protocol Stack Requirements for IP Networks ..... 84
`Protocol Overview ................................... 85
`DJ. 1 .3
`DJ.I.4 Discoveryin Brief ................................... 85
`DJ'. 1.4. 1 Groups ................................... 85
`DJ. 1 .4 2 The Multicast Request Protocol ................ 86
`DJ .1 4.3 The Multicast Announcement Protocol .......... 87
`
`DJ .l .4.4 The Unicast Discovery Protocol ................ 88
`DJ. ] .5 Dependencies ....................................... 88
`
`DJ.2 The Discovery Protocols ................................ 89
`DJ.2.1
`Protocol Roles ...................................... 89
`
`DJ.2.2 The Multicnst Request Protocol ........................ 89
`DJ.2.2.1
`Protocol Participants ......................... 89
`DJ.2.2.2 The Multicast Request Service ................. 90
`DJ 2.2.3 Request Packet Format ....................... 91
`DJ.2.2.4 The Multicast Response Service ............... 93
`DJ.2.3 Discovery Using the Multicast Request Protocol ........... 93
`DJ.2.3.1
`Steps Taken by the Discovering Entity .......... 93
`DJ.2.3.2 Steps Taken by the Multieast Request Server ..... 94
`DJ.2.3.3 Handling Responses from Multiple Djinns ....... 95
`DJ.2.4 The Multicast Announcement Protocol ................... 95
`DJ.2.4.l The Multieast Announcement Service ........... 95
`DJ 2.4.2 The Protocol ............................... 97
`
`D125 Unieast Discovery ................................... 97
`DJ 2.5.1 The Protocoi ............................... 98
`DJ.2.5.2 Request; Format ............................. 99
`D1153 Response Format .......................... 100
`
`
`
`7
`
`

`

`
`
`DJ.3 The Join Protocol ..................................... 101
`DJ .3.1
`Persistent State .................................... 101
`D132 The Join Protocol .................................. 101
`
`Initial Discovery and Registration ............. 102
`DJ.3.2.1
`D1322 Lease Renewal and Handling of Communication
`Problems ................................ 102
`
`DJ.3.2.3 Making Changes and Performing Updates ...... 103
`DJ.3.2.4
`Joining or Leaving a Group .................. 103
`DJ.4 Network Issues ........................................ 105
`
`D1441
`
`Properties of the Underlying Transport ................. 105
`DJ .4.1.1 Limitations on Packet Sizes .................. 1.05
`
`DJ 4.2 Bridging Calls to the Discovery Request Service .......... 105
`
`D143 Limiting the Scope of Multicasts ...................... 106
`DJ 4.4 Using Multicast IP as the Underlying Transport .......... 106
`D145 Address and Port Mappings for TCP and Multicast UDP .
`.
`. 106
`
`DJ.5 LookupLocator Class .................................. 107
`DJ.5.1
`Jini Technology URL Syntax ......................... 108
`DJ .52 Serialized Form .................................... 109
`
`DU The Jini Discovery Utilities Specification ............. 111
`
`DU.1 Introduction ........................................... 111
`
`DU.1.1 Dependencies ..................................... l 11
`
`DU.2 Multicast Discovery Utility ............................ 113
`DU.2.1 The LookupD‘i scovery Class ......................... 114
`DU.2.2 Useful Constants ................................... 115
`
`DU.2.3 Changing the Set of Groups to Discover ................ l 15
`DU.2.4 The DiscoveryEvent Class .......................... 116
`DU.2.5 The Di 5coveryL1' stener’ Interface .................... 116
`
`DU.2.6 Security and Multicast Discovery ...................... 117
`DU.2.7 Serialized Forms ................................... l 18
`
`DU.3 Protocol Utilities ...................................... 119
`
`DU.3.1 Marshalling Multicast Requests ....................... 119
`DU.3.2 Unmarshalling Multicast Requests ..................... 120
`DU.3.3 Marshalling Multicast Announcements ................. 121
`DU.3.4 Unmarshalling Multicast Announcements ............... 122
`DU.3.5 Easy Access to Constants ............................ 122
`DU.3.6 Marshalling Unicast Discovery Requests ................ 123
`DU.3.7 Unmarshalling Unicast Discovery Requests .............. 123
`DU.3.S Marshalling Unicast Discovery Responses ............... 124-
`DU.3.9 Unmarshalling Unicast Discovery Responses ............ 124
`
`EN The
`
`EN;
`
`EU Th1
`
`EU.
`
`LE Th
`
`LE
`
`LE
`
`LI
`
`EV Tl
`
`E1
`
`El
`
`
`
`8
`
`

`

`xi
`
`EN The Jini Entry Specification ............................ 127
`
`EN.1 Entries and Templates ................................ 127
`EN.1.1 Operations ........................................ 127
`EN.1.2 Entry ............................................ 128
`EN.1.3 Serializing Entry Objects ............................ 128
`EN.1.4 Unusab'leEnt ryException .......................... 129
`EN.1.5 Templates and Matching ............................. 131.
`EN.1,6 Seriaiized Form .................................... 131
`
`EU The Jini Entry Utilities Specification .................. 133
`EU.l Entry Utilities ........................................ 133
`EU.1.1 AbstractEntry .................................... 133
`EU.1.2 Serialized Form .................................... 134
`
`LE The Jini Distributed Leasing Specification ........... 137
`LE.1 Introduction .......................................... 137
`LE.‘I .1 Leasing and Distributed Systems ...................... 137
`LE. 1 .2 Goals and Requirements ............................. 140
`LE.1.3 Dependencies .............................. . ....... 140
`LE.2 Basic Leasing Interfaces .............................. 141
`LE.2.1 Characteristics of a Lease ............................ 141
`LE.2.2 Basic Operations ................................... 142
`LE.2.3 Leasing and Time .................................. 147
`LE.2.4 Serialized Forms ................................... 148
`LE.3 Example Supporting Classes .......................... 149
`LE.3.1 A Renewal Class ................................... 149
`LE.3.2 A Renewal Service ................................. 151
`
`EV The Jini Distributed Event Specification .............. 155
`EV.1 Introduction .......................................... 155
`EV.l.1 Distributed Events and Notifications .................... 155
`EV.1.2 Goals and Requirements ............................. 156
`EV. l .3 Dependencies ...................................... 157
`EV.2 The Basic Interfaces .................................. 159
`8V2] Entities Involved ................................... 159
`EV.2.2 Overview of the Interfaces and Classes .................. 161
`EV.2.3 Details of the Interfaces and Classes .................... 163
`EV.2.3.1 The RemoteEventL‘i stener Interface .......... 163
`EV.2.3.2 The Remote-Event Class ..................... 164
`EV.2.3.3 The UnknownEventException ............... 165
`EV.2.3.4 An Example EventGenerator Interface ........ 166
`EV.2.3.5 The EventRegi stration Class .............. 168
`
`
`
`9
`
`

`

`EV.2.4 Sequence Numbers= Leasing and Transactions ............ 169
`EV.2 5 Serialired Forms ................................... 170
`EV.3 Third-Party Objects ................................... 171
`EV.3.1 Storeand-Forward Agents ........................... l7]
`EV.3.2 Notification Filters ................................. 173
`EV.3.2.1 Notification Multiplexing ................... 174
`EV.3.2.2 Notification Demultiplexing ................. 174
`EV.3.3 Notification Mailboxes .............................. 175
`EV34 Compositionality ................................... 176
`EV.4 Integration with JavaBeans Components .............. 179
`EV4.1 Differences with the JavaBeans Component Event Model
`.
`.
`ISO
`EV.4.2 Converting Distributed Events to JavaBeans Events ....... 182
`
`.‘X The Jini Transaction Specification .................... 185
`TX.1 Introduction ........................................... 185
`TX. 1.1 Model and Terms .................................. 186
`TX I2 Distributed Transactions and ACID Properties ........... 188
`TX.1.3 Requirements ..................................... 189
`TX] .4 Dependencies ..................................... 190
`TX.2 The Two-Phase Commit Protocol ..................... 191
`TX .21 Starting a Transaction ............................... 192
`TX.2.2 Starting a Nested Transaction ......................... I93
`TX.2.3 Joining 21 Transaction ............................... 195
`TX.2.4 Transaction States .................................. 196
`TX.2.5 Completing a Transaction: The Client’s View ............ 197
`TX.2.6 Completing 3 Transaction: A Participant’s View .......... 199
`TX.2.7 Completing 21 Transaction: The Manager’s View .......... 202
`TX.2.8 Crash Recovery .................................... 204
`TX.2.8.1 The Roll Decision ......................... 205
`TX.2.9 Durability ........................................ 205
`TX.3 Default Transaction Semantics ........................ 207
`TX.3.1 Transaction and Nestab1 eTransacti on Interfaces ...... 207
`TX.3.2 Transacti onFactory Class ......................... 209
`TX.3.3 ServerTransact‘i on and NestableServerTransact-‘ion
`Classes .......................................... 210
`TX.3.4 CannotNestExcept‘ion Class ........................ 212
`TX.3.5 Semantics ........................................ 212
`TX.3.6 Serialized Forms ................................... 214
`
`LU The Jini Lookup Service Specification ................ 217
`LU.1 Introduction ........................................... 217
`LU.] .1 The Lookup Service Model .......................... 217
`LU.1.2 Attributes ........................................ 218
`
`LU.2
`
`LS The
`
`IJSQI
`
`LS2
`
`LS.3
`
`IJSI‘
`
`JS Tl
`
`JS
`
`
`
`10
`
`10
`
`

`

`
`
`l
`
`
`
`xiii
`
`LU.2
`
`LU.l .3 Dependencies ...................................... 219
`
`The ServiceRegistrar' ............................... 221
`LU.2.1
`Se r‘V'i ceID ........................................ 22]
`LU.2.2 Servi ceItem ..................................... 222
`
`LU.2.3 Se rvi ceTempl ate and Item Matching .................. 223
`LU.2.4 Othcr Supporting Types .............................. 224
`LU.2.5 Se rvi ceReg‘i st rar ................................. 225
`LU.2.6 ServiceRegi stration ............................. 229
`LU.2.7 Serialized Forms ................................... 230
`
`. 233
`LS The Jini Lookup Attribute Schema Specification .. .
`LS.1 Introduction........................................... 233
`LS.l.l Terminology ...................................... 234
`1.8.1.2 Design Issues ...................................... 234
`LS.1.3 Dependencies ...................................... 235
`L82 Human Access to Attributes .......................... 237
`
`L821 Providing a Single View of an Attributc’s Value .......... 237
`LS.3 JavaBeans Components and Design Patterns ......... 239
`1.8.3.1 Allowing Display and Modification of Attributes .......... 239
`LS.3.1.1 Using Javchans Components with Entry Classes
`239
`LS.3.2 Associating JavaBeans Components with Entry Classes
`.
`.
`.
`. 240
`LS.3.3 Supporting Interfaces and Classes ...................... 241
`LS.4 Generic Attribute Classes ............................. 243
`
`Indicating User Modifiability ......................... 243
`1.8.4.1
`L342 BaSic Service Information ............................ 243
`
`1.5.4.3 More Specific Information ........................... 245
`L544 Naming a Service ................................... 246
`L545 Adding a Comment to a Service ....................... 246
`LS.4.6 Physical Location .................................. 247
`1.3.4.7 Status Information .................................. 248
`LS.4.8 Serialized Forms ................................... 249
`
`JS The JavaSpaces Specification ........................... 253
`
`J 5.1
`
`Introduction ........................................... 253
`15.1.1
`The JavaSpaces Application Model and Terms ........... 2S3
`JS.1.] .1 Distributed Persistence ...................... 254
`
`18.] .l .2 Distributed Algorithms as Flows of Objects ..... 254
`JS.1.2 Benefits .......................................... 256
`
`JavaSpaccs Technology and Databases .................. 257
`18.1.3
`JavaSpaces System Design and Linda Systems ........... 258
`13.1.4
`18.1.5 Goals and Requirements ............................. 259
`13.1.6 Dependencies ...................................... 260
`
`
`
`11
`
`11
`
`

`

`
`
`
`xiv
`
`J82 Operations ............................................ 261
`18.2.1
`Entries ........................................... 261
`18.2.2
`net.j1'n'i .5pace.]avaSpace ........................ 262
`15.2.2.1
`Internal SpaceException ................. 263
`.1523 write ........................................... 264
`13.2.4
`readIfExi 51:5 and read ............................ 264
`JS.2.5
`takeIfExists and take ............................ 265
`JS.2.6
`snapshot ........................................ 265
`18.2.7 notify .......................................... 266
`18.2.8 Operation Ordering ................................. 268
`13.2.9
`Serialized Form .................................... 268
`JS.3 Transactions .......................................... 269
`18.3.1 Operations under Transactions ........................ 269
`15.3.2 Transactions and ACID Properties ..................... 270
`JS.4 Further Reading ...................................... 273
`JS.4.1
`Linda Systems ..................................... 273
`18.4.2 The Java Platform .................................. 273
`15.4.3 Distributed Computing .............................. 274
`
`DA The Jini Device Architecture Specification ........... 277
`DAJ Introduction .................................... . ...... 277
`DA. 1 .1 Requirements from the Jini Lookup Service ............. 278
`DA.2 Basic Device Architecture Examples ................... 281
`DA.2.1 Devices with Resident Java Virtual Machines ............ 28]
`DA.2.2 Devices Using Specialized Virtual Machines ............. 283
`DA.2.3 Clustering Devices with a Shared Virtual Machine
`(Physical Option) .................................. 284
`DA.2.4 Clustering Devices with a Shared Virtual Machine
`(Network Option) .................................. 286
`DA.2.5 Jini Software Services over the Internet Inter-Operability
`Protocol .......................................... 288
`
`
`
`P A R T 3
`Supplemental Material
`
`
`The Jini Technology Glossary .............................. 293
`
`Appendix A: A Note on Distributed Computing ......... 307
`A.1
`Introduction ........................................... 307
`All
`Terminology ...................................... 308
`
`
`
`12
`
`12
`
`

`

`
`
`XV
`
`The Vision of Unified Objects ......................... 308
`A.2
`A.3 Déja Vu All Over Again .............................. 311
`AA Local and Distributed Computing .................... 312
`A.4.l
`Latency .......................................... 312
`A.4.2 Memory Access .................................... 314
`Partial Failure and Concurrency ..................... 316
`A.5
`The Myth of “Quality of Service” ..................... 318
`A.6
`Lessons From NF S .................................... 320
`AJ
`Taking the Difference Seriously ....................... 322
`A.8
`A Middle Ground ..................................... 324
`A.9
`A.10 References ............................................ 325
`A.11 Observations for this Reprinting ...................... 326
`
`Appendix B: The Example Code ........................... 327
`
`Index ............................................................ 371
`
`Colophon ....................................................... 385
`
`
`
`13
`
`13
`
`

`

`
`Foreword
`
`THE emergence of the Internet has led computing into a new era. It is no longer
`What your computer can do that matters. Instead, your computer can have access
`to the power of everything that is connected to the network: The Network is the
`Computer”. This network of devices and services is the computing environment
`of the future.
`The JavaTM programming language brought reliable obj cot—oriented programs
`to the net. The power of the Java platform is its simplicity, which allows program-
`mers to be fully fluent in the language. This simplicity allows debugged Java pro-
`grams to be written in about a quarter the time it takes to write programs in C++.
`We believe that use of the Java platform is the key to the emergence of a “best
`practices” discipline in software construction to give us the reliability we need in
`our software systems as they become more and more widely used.
`The JiniTM architecture is designed to bring reliability and simplicity to the
`construction of networked devices and services. The philosophy behind Jini is lan—
`guageebased systems: a Jini system is a collection of interacting Java programs,
`and you can understand the behavior of this Jini system completely by under—
`standing the semantics of the Java programming language and the nature of the
`network, namely that networks have limited bandwidth, inherent latency, and par-
`tial failure.
`
`Because the Jini architecture focuses on a few simple principles, we can teach
`Java language programmers the full power of the Jini technology in a few days. To
`do this, we introduce remote objects (they just throw a RemoteException), leas-
`ing (commitments in a Jini system are of limited duration), distributed events (in
`the network events aren’t as predictable on a single machine), and the need for
`two-phase commit (because the network is a world of partial failures). This small
`set of additional concepts allows distributed applications to be written, and we can
`illustrate this with the JavaSpacesm service, which is also specified here.
`For me, the Jini architecture represents the results of almost 20 years of yearn-
`ing for a new substrate for distributed computing. Ever since I shipped the first
`
`xvii
`
`
`
`14
`
`14
`
`

`

`
`
`FOREWORD
`
`widely used implementation of TCPflP with the Berkeley UNIX system, I have
`wanted to raise the level of discourse on the network from the bits and bytes of
`TCPHP to the level of objects. Objects have the enormous advantage of combining
`the data with the code, greatly improving the reliability and integrity of systems.
`For me, the Jini architecture represents the culmination of this dream.
`I would like to thank the entire Jini team for their continuing hard work and
`commitment.
`I would especially like to thank my longtime collaborator Mike
`Clary for helping to get the Jim project started and for directing the project; the
`Jini architects Jim Waldo, Ken Arnold, Bob Scheiffler, and Ann Wollrath for
`designing and implementing such a simple and elegant system; Mark Hodapp for
`his excellent engineering management; and Samir Mitra for committing early to
`the Jini project, helping us understand how to explain it and what problems it
`would solve, and for driving the key business development that helped give Iini
`technology the momentum it has in the marketplace today. I would also like to
`thank Mark Tolliver, the head of the Consumer and Embedded Division, which
`the Jini project became part of, for his support.
`Finally, I would like to thank Scott McNealy, with me a founder of Sun
`Microsystemsm, Inc, and its longtime CEO. It
`is his continuing support for
`breakthrough technologies such as Java and J ini that makes them possible. As
`Machiavelli noted, it is hard to introduce new ideas, and support like Scott’s is
`essential to our continuing success.
`
`BILL JOY
`
`ASPEN, COLORADO
`APRIL, 1999
`
`THE Jini .
`Networks a
`
`existing thi
`are therefot
`
`tiple procet
`These
`
`changes all
`A distribut
`
`change. Tl”
`This b
`
`architectur
`
`following '
`first sectio
`
`cal manag
`The st
`
`you withir
`Of them a:
`tem. As v-
`can start 3,
`The s
`
`specificat'
`ture.
`The t
`
`defines I:
`
`design, at
`
`
`
`15
`
`15
`
`

`

`
`
`
`
`Preface
`
`Perfection is reached, not when there is no longer anything to add,
`but when there is no longer anything to take away
`7Antoine de Saint~Exupery
`
`THE Jini architecture is designed for deploying and using services in a network.
`Networks are by nature dynamic: new things are added, old things are removed,
`existing things are changed, and parts of the network fail and are repaired. There
`are therefore problems unlike any that will appear in a single process or even mul-
`tiple processes in a single machine.
`These differences require an approach that takes them into account, makes
`changes apparent, and ailows older parts to work with newer parts that are added.
`A distributed system must adapt as the network changes since the network Will!
`Change The Jm1 architecture13 designed to be adaptable
`This book contains three parts. The first part gives an overview of the Jini
`architecture, its design philosophy, and its application. This overview sets up the
`following sections, which contain examples of programming in a Iini system. The
`first section of the introduction is also usable as a high-level overview for techni-
`cal managers.
`The sections of the introduction that contain examples are designed to orient
`you within the Jini technology and architecture. They are not a full tutorial: Think
`of them as a tour through the process of design and implementation in a Jini sys-
`tem. As with any tour, you can get the flavor of how things work and where you
`can start your own investigation.
`The second part of the book is the specification itself. Each chapter of the
`specification has a brief introduction describing its place in the overall architec—
`ture.
`
`The third part of the book contains supplementary material: a glossary that
`defines terms used in the specifications and in talking about Jini architecture,
`design, and technology, and two appendices. Appendix A is a reprint of “A Note
`
`xix
`
`
`
`16
`
`16
`
`

`

`PREFACE
`
`on Distributed Computing,” which describes critical differences between local and
`remote programming. Appendix B contains the full source code for the examples
`in the introductory material.
`
`HISTORY
`
`The Jini architecture is the result of a rather extraordinary string of events. But
`then almost everything is. The capriciousness of lifeeand to the fortunate, its
`occasional serendipity—As always extraordinary. It is only in retrospect that we
`examine the causes and antecedents of something interesting and decide that,
`because they shaped that interesting result, we will call them “extraordinary.”
`Other events, however remarkable, go unremarked because they are unexamined.
`Those of us who wrote the Jini architecture, along with the many who contributed
`to its growth, are lucky to have a reason to examine our particular history to notice
`its pleasures.
`This is not the proper place for a long history of. the project, but it seems
`apprOpriatc to give a brief summary of the highlights. The project had its origins
`in Sun Microsystems Laboratories, where Jim Waldo ran the Large Scale Distri-
`bution research project. Jim Waldo and Ken Arnold had previously been involved
`with the Object Management Group’s first CORBA specification while working
`for Hewlett~Packard. Jim brought that experience and a longstenn background in
`distributed computing with him to Sun Labs.
`Soon after joining the Labs, Jim made Ann Wollrath part of the team. Soon
`after, observations about many common approaches in the field of distributed
`computing led Jim, Ann, and the other authors to write “A Note on Distributed
`Computing,” which outlined core distinctions between local and distributed
`design. Many people had been trying to hide those differences under the general
`rubric of “local/remote transparency.” The “Note” argued that this was not possi-
`ble. It has become the most cited Sun Laboratories technical report, and the les-
`sons it distills are at the core of the design approach taken by the project.
`At this time the project was using Modula 3 Network Objects for experiments
`in distributed computing. As Modula 3 ceased to be developed, the team looked
`around for a replacement language. At that time Oak, the language an internal Sun
`project, seemed a viable replacement with some interesting new properties. To a
`research project, the fact that Oak was commercially insignificant was irrelevant.
`It was at this time that Ken rejoined Jim on his new team.
`Soon after, Oak was renamed “Java.”
`
`When it was still Oak, it once had a remote method invocation mechanism,
`but that was removed when the mechanism failed—it, too, had fallen into the
`locallremote transparency trap. When Bill Joy and James Gosling wanted to cre-
`ate a working distributed computing mechanism, they asked Jim to lead the effort,
`
`PREFACE
`
`which swi
`As the firs
`
`an explore
`uted corn]
`
`rral appro
`After
`
`its horizo
`name “lit
`
`a separat:
`was soon
`
`rience frc
`architectr
`As [1".
`
`the archi
`
`lookup d
`time to g
`and run
`Brian M‘
`tecture t
`
`impleme
`Adrian (
`Charlie ‘.
`nies. sta
`team to
`
`ducdon
`
`to worki
`over the
`structun
`Our
`
`dart Dal
`
`Emily 5
`Roman:
`
`Hurley
`Marksj
`ness
`:1
`McNer
`
`Vasquc
`the Jini
`
`1
`
`Jini
`It is
`
`
`
`17
`
`17
`
`

`

`PREFACE
`
`xxi
`
`which switched our team from the laboratories into the J avaSoft product group.
`As the first result of this effort, Ann, as the Java RMI architect, steered the team on
`
`an exploration of what could be done with a language—centric approach to distrib-
`uted computing (most distributed computing systems are built on language—neu—
`tral approaches).
`After RN11 became part of the Java platform, Bill Joy asked the team to expand
`its horizons to include a platform for easier distributed computing, coining the
`name “Jini."l He convinced Sun management to put the RM[ and Jini project into
`a separate unit. This new unit started with Jim, Ann, Ken, and Peter Jones, and
`was soon joined by Bob Scheiffler who had extensive distributed computing expe—
`rience from the X Windows project that he ran. This put together the original core
`architectural team: Jim, Ann, Ken, and Bob.
`
`As the team greW, many people had a hand in the direction of various parts of
`the architecture, including Bryan O’Sullivan who took over the design of the
`lookup discovery protocol. Mike Clary took the project under his wing to give it
`time to grow. Mark Hodapp joined the team to manage its software development
`and run it in partnership with its technical leadership. Gary Holness, Zane Pan,
`Brian Murphy, John McClain, and Bob Resendes all reviewed the primary archi-
`tecture documents and had responsibility for various parts of the tool design,
`implementation design, and the implementations themselves. Laird Dornin and
`Adrian Colley joined the RMI sub-team to continue and expand its development.
`Charlie Lamb joined the architectural team to oversee work with outside compa—
`nies, starting with printing and storage service standards. Jen McGinn joined the
`team to document what we had done, later with the help of Susan Snyder on pro-
`duction support. Jimmy Torres started out as our release engineer and has changed
`to working on helping build our public developer community. Frank Barnaby took
`over the release engineering duties. Helen Leary joined early and