System and method for building a runtime image from components of a software program

• US 20030121024A1
• Filed: 03/28/2002
• Published: 06/26/2003
• Est. Priority Date: 12/13/2001
• Status: Abandoned Application

• Current Assignee: Microsoft Technology Licensing LLC (Microsoft Corporation)
• Original Assignee: Microsoft Corporation
• Inventors: Beachman, Bruce J., Hill, Timothy J.
• Application Number:
  US10/108,963
• Publication Number:
  US 20030121024A1
• Time in Patent Office: Days
• US Class Current: 717/107
• CPC Class Codes: G06F 8/63 Image based installation; Cloning; Build to order
• CPC Class Codes: G06F 8/71 Version control security arrangements therefor G06F21/57; Configuration management

Abstract

A system and method for generating run-time images of a software program, such as an operating system, builds a run-time image from a plurality of selected software program components, each of which is a discrete packet of functionality. Each component not only specifies its properties and resources but also provides script for its own build behavior. To build the run-time image, a configuration is constructed to include instances of selected components, and the scripts of the instances are invoked such that each component instance builds itself into the run-time image. A general framework is provided for managing the components and the build process. A prototyping scheme is provided for a component to inherit its properties, resources, and script from other components. Each component may also specify dependency data in terms of component inclusion in the run-time image and the orders in which the components are built into the run-time image. A versioning scheme facilitates the tracking of various revisions and upgrades of components.

Claims

1. A computer-readable medium having computer-executable instructions for performing steps for building a run-time image of a software program, comprising:

providing a plurality of software program components, each software program component having description data defining properties and resources thereof and providing associated script for building said each software program component into the run-time image;

selecting software program components from the plurality of software program components;

generating an instance of each selected software program component;

combining instances of the selected software program components in a configuration of the run-time image, each instance having script including the script for building a corresponding selected software program component;

creating the run-time image by invoking the script of each of the instances in the configuration to build the corresponding selected software program component into the run-time image.

2. A Computer-readable medium as in claim 1, wherein the software program is an operating system.

3. A computer-readable medium as in claim 1, wherein the script for building each software program component includes instructions for copying binary files required by said each software program component into the run-time image.

4. A computer-readable medium as in claim 1, wherein the step of generating an instance of each selected software program component includes:

identifying an inheritance chain for said each selected software program component, the inheritance chain containing a plurality of software program components;

collapsing properties and resources of the software program components in the inheritance chain to form properties and resources of the instance; and

coalescing scripts of the software program components in the inheritance chain to form the script of the instance for building said each selected software program component into the run-time image.

5. A computer-readable medium as in claim 4, wherein the inheritance chain ends with a default prototype component provided by a platform selected for the run-time image, the default prototype component having script defining default build behavior for software program components belonging to the platform.

6. A computer-readable medium as in claim 1, having further computer-executable instructions for performing the steps of:

including script for dependency management in the configuration; and

invoking the script for dependency management to check dependencies among the selected software program components.

7. A computer-executable media as in claim 6, wherein the script for dependency management includes instructions to automatically include a non-selected software program component required by a selected software program component.

8. A computer-readable media as in claim 1, having further computer-executable instructions for presenting a user interface for receiving user inputs for selecting the software program components for inclusion in the configuration.

9. A system for generating run-time images of a software program, comprising:

a database for storing description data for a plurality of software program components, the description data for each software program component defining properties and resources of said each software program component and providing associated script for building said each software program component into a run-time image;

a repository for storing a plurality of binary files constituting the software program components described in the database;

a configuration object containing instances of a plurality of selected components selected from said plurality of software program components for constructing a target run-time image, each instance in the configuration object including the script for building a corresponding selected component; and

a management module for causing, during a build operation for generating the target run-time image, the script of each instance contained in the configuration object to be invoked to build the corresponding selected component into the target run-time image.

10. A system as in claim 9, further including a user interface tool for providing user interface to a user, the interface tool cooperating with the management module to allow the user to select software program components for inclusion in the configuration file and to initiate construction of the target run-time image.

11. A system as in claim 9, wherein the software program is an operating system.

12. A system as in claim 9, wherein the description data for each software program component include data specifying dependency information with respect to other software program components in the database.

13. A system as in claim 9, wherein the database further includes description data for a platform of the software program.

14. A system as in claim 13, wherein the description data for the platform include a script for dependency management.

15. A system as in claim 14, wherein the description data for each software program component include data specifying dependency information with respect to other software program components in the database, and wherein the management module generates the configuration object to include the script of the platform and invokes said script during the build operation to check dependencies among the selected software program components based on the dependency information specified by the description data of the selected software program components.

16. A system as in claim 15, wherein the dependencies among the selected software program components include inclusion dependencies and build-order dependencies.

17. A system as in claim 9, wherein the management module is further programmed to import data into the database, repository, and a configuration file corresponding to the configuration object from a carrier file.

18. A computer-readable medium having stored thereon a database containing description data for a plurality of software components for use in building run-time images, the description data for each software program component having a data structure comprising:

a first data field containing data describing properties of said software program component;

a second data field containing data describing required resources of said software program component;

a third data field containing data representing script defining a build behavior of said software program component, said script being invokable for building said software program component into a target run-time image.

19. A computer-readable medium as in claim 18, wherein the first data field further contains data identifying a prototype software program component stored in the database.

20. A computer-readable medium as in claim 18, wherein the database further includes description data for a platform for the target run-time image.

21. A computer-readable medium as in claim 18, wherein the data structure further includes a fourth data field containing dependency information data specifying dependencies between said software component and other software program components in the database.

22. A computer-readable medium as in claim 21, wherein the dependency information data include data specifying a dependency between said software component and a group of software program components stored in the database.

23. A computer-readable medium as in claim 18, having stored further thereon a plurality of binary files constituting the software program components described by the description data in the database.