(12) United States Patent
`Pinera et al.
`
`(10) Patent No.:
`(45) Date of Patent:
`
`US 7,171,661 B1
`Jan. 30, 2007
`
`US007 171661B1
`
`(54) REALTIME CONFIGURATION UPDATES
`AND SOFTWARE DISTRIBUTION TO
`ACTIVE CLIENT POSITIONS
`(75) Inventors: Carlos V. Pinera, Boca Raton, FL
`(US); Paul G. Ringhof, Boca Raton,
`FL (US); Jeff Slutzky, Lake Worth, FL
`(US)
`
`(73) Assignee: International Business Machines
`Corporation, Armonk, NY (US)
`
`(*) Notice:
`
`Subject to any disclaimer, the term of this
`patent is extended or adjusted under 35
`U.S.C. 154(b) by 311 days.
`
`(21) Appl. No.: 09/691.968
`y x- - -
`9
`Oct. 19, 2000
`
`(22) Filed:
`(51) Int. Cl.
`(2006.01)
`G06F 9/44
`(2006.01)
`G06F 5/16
`(52) U.S. Cl. ....................... 717/172; 709/202; 709/203
`(58) Field of Classification Search ................ 717/172,
`717/171, 173, 176 178; 709/203, 217, 219
`See application file for complete search history.
`References Cited
`U.S. PATENT DOCUMENTS
`
`(56)
`
`5/1998 Cole et al. .................. 717/173
`5,752,042 A *
`5,920,725 A * 7/1999 Ma et al. .................... 717/171
`5,960.204 A * 9/1999 Yinger et al. ............... 717/176
`6,029, 196 A
`2/2000 Lenz .......................... TO9,221
`6,074,434. A
`6/2000 Cole et al. .................. 717/173
`6,123,737 A
`9/2000 Sadowsky ...
`... T17.11
`6,151,643 A * 1 1/2000 Cheng et al. ...
`... 710,36
`6,167,567 A * 12/2000 Chiles et al. ............... 717/173
`6,202,207 B1
`3/2001 Donohue .................... 717/173
`
`6,301.710 B1* 10/2001 Fujiwara ..................... 717/175
`6,314,088 B1 * 1 1/2001 Yamano ....
`... 370,254
`6,408,434 B1* 6/2002 Fujiwara ..................... 717/170
`FOREIGN PATENT DOCUMENTS
`0809183
`11, 1997
`O969359
`1, 2000
`04-175952
`6, 1992
`08-095760
`4f1996
`OTHER PUBLICATIONS
`
`EP
`EP
`JP
`JP
`
`“JNDI Java Naming & Directory InterfaceTM,” Jan. 1998, JavaSoft,
`pp. 1-2.*
`V. Ryan, et al., “Schema for Representing JavaTM Objects in an
`LDAP Directory.” Oct. 1999, Sun Microsystems, Inc., RFC 2713,
`pp. 1-21.*
`Andrew S. Tanenbaum, “Computer Networks.” 1996, Prentice Hall
`PTR, 3 ed., pp. iii., iv. 36-37, 542.*
`* cited by examiner
`Primary Examiner Tuan Dam
`Assistant Examiner Eric B. Kiss
`(74) Attorney, Agent, or Firm—Akerman Senterfitt
`
`ABSTRACT
`(57)
`A system for updating active client positions can include a
`platform for managing active application components; a
`configuration server for storing updates; and, a configuration
`client for receiving updates from the configuration server
`and communicating the received updates to the platform.
`The platform can receive the updates from the configuration
`client. Subsequently, the platform can terminate selected
`ones of the active application components. Then, the plat
`form can apply the received updates to the terminated
`application components. Finally, the platform can reload the
`updated application components.
`
`27 Claims, 4 Drawing Sheets
`
`
`
`
`
`
`
`
`
`
`
`
`
`207
`
`Client Position
`
`
`
`
`
`A Configuration
`Client
`
`Application
`Component n
`
`Application
`Component 2
`
`Application
`Component 1
`
`Loader
`
`Instacart, Ex. 1011
`
`1
`
`

`

`U.S. Patent
`U.S. Patent
`
`Jan. 30, 2007
`Jan. 30, 2007
`
`Sheet 1 of 4
`Sheet 1 of 4
`
`US 7,171,661 B1
`US 7,171,661 B1
`
`
`
`
`
`2
`
`

`

`U.S. Patent
`
`Jan. 30, 2007
`
`Sheet 2 of 4
`
`US 7,171,661 B1
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`Z '50IH
`
`
`
`3
`
`

`

`U.S. Patent
`
`Jan. 30, 2007
`
`Sheet 3 of 4
`
`US 7,171,661 B1
`
`301
`
`
`
`306
`
`302
`Configuration
`
`303
`
`304
`
`305A
`App
`
`305B
`App
`
`305C
`App
`
`instantiate
`
`
`
`312
`
`Instantiate all
`aggregated classes
`such as the Loader
`
`34
`
`D addConfiglistener(String)
`D getConfig(String)
`
`316
`
`O
`
`
`
`
`
`
`
`
`
`
`
`inquiry-ge client types 322
`
`induiry= et client data 324
`
`inquiry-get client 2 data 328
`
`serializeNE 326
`
`serialize NE 2330
`
`serialize NEn 334
`
`enumeration returned 338
`
`FIG 3A
`
`4
`
`

`

`U.S. Patent
`
`Jan. 30, 2007
`
`Sheet 4 of 4
`
`US 7,171,661 B1
`
`301
`
`306
`Bootstrap
`
`
`
`302
`Configuration
`
`303
`Platform
`
`304
`Loader
`
`30SA
`305B
`305C
`Ap Ap App
`
`
`
`For each class name
`contained in the
`configuration data,
`the following
`sequences occur.
`
`load(Platfornterface) 340
`
`
`
`
`
`create 348
`
`
`
`setup(reference to Platform) 350
`
`getInstance() 354
`
`
`
`O
`
`
`
`register(EnumCmdDescriptor, EnumDataDescriptor) 360
`
`startO 36
`subscribe(EnumDataSubscription) 364
`pass 2 initialization 366
`
`activateO 368
`
`
`
`FIG. 3B
`
`5
`
`

`

`US 7,171,661 B1
`
`1.
`REALTIME CONFIGURATION UPDATES
`AND SOFTWARE DISTRIBUTION TO
`ACTIVE CLIENT POSITIONS
`
`CROSS REFERENCE TO RELATED
`APPLICATIONS
`
`(Not Applicable)
`
`STATEMENT REGARDING FEDERALLY
`SPONSORED RESEARCH OR DEVELOPMENT
`
`10
`
`(Not Applicable)
`
`BACKGROUND OF THE INVENTION
`
`15
`
`1. Technical Field
`The present invention relates to the field of client server
`applications and the distribution of application updates.
`More particularly, the instant invention relates to a method
`and apparatus for distributing application updates while a
`host platform for the application is still active.
`2. Description of the Related Art
`In typical computing environments, there is often a need
`to provide an automated method for distributing software
`from a server to one or more client applications. Computing
`environments are typically composed of one or more servers
`which provide localized or specialized services to one or
`more clients. These distributed environments result in infor
`mation being spread across various heterogenous data
`stores. One of the consequences of having information
`spread across heterogeneous data stores is that data can
`easily be duplicated. However, spurious duplication often
`results in inconsistent updating.
`Various methods have been employed to provide an
`efficient solution for performing operations on data in a
`distributed computed environment. In particular, operations
`can include, locating, adding, deleting, and modifying the
`data. One Solution involves utilizing a directory service
`acting as a central repository for storing all data within an
`environment. In this solution, the directory service is the
`single point from which the data contained therein is
`manipulated.
`The use of a directory service for storing and accessing
`data in a distributed environment can be advantageous in
`several respects. A directory service provides a single central
`resource for managing resources that may be localized as in
`a local area network (LAN), or distributed as in a wide area
`network (WAN). Additionally, since there is only a single
`central repository, resources within the environment can be
`replicated to ensure peak performance and also for redun
`dancy purposes.
`Since the directory service defines a single format for
`storing data, other applications having disparate storage
`formats can, through a single interface, communicate with
`the directory service. Since the single open format allows
`interoperability among various vendors, applications from
`other vendors can easily be shared with the directory service.
`Moreover, the single format is flexible enough that it can
`easily be extended to permit future growth that might occur
`as a result of technical advances or simply due to a need to
`scale the size of the operating environment.
`Given these advantages, several directory service tech
`nologies have been created to access data stores. Among
`these methodologies is a Lightweight Directory Access
`Protocol (LDAP). LDAP defines a model for storing entries
`in a directory service and a method for accessing these
`
`25
`
`30
`
`35
`
`40
`
`45
`
`50
`
`55
`
`60
`
`65
`
`2
`entries in a directory service. LDAP provides access to the
`directory service through the use of a TCP/IP connection.
`The data stored in a directory service can include, but is not
`limited to, user information, application updates and con
`figuration information.
`An entry is the basic data unit entity in the LDAP
`technology. An entry is an object that contains persistent
`information about a specific resource. Each entry has a
`unique identifier referred to as a distinguished name (DN),
`and belongs to a directory information tree (DIT). Each
`entry of the LDAP is composed of a collection of attributes
`with each attribute defining some specific characteristic of
`the entry. Each attribute is associated with a specific value
`type.
`Many attempts have been made to automate the distribu
`tion of software in the client-server environment. However,
`present solutions lack the capability to perform realtime
`application updates and Software distribution to active appli
`cations without having to reboot the Supporting platform.
`Additionally, present automated Software distribution sys
`tems do not support realtime updates of configuration data
`without first shutting down all active applications and Sub
`sequently rebooting the platform. Thus, there exists a need
`for efficiently distributing application updates and configu
`ration to a host platform while the host platform is still
`actively running other applications.
`
`SUMMARY OF THE INVENTION
`
`The present invention is a system, method and apparatus
`for distributing realtime updates to active application com
`ponents in an active client position. A method in accordance
`with the present invention can include establishing a first
`communications connection between a platform managing
`the active application components and a configuration client;
`establishing a second communications connection between
`the configuration client and a configuration server, and,
`delivering updates to the configuration client over the sec
`ond communications connection. Notably, each update can
`correspond to at least one particular application component.
`Subsequently, the platform can be notified that updates
`have become available. Responsive to receiving Such a
`notification, the execution of the particular active applica
`tion components can be terminated. Following termination,
`each update can be delivered over the first communications
`connection to the platform, and each update can be applied
`to the particular application components. Finally, each
`updated application component can be re-executed.
`In one aspect of the present invention, the termination step
`can include identifying the particular corresponding appli
`cation component to be updated based on the notification;
`terminating instances of each identified application compo
`nent; and, removing interdependencies between the termi
`nated application component instances and other application
`components. Additionally, the re-executing step can include
`instantiating each updated application component; and ini
`tializing each updated application component instance.
`Moreover, the initializing step can include communicating
`configuration information to the configuration client; and
`reinitializing state information internal to each updated
`application component based on the configuration informa
`tion. Finally, the method can further include requesting from
`the configuration client update notifications, the update
`notifications notifying the platform of application compo
`nent updates as the updates become available in the con
`figuration server.
`
`6
`
`

`

`3
`In another aspect of the present invention, the method can
`further include transmitting update notifications over the
`second communications connection to the configuration
`client. In particular, the update notifications can notify the
`configuration client of application component updates as the
`updates become available in the configuration server. Addi
`tionally, the step of transmitting update notifications over the
`second connection can include packetizing the update noti
`fications according to the User Datagram Protocol (UDP);
`and transmitting the UDP packets to the configuration client.
`That is, update notifications can be packetized into data
`grams that can be conveyed from the configuration server to
`the configuration client. Finally, in yet another aspect of the
`present invention, the configuration server can be an LDAP
`server. Accordingly, the method can include storing the
`15
`application component updates in an LDAP-based database
`in the LDAP server.
`In yet another aspect of the method of the invention, a
`method for distributing realtime updates to active applica
`tion components executing in an active client position can
`include first receiving updates to the active application
`components from a communicatively linked configuration
`client, wherein each update corresponds to at least one
`particular application component. Second, execution of each
`particular active application component having a received
`corresponding update can be terminated. Third, the received
`updates can be applied to the corresponding application
`components. Finally, the updated application components
`can be re-executed.
`The terminating step can include terminating instances of
`each particular active application component having a
`received corresponding update; and removing interdepen
`dencies between the terminated application component
`instances and other application components. The re-execut
`35
`ing step can include instantiating each updated application
`component; and initializing each updated application com
`ponent instance. Finally, the method also can include Sub
`scribing to update notifications from the configuration client,
`wherein the update notifications notify the active client
`position of application component updates as the updates
`become available.
`A system for updating active client positions can include
`a platform for managing active application components; a
`configuration server for storing updates; and, a configuration
`client for receiving updates from the configuration server
`and communicating the received updates to the platform.
`The platform can receive the updates from the configuration
`client. Subsequently, the platform can terminate selected
`ones of the active application components. Then, the plat
`form can apply the received updates to the terminated
`application components. Finally, the platform can reload the
`updated application components.
`In one aspect of the present invention, the configuration
`server can be an LDAP server. In another aspect of the
`present invention, the active application components can be
`instances of JAVA programming language classes (hence
`forth Java classes) classes. In yet another aspect of the
`present invention, the configuration client can include a
`notifier object and a listener interface. In consequence, the
`active application components can be configured to receive
`update notifications from the configuration client through
`the listener interface. Similarly, the configuration server also
`can include a notifier object and a listener interface. Like
`wise, the configuration client can be configured to receive
`update notifications from the configuration server through
`the listener interface.
`
`25
`
`30
`
`40
`
`45
`
`50
`
`55
`
`60
`
`65
`
`US 7,171,661 B1
`
`10
`
`4
`BRIEF DESCRIPTION OF THE DRAWINGS
`
`There are presently shown in the drawings embodiments
`which are presently preferred, it being understood, however,
`that the invention is not so limited to the precise arrange
`ments and instrumentalities shown, wherein:
`FIG. 1 is a high-level schematic illustrating a system for
`performing realtime configuration updates and software
`distribution to active client positions.
`FIG. 2 is a network architecture diagram for use in the
`system of FIG. 1; and
`FIGS. 3A and 3B, taken together, are a UML sequence
`diagram illustrating a process for performing realtime con
`figuration updates and Software distribution to active client
`positions in the system illustrated in FIG. 2.
`
`DETAILED DESCRIPTION OF THE
`INVENTION
`
`The present invention is a system for performing realtime
`configuration updates and software distribution to active
`client positions in a client-server environment. In particular,
`the system of the present invention can distribute software
`and configuration data to client positions without having to
`reboot each client position. FIG. 1 illustrates a network
`architecture configured for use with the system of the
`invention. As shown in FIG. 1, the system for performing
`realtime configuration updates and Software distribution to
`active client positions can include a configuration server
`105, a computer communications network 115, and a plu
`rality of client positions 110A, 110B, 110C connected to the
`configuration server 105 through the computer communica
`tions network 115.
`As each client position 110A, 110B, 110C undergoes
`bootstrap, a communications link can be established
`between the configuration server 105 and the client positions
`110A, 110B, 110C. Subsequently, each booted client posi
`tion 110A, 110B, 110C can query the configuration server
`105 to identify the application components which are to be
`installed in the client position 110A, 110B, 110C. Upon
`identifying the application components, each client position
`110A, 110B, 110C can install the identified application
`components.
`Significantly, upon initialization each application compo
`nent can request that the application component be notified
`of any future updates. When updates become available at the
`configuration server 105, messages can be broadcast to the
`client positions 110A, 110B, 110C notifying the positions of
`the update. In response, a communications link again can be
`established between affected client positions 110A, 110B,
`110C. Subsequently, the updates, including configuration
`data and updated modules, can be retrieved through the
`communications link. Following retrieval, the application
`components to which the updates are to be applied can be
`terminated, updated and re-loaded. Notably, once re-loaded,
`the application components will have incorporated the
`updates. Hence, the system of the present invention can
`perform realtime application updates of application compo
`nents in active client positions.
`FIG. 2 depicts the interaction between a configuration
`server 201 and a single client position 207 through a network
`206. The network 206 can be a LAN, WAN a data bus, or
`other suitable medium for communicatively linking distrib
`uted processes. As shown in the figure, the single client
`position 207 can include a configuration client 202, at least
`one application component 205, an application platform 203
`for managing the application components 205, and an appli
`
`7
`
`

`

`US 7,171,661 B1
`
`10
`
`15
`
`5
`cation loader 204 for loading and unloading the application
`components 205. Still, the invention is not limited in this
`regard and the configuration client 202 can be included as an
`application component external to the client position 207 in
`a distributed environment.
`Notably, the invention is limited neither in the number of
`application components 205 managed by the platform 203,
`nor in the number of platforms 203 for managing the
`application components 205. Moreover, the loader 204 can
`be included as part of the platform 204 or can exist inde
`pendently of the platform 203. Finally, the configuration
`client 202 can be included as an application component
`managed by the platform 203 along with the application
`components 205. The configuration server 201 can store
`both configuration data 214 and software modules 216 for
`distribution to the client positions. Specifically, the configu
`ration server 201 can store the data 214 and modules 216 in
`an LDAP file server 210. However, the invention is not
`limited in this regard. Rather, the data 214 and modules 216
`can be stored and accessed through any suitable means, for
`example an XML file server.
`As shown in FIG. 2, the configuration client 202 can be
`managed separately from the platform 203. Moreover, in one
`aspect of the invention, the configuration client 202 can be
`implemented as a JAVA BEAN software object. In conse
`quence, the configuration client 202 JAVA BEAN software
`object implementation can be reused by other applications.
`Notably, the platform 203 can be a JAVA programming
`language-based platform for managing application compo
`nents 205. As such, the platform 203 can behave as an object
`request broker (ORB) for the various application compo
`nents 205 installed on the platform 203.
`In operation, when the client position 207 undergoes
`bootstrap, the platform 203 can start the configuration client
`202. Once started, the configuration client 202 can read a
`bootstrap properties file containing only the uniform
`resource locator (URL) of the configuration server 201 and
`a client position identifier. Subsequently, the configuration
`client 202 can establish a communications connection to the
`configuration server 201. In particular, the communications
`connection can be an LDAP connection to an LDAP server
`using a JAVA Naming and Directory Interface (JNDI/
`LDAP). Still, the invention is not limited in regard to the
`particular communications connection. Rather, any suitable
`communications connection can Suffice. For example, the
`communications connection can be a point-to-point TCP/IP
`connection to a CGI interface to a flat-file database using
`HTTP
`Once a communications connection has been established,
`the configuration client 202 can perform an initial inquiry of
`the configuration server 201 using the position identifier as
`the search argument. A response to the initial inquiry can
`include a list of application components 205 to be installed
`in the client position 207. Subsequently, the configuration
`client 202 can inspect the list and can perform secondary
`inquiries for each of application components 205 in the list.
`AS before, secondary responses to the secondary inquiries
`can include executable modules for the application compo
`nents 205 as well as configuration data that can include
`server addresses necessary for the execution of the applica
`tion components 205.
`The secondary responses can be received in the platform
`203. Once received, the application components 205 can be
`executed. More particularly, the platform 203 can retrieve a
`list of each application component 205 to be installed in the
`client position 207. Subsequently, each application compo
`nent 205 can be installed by performing appropriate instan
`
`6
`tiations and calling required initialization methods defined in
`a corresponding application component interface.
`During initialization, each application component 205 can
`request corresponding configuration data from the configu
`ration client 202. Examples of configuration data can
`include option settings, screen definitions, and server
`addresses. When received, the requesting application com
`ponent 205 can perform an appropriate initialization. Each
`application component 205 also can request that the con
`figuration client 202 notify the application component 205
`of future updates for utilization by the application compo
`nent 205. Notably, in one aspect of the invention the
`application component notification facility can include an
`implementation of an observer design pattern. Notwith
`standing, the invention is not limited in this regard. Rather,
`other implementations of the application component notifi
`cation facility can Suffice, including storing a list of appli
`cation components in a database and notifying selected
`application components each time an update is received
`which is directed to an application component in the list.
`When updates become available in the configuration
`server 201, an update message can be transmitted to client
`positions 207 containing application components 205 to
`which the update is directed. Still, the invention is not
`limited in this regard. Rather, the messages can be broadcast
`messages or UDP narrow-cast messages directed to client
`positions 207 regardless of the application components 205
`contained therein. In any case, once the configuration client
`202 receives an update message, the configuration client 202
`can establish a new communications connection to the
`configuration server 201. As before, the communications
`connection can be an LDAP connection where the configu
`ration server 201 is an LDAP server. Subsequently, updates
`in the form of updated configuration data and software
`modules can be transmitted to the configuration client 202
`through the communications connection.
`Once the updated configuration data and Software mod
`ules have been retrieved, the configuration client 202 can
`notify the platform 203 that updates have been received. For
`example, in a JAVA programming language or a C++ pro
`gramming language implementation, the configuration cli
`ent 202 can generate an update received event and transmit
`the same to the platform 203. In response, if updated
`software modules have been received, the platform 203 can
`identify application components to which the updates are
`directed. Where an update is updated configuration data
`which does not require the termination of the targeted
`application component 205, the platform 203 can simply
`deliver the update to the targeted application component
`205. Specifically, the configuration client 202 can notify the
`targeted application component 205 that updated configu
`ration data has been received. In response, the targeted
`application components 205 can retrieve the updated con
`figuration data from the configuration client 202 and can
`reinitialize associated internal States appropriately.
`In contrast, where an update is either an updated Software
`module or updated configuration data which requires the
`termination and re-instantiation of the application compo
`nent 205, the platform 203 can terminate the targeted
`application component 205 prior to applying the update to
`the targeted application component 205. In one aspect of the
`invention, the platform 203 can terminate the execution of
`the targeted application component 205 by accessing a
`terminate method associated with the targeted application
`component 205 and exposed by an interface to the targeted
`application component 205. Significantly, when applying an
`
`25
`
`30
`
`35
`
`40
`
`45
`
`50
`
`55
`
`60
`
`65
`
`8
`
`

`

`US 7,171,661 B1
`
`10
`
`15
`
`7
`update to a targeted application component 205, a two
`phased startup and shutdown approach can be implemented.
`In consequence of this approach, application components
`205 can remove any interdependencies without necessarily
`affecting program execution of other application compo
`nents 205. Once the application component 205 has been
`terminated, the platform can apply the update according to
`configuration data associated with the update. Subsequently,
`the platform 203 can re-instantiate the targeted application
`component 205. Additionally, the platform 203 then can call
`the initialization method of the targeted application compo
`nent 205 so that the targeted application component 205 can
`properly reload.
`Turning now to FIGS. 3A and 3B, a communications
`sequence is illustrated in which the system of FIGS. 1 and
`2 can be configured to distributed real time updates to active
`client positions. As in FIGS. 1 and 2, the system can include
`a configuration server 301, a configuration client 302, a
`platform 303, a loader 304, and application components
`305A-305C. Additionally, the system can include a boot
`strap probe 306 for assisting the configuration client 302
`during bootstrap.
`Turning now to FIG. 3A, when the platform 303 under
`goes bootstrap, the platform 304 can perform an instantia
`tion 310 of the loader 304 and the configuration client 302.
`The platform 303 then can perform a series of runtime
`communication routines with the configuration client 302
`Such as getinstance() 312 to acquire a particular instance of
`the configuration client 302, addConfig|Listenter(string) 314
`to instruct the configuration client 302 to add the platform as
`a listener/observer and getConfig(string) 316 to retrieve
`configuration data. Once this initial phase of bootstrap has
`completed, the configuration client 302 can read 318 a
`bootstrap properties file and can extract therefrom an
`address for the configuration server 301. In one aspect of the
`invention, the bootstrap properties file can contain a URL of
`the configuration server 301 and a position identifier.
`Once the bootstrap operation has completed, the configu
`ration client 302 can establish a communications connection
`to the configuration server 301. In particular, where the
`configuration server 301 is an LDAP server, the configura
`tion client 302 can establish an LDAP connection to the
`configuration server 301 using JNDI/LDAP. Subsequently, a
`getContext() method 320 can be used by the configuration
`client 302 to acquire the context of the configuration server
`301. An initial inquiry then can be made to the configuration
`server 301 by the configuration client 302 to retrieve a list
`of client application component types. The initial inquiry
`322 can use the position identifier of the configuration client
`302 as a search argument.
`In response to the initial inquiry 322, the configuration
`server 301 can return a response containing a list of client
`application component types to be installed in the platform
`303. In one embodiment, a separate inquiry 324 can specify
`data within the configuration server 301 that is to be pro
`vided to the platform 303. Subsequently, the configuration
`client 302 can cycle through the list of client application
`component types and can issue corresponding secondary
`inquiries 328 and 332 for each of the application component
`types defined, in order to retrieve related client configuration
`data. The responses to the secondary inquiries 328,332 can
`contain executable modules for the application components
`305A, 305B, 305C. To complete this initial stage, an enu
`meration 338 of the responses from the configuration client
`302 can be returned to the platform 303. The configuration
`client 302 can convey an instruction to close 336 the
`
`8
`communication connection with the configuration server
`301 once initialization tasks have been performed.
`It should be noted that different application components
`may need to be installed within the platform 303 in a serial
`fashion. That is, the installation of particular application
`components can require other components to have already
`been installed and/or activated. Therefore, the configuration
`client 302 can submit instructions to the configuration server
`301 detailing an order in which inquires are to be handled.
`For example, a serialization instruction 326 can specify that
`inquiry 324 is to be processed before inquiry 328; a serial
`ization instruction 330 can specify that inquiry 328 is to be
`processed before inquiry 332, and, a serialization instruction
`334 can specify that inquiry 328 is to be processed before
`closing 336 the communication connection.
`Turning now to FIG. 3B, the platform 303, using the
`configuration data, can load and initialize an appropriate
`platform interface to the loader 304 using the load (Platfor
`mInterface) method 340. Once initialized, the loader 304 can
`perform a series of communication routines with the con
`figuration client 302. Specifically, the loader 304 can access
`a getInstance() method 342 in order to acquire the particular
`instance of the configuration client 302. Additionally, the
`loader 304 can access an addConfiglistenter(string) 344 in
`order to instruct the configuration client 302 to add the
`loader 304 as a listener/observer. Finally, the loader 304 can
`access a getConfig(string) method 346 to retrieve the con
`figuration data containing the names of classes to instantiate.
`For each of the class names of application components
`305A, 305B, 305C listed in the configuration data provided
`by the configuration server 301 in the inquiries, 324, 328,
`and 332, the following sequence of events can occur. First,
`the loader 304 can instantiate 348 the application component
`305A, 305B, 305C and can provide to the application
`component 305A, 305B, 305C a reference to the platform
`303 through the setup(reference to Platform) method 350.
`Subsequently, the application component 305A, 305B,305C
`can undergo initialization.
`Specifically, in accordance with the two-phased startup
`and shutdown approach described above, a first phase 352 of
`the initialization process can follow the completion of the
`setup(reference to Platform) method 350 in which an exist
`ing instance of the application component 305A, 305B,
`305C is shutdown and the application component 305A,
`305B, 305C is updated. Subsequently, the application com
`ponent