JP2008059482A - Information processor and processing method - Google Patents

Abstract

<P>PROBLEM TO BE SOLVED: To provide a technology for actually using a bundle, which is desired for use as a system library, as the system library. <P>SOLUTION: Using a software module management function, attributes necessary for execution of an installed software module 2040 are referred when the software module 2040 is started. The attributes include a system library construction attribute allowing an application 2020 itself to use the software module 2040 as a management target. When the system library construction attribute is referred in starting the software module 2040, the software module management function allows the application 202 to use the target software module 2040. <P>COPYRIGHT: (C)2008,JPO&INPIT

Description

  The present invention relates to software management technology.

  In a so-called embedded device in which device control is performed by incorporating a microcomputer, a program executed on the microcomputer is written in a ROM or the like. For this reason, this program was often not rewritten. However, this program cannot be changed if there are bugs in the program, so there were many cases where it was necessary to keep running with bugs.

  For this reason, there are devices that store programs in a rewritable flash ROM or the like and support program rewriting. However, in this case as well, the entire program is often changed, and it has not been possible to easily change a part or add a new function like a personal computer.

  Even in embedded devices with limited storage capacity and processing capacity, it is necessary to easily update programs and add new functions like in a personal computer, and even embedded devices must be able to handle rapidly changing business processes. It is coming.

  As a technology for that purpose, Java (registered trademark) (Java (registered trademark) is a software technology including a programming language, and is a registered trademark of Sun Microsystems Inc., USA) can be expanded using the portability of the program. Have been proposed (see, for example, Patent Document 1 and Non-Patent Document 1).

  According to such a technique, since it is executed on one application, the required amount of hardware resources can be reduced as compared with the case where the function is expanded in units of applications.

  In OSGi Service Platform (hereinafter abbreviated as OSGi) disclosed in Non-Patent Document 1, a software module added to an application is called a bundle, and the life cycle of the software module such as install / start / end / update / uninstall the bundle Defines the specifications for managing

OSGi also has a function of storing the execution status of each bundle when the application is stopped, and returning the state of each bundle to the stop state when the application is restarted.
JP 2000-29713 A “OSGi Service Platform Specification Release 2”, OSGi, 20001

  In the prior art, software modules that can be installed / updated later can flexibly provide new functions or update improved functions to other software modules. However, only software modules that run on the application benefit from this mechanism.

  For example, in OSGi, the basic part of the application is called a platform, but on this platform, the functions provided by the bundle, which is a removable software module, cannot be used.

  When trying to update software modules such as libraries used by the platform itself, it is necessary to prepare a completely different mechanism without using the life cycle management mechanism of the bundle that the platform has.

  Since OSGi is premised on the use of Java (registered trademark), it is necessary to execute the following procedure as software different from the platform when attempting to change the library used by the platform.

  (1) Add / update libraries using file transfer means such as ftp. In order to update, it is necessary to install with a name different from the name of the library file currently in use.

  (2) The class loader that defines the order in which a class loader that loads a Java (registered trademark) class is searched for is reconfigured to search for a new library.

  (3) Restart the platform using the classpath created in (2).

  As described above, there is a problem that the management of the entire system becomes complicated because it must be managed by a procedure different from the life cycle of the bundle.

  The present invention has been made in view of the above problems, and an object thereof is to provide a technique for actually using a bundle desired to be used as a system library as a system library.

  In order to achieve the object of the present invention, for example, an information processing apparatus of the present invention comprises the following arrangement.

That is, an information processing apparatus including an application having a software module management function for managing a plurality of software modules,
Using the software module management function, comprising a reference means for referring to attributes required when executing the installed software module when starting the software module,
As the attribute, it has a system library attribute that makes the software module to be managed available to the application itself,
When the software module is activated, the reference means refers to the system library attribute so that the target software module can be used in the application by the software module management function.

  In order to achieve the object of the present invention, for example, an information processing method of the present invention comprises the following arrangement.

That is, an information processing method performed by an information processing apparatus including an application having a software module management function for managing a plurality of software modules,
Using the software module management function, comprising a reference step of referring to attributes required when executing the installed software module when starting the software module,
As the attribute, it has a system library attribute that makes the software module to be managed available to the application itself,
By referring to the system library attribute in the reference step when the software module is activated, the software module management function enables the target software module to be used in the application.

  According to the configuration of the present invention, a bundle desired to be used as a system library can actually be used as a system library.

  Hereinafter, the present invention will be described in detail according to preferred embodiments with reference to the accompanying drawings.

  FIG. 1 is a block diagram showing a hardware configuration of a computer applicable to information processing according to this embodiment.

  The control unit 1010 is configured by a CPU, an MPU, and the like, and controls the entire computer using programs and data stored in the RAM 1020 and executes each process described later performed by the computer.

  The RAM 1020 has an area for temporarily storing programs and data loaded from the hard disk 1030, and also has a work area used when the control unit 1010 executes various processes. That is, the RAM 1020 can provide various areas as appropriate.

  The hard disk 1030 stores an OS (operating system), various software described below, data, and the like. These software and data are appropriately loaded into the RAM 1020 in accordance with control by the control unit 1010. Then, the control unit 1010 executes each process described later using the loaded software and data.

  The input unit 1040 includes a keyboard, a mouse, and the like, and various instructions can be input to the control unit 1010 by an operator of the computer.

  The display unit 1050 is configured by a CRT, a liquid crystal screen, or the like, and can display a processing result by the control unit 1010 using an image, text, or the like.

  The network unit 1060 is for connecting the computer to a network such as a LAN or the Internet, and the computer can perform data communication with each device connected to the network via the network unit 1060. .

  Reference numeral 1070 denotes a bus connecting the above-described units.

  FIG. 2 is a diagram illustrating a hierarchical structure of software stored in the hard disk 1030. In the figure, reference numeral 2010 denotes an operating system (OS) that manages software and hardware resources. 2020 is a platform on which the specification of OSGi Service Platform, which is an application written in Java (registered trademark) language, which can extend software modules, is implemented. Reference numeral 2030 denotes a Java (registered trademark) VM (virtual machine that interprets and executes a Java (registered trademark) language) for executing the platform 2020. Reference numeral 2040 denotes a set of software modules (hereinafter referred to as bundles) described in the Java (registered trademark) language that can be executed on the platform 2020. Reference numeral 2050 denotes a system library necessary for executing the platform 2020 on the Java (registered trademark) VM 2030.

  FIG. 4 is a diagram illustrating a configuration example of the file in a state where the bundle file is not encrypted.

  Reference numeral 4010 denotes a bundle file body. This file 4010 is in the Jar file format of Java (registered trademark) language. The Jar file is a ZIP archive file and is composed of a plurality of file entries 4020.

  Each file entry 4020 includes a magic number 4030 indicating the start of the file entry, a file entry size 4040, a file name size 4050, a file name 4060, and a file content 4070. In the figure, the specification of the ZIP file is simplified to simplify the explanation.

  Various attributes of a Jar file are stored in a file entry called a manifest. The manifest file name is “META-INF / MANIFEST.MF”, and the attribute value is described as a pair of the attribute name and its value in the manifest.

  First, processing performed by the control unit 1010 when a bundle is installed on the hard disk 1030 will be described below with reference to FIG. 3 showing a flowchart of the processing. Note that programs and data for causing the control unit 1010 to execute processing according to the flowchart of FIG. The program and data are loaded into the RAM 1020 as appropriate under the control of the control unit 1010. When the control unit 1010 executes processing using the loaded program and data, the computer executes each processing described below.

  First, in step S3010, it is checked whether or not a bundle file installed from the same location as the storage location of the bundle file designated to be installed already exists. The bundle storage location is, for example, in an external device on the network. In this case, the bundle is installed in the hard disk 1030 via the network unit 1060.

  If it exists as a result of this check, this processing is terminated. On the other hand, if it does not exist, the process proceeds to step S3020.

  In step S3020, the encrypted bundle file 4010 installed on the platform is decrypted. The encryption key used for decryption is managed by the platform as a secret key.

  In step S3030, the platform 4010 decrypted in step S3020 is stored in the hard disk 1030. More specifically, the information is stored in a “directory for storing bundles for bundle management” provided in the hard disk 1030.

  In step S3040, a bundle management object for managing the installed bundle on the platform is generated. FIG. 5 is a diagram illustrating a configuration example of a bundle management object.

  In the figure, reference numeral 5010 denotes a bundle identifier unique to the installed bundle, and is different for each bundle. Reference numeral 5020 denotes bundle location information specified by a URL indicating where the bundle is installed from. Reference numeral 5030 denotes a status indicating the execution state of the bundle. Reference numeral 5040 denotes an attribute list indicating bundle attributes.

  Such a bundle management object is created for each bundle to be installed.

  Returning to FIG. 3, in step S3050, the attribute list 5040 in the bundle management object generated in step S3040 can be searched for the attribute described in the manifest in the bundle file 4010 using the attribute name as a key. Set as all registered hash table instances. At this time, if the SystemLibrary attribute indicating the system library is set in the bundle manifest, this attribute is set in the attribute list 5040. Then, an INSTALLED state value indicating that the bundle is installed is set in the status 5030 of the bundle management object.

  With the process described above, the bundle can be installed.

  Next, processing performed by the control unit 1010 when starting the bundle installed in this way will be described below with reference to FIG. 6 showing a flowchart of the processing. Note that programs and data for causing the control unit 1010 to execute processing according to the flowchart of FIG. The program and data are loaded into the RAM 1020 as appropriate under the control of the control unit 1010. Then, when the control unit 1010 executes a process using the loaded program or data, the computer executes each process described below.

  First, in step S6010, the status 5030 of the bundle management object corresponding to the bundle designated for activation is referred to. Then, it is checked whether or not the status 5030 is ACTIVE. If the result of this check is ACTIVE, this bundle is already executed, and this processing is terminated. On the other hand, if it is not ACTIVE, the process proceeds to step S6020.

  In step S6020, the bundle management object attribute list 5040 referred to in step S6010 is referred to. Then, it is checked whether or not the SystemLibrary attribute is set in the attribute list 5040. Since the attribute list 5040 is configured as a hash table, the SystemLibrary attribute value is obtained by specifying the name of the SystemLibrary attribute as a key. If the SystemLibrary attribute is set, the process proceeds to step S6040. If the SystemLibrary attribute is not set, the process proceeds to step S6030.

  In step S6030, since the bundle to be activated is a bundle on the normal platform 2020, activation processing as a bundle on the platform 2020 is performed. When the activation process ends, an ACTIVE state value indicating that the bundle management object of this bundle is being executed is set in the status 5030.

  On the other hand, in step S6040, the path when the bundle file to be activated is stored in step S3030 is acquired, and the acquired path is registered at the end of a subclass path management table described later.

  FIG. 7A is a diagram illustrating a configuration example of a subclass path management table and explaining a process of registering a path in the subclass path management table. In the figure, reference numeral 7010 denotes a subclass path management table. Reference numeral 7020 denotes a subclass path storage file stored in the hard disk 1030 in order to permanently store the subclass path management table 7010. Also, as shown on the left side of the figure, the last pointer indicates the position of the last entry registered in the subclass path management table 7010.

  Here, when a path is registered in the subclass path management table 7010 in step S6040, first, the position of the last pointer is shifted backward by one. This state is shown in the center of the figure. Next, the path when the file of the bundle to be activated is stored in step S3030 is registered at the position indicated by the last pointer. This state is shown on the right side of the figure.

  Finally, the contents registered in the subclass path management table 7010 are converted into a character string in the class path format and stored in the sub class path storage file 7020. Of course, the subclass path storage file 7020 is stored in the hard disk 1030. Then, an ACTIVE state value indicating that the bundle management object is being executed is set in the status 5030 of the bundle management object.

  With the process described above, the bundle can be activated.

  Next, processing performed by the control unit 1010 to stop the bundle being executed will be described below with reference to FIG. 8 showing a flowchart of the processing. Note that programs and data for causing the control unit 1010 to execute processing according to the flowchart of FIG. The program and data are loaded into the RAM 1020 as appropriate under the control of the control unit 1010. When the control unit 1010 executes processing using the loaded program and data, the computer executes each processing described below.

  First, in step S8010, the status 5030 of the bundle management object of the bundle to be stopped is referred to. Then, it is checked whether or not the status 5030 is ACTIVE. If the status 5030 is not ACTIVE as a result of this check, it is assumed that the status 5030 has already stopped, and this processing is terminated. On the other hand, if the status 5030 is ACTIVE, the process proceeds to step S8020.

  In step S8020, it is checked whether the SystemLibrary attribute is set in the attribute list 5040 of the bundle management object of the bundle to be stopped. As a result of this check, if the SystemLibrary attribute is set, the process advances to step S8040. On the other hand, if it is not set, the process proceeds to step S8030.

  In step S8030, since the bundle to be stopped is a normal bundle, normal stop processing is performed. When the stop process ends, an INSTALLED state value indicating that the bundle management object is stopped is set in the status 5030 of this bundle management object. Then, this process ends.

  On the other hand, in step S8040, the path where the bundle to be stopped is installed is deleted from the subclass path management table 7010.

  FIG. 7B is a diagram illustrating a configuration example of the subclass path management table and explaining processing for deleting a path from the subclass path management table.

  First, as shown on the left side of the figure, the bundle path to be stopped is searched from the paths registered in the subclass path management table 7010. Here, “BundleB.jar” will be described as an example of a search target. When searching for “BundleB.jar”, this entry is deleted from the subclass path management table 7010. The center of the figure shows the subclass path management table 7010 after this deletion.

  Then, as shown on the right side of the figure, the storage positions of the paths after the deleted entry are shifted forward one by one, and the position of the last pointer is moved forward by one.

  Finally, the contents registered in the subclass path management table 7010 are converted into a character string in the class path format and stored in the sub class path storage file 7020. Then, an INSTALLED state value indicating that the bundle management object is stopped is set in the status 5030 of the bundle management object.

  With the processing described above, the bundle being executed can be stopped.

  Next, processing performed by the control unit 1010 when the computer is restarted after the above series of processing will be described.

  The Java (registered trademark) VM 2030 that executes a normal Java (registered trademark) program sets the library used by the program as file path information called a class path, and then starts the program. This class path is given as a command parameter of a start command java for starting Java (registered trademark) VM 2030.

  Here is an example command line for the java command: This is when starting with the initial class path as a.jar; b.jar; c.jar and the x.y.z class as the main class.

java −classpath a.jar; b.jar; c.jar xyz
Normally, when searching for a class, the library added by the class path specified as the command parameter is searched next to the system library necessary for the computer.

  FIG. 7C is a diagram schematically showing the flow of processing when the computer is restarted.

  The library file path is acquired from the subclass path storage file 7020 set / changed at the time of starting / ending the bundle, and inserted between the system library and the class path specified by the command parameter. Through such processing, a system library group 7030 is constructed.

  Then, the system library group 7030 generated in this way is given when the system class loader 7040 for loading the computer class is constructed, and the bundle file is added to the system class search path.

  That is, among software module groups described in a language that can be executed on the platform, a path indicating the storage location is registered in the list for a software module to be made into a library. When the computer is started after the registration process, the path registered in the list is given as a command parameter of the start command, and the computer is started using the start command.

  The computer can be restarted by the processing described above.

  OSGi is designed to store the state of each bundle when the platform is shut down and to return to the state stored when the platform is started again. For example, a bundle that was activated when the platform was shut down is automatically activated when the platform is started. Since this activation procedure is exactly the same as the above-described bundle activation procedure, if the subclass path management table 7010 is initialized in an empty state, it is automatically reconstructed by the bundle activation process.

  As described above, according to the present embodiment, a bundle file to be used as a system library can be actually used as a system library.

  In general, the classes constituting the platform are often stored in a library designated on a class path designated as a command parameter. For example, suppose that you want to upgrade a version by replacing some of the classes that make up the platform. In this case, if you create a bundle file consisting of the classes to be replaced, set the SystemLibrary attribute, install and start it just like a normal bundle, the upgraded class will be used the next time it starts It is possible.

<Other embodiments>
Needless to say, the object of the present invention can be achieved as follows. That is, a recording medium (or storage medium) that records a program code of software that implements the functions of the above-described embodiments is supplied to a system or apparatus. Then, the computer (or CPU or MPU) of the system or apparatus reads and executes the program code stored in the recording medium. In this case, the program code itself read from the recording medium realizes the functions of the above-described embodiment, and the recording medium on which the program code is recorded constitutes the present invention.

  Further, by executing the program code read by the computer, an operating system (OS) or the like running on the computer performs part or all of the actual processing based on the instruction of the program code. Needless to say, the process includes the case where the functions of the above-described embodiments are realized.

  Furthermore, it is assumed that the program code read from the recording medium is written in a memory provided in a function expansion card inserted into the computer or a function expansion unit connected to the computer. After that, based on the instruction of the program code, the CPU included in the function expansion card or function expansion unit performs part or all of the actual processing, and the function of the above-described embodiment is realized by the processing. Needless to say.

  When the present invention is applied to the recording medium, program code corresponding to the flowchart described above is stored in the recording medium.

It is a block diagram which shows the hardware constitutions of the computer applicable to the information processing which concerns on embodiment of this invention. 3 is a diagram illustrating a hierarchical structure of software stored in a hard disk 1030. FIG. 10 is a flowchart of processing performed by the control unit 1010 when a bundle is installed in the hard disk 1030. It is a figure which shows the structural example of this file in the state where the file of a bundle is not encrypted. It is a figure which shows the structural example of a bundle management object. It is a flowchart of the process which the control part 1010 performs when starting the installed bundle. It is a figure explaining the registration process of the path | pass to this subclass path management table while showing the example of a structure of a subclass path management table. It is a figure explaining the process which deletes a path | pass from this subclass path management table while showing the example of a structure of a subclass path management table. It is the figure which showed typically the flow of the process at the time of restarting this computer. It is a flowchart of the process which the control part 1010 performs in order to stop the bundle under execution.

Claims (5)

An information processing apparatus including an application having a software module management function for managing a plurality of software modules,
Using the software module management function, comprising a reference means for referring to attributes required when executing the installed software module when starting the software module,
As the attribute, it has a system library attribute that makes the software module to be managed available to the application itself,
When the software module is activated, the reference means refers to the system library attribute, so that the software module management function enables the target software module to be used in the application. apparatus.   The information processing apparatus according to claim 1, further comprising: a unit that does not make the software module usable in the application after the software module having the system library attribute is stopped. An information processing method performed by an information processing apparatus including an application having a software module management function for managing a plurality of software modules,
Using the software module management function, comprising a reference step of referring to attributes required when executing the installed software module when starting the software module,
As the attribute, it has a system library attribute that makes the software module to be managed available to the application itself,
By referring to the system library attribute in the reference step when the software module is activated, the software module management function enables the target software module to be used in the application. Method.   A program for causing a computer to execute the information processing method according to claim 3.   A computer-readable storage medium storing the program according to claim 4.

Images