[19]
`United States Patent
`6,117,187
`[11] Patent Number:
`
`Staelin
`[45 J Date of Patent:
`*Sep. 12, 2000
`
`USOO6117187A
`
`[54] AUTOMATIC GENERATION OFA
`SOFTWARE INSTALLATION PACKAGE
`
`5,721,824
`5,832,205
`5,835,777
`
`2/1998 Taylor ..................................... 709/203
`11/1998 Kelly et al.
`714/53
`
`., 395/712
`11/1998 Staelin
`
`[75]
`
`Inventor: Carl H. Staelin, Palo Alto, Calif.
`
`5,860,012
`
`1/1999 Luu ......................................... 395/712
`
`[73] Assignee: Hewlett-Packard Company, Palo Alto,
`Calif.
`
`Primary Examiner4<akali Chaki
`Attorney, Agent, or Firm—Marc R. Mayer
`
`[*] Notice:
`
`This patent is subject to a terminal dis-
`I
`'
`.
`C a1mer
`
`.
`[21] Appl. No” 08/940’756
`[22]
`Filed:
`Sep. 30, 1997
`
`7
`
`...................................................... G06F 9/445
`Int. Cl.
`[51]
`.................................................... 717/11, 717/1
`[52] U.S. Cl.
`[58] Field of Search ..................................... 395/712, 701,
`395/702, 703; 709/203, 220, 221, 222,
`223, 224; 713/1, 100; 707/200, 203, 204
`_
`References Clted
`U. S. PATENT DOCUMENTS
`
`[56]
`
`5,247,683
`573617360
`57361686
`5’421’009
`5’473’772
`5,493,682
`5,555,416
`5,634,114
`
`9/1993 Holmes et a1.
`......................... 709/221
`11/1994 I§higami et a1.
`..
`395/712
`
`1141994 Fisher et a1.
`~~
`395/712
`
`5/1995 Platt """""""
`709/221
`12/1995 Halhwell et al'
`'
`395/712
`2/1996 Tyra ct al.
`395/703
`
`........................... 395/712
`9/1996 Owens et al.
`5/1997 Shipley ................................... 395/500
`
`[57]
`
`ABSTRACT
`
`A method of automatically generating a software installation
`package. The method operates on an application program
`that has been ported to and debugged on a target computer
`system. A manifest is automatically generated, listing all
`application program files that must be installed on the target
`computer system. Then the method automatically deter-
`mines Wthh resources, in particular shared libraries, are
`needed by any of the listed files. Necessary filesets and
`subproducts are then automatically generated. Program files
`are then automatically assigned to the filesets and filesets are
`automatically assigned to the subproducts. The need for
`control scripts is automatically detected and control scripts
`are automatlcally generated. Then the mstallation package 1s
`generated by combmmg the llsted files, filesets, subproducts,
`control scripts, the needed resources, and any related instal-
`lation materials. The needed resources are determined by
`generating a dependency list, comparing it with existing
`software installation packages, and identifying any packages
`that contain needed shared libraries as needed resources
`'
`
`18 Claims, 6 Drawing Sheets
`
`pplieation Provide
`Qy Software Engflififl\\
`1
`100
`Port and Debug as
`
`Needed
`\
`
`V
`Generate
`Manifest
`,
`xi
`, ,
`Determine
`1
`.\\
`I
`RNeeded
`
`esoiirces
`J
`400
`v
`Fileset and
`\
`'
`‘
`Subpioduct \
`
`Generation
`500
`’Tssigi'nm—i
`Files to Filesets
`l
`
`and Filesets to
`ram)
`
`, Subproduets
`l
`V ,,
`
`
`
`*
`
`,,,,,,,,
`
`
`
`
`
`
`\
`200
`
`\\
`300
`
`
`
`
`l
`Detect Need for
`Control Scripts r\
`
`AWQ\
`W
`l
`Interaction)
`\
`c
`'
`/ \\
`
`x orrectinn 800
`Error Checking A900
`V
`Generate Control
`
`
`Scripts
`moo
`lV
`Generate Installation
`Package
`
`1i on
`
`Apple v. Realtime
`Proceeding No. |PR2016-01738
`APPLE 1031
`
`1
`
`Apple v. Realtime
`Proceeding No. IPR2016-01738
`APPLE 1031
`
`

`

`US. Patent
`
`Scp. 12, 2000
`
`Sheet 1 0f 6
`
`6,117,187
`
` pplication Provide-
`
`100
`
`200
`
`_\300
`
`:
`
`
`
`5
`
`l_______*
`
`y Software Enginee
`________*‘
`Generate
`
`Manifest
`;
`Detefime
`""""’
`£33,215
`700
`1
`r—
`Filesetand
`
`""""* 22:22:20? 3x
`L 500
`
`Assignment of
`Files to Filesets
`and Filesets to d
`
`
`
`
`
`
`
`
`
`Subflfducts
`
`600
`
`‘L_______* Detect Need for
`1
`Control Scripts \
`
`3
`2
`700
`
`FlG.1
`
`oftware Enginee
`Interaction]
`
`Correction
`
`
`
`
`.
`Error Checking
`/‘\
`
`900
`
`
`V
`
`
`
`
`
`Generate Control /_\
`scripts
`‘
`1000
`
`Generate Installation
`
`Package
`
`1 100
`
`2
`
`

`

`US. Patent
`
`Scp. 12, 2000
`
`Sheet 2 0f 6
`
`6,117,187
`
`
`
`
`
`Select an
`
`Executable File
`
`
`
`
`
`Run CHATR to Create
`
`List of Shared Libraries
`
`
`
`Executable
`
`Yes
`
`410
`
`420
`
`Save New Timestamp R
`
`310
`
`Install Application in
`Testbed Computer \|
`I
`320
`
`
`
`
`
`
`
`Select Directories
`
`to be Searched
`
`Use FIND -NEWERC to
`
`‘Generate List of Installed Files
`
`
`
`‘l
`
`
`
`Delete Files Known to
`be Spurious \
`340
`
`330
`
`Check for
`
`Spurious Files
`
`350
`
` More
`
`
`
`Files?
`
`430
`
`440
`
`Identify Packages as
`Needed Resources
`
`
`
`
`
`
`
`List Any Needed
`Shared Libraries
`
`460
`
`450
`
`FIG. 2
`
`FIG. 3
`
`3
`
`

`

`US. Patent
`
`Scp. 12, 2000
`
`Sheet 3 0f 6
`
`6,117,187
`
`
`
`
`
`Select a File
`W
`—>
`605
`
`3
`
`
`
`
`Scan Fileset Rules
`
`for First Match W
`610
`
`I
`
`Assign File
`to Fileset \
`615
`
`Yes
`
`
`
`No
`
`620
`
`
`
`—> SelectaFileset —\
`625
`
`Y
`
`
`
`Scan Subproduct Rules
`for First Match \
`630
`
`
`First Match
`
`Exists?
`
`635
`
`
`
`Assign Fileset
`to Subproduct \
`640
`
` More
`Filesets?
`
`
` Assignment of Files to
`( Filesets and Filesets to
`
`\Subproducts Cornpilete
`650
`
`FIG. 5
`
`
`
`
`
`
`
`
`
`
`%
`
`Select a File
`
`}\
`
`i
`
`E
`Scan Fileset Rules
`
`
`for First Match \
`510
`
`505
`
`!No
`
`——> SelectaFileset b
`i
`535
`,,
`,
`V
`
`
`
`
`Scan Subproduct Rules
`for First Match
`
`v 540
`
`Subproduct
`Exists?
`
`
`
`
`
`Generate 7
`Subproduct
`
`
`
`
`
` Generate Fileset /\525
`
`530
`
`
`
`
`More
`Filesets?
`
`
`
`
`
`_ Fileset and Subproduct
`\ Generation Complete
`
`565
`
`FIG. 4
`
`4
`
`

`

`US. Patent
`
`Sep. 12, 2000
`
`Sheet 4 0f 6
`
`6,117,187
`
`k
`702
`
`Select a File
`
`<—~—
`
`Filename
`n atches *Ietc/*7
`
`No
`
`
`
`
`
`ilename matches
`
`*Inewconfig/*?
`
`
`
`Select a File
`
`702
`
`Pathname
`
`
`: atches *Ibinl*7
`
`718
`
`
`
`
` IethPATH Action
`
`or Pathname Exists?
`
`
`
`
`
`
`
`
`
`Create [etc/PATH
`.
`(-
`722 Action for Pathname
`
`
`athname matches
`*lmanlman*?
`
`724
`
`Yes
`
` ANPATH action for
`Pathname Exists?
`
`
`
`ile is Share -
`
`730
`
`728
`
`Create MANPATH
`Action for Pathname
`
`
`
`
`
`
`
`
`
`Yes
`HL|B_PATH Action
`or Pathname Exists?
`
`
`
`
`Create SHLIB_PATH J
`Action for Pathname
`
`
`
`
` Need for Control
`Script Detection
`Complete
`
`
`
`
`
`
`
`704
`
`rYes
`
`
`
`Newconfig Control
`ction for File Exists?
`
`708
`
`
`i No
`
`l Create Newconfig
`‘
`c tl
`t'
`[
`onroAcIon
`
`’\
`710
`
`eed for Control Scrip
`Detection Complete
`
`714
`
`FIG. 6A
`
`
`
`
`
`
`
`714
`
`
`5
`
`

`

`US. Patent
`
`Scp. 12, 2000
`
`Sheet 5 0f 6
`
`6,117,187
`
`
`
`/j
`702 '
`
`Select a File
`
`
`
`/
`
`Select a File eh
`
`File in Default Set of
`User IDs?
`
`742
`
`User ID Action
`for File Exists?
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`746
`
`Create User ID /
`Action for File
`
`
`
`
`roup ID Action
`for File Exists?
`
`758
`
`Create Group ID d
`Action for File
`
`
`760
`
`Need forControl
`
`
`Script Detection
`
`Complete
`
`Need for Control
`
`Script Detection
`Complete
`
`
`
`FIG. 6C
`
`FIG. 6D
`
`6
`
`

`

`US. Patent
`
`Scp. 12, 2000
`
`
`Sheet 6 0f 6
`
`6,117,187
`
`
`Select a Fileset R
`
`
`1005
`
`
`
`
`1010
`\ SelectaScriptType 4—H
`
`1
`
`"”L
`
`'
`Select a Control Action 4“
`
`outine for
`
`
`
`No
`
`
`Control Action for Script
`T pe Exists?
`
`
`
`
`Retrieve Relevant
`Parameters using Routine ;
`
`
`
`
`Select Script
`Fragment Template
`
`
`y’
`
`
`
`$030
`
`
`
`Output 0
`@ript Fragment TemW
`Exist?
`060
`Yes 1
`
`Open Script File /
`
`
`1 065
`
`1070
`
`l
`
`
`Write Preamble, Output, & /
`Postamble into Script File
`
`Close Script File
`
`
`
`
`
`No
`
`i No
`
`FIG. 7
`
`Yes
`
`9
`'
`\More Frlesets.
`\<1080
`
`No
`
`1085
`
`‘
`
`7
`
`Control Script
`Generation Complete
`
`
`
`
`
`Y
`
`
`
`
`Insert Parameters into Script
`Fragment Template
`
`A
`
`1040
`Call Script Fragment /
`Template
`7 4%
`1 045
`‘_/
`Collect Output of Script‘
`Fragment Template
`
`
`
`
`1050
`
`1055
`{
`
`
`
`7
`
`

`

`6,117,187
`
`1
`AUTOMATIC GENERATION OF A
`SOFTWARE INSTALLATION PACKAGE
`
`BACKGROUND OF THE INVENTION
`
`1. Field of the Invention
`
`10
`
`15
`
`The present invention relates generally to computer sys-
`tems and more particularly to a method of automatically
`generating a software installation package that can be used
`to install an application program in a user’s computer
`system.
`2. Description of the Related Art
`There has been a continuing need for a simple and easy
`way to install an application program in a user’s computer
`system. At one time this was done manually. The user would
`obtain an application program,
`typically on diskettes or
`other magnetic media, and would manually copy the appli-
`cation files from the magnetic media into one or more
`directories in the user’s computer system. After this was
`done, the user would manually configure the application. As '
`applications acquired more capabilities and grew corre-
`spondingly more complex, this installation process became
`a time-consuming and error-prone ordeal that often ended in
`an inoperative system and extreme frustration on the part of
`the user.
`
`25
`
`Software publishers have devoted much effort to finding
`a way to make it easier for users to install application
`programs. These efforts have led to the development of
`installation packages that take over the installation process
`from the user. Such installation packages have been per-
`fected to the point that now they can install an application
`program almost completely automatically, ensuring that the
`application will work as desired and relieving the user of this
`burdensome chore.
`
`Creating an installation package that can reliably install
`an application program is not a trivial task. The installation
`package must include all the files of the application program,
`and these files must be properly configured for the target
`computer system.
`In addition,
`the installation package
`includes other materials such as data files, scripts, execut-
`able programs, or the like. These materials operate more or
`less automatically to carry out the installation of the appli—
`cation program files. Depending on the operating system and
`other characteristics of the computer system in which the
`application is to be installed, creating a new installation
`package generally requires creating some or all of such
`materials anew, and this in turn may involve such tasks as
`writing a new program or creating a complicated data file.
`The burden of creating these materials falls on the software
`engineer, who must devote many hours of meticulous effort
`to this task.
`
`Software tools that can create portions of installation
`packages are known. However, such tools do not relieve the
`software engineer of the considerable effort of creating the
`complete package. For example, one such tool requires the
`software engineer to manually create an arcane and com-
`plicated configuration file specifying many of the details of
`the installation.
`
`A mass-marketed application program may sell hundreds
`of thousands of copies and thereby generate sufficient rev-
`enue to justify the extensive effort required to produce a
`good installation package. But many applications, especially
`those created for use by engineers and others who use
`computer workstations in environments such as the UNIX®
`operating system are distributed singly or in only a few
`copies (UNIX is a registered trademark in the United States
`
`30
`
`35
`
`40
`
`45
`
`50
`
`55
`
`60
`
`65
`
`2
`and other countries licensed exclusively through X/Open
`Company, Ltd.). It has not been economically justifiable to
`spend the time necessary to develop good installation pack—
`ages for such applications. The result has been either that
`effort is expended out of all proportion to the value of the
`application, or that the installation package does not get
`developed at all, or that an inadequate package is prepared.
`None of these outcomes is satisfactory.
`One part of developing an installation procedure for a new
`application is determining which files to install and where in
`a target computer system to install them. A script has been
`developed that attempts to do this by (1) saving a list of all
`files in the system prior
`to installation of the new
`application, (2) saving preselected configuration files prior
`to installation, (3) installing the new application, (4) saving
`a list of all files in the system after the installation, (5) saving
`the preselected configuration files after installation, and (6)
`comparing to make a list of added files and any configuration
`changes. This script does not account for any files that are
`modified during installation (except the preselected configu-
`ration files). Thus, although the script performs one step in
`the process of creating an installation package, most of the
`work must still be done manually by the software engineer.
`One method was developed to automatically generate
`various parts of the software installation package, saving the
`software engineer a great deal of time and effort. In copend-
`ing US. patent application Ser. No. 08/619,876, now US
`Pat. No. 5,835,777 entitled “Method of Automatically Gen-
`erating a Software Installation Package,” assigned to the
`assignee of the present invention and incorporated herein by
`reference,
`there is described a method for automatically
`generating a manifest that lists all application program files
`which need to be installed, determining needed resources,
`providing installation materials, and generating the installa-
`tion package. The method described requires however, that
`certain steps necessary to generate a software installation
`package be done manually.
`From the foregoing it will be apparent that there is a need
`to automate the steps that are done manually in the method
`described in copending US. patent application Ser. No.
`08/619,876, now US. Pat. No. 5,835,777 in order to further
`reduce software engineering effort and increase efficiency.
`SUMMARY OF THE INVENTION
`
`The present invention provides a method of automatically
`creating a new software installation package that can cor-
`rectly install an application program on a target computer
`system. Using the method of the invention, a software
`engineer can more easily and quickly create the installation
`package than was possible in the past.
`Briefly and in general terms, the method of the invention
`begins with a new application program. The application
`program may have been created by the same engineer who
`wishes to use the method of the invention to create an
`installation package, or it may have been created by others.
`Once the application has been ported to the target computer
`system and debugged so that it is operable on the target
`system,
`the invention is used to generate the installation
`package. This includes the steps of automatically generating
`a manifest that lists all application program files which need
`to be installed on the target system, automatically determin-
`ing which resources are needed by those files, automatically
`generating filesets and subproducts, automatically assigning
`files to the filesets and filesets to the subproducts, automati-
`cally determining a need for control scripts, automatically
`generating the control scripts, and generating the installation
`
`8
`
`

`

`6,117,187
`
`3
`package by combining the listed files, any needed resources,
`the filesets, the subproducts, and the control scripts.
`The step of determining which resources are needed
`preferably includes several substeps. The first substep is
`automatically generating a dependency list of any shared
`libraries referenced by any of the listed application program
`files. The next substep is automatically determining which of
`these shared libraries is already present in a preexisting
`software installation package. Finally, if any shared libraries
`are included in one or more preexisting software installation
`packages, then such preexisting packages are identified as
`needed resources.
`
`The step of automatically detecting the need for control
`scripts also preferably includes several substeps. The first
`substep is automatically detecting the need for an add-new-
`configuration-file control script. The next substep is auto-
`matically detecting the need for an add-new-user control
`script. Athird substep is automatically detecting the need for
`an add-new-group control script. A final substep is auto-
`matically detecting the need for an add-pathname-elements
`control script. Additional substeps may also be included to
`automatically detect the need for additional control scripts
`beyond those listed here.
`Optionally, a cross-reference to any listed shared library
`that is not included in any of said preexisting installation
`packages is also included in the software installation pro-
`gram.
`The new software installation package is typically dis-
`tributed by recording on magnetic media, such as tape or
`diskettes or by imprinting the data in optical media, such as
`CD-rom or DVD. The magnetic or optical media can then be
`reproduced and distributed to users as desired. Alternatively,
`the package may be stored in a central location such as the
`hard disk of a network server so that the application program
`can be installed on any other computer having access to the
`central location.
`
`The step of generating the manifest preferably includes
`saving a new timestamp, installing the application program
`in a testbed computer, and generating a list of all files in the
`testbed computer system having a timestamp more recent
`than the saved timestamp. This will ensure that all necessary
`files are identified. In one embodiment any file of a kind that
`has been previously determined to be spurious is excluded.
`The software engineer may review the list to delete any other
`spurious files that may have crept in. In another embodiment
`only files in certain preselected directory trees are consid-
`ered.
`
`Other aspects and advantages of the invention will
`become apparent from the following detailed description,
`taken in conjunction with the accompanying drawings,
`illustrating by way of example the principles of the inven-
`tion.
`
`BRIEF DESCRIPTION OF THE DRAWINGS
`
`FIG. 1 is a flowchart depicting in general outline the
`method of the invention.
`
`FIG. 2 is a flowchart depicting more details of a preferred
`embodiment of the “generate manifest” block of FIG. 1.
`FIG. 3 is a flowchart depicting more details of a preferred
`embodiment of the “determine needed resources” block of
`FIG. 1.
`
`FIG. 4 is a flowchart depicting more details of a preferred
`embodiment of the “fileset and subproduct generation”
`block of FIG. 1.
`
`FIG. 5 is a flowchart depicting more details of a preferred
`embodiment of the “assignment of files to filesets and
`filesets to subproducts” block of FIG. 1.
`
`4
`FIG. 6A is a flowchart depicting details of a first portion
`of a preferred embodiment of the “detect control scripts”
`block of FIG. 1.
`
`FIG. 6B is a flowchart depicting details of a second
`portion of a preferred embodiment of the “detect control
`scripts” block of FIG. 1.
`FIG. 6C is a flowchart depicting details of a third portion
`of a preferred embodiment of the “detect control scripts”
`block of FIG. 1.
`
`10
`
`FIG. 6D is a flowchart depicting details of a fourth portion
`of a preferred embodiment of the “detect control scripts”
`block of FIG. 1.
`
`15
`
`FIG. 7 is a flowchart depicting more details of a preferred
`embodiment of the “generate control scripts” block of FIG.
`1.
`
`DESCRIPTION OF THE PREFERRED
`EMBODIMENT
`
`As shown in the drawings for purposes of illustration, the
`invention provides a method of automatically creating a new
`software installation package that
`is used to install an
`application program in a target computer. Software engi-
`neers have had to create such installation packages
`manually, a procedure that has required increasingly large
`amounts of effort as application programs have grown larger
`and more complex.
`In accordance with the invention, when a new application
`program has been ported to a target computer system and
`debugged, the method of the invention automatically gen-
`erates a manifest of files, a list of required shared libraries,
`appropriate filesets and subproducts, and necessary control
`scripts. The method of the invention also automatically
`assigns each file to a fileset and assigns each fileset to a
`subproduct. Using this information, an installation package
`is assembled. This method enables the software engineer to
`quickly and easily create an installation package that cor-
`rectly installs even a very large and complex application
`program.
`
`A method of automatically generating a software instal-
`lation package for installing an application program on a
`target computer system according to the principles of the
`invention is depicted in flowchart form in FIG. 1. Initially
`the new application is provided, for example by a software
`engineer or by a team of such engineers (block 100), and is
`ported and debugged (block 200) so that it is operable on a
`target system. This has been satisfactorily done if the soft-
`ware is in such condition that the application program can be
`installed on a testbed computer. For example, in a computer
`system that uses the HP-UX operating system version 9.0,
`distributed by Hewlett-Packard Company, often the appli-
`cation is in satisfactory condition when the “MAKE
`CLEAN”, “MAKE”, and “MAKE INSTALL” commands
`build and install the application properly.
`Starting with software that has been ported and debugged,
`the first step of the invention is to automatically generate a
`manifest that lists all files which must be installed on the
`
`target computer system for the application program to func-
`tion correctly (block 300). The next step is to automatically
`determine which resources referenced by any of the listed
`files are needed on the target computer system for the
`application program to function correctly (block 400). Then,
`filesets and subproducts needed on the target computer
`system for the application program to function correctly are
`automatically generated (block 500).
`
`25
`
`30
`
`35
`
`40
`
`45
`
`50
`
`55
`
`60
`
`65
`
`9
`
`

`

`6,117,187
`
`5
`Filesets and subproducts are part of a hierarch of software
`objects that make rip the applications or operating systems
`on which Software Distributor-Unix (SD-UX) commands
`work. Filesets include all the files an control scripts that
`make up a product. The are the smallest selectable SD-UX
`software object. Subproducts are used to group logically
`related filesets within a product when the product contains
`several filesets.
`
`Following automatic generation of the filesets and
`subproducts, each listed file is automatically assigned to an
`appropriate fileset and each of the filesets is automatically
`assigned to an appropriate subproduct (block 600). The next
`step is automatically detecting a need for certain control
`scripts that are necessary for installation on the target
`computer to function correctly (block 700). A control script,
`sometime known as a macro or batch file,
`is a list of
`commands that can be executed without user interaction. A
`
`10
`
`15
`
`software engineer then views the results of the steps which '
`have already been performed according to the invention and
`provides information regarding any necessary corrections or
`additions to the invention (block 800).
`If the software
`engineer has directed that changes or additions are needed,
`the previous steps (block 200 through block 700) may be
`repeated as necessary. Otherwise, error checking is per—
`formed to ensure the previous steps have functioned prop-
`erly (block 900). Next,
`the control scripts necessary for
`installation on the target computer to function correctly are
`generated (block 1000). The last step is generating an
`installation package by combining the listed application
`program files, any needed resources,
`the filesets,
`the
`subproducts, and the control scripts (block 1100).
`
`25
`
`30
`
`35
`
`6
`In one embodiment the file list is filtered to remove any
`file of a kind which has been predetermined as indicative of
`a spurious file (block 340). This may be done, for example,
`by searching for all files having a certain name or a certain
`character string in their name. Such files may have been
`generated or modified by system daemons. Such filtering
`can be done during the generation of the list, such that the
`unwanted files are never added to the list, or afterwards by
`deleting the unwanted files from the list. Optionally, the
`software engineer then manually reviews the file list to
`remove any other unwanted files (block 350).
`
`In another embodiment, only files in predetermined direc-
`tory trees are checked and, if their timestamps are newer
`than the saved timestamp, are placed on the list (block 360).
`This can shorten the time required to prepare the list if the
`software engineer knows ahead of time which directories
`need not be checked, for example because it is known that
`no new program files will be inserted in such directories.
`
`The step of determining which resources are needed
`(block 400) preferably comprises automatically generating a
`dependency list that lists any shared libraries referenced by
`any of the listed object files, automatically determining
`which of the listed shared libraries are already included in
`one or more preexisting software installation packages, and
`identifying each such preexisting software installation pack-
`age as a needed resource. An example of how these steps
`preferably are carried out is given in FIG. 3. An executable
`file is selected from the manifest (block 410). This file is
`then examined to determine which shared libraries it uses
`
`and a list of these libraries is prepared (block 420). In the
`HP-UX 9.0 environment this is conveniently done by means
`of the “CHATR” command. If there are more executable
`
`The step of generating the installation package typically
`includes recording the listed files and other subject matter on
`media, such as tape, floppy diskettes, CD-rom, and DVD, for
`distribution to a user of the target computer system. These
`files and other subject matter may also be placed in an
`accessible location on a computer system, for example the
`hard disk of a network server, that is in electrical commu—
`nication with the target computer system. The target system
`can run the installation package directly from the server or
`it can download the installation package and then run the
`installation program locally.
`
`FIG. 2 illustrates an example of how to generate the
`manifest. A new timestamp is generated and saved (block
`310). Then the application program is installed in a testbed
`computer system (block 320). In the HP-UX 9.0 environ-
`ment
`this may be done by running the “MAKE” and
`“MAKE INSTALL” commands. Typically the testbed is a
`system similar to the target systems on which the installation
`package will
`later be run. Then all files in the testbed
`computer system having a timestamp more recent than the
`saved timestamp are listed (block 330). In the HP—UX 9.0
`environment this may be done by using the “-NEWERC”
`option with the “FIND” command.
`
`Depending on the operating system, it may be necessary
`to attach the new timestamp to each of the application
`program files prior to installing the application on the
`testbed computer. In the HP-UX 9.0 environment this is not
`necessary because the files will automatically receive new
`timestamps when they are copied during the installation
`process.
`
`40
`
`files the procedure is repeated, once [or each executable file,
`and any shared libraries are added to the list (block 430).
`
`45
`
`50
`
`55
`
`60
`
`65
`
`The list of shared library dependencies is compared with
`those libraries already present in preexisting software instal-
`lation packages (block 440). Alist of any needed preexisting
`software installation packages results from this comparison
`(block 450) and is used in generating the new software
`installation package.
`
`In one embodiment the new software installation package
`also includes a cross-reference to any shared libraries which
`are needed by the new package but which have not been
`found in any preexisting software installation packages
`(block 460).
`
`The step of automatically generating filesets and subprod-
`ucts (block 500) preferably includes the substeps of auto-
`matically comparing each file against a set of fileset rules,
`determining which filesets need to be generated, generating
`the needed filesets, comparing each fileset
`to a set of
`subproduct rules, determining which subproducts need to be
`generated, and generating the necessary subproducts.
`
`One possible set of fileset rules includes the following
`individual rules:
`
`10
`
`10
`
`

`

`6,117,187
`
`{{\.s1$} 3 {-SHLIBS}}
`{{/h'h[ /]*\_[0—9]$} 3 {—smms}}
`{{/include/} 5 {-INC}}
`{{/man/man} 5 {-MAN}}
`{{/man/fr,FR\.i5088591} 0 {-FRE-I-MAN}}
`{{/man/friFR\.roman} 0 {AFREARAMANH
`{{/man/friFR} 0 {-FRE-MAN}}
`{{/1nau/f1-,CA\.i5088591} 0 {-CFR-I-MAN}}
`{{/mau/fI,CA\.roman} 0 {-CFR—R-MAN}}
`{{/man/fr,CA} 0 {-CFR—MAN}}
`{{/help/deiDE\.iso} 0 {-GER-I-HELP}}
`{{/help/deiDE\.rohelp} D {-GER-R-HELP}}
`{{/he1p/de,L)E} 0 {-GER-HELP}}
`{{/msg/C}~ s {-MSG}}
`{{/msg/fi,FR\.isosss91} 0 {-FRE-I-MSG}}
`{{/msg/friFR\.roman} 0 {-FRE-R-MSG}}
`{{/msg/fi,FR} 0 {-FRE—MSG}}
`{{/msg/fr7CA\.is088591} 0 {-CFR—I—MSG}}
`
`{{/man/deiDE\.iso} 0 {-GER-I-MAN}}
`{{/man/de7DF.\.roman} 0 {-GFR-R-MAN}}
`{{/man/deiDE} 0 {-GER—MAN}}
`{{/he1p/C/} 5 {—HELP}}
`{{/help/friFRMisoSSSQl} 0 {-FRE-I—HELP}}
`{{/help/friFR\.rohelp} 0 {AFREARAHELPH
`{{/hc1p/fr,FR} 0 {-FRE-HELP}}
`{{/help/fr,CA\.i5088591} 0 {-CFR-I-HELP}}
`{{/help/friCA\.rohelp} 0 {-CFR-R—HELP}}
`{{/he1p/fr,CA} 0 {-CFR-HELP}}
`{{/msg/friCA\.roman} 0 {-CFR-R-MSG}}
`{{ansg/fLCA} 0 {-CFR-MSG}}
`{{lmsg/deiDELiso} 0 {-GER-I—MSG}}
`{{/msg/deiDE\.roman} 0 {-GER-R-MSG}}
`{{/msg/de,DE} 0 {-GER-MSG}}
`
`Each of these rules is composed of three fields, the regexp,
`threshold and the name of the rule. The regexp is a regular
`expression used to match against filenames. The threshold is
`a minimum number of files which need to match the pattern
`defined by the regexp before the fileset is created. The name
`field, defines a string that is appended to the product name
`to create the fileset name.
`It is understood that these rules serve only as an example
`of the set of fileset rules, and that numerous other forms of
`fileset rules may be substituted for the listed fileset rules.
`Alternatively, the set of fileset rules may include fileset rules
`in addition to the above-listed fileset rules, a subset of the
`above-listed fileset rules, or some combination thereof.
`Similarly, one possible set of subproduct rules includes
`the following individual rules:
`
`{{ [ -]*-MAN$} {Manuals}}
`{{-...-MAN$} {ManualsByLang}}
`{{1...A-.-MAN$} {ManualsByLang}}
`{{ I -]*-HELP$}{He1p}}
`{{-...-HELP$} {HelpByLang}}
`{{Z...h-.-HELP$} {HelpByLang}}
`{{ [ -]*-MSG$} {Messages}}
`{{-...-MSG$} {MessagesByLang}}
`{{-...-.-MSG$} {MessagesByLang}}
`
`{{-RUN$} {Runtime}}
`{{-MIN$} {Runtime}}
`{{-AUX$} {Runtime}}
`{{-SHLIBS$} {Runtime}}
`{{-KRN$} {Runtime}}
`{{-MIN$}
`{MmirnumRuntime}}
`{{-SHLIBS$}
`{MmirnumRuntimeH
`{{-KRN$}
`{MmirnumRuntime}}
`{{-NOTES$} {ReleaseNotes}}
`{{-DEMO$} {Demonstration}}
`{{-PRG$} {Development}}
`{{-INC$} {Development}}
`
`The subproduct rules are composed of two fields, a regexp
`and a subproduct name. In this case the regexp is used to
`match against fileset names. As with the fileset rules, these
`subproduct rules serve as an example of possible subproduct
`rules and numerous other subproduct rules may be substi-
`tuted for these subproduct rules. Alternatively, the set of
`subproduct rules may include subproduct rules in addition to
`the above-listed subproduct rules, a subset of the above-
`listed subproduct rules, or some combination thereof.
`An example of how these steps preferably are carried out
`is given in FIG. 4. First, a file is selected from the manifest
`(block 505). The fileset rules for the file are then scanned for
`a first match (block 510). If a first match does exists (block
`515) and thc filcsct defined by the first match does not
`already exist (block 520) then the fileset defined by the first
`match is generated (block 525). Otherwise, the step of fileset
`generation (block 525) is bypassed. The next step is then to
`
`check if the manifest contains files which have not yet been
`checked (block 530). If it does, then the steps above (blocks
`505 to 530) are repeated until the entire manifest has been
`checked.
`In a similar fashion, a fileset is selected (block 535) from
`a list of all the filesets which were generated (block 525).
`The subproduct rules for the fileset are then scanned for a
`first match (block 540). If a first match exists (block 545)
`and the subproduct defined by the first match does not
`already exist (block 550) then the subproduct defined by the
`first match is generated (block 555). Otherwise, the step of
`subproduct generation (block 555) is bypassed. The next
`step is then to check for other filesets that have not yet been
`checked (block 560). If there are more filesets, then the steps
`above (blocks 535 to 560) are repeated until all the filesets
`have been checked. Once this has been completed, fileset
`and subproduct generation is complete (block 565).
`Once the filesets and subproducts are generated, the next
`step is automatically assigning files to filesets and filesets to
`subproducts (block 600). An example of how this step is
`preferably accomplished is depicted in FIG. 5. First, a file
`from the manifest is selected (block