SUMMARY Distributing large software packages presents many challenges. The process of controlling software versions, building installation packages from multiple components, and customizing them to run in multiple target environments requires specialized knowledge. In-house development teams need to focus on creating and updating their companies’ products, and therefore organizations are increasingly using the services of consultants to assist in packaging their software for distribution. The UmbrellaX methodology combines professional skills and sophisticated proprietary tools - built up over multiple cycles of software releases for several large organizations. By using the UmbrellaX approach, our clients enjoy the following advantages: • Access to specialized skills and experience in the field of software package management, without having to employ additional in-house technical resources • Minimum involvement of software staff, who can therefore concentrate on product development • The UmbrellaX service includes use of the UmbrellaX Self-Extractor, BootStrapper and PatchCreator tools which the user could not normally develop himself. These tools include many features directly developed to meet the build and installation environments and allow extensive build-time and install-time customization.
ADVANTAGES OF THE UMBRELLAX APPROACH
The UmbrellaX tools provide just the right mix of automation and accessibility, so that the UmbrellaX Consultant can work with the software vendor’s development team, gather the required information and create a build environment that will run quickly and efficiently.
WHAT IS THE PROBLEM?
Building an installation package involves many skills – deciding what software to use to build the package, ensuring that you cover all possible target environments, integrating all the correct components (and replacing them when bugs are found!), being able to add in required 3rd-party packages where required, and being able to monitor the deployment process
• What installation builder are you going to use?
There is a bewildering array of products.
They have long lists of ‘advantages’ and ‘benefits’ – some of them contradictory, like ‘Full scripting support’ and ‘No scripting required’! The simpler offerings often don’t have the features your software build requires, while the more powerful products need high levels of skill and specific experience, which you may not have in-house.
(Look at http://en.wikipedia.org/wiki/List_of_installation_software for a list!)
Several of the packages also require that you maintain a license for using them – thus tying you to long term costs, and limiting your ability to switch to other suppliers, or to mix-and match to suit your requirements.
• The build package is very large and complex
You have to cater for multiple target environments, with each supporting all the options or variations that your software needs to cover. Most software builders process in the background and are not transparent, so you cannot see what is happening during the build process.
• You have to do the whole process multiple times
For each time your QA process finds a bug in the package, the build process has to be started again. Keeping track of what components must be included each time can be very difficult. And then you have to QA the resulting build again – which may uncover new problems, meaning another cycle!
• . . . and then you need ‘just one more change’
When your package is out in the field, there are always the ‘hot fixes’ that you need urgently, and that have to be delivered before your next major release – like an integration of a new piece of equipment that one client needs or a special feature that has only been QC’d for one customer but will be issued to everyone later. So you want to issue a patch, but you need to make sure that all the affected files are included!
Three specialized tools have been developed:
The UmbrellaX SelfExtractor is a C++ application which sets up the installation/deployment process. It allows the user to specify an input folder path and output filename, and provides an interface so that the user can monitor the installation process and input command line parameters for the target application.
The UmbrellaX BootStrapper tool uses a configurable XML file to run the installation process. The file contains variable information such as the Product Name and Version of the target application, lists of all valid upgrade paths, definition of package variations to be covered during the install process (such as preparing multiple target versions with different feature sets and different branding), Prerequisites, (both required and conditional), lists of features offered (in each version, and in what sequence they are to be presented), cross-dependencies depending on versions and target environments, patches to be included, and external name parameters such as Windows IIS sitename and app name and the SQL instance name which are to be assigned during the installation process.
The UmbrellaX BootStrapper supports full MSI error detection and logging. The need for pending reboots is tracked through the process. If required, the BootStrapper can run the full IIS and SQL installation and configuration processes. It has full OS and Registry query capability, for handling environment variables such as machine type (32/64 bit and OS variations).
The BootStrapper uses its full MSI, SGL and File queries to control the installation process and make run-time decisions of whether to run or skip individual steps.
The BootStrapper gives the user the ability to install the application in either full-UI mode, where the user supplies all parameters, or silent installation mode, where the parameters are entered via the command line.
The UmbrellaX PatchCreator automates the entire process of building a patch file. Developers don’t have to ‘remember’ which files they changed, and the build team does not have to worry about ‘forgetting’ to include a particular file. PatchCreator goes through the complete build, isolates only those components that have changed since the previous build, and creates a patch file. Identification of changed components is at binary level, and does not rely on manually-created file lists, creation dates or version numbers.
• UmbrellaX supplies the software vendor the SelfExtractor, BootStrapper and PatchCreator packages.
• Software vendor creates a single folder containing the following (for example):
o Subfolders with each of the application modules that must be included
o Subfolder with separate GUI files
o Prerequisites folder with all required external (3rd-party) modules (can be divided into required and conditional subgroups)
o Subfolder for SQL Server module
o User patches to be installed (will only be installed after execution of the installation, depending on the features the end-user requires)
• The UmbrellaX consultant prepares the set of BootStrapper files which the Software Vendor places in the same folder.
• Software vendor runs Self-Extractor to consolidate and compress the files, producing a single .exe (‘Installer’) which is supplied to the end user.
• End user runs the Installer, which decompresses the files.
o The Installer checks whether .NET is installed and if necessary, installs it, and then loads the BootStrapper
o The BootStrapper then queries the OS, Registry, Files, and its own XML files in order to “decide” which unconditional pre-requisites / Features / Patches can be installed.
o The necessary dialogs are presented, depending on the End-user’s required configuration (or the process can be controlled through the Command Line).
o The BootStrapper executes the conditional pre-requisites / and selected Features
o BootStrapper adds the required patches
o BootStrapper gives the option of executing the application at the end of the sequence. During the entire sequence, BootStrapper will:
- Keep full log of its actions and decisions
- Monitor and control pending reboots, and reboot the machine if needed
- Execute the various MSI files
• PatchCreator can take the new build, compare with a previous one, extract only the changed files, and build a patch file.