JP2007323331A - Software system and software registration method - Google Patents

Abstract

<P>PROBLEM TO BE SOLVED: To shorten the startup time of a software system consisting of a plurality of software modules, and achieve a software system startup method that is not affected by a software module startup failure. <P>SOLUTION: In the registration/retrieval of a service in which program modules are mutually dependent, the system waits until an unregistered service is registered at the time of retrieving a service only when the system is started up. Also, the system is configured in such a manner that, even when the startup of a program module that does not provide a service fails, the startup can succeed as the whole of the system. <P>COPYRIGHT: (C)2008,JPO&INPIT

Description

  The present invention relates to a system or the like for controlling the activation processing of each program module in a software system or the like composed of a plurality of program modules. For example, the present invention relates to a system that can safely and quickly start a software system when program modules have a dependency relationship with each other.

  2. Description of the Related Art Conventionally, a software system composed of a plurality of program modules has an activation order control means for controlling in what order the program modules are activated when the system is activated. is there. Such a technique is described in, for example, Patent Document 1, Patent Document 2, Patent Document 3, Non-Patent Document 1, and the like.

  The control of the startup order is mainly because when a program module uses a function provided by another program module, the program module that provides the function must be started first. Has been done. In other words, if the program module that provides the function is not activated first, it is necessary to satisfy the dependency relationship that the activation of the program module that uses the function fails.

  An example of the dependency relationship is a service providing system in an object-oriented system. For example, the OSGi service platform described in Non-Patent Document 1 provides services as follows.

The service is provided in the following procedure.
Define an interface description that describes how to access a function.
On the service providing side, a service object that implements an interface based on this interface description is registered in a service registry that exists only in the system.
The service described by the interface description is provided to the user side via this service object.
The service using side searches the service registry using the service interface description as a key, finds the registered service object, and obtains the service object from the service registry.

  In this way, the functions of a module can be used by other modules.

  A general method is to sequentially start by determining the order of starting in consideration of these dependency relationships. This method has the problem that if all the program modules that are in the startup order before the target program module are not started, the target module cannot be started and the startup time becomes long. is doing.

  To deal with this problem, consider the dependency relationship, group the dependents, determine the startup order within the group, and shorten the startup time by enabling startup processing to be performed in parallel between groups. The method is taken.

JP-A-10-293893 JP 2001-325240 A Japanese Patent No. 3278885 "OSGi Service Platform Release 3", Open Service Gateway Initiative, March 2003

  Furthermore, in order to shorten the activation time, the activation process may fail when attempting to activate all program modules in parallel without grouping. In other words, if a module that uses a service requests service provision before the service providing module registers the service provided to other modules in the service registry, the service cannot be used because the service is not registered. It ends up.

  In addition, in a group having a dependency relationship, activation of the dependent module does not end for some reason, and subsequent modules cannot be started, and there is a problem that it takes time to finish starting the group.

  Further, there is a problem that the initialization of the group and the initialization of the entire system fail due to the failure of the initialization of the module.

  The present invention has been made to solve the above-described problems. An installation process for installing a program module in a software system after the software system is started, and a program module for individually specifying and starting the program module. A starting step, a program module stopping step for individually specifying and stopping the program module, a system starting step for starting each program module in parallel by the program module starting step when starting the software system, and a program A function access step for making the functions possessed by the module available to other modules, a service registration step for registering the functions to be disclosed to other program modules, a service search step for searching for the functions, A service acquisition step of acquiring a function, and in the service search step, when the (predetermined) desired function is not normally registered in the service registration step, the search fails and software A software registration method or the like is provided that waits until a predetermined (desired) function is registered in the service registration step when the system is activated.

  According to the present invention, even if all program modules are started in parallel at the time of system startup, the startup of the program modules does not fail, and a software system that can be started quickly and safely can be constructed. .

  Further, it is possible to prevent the entire software system from being activated due to the influence of the abnormality at the time of starting the program module, and it is possible to construct a robust software system having resistance against the abnormality of the program module.

  Embodiments of the present invention will be described with reference to the drawings.

FIG. 1 shows the configuration of software running on a system that implements the present invention, and is defined by the OSGi service platform described in Non-Patent Document 1.
In the figure, reference numeral 1010 denotes an operating system for controlling hardware and software. Reference numeral 1020 denotes a Java (registered trademark) virtual machine that operates on the operating system 1010 and interprets and executes byte codes that are intermediate languages generated from the Java (registered trademark) language. “Java (registered trademark)” is a registered trademark of Sun Microsystems, Inc. Reference numeral 1030 denotes a framework which is written in the Java (registered trademark) language and allows various application programs to be executed on one Java (registered trademark) virtual machine 1020. Reference numeral 1040 denotes a bundle which is a management unit on the framework of an application operating on the framework 1030. The bundle 1040 includes a program described in Java (registered trademark) language constituting the application, image data used by the program, various file data, and the like. The framework 1030 has a function of installing / uninstalling the bundle 1040 independently from the framework, a function of updating the installed bundle to a new one, and a function of starting / stopping the installed bundle.

FIG. 2 is a diagram describing the configuration of main Java (registered trademark) language classes constituting the framework 1030.
In the figure, 2010 is a framework implementation class that realizes the main functions of the framework 1030. Reference numeral 2015 denotes a BunleContext interface that defines an interface for accessing functions implemented by the framework implementation class from other than the framework.

  Reference numeral 2020 denotes a bundle interface that defines an interface for accessing the bundle 1040 from another bundle 1040. Reference numeral 2025 denotes a bundle control implementation class generated for managing the bundle 1040 on the framework 1030.

  Reference numeral 2030 denotes a BundleActivator interface that is an interface that defines a method to be called by the framework 1030 when starting / stopping the bundle 1040.

  Reference numeral 2035 denotes a bundle implementation in which the BundleActivator interface 2030 is implemented in the bundle 1040. Reference numeral 2040 denotes a service control implementation for managing on the framework 1030 a service that the bundle 1040 provides to other bundles 1040.

  Reference numeral 2045 denotes a service implementation that actually implements a service provided by the bundle 1040 in the bundle 1040. Reference numeral 2050 denotes a ServiceRegistration interface which is an interface for accessing service registration data.

  Reference numeral 2055 denotes a ServiceReference interface which is an interface for accessing service data when using the service.

FIG. 3 shows the structure of the Jar file used when installing the bundle 1040 and the attributes of the bundle set in the manifest header in the case of a file constituting the bundle (referred to as a bundle file). Here, the Jar file is an archive file, and the manifest header is the header of the Jar file. However, it is not always necessary to specify these bundle attributes, and the order is not specified.
In the figure, 3010 is a bundle name describing the name of the bundle 1040, and 3020 is a static reference which is a list of package names of Java (registered trademark) packages provided by other bundles 1040 to which the bundle 1040 refers. It is a package.

  Reference numeral 3030 denotes a provided package that is a list of Java (registered trademark) package names that the bundle 1040 provides to other bundles.

  Reference numeral 3040 denotes a list of Java (registered trademark) package names referred to by the bundle 1040 as in the static reference package 3020. However, while the static reference package 3020 needs to resolve the reference relationship when the bundle 1040 is activated, 3040 is a dynamic reference package that only needs to be able to resolve the reference relationship when it is actually needed.

  Reference numeral 3050 denotes a reference service for declaring which service to use among services provided by other bundles 1040. Reference numeral 3060 denotes a provision service that declares a service that can be provided to another bundle 1040, and reference numeral 3070 denotes a BundleActivator implementation class name that declares the name of a class that implements the BundleActivator interface 2030.

  Hereinafter, an installation process for generating data to be referred to when the system is stopped, a bundle start / stop process, and a system restart process will be described.

"Installation Process"
First, processing when the bundle 1040 is installed in the framework 1030 will be described with reference to FIG.

  The system operator designates the location where the bundle file is stored using Uniform Resource Locators (URL). Then, the framework implementation 2010 is instructed to install the bundle file stored in the designated location in the framework 1030.

  The framework implementation 2010 reads the bundle file from the designated storage location, and stores the read bundle file data in a cache provided so that it can be easily referred to in the framework.

  The provided package header 3030 and the static reference package header 3020 are read from the manifest of the bundle file that has been read (the header that defines the attributes of the Jar file). The Java (registered trademark) package provided by each bundle 1040 is stored in the provided package registry of the framework implementation 2010 together with the bundle ID of the provided bundle 1040.

  If the reference package described in the static reference package header 3020 is already registered in the provided package registry or is described in its own provided package header 3030, the processing is continued.

  Otherwise, an exception indicating that the installation process has failed is generated and the process is stopped.

  An object of the bundle control implementation 2025 is generated, and initialization is performed based on the bundle file manifest information.

  The contents of the manifest are managed by the bundle control implementation 2025, and can be referred to using a character string representing an entry of each manifest header as a key.

  Further, a bundle ID for uniquely identifying the bundle is given to the bundle.

  A bundle list having the structure shown in FIG. 8 is generated by the framework implementation.

  An entry relating to the newly installed bundle is created based on information such as the bundle ID and the storage position in the cache, and added to the end of the bundle list. This bundle list is stored in a nonvolatile memory such as a hard disk.

An INSTALLALLED state indicating that the bundle control implementation 2025 is installed is set.
This state is searched from the bundle list using the bundle ID as a key, and a bundle list entry for the target bundle is searched, and the state registered in the entry is changed to INSTALLED.

  In this way, the bundle 1040 is installed in the framework 1030.

"Bundle start / stop processing"
Next, processing when the bundle 1040 is started / stopped will be described with reference to FIG.

  The framework implementation 2010 instructed by the operator to start the bundle corresponding to the designated bundle ID by specifying the bundle ID detects the bundle control implementation 2025 corresponding to the bundle ID from the bundle ID.

  A character string representing the BundleActivator implementation class name header 3070 is designated as a key for the bundle control implementation 2025, and data of the BundleActivator implementation class name 3070 is acquired.

  When the BundleActivator implementation class name 3070 is defined, the class indicated by the BundleActivator implementation class name 3070 is loaded to generate an object.

  The generated BundleActivator object is stored in the bundle control implementation 2025.

  A start method is called for the generated BundleActivator object, and a bundle initialization routine defined for each bundle 1040 is executed.

  In this initialization routine, a service provided by the bundle 1040 is registered in the framework implementation 2010, and a ServiceRegistration object representing the registered service is acquired. Also, a service used by the bundle 1040 is searched from services registered in the framework implementation 2010, and a ServiceReference object representing the searched service is acquired to acquire a service object.

  Here, a service / object acquisition process performed when a normal bundle is activated will be described with reference to an activity diagram shown in FIG. In normal startup processing, if a ServiceReference object cannot be obtained as a result of searching for a service, that is, if a service is not found, subsequent startup processing cannot be performed, so an exception is generated and notification that startup processing has failed To do.

  If the activation is successful, the bundle control implementation is set to the ACTIVE state, which is a state indicating that the bundle 1040 is activated.

  This ACTIVE status is also set in the status field of the corresponding entry in the bundle list and is stored permanently.

  Further, the framework implementation 2010 maintains a bundle activation order list shown in FIG. 7, and this list is also stored permanently like the bundle list. The bundle ID of the bundle activated at the end of this bundle activation order list is added.

  Next, the stop process will be described. The framework implementation 2010 instructed by the operator to stop the bundle corresponding to the specified bundle ID by specifying the bundle ID detects the bundle control implementation 2025 corresponding to the bundle ID from the bundle ID.

  The BundleActivator object stored in the bundle control implementation 2025 is acquired. A stop method is called for the acquired BundleActivator object, and a bundle stop routine defined for each bundle 1040 is executed. In this stop routine, for example, the registration of the service registered by the bundle 1040 is performed, or the service that has been used is released.

  If the stop is successful, the bundle control implementation is set to the RESOLVED state, which is a state indicating that the bundle 1040 is stopped.

  The RESOLVED state is also set in the state field of the corresponding entry in the bundle list and is stored permanently.

  Further, the entry describing the bundle ID of the stopped bundle is deleted from the bundle activation order list.

  By executing such processing, the bundle activation order list can hold in what order the activated bundles are activated.

"System restart process"
Next, processing when the system is restarted will be described with reference to FIG.

  In this system, the bundle 1040 that has been operating until the system stop process starts is automatically started when the system is restarted. The method will be described below.

  First, when the system is started, a framework implementation 2010 is generated.

  When the framework implementation 2010 is activated, the bundle list stored permanently is read out.

  A bundle control implementation 2025 is generated from the bundle information stored in the bundle list, and the generated bundle control implementation 2025 is initialized.

  In addition, the bundle state is set to the state stored in the bundle list.

  Further, the bundle activation order list stored permanently is read, the bundle ID registered in the list is acquired, the object of the bundle control implementation 2025 of the acquired bundle ID is searched, and the bundle 1040 is activated. .

  The activation process of each bundle 1040 is performed in a separate thread and processed in parallel. The activation process of each bundle is the same as the normal activation process except that the process for registering / acquiring services is different.

  Here, the relationship of service registration / acquisition when the system is started will be described with reference to the activity diagram shown in FIG. In the figure, bundle A is a bundle for registering services, and bundle B is a bundle for using services.

  In the bundle B, if a service is searched and a ServiceReference object cannot be obtained, the service waits for the service to be registered by the wait () method.

  On the other hand, in the bundle A for registering the service, after registering the service, the notify All () method notifies the thread waiting for the service registration.

  Bundles waiting for service registration (calling the wait () method) are awakened by the notifyAll () method and continue processing.

  In the bundle B, it is checked again whether a desired service is registered.

  If it is not registered, it waits again with the wait () method. If it is registered, the service object is acquired and the activation process is continued.

  In FIG. 9, for the sake of explanation, a process that is not found by searching for a service is performed inside the bundle activation process. The process is separated by detecting whether the process is normal. By configuring the system to wait for service registration when the system is activated, the bundle activation process can search for services without being aware of whether the system is activated or normal.

  The bundle that is activated when the system is activated is a bundle that has been activated after the system ends the activation process. The normal activation means that the bundle providing the necessary service for the bundle to be activated has already registered the necessary service, and thus the bundle has been successfully activated.

  In other words, if all bundles are activated after the system is activated, it is guaranteed that there is no state where the necessary services are not registered.

  Whether or not the system is activated is determined by using a flag that is set at the beginning of the system activation process and is canceled at the end of the system activation process. When this flag is set, it is determined that the system is being started.

  Due to a defect in the bundle that provides the service, it may not be possible to search for a desired service when the system is started, or the bundle activation may not be terminated due to other reasons.

  Normally, the system startup and termination process is performed after the startup of all bundles is completed. If there is a bundle that cannot be terminated even after the preset timeout period has elapsed, the subsequent processing depends on the bundle's attributes. To change.

  If the provided service 3060 is not set in the manifest header of a bundle that could not be activated, the effect on the entire system is negligible even if this bundle is not activated. For this reason, a log indicating that the bundle could not be activated is generated and the system activation process is normally terminated.

  When the provision service 3060 is set, the bundle cannot be activated, which greatly affects other bundles. Therefore, the system activation process is terminated and the entire system is stopped.

  In this way, it is possible to quickly and safely start the system.

  The embodiment of the present invention can be realized by, for example, a computer executing a program. Also, means for supplying a program to a computer, for example, a computer-readable recording medium such as a CD-ROM recording such a program, or a transmission medium such as the Internet for transmitting such a program is also applied as an embodiment of the present invention. Can do. The above program can also be applied as an embodiment of the present invention. The above program, recording medium, transmission medium, and program product are included in the scope of the present invention.

It is a figure which shows the software structure in an Example. It is a figure which shows the class structure of the framework in an Example. It is a figure which shows the structure of a Jar file and a manifest. It is a flowchart which shows a bundle installation process. It is a flowchart which shows bundle starting / stopping processing. It is a flowchart which shows a system restart process. It is a figure which shows the structure of a bundle list and a bundle stop order list. It is an activity diagram which shows the service acquisition process at the normal time. It is an activity diagram which shows the service acquisition process at the time of system starting.

Explanation of symbols

1010: Operating system 1020: Java (registered trademark) virtual machine 1030: Framework 1040: Bundle 2010: Framework implementation 2015: BundleContext
2020: Bundle
2025: Bundle control implementation 2030: BundleActivator
2035: Bundle implementation 2040: Service control implementation 2045: Service implementation 2050: ServiceRegistration
2055: ServiceReference
3010: Bundle name 3020: Static reference package 3030: Provided package 3040: Dynamic reference package 3050: Reference service 3060: Provided service 3070: BundleActivator implementation class name

Claims (4)

In a software system consisting of multiple program modules,
Installation means for installing the program module into the software system after the software system is started; and
Program module starting means for individually specifying and starting the program modules installed by the installing means;
Program module stop means for individually specifying and stopping the program modules started by the program module start means;
System starting means for starting each program module in parallel by the program module starting means when starting the software system; and
Function access means for making the functions of the program module available to other modules;
Service registration means for registering the function access means for publishing to other program modules;
Service search means for searching for function access means registered by the service registration means;
Service acquisition means for acquiring function access means searched by the service search means;
Have
The service search means normally fails when the predetermined function access means is not registered by the service registration means, and is predetermined by the service registration means when the software system is activated. A software system which waits until the function access means is registered. Module attribute assigning means for setting the attribute of the program module to the program module;
Module attribute reference means for referring to the attribute of the program module set by the module attribute giving means;
Have
Provided service attributes indicating that the function access means is provided to other program modules and use service attributes indicating that the function access means provided by the other program modules are used are defined,
The system activation means determines whether or not the software system has a service attribute to be provided when a processing time longer than a predetermined time is required to activate the program module when the software system is activated. 2. The software system according to claim 1, wherein it is determined whether the startup process of the system is normally terminated or abnormally terminated. An installation process for installing the program module into the software system after the software system is started;
A program module starting step for individually specifying and starting the program modules; and
A program module stop step for individually specifying and stopping the program modules; and
A system starting step of starting each program module in parallel by the program module starting step when starting the software system;
A function access process for making the functions of the program module available to other modules;
A service registration step of registering the function for publishing to other program modules;
A service search process for searching for the function;
A service acquisition step of acquiring the function;
Have
In the service search step, if the function that is predetermined in the normal state is not registered in the service registration step, the search fails, and the function that is predetermined in the service registration step when the software system is started up A software registration method characterized by waiting until the software is registered. On the computer,
An installation procedure for installing the program module in the software system after the software system is started; and
A program module starting procedure for individually specifying and starting the program modules;
A program module stop procedure for individually specifying and stopping the program modules;
A system startup procedure for starting each program module in parallel by the program module startup procedure when starting the software system; and
Function access procedure to make the functions of the program module available to other modules;
A service registration procedure for registering the function for publishing to other program modules;
A service search procedure for searching for the function;
A service acquisition procedure for acquiring the function;
A software registration program that executes
In the service search procedure, if the function predetermined in normal operation is not registered in the service registration procedure, the search fails, and the function predetermined in the service registration procedure is started when the software system is started. A program characterized by having it wait until it is registered.

Images