ActivePatch

Overview | Pricing & Licensing | Evals & Downloads | Compatibility | Publisher Details | Reviews | Support Forum | Summary

Conserve bandwidth and speed update time for your applications. ActivePatch software development toolkit enables your application to reduce the size of updated files as much as 90%, significantly reducing network load and file download time. Use it to provide automatic updates for your software over the Internet, distribute modified databases over a corporate WAN, or reduce the storage requirements for archived files. ActivePatch does not depend on external tools or complicated batch files and proprietary scripting languages.

Our regular prices are shown below. Please logon to see your discounted prices.

ActivePatch V1.2 SP1

Our prices include ComponentSource technical support and, for most downloadable products, an online backup and a FREE upgrade to the new version if it is released within 30 days of your purchase.  All sales are made on our standard Terms and Conditions and subject to our Return Policy. Please contact us if you require any licensing option not listed above including volume licensing and previous versions.

Our regular prices are shown above. Please logon to see your discounted prices.

New in Version 1.2:

• Modified patch generation and compression routines to reduce the overall size of patch files and packages. Implemented a new patch file format which reduces overhead for patches that contain a large number of change records. Existing patch files and packages can be used by the current version, but previous versions of the product will not be able to read the new format
• Corrected a problem where package options were not propagated to individual patch files created when building a package. This could potentially cause the application of a package to fail because the correct options were not being specified at the time the patch was being applied
• Corrected a problem where the Options property in the Package control was not being updated when a package was opened, and setting the property only worked when creating new packages. When a package is opened, the Options property is now set to that package's current options. Setting the property while a package is open will change the options for that package. Setting the property when there is no open package will change the default options used when a package is created
• The CreatePatchFile, CreatePackage and SetPackageOptions functions will now ignore the PACKAGE_OPTION_NOUPDATE option if it is specified. This option is only valid when applying a patch file or package
• Corrected a problem where PACKAGE_OPTION_NOUPDATE would indicate that the specific package could be applied successfully, but would fail when actually applied. This option now provides more extensive validation of the package and the patches that it contains
• Corrected a problem where the compression ratio for a patch file would be returned as a very large number. This affected both the values returned in the PATCH_FILE_INFORMATION structure as well as the Compression property for the PackageFile object
• Corrected a problem where temporary files could be left in the installation or system temporary directory when the application process failed or was canceled
• Corrected a problem where an error would be returned when attempting to access certain properties of the control in a scripting environment, such as the Windows Scripting Host
• The error AP_ERROR_INVALID_PATCH_LEVEL is returned if an invalid patch level is specified when creating a patch file. Patch levels must be between 1 and 9, defined as PATCH_LEVEL_MINIMUM and PATCH_LEVEL_MAXIMUM. Patch level 0 is a special value which specifies a default patch level that has the best balance between patch size and patch generation speed. This patch level is defined as PATCH_LEVEL_DEFAULT and corresponds to patch level 4
• Updated Developer's Guide, Technical Reference online help and product samples

New in Version 1.1:

• Corrects a problem with progress events not firing correctly, under some circumstances, or the percentage values being incorrect as a package is created or applied
• Corrects a problem with locked files on Windows 95/98, where in some cases the files would not be replaced after the system was restarted
• Corrects a problem where a locked file could cause the library or control to search for another matching file on the local system (as if the locked file did not exist)
• Adds three new methods to the Package control. Open, which explicitly opens a package (rather than using the side-effect of setting the FileName and Password properties, although this can still be done); Close which explicitly closes a package; Flush which forces any changes to the package to be written to disk
• Adds a new property to the Package control called Applied; if this value is zero, the package has not been applied on the local system; if the value is non-zero, the package has been applied and the actual value specifies one or more bitfields (1=completed, 2=delayed). This allows your application to determine if any of the updates were delayed because a file was locked. The code would look like this:

    If Package1.Applied And apApplyDelayed Then
        MsgBox "You must restart you system ...", vbInformation
    End If

• The ApplyPackage syntax has been updated in the DLL so that the reserved parameter is now a pointer to an unsigned long integer which contains status bits that provide information about the package application; this is backwards compatible as long as developers followed the documentation and only specified a value of 0 for the reserved parameter
• The PACKAGE_OPTION_NOUPDATE and PATCH_OPTION_NOUPDATE option flags have been added for the ApplyPackage and ApplyPatchFile functions respectively. This allows an application to test the package or patch apply process without modifying any files on the target system.  In the case of packages, it can be combined with the apply status to determine if applying a package would potentially require the user to reboot the system
• The PACKAGE_OPTION_IGNORE_MODIFIED option flag has been added for the ApplyPackage function. This specifies that ApplyPackage should not return an error if it determines that a target file has been modified. Instead, it ignores the file and processes the next update in the package. This option should be used with caution, since it explicitly bypasses the an integrity check that makes sure that each target file is identical to the original version of the file at the time that the package was created. Inappropriate use of this flag can potentially leave a target system in a "half-patched" state
• A new FlushPackage function has been added which corresponds to the control's Flush method
• A new error code AP_ERROR_FILE_LOCKED has been added which is more explicit than the more general access denied error; a problem where the AP_ERROR_FILE_NOT_FOUND error may be returned for a locked file has also been corrected
  

The ActivePatch API is designed to be simple enough to easily integrate into existing products, as well as offer a great degree of power and flexibility. ActivePatch comes with sample programs written in Visual Basic and C++, and includes utilities that simplify the creation and application of patches.

Using ActivePatch has a number of important advantages over the common methods of software re-packaging or incremental updates:

Reduces the size of an update

ActivePatch analyzes the original and updated file at the byte level, generating the smallest size patch file required to perform the update. This results in a significant reduction in the size of the patch, which translates into lower bandwidth usage, shorter download times and increased reliability.

Faster update creation and distribution

Unlike re-packaging or creating incremental updates, generating a patch does not require the developer to create another program or modify an existing script (such as an InstallShield installation script) for each update that is released.

Improved technical support and customer satisfaction

With the ability to easily generate patches for updated software, there is no reason to keep customers waiting for the next version. Your customers always have the latest version of your software, reducing the number of technical support issues for those defects, which have already been corrected.

Lowered media and distribution costs

The ability to distribute a small patch, rather than re-packaging the complete product, can significantly reduce the costs associated with creating and shipping media. In addition, the smaller size of the patch files means bandwidth savings when making the update available for download.

Complete integration with the application

The ActivePatch SDK allows the developer to fully integrate the patching process within the application. This provides the flexibility to implement custom user interfaces, specialized processing on updated files or any other customization required during the patching process or after the patch has been applied.

Safety and security

The patching process is designed to be completely safe, committing the update only if no problems are encountered during the process. The original and updated file version, checksum and digital signature (if any) are checked to ensure that the file was patched correctly. A patch may be encrypted so that a password is required before it can be applied. Because a patch consists only of the changes to a file, it requires that the user actually have the software installed on their system, and can help protect against illegal distributions of updates for your software.

ACTIVEPATCH FEATURES

ActivePatch provides a comprehensive solution for the generation and application of product updates and upgrades. The following are some of the key features of ActivePatch:

Support for all file types

Patches are generated by analyzing the original and updated file at the byte level and will work on all file types including text files, binary data files, and executable programs.

Optimal patch file generation

The patch generation algorithm is adaptive, selecting the optimal method for creating the patch based on the contents of the file and the extent of the changes between the original and updated versions of the file. The developer has the option to generate smaller patches at the expense of speed and memory usage, or minimize memory usage during patch generation at the expense of the patch size.

Fast patch file application

The patch application algorithm is designed for speed, and minimal memory and CPU utilization on the target platform.

Update multiple files and directories.

Create patch packages that can be used to update multiple files at once. Directories can be recursively scanned, producing a list of files that have been added, deleted and modified from the original distribution.

Safe error recovery

A patch is only applied when it has been determined that all updated files have been patched successfully and have passed all validation checks. The patch application process calculates and verifies CRC checksums for each file, compares file version information, and validates any AuthentiCode digital signatures present in object modules. File deletions may be sent to the Windows recycle bin for easy recovery by the user.

Automatic file backup and logging

Backup copies of the files modified during the patching process can be created, allowing the patch to be rolled back if needed. Activity during the patch application process is automatically logged in a human-readable text format.

Support for file attributes and permissions

After the patch process has completed, the file's timestamp, attributes and permissions are updated to match the new version of the file. The developer can choose to ignore these values if required.

Support for shared files

A file can be marked as shared and if it is currently in use, it will be replaced after the next system reboot. If a shared file is added or removed from the system, the file's reference count in the registry will be updated accordingly.

Support for ActiveX components

When a self-registering ActiveX component is updated, it can be automatically registered after the patching process has completed.

Support for executable programs

After the patching process has completed, a designated program or script can be executed along with any required command line arguments.