New! View global litigation for patent families

US20080201705A1 - Apparatus and method for generating a software dependency map - Google Patents

Apparatus and method for generating a software dependency map Download PDF

Info

Publication number
US20080201705A1
US20080201705A1 US11862987 US86298707A US2008201705A1 US 20080201705 A1 US20080201705 A1 US 20080201705A1 US 11862987 US11862987 US 11862987 US 86298707 A US86298707 A US 86298707A US 2008201705 A1 US2008201705 A1 US 2008201705A1
Authority
US
Grant status
Application
Patent type
Prior art keywords
software
installation
dependency
route
map
Prior art date
Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
Abandoned
Application number
US11862987
Inventor
Michael J. Wookey
Current Assignee (The listed assignees may be inaccurate. Google has not performed a legal analysis and makes no representation or warranty as to the accuracy of the list.)
Sun Microsystems Inc
Original Assignee
Sun Microsystems Inc
Priority date (The priority date is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the date listed.)
Filing date
Publication date

Links

Images

Classifications

    • G06F8/658

Abstract

A system and method for generating a software installation map, also referred to as a dependency map, that involves receiving a first software package comprising at least a first software file and a second software file. The first software file is dependent on the second software file. The method further involves generating a first software element representing the first software file and generating a second software element representing the second software file. The method involves generating a first dependency pointer representing the dependency between the first software file and the second software file. Finally, the software elements are provided in an installation map, and the process repeats for each software file in the first software package.

Description

    CROSS-REFERENCE TO RELATED APPLICATIONS
  • [0001]
    The present application is a non-provisional application claiming priority under 35 U.S.C. § 119(e) to co-pending provisional patent application 60/890,171 titled “System and Method for Deploying and Managing Software”, filed on Feb. 15, 2007, which is hereby incorporated by reference herein.
  • FIELD OF THE INVENTION
  • [0002]
    This invention relates, in general, to software deployment, and more particularly to the installation of enterprise-wide software applications based on customer-preferred installation parameters.
  • BACKGROUND
  • [0003]
    In order to run a software application on a computer, it usually requires the execution of an installation program to install the software onto the computer's hard drive or other storage medium. Depending on the size and complexity of the software, the installation program can be quite complicated. An installation program typically manages the installation of multiple files to one or more directories within a file system of the storage medium. Often, existing configuration files are edited in order for the computer's operating system to become aware of the new software. Further, some of the edited configuration files are accessed by other applications. Such changes to a computer's environment may cause problems, such that a newly installed application may not work correctly, or possibly worse, a previously installed application may begin to malfunction. Such problems become a much larger concern when an application is installed on numerous computers across an entire company, sometimes referred to as an enterprise computing environment.
  • [0004]
    Due to such problems, the deployment and installation of software applications in an enterprise computing environment is a major challenge for the software industry. A significant percentage of all software installations fail in some manner. A software installation failure can be defined as some type of error that exists after the installation of the software. Errors can exist in both the newly installed application as well as in some previously installed application. Such errors include installation time errors, run time errors, performance errors and compatibility errors. An installation time error occurs during the installation of the software itself. Installation errors may result from an incorrectly linked software component, which would have been defined by an actual human, poorly written computer code that has not considered the current configuration of the client system or number of other scenarios. Such an error may prevent the software application from being installed successfully. In such examples, only a portion of the required files are installed, resulting in a partial installation which is incapable of running correctly. Efforts are then required to back out the partial installation to return the computer back to its previous state.
  • [0005]
    The next type of installation failure is known as a run time error. A run time error is an error that occurs during execution of the software, but often occurs while initially launching the application. One type of run time error may result in a failure to launch the software, with no warning or error messages stating the problem. In result, nothing happens when the software is attempted to execute. Often times one or more cryptic error or warning messages are displayed as to why the application has failed to launch correctly. Other types of run time errors may occur while using the application. Under various scenarios, such as an incorrect version of some software component in the client system, the application may simply stop working during execution of one or more features within the software.
  • [0006]
    Performance errors reflect problems that allow the application to load and run successfully, but at some reduced level of performance. For example, in a typical installation of Apache Software Foundation™ Apache 5.5 Web Server (hereinafter “Apache 5.5”), the software's ability to resolve one page of Hyper Text Markup Language (hereinafter “HTML”) code and display the output on a webpage may take 5 milliseconds. In a performance hindered installation of Apache 5.5, resolving and displaying a web page may take a full second, causing a drastic reduction in Internet browsing performance.
  • [0007]
    The last type of installation error involves compatibility problems with other applications. Compatibility problems may allow the newly installed application to run properly, but one or more previously installed applications may fail to work correctly after the new installation. Such errors are often the result from a common file or group of files shared between multiple software applications. For example, the parameters in a given configuration file may be accessed by one or more applications. Such a configuration file may contain parameters required by the software. A newly installed application may alter the parameters in such a way that a previously installed application may be expecting certain parameters to have remained unchanged. In another example, one or more software applications may depend upon the existence of a software service that resides on a computer. For example, many applications require TCP/IP connectivity services, which is the standard communication protocol used by computers to communicate over the Internet. Installation of a new application may replace TCP/IP version 6.2 with 7.0. However, previously installed applications may be incompatible with TCP/IP version 7.0, causing the existing applications to experience errors.
  • [0008]
    The reasons for such software installation errors vary. Some errors are the result of the installation tools that install software onto a computer. Normally, software is delivered to users as a compact disc (“CD”) or digital versatile disc (“DVD”) or other form of removable storage media. A user would place the disk into the computer's optical drive and follow the instructions for installation. These instructions are human defined tools that physically install the files onto a storage medium. The tools are prone to errors during installation for a variety of reasons. Installation errors may also result from the way software applications are constructed and packaged, rather than the installation tools that apply the software onto a computer system. Installation tools are human created, which allows for the possibility of human-generated errors. The packaging and construction of software are also defined by humans. As a result, the packaging of software may be prone to installation errors as well.
  • [0009]
    Software is normally constructed of multiple packages. Each package usually has one or more pieces of functionality within the entire software application. Each piece of functionality will further contain numerous individual files containing software code. An individual software file comes in the form of differing types of functionality. For example, a software file could be a shared library file, configuration file, executable file, etc. A shared library is a human understandable listing of variables, functions or procedures that define how certain functions of a software application work. It would also be accessible by one or more other files, hence the reason it is called a “shared” library. A configuration file may also be in human understandable language. Its function is to define variables that are used throughout the software application. For example, one entry in a configuration file might specify that the default installation path for the software is /bin/usr/apps. This variable could be changed by editing the file at any time. An executable file differs in that it is not readily understandable by humans. The executable file is a compilation of one or more files, containing software code, that have been compiled to create a binary file understandable to a computer directly.
  • [0010]
    In an example of the delineation of functionality between software packages, an accounting application may contain a package that controls accounts receivable. Another package may control the functionality for accounts payable. Such package-based presentation of a software application is the result of the way software applications are written. Software packages are usually written by numerous software programmers. In order to manage the efforts of each programmer, their tasks are divided into small pieces of functionality where each functional piece can communicate with each other. The division of such functional pieces often results in packages. For example, a software application may comprise 57 packages, with each package comprising hundreds of individual files. One group of software programmers might be tasked with writing the accounts receivable portion and its associated files, with another group responsible for the accounts payable portion and its associated files. Knowing how to divide the functionality between each software package is as much an art as it is computer science.
  • [0011]
    The division of functionality between packages is the result of compromises. On one side, the more packages that an application comprises, the greater the ability to divide functionality between each package, resulting in a more compact and compartmentalized design. For example, if a software application contains 20 packages, the amount of functionality required in each package is far more than if the same application had 200 packages. On the other side of the compromise, the smaller the number of packages, the easier it is for a system administrator to grasp the division of functionality. Typically, a system administrator is the person or persons within an enterprise that is responsible for installing and maintaining software applications in the enterprise environment. When installing a software application comprised of individual packages the administrator executes an initial installation script that begins the installation process. Depending on the specific software application and its complexity, an installation script may pose one or more questions to the administrator. Such questions might involve where to physically install the software within the computer's file system, what optional features or services are desired, or the privilege level for installing the software. Conventionally, the software installation process is script driven. Installation scripts set forth the above types of questions and record the answers for later use during the installation. For example, if a script asks where to install an application, the provided answer would then be used during installation to install the application in the desired location in the file system.
  • [0012]
    One way that an administrator is able to reduce the amount of interaction required during an installation is to modify the installation scripts to remove the questions and enter the answers directly into the script. Hence, when the installation script is executed, no questions are asked, as the answers are already provided.
  • [0013]
    Along with the compromises mentioned above, there are additional problems which continue to escalate over the life cycle of a typical application. These problems are mostly centered on a concept sometimes referred to as “software drift.” Once a software application and its division of functionality between packages is defined, it becomes familiar to the system administrators who install and maintain the application. If the division of functionality between packages changes in the future (i.e., it “drifts”) whether from the fixing of software bugs, functionality improvements or additions, etc., this may cause difficulty for the system administrators who were already familiar with the previous delineation of packages. Hence, software drift can create a growing conflict between the needs of the administrators and the preferences of the software developers as versions of a software application incrementally change. For example, when a software application is originally created, the original definition of the individual packages within the application likely involved a compromise between the functional interaction between the individual files that make up the package and something comprehendible by system administrators. However, as software versions increase, it is likely that the delineation between the packages will change which in turn increases the complexity of the installation as well as the potential for various installation errors.
  • [0014]
    To address these problems, packaging formats for software are continually evolving. However, each change tends to represent minor or incremental improvements over the prior approach that only address the results of the inherent problems rather than the inherent problems of software packaging. Much of the hesitation to change how software is packaged is due to the unwillingness of software vendors to change the way software development projects are designed. A software application is a self-contained entity that can be delivered on a CD/DVD-Rom. Rarely would this application have any relationships to any other software application. This is one of the major problems with the current method for software packaging. All of the decisions and software dependencies are made at the time of the software creation. Hence, the developers are aware of the various computing system configurations and generally attempt to account for them, but they know little about the uniqueness of the particular computing systems the software is installed on.
  • [0015]
    There are a number of software packaging formats in use today, many of which date back to the 1980s when the current problems of software packaging originated. FIG. 1 is a block diagram illustrating the general components in a conventional computer software package. There are five major components to a basic software application 100. The core software inventory 110 is the main component that contains the actual files of the software application 100. These files are organized into packages. The core software inventory 110 is the eventual compilation of bits to be installed onto a computing system. One or more of these files are often stored in a compressed format.
  • [0016]
    Functional relationships with other packages 120 are the second major component of a basic software application 100. A functional relationship is a requirement, by the software to be installed, that something else must exist before installation of the software application to run properly. For example, a functional relationship may require that an additional software application or service be installed before the new software application can be installed. In order to install Apache 5.5, for example, TCP/IP services should be installed on the system. In other examples, a functional relationship may require that certain services be installed concurrently with the software to be installed, or that certain software or services not be present on the computing system due to incompatibilities between certain software applications and services.
  • [0017]
    Finally, in yet another example, a functional relationship may require that one or more software applications or services be de-installed before installation of the new software because the new software may replace one or more packages.
  • [0018]
    The package manifest 130 is the third component in the basic software package 100. The package manifest 130 involves a list of all of the files with the packages that make up the basic software application 100. Thus, the manifest lists all of the files in the core software inventory 110. The manifest is often used for validation purposes in order to confirm that each and every file required for installation is accounted for within the software inventory core.
  • [0019]
    A pre-installation script 140 is the next component in the basic software package 100. This script describes what needs to be validated prior to the installation of a software application. Generally speaking, a script is a software file that sequentially lists steps that are to be executed. For example, a script may list steps for creating a new directory, moving files into it from another location, validating the size of the files as being within a threshold range and sending an email if the files are outside the threshold range. There are numerous scripting languages that exist for writing scripts, such as: perl, python, tcl, etc. As mentioned above, there can often be numerous dependencies that exist between the software to be installed and other software or services that may be needed, etc. Other validation requirements may be included in a pre-installation script 140 aside from dependencies. For example, the pre-installation script may look to determine if there is enough disk space to install the software application. Another example is whether there is enough memory available to run the application effectively. Further, the pre-installation scripts may also serve the purpose of asking a system administrator questions regarding the installation. Examples of such questions were discussed above.
  • [0020]
    A post-installation script 150 is the final component in the basic software package 100. Similar to the pre-installation script mentioned above, the post-installation script 150 describes what needs to be performed after installation of the software application 100 has been completed. An example of such a script entry may be that the computing system needs to be rebooted in order for new startup processes to be loaded or old ones to be deleted. In another embodiment, the post-installation script 150 may require de-fragmentation of the hard drive, depending on the nature of the installation and where the files are store on the hard drive.
  • [0021]
    FIG. 2 is a block diagram that illustrates the functional relationships between the packages that comprise Software Application A. Software application A (200) comprises packages 1-5 (210-250). Each package encapsulates a group of one or more functions required to install the application. Coming out of each package are a number of straight lines connected to other packages. These lines 205 illustrate the functional relationships that exist between packages. For example, package 1 (210) has an interrelationship with packages 2 (220), 3 (230) and 5 (250). Hence, it is not possible to install package 1 (210) without the inclusion of packages 2, 3 and 5 as each of these packages interrelate to one another. For example, package 1 may provide the function of accounts receivable within an accounting software application. Since accounts payable (e.g., package 2 (220)) is an essential part of the software application, it would not be possible to install package 1 without also installing package 2. Further, package 2 (220) also has a functional relationship 205 to other packages. Packages 3, 4 and 5 (230, 240 and 250) also have functional relationships 205 to other packages. In this example, there are only five packages, which are quite manageable for a system administrator. However, if those five packages are extracted down to the granular level (not shown for simplicity), there may be thousands of files with thousands of functional relationships between the files. A typical system administrator would be greatly challenged to comprehend the hierarchy and functional relationships of so many files.
  • [0022]
    Much of the recent development of software packaging has focused on improvements in three core components of the basic software package, namely functional relationships on external application, pre-installation and post-installation scripts. Software vendors are putting forth much effort on making improvements to the pre-installation and post-installation scripts and their descriptions. One of the original challenges to software vendors was that these scripts were not well validated and could not adjust to specific installation needs. One attempt at addressing this challenge is by writing scripts with meta languages, such as XML. This may allow for a more syntactical runtime verification of these scripts. An example of such XML-based install scripts is the Debian packaging format used by many recent versions of the Linux™ operating system.
  • [0023]
    Management and validation of functional relationships is the other core component where much effort is being placed on improvements to the basic software application. The generation of functional relationships are human defined. This means that software developers have to determine which functional relationships are required before installation of a software application. As such, the creation of functional relationship within software is prone to human errors since they are artificially created during development and do not necessarily correspond to the unique functional relationships that may occur during installation. In other words, conventional functional relationship creation occurs at a point in time before the installation of a software application. Hence, these functional relationship are generic in that they exist for all computing system configurations without any ability to change depending on the uniqueness of each computing system environment. Another problem that can exist from the human declaration of functional relationships are circular relationships between individual software files that cannot be resolved because the relationships are created based on artificial constraints. A circular relationship occurs when two software files or functional blocks of software code are both declared to relate to each other. As a solution, developers are creating automated validators that help define functional relationships. Such validators can then be used validate the functional relationships in a software package.
  • [0024]
    As described above, there are inherent problems with the way that software is conventionally packaged and installed on computing systems today.
  • SUMMARY
  • [0025]
    Aspects of the present invention provide a novel approach to packaging and installing software. In order to streamline the software installation process, system administrators should be provided the opportunity to install the minimal components and features they need. With conventional packaging techniques, this ability is strained. Conventionally, software applications are divided into distinct packages of functionality. Each package usually includes more functionality than is needed for a custom installation. However, there is limited ability to pick and choose the functions desired. As a result, installed software applications often include more functionality than desired. As such, additional disk space and other finite computing resources are wasted. Further, system administrators often resort to manual deletion of unneeded functionality which can further reduce the stability of their systems. Other problems with conventional software packaging and installation techniques result in many failed installations. Installations may fail in a number of ways as described in Section II. Implementations conforming to aspects of the present invention or those set forth in the related applications succeed in reducing the number of software installation errors by learning from the mistakes of previously failed attempts and customizing installation routines to circumvent such failures. Various implementations of the present invention may also recognize that the way to address these problems is not to incrementally improve the existing approaches to software packaging where dependencies are created during the development cycle. Instead, aspects of the present invention revolve around delaying the time for dependency creation to the time of each individual install.
  • [0026]
    One particular aspect of the present invention involves a method for generating a software installation map. The method includes receiving a first software package comprising at least a first software file and a second software file, the first software file being dependent on the second software file. The method further involves generating a first software element representing the first software file and generating a second software element representing the second software file. Finally, the method involves generating a first dependency pointer representing the dependency between the first software file and the second software file.
  • [0027]
    These and other aspects of implementations of the present invention are set forth in greater detail below.
  • BRIEF DESCRIPTION OF THE DRAWINGS
  • [0028]
    FIG. 1 (prior art) is a block diagram illustrating the general components in a conventional computer software package;
  • [0029]
    FIG. 2 (prior art) is a block diagram that illustrates the functional relationships between a set of packages for an example software application A;
  • [0030]
    FIG. 3 is a flow diagram illustrating a method for installing an application involving the operation of unpacking a software application, generating a file-level dependency map, and using the map to install an application;
  • [0031]
    FIG. 4 is a block diagram depicting one example of a client-server arrangement that may be used in some implementations set forth herein, the arrangement involving a dependency map hosted at a server-side configuration and available to client-side system administrators when installing software;
  • [0032]
    FIG. 5 is a flow diagram of aspects of a particular method of performing a software installation;
  • [0033]
    FIG. 6 is a block diagram illustrating a portion of a software dependency map;
  • [0034]
    FIG. 7 is a block diagram illustrating dependency map generator modules that are involved in building and/or refreshing a software dependency map;
  • [0035]
    FIG. 8 is a flow diagram illustrating aspects of one particular method of generating a dependency map;
  • [0036]
    FIG. 9 is a flow diagram illustrating one particular method of generating a dependency map;
  • [0037]
    FIG. 10 is a block diagram illustrating an OS specific module as well as additional modules involved in resolving dependencies between software elements;
  • [0038]
    FIG. 11 is a block diagram illustrating an example of a dependency map with a software boundary overlay;
  • [0039]
    FIG. 12 is a flow diagram illustrating aspects of one particular method of creating a software boundary overlay in a dependency map;
  • [0040]
    FIG. 13 is a block diagram illustrating components involved in dependency route calculation;
  • [0041]
    FIG. 14 is a flow diagram illustrating aspects of a method of generating a dependency route for installing, updating, or otherwise modifying an application or “installation” on a target computer or computers;
  • [0042]
    FIG. 15 is a block diagram illustrating an example of a dependency route overlay;
  • [0043]
    FIG. 16 is a flow diagram illustrating aspects of a method of generating a rapid dependency route for installing, updating, or otherwise modifying an application on a target computer or computers;
  • [0044]
    FIG. 17 is a flow diagram illustrating aspects of a method for performing a pre-installation verification of a dependency route;
  • [0045]
    FIG. 18 is a block diagram illustrating another embodiment of a dependency route calculator that includes modules that collect and use successful and unsuccessful installations to optimize future installations, amongst other functions;
  • [0046]
    FIG. 19 is a method for updating a dependency graph to account for software elements that may no longer be useful in installations;
  • [0047]
    FIG. 20 is a block diagram illustrating a software management agent on a target computer that tracks and analyzes information about run-time failures and performance statistics of successfully installed routes and communicates the information to component modules in dependency map generation to optimize installation route information;
  • [0048]
    FIG. 21 is a flow diagram illustrating a method for performing a software installation simulation;
  • [0049]
    FIG. 22 is a flow diagram illustrating aspects of a method for validating an installation using a installation validation thread;
  • [0050]
    FIG. 23 is a flow diagram illustrating aspects of a method for performing a system rollback; and
  • [0051]
    FIGS. 24A and 24B is a flow diagram illustrating aspects of a method for duplicating software across multiple servers.
  • DETAILED DESCRIPTION
  • [0052]
    This detailed description of various implementations of the invention claimed in this or the related applications is subdivided into six major sections: section I (“Introduction”); section II (“Removing the Need for Software Packaging”); section III (“Software Dependency Maps”); section IV (“Software Dependency Routes”); section V (“Enriching the Dependency Map by Monitoring Software Installations and Performance”); and, section VI (“Software Installation Simulation and Intelligent Software De-installation”). The first section provides an introduction and a description of some of the overarching concepts of a dependency map and related implementations set forth herein. A dependency map involves a collection of software elements, which each include a reference to some type of software file, and the dependency relationship between the software elements. The dependency map provides the vehicle by which a software application may be installed at some target computer. Finally, the introduction provides a description of a service provider that generates and hosts a software dependency map for use by a client for installation.
  • [0053]
    The second section provides a detailed description of a method for installing software that begins at the file level rather than the package level. If individual software files are removed from the constraints of conventional packages and related at a more granular level, the inherent problems caused by packages may be alleviated. In addition, section II discusses how to install and manage software from the file level as well as the dependencies that exist down at a granular level. Absent features of various implementations set forth herein, such a granular level could make a system administrator's ability to grasp the additional number of pieces and their dependencies exceedingly difficult. For example, with the traditional approach to software packages, a software application may comprise 57 interrelated functional packages. This number of packages and their relationships are typical of a conventional software application. Functional relationships at the package level are readily ascertained and managed by a system administrator. However, aspects of the present invention define a software application at the individual file level with perhaps thousands of files, making it potentially more difficult for a system administrator to ascertain all of the file level interaction and manage the same. To remedy such a potential problem, aspects of the present invention involve a method of using a dependency map to determine which software files are needed to install a software application. Lastly, section two sets forth methods for managing pre-installation and post-installation conditions by adding such pre-installation and post-installation conditions as attributes to individual software files in a dependency map.
  • [0054]
    The third section provides additional details of software dependency maps and various possible particular implementations. Thus, the third section builds on the dependency map descriptions set forth in the introduction. All software files depend upon or are dependent on one or more other software files. A dependency map, in one particular configuration, is a memory resident dynamic model of the relationships between each software file of a given software application and other applications, while also accounting for the operating systems in which they reside. Over time, a given dependency map may grow in size as software applications or features thereof are added to the map, or may shrink when applications or features thereof are removed. The dependency map may also include a weighting system that reflects a confidence factor between software element dependencies. For example, if software file A is known to depend upon the presence of software file B, a confidence factor may be built into this dependency. The factor may exist in the form of a percentage of installations that have been successful based on this dependency as related to the total attempts. So, if 85 out of 100 attempts at installing a software application using the dependency between A and B, were successful, that dependency may have a confidence factor of 85%.
  • [0055]
    The third section also discusses various aspects of a client agent that interacts with a remotely hosted dependency map at various level. For example, in one implementation a dependency map is hosted by a remote service provider and a local computer hosts a client agent capable of communication with the service provider's map. Installing a software application on a client computer involves the client agent requesting the map at the service provider. The intellectual property contained in a software dependency map is often a trade secret and is kept confidential by its owners. Further, the amount of data contained in such a map could be enormous. In result, hosting the entirety of the map on each individual computer while possible, may be undesirable. Hence, aspects of the present invention involve placing a client-based software agent on each computer that is capable of accessing and querying only relevant portions of the remotely hosted dependency map to install a particular software application.
  • [0056]
    The fourth section provides a detailed description of the dependency route portion of the dependency map. A dependency route involves a list (or “path” in the context of a map) of software files needed to install a software application. Almost all software applications may be installed in different ways. For example, the same software application may be installed to achieve the fastest run time, the highest reliability, the highest security, etc. Each configuration will most likely change the software files required for installation. Hence, a dependency route involves a pathway in the map, between every file needed to install a software application under the conditions chosen by a user. As software file dependencies have confidence factors, so do individual dependency routes. For example, if 79 out of 100 installations used a specific dependency route for installing application A on operating system B, the confidence factor for that route would be 79%. Whereas a different dependency route that installs the same software on the same operating system may be successful 150 out of 172 attempts, resulting in a higher confidence factor of 87%. There are likely to be multiple possible routes through the map for any particular software installation configuration.
  • [0057]
    The fifth section provides a detailed description of methods for monitoring software installations based on a given dependency route as well as methods for analyzing software performance of a given installation. Client-side monitoring agents may be used on each computer to monitor the performance of a given dependency route. Such performance data may be uploaded to the central service provider that hosts the dependency map. Over time, the service provider for the dependency map collects performance data for each application using different dependency routes. Such data may be implemented into the dependency map as a means of further adding to confidence weightings of particular dependency routes.
  • [0058]
    The sixth section provides a detailed description of methods for simulating a software installation based on a given dependency route without actually installing the software. Such a simulation can forecast the ramifications of an installation on a computer by provisioning a virtual operating system and the list of currently installed software on the computer. By using such a simulation, potential installation time or run time errors can be flagged before the actual installation is performed. Section six also discusses the use of intelligent backup of an installation. By knowing the steps and ordering of a route taken to install an application, the same application can be backed-out along the same route. Through use of the dependency map and the dependency route used, an installation can be removed by knowing the list and ordering of software files that need to be removed. In contrast, convention de-installation techniques are converging in that they move forward in time trying to merge back to a state that resembles the previously stored state.
  • [0059]
    In summary, sections one through six teach various methods for replacing the conventional software application packaging approach by removing the functional packages from each application. Individual files that comprise software packages are extracted and placed into a dependency map. Dependencies between each file, or software elements, are further added into the dependency map. Customized dependency routes are further added into the dependency map, allowing for true installation-time customization of software applications. Lastly, methods are set forth for simulating software installations, measuring and increasing performance of installed applications, and intelligent software de-installation routines. There are other inventive features set forth in further detail below.
  • I. Introduction
  • [0060]
    One feature that various implementations set forth herein build upon or leverage in some way is the dependency map. A dependency map, also at times referred to herein as an “installation map”, involves a set of software elements and dependency relationships between the software elements. Each software element is extracted from some particular software application that may be installed on a computer. To achieve this, a conventional software package is “unpacked” to extract the various files that make-up the various packages of a software application. The various files are added to a dependency map, and form one attribute of a software element. The files or the software elements are analyzed to determine their dependency relationships with other software elements, and these dependency relationships are further added to the map. From the map, dependency or “installation” routes may be derived. A dependency route involves a list of software elements corresponding to a particular installation, which routes are leveraged to facilitate installation of a software application on a target computer. FIG. 3 is a flow diagram, discussed throughout this section, illustrating a method for installing an application, the operations involving unpacking a software application, generating a file-level dependency map, and using the map to install an application.
  • [0061]
    In one particular embodiment set forth herein, a method and various related features are described in the context of a service provider model where the service provider generates and hosts the dependency map and is involved in updating, etc. In such a context, installations are performed at client devices. However, a service provider model is simply one possible arrangement for deploying and using a dependency map. Such additional systems are further described throughout this application. As alluded to above, one inventive concept set forth herein involves the transformation of software from high-level packages to low-level individual files for the purpose of installation amongst others. In the service provider context, the service provider transforms the software (e.g., unpacking the software packages and defining a dependency map setting forth the file-level dependencies both within the software application and to external software application), hosts the dependency map, and provides knowledge to end-users on how best to install software hosted with the model, amongst other functions.
  • [0062]
    In one possible arrangement, a dependency map hosted and generated by a service provider is available as a fee-based service. Such a fee could be based on a per-request basis, annual maintenance fee basis with unlimited installation requests, or other fee arrangements.
  • [0063]
    In a service provider configuration, the service provider provides the infrastructure (e.g., servers, storage, functional modules, etc.) to generate and hosts the software dependency map. The generation and management of the dependency map is further described in Sections II and III and other places throughout this document. In one fundamental respect, a dependency map is a logical collection of each individual file from one or more software applications added to the map and a dependency relationship between the files. The server-side computing components include modules (as described with respect to FIGS. 7, 10 and others) that are configured to disassemble a software application's packages into their individual files and represent each file in the map as software elements (operation 300, FIG. 3). In one embodiment, a software element is a representation of an individual file that is part of a software application. Further, a software element stores a plurality of attributes to describe each file represented by the element. One attribute is a pointer (such as a network address, attached memory address, database pointer, etc) to the physical location of the represented file. Additional attributes represent dependency relationships, confidence factors, timestamps, versioning, etc which are discussed through out this application.
  • [0064]
    As will be further described below in Section III, each software element in the map has at least one dependency relationship with another software element. Generally speaking, a dependency relationship indicates that the file represented by the software element is depended upon or depends upon at least one other file represented by another software element. The reason for dependencies between software elements is to allow a collection of individual software elements to work together to form a functional software application. For example, a specific software element may be an executable file that is dependent upon execution parameters stored in a library file that is shared by additional software elements. If the executable file did not have a dependency on the shared library file, the executable file would be unable to run successfully. In order to resolve the dependencies between each software element in the dependency map, additional modules coupled to the dependency map, are configured to resolve and represent these dependencies within the map (operation 310, FIG. 3). These processes are further described with respect to FIG. 9 and elsewhere. Operations 300 and 310 of FIG. 3 are repeated for each software application hosted by the dependency map. As a result, the dependency map may represent a plurality of software applications that are each represented at the file level by individual software elements, along with the dependencies that exist between each element. It is possible that a dependency map may include millions of software elements and dependencies. FIG. 11 illustrates a graphical example of a dependency map.
  • [0065]
    In one particular embodiment, the infrastructure and contents of a software dependency map are organized and stored in a scalable database (e.g., relational, object-oriented, etc.). Such a database contains multiple tables with each one representing software elements and their attributes, dependencies, and their attributes, between elements, software boundary overlays, dependency route overlays and their attributes, route calculation overlays and their attributes and other components configured to create the infrastructure of a software dependency map. As described below, the actual software files represented by software elements may be stored in a second database. The software elements maintain a pointer to the physical database location of the files they represent. As such, the database providing the infrastructure of the software dependency map may communicate with the database storing the actual software files represented by the dependency map.
  • [0066]
    Once a dependency map is created, specific dependency routes may be implemented throughout the map. A dependency route is a collection of software elements having dependencies with at least one other software element, wherein the elements each represent an individual file forming part of a software application that will be installed on a target computer or computers based on specific requirements and configuration parameters. The route may be considered a pathway through the dependency map between a first collection of software elements that are related to a current state of the software resident on the target computer to a second collection of software elements that will allow the addition of a new software application, upgrade or reconfiguration of a current software application. FIG. 15 provides a graphical example of a dependency route running through an example dependency map. The dependency map is coupled to a route manager (as shown in FIG. 13) that is configured to analyze the software elements that comprise a software application and generate specific software dependency routes that may be used to install the application on a client machine (operation 320, FIG. 3). Once a client communicates their installation requests to the service provider or whatever computing system is provided to host the dependency map, the route manager determines one or more dependency routes that may accomplish the specific needs of the client. The dependency routes are then transmitted to the client for installation (operation 330).
  • [0067]
    Once a client has decided on their installation needs, they have many options on how to proceed. First, they may install the software based on one of the dependency routes provided by the dependency map. Secondly, the client may run a simulation (as described in Section VI) of the chosen dependency route to determine if the route would result in a successful installation. Based on the success of the simulation, the client may chose to install the route or request an alternate route from the dependency map. Lastly, the client may take a snapshot of their current system. A snapshot is a detailed description of the current software inventory and system configuration of a computing system. Multiple snapshots may be taken that represent the current state of the computing system at differing periods of time. If errors occur during the installation, the client may request to uninstall or back-out the installation (as described in Section VI) in order to place the client machine in the same position before the installation commenced (i.e., at the snapshot). This approach differs from conventional back-out methods that move forward to place the machine in the previous configuration. Whereas, the inventive approach moves backwards in order to place the machine in its previous configuration, resulting in a substantially identical mirror of the machine's previous state.
  • [0068]
    Lastly, client machines are capable of communicating the success or failure of installations back to the service provider (operation 340). Such information may be used to implement a weighting system on the confidence of dependency routes and individual dependencies between software elements.
  • II. Removing the Need for Software Packaging
  • [0069]
    A purpose for combining a software application into packages is to allow system administrators to grasp the interrelationships between each functional package of the application. The smaller the number of packages, the easier it is to grasp their interrelationships. As stated above, conventional software packages are not represented at the granular level of individual files because a typical system administrator would find it exceedingly difficult to grasp the vast number of individual files and the complex dependencies that exist between them. Hence, this is one of the reasons that conventional software is represented at a higher package level as previously described with respect to FIG. 2 and elsewhere, particularly in the Background section.
  • [0070]
    File level dependency mapping set forth in accordance with aspects of the present invention is useful for custom installations, besides other advantages. In many software installations, not all files of a software application are required. However, based on the way conventional software is packaged, additional files are usually installed that will not be needed by the current configuration. In most software installations, many of the individual files are part of the core of the application. These core files are required no matter what installation parameters or options are chosen. However, the remaining non-core files in an application may be configuration-dependent in that they are only needed under certain circumstances. For example, Apache 5.5 may have 50 files devoted to a certain type of security feature that an administrator may chose to forego. Another 20 files may be “help” files that describe how to run and configure a web server. The decision to install these files should be optional. However, conventional software packaging often makes optional file installation difficult. Further, knowledge of which files are needed for each of the above examples would be difficult or impossible for an administrator to ascertain as there may not be available information describing which files correspond to which features.
  • [0071]
    Besides making custom installations difficult or impossible, as set out above, conventional software packaging is also a cause of installation failures. Aspects of the present invention thus involve a solution that removes the need for software packages, allowing it to be organized at the granular file level, and also providing a way to facilitate installation from the root file level.
  • [0072]
    Once the artificial constraints created by software packages are removed, focus can be placed on the individual software elements representing each file and their relationships with one another (i.e. dependencies). However, software element dependencies are often not absolute. In other words, a dependency between element A and element B may not always need to exist. There are examples where such a dependency is needed and others where it is not needed. For example, if an administrator wishes to install a software package based on “the most reliable version”, element A may not depend on element B. However, if an administrator wishes to install the same software package based on “the latest version”, element A may indeed depend on element B. Under this example, the dependency between element A and B is not absolute.
  • [0073]
    Another factor that affects whether a dependency exists are that certain dependencies can create “circular relationships” that should be resolved (i.e., redirecting or adding a dependency to another element to remove the circular relationship or provide a link to a software element outside the circle). If an absolute dependency exists within a “circular relationship”, this can make resolution of such a relationship difficult. An absolute dependency is where A will always depend on B no matter what the circumstance. An example of a circular relationships would be A depends on B which depends on C which depends on A. In this example, if the dependency between C and A is absolute (i.e., always exists), there would be no way to resolve this circular relationship since C always depends on A and A depends on B which depends on C. If however, the absolute dependency between C and A were only necessary due to a certain symbol that could also be met by D, than the circular relationship could be resolved by redirecting C to depend on D instead of A.
  • [0074]
    Yet another factor is that there are other parameters other than pure positive dependencies. There may be stated incompatibilities between elements and there may be replacement relationships where a new element with similar functionality might replace it. For example, in a specific software application, package A may have a stated dependency on package libCORE. The software developer responsible for packaging this software may have defined this dependency because package A contains an executable command called “ps”. In order to execute “ps”, the memchk command is needed. In this example, memchk is stored in the library definitions of libC which is further a part of package libCORE. It may be possible that memchk also exists in a different set of library definitions called libgtk which is part of package GTKlibs. In this case GTKlibs is a replacement dependency for package A, even though package libCORE also includes the same memchk element needed by “ps”. The reason a software developer chose a stated dependency on libCORE instead of GTKlibs may be that GTKlibs is part of a different software application which may not be installed on the computer. However, if the software application that includes the GTKlibs package is present, the dependency from package A may be changed from libCORE to GTKlibs, in implementations conforming to aspects of the invention.
  • [0075]
    One particular implementation involves a server-side dependency map that provides software application information at the software element level rather than the package level. FIG. 4 is a block diagram depicting one example of client-server architecture where the dependency map 400 is hosted by a database 410 in communication with a server-side computing arrangement (service provider 420) and available to client-side computers 430 to install a software application.
  • [0076]
    In the example set out in FIG. 4, the one or more client computers 430 would seek access to the service provider's dependency map 400 and the installation routes that may be derived therefrom. In one embodiment, client computers 430 communicate with the service provider 420 via the Internet 440. In another embodiment, client computers 430 may communicate with the service provider 420 via a local or enterprise-wide network (not shown). To facilitate communications between clients 430 and the service provider 420, a client-side software installation agent 450 may reside on each client computing system where software installations are desired. This software agent 450 is able to communicate with the service provider 420 to make installation requests as well as receive installation instructions, besides other functions. Further, the software elements (or related files) needed to fulfill an installation request may be transmitted from the service provider 420 to the client 430 over the Internet, local, enterprise-wide networks, or other removable storage media (e.g., the root level file may be recorded on optical disc, etc.)
  • [0077]
    The entity responsible for hosting a dependency map is not limited to a service provider as previously mentioned. A dependency map host may come in many forms. However, in one embodiment, the map is hosted by a third party service provider with no formal relationships with individual software vendors. The third party hosts a dependency map that may represent software from one or more software vendors. In another embodiment, the entity hosting the dependency map may be an actual software vendor, such that the dependency map represents software applications specific to the vendor. Further, the vendor-hosted dependency map may also represent software applications from other vendors. In another embodiment, the dependency map entity may be a company that hosts a dependency map for the software applications used in the company's enterprise-wide software environment. Such a dependency map would likely include software from many different software vendors.
  • [0078]
    FIG. 5 is a flow diagram of aspects of a particular method of performing a software installation. Referring to FIGS. 4 and 5, when a system administrator responsible for maintaining a client computing system wishes to install a software application with certain requirements, the request is communicated to the software agent 450 installed on the client computing system (operation 500). An example of an installation request may set out installation parameters: a) install Apache 5.5; b) use the securest version possible; c) run on Sun Microsystems™ Solaris™ 9.1 operating system. The software agent installed on the client communicates the request to the service provider 420 (operation 510).
  • [0079]
    The software agent also communicates, either as part of the installation request or separately, the client's software manifest to the service provider (operation 520). A client software manifest is a listing of some and likely all the software applications installed on the client as well as the individual files that comprise each application. It is also possible to provide an arrangement where the software manifest is transmitted to the service provider whenever there is a software change, allowing the service provider to maintain a current client manifest. Further, the manifest may be maintained at the software agent 450, with the service provider 420 accessing the manifest as part of the installation path determination (see discussion of operation 530 below).
  • [0080]
    With knowledge of the client manifest, the dependency map 400 is analyzed to generate one or more installation paths commensurate with the installation request (operation 530). The installation paths are then communicated, to the software agent 450 (operation 540). Once each installation path is received by the software agent 450, the system administrator may review each path and determine which installation path to use or the system may be configured to automatically install the new software using one of the paths (operation 550). Next, the selected dependency route is communicated, via the software agent 450, back to the service provider 420 (operation 560). Lastly, in an implementation where the service provider hosts the software files, the service provider streams the files to the client based on the chosen installation path (operation 570). It is also possible that the client system will have the files needed for the software application resident on the files system. In such an arrangement, the software agent is configured to receive the dependency route and manage the installation of the file already resident on the client system. It is also possible for the software agent 450 to obtain files identified by the installation through various other possible mediums.
  • [0081]
    Two features of a conventional software package based installation that a dependency map driven installation may eliminate are pre-installation and post-installation scripts. As previously discussed with reference to FIG. 1, pre-installation scripts describe what needs to be validated prior to the installation of a software application. Post-installation scripts, on the other hand, describe what needs to occur after installation of the software application. When using conventional package-based installation methods, the pre-installation and post-installation scripts are separate entities from the pre-determined group of packages. Yet, the scripts are generated at the time of software development, resulting in generic requirements without knowledge of the unique computing system configurations the software will eventually be installed. In stark contrast, when performing an installation using a dependency map, the collection of required of software files is generated at the time of the installation as a function of current computing system features, rendering pre-created installation scripts unnecessary. Eliminating the necessity of pre- and post-installation scripts also illuminates one advantage of certain configurations falling within aspects of the present invention. Namely, removing the constraints of the installation scripts, along with other features of various implementations set forth herein, facilitates file-level customized installation of a software application.
  • [0082]
    Aspects of the present invention may further involve integrating pre- and post-conditions or requirements of an installation into each software element as additional attributes. Conventional pre-installation and post-installation scripts are created for and bound to a specific conventional software package. Each script describes conditions or requirements of both the entirety of a given package as well as the files in the package. As such, these scripts are package-centric (i.e., they describe conditions for the entirety of the package.) To circumvent the problem with package-centric scripts, the pre- and post-condition attributes of each software element are specific to each particular element. Pre- and post-installation attributes are extracted from the original installation scripts 140 and 150 as described with respect to FIG. 1. The service provider is able to analyze each condition from the original installation scripts and create an attribute to a software element any time the original script references the file represented by the attribute. For example, if the original installation script states that file A has a stated dependency on file B, the service provider would add this requirement, as an attribute, into the software element representing file A. Therefore, the software element representing file would have an attribute stating that it is dependent upon element B.
  • [0083]
    The pre- and post-condition attributes of software elements may be described as being compartmentalized as opposed to the conventional package-centric scripts. For example, an attribute of software element A may state a dependency on element B. This dependency is confined to software element A, allowing the attribute to be element-centric. Whereas, conventional pre- and post-installation scripts have a one to many relationship between all files in the package with no compartmentalization. Hence, in a conventional packaging script, the dependency from A to B is always defined even if element A is not needed in the installation. Whereas, the dependency attribute of A is only declared if A is included in the dependency route being installed. As a result, only the pre- and post-conditions defined by elements in the dependency route are needed, as opposed to every condition being defined in the convention scripting approach.
  • [0084]
    After the service provider builds the list of all software elements required for an installation, the pre- and post-conditions built into each software element can be summarized to create a type of hybrid pre-installation and post-installation script containing a mere subset of all the conditions from the original pre- and post-installation scripts. This technique differs from conventional installation scripts through its ability for creation after the dependency route is defined. Hence, the scripts are customized specifically for the installation and the current configuration existing on the client system. Such a technique offers a flexible way of managing the pre- and post-installation scripting as the implicit ordering of the software elements based on dependencies matches the exact order of execution required by the pre- and post-conditions built into each software element.
  • III. Software Dependency Maps
  • [0085]
    As already discussed at some length, aspects of the present invention involve the generation and use of a software dependency map with element level dependencies, amongst other things, to facilitate the installation of new software. Further aspects of the present invention involve the removal of software packaging from software installations, allowing for software to be represented at the individual file or software element level of granularity. The constantly changing nature and intricacies of file level dependencies makes manual monitoring and use in installation by a system administrator exceedingly difficult if not impossible. Hence, a service provider hosts the information needed (i.e., knowledge base) to install and organize software at the element level. As introduced above, the collection of software elements and their dependencies is referred to herein as a software dependency map. The size and arrangement of the map is a function of the number of software applications mapped and the number of files and dependencies within each mapped application. Accordingly, a dependency map may represent any number of operating systems and software applications encompassing literally millions of individual software elements. Moreover, the map is constantly changing as installation information arrives from software agents residing at various client locations as well as new software and/or operating systems are unpackaged and added to the map.
  • [0086]
    FIG. 6 is a block diagram illustrating a portion of a software dependency map. The lowest level of granularity in this map 600 is a software element (605, 610, 615, etc.). A software element is a representation of an individual file, such as a configuration file, an executable file or a library file. The software element includes one or more attributes, one of which may be a pointer to the physical location of the file it represents. In one embodiment, this attribute may point to a memory address within a software warehouse (described further in Section IV). Every software element has some dependency on another element; otherwise, the element would not be needed as nothing else depends on it being present. Accordingly, in another embodiment an additional attribute of a software element is a dependency attribute identifying dependencies associated with the software element. FIG. 6 comprises a plurality of software elements each of which has at least one dependency (illustrated by arrows 650) (e.g., between the blocks) on another software element. Each software element, depicted by a block, represents a type of file. In this example, configuration files, executables files, shared library files and class files are shown. Within FIG. 6, shared library file 601 is dependent upon shared library file 605, configuration file 610 depends upon shared library file 601, executable file 630 depends upon configuration file 610, and so on.
  • [0087]
    In an example from FIG. 6, class file 640 is dependent on shared library file 601. The actual dependency may be that within class file 640, function “GetDependencyMap” may be called. The location of this function exists in shared library file 601. Therefore, if class file 640 did not have a dependency on shared library file 601, class file 640 would be unable to call function “GetDependencyMap”. In another example, executable file 630 depends upon configuration file 610. Configuration file 610 may declare “TimeOutCounter” with a value of 50 milliseconds. During execution of executable file 630, the value of “TimeOutCounter” is used to determine how long to wait before ending execution if no response is received from another executable file. If configuration file 610 were not present, executable file 630 would be unable to execute properly since no value would be presented as to when to end execution.
  • [0088]
    FIG. 7 is a block diagram illustrating various dependency map generator modules involved in building and/or refreshing a software dependency map 400. In concurrence with FIG. 7, FIG. 8 is a flow diagram illustrating the operations involved in converting a package-based software application into a collection of software elements and generating a dependency map. The method of FIG. 8 is discussed with reference to the dependency map generator module of FIG. 7; however, other processing configurations may be implemented to perform the operations set out in FIG. 8.
  • [0089]
    Particularly referring to FIG. 7, a software collector 705 is configured to collect software applications that will be unpacked and added to the dependency map 400 (operation 800). In one embodiment, the software collector 705 interacts with sources of software 701, such as vendor websites or other software repositories. In another embodiment, the software collector 705 may receive destinations for software applications through the assistance of one or more software seekers 702. Generally speaking, a software seeker 702 is a module configured to search the Internet for software applications and additional information useful for downloading applications. In one configuration, a software seeker is instructed to locate a particular software application. Once the particular software application is located by the software seeker, the destination is relayed to the software collector 705. The software seeker may also include additional information on downloading the software such as an FTP or http user name and password that may be required to download the software. With the provided information from the software seeker 702, the software collector 705 downloads the software application from the software source 701.
  • [0090]
    Once a software application has been retrieved by the software collector 705, it is forwarded to an element unpacker 710. The element unpacker 710 has two primary responsibilities. First, the element unpacker 710 determines which operating system (hereafter “OS”) the application has been written for. With the exception of interpretive languages, software applications are written for a specific OS. Hence, the process of extracting or unpacking software elements from an application involves knowledge of which OS the application is written for. Secondly, the element unpacker 710 unpacks the software application from the package level to the file level. As previously described above, conventional software applications have one or more functional groupings or “collections” of files known as packages. Unpacking a software package involves a process of extracting the individual files from each package.
  • [0091]
    Referring now to the OS determination, the element unpacker 710 determines which OS the software is written for. This determination is made through the assistance of an OS Detector 712 which analyzes the software to determine which OS it has been written for (operation 810). In one embodiment, the OS detector 712 determines which OS the software is written for through the assistance of an OS lookup table 718. The lookup table 718 lists the different types of software packaging formats that exist and cross-references each type to its appropriate OS class type. The OS detector is able submit the type of software packaging format to the lookup table and determine which OS class the packaging format corresponds too. Next, the OS detector 712 uses the OS class type to analyze one or more binaries of the software application to assess which architecture the binary is targeted for (e.g., x86, Sparc, PowerPC, etc). In many situations, this level of detection is sufficient to determine the OS of the software application. If further analysis is required, the OS detector 712 can implement additional tools to review the package manifest of the software application to determine which OS the software is targeted for. Once the correct OS has been determined, the element unpacker 710 may begin extracting the file from the software application's packages.
  • [0092]
    In order for the element unpacker 710 to extract the files from a software application, it also receives assistance from an OS specific module 725. An OS specific module 725 or plugin exists for each OS in which software is written for within the dependency map 400. Once the OS detector 712 determines which OS the software application is written for, the appropriate OS plugin 725 is called to assist the element unpacker 710 with extracting the files from each package in the software application (operation 820). The element unpacker 710 uses unpacking commands specific to the OS that the software is targeted for. For example, if the software application is targeted for UNIX, the element unpacker 710 may use tar, or gzip to unpack the files from the package. If the application is targeted for Microsoft™ Windows™, the element unpacker 710 may use unzip or rar to extract the files from the package.
  • [0093]
    Once all the files have been extracted, the element unpacker 710 analyzes the software manifest and the installation scripts for the software application to characterize each file by its file type (e.g., executable file, configuration file, library file, etc.) (operation 830). In one embodiment, a file type lookup table is used to map each file type suffix (e.g. exe, dll, etc.) to the file type that the suffix corresponds too. For example, if a file has a “dll” suffix, the lookup table would return shared library as its file type. In another embodiment, many operating systems provide commands to analyze a file for its file type. For example, Solaris has a “file” OS command that will reveal the file type of a file.
  • [0094]
    Lastly, the files extracted from the packages are forwarded to a graph manager 730. The graph manager 730 is responsible for creating a software element 745 and adding it to the dependency map 400 (operation 840). As previously stated, a software element includes an attribute that has a pointer to the physical location of the file the element represents. As software elements 745 are placed into the dependency map 400, the graph manager 730 creates a pointer to the physical location of the file it represents (operation 850). As stated above, the pointer is stored as an attribute of each software element. In one embodiment, each file is stored in a software warehouse or database. Hence, the software element's pointer would point to the location within the software warehouse that hosts the actual file. Therefore, when the actual file is needed, the pointer will direct the dependency map 400 to the location of the physical file. Further, the graph manager 730 allows for each software element 745 to have additional attributes associated with it. The details of such attributes are discussed throughout this application.
  • [0095]
    As software elements 745 are added to the dependency map 400, their status is temporary in that the elements are inaccessible by other modules of the service provider. It is not until dependencies 747 are created between these software elements 745, that their status is changed to operational allowing the elements to become available for dependency routes. Once the software elements 745 have been created and placed into the dependency map 400, a copy of each element 745 is relayed to the dependency resolver 715 for analysis of the element's dependencies 747. Through the assistance of the appropriate OS plugin 725, the dependency resolver 715 launches an OS shell 727. An OS shell is a minimal instance of an OS which is able to perform a minimal set of instructions specific to the OS. The dependency resolver 715 is able to analyze each software element 745 within the OS shell to determine the dependencies with other software elements 745. The process for determining each dependency will be further described below. Once each dependency 747 is determined, the dependency resolver 715 passes this information to the graph manager 730 to add to the dependency map 400.
  • [0096]
    FIG. 9 is a flow diagram illustrating the operations for identifying dependencies between the software elements, and the new element placed in the map as described in FIG. 8. Upon completion of adding software elements to the dependency map and placing them in a temporary status, the analysis of dependencies 747 between each software element 745 begins (operation 900). In many circumstances, each package in a software application will already include a number of declared dependencies. These declared dependencies are often located in item 120 from FIG. 1. Based on this knowledge, many of the dependencies between individual files can be extracted from the package and represented in the dependency map 400 (operation 910). In one embodiment, the specific OS the software is targeted for includes packaging tools that may be utilized to extract the dependencies between software elements. Next, the shared libraries from within the software application are analyzed to ascertain inter-library dependencies (operation 920). Each shared library often defines dependencies to other shared libraries. Upon identification of a shared library, these dependencies are represented in the dependency map 400. After shared libraries are analyzed for defined dependencies, configuration files are analyzed to identify declared dependencies. Configuration files within a software application may also declare dependencies between files are identified and represented in the dependency map 400 (operation 930). Next, all the executable files from within a software application are analyzed to identify dependencies (operation 940). Typically, each executable file contains a symbol table. Analysis of these symbol tables may identify dependencies that exist between the executable file and other file types within the software application (operation 950). An OS typically has commands that are able to analyze executable symbol tables. For example, UNIX uses a command called “nm” to analyze symbol tables. Finally, simulated execution of executable files is possible. Upon execution of an executable file, the initial execution cycles are analyzed to assess what files are loaded or referenced during execution (operation 960). Any files that are loaded or referenced during the initial execution cycles are identified as dependencies on the executable file. These dependencies can then be represented in the dependency map. Recursive use of some or all operations 940-960 may continue (operation 970) until all the executable files have been analyzed. Once all the executable files have been analyzed, the dependency analysis is complete (operation 980) and the newly added software elements are changed to an operational status.
  • [0097]
    FIG. 10 is a block diagram that illustrates an OS specific module as well as additional modules used to resolve dependencies between software elements recently added to the dependency map. As stated above in regards to FIG. 7, the dependency resolver 715 identifies the dependencies for each software element. In order to accomplish this, the dependency resolver 715 is expected to know which OS each file, represented by a software element, is written for. In one embodiment, the OS detector module 712 described in FIGS. 7 and 8 is in communication with the dependency resolver 715. The OS detector 712 analyzes a file and determines which OS it is written for and passes this information to the dependency resolver 715. One or more OS specific modules (also referred to as “plugins”) are coupled to the dependency resolver 715 with each plugin representing a different OS. Through the assistance of the appropriate OS plugin 725, the dependency resolver 715 launches an OS shell 727. As stated above in regards to FIGS. 7 and 8, an OS shell is a minimal instance of an OS which is able to perform a minimal set of instructions specific to the OS. The dependency resolver 715 is able place each file in the OS shell 727 and analyze the file to identify its dependencies.
  • [0098]
    In one embodiment, the dependency resolver is able to identify the dependencies of a file through the assistance of the appropriate OS plugin 725. Each OS plugin has a plurality of individual sub-modules 1010-1030. The OS specific package dependency analyzer module 1010 performs the functions described above in regards to operation 900 from FIG. 9. Whereas, sub-modules 1020-1030 are responsible for analyzing each type of software file. Therefore, depending on what type of file is placed into the OS shell, one of these sub-modules are called to identify the dependencies. For example, if the received software element is a shared library, the OS specific dynamic library dependency analysis module 1020 is called by the OS plugin 725. This sub-module analyzes the shared library file and determines what dependencies exist between the shared library file and any other files. This is accomplished by checking each line of code within the shared library file to identify code that declares a dependency. If the software element being received is a configuration file, an OS specific configuration file detection module 1025 is called by the OS plugin 725. This sub-module analyzes the configuration file line by line to identify code that declares a dependency. If the received software element is an executable file, two separate sub-modules are accessed. First, an OS specific symbol analyzer module 1015 is called by the OS plugin 725. This sub-module accesses the symbol table of the executable file and checks each line of code to identify code that declares any dependencies. Next, an OS specific runtime executable management module 1030 is called by the OS plugin 725. This sub-module actually launches an OS virtual container 1040.
  • [0099]
    A virtual OS container is a virtualized instance of an OS running with a minimal set of functionality sufficient to execute an executable binary file and analyze its run-time path. In one embodiment, multiple virtual operating systems may run on a single hardware platform. Once the virtual OS container 1040 is launched, sub-module 1030 places the executable 1045 into the OS container 1040 along with any known dependencies of the executable. The executable 1045 is executed with the runtime execution being monitored to assess for any missing configuration files that are needed by the executable. These additional configuration files are then declared as dependencies to the executable. Any additional dependencies that were declared in the runtime execution path are then returned to the OS specific runtime executable management module 1030.
  • [0100]
    The previous section discussed the ability to identify dependencies from executable files using sub-modules with each OS specific module. This approach works effectively when identification of the dependencies occurs for software elements that are part of a software application. However, this approach is less effective when trying to identify dependencies in an actual operating system. In the core files comprising an OS, the dependencies are so tight, that dependency identification should be fully analyzed as an entirety of the files and not sequentially. In order to accomplish such analysis of an entire OS, a full version of the OS is loaded (also known as “provisioned”) and its file-level dependencies are validated.
  • [0101]
    The complete system dependency validation is an asynchronous scheduled act from the actual dependency discovery. Complete system dependency validation does not define dependencies (which is accomplished by the dependency resolver) but rather validates the identified dependencies. Dependencies may nonetheless be redefined during the validation procedure, such as when an invalid dependency is identified. One method for validating dependencies is through the use of a processes referred to as Bare Metal Provisioning. In this process, the complete OS defined in the dependency map is collected into an optical disc image (hereinafter “ISO”) format and provisioned onto dedicated hardware that the OS architecture is targeted for. For example, in analyzing the dependencies of Solaris 9.1, the entirety of the OS may be provisioned on a Sun Mircosystems Sparc™ Station. Once provisioning is complete, a set of system tests are performed that have been prebuilt as part of the OS. These tests, common to a particular OS, may be run to exercise the basic input/output system of the OS to ensure it is working within expected parameters. In order to include these tests in the Bare Metal Provision, the files needed to execute these tests are included.
  • [0102]
    A first test includes file system checking such as reading and writing files to the OS This in turn exercises the kernel of the OS since basic I/O processing is written as part of the kernel. A second test includes system error log scraping to ensure that the running OS is operating within normal parameters. In one embodiment, this is performed by a log watcher. Since operating systems classify errors in their system logs based on severity, the log watcher looks for errors with a severity greatest than a predetermined threshold severity level. If an error is flagged with a severity above the threshold, the error is captured for further analysis.
  • [0103]
    A third test includes deployment of a common software application (e.g., a web server) to see if the operating system runs the application within the specified parameters. Each deployed application and test environment may have its own testing parameters and expected results. However, the general approach is to verify that the deployed software application runs successfully (i.e., all dependencies are in place and accounted for.) For example, if the deployed application were a web server, the test would verify that the core web server daemon is running and that any errors returned by application specific error logs are below a threshold severity level. Upon successful completion of the system tests described above, the OS as a whole is given a first level assertion of correctness for the dependencies through the OS.
  • [0104]
    In one embodiment, the dependency resolver analyzes the software files extracted from a package to identify the dependencies between each file. As previously stated, dependencies are not necessarily absolute. Installing a software application “with the most stable version” may require element A be dependent on element B. Whereas installing the same software “with the newest version” may show that element A is not dependent on element B. Hence, in this example the dependency between element A and B is not absolute, bur rather installation specific. In another example, a dependency may be declared within the conventional package of the software application itself, yet not found to exist by the dependency resolver. To handle this situation, a confidence factor or weighting is placed on the dependency such that the dependency still exists, but may likely have a low confidence factor attached to it. This confidence factor becomes an attribute of the dependency.
  • [0105]
    A confidence factor attached to a dependency can increase each time the dependency resolver reanalyzes that the dependency is in fact real. On the opposite end, the confidence factor can decrease if the dependency resolver reanalyzes the dependency and finds that it is not required or if an additional software element was preferred. This allows the dependency map to reflect the confidence based on computational analysis of the independent software element. The output is a complex software map that reflects the true dependencies and relative confidence of the dependencies for the software applications that are being mapped.
  • [0106]
    Another aspect of the present invention involves dependency map overlays. In one particular implementation, there are three types of overlays placed on the dependency map: software boundary overlays, dependency route overlays and route calculation overlays. The first type of overlay is described in the next paragraph, wherein the last two types of overlays are described in Section IV. Generally speaking, an overlay is a subset of software elements and their dependencies that are overlaid on top of the primary dependency map, where the subset of software elements have some overarching feature in common, such as originating from a common software application or belonging to a common dependency route.
  • [0107]
    The first type of dependency map overlay is a software boundary overlay, which is a virtual boundary placed around a collection of software elements that make up the entirety of a software application and groups them into a form understandable by a human. One embodiment for creating a software boundary overlay is performed by analyzing the package manifest 130 of the software application to identify a list of files for the application. Then each software element (from the dependency map) that represents the files from the manifest are collected together to create the boundary overlay. Other elements with dependencies, not necessarily identified in the manifest may also be included. In one embodiment, the software elements that make up a software boundary overlay may change over time if additional software elements are added or removed from the application. Such an approach is a replacement for convention software packaging where one or more packages comprise the pieces for a software application. It is possible for a software boundary overlay to include software elements that are not all related through dependencies, but instead are collected together to form a human understandable software application. An example of a software boundary overlay would be an application such as Apache 5.5.
  • [0108]
    FIG. 11 is a diagram illustrating an example of a dependency map with a software boundary overlay. FIG. 11 shows a plurality of software elements 1120 that comprise an example of a dependency map 1100. The bounds of the dependency map 1100 are shown by the dashed line surrounding the software elements 1120. Each software element 1120 has at least one dependency 1130 upon another software element 1120. The dependencies 1130 are shown as straight lines that connect two software elements 1120. In this embodiment, there are no software elements 1120 within confines of the boundary 1110 that depend upon a software element 1120 outside the boundary 1110. This example illustrates a single software boundary overlay 1110. However, a dependency map 1100 may comprise a plurality of software boundary overlays, each representing different possible overlays.
  • [0109]
    FIG. 12 is a flow diagram illustrating various operations involved in creating a software boundary overlay in a dependency map. In one particular implementation, to begin creating a software boundary overlay, the package manifests 130 of the software application are analyzed and each software element is extracted from its package and placed onto the dependency map (operation 1200). The methods used for these processes are described above with respect to FIG. 8. Once all the software elements are placed into the dependency map, the dependencies between all of the software elements are determined and placed onto the dependency map (operation 1210). The methods used for these processes are described above with respect to FIG. 9 and otherwise. Next, a boundary is drawn around all of the software elements derived from the unpacking of the software application (operation 1220). This creates the initial bounds of the software application. The software elements and their dependencies are then analyzed by the graph manager 730 to identify dangling references (operation 1230). In one embodiment, a dangling reference is a reference that is outside the scope of a software boundary or of a dependency that is not yet defined if the corresponding element is not loaded into the dependency graph. For example, if a software element within the bounds of the software boundary overlay shows a dependency on a software element outside the bounds of the overlay, this would be a dangling reference. If a dangling reference is found such that the software element referenced is outside the bounds of the boundary, the boundary is increased to encompass the new software element (operation 1240). Moreover, attributes of the software element are updated to identify the newly added dependency. Hence, the software boundary overlay is increased in size to include this new software element. This process continues until each dangling reference is resolved. Hence, a software boundary overlay will continue to expand until there are no further dangling references.
  • [0110]
    In one embodiment, a software boundary overlay should not comprise any software elements from any other declared software boundary overlays. For example, software elements should not be included in two separate software boundaries. Such a rule prevents software boundaries from encroaching on each other and keeps them inherently distinct. The end result is that a software boundary declares the manifest of a software application that the dependency map supports. The dependency map itself understands explicitly all of the dependencies within the software package and all of the detailed inter dependencies between software packages. But this level of detail does not need to be known by a system administrator.
  • [0111]
    Aspects of the present invention are also able to address another concern with conventional software applications; namely, accounting for patches and minor revision releases in the installation process. It is known in the art that software applications change over time. Due to the release of bug fixes or patches, a software application's version is constantly in flux. As patches are released, dependencies between software elements may change. Under such circumstances, a software dependency between element A and B may exist in the initial release of a software application. However, once a patch is applied, the dependency between A and B may no longer exist. The software dependency map is configured to track software dependency changes over time, in one particular implementation. For example, assume element B provides certain functionality in version 1 of an application, with an element A depending upon B. When version 1.1 is released, the functionality of B is replaced with new software element C. At this point, the dependency between A and B is removed and a new dependency between A and C is created.
  • [0112]
    A common request from a customer is that they wish to install the most “stable” version of a software application. This request can be version related, as the current version of an application may not be the most stable version. In one embodiment, in order to install the most stable version of a software application, the root software application is installed first, followed by a potential list of updates, service packs, patches and point releases to get the software to the configuration requested by the customer. The root software elements of a software application do not depend on any other software elements, only other software elements depend on them. These root elements tend to remain constant, no matter which version or configuration of the application is installed In order to map any minor versions of a software application, the dependency map includes each minor version, patch or bug fix of the major software application. Hence, after the root elements are installed, each software element in each minor version would be mapped, with dependencies, to each root software element in the major versions.
  • [0113]
    Once all the dependencies of each version of a software application are mapped, the need for mapping dependencies over time becomes important. In one embodiment, when a dependency is added into the dependency map, two timestamps are recorded as attributes to the dependency. Thus, a software element may have time stamp attributes. First, the timestamp associated with the file represented by the software element is recorded. Whenever an individual software file is created, a timestamp is added to the file. Therefore, a software developer will know when the file was actually created during development. Second, the software element includes a timestamp of when it was added into the dependency map. The timestamp information is stored in the dependency map using a timeline data construct. A timeline data construct describes a set of software elements that are all related when they were inserted into the dependency map. This is how the service provider knows that a group of software elements are from the same version and hence part of the same software boundary overlay. As each new software element and dependency are added to the dependency map, the timeline construct is also added. As a result of these timelines, when a customer wishes to install a specific version of a software application, these timelines are used to calculate the optimal installation by correlating the timestamp on the root install software with each of its assumed dependencies. In one embodiment, the timelines are assembled as fragments and as the route analyzer of the dependency map analyzes the map, it assembles the overall timeline of software that needs to be installed. The above is applicable if there are more than one version of a software application and each version has the same dependency resolution.
  • IV. Software Dependency Routes
  • [0114]
    The previous section discussed a first type of dependency map overlay referred to herein as a “software boundary overlay.” This section describes a second type of dependency map overlay referred to herein as “a dependency route overlay.” The dependency map is a vehicle for identifying and facilitating various possible software installations. Software elements and their dependencies from mapped software applications are set forth in the dependency map. A dependency route is one of many paths or ways of connecting a group of software elements based on specific installation needs. From another perspective, a dependency route is a list of software elements and the dependencies associated with the elements that get a customer from their current place in the dependency map (starting collection of software elements) to where they want to be (ending collection of software elements conforming to an installation goal). For example, installing Apache 5.5 on Solaris 9 would create a dependency route through the map connecting each software element needed to install Apache 5.5 on Solaris 9. The starting point might be all the software elements for Apache 5.0 on Solaris 9 (obtained from target computer) and the ending point is the collection of software elements for Apache 5.5 on Solaris 9. There may be software elements added, removed and consolidated along the path. Installing the most stable version of Apache on Solaris 9 would take a slightly different route through the map as it may involve Apache 5.5 or some other version. As such, the collection of software elements that comprise each installation may be different.
  • [0115]
    As with software boundary overlays, dependency routes are subsets of information contained within the dependency map. To restate, the dependency map is a collection of software elements and their dependencies that are placed in the map by the apparatuses and methods described in FIGS. 7-10 and elsewhere. Dependency routes are formed from a subset of all possible software elements to advance an installation goal. Moreover, dependency routes reflect customer installation choices, analysis of the installation success, and feedback to the map concerning the same. The installation feedback is captured in a confidence factor tied to a given dependency route.
  • [0116]
    Dependency routes do not exist automatically from the creation of the dependency map. Dependency routes are first defined when a specific installation is undertaken by a dependency route calculator. The routes are refined over time based on success and failure feedback based on the actual install. FIG. 13 is a block diagram illustrating an embodiment of the components involved in generating a dependency route. In the service provider arrangement set out in FIG. 13, there is both a customer environment and a service provider environment. In Section III above, the concept of a software installer or software management agent operating on the client environment was discussed. The software agent 1350 is a client-based service that manages communication with the service provider hosting the dependency map 1310.
  • [0117]
    In concurrence with FIG. 13, FIG. 14 is a flow diagram illustrating the operations performed by the service provider to calculate a dependency route overlay for a client system or systems. First, the client relays software installation requests to the software agent 1350 (operation 1400). In an example, it may be the goal to install, on a client system, the fastest version of Apache 5.5 that runs on Solaris 9. Upon receiving the request, the software agent 1350 obtains the current software manifest for the client computing system (operation 1400). In other words, the software agent obtains a complete collection of all software applications and their configurations and provides the manifest to the service provider system. In one particular implementation, a software manifest monitor 1355, which is coupled to the software agent 1350, performs this function. The software manifest monitor 1355 monitors, whether periodically, intermittently or otherwise, changes to the client's software manifest. As changes are made to client's system the software manifest monitor 1355 records them. Hence, when a request for the client's software manifest is made by the software agent 1350, the software manifest monitor 1355 compiles the manifest and transmits it to the service provider, via the software agent 1350.
  • [0118]
    Once the software manifest and installation requested is received by the service provider (operation 1400), the route manager 1305 analyzes the client's software manifest and creates a dependency route overlay on the dependency map (operation 1410). A dependency route overlay 1320 is a structural overlay placed on the dependency map 1310, including each software element in the client's manifest. Hence, the installation overlay is initially a snapshot of the elements of each software application installed on the client's computing system. In order to carry out this service, the route manager 1305 begins with the first software element in the manifest and searches the dependency map 1310 for the same element. Once found, the element is flagged as the start of the dependency route overlay 1320. The route manager 1305 continues this process through each software element in the manifest until they are all flagged in the dependency map 1310 and placed into the dependency route overlay. Next, the route manager 1305 assesses the declared dependencies between each of the software elements in the manifest and recreates these dependencies in the dependency route overlay. Just as dependencies between elements are used to define a software boundary overlay 1315, dependencies between software elements in a dependency route overlay 1320 are also used to define the relationship of each element that comprises the manifest of the client's computing system. Lastly, the route manager 1305 defines a relationship (draws a line) between each software element in the client's manifest. The line will only connect between two elements by way of the dependency that connects them. Hence, the line will not connect between two software elements if there wasn't a dependency that already connected them.
  • [0119]
    Once the route manager 1305 completes the dependency route overlay over the dependency map 1310, a start point calculator 1325 determines the start point of the client's dependency route overlay (operation 1420). The start point is the current state of the client's software manifest before any additional changes are made to it. At this point, the current state (i.e., start point) of the client's environment is recorded in a persistent store 1330 (e.g., data warehouse) and time stamped for future reference (operation 1430). For example, the timestamp can be later used to intelligently back out of a future install, which is further described in Section VI. Next, an end point calculator 1335 is used to calculate an end point based on the client's install request (operation 1440). In one example, the state of the client system start point is known to run Apache 4.0 on Solaris 9.0. Whereas, the end point of the client's system would be the fastest version of Apache 5.5 running on Solaris 9.0. Therefore, the difference between the start point and the end point is a compilation of the software elements that must be added and removed to transform the client system from its current state of software elements (i.e., start point) to its new collection of software elements (i.e., end point.) The software elements used to get the client system from the start point to the end point is known as a route calculation overlay, which will be described below.
  • [0120]
    In one particular embodiment, each time the client wishes to add or remove software from their system, the start point is recalculated based on the current software manifest and not assumed from a previously stored start point located in the persistent store 1330. This is due to the possibility of software drift. Software drift occurs when the current state of a computer's manifest changes due to the manual removal of certain services or files on the computer. This usually occurs when a system administrator wishes to remove certain portions of code from an application or OS. For example, the client system may contain ksh, csh, tsh as part of its Unix OS scripting inventory. In order to reduce the chance that someone will use ksh, a system administrator may remove ksh from the OS. This change would not be known by the previous start point. Hence, the route manager 1305 and start point calculator 1325 conducts a new analysis of the client manifest and creates a new dependency route overlay 1320 and start point each time the client wishes to make a change to their system.
  • [0121]
    Once the start point and end point have been determined by the respective calculators, the overlays are passed to a route calculator 1340 that plots a complete route between the start and end point (operation 1450). In one embodiment, there are numerous routes that exist between the start point and end point. This is why confidence factors and weighting of dependencies are valuable. One function of the route calculator 1340 is to compute the total dependency confidence value across a route and declare its confidence factor. For example, there may be 23 possible routes between the start point and end point. Beginning with the first route, the route calculator will summarize the dependency confidence factors across each dependency in the route. The route calculator 1340 uses calculations to arrive at a summarized confidence factor of the entire route. In one embodiment, the dependency route confidence factor is determined by summarizing the confidence factor between each dependency and dividing it by the total number of dependencies.
  • [0122]
    A list of routes may then be presented to the client with the route having the highest level of calculated confidence being presented first (operation 1460). Lastly, the system administrator selects the route they wish to use. In another embodiment, the client system may be automatically configured to trust the route with the highest level of confidence and install the solution automatically.
  • [0123]
    FIG. 15 is a block diagram illustrating an example of a dependency route overlay. FIG. 15 shows a plurality of software elements 1530 that comprise an example of a dependency map 1500. The bounds of the dependency map 1500 are shown by the line encompassing the software elements 1530. Each software element 1530 has at least one dependency upon another software element. The dependencies 1520 are shown as straight lines that connect two software elements 1530. A dependency route overlay 1510 is also shown. In one example, the dependency route overlay 1510 is a path drawn around a plurality of software elements 1530 needed to bring a client computing system from its current state to the state it would be in after the requested installation. This example illustrates a single dependency route overlay 1510. However, a dependency map 1500 would likely comprise a plurality of dependency route overlays 1510, each representing different dependency routes for installing a software application.
  • [0124]
    In a particular implementation, automated installation policies may be put into place on a client computing system. Such policies give system administrators complete control over all installation options. On the other hand, installation policies can learn, over time, an administrator's preferences and desired level of manual interaction. One purpose of such installation policy is to allow for as much automation, regarding installation decisions, as possible.
  • [0125]
    Policy may be defined within each software application's dependency route and/or within each client system's software agent. In one example, each dependency route includes a statically defined policy. The policy may state that upon completion of the installation, perform an automatic reboot of the system. The policy definition may also comprise policy information about user preferences. For example, the policy may ask the user's permission to reboot, or proceed automatically. Over time, the default policy definitions attached to each dependency route may change. As dependency routes are installed, the software agent from each client returns success or failure information regarding the individual install of the software application. The dependency map may consider these statistics when determine policy definitions. For example, a policy definition may state that user permission is requested for each installation step. Over time, the installation success rate of this route may increase dramatically. As a result, the default policy definition of this route may change to “proceed automatically” instead of requesting user permission to continue. Such a change is the result of increased confidence in the installation success of the dependency route.
  • [0126]
    By implementing such an approach, the amount of manual involvement by system administrator may decrease. If a dependency route has a high confidence factor, due to the number of previously successful installs, the route may be configured with a policy to automatically implement the route which does not involve the administrator. On the other hand, if a dependency route has unsuccessful installations, a default policy that involves the administrator would decrease the likelihood that the install may fail. In one embodiment, a threshold confidence factor along with the number of installation attempts may be used to determine the level of automation within a route's installation policy. For example, a dependency route that has been installed 800 times with a confidence factor of 87% may have an installation policy with increased automation. Whereas, a dependency route that was installed 4 times with a confidence factor of 50% may have an installation policy with reduced automation.
  • [0127]
    The second place that user policy is defined is in the software agent of each client system. In one embodiment, the default policy stored in the software agent may override the default policy tied to a specific dependency route. In other embodiments, a combination of the dependency route policy and the software agent policy may be combined to arrive at a hybrid policy definition. For example, if a new dependency route without previous installation history is chosen, then the default policy of the dependency route may be combined with the default policy of the software agent. If the software agent's policy allows for automated installation in all cases, then the new route will be installed regardless of its confidence factor. In another example, a software agent's default policy may request administrative interaction regardless of the confidence factor of the chosen dependency route. Even if the chosen dependency route has 1500 installs with a confidence factor of 98%, the administrator would still be requested to interact during the installation.
  • [0128]
    When a client requests a software application to be installed on a system, optimization of the system prior to installation is another consideration. A client may request that Apache 5.5 be installed in one of many ways. Although the software boundary overlay of Apache 5.5 does not change, the dependency route plotted through this overlay may change depending of the installation choice made by the customer. For example, the system administrator may wish to install Apache 5.5 with a configuration including: 1) the least number of software elements required; 2) the least disk space needed; 3) the least errors reported; or 4) the latest security updates. Each one of the options or combination of options may result in a slightly different dependency route. In order to analyze and plot a dependency route, the route manager will also consider the current state of the client's system. As stated above, the client's software agent will upload the client's current software manifest to the route manager for analysis.
  • [0129]
    In one embodiment, it is possible that the current state of the client's computing system will require some changes in order to install the new application based on the preferences chosen by the system administrator. For example, the client's computing system may contain no software other than a fresh installation of the Solaris 9.0 OS. If the administrator wishes to install the most stable version of Apache web server, a number of changes or optimizations to the current client system may be required. For example, in order to install the most stable version of Apache, Solaris may need to be upgraded from version 9.0 to version 9.1 (release B). Such a change may be unacceptable to the administrator, as they may plan on installing an additional application that requires Solaris 9.0.
  • [0130]
    When a dependency route is being calculated by the route manager, as discussed in regards to FIG. 14, any required changes to the existing client's software configuration or versions will be provided to the system administrator. Assuming the changes are acceptable to the administrator, the software agent will apply these changes to the client's system before installation of the new software application begins. If the changes are not accepted, a different installation and/or preferences must be redefined such as installing the most stable version of Apache that works on Solaris 9.0.
  • [0131]
    In order to provide an accurate installation dependency route to a client, it may be necessary to provide multiple iterations of the route to the client. The reason for multiple iterations is due to the potential of the first route being incomplete or inaccurate. Hence, additional routes may be needed, with each iteration improving on the errors discovered in the previous route.
  • [0132]
    FIG. 16 is a flow diagram illustrating one method involved in presenting an accurate dependency route to a client computing system. As previously described, when the route manager receives an initial software installation request from a client device, the relevant portion of the client software manifest is also submitted to the route manager (operation 1600). In a particular implementation, less than the entire software manifest is sufficient for the route manager and other components to generate a dependency route. The software agent running on the client determines which portions of the software manifest are relevant to the installation request and only transmits those portions. Logic is built into the software agent that permits the agent to analyze the software manifest and the installation request and resolve which portions of the manifest are likely needed by the service provider in creating the dependency route based on the installation request. If the portion of the manifest sent is insufficient, additional portion may be transmitted as needed. Providing only a portion of the manifest reduces the amount of information being communicated to and analyzed by the route manager.
  • [0133]
    The route manager may next calculate a complete dependency. Alternatively, the route manager may calculate a rapid dependency route through the dependency map based on the software elements needed to complete the installation (operation 1610). A rapid dependency route describes the first route that is calculated based on a first pass through the dependency map. This route may not be relevant to any previous routes or may not take advantage of confidence factors, etc.; thus it may not be the most optimal route. However, the rapid dependency route is the easiest to calculate since it is based on absolute dependencies. In other words, the calculated route only includes dependencies between elements that will always exists, such that a confidence factor is ineffectual, as the dependencies are not optional.
  • [0134]
    In one embodiment, the dependency route is packaged as an XML file and transmitted to the software agent on the client (operation 1620). This initially transmitted dependency route is created in response to the client request, and provides the client with an immediate response to their installation request based on the portion of the software manifest transmitted by the software agent. In this first “rapid” iteration of the dependency route, the route manager is more concerned with providing an immediate response to the client than providing a completely accurate dependency route which takes more time. Such an approach provides real-time feedback to the system administrator, with accuracy refinement coming after the system administrator chooses a route. As mentioned above, it is possible to set forth an implementation that does not employ “rapid” dependency route calculation, but rather transmits a more complete route.
  • [0135]
    Once the system administrator approves the dependency route, the software agent on the client begins processing the dependency route (operation 1630). If there are no errors or problems with the dependency route, then the installation will complete successfully (operation 1650). However, it is possible that the partially provided software manifest is incomplete or not granular enough for complete determination of the dependency route. In such an instance, the route provided by the route manager may become invalid as the installation progresses. The software agent handles this issue by using a soft reference style connection to an element that does not exist in the current dependency route, but is known to exist. The software agent transparently initiates a web services request back to the service provider and requests a reroute through the dependency map (operation 1640) based on the declared soft reference. The route manager provides the reroute information back to the software agent on the client (operation 1660), allowing the agent to continue installation. In one embodiment, the software agent comprises both a main logic layer and a business logic layer. The main logic layer is responsible for communication with the service provider, as well as receiving dependency route information. The business logic layer is unaware of the processing of the main logic layer. The reroute request is handled by the software agent's main logic layer. Therefore, the business logic layer is unaware of the network reroute. In other words, the business logic layer receives continuous instructions from the main logic layer to proceed with the installation. If a change in the instructions, due to a network reroute, occurs at the main logic layer, the business logic layer is unaware of these changes and continues to receive instructions as if nothing has changed. Hence, the business layer of the software agent continues with the installation based on the reroute (operation 1670) without knowledge of underlying changes that may occur. The installation continues until completion (operation 1650).
  • [0136]
    In order to perform a reroute, a number of parameters are considered by the route manager. In a first parameter, the route manager determines whether specific software modules are included as new in the installation request. This is often the case as these modules may not be explicitly called out in the manifest. For example, a requested patch (Patch A) introduces a new library that has a side effect. Further, patch A is introduced to fix a security hole in an OS. Patch A may also include a new version of libSocket. Additional applications may use libSocket and depend upon it based on its current version. The new version of libSocket may have new changes in the functional profile of libSocket, such that the applications that relied on the previous version may stop operating correctly. In order to address such an issue, the route manager will create a reroute to include all of the updated applications based on the new version of libSocket.
  • [0137]
    A second parameter that may be considered by the route manager when performing a reroute is a historical request. As previously stated, the dependency map maintains historically successful installation routes. If a client requests an installation that matches one of these historical routes, the reroute will include this additional information which may reduce the information included in the re-request. This acts as a predictive model for the routing system by utilizing historically successful route information when possible.
  • [0138]
    The third and last parameter that may be considered by the route manager during rerouting is a declared dependency in the software installed on the client system that is not included in the dependency map. This will usually occur for custom software packages that are already installed on the client system yet are unknown to the dependency map.
  • [0139]
    In order for a software agent to install a software application based on a given dependency route, the portion (i.e., actual files) of the dependency map that encompasses the route is needed by the software agent. It is possible to host some or all of the files of the dependency map on each client system. However, the size of the map could be so large that local storage would be impractical. Accordingly, in one implementation, the service provider is configured to stream or otherwise transmit the relevant portions of the dependency map to the client system.
  • [0140]
    Further problems may arise due to potentially unrecognized dependencies on the client system that are not included in the software manifest. In result, the initial portion of the dependency map streamed to the client may be incomplete or inaccurate based on unrecognized dependencies in the software manifest that was communicated to the service provider. As previously stated, an unrecognized dependency can occur if a system administrator manually removes files from the system. For example, the software agent may not be aware of such manual changes, hence the software manifest is not properly updated with such changes. This results in a differences between the client manifest and the actual files on the client system. As such, it is possible that the actual dependency route may need to change once the installation begins. Therefore, in one particular implementation, the relevant portions of the dependency map are divided into multiple pieces and transmitted in phases.
  • [0141]
    In an example, once the client submits the initial install request, that request is sent back to the service provider where the request is analyzed. The initial portion of the dependency map, which may involve root software elements relevant to the request, is returned and processed for install by the software agent. This is the first phase of the installation, which involves installation of the root software application. Next, the total route length is calculated. The route length is defined as the number of individual software elements that comprise the dependency route. Based on the confidence factors of each dependency in the route, the route is calculated at specific steps along the way such that the entire path may not always be known from the start. In other words, as the dependencies between each element in the route are calculated with a summarized confidence factor, the route may change if the confidence factor drops below a threshold. As long as the summarized confidence factor of the dependencies maintain above the threshold, the route will continue without deviation.
  • [0142]
    In another embodiment, a route may be recalculated if the software elements already installed on the client require the route to be changed. Such a situation arises when software is present on the client's system, yet is not explicitly declared by the software manifest. An example might be if a library that is versioned and has a dependency present based on a symbolic link. If route calculation drives the software agent to an unresolved software dependency on the local dependency map, hosted by the client, a request will be sent to the service provider causing calculation of an additional segment of the dependency map, which is subsequently streamed to the client. This route calculation is based on the route path that has been recalculated by the software agent on the client. The service provider follows the route path and sends back the relevant part of the dependency map to the client. The client then continues its installation until completion. This recalculation can occur many times and is highly related to the size and complexity of the installation job that is requested by the client.
  • [0143]
    Aspects of the present invention may further involve the inclusion of confidence factors with a dependency route provided to a client from the service provider. As previously described, the service provider often transmits multiple dependency routes to the client. Each of the routes may have a confidence factor. These confidence factors provide a system administrator with a weighted scale of which route will likely result in a successful installation. Confidence factors for each dependency route can change based on a variety of factors. As installations are attempted on client devices based on a given dependency route, the service provider system collects the successes or failures of the installations. This collected data is provided to the service provider system as feedback from the software agents based on each installation in one particular embodiment. As a specific dependency route results in more successful installs, its confidence factor increases. In contrast, if a dependency route results in failure, its confidence factor is diminished. In the end, the best choice for the client will be provided by understanding successful installations that have previously occurred and using this information to provide the best solution.
  • [0144]
    Confidence factors explicitly apply to dependencies between individual software elements. Whereas, a confidence factor of an installation route may be implicitly represented based on the average of the confidence factors for each dependency within the route. For example, if a dependency route has three dependencies with confidence factors of 100%, 65% and 75%, the average confidence factor of the dependency route is 80%. The value of each confidence factor may change over time. As more installations are performed and feedback received from software agents, the confidence factor of each dependency between two software elements becomes more valuable. For example, if feedback from a particular installation route is positive (e.g., successfully installed), the confidence factor for each dependency in the route is increased accordingly. In result, the implicit confidence factor of the installation route is also increased, based on the average of the individual confidence factors from the dependencies that represent the route. As such, the more installations that have provided feedback on a dependency route, the more valuable the confidence factor of each dependency within the route becomes. In an example, dependency route A consists of 1000 dependencies with an average confidence factor for the dependencies of 100%, based on three installations. Dependency route B consists of 1000 dependencies with an average confidence factor for the dependencies of 78% based on 450 installations. The averaged confidence factor of dependency route B may be more valuable that dependency route A based on the frequent use of dependency route B.
  • [0145]
    In order to build a confidence factor for an individual dependency or an entire dependency route, the service provider may receive feedback from software agents during client installations. In one particular arrangement the software agent is configured to monitor the installation for errors. During an installation, any errors detected by the software agent are sent to the service provider hosting the dependency map. The software agent may send the actual error string, the software element that caused the error and the current location within the route where the error occurred. To begin analysis of the errors, the service provider will launch an analysis service to begin parsing the error string. The analysis service identifies references to any files that may have already been installed on the client system prior to the installation. This may point to problems with pre-installed files. For example, an existing application may have already experienced runtime errors. Hence, the previous state of the client system may already experience problems.
  • [0146]
    Further, the analysis service also identifies references to any known installation problems such a disk space, file system errors or other operating environment problems. As such, the software agent, with the assistance of the analysis service, constantly monitors the client system for failures, as well as other issues such as disk space utilization and speed of installed applications, which are reported back to and included as features of individual software elements and/or installation routes. Software elements and routes also have other features such as a version number of the related software file, security update status, and the like. In one embodiment, the agent monitors file system utilization and the system error log. When the agent detects any errors, the error is correlated to specific files on the client system. The software agent can then communicate this error back to the service provider as an error of a dependency between two software elements.
  • [0147]
    Once an error in an individual dependency has been addressed by the analysis service, the dependency is flagged with the error as well as the reason, if known. This error and its reason are stored as attributes of the dependency. The confidence factor of the dependency is now reduced due to the new error. In one embodiment, the confidence factor is calculated by taking the number of installations involving the dependency divided by the number of successful installations to generate a new confidence value.
  • [0148]
    As previously described, in one particular arrangement, in order for a software agent to install a software application on a client system, a portion of the dependency map is streamed to the software agent along with a manifest of each software element to be installed. In one embodiment, the software agent may perform a pre-installation verification check to verify that the dependency route chosen will install without errors. However, such a check is not mandatory. Further, a threshold confidence factor may be implemented such that a pre-installation verification is only triggered if the confidence factor falls below the threshold. For example, the software agent may be configured to only perform the pre-installation verification if the confidence factor of the chosen dependency route is below 65%. Therefore, a pre-installation verification would not occur on a dependency route with a 98% confidence factor as its chance for success is very high. The threshold may nonetheless be set at any value desired by a system administrator at either the computer-specific level or applying enterprise-wide.
  • [0149]
    Even with a reasonably high confidence factor, it is still possible that an installation based on a chosen dependency route may fail. FIG. 17 is a flow diagram illustrating a method for performing a pre-installation verification. A pre-installation verification may reduce the opportunity for installation-time errors by illuminating such errors during the validation process. In order to perform a pre-installation verification, the software agent receives the relevant portion of the dependency map needed for installation, which includes a manifest that lists each software file needed for installation (operation 1700). Once the dependency map has been received, the software agent scans the manifest of the dependency route to verify that all the files and symbol-based dependencies needed by the installation presently exist on the client system (operation 1710). As described above, symbol-based dependencies are dependencies declared within the symbol table of each executable file. If a missing dependency or software file is discovered during the verification check, the software agent requests the missing file from the dependency map (operation 1720). The dependency map locates and transmits the file back to the software agent (operation 1730). Once the missing file is received, the verification continues until each file and dependency has been determined to reside on the client system.
  • [0150]
    FIG. 18 is a block diagram illustrating another embodiment of the architectural components of a dependency route calculator that additionally stores information about successfully installed routes. In order to identify successfully installed routes in the dependency map, a third dependency map overlay is provided, known as a route calculation overlay 1810. This type of overlay represents each dependency route used to install or remove any software applications managed by the dependency map. In order to track the success or failure of dependency routes, the software agents 1350 provide results of the installation including whether the installation was successful and if not where the installation failed. In one embodiment a software installation monitor 1830 is responsible for monitoring a software installation. If any errors or warnings are detected by the installation monitor 1830, the information is passed to the software agent, who in turn relays the error to the service provider. As previously described, a communication feedback loop 1303 may exist between the software agent 1350 that performs the installation and the route manager 1305. Software installation or removal is monitored by the software agent 1350. If a dependency route is successfully (or unsuccessfully) installed or removed, the success (or lack thereof) is transmitted back to the route manager 1305. If the dependency route already existed as a route calculation overlay, than the confidence factor of that overlay is updated with the success received from the software agent 1350. An attribute of the route calculation overlay tracks the total number of successful and unsuccessful installations. This attribute is then incremented based on the success of the installation.
  • [0151]
    Another attribute of the route calculation overlay stores a timestamp of each installation attempt. This attribute allows for queries to be made as to how many successful or unsuccessful installs have occurred as well as the date and time of each install. On the other hand, if the specific dependency route did not exist, the route manager 1305 creates an overlay of the dependency route and provides an initial confidence factor to the overlay and a first value in the timestamp attribute. In one embodiment, the initial confidence factor is set to zero, as no data has been provided.
  • [0152]
    When the dependency map 1310 is initially created, no route calculation overlays exist. As installations occur, calculation route overlays are created. Over time, the number of overlays and their timestamp attributes will increase. However, it is likely that after a certain period of time, the number of unique route overlays may stabilize after the initial increase, as there are a limited number of installation paths available.
  • [0153]
    As stated above, the route manager 1305 considers the start point and end point of the client when building a dependency route for the client. The route manager 1305 searches the route calculation overlay 1810 for all possible routes along with their corresponding confidence factor. In one embodiment, it is possible that a route overlay may not exist that would include each software element needed to get the client from their start point to their end point. In such a circumstance, some level of deviation between the start point and end point may be allowed such that the finalized dependency route is slightly modified based on the differential between the start point and end point. In such an embodiment, it may be preferable to provide a slightly deviated route overlay that has been successfully installed rather than a completely customized overlay that has never been installed. Once all the dependency routes are calculated by the route manager 1305 they are passed to a route matcher 1825 which attempts to find exact matches in the route overlay followed by a degrading analysis to find nearest matches. In one embodiment a 10% deviation (i.e., the number of different software elements between the preferred route and the deviated route is 10% or less) is acceptable. For example, if the preferred route has 1000 elements and the deviated route has 980 elements of which 910 of the elements are the same, the deviated route would fall within 10% deviation.
  • [0154]
    The nearest matched routes are then analyzed around the start and end points to see how important the deviation is and if it can be legitimately corrected. Based on the possibility of a deviation, the confidence factor for a given route may also change. In one embodiment, the route manager 1305 may calculate the overall confidence factor based on the following equation: Route confidence=(0.1(1+Number of times route already used)*base dependency confidence calculation of route)/dependency confidence of any deviation from route. The above equation may promote the continued reuse of a route that has been successfully installed and reflects that the more use it has the less the risk the deviation becomes.
  • [0155]
    One consideration to be addressed by a service provider hosting a dependency map is the physical storage requirements for hosting the dependency map and all its software applications. One approach to storing this data is a software warehouse. Large amounts of disk space may be needed to store the dependency map data. For example, a single software application may require multiple gigabytes of storage space. Hence, a software warehouse storing hundred of applications and OS could reach well into the multiple terabyte range of storage space. Over time, the number of software applications stored in a software warehouse may continue to grow. Not only may the number of different applications increase but the number of versions of each application may increase as well. It is possible that the size and cost of storing all this data may become prohibitive unless measures are taken to phase out certain applications from the software warehouse based on differing criteria and to only store current software.
  • [0156]
    One approach for determining whether to phase out software or keep it as current, is to base the decision on the support of the actual software vendor. If a given software vendor happened to provide support for only the current and previous two versions of their operating systems, then there would be little need for continued hosting unsupported operating systems. Each software vendor has their own rules on how far back they will support their software versions. Hence, a vendor by vendor analysis may be used to determine when software versions can be phased out of the software warehouse.
  • [0157]
    Another approach for determining which software should be flagged as current and which may be phased out is based on usage patterns from customers (discussed as aging below). As previously stated, each time a software element or route is used in an installation, a timestamp is recorded of its use. These timestamps may be used in determining the frequency by which the software elements are accessed. An advantage to hosting software applications at the software element level allows for added flexibility to phase out portions of a software application, while only maintaining the current portions. For example, Apache 5.5 may have 10,000 software elements that comprise the entire software boundary overlay. Of these 10,000 elements, actual dependency routes may only include 5000 of the software elements over a specified period of time. Therefore, it may be possible that the unused software elements are no longer needed, and may thus be phased out (removal from warehouse or otherwise as discussed below).
  • [0158]
    FIG. 19 is a flow diagram illustrating operations involved in determining which software elements to phase out (also referred to as “aging”). An aging process controlled by the dependency map periodically analyzes the map and the recent time stamps associated with each software element (operation 1900). The aging process analyzes each software element and determines the amount of recent use and assigns the element a use factor (operation 1910). The use factor is determined by the number of times the software element was accessed over a pre-determined time period.
  • [0159]
    Next, the aging process analyzes the number of dependencies connected to the software element and the confidence factor of each dependency. Since dependencies have a confidence factor tied to them, the confidence factor of each dependency is summed and an average is drawn across all the dependencies for the element (operation 1920). A pre-determined threshold value exists to determine whether to age the software element (operation 1930). In one arrangement, if either the use factor or total dependency confidence factor fall below the threshold, the software element is aged (operation 1940). In an example, the threshold value is 42%. Software element A has been assigned a use factor of 47% based on it use over the past 30 days. Element A also has three dependencies, each having a confidence factor of 20%, 90% and 10%, respectively. The average confidence factor of element A's dependencies is 40%. Hence, the use factor of 47% is above the predetermined threshold of 42%. However, the confidence factor of 40% falls below the threshold value, resulting in the software element being aged. In another embodiment, a software element is not aged unless both the use factor and the total dependency confidence factor fall below the threshold value. The method described above is merely an example of how software elements may be aged. As such, additional methods may be used to determine which software elements may be aged.
  • [0160]
    Once a software element reaches a certain age, it may be removed from the dependency map, or otherwise identified as “aged”. In a first level of aging, a file represented by a software element may be moved from the primary hard disks that comprise storage for the software warehouse to a slower retrieval mechanism such as tape drives or slower disk drives (e.g., slower seek times, RPMs, cache, etc.) In this level, access to these elements are still possible, but with reduced retrieval performance. In a second level of aging, software elements that have not been referenced through dependency routes are aged into an offline storage. The elements are no longer maintained in the dependency map, however, a link to the elements still exist. After 90 days, the reference from the dependency map to the element is removed. In another approach, the file represented by the software element is also removed from the software warehouse. However, a log is maintained of previously removed elements for future retrieval if needed.
  • [0161]
    The purpose of aging software elements and removing them from the software warehouse is to reduce the exponential size of the warehouse. As software applications are added to the dependency map and the warehouse, the warehouse increases in size. As a relational database grows in size, its performance diminishes. The “aging” process permits the dependency map to continue to add software applications and dependency routes, while maintaining acceptable performance in the underlying warehouse that hosts the software applications.
  • [0162]
    Another consideration for a service provider hosting a dependency map is the division of software applications that occurs across multiple vendors. It may be the case that a single service provider will not host a dependency map and software warehouse for all software applications across different vendors. Accordingly, in one implementation, dependency maps from different vendors are linked together. In one example, each software vendor, or other party hosting a dependency map may have links to other dependency maps, allowing a customer to access dependency routes across multiple vendors.
  • [0163]
    In one arrangement, the linking of vendor specific or other separate dependency maps provide a virtual dependency map. The virtual dependency map is accessible by the software agent on each client. The virtual dependency map is an accumulation of many separate vendor maps. Each vendor dependency map knows the location of every other vendor dependency map by way of one or more soft references to the other vendor dependency maps. These references are in effect dangling references, as discussed above, that will be fulfilled when connected by dependencies from other dependency maps based on a request made from a customer to install applications that span two vendors. Hence, a plurality of individual vendor-hosted dependency maps can be connected to each other when needed.
  • [0164]
    In an example, a customer may wish to install Apache 5.5 on Solaris 9.0. In this example, two different vendors supply the software applications and host the dependency maps, thus two different dependency maps are accessed. The software agent on the customer's client system may query one dependency map for the optimal dependency route for installing Solaris 9.0. Next, the software agent on the client system identifies a soft reference to the Apache dependency map. The software agent uses a lookup request to obtain the uniform resource indicator (hereinafter “URI”) of the Apache dependency map that fulfills the soft reference. The two separate maps are thus functionally combined to create a “virtual” map for the purpose of providing a dependency route installing Apache 5.5 on Solaris 9.0 of a target computer.
  • [0165]
    In anther embodiment, the use of soft references to connect multiple dependency maps can be used in an opposite approach by dividing a single large dependency map from an organization into smaller and more manageable maps. Each dependency map would have a soft reference allowing it to be connected to the other dependency maps within the organization.
  • [0166]
    In one embodiment, each map could be divided across product lines, vendors, or other division criteria.
  • V. Enriching the Dependency Map by Monitoring Software Installations and Performance
  • [0167]
    As described in Section IV, dependency routes include attributes that store additional information about a dependency route. Such information includes the number of successful and unsuccessful installations based on the route as well as timestamps for each installation attempt. Tracking installation-time success and failure is not the extent of the information that may be associated with each route. In addition, tracking run-time failures as well as performance data is also possible, besides other information. In order to track this type of information, additional modules may be coupled to the software management agent as shown in FIG. 20. FIG. 20 is a block diagram illustrating another embodiment of the architectural components of a software management agent that tracks and analyzes information about run-time failures and performance statistics of successfully installed routes. In this embodiment, the software agent 1350 further includes one or more software error detection modules 2010 and software performance analysis modules 2020.
  • [0168]
    In one embodiment, run-time errors and execution analysis is performed by the software error detection module 2010 which may include two sub-modules; an event detector and a log file watcher. The event detector is configured to detect problematic events in the software that is being installed by the software agent. The event detector may be configured to perform simple network management protocol (“SNMP”) sniffing, core or memory image dumps, java stack detection, etc. By contrast, a log file watcher tracks pre-determined log files looking for conventional textual entries associated with system error logs or application specific error logs.
  • [0169]
    The software error detection module 2010 is further configured to receive input from the system administrator regarding the type of errors to monitor and how to determine if such errors should be flagged. Hence, each error detection module includes a definition construct, defined by the system administrator, describing the module's responsibilities. In the case of an event detector, the definition construct describes which type of events to monitor and whether a given event type should be defined as an error. In the case of file log watcher, the definition construct describes which type of log files to monitor and which type of log events should be flagged as an error.
  • [0170]
    In one particular arrangement, there are individual software error detection modules 2010 for each application on the client's system. The software agent 1350 then uses these modules to watch for errors that are associated with individual software applications. As errors are detected by the individual software error detection modules 2010, the software agent 1350 periodically sends these errors and the client software manifest back to the route manager 1305. The route manager is further tasked with applying these errors to the dependency route or routes associated with the error in question. The error is then computed into the existing confidence factor, thereby reducing the factor to some degree.
  • [0171]
    The tracking and analysis of performance data is similar to tracking errors such that software performance analysis modules 2020 are deployed to monitor the performance of each software application installed on the client's system. In one embodiment, there may be only one software performance analysis module 2020 configured to monitor all the software applications. In another embodiment, there may individual analysis modules 2020 for each software application. The module is configured to define what type of performance variables to monitor and for which software applications. Such performance variables may include, but are not limited to, the timeframe required to execute certain functions, the number of processor clock cycles for performing a function, etc. Once performance information is gathered by the analysis module 2020, the information may be submitted to the route manager 1305 along with the dependency route used to install each software application. In one embodiment, a performance rating may be applied as an additional attribute to dependency routes. Once additional performance information is submitted to the route manager, the performance information may be averaged into the existing performance rating.
  • [0172]
    Further, the performance rating of this route may be compared to the performance ratings of additional routes. This permits the route manager to order other dependency routes, with the same software configuration, based on performance.
  • VI. Software Installation Simulation and Intelligent Software De-Installation
  • [0173]
    Another feature of using a dependency map to create a software dependency route is the possibility of simulating a software installation. By understanding the precise state of a start point, the exact installation effects of a request can be simulated using a virtually provisioned operating system. Such a simulation can allow system administrators to see the effect of the installation with complete accuracy, yet without having to physically install the software. There are many benefits to simulating a software installation. For example, a requested installation of a software application may generate a dependency route with a low confidence factor. Accordingly, the administrator may wish to test whether the install is likely to work in their environment without having to install the software beforehand. In another example, a returned dependency route may have little or no confidence factor weighting tied to the route. This would be the result of very few, if any, installations having been attempted with the route. Running a simulation allows an administrator to verify whether the installation will be successful.
  • [0174]
    FIG. 21 is a flow diagram illustrating the operations for performing a software installation simulation. When an administrator requests a simulation of a software application, they would proceed by defining the request through the software agent on the client system (operation 2100). The simulation request would be similar to a traditional installation request in that the system administrator would define the application to be installed and any special configuration options they require. For example, they may wish to simulate the affects of installing the latest version Apache 5.5 on Solaris 9. Once the request is relayed to the software agent, the request, its configuration parameters and the current manifest of the client are transmitted to the route calculator (operation 2110). The route calculator uses the dependency map to back trace the software elements needed to install the software based on the manifest (i.e., start point) of the current software inventory on the client system (operation 2120). As with actual installations, the service provider will often return multiple dependency routes that meet the criteria of the simulation request. Each route may also comprise confidence factors, allowing the administrator to decide which route to simulate (operation 2130).
  • [0175]
    In order to simulate an installation of a software package a mirror image of the client's system is needed. This includes a virtually provisioned OS as well the other software applications and services which resides on the client. By having a copy of the client's manifest, the route calculator can create a virtual dependency map of the client OS and the other applications and services that exist on the client (operation 2140). Next, a dependency route is created for the OS residing on the client system (operation 2150). This route includes every software element and dependency needed to rebuild the OS exactly as it exists on the client system. Next, a separate dependency route is created for each software application and service that exists on the client system (operation 2160). Lastly, the simulated dependency route selected by the administrator is provisioned. In one embodiment, a plurality of dependency routes exist (e.g., one route for the OS and one route for each software application on the client) that may be joined together into one large route (operation 2170). It is possible that joining two dependency routes together is straightforward if all the dependencies between the two routes are already realized. However, it is possible that an interim dependency route may need to be created to connect unrealized dependencies between the individual routes.
  • [0176]
    Once all the dependency routes have been joined, the complete route is validated by verifying the dependencies of the elements in the route and resolving any dependencies that are incomplete (operation 2180). In one embodiment, this validation is a step-by-step model that creates a stack of all the software elements created and their dependencies. The stack is responsible for storing the validation results. Upon completion of the validation, verification is made that there are no dangling references (operation 2190). However, if any dangling reference are reported from the validation process, the dangling reference is returned to the system administrator and the validation process halts. Since a dangling reference is typically not permissible in the installation of a software application, the simulation shows that the simulated dependency route would not be installed successfully.
  • [0177]
    One type of issue that a simulation may be unable to recognize or fix is the possibility that some piece of software needed for an installation is unavailable. In other words, it is possible that the software manifest of a client system includes a dependency that is unforeseen or unrecognized by the service provider. Hence, this embodiment focuses on the need for on-the-fly resolutions of problems in the installation phase that may not be recognized during simulation or analysis of dependencies. As previously stated, each client system contains a software manifest that lists every software element on the client system. When a client requests software to be installed, the client manifest is uploaded to the route calculator by the software agent. Access to the manifest permits the route calculator to determine the start point of the client's system. If the client manifest is incorrect for some reason, then the dependency route created by the route calculator may cause installation-time errors.
  • [0178]
    Normally the items contained in the client manifest are updated as software applications or services are installed or deleted. For example, if a software service is deleted from the client, each file that has been removed is reflected in the manifest. Under most circumstances the manifest accurately reflects the current state of the client system. However, a client manifest may have inaccuracies for a number of reasons. One common situation that may cause inaccuracies occurs when manual changes are made to the client system by a system administrator. For example, a system administrator may have Solaris 9 installed on the client. By default, CoreLoginServices, a module of Solaris, is installed. CoreLoginServices includes a number of individual login shells for accessing a UNIX server. One of the login shells, sshd, is a secure login shell. It is possible for a system administrator to manually delete this shell and its associated files to prevent others from accessing the server from this method. However, a manual deletion of this shell would not show up in the client's manifest because the manifest is only updated based on changes that occur through the control of the software agent. Therefore, if an administrator wishes to simulate an installation of Apache 5.5 on the client, the uploaded manifest states that sshd exists on the client. In this case, Apache 5.5 may have a dependency on sshd. During a simulation, this discrepancy may not be found since the simulation uses the client manifest to determine the software state of the client. Since the manifest does not show sshd as missing, the simulation will not find this potential problem. However, during an actual installation the absence of sshd will likely cause installation-time errors.
  • [0179]
    One method for alleviating this situation is to add an additional installation validation thread to the software agent running on the client. This thread is concurrently active during installations occurring on the client. During an installation, this validation thread acts as a background process to the software agent running low level validation checks of each dependency in the installation. Based on the above example, the validation thread validates the integrity of each OS command (e.g., sshd) by analyzing any potential log files created from the command being executed. In other words, this thread is tasked with isolating any dependency discrepancies that may occur during the installation that have not been detected during the initial route creation or installation simulation.
  • [0180]
    FIG. 22 is a flow diagram illustrating the operations for validating an installation using a installation validation thread as described above. The validation thread works by analyzing each new software file that is being installed during a software installation. After a software file is installed, the thread identifies each dependency that exists in the dependency route for the software element associated with the file (operation 2200). If each dependency is accounted for (i.e., each software file that depends upon the installed element are found to exist on the client system), the associated element is found to be complete and date stamped as an attribute to the element (operation 2210). On the other hand, if a file is found to have a missing dependency (e.g., sshd) the validation thread requests a pause on the installation (operation 2220). The installed file is then forcibly de-installed (operation 2230) and a network request is sent to the installation map to identify the missing software element (file) (operation 2240). The dependency map receives the request, locates the missing element through a uniform resource locator (“URL”) reference or otherwise, and returns the missing element to the client (operation 2250). The software agent then reinstalls the software element as well as the missing software element from the dependency (operation 2260). Once the validation thread re-validates the software element and all its dependencies as being accounted for, the element is time stamped for completeness and the main installation is unpaused and continues (operation 2270). This process continues through the entire installation until each individual software element and its dependencies are validated and time stamped.
  • [0181]
    In one embodiment, user policy of a client system can be configured to specify the level of validation to be performed by the validation thread. In a minimal involvement, the system administrator can specify that the validation thread simply verify the existence of the files declared in the manifest. Such an approach would be faster in its execution, but less thorough. For example, this approach would not validate the dependencies that exist between each software element, only that the software elements exist. In an intermediate involvement, the administrator can specify that the validation thread validate actual file permissions for all files declared in the manifest. In higher level of involvement, the validation thread can be specified to perform analysis on the symbol tables for each executable in the dependency route. As previously stated, the symbol table for each executable file contains all the dependencies related to the executable file. For example, the symbol table of the executable file called “Is” may show that “Is” imports “PrtOut” which is a routine that allows the printing of text on an output display. PrtOut actually exists as a routine within a C library called libC. Therefore, analysis of the symbol table for “Is” would show that “Is” depends upon libC to operate successfully.
  • [0182]
    One of the benefits of simulating a software installation is to determine whether an installation would be successful without going through the actual installation process. However, there are times when an installation is found to be successful yet there may be reasons that an administrator may wish to back out of the installation after it has been completed. Conventional approaches to de-installing software are converging, in that they go forwards in time trying to merge back to a state that resembles the previously stored state of a system. This feature is also known as check-pointing or convergent software rollback. In order to perform such a rollback, an administrator must create a checkpoint before an installation takes place. This checkpoint takes a snap shot of the client's current software inventory and configuration. If the administrator wishes to return to the checkpoint at some point in the future, the system is actually moved forward by attempting to change the system to conform to the previous configuration as defined in the checkpoint. This often results in a mere approximation of the former check-pointed system due to the way conventional rollbacks are done at the package level and not the file level.
  • [0183]
    Aspects of the present invention offer an approach of moving backward in time to return a system to substantially the exact previous state. In order to allow for such an approach, the dependency map described above implements time tracking of each change to a client system. In order to implement time tracking of manifest changes an additional manifest is created and stored on the client when an installation is performed on the client. This additional manifest includes all of the dependency routes that were used to install all software applications on the client. This additional manifest further includes a timestamp for each dependency route used to install software. FIG. 23 is a flow diagram illustrating the operations for returning a computing system to a previous state. When a snapshot is requested for a client system, all of the dependencies on the client are traced back through the dependency map and the additional client manifest (operation 2300). This allows for a complete manifest to be created. The time-stamped information within the complete manifest allows for an accurate assessment of the routes that were used to create them.
  • [0184]
    At some point in the future when the client requests the system to be returned to the previous state represented by the snapshot, the software agent on the client recovers the new manifest and transmits it to the service provider (operation 2310). This manifest lists all the root software elements, the dependencies associated with each root software element, as well as a the root time dependency routes associates with the root software elements. As previously described, a root software element is an element that does not depend upon any other elements. Once the manifest is received, the service provider analyzes the historical data stored within the manifest and compares it to the dependency map to assess exactly what software elements and versions were installed at the time of the checkpoint (operation 2320). Upon completion, an accurate assessment of the software load at the time of the checkpoint is compiled and sent back to the software agent on the client (operation 2330). The software agent then compares the previous software load against the current software load and compiles a list of all the differences (operation 2340). These differences are then sent back to the service provider where the dependency map is used to assess what software needs to be de-installed and in what order to accurately return the client system to its previous state (operation 2350). Since the dependency map stores the previously installed software for the client, it is possible to properly assess which software elements need to be installed or de-installed. In other words, a dependency route is being constructed where the start point is the current software manifest of the client and the end point is the manifest at the time of the snapshot. Hence, the route contains all the software elements that need to be installed and de-installed to get the client from its start point to its end point. Without such historically collected information, such a de-installation approach as described would be extremely difficult if not impossible.
  • [0185]
    The service provider also uses the time stamped dependency routes from the additional client manifest to understand the differences. These time-stamped dependency routes can be broken down into smaller routes and the differences isolated. Once the differences are understood, metadata stored in each root software element and their dependencies are used to create de-installation and re-installation instructions (operation 2360). Lastly, the instructions are returned to the software agent on the client who carries them out line by line (operation 2370). Once completed, the client system is returned to substantially its exact state at the time the snapshot was created.
  • [0186]
    System administrators are often seeking ways to improve the performance of their systems. Aspects of the present invention permit existing software configurations on client systems to be analyzed by the service provider to determine if changes could be made increase its performance or remove unneeded software elements. In order for a client system to be analyzed for possible performance increases, the client manifest is transmitted to the service provider.
  • [0187]
    In one embodiment, an additional attribute stores with a dependency route is performance statistics. The software agent installed on each client may monitor the run-time performance of an installation, based on a specific dependency route, and communicate this performance information to the service provider. The performance data is then stored with the dependency route. As additional performance information is received from additional clients, the performance rating of the route is changed. If changes to a configuration are detected by the route manager that may increase performance, a list of such changes may be complied by the service provider and streamed to the software agent in the form of dependency routes that would install and de-install software elements as needed to change the installation of the software application to match the software elements that comprise the selected dependency route. The service provider could also provide performance information to the system administrator as a reason to perform the suggested changes. Further, such metrics could be used to give reasons why an updated version of an already installed application would be beneficial, resulting in additional revenue for the vendor or service provider. Once changes have been streamed to the client, they can be implemented by the software agent.
  • [0188]
    In another embodiment, the service provider could further analyze the client manifest to determine if there any installed software elements on the client that are not needed for the current configuration. If such elements are discovered, the service provider could transmit a list of the elements that may be de-installed along with a dependency route that would de-install these elements.
  • [0000]
    software application to match the software elements that comprise the selected dependency route. The service provider could also provide performance information to the system administrator as a reason to perform the suggested changes. Further, such metrics could be used to give reasons why an updated version of an already installed application would be beneficial, resulting in additional revenue for the vendor or service provider. Once changes have been streamed to the client, they can be implemented by the software agent.
  • [0189]
    In another embodiment, the service provider could further analyze the client manifest to determine if there any installed software elements on the client that are not needed for the current configuration. If such elements are discovered, the service provider could transmit a list of the elements that may be de-installed along with a dependency route that would de-install these elements.
  • [0190]
    Another solution available to system administrators through the use of dependency maps and dependency routes is server software duplication. It is common for a system administrator to substantially duplicate a software configuration across many servers. An example would be a large website that has a large amount of Internet traffic. Conventionally, in order for the website to manage the high traffic volume, a plurality of servers and a load balancer are used. Each server would comprise identical or substantially identical software configurations so that someone browsing the website hosted by the servers would see the same website no matter which server they were directed to by the load balancer. In any arrangement, it is possible for two servers to include the same functional software arrangements, but nonetheless differ by having different device drivers, different network connection drivers, etc., when different hardware or network connections are associated with the servers.
  • [0191]
    Conventionally, in order for a system administrator to configure multiple servers with the same software a common set of software distributions are created. The administrator would then use this distribution set to copy all the software onto each server. One problem with this approach is the inability to track or fix deviations or performance enhancements at the software element level, as the software would have been installed by the conventional package approach as described in the background section of the present application. In order to make changes to an existing software configuration the administrator would need to make such changes manually on the first server and then duplicate this effort across every other server comprising the same configuration. Depending on the number of duplicate servers, this task may be extremely time consuming as well as prone to human error.
  • [0192]
    In accordance with aspects of the present invention, by using dependency maps and dependency routes, a solution for providing duplicate or substantially duplicate software manifests and configurations across multiple servers is possible. One method for duplicating software across multiple servers is illustrated in FIGS. 24A and 24B. First, a system administrator makes a request to the service provider to make a duplicate configuration on a target server from the current configuration on a source server (operation 2400). The request is uploaded to the service provider from the software agent on the source server. As with all installation requests the software manifest of the source server is also uploaded to and received by the service provider (operation 2405). Once the request and manifest is received, the route calculator attempts to locate a dependency route that matches the installation manifest for the source server (operation 2410). In order for this to occur, a software agent is preferably installed at the source server when it is first brought online. Otherwise, it is difficult for the manifest to accurately reflect the current and historical software load of the source server since a software agent tracks changes to a manifest as the changes occur.
  • [0193]
    If an exact dependency route is not found or if the software agent was not installed for the lifetime of the source server, then a dependency route is calculated based on the currently supplied manifest. As with a normal installation request, it is common for a number of dependency routes to be presented, with each route including a confidence factor based on the number of previously successful installations using the same route (operation 2415). Upon confirmation of a preferred route, the service provider streams the route to the software agent on the source server (operation 2420). As with any dependency route for installing a software application, the route will include every single dependency on other software elements needed to install the application. For example, when installing Apache 5.5 using dependency route Y, there may be 1200 software elements that the route depends upon. Therefore, all of these software elements should either exist on the client or be installed before Apache 5.5 is installed.
  • [0194]
    Once the dependency route is streamed to the software agent on the source server, the software agent will analyze the dependency route and match it to the current software load on the source server (operation 2425). If there are any differences between the software load of the source server and the dependencies required by the dependency route, which is likely, the software agent will remove and install whatever software elements are necessary to ensure that the route accurately reflects the software load of the source server (operation 2430). The purpose of matching the source server's software load with all the software elements and dependencies from the chosen dependency route is to ensure that the target server will end up with a substantial identical software load as the source server once the target installs the dependency route.
  • [0195]
    Once the source server's software load and the dependency route are equal, the target server is assessed. Depending on whether the target server has a software agent installed, two different installation paths would be followed. If the target server does not have a software agent installed, a minimal OS is installed on the target which includes a software agent (operation 2435). In one embodiment, Bar Metal Provisioning is used as previously described. In this embodiment, a bare OS, along with a software monitoring agent, is provisioned onto the hardware machine, erasing any previously installed OS or applications.
  • [0196]
    Once the target server includes a software agent, or if it already had one, the dependency route is streamed to the target server (operation 2440). The software agent scans the current software manifest on the target server and creates a de-installation list of every software element that is not part of the dependency route (operation 2445). Next, the software agent analyzes the file manifest of each software element in the de-installation list and performs a file-level dependency check on each software element to ensure there are no files that are created at runtime but are not under the control of the software elements manifest (operation 2450). An example of such a file may be system-level or application-level configuration files. If any such runtime created files are found, they are flagged in a separate post de-installation list. Once assessed, all the software elements and the de-installation list are checked for additional dependencies which are then added to the post de-installation list (operation 2455). After the software elements and runtime files are deleted, the software load on the target server should not have any additional software elements that are not part of the dependency map. Hence, the software agent only has to add software elements from the dependency map and not delete anything. At this point, the software agent carries out the installation as specified in the dependency map, resulting in a mirror image software load of the source server (operation 2260).
  • [0197]
    Another advantage of managing software with a service provider model is the ability to fine tune software configurations that are currently installed on a client system. As with all software applications, patches, bug fixes or new versions are continuously released by vendors. A vendor will often claim that the latest patch or version is always the best. Often times, vendor support may be denied unless the client upgrades to the current version or installs the latest patch. This approach is often flawed, as a particular patch may fix one thing, yet hinder others. As such, a system administrator may spend a great deal of time trying to determine which patch causes the least problems regardless of its release date.
  • [0198]
    A method for managing presently installed software configurations is described below. As previously described, software dependency routes stored as overlays on a software dependency map represent previously installed dependency routes for one or more software applications. Confidence factors for each route are calculated based on the success rate of an installation based on a specific dependency route. It is possible that a number of dependency routes exist for installing Apache 5.5 on Solaris 9.0 update 1. Each route may have the same end result of installing Apache 5.5, however, each route may have minor nuances that differentiate them in some way. Out of each route, one may be the most stable, one may have better performance statistics and one may be the most secure.
  • [0199]
    In one embodiment, a software dependency map hosted by a service provider comprises two type of nodes; major nodes and minor nodes. Each type of node is comprised of many individual software elements and dependencies. A major node is normally user-requested software that directly relates to the need of the user. An example might be Apache 5.5. Minor nodes are normally software that is installed in order to support the desires of the user. An example might be additional software elements that allows Apache 5.5 run with stability as its main attribute. There are very few major nodes compared to the number of minor nodes. For example, Apache 5.5 may have a single major node. Yet there may be 10 different minor nodes that change the attributes of how Apache 5.5 is configured.
  • [0200]
    In one scenario, a system administrator may want to check and see if there is a more stable install of Apache 5.5 on Solaris 9 (release B), than the current configuration on their client system. If such an inquiry is transmitted to the service provider, it is likely that the minor nodes that support Apache 5.5 are the nodes being analyzed with the major node being untouched. The dependency map would analyze the current configuration of Apache 5.5 based on the client manifest and attempt to find a dependency route that matches this configuration. If such a route does not exist, a new route is created and given a low confidence factor. Next, the dependency map compares this new route to existing dependency routes, along with the confidence factors. If another route is found to have a higher confidence factor (i.e., less install or runtime errors and hence more stable) than the new route, it is selected for installation on the client system.
  • [0201]
    Before installation of the new dependency route, the software agent on the client system performs a depth first search of the first of the leaves in the dependency graph. The software agent then works upward from the bottom of the route reinstalling and updating software elements as needed to match the software manifest of the client to the software elements and dependencies from the dependency route chosen for installation. Once the update of the client is complete, the route information is uploaded to the dependency map for historical storage.
  • [0202]
    While the disclosed embodiments are described in specific terms, other embodiments encompassing principles of the invention are also possible. Further, operations may be set forth in a particular order. The order, however, is but one example of the way that operations may be provided. Operations may be rearranged, modified, or eliminated in any particular implementation while still conforming to aspects of the invention. Embodiments within the scope of the present invention also include computer readable media for carrying or having computer-executable instructions or data structures stored thereon. Such computer-readable media may be any available media that can be accessed by a general purpose or special purpose computer. By way of example, and not limitation, such computer-readable media can comprise RAM, ROM, EEPROM, DVD, CD ROM or other optical disk storage, magnetic disk storage or other magnetic storage devices, or any other medium which can be used to carry or store desired program code means in the form of computer-executable instructions or data structures and which can be accessed by a general purpose or special purpose computer. When information is transferred or provided over a network or another communications link or connection (either hardwired, wireless, or a combination of hardwired or wireless) to a computer, the computer properly views the connection as a computer-readable medium. Thus, any such a connection is properly termed a computer-readable medium. Combinations of the above should also be included within the scope of computer-readable media. Computer-executable instructions comprise, for example, instructions and data which cause a general purpose computer, special purpose computer, or special purpose processing device to perform a certain function or group of functions.
  • [0203]
    Those skilled in the art will appreciate that aspects of the invention may be practiced in network computing environments with many types of computer system configurations, including personal computers, hand-held devices, multi-processor systems, microprocessor based or programmable consumer electronics, network PCs, minicomputers, mainframe computers, and the like. Various embodiments discussed herein including embodiments involving a satellite or cable signal delivered to a set-top box, television system processor, or the like, as well as digital data signals delivered to some form of multimedia processing configuration, such as employed for IPTV, or other similar configurations can be considered as within a network computing environment. Further, wirelessly connected cell phones, a type of hand-held device, are considered as within a network computing environment. For example, cell phones include a processor, memory, display, and some form of wireless connection, whether digital or analog, and some form of input medium, such as a keyboards, touch screens, etc. Hand-held computing platforms can also include video on demand type of selection ability. Examples of wireless connection technologies applicable in various mobile embodiments include, but are not limited to, radio frequency, AM, FM, cellular, television, satellite, microwave, WiFi, blue-tooth, infrared, and the like. Hand-held computing platforms do not necessarily require a wireless connection. For example, a hand-held device may access multimedia from some form of memory, which may include both integrated memory (e.g., RAM, Flash, etc) as well as removable memory (e.g., optical storage media, memory sticks, flash memory cards, etc.) for playback on the device. Aspects of the invention may also be practiced in distributed computing environments where tasks are performed by local and remote processing devices that are linked (either by hardwired links, wireless links, or by a combination of hardwired or wireless links) through a communications network. In a distributed computing environment, program modules may be located in both local and remote memory storage devices.

Claims (242)

  1. 1. A method for altering an existing configuration of a first software functionality on a client device to install a second software functionality comprising:
    receiving a request to install a second software functionality on a client device;
    receiving a software manifest describing a plurality of software files residing on the client device;
    accessing a software installation map comprising a plurality of software elements representing at least the plurality of software files described in the software manifest, a plurality of software files for installing the second software functionality, and a plurality of dependency pointers representing dependencies between the software files;
    analyzing the software installation map to determine a first software installation route for installing the second software functionality, the software installation route comprising:
    the plurality of software files for installing the second software functionality, the plurality of software files including at least one existing software file associated with the first software functionality to be altered for installation of the second software functionality, and
    an installation order for installing the plurality of software files; and
    providing the first software installation route to the client device to alter the first software functionality and install the second software functionality.
  2. 2. The method of claim 1 further comprising:
    receiving a first installation criteria for installing the second software functionality.
  3. 3. The method of claim 2 wherein the first installation criteria is at least one of the following:
    a) an installation with an optimized number of required software files;
    b) an installation with an optimized amount of disk space required;
    c) an installation with a least number of errors reported against it; and
    d) and installation with a latest security update.
  4. 4. The method of claim 3 where the operation of determining the first software installation route is a function of the first installation criteria and wherein the installation route and software installation map include features indicative of at least one of:
    a number of software files to related to the installation route, an amount of disk space required to install the files identified in the installation route, a number of errors associated with the installation route, and a security status of the installation route.
  5. 5. The method of claim 4 wherein the at least one software file associated with the first software functionality to be altered involves one of:
    removing the at least one software file, replacing the at least one software file with a newer version of the at least one software file, and replacing the at least one software file with an older version of the at least one software file.
  6. 6. The method of claim 2 further comprising:
    receiving a rejection of the first software installation route due to a requirement to not alter the at least one existing software file.
  7. 7. The method of claim 6 further comprising:
    providing a second optimized software installation route describing at least one existing software file associated with the first software functionality to be altered to optimize the performance of the second software functionality.
  8. 8. The method of claim 1 wherein the operation of determining a first software installation route comprises the operations of:
    determining a start point within a software installation map, wherein the start point is a collection of the software files described in the software manifest;
    determining an end point within the software installation map, wherein the end point is a collection of some or all of the software files described in the software manifest and the files needed for installing the second software functionality; and
    determining a collection of software files for installing the second software functionality wherein the collection of software files for installing the second software functionality is a function of a difference in files between the end point and the start point.
  9. 9. The method of claim 1 wherein the software installation map comprises:
    a plurality of software elements representing at least the plurality of software files described in the software manifest and the plurality of software files for installing the second software functionality; and
    a plurality of dependency pointers representing dependencies between the software files.
  10. 10. The method of claim 1 wherein the first software installation route is associated with a confidence factor representing an estimate that the first software installation route provides for a successful installation.
  11. 11. A method for receiving instructions for installing a second software functionality on a client device with an existing first software functionality comprising:
    providing an installation request for a second software functionality wherein a first software functionality currently resides on a client device;
    providing a software manifest describing a plurality of software files residing on the client device and associated with at least the first software functionality; and
    receiving a software installation route comprising:
    a plurality of software files for installing the second software functionality, the plurality of software files including at least one software file associated with the first software functionality to be altered for installation of the second software functionality; and
    an installation order for installing the plurality of software files.
  12. 12. The method of claim 11 further comprising:
    providing a first installation criteria for installing the second software functionality, the first installation criteria for generating the software installation route.
  13. 13. The method of claim 12 wherein the first installation criteria is one of the following:
    a) an installation with an optimized number of required software files;
    b) an installation with an optimized amount of disk space required;
    c) an installation with a least number of errors reported against it; and
    d) and installation with a latest security update.
  14. 14. The method of claim 13 wherein the at least one software file associated with the first software functionality to be altered involves one of:
    removing the at least one software file, replacing the at least one software file with a newer version of the at least one software file, and replacing the at least one software file with an older version of the at least one software file.
  15. 15. The method of claim 13 wherein the installation route is a function of the first installation criteria and wherein the installation route and software installation map include features indicative of at least one of:
    a number of software files to related to the installation route, an amount of disk space required to install the files identified in the installation route, a number of errors associated with the installation route, and a security status of the installation route.
  16. 16. The method of claim 15 further comprising:
    providing for determining whether alteration of the at least one software file is acceptable;
    providing a refusal to alter the at least one software file; and
    receiving a second installation route for installing the second software functionality describing at least one second software file associated with the first software functionality to be altered for installation of the second software functionality.
  17. 17. The method of claim 16 further comprising:
    altering the at least one second software file at the client device.
  18. 18. The method of claim 17 further comprising:
    installing the plurality of software files as described in the second software installation route.
  19. 19. The method of claim 1 wherein the operation of receiving a software installation route is from a software installation map comprising a plurality of software elements representing at least the plurality of software files described in the software manifest and the plurality of software files for installing the second software functionality; and
    each software element including at least one dependency pointers representing a dependency with at least one other software files.
  20. 20. A software management system for managing a plurality of software installation maps, comprising:
    a first module configured for hosting a first software installation map, the first software installation map comprising:
    a first plurality of software elements representing a first plurality of software files;
    a first plurality of dependency pointers representing a plurality of dependencies between the first plurality of software files;
    a second module configured for hosting a second software installation map, the second software installation map configured to communicate with the first software installation map to collectively define a virtual software installation map, the second software installation map comprising:
    a second plurality of software elements representing a second plurality of software files; and
    a second plurality of dependency pointers representing a plurality of dependencies between the second plurality of software files.
  21. 21. The system of claim 20 wherein the first software installation map further comprises:
    at least a first map reference pointer configured to reference a third map reference pointer from a third software installation map.
  22. 22. The system of claim 20 wherein the first software installation map further comprises a first map reference pointer to a second map reference pointer of the second software installation map.
  23. 23. The system of claim 22 wherein the first map reference pointer comprises:
    a confidence factor being an estimate that the first map reference pointer is a valid reference to the third software installation map.
  24. 24. The system of claim 23 wherein the first map reference pointer further comprises:
    a class definition of a class of software of the first map reference pointer wherein the second map reference pointer from the second additional software installation map has a dependency on the class of software of the first map reference pointer.
  25. 25. The system of claim 24 wherein the first map reference pointer comprises a reference version defining a version of a software application associated with the first map reference pointer wherein a version of a reference pointer from the at least additional software installation map is of the same version.
  26. 26. The system of claim 20 wherein the first software installation map comprises software associated with a first software vendor and the second software installation map comprises software associated with a second software vendor.
  27. 27. The system of claim 22 wherein the first and second map reference pointers associate the first and second software installation maps into the virtual software installation map.
  28. 28. The system of claim 27 wherein the virtual software installation map is configured to receive a software installation request for software functionality from both the first and second software installation maps.
  29. 29. The system of claim 28 wherein at least a portion of the virtual software installation map may reside in a memory of a software agent of a client device.
  30. 30. A method for managing a plurality of software installation maps:
    receiving a request for installing a first software functionality on a client device wherein the first software functionality comprises a first software file referenced in a first software installation map and a second software file referenced in a second software installation map;
    combining the first installation map and the second installation map into a virtual software installation map;
    generating a software installation route from the virtual software installation map, wherein the software installation route includes the first software file from the first installation map and the second file from the second software installation map; and
    providing the software installation route to the client device.
  31. 31. The method of claim 30 wherein the operation of combining the first installation map and the second software installation map further comprises:
    associating a first map reference pointer of the first software installation map with a second map reference pointer of the second software installation map to establish the virtual installation map.
  32. 32. The method of claim 30 wherein each of the first and second installation maps comprise:
    a plurality of software elements representing a plurality of software files; and
    a plurality of dependency pointers representing a plurality of dependencies between the plurality of software files.
  33. 33. The method of claim 31 wherein the first map reference pointer comprises:
    a confidence factor that the first map reference pointer is a valid reference point to the second map reference pointer.
  34. 34. The method of claim 33 wherein the first map reference pointer further comprises:
    a class definition of a class of software of the first map reference pointer.
  35. 35. The method of claim 34 wherein the class definition expresses a dependency of a class of the second reference pointer.
  36. 36. The method of claim 35 wherein the first map reference pointer further comprises:
    a reference version defining a version of a software application associated with the first map reference pointer.
  37. 37. The method of claim 30 wherein the first software installation map comprises software associated with a first software vendor and the second software installation map comprises software associated with a second software vendor.
  38. 38. The method of claim 30 wherein at least a portion of the virtual software installation map may reside in a memory of a software agent of the client device.
  39. 39. The method of claim 30 wherein the software installation route comprises:
    a confidence factor that the software installation route provides for a valid installation of the first software functionality.
  40. 40. A system for substantially duplicating a software configuration from a first computing system to at least a second computing system comprising:
    a software installation map configured to receive a source software manifest reflecting a source software configuration describing a plurality of source software files residing on a source client;
    the software installation map further configured to generate a first software installation route describing a plurality of software files and associated dependencies, the first software installation route being a function of the source software manifest; and
    the software installation map further configured to provide the first software installation route to a target client, the first route providing an identification of software files to substantially duplicate the source software configuration of the source client on the target client.
  41. 41. The system of claim 40 wherein the source client has a source software load, the source client further having a source software agent running on the source client, the source software agent configured to track changes to the source software manifest.
  42. 42. The system of claim 40 wherein the target client has a target software load, the target client further having a target software agent running on the target client, the target software agent configured to receive the first software installation route to substantially duplicate the source software manifest.
  43. 43. The system of claim 40 wherein the system is further configured to provide a bare metal provision to the target client.
  44. 44. The system of claim 41 wherein the software agent of the source client is configured to perform the operations comprising:
    comparing the software files described in the first software installation route against the source software manifest; and
    communicating with the software installation map to obtain software files identified on the first software installation route but not present in the source software manifest.
  45. 45. The system of claim 44 where the software agent of the source client is configured to perform the operations of:
    identifying any removal software files that exist on the source client but are not described in the first software installation route;
    removing the removal software files from the source client;
    identifying any additional software files that are described in the first software installation route but do not exist on the source client; and
    installing the additional software files on the source client.
  46. 46. The system of claim 42 wherein the target software agent of the target client is configured to perform the operations comprising:
    receiving the first software installation route;
    analyzing the target software load and identifying any software files that exist in the target software load but are not described in the first software installation route;
    creating a first de-installation list of at least one software file that is not part of the first software installation route;
    analyzing a file manifest of each software file in the first de-installation list and performing a file-level dependency check on each software file in the first de-installation list to identify additional files that are created at runtime but are not under the control of the target software manifest;
    creating a second de-installation list describing any additional files created at run-time but are not under the control of the target software manifest; and
    deleting the software files described in the first and second de-installation lists.
  47. 47. The system of claim 40 wherein the software installation map comprises:
    a plurality of software elements representing a plurality of software files; and
    a plurality of dependency pointers representing dependencies between the plurality of software files.
  48. 48. The system of claim 43 wherein the operation of providing a bare metal provision to the target client further comprises providing a target software agent for installation on the target client.
  49. 49. A method for substantially duplicating a software configuration from a first computing system to at least a second computing system comprising:
    receiving a request for duplicating a software configuration from a source client to a target client, the source client having a source software manifest listing the source software files residing on the source client and the target client having a target software load listing the target software files residing on the target client;
    receiving the source software manifest;
    generating a first software installation route based on the source software manifest, the first software installation route generated from a software installation map; and
    providing the first software installation route to the target client.
  50. 50. The method of claim 49 wherein the source client further performs the operations comprising:
    comparing the plurality of software files described in the first software installation route against the source software load; and
    altering the source software load to substantially equal the plurality of files described in the first software installation route.
  51. 51. The method of claim 50 wherein the software installation map comprises:
    a plurality of software elements representing a plurality of software files; and
    a plurality of dependency pointers representing dependencies between each of the plurality of software files.
  52. 52. The method of claim 50 wherein the target client further performs the operations comprising:
    receiving the first software installation route;
    analyzing the target software load and identifying any software files that exist in the target software load but are not described in the first software installation route;
    creating a first de-installation list of the software files that are not part of the first software installation route;
    analyzing a file manifest of each software file in the first de-installation list and performing a file-level dependency check on each software file in the first de-installation list to identify additional files that are created at runtime but are not under the control of the target software manifest;
    creating a second de-installation list describing any additional files created at run-time but are not under the control of the target software manifest; and
    deleting the software files described in the first and second de-installation lists.
  53. 53. The method of claim 52 further comprising installing a software agent on the target client.
  54. 54. The method of claim 50 further comprising installing a software agent on the source client.
  55. 55. The method of claim 49 further comprising:
    providing a bare metal provision to the target client.
  56. 56. The method of claim 55 wherein the operation of providing a bare metal provision to the target client comprises an installation for a minimal operating system for installation on the target client wherein the minimal operating system is a same operating system existing on the source client.
  57. 57. The system of claim 56 wherein the operation of providing a bare metal provision to the target client further comprises providing a target software agent for installation on the target client.
  58. 58. A system for managing software installation errors comprising:
    a service provider module for hosting a software installation map, the software installation map comprising:
    a plurality of software elements representing a plurality of software files;
    a plurality of dependency pointers representing a plurality of dependencies between the plurality of software files;
    at least one software installation route describing a subset of the plurality of software files combinable to represent at least one software functionality;
    the service provider configured to provide the installation route to a client device to install the subset of the plurality of software files; and
    an error analysis module in communication with the service provider module, the error analysis module configured to analyze an error message received from the client device in association with installation of the subset the plurality of software files.
  59. 59. The system of claim 58 wherein the error analysis module is configured to perform the operations of:
    analyzing the error message to determine a source of the error message;
    associating the received error and a timestamp of when the error occurred with at least one of the plurality of software elements responsible for the error; and
    associating the received error with the software installation route used for installing the software functionality.
  60. 60. The system of claim 59 wherein the error analysis module is configured to perform the operations of:
    analyzing the error message to identify files installed on the client device prior to the installation of the subset of the plurality of software files.
  61. 61. The system of claim 59 wherein the at least one software installation route has a confidence factor representing an estimate of whether the at least one software installation route will provide for a successful installation of the software functionality.
  62. 62. The system of claim 61 wherein the operation of associating the received error with the software installation route used for installing the software functionality further comprises:
    associating information about the received error with the software installation route; and
    reducing the confidence factor associated with the software installation route.
  63. 63. The system of claim 62 where the operation of reducing the confidence factor associated with the software installation route is determined by dividing a number of installations based on the software installation route by a number of successful installations based on the software installation route.
  64. 64. A method for managing software installation errors comprising:
    providing a software installation route to a client device for installing a software functionality;
    receiving an error string associated with the software installation route;
    parsing the error string to determine a cause of the error;
    associating the received error with a software element associated with the error; and
    associating the received error with the software installation route used for installing the software functionality.
  65. 65. The method of claim 64 further comprising:
    parsing the error string to further determine a time of the error; and
    associating the received error and the time of the error with the software element associated with the error.
  66. 66. The method of claim 65 wherein the operation of parsing the error string further comprises:
    identifying references to any files that may have already been installed on the client device prior to the installation; and
    identifying references to any known installation problems.
  67. 67. The method of claim 66 wherein the software installation route has a confidence factor representing an estimate that the at least one software installation route will provide for a successful installation.
  68. 68. The method of claim 67 wherein the operation of associating the received error with the software installation route used for installing the software functionality further comprises:
    attaching information about the received error to the software installation route; and
    reducing the confidence factor associated with the software installation route as a function of the received error.
  69. 69. The method of claim 68 where the operation of reducing the confidence factor associated with the software installation route involves dividing a number of uses of the software installation route by a number of successful installations provided by the software installation route.
  70. 70. The method of claim 68 wherein the operation of associating information about the received error to the software installation route further comprises:
    associating the software module responsible for the error with the software installation route;
    associating the error string with the software installation route; and
    associating a cause of the error with the software installation route.
  71. 71. The method of claim 65 wherein the error string is transmitted by a software agent installed on the client device.
  72. 72. The method of claim 64 further comprising:
    providing details of the parsed error string to the client device.
  73. 73. The method of claim 64, further comprising:
    revising the software installation route to avoid the cause of the error.
  74. 74. The method of claim 73, further comprising:
    providing a revised software installation route to the client device.
  75. 75. A method for transmitting software installation errors, comprising:
    upon a request for installing a software functionality, receiving a software installation route from a service provider module, the software installation route providing at least one software file for installing the software functionality;
    installing the at least one software file based on the software installation route on a client device;
    receiving an installation error during installation of the software installation route; and
    transmitting the installation error to the service provider module.
  76. 76. The method of claim 75 further comprising providing a software agent on the client device to perform the operations of claim 75.
  77. 77. The method of claim 75, further comprising:
    receiving a revised software installation route.
  78. 78. A method for returning a software configuration on a computing device to a previous state comprising:
    receiving a request for returning a client device software configuration to a previous state;
    comparing a previous state software manifest comprising a list of a plurality of software files residing on the client device during the previous state with a software installation map to identify software elements within the map associated with the list of the plurality of software files residing on the client device during the previous state;
    generating a previous state installation route describing at least a portion of the software elements within the map and associated software files for returning the client device to the previous state; and
    providing the previous state installation route to the computing device.
  79. 79. The method of claim 78 further comprising:
    comparing the previous state software manifest to a current client software manifest;
    receiving a indication of at least one difference in software files between the current client software manifest and the previous state software manifest; and
    using the difference in software files, generating a previous state installation route describing software files to install or de-install from the client device to return the computing device to the previous state.
  80. 80. The method of claim 79 wherein the previous software manifest further comprises:
    a list of root software files residing on the client device, the root software files not having a dependency on any other software files.
  81. 81. The method of claim 78 wherein the operation of comparing the previous software manifest with a software installation map further comprises:
    matching each software file in the software manifest against a software element representing each software file from the software installation map, each software file being matched based on a version of the software file.
  82. 82. The method of claim 78 wherein a software installation map comprises:
    a plurality of software elements representing a plurality of software files; and
    a plurality of dependency pointers representing dependencies between each of the plurality of software files.
  83. 83. The method of claim 78 further comprising receiving the previous state software manifest from the computing device, the computing device storing a plurality of previous software manifests, each software manifest represented by a date that the manifest was created.
  84. 84. The method of claim 81 wherein the previous state software manifest provides an order in which the software files described in the previous state manifest were installed on the computing device.
  85. 85. The method of claim 78 wherein the previous state installation route describes an installation route for installing software files to the computing device and removing existing software files from the computing device.
  86. 86. The method of claim 85, wherein the previous state installation route further includes an installation ordering for installing and removing the software files, wherein the installation ordering lists the order in which each software file should be installed or un-installed from the client device.
  87. 87. The method of claim 78, further comprising:
    receiving an indication of success from the computing device, the indication of success representing a successful installation of the previous state installation route, returning the computing device to the previous state.
  88. 88. The method of claim 78, further comprising:
    receiving an indication of failure from the computing device, the indication of failure representing a failed installation of the previous state installation route, the indication of failure further comprising:
    a listing of software files and their versions installed to the computing device before a failure occurred;
    a listing of software files and their versions removed from the computing device before the failure occurred;
    a reason for the failure of the previous state installation route; and
    a listing of one of more software files responsible for the failure.
  89. 89. A method for returning a software configuration of a computing device to a previous state comprising;
    requesting a rollback of a computing device software configuration to a configuration as described in a previous software manifest;
    providing the previous software manifest to a software installation map, the previous software manifest describing a listing of each software file and associated version residing on the computing device at the time of the previous software manifest;
    comparing the previous software manifest with a current software manifest of the computing device to generate a list of differences between the previous software manifest and the current software manifest;
    providing the list of differences to the software installation map;
    receiving a previous state installation route describing software files and an associated version for returning the computing device to the previous software configuration at the time of the previous state; and
    installing the software files on the computing device.
  90. 90. The method of claim 89 further comprising:
    generating the current software manifest describing a current listing of each software file and associated version residing on the computing device.
  91. 91. The method of claim 89 wherein the previous software manifest further comprises:
    a list of root software modules residing on the client device, root software modules not having a dependency on any other software modules.
  92. 92. The method of claim 89 further comprising receiving a software agent at the computing device, the software agent providing communication with the software installation map.
  93. 93. The method of claim 89 wherein the software installation map comprises:
    a plurality of software elements representing a plurality of software files; and
    a plurality of dependency pointers representing dependencies between each of the plurality of software files.
  94. 94. The method of claim 89, wherein the previous state installation route further includes an order for installing software files onto the computing device and removing existing software files from the client device.
  95. 95. The method of claim 89, further comprising:
    transmitting an indication of success from the client device, the indication of success representing a successful installation of the previous state installation route returning the computing device to the configuration described in the previous software manifest.
  96. 96. The method of claim 89, further comprising:
    transmitting an indication of failure from the client device, the indication of failure representing a failed installation of the previous installation routed intended to return the computing device to the configuration described in the previous software manifest.
  97. 97. The method of claim 89, further comprising:
    wherein the indication of failure comprises:
    a listing of software files and their versions installed to the computing device before a failure occurred;
    a listing of software files and their versions removed from the computing device before the failure occurred;
    a reason for the failure of the previous state installation route; and
    a listing of one of more software files responsible for the failure.
  98. 98. A method for installing software on a computing device comprising:
    receiving a first software installation request to install a first software functionality;
    accessing a software installation map comprising:
    a plurality of software elements representing a plurality of software files, a subset of the plurality of software elements associated with the first software functionality;
    a plurality of dependency pointers identifying functional dependencies between the plurality of software files;
    determining at least one installation route for installing the first software functionality, the at least one installation route identifying the subset of the plurality of software elements; and
    providing the installation route to a computing device.
  99. 99. The method of claim 98 further comprising:
    transmitting the at least one installation route to the computing device over a communication network.
  100. 100. The method of claim 98 wherein the operation of receiving a first software installation request further comprises:
    receiving a first installation criteria for installing the first software functionality.
  101. 101. The method of claim 100 wherein the software installation map includes indicators representative of operating speed of the software functionality, error rate of the software functionality, and version of the software functionality and wherein the first installation criteria is a function of at least one of the following factors:
    operating speed of the software functionality, stability of the software functionality, and version of the software functionality.
  102. 102. The method of claim 98 wherein the software installation map further comprises:
    a first installation route including at least a first subset of the plurality of software elements to install the first software functionality; and
    a second installation route including at least a second subset of the plurality of software elements, the second subset differing from the first subset by at least one software element, the second subset of software elements to install the first software functionality.
  103. 103. The method of claim 102 wherein the operation of determining the at least one install route further comprises:
    selecting a preferred installation route from at least the first and second installation route.
  104. 104. The method of claim 103 wherein the operation of selecting a preferred installation route is a function of a first installation criteria.
  105. 105. The method of claim 102 wherein the first installation route has a first confidence factor being a function of a historical record of previous installations based on the first installation route and the second installation route has a second confidence factor being a function of a historical record of previous installations based on the second installation route.
  106. 106. The method of claim 105 wherein the first and second confidence factors represent an estimate of whether the first and second installation routes, respectively, will result in a successful installation of the first software functionality on the computing device.
  107. 107. The method of claim 103 wherein the operation of selecting a preferred installation route is a function of at least the first and second confidence factors.
  108. 108. The method of claim 98 further comprising:
    providing the software files to the computing device, the software files associated with each software element identified in the installation route.
  109. 109. The method of claim 98 wherein each of the plurality of dependency pointers represents a functional dependency between two software files, each of the plurality of dependency pointers having a dependency confidence factor being a function of the dependency between the two software files and a historical record of installations involving the dependency between the two software files.
  110. 110. The method of claim 109 wherein the dependency confidence factor represents an estimate that the dependency between the two software files is accurate.
  111. 111. The method of claim 98 further comprising:
    obtaining a location pointer from each of the subset of software elements, the location pointer identifying a memory location of the software file associated with the corresponding software element.
  112. 112. The method of claim 98 further comprising:
    obtaining each of the software files from the memory location of a relational database.
  113. 113. The method of claim 98 wherein each of the plurality of software files comprises one of the following types of software files:
    a) an executable file;
    b) a shared library file;
    c) a configuration file; and
    d) a script file.
  114. 114. The method of claim 98 wherein each of the plurality of dependency pointers is associated with at least one of the first and second software elements creating the dependency.
  115. 115. A method for installing software on a computing device comprising:
    transmitting a software installation request for installing a first software functionality;
    receiving at least one installation route from a software installation map, the installation route identifying:
    a plurality of software elements for installing the first software functionality, each software element having an associated software file;
    an installation order for installing the software files;
    a confidence factor associated with the installation route, the confidence factor representing an estimate of whether the installation route will provide for a successful installation;
    receiving the software files for installing the first software functionality, the plurality of software files associated with the at least one installation route; and
    installing the software files to obtain the first software functionality.
  116. 116. The method of claim 115 further comprising:
    obtaining a first installation route including at least a first subset of the plurality of software elements to install the first software functionality;
    a second installation route including at least a second subset of the plurality of software elements, the second subset differing from the first subset by at least one software element, the second subset of software elements to install the first software functionality; and
    determining a preferred installation route between the first and second installation routes.
  117. 117. The method of claim 115 further comprising:
    transmitting a success rate to the software installation map, wherein the success rate is a function of the success of installing the software functionality.
  118. 118. The method of claim 115 further comprising:
    transmitting at least one installation criteria for installing the first software functionality, the at lest one installation criteria represent at least one of the following types of requirements for installing the first software functionality:
    operating speed of the software functionality, stability of the software functionality, version of the software functionality, and compatibility of the software functionality with other software functionality.
  119. 119. The method of claim 118 where the operation of receiving the at least one installation route is a function of the transmission of the at least one installation criteria.
  120. 120. A method for generating dependencies within a software installation map comprising:
    creating a first software element in a software installation map, wherein the first software element represents a first software file;
    creating a second software element in the software installation map, wherein the second software element represents a second software file;
    analyzing a first software package being the source of the first software file and the second software file to identify a dependency between the first software file and the second software file; and
    defining a first dependency pointer within the software installation map, the first dependency pointer representing the dependency from the first software file to the second software file.
  121. 121. The method of claim 120 wherein the operation of analyzing includes extracting a declared dependency between the first software file and the second software file.
  122. 122. The method of claim 120 wherein the operation of analyzing includes analyzing shared libraries to identify a declared dependency between the first software file and the second software file.
  123. 123. The method of claim 120 wherein the operation of analyzing includes analyzing configuration files to identify a declared dependency between the first software file and the second software file.
  124. 124. The method of claim 120 further comprising analyzing a symbol file of at least one executable file of the first software package to identify dependency between the first software file and the second software file.
  125. 125. The method of claim 120 further comprising executing at least one executable file of the first software package to identify the dependency between the first software file and the second software file.
  126. 126. The method of claim 120 further comprising:
    assigning a confidence factor to the first dependency pointer; and
    assigning a timestamp to the first dependency pointer, the timestamp storing a date the dependency was generated in the software installation map.
  127. 127. The method of claim 126 further comprising:
    receiving a success indication based on an installation of a software functionality on a client device involving the first software file and the second software file; and
    adjusting the confidence factor of the first dependency pointer as a function of the success indication.
  128. 128. The method of claim 121 wherein the declared dependency is located in one of the following types of software files residing within the first software package:
    a) a shared library file;
    b) a configuration file;
    c) an executable file; and
    d) a symbol table.
  129. 129. The method of claim 120 further comprising:
    extracting a plurality of software files from the first software package, the plurality of files comprising at least the first software file and the second software file.
  130. 130. An apparatus for generating dependencies within a software installation map configured for performing the operations of:
    creating a first software element in a software installation map, wherein the first software element represents a first software file;
    creating a second software element in the software installation map, wherein the second software element represents a second software file;
    analyzing a first software package being the source of the first software file and the second software file to identify a dependency between the first software file and the second software file; and
    defining a first dependency pointer within the software installation map, the first dependency pointer representing the dependency from the first software file to the second software file.
  131. 131. The apparatus of claim 130 wherein the operation of analyzing includes extracting a declared dependency between the first software file and the second software file.
  132. 132. The apparatus of claim 131 wherein the operation of analyzing includes analyzing shared libraries to identify a declared dependency between the first software file and the second software file.
  133. 133. The apparatus of claim 132 wherein the operation of analyzing includes analyzing configuration files to identify a declared dependency between the first software file and the second software file.
  134. 134. The apparatus of claim 130 further configured to perform the operation of analyzing a symbol file of at least one executable file of the first software package to identify dependency between the first software file and the second software file.
  135. 135. The apparatus of claim 130 further configured to perform the operation of executing at least one executable file of the first software package to identify dependency between the first software file and the second software file.
  136. 136. The apparatus of claim 130 further configured to perform the operations of:
    assigning a confidence factor to the first dependency pointer; and
    assigning a timestamp to the first dependency pointer, the timestamp storing a date the dependency was generated in the software installation map.
  137. 137. The apparatus of claim 130 further configured to perform the operations of:
    receiving a success indication based on an installation of a software functionality on a client device involving the first software file and the second software file; and
    adjusting the confidence factor of the first dependency pointer as a function of the success indication.
  138. 138. The apparatus of claim 131 wherein the declared dependency is located in one of the following types of software files residing within the first software package:
    a) a shared library file;
    b) a configuration file;
    c) an executable file; and
    d) a symbol table.
  139. 139. The apparatus of claim 138 further configured to perform the operation of extracting a plurality of software files from the first software package, the plurality of files comprising at least the first software file and the second software file.
  140. 140. A method for automating software installations accounting for an installation policy, the method comprising:
    defining a client installation policy for a client device;
    transmitting a software installation request for installing a first software functionality;
    receiving a software installation route from a software installation map, the software installation route describes a plurality of software files for installing the first software functionality, the software installation route comprising:
    a confidence factor representing an indication of previous installation success based on the software installation route;
    a route installation policy; and
    installing the first software functionality based on a combination of the client installation policy and the route installation policy.
  141. 141. The method of claim 140 wherein the client installation policy defines a level of manual interaction suggested for installing software functionalities on the client device.
  142. 142. The method of claim 141 wherein the route installation policy defines a level of manual interaction suggested for installing the first software functionality.
  143. 143. The method of claim 142 further comprising:
    overriding the route installation policy to install the first software functionality based on the client installation policy.
  144. 144. The method of claim 142 further comprising:
    overriding the client installation policy to install the first software functionality based on the route installation policy.
  145. 145. The method of claim 142 wherein the route installation policy is a function of the confidence factor associated with the software installation route.
  146. 146. The method of claim 140 wherein the software installation map comprises:
    a plurality of software elements representing a plurality of software files; and
    a plurality of dependency pointers representing dependencies between each of the plurality of software files.
  147. 147. The method of claim 140 wherein the client installation policy automatically changes over time based on a historical record of successful installations performed on the client device.
  148. 148. The method of claim 147 wherein the client installation policy changes to suggest less manual interaction if the first software functionality installs successfully.
  149. 149. The method of claim 147 wherein the client installation policy changes to suggest more manual interaction if the first software functionality installs unsuccessfully.
  150. 150. A method for providing a software installation accounting for an installation policy comprising:
    maintaining a software installation map comprising:
    a plurality of software elements representing a plurality of software files;
    a plurality of dependency pointers representing dependencies between each of the plurality of software files;
    at least one software installation route for installing a first software functionality, the installation route including a subset of the plurality of software elements and having a route installation policy defining a level of manual interaction suggested for installing the software functionality;
    receiving a request for installing the first software functionality from a client device; and
    providing the first software installation route to the client device.
  151. 151. The method of claim 150 wherein the first software installation route comprises:
    a confidence factor representing an estimate of whether the first software installation route will provide for a successful installation.
  152. 152. The method of claim 151 wherein the route installation policy is a function of the confidence factor.
  153. 153. The method of claim 152 further comprising:
    receiving an indication of success from the installation of the first software functionality, wherein the indication of success describes whether the installation resulted in one or more errors.
  154. 154. The method of claim 153 further comprising:
    altering the route installation policy based on the indication of success.
  155. 155. The method of claim 154 wherein the operation of altering the route installation policy increases a suggested level of manual interaction if the indication of success returned one or more installation errors.
  156. 156. The method of claim 154 wherein the operation of altering the route installation policy decreases the suggested level of manual interaction if the indication of success returned no installation errors.
  157. 157. The method of claim 151 wherein the route installation policy suggests a decreased level of manual interaction if the confidence factor of the software installation route is increased.
  158. 158. The method of claim 151 wherein the route installation policy suggests a increased level of manual interaction if the confidence factor of the software installation route is reduced.
  159. 159. The method of claim 151 wherein the route installation policy is a function of a number of installations performed based on the first software installation route.
  160. 160. A software run-time error detection system comprising:
    an error receiving module residing on a server device, the error receiving module to receive run-time error messages from a software monitoring agent residing on a client device, the software monitoring agent configured to detect run-time errors associated with at least one software functionality installed on the client device; and
    a route manager residing on the server device, the route manager in communication with the error receiving module, the route manager further configured to modify a confidence factor associate with at least one software installation route defined in a software installation map, the software installation route defining a plurality of software elements associated with the software functionality installed on the client device.
  161. 161. The system of claim 160 wherein the software monitoring agent further comprises:
    a first software error detection module configured to detect run-time errors in the first software functionality.
  162. 162. The system of claim 161 wherein the first software error detection module further comprises:
    a first event detector configured to detect run-time errors events in the first software functionality; and
    a first log file watcher configured to monitor at least one error log associated with the first software functionality.
  163. 163. The system of claim 162 wherein the first event detector is further configured to accept instructions on which types of run-time error events to detect.
  164. 164. The system of claim 162 wherein the first log file watcher is further configured to accept instructions on which types of error entries to monitor in the at least one error log.
  165. 165. The system of claim 164 wherein the at least one error log is one of at least a system error log and an application specific error log.
  166. 166. The system of claim 163 further comprising an event detector configured to perform at least one of the following:
    a) simple network management protocol (“SNMP”) sniffing;
    b) core image dumps;
    c) memory image dumps;
    d) java stack detections; and
    e) kernel level system interrupts.
  167. 167. The system of claim 160 wherein the software monitoring agent is configured to accept instructions on which types of run-time errors are to be flagged and provided to the route manager.
  168. 168. The system of claim 160 wherein the route manager is configured to receive, by way of the error receiving module, run-time error messages and software manifests from the software monitoring agent.
  169. 169. The system of claim 168 wherein the route manager is further configured for:
    determining at least one software installation route associated with at least one error message;
    associating the at least one error message with the at least one software installation route; and
    updating a confidence factor of the at least one software installation route, the confidence factor being a function of the at least one error message.
  170. 170. A method for monitoring software run-time errors on a client device comprising:
    receiving a software monitoring agent on the client device;
    configuring the software agent to detect at least one type of run-time error occurring on the client device;
    monitoring the client device for an occurrence of the at least one type of run-time error; and
    providing at least one error message and a software manifest to a route manager, the software manifest listing a plurality of software files residing on the client device.
  171. 171. The method of claim 170 further comprising:
    receiving a confirmation from the route manager that at least one software installation route associated with the at least one error message has been updated to reflect the occurrence of the run-time error on the client device.
  172. 172. The method of claim 170 wherein the operation of monitoring the client device further comprises monitoring at least one error log file residing on the client device.
  173. 173. The method of claim 172 wherein the software agent is configured to conduct at least one of the following a) simple network management protocol (“SNMP”) sniffing; b) core image dumps; c) memory image dumps; d) java stack detections; and e) kernel level system interrupts.
  174. 174. The method of claim 172 wherein the at least one error log is one of at least a system error log and an application specific error log.
  175. 175. The method of claim 170 wherein the operation of providing at least one error message to a route manager is performed by the software monitoring agent.
  176. 176. The method of claim 170 wherein the operation of configuring the software agent to detect at least one type of run-time error further comprises:
    configuring a first software error detection module to detect run-time errors associated with a first software functionality residing on the client device.
  177. 177. The method of claim 176 wherein the operation of configuring the software agent to detect at least one type of run-time error further comprises:
    configuring the first software error detection module to detect run-time errors associated with a second software functionality residing on the client device.
  178. 178. The method of claim 176 wherein the operation of configuring the software agent to detect at least one type of run-time error further comprises:
    configuring a second software error detection module to detect run-time errors associated with a second software functionality residing on the client device.
  179. 179. The method of claim 170 wherein the operation of configuring the software agent to detect at least one type of run-time error occurring on the client device is performed by a system administrator.
  180. 180. A method for providing information to assess a contemplated software installation comprising:
    receiving a request for assessing a contemplated installation of a first software functionality on a client device;
    receiving a software manifest comprising a plurality of software files residing on the client device;
    accessing an existing software installation map to determine a plurality of installation files for assessing the installation and to identify a plurality of dependencies between the plurality of installation files;
    generating at least one new software installation route describing the plurality of installation files and their dependencies for assessing the installation;
    comparing the at least one new software installation route against at least one existing and substantially similar software installation route residing in the software installation map to provide a new confidence factor associated with the at least one new software installation route based on an existing confidence factor of the at least one existing software installation routes.
  181. 181. The method of claim 180 further comprising:
    providing the at least one new software installation route and its associated confidence factor to the client device, the confidence factor of the at least one new software installation route permitting the client device to determine the likelihood of whether the new software installation route will provide for a stable installation of the first software functionality.
  182. 182. The method of claim 180 further comprising:
    generating a virtual software installation map comprising a plurality of software elements representing the plurality of files described in the software manifest, and dependencies between the plurality of files.
  183. 183. The method of claim 182 wherein the operation of generating a virtual software installation map further comprises:
    analyzing the existing software installation map;
    based on the analysis, generating an operating system dependency route describing substantially all software elements and their dependencies to provision an operating system as configured on the client device; and
    based on the analysis, generating at least one application dependency route describing substantially all the software elements and their dependencies to provision at least one existing application on the client device.
  184. 184. The method of claim 183 further comprising simulating an installation of the first software functionality by provisioning the new software installation route on the virtual software installation map.
  185. 185. The method of claim 184 further comprising:
    providing a simulated confidence factor of the virtually provisioned new software installation route by assessing a confidence factor of each dependency relationship in the new installation route, the operating system dependency route, and the at least one application dependency route.
  186. 186. The method of claim 185 wherein the simulated confidence factor represents an estimate of whether the new preferred software installation route provides for a successful installation of the first software functionality.
  187. 187. The method of claim 185 further comprising identifying any dangling references in the virtually provisioned new software installation route.
  188. 188. The method of claim 180 wherein the existing software installation map comprises:
    a plurality of software elements representing at least the plurality of software files set forth in the software manifest; and
    a plurality of dependency pointers representing dependencies between the plurality of software elements.
  189. 189. A method for validating and repairing a software installation comprising:
    installing a first software file on a client device wherein the first software file is a subset of an installation of a first software functionality, the first software file further having at least one dependency on at least one dependent software file presumed to reside on the client device;
    determining whether the at least one dependent software file resides on the client device; and
    installing the at least one dependent software file.
  190. 190. The method of claim 189 wherein if the at least one dependent software file does not reside on the client device perform the operations of:
    pausing the installation of the first software functionality;
    removing the first software file from the client device;
    requesting the at least one dependent software file from a software installation map;
    receiving the at least one dependent software file from the software installation map;
    installing the first software file and the at least one dependent software file on the client device; and
    resuming the installation of the first software functionality.
  191. 191. The method of claim 190 wherein the software installation map comprises:
    a plurality of software elements representing a plurality of software files including a first software element representing the first software file; and
    a plurality of dependency pointers representing a dependency between the plurality of software files.
  192. 192. The method of claim 191 further comprising:
    applying a time stamp to the first software element signifying that the at least one dependent software file resides on the client device.
  193. 193. The method of claim 191 wherein each software element includes a uniform resource location (“URL”) reference to a memory location of the associated software file.
  194. 194. The method of claim 193 further comprising:
    by way of a uniform resource locator for the at least one dependent software file, obtaining the at least one dependent software file.
  195. 195. The method of claim 189 wherein the operation of installing a first software file on a client is performed by a software agent residing on the client device.
  196. 196. The method of claim 195 further comprising providing for configuration of the software agent by a system administrator.
  197. 197. The method of claim 189 wherein the operation of determining whether the at least one dependent software file resides on the client device is performed by a validation thread of a software agent residing on the client device.
  198. 198. An apparatus for validating and repairing a software installation comprising:
    a software agent residing on a client device, the software agent in communication with a software installation map residing on a server device; the software agent configured to:
    install a first software file on the client device received form the software installation map, the first software file is a subset of an installation of a first software functionality, the first software file further having at least one dependency on at least one dependent software file presumed to reside on the client device;
    determine whether the at least one dependent software file resides on the client device;
    request the at least one dependent software file from the software installation map; and
    install the at least one dependent software file.
  199. 199. The apparatus of claim 198 wherein, upon determination that the at least one software file does not reside on the client device, the software agent is further configured to:
    pause the installation of the first software functionality;
    remove the first software file from the client device;
    request the at least one dependent software file from the software installation map;
    receive the at least one dependent software file from the software installation map;
    install the first software file and the at least one dependent software file on the client device; and
    resume the installation of the first software functionality.
  200. 200. The apparatus of claim 199 wherein the software agent further comprises:
    a validation thread configured to determine whether the at least one dependent software file resides on the client device.
  201. 201. The apparatus of claim 200 wherein the software agent is configurable to alter the determination of whether the at least one dependent software file resides on the client device.
  202. 202. The apparatus of claim 201 wherein the software agent is configured to determine whether the at least one dependent software file resides on the client device by obtaining file level access permissions of the at least one dependent software file residing on the client device.
  203. 203. The apparatus of claim 202 wherein the software agent is configured to determine whether the at least one dependent software file resides on the client device by accessing at least one high level symbol table associated with the dependent software file.
  204. 204. The apparatus of claim 198 wherein the software installation map comprises:
    a plurality of software elements representing a plurality of software files including a first software element representing the first software file; and
    a plurality of dependency pointers representing a dependency between the plurality of software files.
  205. 205. The apparatus of claim 198 wherein the software agent is configured to provide an indication of the presence of the at least one dependent file to the software installation map so that the software installation map may apply a time stamp to the first software element signifying that the at least one dependent software file resides on the client device.
  206. 206. A method for maintaining a software repository of software files used for installing at least a first software functionality comprising:
    maintaining a first software application within a primary storage facility of the software repository, the first software application comprising a plurality of software files wherein each software file is represented by a plurality of software elements maintained in a software installation map;
    updating a usage factor of a first software element associated with a first software file from the plurality of software files, the usage factor being a function of a number of times the first software file is installed during a first time period; and
    moving the first software file from the primary storage facility of the software repository to a secondary storage facility as a function of the usage factor.
  207. 207. The method of claim 206 further comprising:
    comparing the usage factor against a threshold value; and
    moving the first software file from the primary storage facility of the software repository to a secondary storage facility if the usage factor meets the threshold value.
  208. 208. The method of claim 207 wherein each software element maintained in the software installation map has at least one associated dependency and a confidence factor associated with the dependency; the method further comprising:
    updating an aging value of the first software element as a function of the confidence factor associated with the dependency.
  209. 209. The method of claim 208 further comprising:
    comparing the aging value to a second threshold; and
    moving the first software file from the primary storage facility of the software repository to a secondary storage facility if the aging value meets the second threshold value.
  210. 210. The method of claim 208 further comprising:
    updating the aging value of the first software element as function of the confidence factor associated with the dependency and the usage factor of the first software element; and
    moving the first software file from the primary storage facility of the software repository to a secondary storage facility as a function of the aging factor.
  211. 211. The method of claim 207 wherein each software element maintained in the software installation map has at least one associated dependency and a plurality of confidence factors associated with the dependency; the method further comprising:
    updating an aging value of the first software element as a function of the confidence factors associated with the dependency.
  212. 212. The method of claim 211 further comprising:
    updating an aging value of the first software element as a function of an average of the confidence factors associated with the dependency.
  213. 213. The method of claim 212 further comprising:
    comparing the aging value to a second threshold; and
    moving the first software file from the primary storage facility of the software repository to a secondary storage facility if the aging value meets the second threshold value.
  214. 214. The method of claim 206 further comprising:
    deleting the first software file from at least one of the primary storage facility and secondary storage facility as a function of the usage factor.
  215. 215. The method of claim 208 further comprising:
    deleting the first software file from at least one of the primary storage facility and the secondary storage facility as a function of the aging factor.
  216. 216. The method of claim 214 further comprising removing the software element from the installation map.
  217. 217. A method for maintaining a software repository of software files used for installing at least a first software functionality comprising:
    maintaining a first software application within a primary storage facility of the software repository, the first software application comprising a plurality of software files wherein each software file is represented by a plurality of software elements maintained in a software installation map, wherein each software element maintained in the software installation map has at least one associated dependency and a confidence factor associated with the dependency;
    updating an aging factor of a first software element associated with a first software file from the plurality of software files, the aging factor being a function of at least one of a number of times the first software file is installed during a first time period and the confidence factor; and
    moving the first software file from the primary storage facility of the software repository to a secondary storage facility as a function of the aging factor.
  218. 218. The method of claim 217 further comprising:
    comparing the aging factor against a threshold value; and
    moving the first software file from the primary storage facility of the software repository to a secondary storage facility if the aging factor meets the threshold value.
  219. 219. The method of claim 217 further comprising:
    deleting the first software file from the secondary storage facility when the first software element representing the first software file is not requested from the software installation map during a predetermined period of time after updating the aging factor.
  220. 220. The method of claim 217 further comprising:
    deleting the first software element from the software installation map as a function of the aging factor.
  221. 221. The method of claim 220 further comprising:
    maintaining a log of deleted software files.
  222. 222. The method of claim 218 wherein the primary storage facility is a relational database.
  223. 223. The method of claim 217 wherein the secondary storage facility is a tape drive system.
  224. 224. A system for maintaining a software warehouse of software files used for installing at least a first software functionality used for installing at least a first software functionality comprising:
    a first storage facility for hosting a plurality of software files wherein each of the plurality of software files are represented by a software element maintained on a software installation map, wherein each software element maintained in the software installation map has at least one associated dependency and a confidence factor associated with the dependency;
    an aging module configured to monitor the plurality of software files and age a software file as function of at least one of a number of times the first software file is installed during a first time period and the confidence factor; and
    a second storage facility in communication with the first storage facility, the second storage facility for receiving from the first storage facility and hosting a plurality of software files when the age of the software file meets a threshold.
  225. 225. The system of claim 224 wherein the first storage facility includes a high speed relational database and the second storage facility includes a tape drive system.
  226. 226. A method for generating a software installation map comprising:
    receiving a first software package comprising at least a first software file and a second software file, the first software file being dependent on the second software file;
    generating a first software element representing the first software file;
    generating a second software element representing the second software file; and
    generating a first dependency pointer representing the dependency between the first software file and the second software file.
  227. 227. The method of claim 226 further comprising:
    extracting the first and the second software files from the first software package.
  228. 228. The method of claim 227 wherein the operation of extracting the first and second software files comprises:
    uncompressing at least the first and second file of the first software package;
    accessing a software installation manifest from the first software package; and
    verifying that at least the first and second software files represented in the software installation manifest have been uncompressed.
  229. 229. The method of claim 228 wherein the operation of uncompressing at least the first and second files from the first software package further comprises executing a compression utility capable of uncompressing the files from the first software package.
  230. 230. The method of claim 228 wherein the software installation manifest includes a list of the first software file, the second software file, and other software files of the first software package.
  231. 231. The method of claim 226 further comprising:
    creating a first location pointer associated with first software element, wherein the first location pointer identifies a physical location of the first software file.
  232. 232. The method of claim 231 wherein the physical location of the first software file is a portion of memory in a relational database.
  233. 233. The method of claim 226 wherein the dependency between the first software file and the second software file is previously declared in the first software package.
  234. 234. The method of claim 233 further comprising:
    generating a first confidence factor representing a validity of the dependency of the first software file on the second software file.
  235. 235. The method of claim 234 wherein the first confidence factor is a function of the defined dependency from the first software package and a historical record of installations involving the dependency of the first software file on the second software file.
  236. 236. The method of claim 226 further comprising:
    defining a first installation route within the software installation map, wherein the first installation route includes at least the first and second software elements and identifies the software elements to install a first functional aspect of the first software package on a computing system.
  237. 237. The method of claim 236 wherein the operation of defining at least one installation route is a function of one or more installation criteria.
  238. 238. The method of claim 237 wherein the installation criteria represent at least one requirement for installing a software application.
  239. 239. The method of claim 236 further comprising:
    defining a second installation route within the software installation map, wherein the second installation route includes at least the first and second software elements and identifies the software elements to install a second functional aspect of the first software package on a computing system; and
    selecting a preferred installation route from at least the first and second installation route achieving at least one of the first and second functional aspects of the first software package.
  240. 240. The method of claim 239 wherein each of the plurality of installation routes is based on differing installation criteria.
  241. 241. The method of claim 226 wherein the first software file comprises one of the following types of software files:
    a) an executable file;
    b) a shared library file;
    c) a configuration file; and
    d) a script file.
  242. 242. The method of claim 226 wherein the first dependency pointer is associated with at least one of the first software element and the second software element.
US11862987 2007-02-15 2007-09-27 Apparatus and method for generating a software dependency map Abandoned US20080201705A1 (en)

Priority Applications (2)

Application Number Priority Date Filing Date Title
US89017107 true 2007-02-15 2007-02-15
US11862987 US20080201705A1 (en) 2007-02-15 2007-09-27 Apparatus and method for generating a software dependency map

Applications Claiming Priority (14)

Application Number Priority Date Filing Date Title
US11862987 US20080201705A1 (en) 2007-02-15 2007-09-27 Apparatus and method for generating a software dependency map
US13083382 US8631400B2 (en) 2007-02-15 2011-04-08 Apparatus and method for generating a software dependency map
US13100982 US8776047B2 (en) 2007-02-15 2011-05-04 Apparatus and method for managing a plurality of software dependency maps and software installation using the same
US13103820 US8566819B2 (en) 2007-02-15 2011-05-09 Apparatus and method for providing software configurations on a plurality of platforms
US13111340 US8589914B2 (en) 2007-02-15 2011-05-19 Apparatus and method to detect and track software installation errors
US13114715 US8645946B2 (en) 2007-02-15 2011-05-24 Apparatus and method for rollback of software updates
US13116902 US8621453B2 (en) 2007-02-15 2011-05-26 Apparatus and method for installing software using a software dependency map
US13149353 US8645947B2 (en) 2007-02-15 2011-05-31 Apparatus and method for establishing dependencies in a software dependency map
US13152088 US8533704B2 (en) 2007-02-15 2011-06-02 Apparatus and method for automated software installation
US13154123 US8719814B2 (en) 2007-02-15 2011-06-06 Apparatus and method for monitoring software installation performance
US13157091 US8640123B2 (en) 2007-02-15 2011-06-09 Apparatus and method for simulating software installation using software dependency map
US13159231 US8589915B2 (en) 2007-02-15 2011-06-13 Apparatus and method for validating and repairing a software installation
US13162429 US8527979B2 (en) 2007-02-15 2011-06-16 Apparatus and method fro maintaining a software repository
US13171189 US8621454B2 (en) 2007-02-15 2011-06-28 Apparatus and method for generating a software dependency map

Related Child Applications (1)

Application Number Title Priority Date Filing Date
US13083382 Continuation US8631400B2 (en) 2007-02-15 2011-04-08 Apparatus and method for generating a software dependency map

Publications (1)

Publication Number Publication Date
US20080201705A1 true true US20080201705A1 (en) 2008-08-21

Family

ID=39707739

Family Applications (14)

Application Number Title Priority Date Filing Date
US11862987 Abandoned US20080201705A1 (en) 2007-02-15 2007-09-27 Apparatus and method for generating a software dependency map
US13083382 Active US8631400B2 (en) 2007-02-15 2011-04-08 Apparatus and method for generating a software dependency map
US13100982 Active 2028-06-14 US8776047B2 (en) 2007-02-15 2011-05-04 Apparatus and method for managing a plurality of software dependency maps and software installation using the same
US13103820 Active 2027-12-13 US8566819B2 (en) 2007-02-15 2011-05-09 Apparatus and method for providing software configurations on a plurality of platforms
US13111340 Active 2028-02-13 US8589914B2 (en) 2007-02-15 2011-05-19 Apparatus and method to detect and track software installation errors
US13114715 Active US8645946B2 (en) 2007-02-15 2011-05-24 Apparatus and method for rollback of software updates
US13116902 Active 2028-02-05 US8621453B2 (en) 2007-02-15 2011-05-26 Apparatus and method for installing software using a software dependency map
US13149353 Active 2031-11-08 US8645947B2 (en) 2007-02-15 2011-05-31 Apparatus and method for establishing dependencies in a software dependency map
US13152088 Active 2028-03-09 US8533704B2 (en) 2007-02-15 2011-06-02 Apparatus and method for automated software installation
US13154123 Active 2028-05-11 US8719814B2 (en) 2007-02-15 2011-06-06 Apparatus and method for monitoring software installation performance
US13157091 Active 2028-05-13 US8640123B2 (en) 2007-02-15 2011-06-09 Apparatus and method for simulating software installation using software dependency map
US13159231 Active 2028-06-22 US8589915B2 (en) 2007-02-15 2011-06-13 Apparatus and method for validating and repairing a software installation
US13162429 Active 2027-12-27 US8527979B2 (en) 2007-02-15 2011-06-16 Apparatus and method fro maintaining a software repository
US13171189 Active 2027-12-16 US8621454B2 (en) 2007-02-15 2011-06-28 Apparatus and method for generating a software dependency map

Family Applications After (13)

Application Number Title Priority Date Filing Date
US13083382 Active US8631400B2 (en) 2007-02-15 2011-04-08 Apparatus and method for generating a software dependency map
US13100982 Active 2028-06-14 US8776047B2 (en) 2007-02-15 2011-05-04 Apparatus and method for managing a plurality of software dependency maps and software installation using the same
US13103820 Active 2027-12-13 US8566819B2 (en) 2007-02-15 2011-05-09 Apparatus and method for providing software configurations on a plurality of platforms
US13111340 Active 2028-02-13 US8589914B2 (en) 2007-02-15 2011-05-19 Apparatus and method to detect and track software installation errors
US13114715 Active US8645946B2 (en) 2007-02-15 2011-05-24 Apparatus and method for rollback of software updates
US13116902 Active 2028-02-05 US8621453B2 (en) 2007-02-15 2011-05-26 Apparatus and method for installing software using a software dependency map
US13149353 Active 2031-11-08 US8645947B2 (en) 2007-02-15 2011-05-31 Apparatus and method for establishing dependencies in a software dependency map
US13152088 Active 2028-03-09 US8533704B2 (en) 2007-02-15 2011-06-02 Apparatus and method for automated software installation
US13154123 Active 2028-05-11 US8719814B2 (en) 2007-02-15 2011-06-06 Apparatus and method for monitoring software installation performance
US13157091 Active 2028-05-13 US8640123B2 (en) 2007-02-15 2011-06-09 Apparatus and method for simulating software installation using software dependency map
US13159231 Active 2028-06-22 US8589915B2 (en) 2007-02-15 2011-06-13 Apparatus and method for validating and repairing a software installation
US13162429 Active 2027-12-27 US8527979B2 (en) 2007-02-15 2011-06-16 Apparatus and method fro maintaining a software repository
US13171189 Active 2027-12-16 US8621454B2 (en) 2007-02-15 2011-06-28 Apparatus and method for generating a software dependency map

Country Status (1)

Country Link
US (14) US20080201705A1 (en)

Cited By (144)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US20060123409A1 (en) * 2004-12-03 2006-06-08 International Business Machines Corporation Method and apparatus for creating a pluggable, prioritized configuration engine to be used for configuring a software during installation, update and new profile creation
US20080235327A1 (en) * 2007-03-23 2008-09-25 Oracle International Corporation Achieving low latencies on network events in a non-real time platform
US20090037897A1 (en) * 2001-03-30 2009-02-05 International Business Machines Corporation Installing and Upgrading an Application in a Computer System
US20090113044A1 (en) * 2007-10-31 2009-04-30 Lancaster Arthur L System and method of configuring a network
US20090165015A1 (en) * 2007-12-21 2009-06-25 Schlumberger Technology Corporation Managing dependencies among applications using satisfiability engine
US20090183182A1 (en) * 2008-01-10 2009-07-16 Microsoft Corporation Dynamic Composition of Virtualized Applications
US20090187894A1 (en) * 2008-01-21 2009-07-23 International Business Machines Corporation Method, apparatus or software for identifying dependencies between components for a given build of a componentised product
WO2009096970A1 (en) * 2008-01-31 2009-08-06 Hewlett-Packard Development Company, L.P. Automated application dependency mapping
US20090217260A1 (en) * 2008-02-26 2009-08-27 Alexander Gebhart Automated virtual appliance sizing
US20090217235A1 (en) * 2008-02-27 2009-08-27 Sap Ag Apparatus and Method of Generating Self-Debugging Computer Software
US20090241107A1 (en) * 2008-03-21 2009-09-24 Canon Kabushiki Kaisha License file issuance apparatus, image processing apparatus, license file issuance method, application installation method, and storage medium
US20090265701A1 (en) * 2008-04-18 2009-10-22 Sun Microsystems, Inc. Method and system for platform-agnostic software installation
US20090265586A1 (en) * 2008-04-18 2009-10-22 Sun Microsystems, Inc. Method and system for installing software deliverables
US20090328051A1 (en) * 2008-06-26 2009-12-31 Oracle International Corporation Resource abstraction via enabler and metadata
US20090328023A1 (en) * 2008-06-27 2009-12-31 Gregory Roger Bestland Implementing optimized installs around pre-install and post-install actions
US20100011042A1 (en) * 2001-10-29 2010-01-14 Eric Debes Method and Apparatus for Efficient Integer Transform
US20100058313A1 (en) * 2008-09-04 2010-03-04 Uwe Hansmann Updating a computer system
US20100058310A1 (en) * 2008-08-29 2010-03-04 Samsung Electronics Co., Ltd. Workform management apparatus and method, image forming apparatus, and workform management system
US20100070468A1 (en) * 2007-06-05 2010-03-18 Canon Kabushiki Kaisha Application management method and information processing apparatus
US20100083228A1 (en) * 2008-09-30 2010-04-01 International Business Machines Corporation Mapping a Class, Method, Package, and/or Pattern to a Component
US20100083246A1 (en) * 2008-09-29 2010-04-01 Synopsys, Inc. System and method for verifying delivered software
US20100100870A1 (en) * 2008-10-21 2010-04-22 Oracle International Corporation Configuration deployment management
US20100107151A1 (en) * 2008-10-24 2010-04-29 Oracle International Corporation Method and system for implementing performance kits
US20100162229A1 (en) * 2008-07-29 2010-06-24 Palm, Inc. Framework versioning
US20100162233A1 (en) * 2008-12-19 2010-06-24 Electronics And Telecommunications Research Institute Method and system for distributing bundled applications
US7770167B1 (en) * 2005-12-30 2010-08-03 United Services Automobile Association (Usaa) Method and system for installing software
US20100211941A1 (en) * 2009-02-13 2010-08-19 Mobitv, Inc. System for automatic management of applications on remote devices
US7840961B1 (en) 2005-12-30 2010-11-23 United Services Automobile Association (Usaa) Method and system for installing software on multiple computing systems
US20100306593A1 (en) * 2009-05-29 2010-12-02 Anton Arapov Automatic bug reporting tool
US20110010649A1 (en) * 2009-07-07 2011-01-13 Hidehiko Watanabe Information processing apparatus, information processing method, and program
US20110016194A1 (en) * 2009-07-15 2011-01-20 Microsoft Corporation Connecting galleries to dynamic server-hosted content
US20110107300A1 (en) * 2009-11-02 2011-05-05 Seth Kelby Vidal Systems and methods for utilizing a history of changes associated with software packages and configuration management to manage multiple computing systems
US20110145278A1 (en) * 2009-11-20 2011-06-16 Oracle International Corporation Methods and systems for generating metadata describing dependencies for composable elements
US20110161953A1 (en) * 2009-12-30 2011-06-30 Lutz Dominick Method for operating a hospital information system
US20110173594A1 (en) * 2010-01-14 2011-07-14 Microsoft Corporation Selective Loading of Code Elements for Code Analysis
US20110185304A1 (en) * 2010-01-28 2011-07-28 International Business Machines Corporation Graphical guides to aid user selection of groups of instruction packages
US20110185339A1 (en) * 2010-01-26 2011-07-28 International Business Machines Corporation Automating the creation of an application provisioning model
US20110185352A1 (en) * 2010-01-22 2011-07-28 Glauber Costa Building packages of functionally different programs from source code of a single program
US20110191762A1 (en) * 2010-02-02 2011-08-04 International Business Machines Corporation Mining dependencies from disk images
US20110214112A1 (en) * 2010-02-26 2011-09-01 Seth Kelby Vidal Systems and mehtods for generating predictive diagnostics via package update manager
US20110214021A1 (en) * 2010-02-26 2011-09-01 Seth Kelby Vidal Systems and methods for initiating software repairs in conjunction with software package updates
US20110214018A1 (en) * 2010-02-26 2011-09-01 Seth Kelby Vidal Systems and methods for diagnostic notification via package update manager
US20110214116A1 (en) * 2010-02-26 2011-09-01 Seth Kelby Vidal Systems and methods for managing software package updates using communication pipes
US20110214118A1 (en) * 2010-02-26 2011-09-01 James Antill Systems and methods for generating and storing translation information as package metadata
US20110246982A1 (en) * 2007-02-15 2011-10-06 Oracle America, Inc. Apparatus and method for maintaining a software repository
US20110271286A1 (en) * 2010-04-30 2011-11-03 Sap Ag System and method for application function consolidation
US20110296393A1 (en) * 2010-05-25 2011-12-01 Seth Kelby Vidal Systems and methods for generating an encoded package profile based on executing host processes
US20120102569A1 (en) * 2010-10-21 2012-04-26 F-Secure Corporation Computer system analysis method and apparatus
US20120117560A1 (en) * 2010-05-26 2012-05-10 Tibco Software Inc. Capability model for deploying componentized applications
US20120124570A1 (en) * 2010-11-16 2012-05-17 Motorola Mobility, Inc. Method and system for facilitating the providing of software updates to mobile devices
US20120151418A1 (en) * 2010-12-14 2012-06-14 International Business Machines Corporation Linking of a plurality of items of a user interface to display new information inferred from the plurality of items that are linked
US20120159468A1 (en) * 2010-12-20 2012-06-21 Microsoft Corporation Software deployment to multiple computing devices
US20120191845A1 (en) * 2010-12-23 2012-07-26 Computer Associates Think, Inc. Methods and Systems for Executing Applications on Personal Digital Assistant Terminals
US20120204149A1 (en) * 2011-02-03 2012-08-09 International Business Machines Corporation Discovery-based migration correctness testing
US20120215831A1 (en) * 2011-02-22 2012-08-23 Julian Michael Urbach Software Application Delivery and Launching System
US20120254900A1 (en) * 2011-04-01 2012-10-04 Ebay Inc. Flow tracing though diverse logical and physical application and infrastructure layers/dependencies
US8321498B2 (en) 2005-03-01 2012-11-27 Oracle International Corporation Policy interface description framework
US20120311562A1 (en) * 2011-06-01 2012-12-06 Yanlin Wang Extendable event processing
WO2013011401A1 (en) * 2011-07-21 2013-01-24 Lam Research Corporation Data architecture and user interface for plasma processing related software applications
US8370506B2 (en) 2007-11-20 2013-02-05 Oracle International Corporation Session initiation protocol-based internet protocol television
US8381036B2 (en) 2010-05-26 2013-02-19 Red Hat, Inc. Systems and methods for restoring machine state history related to detected faults in package update process
US8401022B2 (en) 2008-02-08 2013-03-19 Oracle International Corporation Pragmatic approaches to IMS
US20130073713A1 (en) * 2011-09-15 2013-03-21 International Business Machines Corporation Resource Selection Advisor Mechanism
US8429256B2 (en) 2010-05-28 2013-04-23 Red Hat, Inc. Systems and methods for generating cached representations of host package inventories in remote package repositories
US20130167136A1 (en) * 2009-03-18 2013-06-27 Adobe Systems Incorporated Component-based installation
WO2013109555A1 (en) * 2012-01-19 2013-07-25 Microsoft Corporation Managing script file dependencies and load times
US8505067B2 (en) 2008-08-21 2013-08-06 Oracle International Corporation Service level network quality of service policy enforcement
US8533773B2 (en) 2009-11-20 2013-09-10 Oracle International Corporation Methods and systems for implementing service level consolidated user information management
US8539097B2 (en) 2007-11-14 2013-09-17 Oracle International Corporation Intelligent message processing
US20130262401A1 (en) * 2012-03-30 2013-10-03 Branch Banking and Trust Compnay System and Method for License Reclamation
US8566820B1 (en) 2005-12-30 2013-10-22 United Services Automobile Association (Usaa) Method and system for installing software
US20130283252A1 (en) * 2012-04-23 2013-10-24 Sandya Srivilliputtur Mannarswamy Dynamic Software Updates
US8583830B2 (en) 2009-11-19 2013-11-12 Oracle International Corporation Inter-working with a walled garden floor-controlled system
US8589338B2 (en) 2008-01-24 2013-11-19 Oracle International Corporation Service-oriented architecture (SOA) management of data repository
US20140020049A1 (en) * 2012-07-13 2014-01-16 Angel Secure Networks, Inc. System and method for policy driven protection of remote computing environments
US20140033315A1 (en) * 2009-11-19 2014-01-30 Adobe Systems Incorporated Method and system for enforcing a license dependency rule for a software application
US20140096129A1 (en) * 2012-09-28 2014-04-03 Wal-Mart Stores, Inc. Systems and methods for installing, managing, and provisioning applications
US20140115151A1 (en) * 2012-10-14 2014-04-24 Empire Technology Development Llc Error-capturing service replacement in datacenter environment for simplified application restructuring
US8713558B2 (en) 2010-09-01 2014-04-29 Red Hat, Inc. Generating package profiles in software package repositories using selective subsets of packages
US8726271B1 (en) 2005-12-30 2014-05-13 United Services Automobile Association (Usaa) Method and system for installing software
US8762931B2 (en) 2010-05-26 2014-06-24 Red Hat, Inc. Generating an encoded package profile
US8776014B2 (en) 2010-09-23 2014-07-08 Microsoft Corporation Software build analysis
US20140222904A1 (en) * 2010-07-02 2014-08-07 Code Systems Corporation Method and system for building and distributing application profiles via the internet
US8806471B2 (en) 2010-09-28 2014-08-12 Red Hat, Inc. Upgrade and downgrade in package update operations
US8806477B2 (en) 2009-10-30 2014-08-12 Red Hat, Inc. Space efficient software package management
US8826223B2 (en) 2012-04-18 2014-09-02 International Business Machines Corporation Techniques for objective assessment and improvement of software quality
US8843919B1 (en) 2005-12-30 2014-09-23 United Services Automobile Association (Usaa) Method and system for restoring software
US8856953B2 (en) 2010-09-01 2014-10-07 Red Hat, Inc. Access policy for package update processes
US8879547B2 (en) 2009-06-02 2014-11-04 Oracle International Corporation Telephony application services
US8914493B2 (en) 2008-03-10 2014-12-16 Oracle International Corporation Presence-based event driven architecture
US20140372799A1 (en) * 2012-01-29 2014-12-18 Huawei Device Co., Ltd. System Differential Upgrade Method, Apparatus, and Mobile Terminal
US8922569B1 (en) 2011-12-30 2014-12-30 hopTo Inc. Cloud based system for and method of translating between disparate 3D graphics languages in client-server computing environments
US20150007197A1 (en) * 2012-04-27 2015-01-01 Travis S. Tripp Mapping application dependencies at runtime
US20150033204A1 (en) * 2012-03-01 2015-01-29 Nec Corporation System-construction-procedure generating device, system-construction-procedure generating method, and program thereof
US8949429B1 (en) * 2011-12-23 2015-02-03 Amazon Technologies, Inc. Client-managed hierarchical resource allocation
US8966498B2 (en) 2008-01-24 2015-02-24 Oracle International Corporation Integrating operational and business support systems with a service delivery platform
US20150074231A1 (en) * 2013-09-10 2015-03-12 International Business Machines Corporation Dynamic help pages using linked data
US20150082298A1 (en) * 2013-09-19 2015-03-19 Qiu Shi WANG Packaging and deploying hybrid applications
US8990561B2 (en) 2011-09-09 2015-03-24 Microsoft Technology Licensing, Llc Pervasive package identifiers
US9003400B2 (en) 2010-11-29 2015-04-07 Red Hat, Inc. Tracking computing systems utilizing software repositories
WO2015057188A1 (en) * 2013-10-14 2015-04-23 Hewlett-Packard Development Company, L.P. Package dependency maps for distributed computing
US20150121485A1 (en) * 2013-10-30 2015-04-30 1E Limited Configuration of network devices
US20150134686A1 (en) * 2013-11-12 2015-05-14 Nikolai Neichev Mechanism for delivery of help content to a cloud landscape
US9038082B2 (en) 2004-05-28 2015-05-19 Oracle International Corporation Resource abstraction via enabler and metadata
US9064292B1 (en) 2011-12-30 2015-06-23 hopTo, Inc. System for and method of classifying and translating graphics commands in client-server computing systems
US20150193331A1 (en) * 2011-09-02 2015-07-09 Vu Lam Systems and methods for processing software application metadata associated with a software application
US9104519B1 (en) * 2013-06-17 2015-08-11 Symantec Corporation Provisioning partner aware apps on sandboxed operating systems
US9118686B2 (en) 2011-09-06 2015-08-25 Microsoft Technology Licensing, Llc Per process networking capabilities
GB2524798A (en) * 2014-04-03 2015-10-07 Ibm Method and test environment for automatic testing a software product comprising a plurality of software packages
US9183663B1 (en) 2011-12-30 2015-11-10 Graphon Corporation System for and method of classifying and translating graphics commands in client-server computing systems
US20150373107A1 (en) * 2012-10-02 2015-12-24 Nextbit Systems, Inc. Managing applications on an electronic device
US9245236B2 (en) 2006-02-16 2016-01-26 Oracle International Corporation Factorization of concerns to build a SDP (service delivery platform)
US9274784B2 (en) * 2014-06-02 2016-03-01 Sap Se Automatic deployment and update of hybrid applications
US9367302B2 (en) 2010-05-27 2016-06-14 Red Hat, Inc. Generating client qualification to execute package update manager
US20160188614A1 (en) * 2014-12-31 2016-06-30 Dell Products L.P. Email and Identity Migration Based on Relationship Information
US20160188310A1 (en) * 2014-12-26 2016-06-30 Canon Kabushiki Kaisha Information processing apparatus, control method for information processing apparatus, and storage medium of program for executing control method
US9417865B2 (en) 2010-05-28 2016-08-16 Red Hat, Inc. Determining when to update a package manager software
US20160266889A1 (en) * 2015-03-13 2016-09-15 Kony, Inc. Providing updates for natively rendered mobile applications
US9503407B2 (en) 2009-12-16 2016-11-22 Oracle International Corporation Message forwarding
US9509790B2 (en) 2009-12-16 2016-11-29 Oracle International Corporation Global presence
WO2017004269A1 (en) * 2015-06-30 2017-01-05 Vmware, Inc. Methods and apparatus for software lifecycle management of a virtual computing environment
US9565297B2 (en) 2004-05-28 2017-02-07 Oracle International Corporation True convergence with end to end identity management
US9569286B2 (en) 2010-01-29 2017-02-14 Code Systems Corporation Method and system for improving startup performance and interoperability of a virtual application
US20170090901A1 (en) * 2015-09-30 2017-03-30 Apple Inc. Software Updating
US9626237B2 (en) 2010-04-17 2017-04-18 Code Systems Corporation Method of hosting a first application in a second application
US9654515B2 (en) 2008-01-23 2017-05-16 Oracle International Corporation Service oriented architecture-based SCIM platform
US9652218B2 (en) * 2015-06-17 2017-05-16 International Business Machines Corporation Feature exploitation evaluator
US9678721B2 (en) * 2015-09-30 2017-06-13 Semmle Limited Implicit software dependency analysis
US9705978B1 (en) * 2016-07-01 2017-07-11 Red Hat Israel, Ltd. Dependency graph management
US9705974B2 (en) 2014-07-11 2017-07-11 Vmware, Inc. Methods and apparatus to transfer physical hardware resources between virtual rack domains in a virtualized server rack
US9717985B2 (en) 2012-10-02 2017-08-01 Razer (Asia-Pacific) Pte. Ltd. Fragment-based mobile device application streaming utilizing crowd-sourcing
US9749393B2 (en) 2010-01-27 2017-08-29 Code Systems Corporation System for downloading and executing a virtual application
US9747000B2 (en) 2012-10-02 2017-08-29 Razer (Asia-Pacific) Pte. Ltd. Launching applications on an electronic device
US9747425B2 (en) 2010-10-29 2017-08-29 Code Systems Corporation Method and system for restricting execution of virtual application to a managed process environment
US9773102B2 (en) 2011-09-09 2017-09-26 Microsoft Technology Licensing, Llc Selective file access for applications
US9772834B2 (en) 2010-04-27 2017-09-26 Red Hat, Inc. Exportable encoded identifications of networked machines
US9773017B2 (en) 2010-01-11 2017-09-26 Code Systems Corporation Method of configuring a virtual application
US9779111B2 (en) 2008-08-07 2017-10-03 Code Systems Corporation Method and system for configuration of virtualized software applications
US9792429B2 (en) 2010-10-06 2017-10-17 Red Hat, Inc. Detection of malicious software packages
US9800688B2 (en) 2011-09-12 2017-10-24 Microsoft Technology Licensing, Llc Platform-enabled proximity service
US9858247B2 (en) 2013-05-20 2018-01-02 Microsoft Technology Licensing, Llc Runtime resolution of content references
US9864600B2 (en) 2008-08-07 2018-01-09 Code Systems Corporation Method and system for virtualization of software applications
US9870213B2 (en) * 2015-08-06 2018-01-16 Sap Se Unified consumption experience for software installation
US9942298B2 (en) * 2013-09-10 2018-04-10 International Business Machines Corporation Dynamic help pages using linked data

Families Citing this family (103)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US8074214B2 (en) * 2005-05-19 2011-12-06 Oracle International Corporation System for creating a customized software installation on demand
US7779401B2 (en) * 2006-06-26 2010-08-17 Research In Motion Limited Method and system for generating a reverse binary patch for undoing a software update
CN102006334B (en) 2007-06-11 2013-01-02 华为技术有限公司 Method, system and device for installing software component
US9323519B2 (en) * 2007-08-31 2016-04-26 Red Hat, Inc. Packaging an application
JP5136105B2 (en) * 2008-02-13 2013-02-06 富士通株式会社 Data mounting device, and upgrading the data mounting device
US20090276269A1 (en) * 2008-05-05 2009-11-05 Oracle International Corp Software identifier based correlation
US8281300B2 (en) * 2008-07-02 2012-10-02 Novell, Inc. Software package management
US9038056B1 (en) * 2009-03-31 2015-05-19 Avaya Inc. Method and apparatus for performing automatable software upgrades using a lightweight serviceless install agent
JP5368878B2 (en) * 2009-05-25 2013-12-18 キヤノン株式会社 The information processing apparatus, manufacturing apparatus and device manufacturing method
US8381208B2 (en) * 2009-06-11 2013-02-19 International Business Machines Corporation Tracking application installation among a plurality of client devices
US8972974B2 (en) 2009-11-09 2015-03-03 Bank Of America Corporation Multiple invocation points in software build task sequence
US20110113424A1 (en) * 2009-11-09 2011-05-12 Bank Of America Corporation Distribution Of Software Updates
US9122558B2 (en) 2009-11-09 2015-09-01 Bank Of America Corporation Software updates using delta patching
US20110113421A1 (en) 2009-11-09 2011-05-12 Bank Of America Corporation Programmatic Creation Of Task Sequences From Manifests
US20110113416A1 (en) * 2009-11-09 2011-05-12 Bank Of America Corporation Network-Enhanced Control Of Software Updates Received Via Removable Computer-Readable Medium
US9176898B2 (en) 2009-11-09 2015-11-03 Bank Of America Corporation Software stack building using logically protected region of computer-readable medium
JP5515904B2 (en) * 2010-03-17 2014-06-11 株式会社リコー The information processing system, the management apparatus, an information processing apparatus, the installation processing method, program and storage medium
US8464208B2 (en) * 2010-03-26 2013-06-11 Oracle International Corporation Capturing and utilizing specific module dependency information
US9448790B2 (en) 2010-04-26 2016-09-20 Pivotal Software, Inc. Rapid updating of cloud applications
US9772831B2 (en) 2010-04-26 2017-09-26 Pivotal Software, Inc. Droplet execution engine for dynamic server application deployment
US8855627B2 (en) 2010-06-14 2014-10-07 Future Dial, Inc. System and method for enhanced diagnostics on mobile communication devices
US8910149B2 (en) * 2010-12-24 2014-12-09 Microsoft Corporation On-demand or incremental remote data copy
US9286037B2 (en) * 2010-12-29 2016-03-15 Microsoft Technology Licensing, Llc Platform for distributed applications
EP2482192A1 (en) * 2011-01-31 2012-08-01 Tata Consultancy Services Limited Testing lifecycle
US8589893B1 (en) * 2011-03-22 2013-11-19 Amazon Technologies, Inc. Usage-based program slicing
JP5284403B2 (en) * 2011-03-28 2013-09-11 株式会社東芝 Ontology updating device, method and system,
US8997078B2 (en) 2011-04-12 2015-03-31 Pivotal Software, Inc. Release lifecycle management system for a multi-node application
US8813060B2 (en) * 2011-06-17 2014-08-19 Microsoft Corporation Context aware application model for connected devices
US8676938B2 (en) * 2011-06-28 2014-03-18 Numecent Holdings, Inc. Local streaming proxy server
JP2013020354A (en) * 2011-07-08 2013-01-31 Ricoh Co Ltd Log tabulation program, log tabulation device, and installer packager program
US8875120B2 (en) * 2011-08-01 2014-10-28 Salesforce.Com, Inc. Methods and apparatus for providing software bug-fix notifications for networked computing systems
US8996916B2 (en) * 2011-08-16 2015-03-31 Future Dial, Inc. System and method for identifying problems via a monitoring application that repetitively records multiple separate consecutive files listing launched or installed applications
US9619779B2 (en) * 2011-08-26 2017-04-11 Apple Inc. Client-side policy enforcement of developer API use
EP2751682A4 (en) * 2011-08-29 2015-01-07 Fiberlink Comm Corp Platform for deployment and distribution of modules to endpoints
US20130067459A1 (en) * 2011-09-09 2013-03-14 Microsoft Corporation Order-Independent Deployment Collections with Dependency Package Identifiers
US8677346B1 (en) * 2011-09-27 2014-03-18 Symantec Corporation Providing installer package information to a user
US20130081007A1 (en) * 2011-09-27 2013-03-28 International Business Machines Corporation Providing continuous application availability during application update
US9213579B2 (en) * 2011-09-28 2015-12-15 International Business Machines Corporation Software component placement on execution platforms
WO2013055373A1 (en) * 2011-10-15 2013-04-18 Hewlett-Packard Development Company, L.P. Quantifying power usage for a service
US8732690B1 (en) * 2011-10-27 2014-05-20 Crimson Corporation Computing device configured for installing an application
US20130117739A1 (en) * 2011-11-09 2013-05-09 Ford Global Technologies, Llc Electronic Tool for Automatically Programming a Plurality of Control Modules in a Vehicle On-Board Computer System
CN102426533B (en) * 2011-12-12 2014-10-01 奇智软件(北京)有限公司 Method and apparatus for software installation
US8898178B2 (en) * 2011-12-15 2014-11-25 Microsoft Corporation Solution monitoring system
US8938518B2 (en) * 2012-01-16 2015-01-20 International Business Machines Corporation Transferring applications and session state to a secondary device
US9386057B2 (en) 2012-01-18 2016-07-05 Numecent Holdings, Inc. Application streaming and execution system for localized clients
US9772832B2 (en) * 2012-01-20 2017-09-26 S-Printing Solution Co., Ltd. Computing system with support for ecosystem mechanism and method of operation thereof
US9262238B2 (en) 2012-01-31 2016-02-16 Red Hat, Inc. Connection management for an application in a computing platform
US9665356B2 (en) 2012-01-31 2017-05-30 Red Hat, Inc. Configuration of an application in a computing platform
US9170797B2 (en) * 2012-01-31 2015-10-27 Red Hat, Inc. Automated deployment of an application in a computing platform
US9047133B2 (en) 2012-03-02 2015-06-02 Vmware, Inc. Single, logical, multi-tier application blueprint used for deployment and management of multiple physical applications in a cloud environment
US9052961B2 (en) 2012-03-02 2015-06-09 Vmware, Inc. System to generate a deployment plan for a cloud infrastructure according to logical, multi-tier application blueprint
US9170798B2 (en) 2012-03-02 2015-10-27 Vmware, Inc. System and method for customizing a deployment plan for a multi-tier application in a cloud infrastructure
US20130232497A1 (en) * 2012-03-02 2013-09-05 Vmware, Inc. Execution of a distributed deployment plan for a multi-tier application in a cloud infrastructure
US9485304B2 (en) 2012-04-30 2016-11-01 Numecent Holdings, Inc. Asset streaming and delivery
US20150127787A1 (en) * 2012-06-04 2015-05-07 Nec Corporation Deployment device and deployment method
US20140325502A1 (en) * 2012-06-29 2014-10-30 Giannis Zarifis Packaging, distribution and de-packaging of device-independent software applications
US9348652B2 (en) 2012-07-02 2016-05-24 Vmware, Inc. Multi-tenant-cloud-aggregation and application-support system
US8930899B2 (en) 2012-08-18 2015-01-06 International Business Machines Corporation Artifact divider for large scale application builds
US9798557B2 (en) 2012-08-24 2017-10-24 Ca, Inc. Injection of updated classes for a java agent
US9817656B2 (en) 2012-08-24 2017-11-14 Ca, Inc. Hot rollback of updated agent
US9276942B2 (en) 2012-09-07 2016-03-01 Oracle International Corporation Multi-tenancy identity management system
US9397884B2 (en) 2012-09-07 2016-07-19 Oracle International Corporation Workflows for processing cloud services
US8949824B2 (en) 2012-09-28 2015-02-03 Wal-Mart Stores, Inc. Systems and methods for installing, managing, and provisioning applications
US9235491B2 (en) 2012-09-28 2016-01-12 Wal-Mart Stores, Inc. Systems and methods for installing, managing, and provisioning applications
US9317269B2 (en) 2012-09-28 2016-04-19 Wal-Mart Stores, Inc. Systems and methods for installing, managing, and provisioning applications
GB201217571D0 (en) 2012-10-02 2012-11-14 Ibm System provisioning optimization
US9569274B2 (en) 2012-10-16 2017-02-14 Microsoft Technology Licensing, Llc Distributed application optimization using service groups
US9164746B2 (en) 2012-10-31 2015-10-20 Wal-Mart Stores, Inc. Automatic topology extraction and plotting with correlation to real time analytic data
US8966316B2 (en) * 2012-11-30 2015-02-24 Lenovo Enterprise Solutions (Singapore) Pte. Ltd. Identifying software responsible for changes in system stability
RU2628176C2 (en) * 2012-12-14 2017-08-15 Телефонактиеболагет Л М Эрикссон (Пабл) Systems, methods and computer software products for assembly and loading process of software with use of compilation and deployment service
US9875090B2 (en) * 2012-12-20 2018-01-23 Microsoft Technology Licensing, Llc Program analysis based on program descriptors
US9661048B2 (en) 2013-01-18 2017-05-23 Numecent Holding, Inc. Asset streaming and delivery
CN103970516B (en) * 2013-01-30 2015-10-07 腾讯科技(深圳)有限公司 Method and apparatus for redundant image has been deleted
US20140259004A1 (en) * 2013-03-07 2014-09-11 Go Daddy Operating Company, LLC System for trusted application deployment
US20140259003A1 (en) * 2013-03-07 2014-09-11 Go Daddy Operating Company, LLC Method for trusted application deployment
US9753714B1 (en) * 2013-03-12 2017-09-05 Ca, Inc. Software package management systems including multiple modules for supporting multiple software package types
US9379954B2 (en) * 2013-03-15 2016-06-28 Chef Software Inc. Configuration management for a resource with prerequisites
WO2014165538A3 (en) 2013-04-01 2014-11-27 Nebula, Inc. Update management for a distributed computing system
US9594545B2 (en) * 2013-06-05 2017-03-14 Splunk Inc. System for displaying notification dependencies between component instances
US8756614B2 (en) 2013-06-05 2014-06-17 Splunk Inc. Central registry for binding features using dynamic pointers
WO2015022890A1 (en) * 2013-08-12 2015-02-19 日本電気株式会社 Software aging test system, software agint test method, and program for software aging test
JP2015060557A (en) * 2013-09-20 2015-03-30 キヤノン株式会社 Information processing system, information processing apparatus, device apparatus, software installation method, and computer program
US9250889B2 (en) * 2013-10-18 2016-02-02 International Business Machines Corporation Assigning severity to a software update
US20150242282A1 (en) * 2014-02-24 2015-08-27 Red Hat, Inc. Mechanism to update software packages
KR20160130785A (en) 2014-02-27 2016-11-14 오픈모바일 월드 와이드, 인크 In-process trapping for service substitution in hosted applicaitons executing on mobile devices with multi operating system environment
WO2015163938A1 (en) * 2014-04-25 2015-10-29 OpenMobile World Wide, Inc. Hybrid installation application package files for multi-operating system environment
US9405524B1 (en) * 2014-04-30 2016-08-02 Allscripts Software, Llc Software verification system and methods
US9336018B2 (en) * 2014-05-02 2016-05-10 Oracle International Corporation Mechanism for class data sharing using extension and application class-loaders
US9223558B2 (en) 2014-06-02 2015-12-29 International Business Machines Corporation Software installation and configuration
US20150379064A1 (en) * 2014-06-25 2015-12-31 Linkedin Corporation Dependency management during model compilation of statistical models
US9535688B2 (en) * 2014-07-23 2017-01-03 Verizon Patent And Licensing Inc. Efficient deployment of application revisions and implementation of application rollbacks across multiple application servers
CN105335187A (en) 2014-08-14 2016-02-17 阿里巴巴集团控股有限公司 Application processing method and apparatus
US9146711B1 (en) 2014-08-27 2015-09-29 International Business Machines Corporation Software component configuration identification
JP2016126568A (en) * 2015-01-05 2016-07-11 富士通株式会社 Application provision method, application provision server, and application provision program
US9626277B2 (en) 2015-04-01 2017-04-18 Microsoft Technology Licensing, Llc Anomaly analysis for software distribution
US9612827B2 (en) 2015-06-11 2017-04-04 International Business Machines Corporation Automatically complete a specific software task using hidden tags
US9594624B2 (en) 2015-06-12 2017-03-14 International Business Machines Corporation Resolving and preventing computer system failures caused by changes to the installed software
US9612821B2 (en) * 2015-07-02 2017-04-04 International Business Machines Corporation Predicting the success of a continuous software deployment pipeline
US20170017798A1 (en) * 2015-07-17 2017-01-19 International Business Machines Corporation Source authentication of a software product
US20170046145A1 (en) * 2015-08-13 2017-02-16 Unisys Corporation Systems and methods for dynamically installing a program's dependent modules before program execution
US9740473B2 (en) 2015-08-26 2017-08-22 Bank Of America Corporation Software and associated hardware regression and compatibility testing system
US9916148B2 (en) * 2015-12-02 2018-03-13 Vmware, Inc. System for managing software package configuration
US9858167B2 (en) * 2015-12-17 2018-01-02 Intel Corporation Monitoring the operation of a processor

Family Cites Families (79)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US6117187A (en) * 1997-09-30 2000-09-12 Hewlett-Packard Company Automatic generation of a software installation package
US6202207B1 (en) 1998-01-28 2001-03-13 International Business Machines Corporation Method and a mechanism for synchronized updating of interoperating software
US6381742B2 (en) 1998-06-19 2002-04-30 Microsoft Corporation Software package management
US7526468B2 (en) 1999-01-08 2009-04-28 Computer Associates Think, Inc. System and method for recursive path analysis of DBMS procedures
US6591418B2 (en) 1999-03-26 2003-07-08 Dell U.S.A., L.P. Factory software management system
US6675382B1 (en) * 1999-06-14 2004-01-06 Sun Microsystems, Inc. Software packaging and distribution system
US6349137B1 (en) 1999-08-05 2002-02-19 Rockwell Electronic Commerce Corp. Apparatus and method for providing support software for an agent workstation of an automatic call distributor
US6542167B1 (en) 2000-01-28 2003-04-01 Wind River Systems, Inc. System and method for flexible software linking
US20020087949A1 (en) 2000-03-03 2002-07-04 Valery Golender System and method for software diagnostics using a combination of visual and dynamic tracing
US20010037289A1 (en) 2000-04-27 2001-11-01 Mona Mayr Methods and systems of identifying, processing and credit evaluating low-moderate income populations and reject inferencing of credit applicants
US6698018B1 (en) 2000-05-10 2004-02-24 Microsoft Corporation System and method of multiple-stage installation of a suite of applications
US6883168B1 (en) 2000-06-21 2005-04-19 Microsoft Corporation Methods, systems, architectures and data structures for delivering software via a network
US7000230B1 (en) 2000-06-21 2006-02-14 Microsoft Corporation Network-based software extensions
US20040003266A1 (en) 2000-09-22 2004-01-01 Patchlink Corporation Non-invasive automatic offsite patch fingerprinting and updating system and method
US6832373B2 (en) 2000-11-17 2004-12-14 Bitfone Corporation System and method for updating and distributing information
US6918112B2 (en) * 2000-11-29 2005-07-12 Microsoft Corporation System and method to facilitate installation of components across one or more computers
US7076496B1 (en) 2001-02-23 2006-07-11 3Com Corporation Method and system for server based software product release version tracking
USPP13320P2 (en) * 2001-04-17 2002-12-03 Berry Genetics, Inc. Strawberry plant named ‘BG-633’
US20020188941A1 (en) 2001-06-12 2002-12-12 International Business Machines Corporation Efficient installation of software packages
US20030028870A1 (en) 2001-08-01 2003-02-06 Weisman Mitchell T. Distribution of downloadable software over a network
US6954928B2 (en) 2001-08-08 2005-10-11 Hewlett-Packard Development Company, L.P. Method for selecting a set of patches to update a system of programs
US6986135B2 (en) 2001-09-06 2006-01-10 Cognos Incorporated Deployment manager for organizing and deploying an application in a distributed computing environment
US20030172368A1 (en) 2001-12-26 2003-09-11 Elizabeth Alumbaugh System and method for autonomously generating heterogeneous data source interoperability bridges based on semantic modeling derived from self adapting ontology
US7503042B2 (en) 2002-03-08 2009-03-10 Microsoft Corporation Non-script based intelligent migration tool capable of migrating software selected by a user, including software for which said migration tool has had no previous knowledge or encounters
US7600021B2 (en) 2002-04-03 2009-10-06 Microsoft Corporation Delta replication of source files and packages across networked resources
US6938250B2 (en) 2002-06-12 2005-08-30 Microsoft Corporation Image-based software installation
US7228526B2 (en) 2002-06-12 2007-06-05 Microsoft Corporation Application imaging infrastructure
US7249174B2 (en) 2002-06-12 2007-07-24 Bladelogic, Inc. Method and system for executing and undoing distributed server change operations
GB0214303D0 (en) 2002-06-21 2002-07-31 Koninkl Philips Electronics Nv Server side configuration management
US7246352B2 (en) 2002-07-24 2007-07-17 International Business Machines Corporation System for generating a virtual map to a plurality of files necessary for installing software from multiple networked locations
US20040054991A1 (en) 2002-09-17 2004-03-18 Harres John M. Debugging tool and method for tracking code execution paths
US8312446B2 (en) 2002-12-17 2012-11-13 International Business Machines Corporation Dependency management when upgrading application components
US7478385B2 (en) 2003-01-17 2009-01-13 National Instruments Corporation Installing software using programmatic component dependency analysis
WO2004081758A3 (en) 2003-03-12 2005-03-24 Digex Inc System and method for maintaining installed software compliance with build standards
US20040250247A1 (en) 2003-06-09 2004-12-09 Sun Microsystems, Inc. Extensible software installation and configuration framework
US7313792B2 (en) 2003-09-08 2007-12-25 Microsoft Corporation Method and system for servicing software
WO2005045671A1 (en) 2003-10-27 2005-05-19 American Power Conversion Corporation System and method for updating a software program
US7802084B2 (en) 2003-11-26 2010-09-21 Hewlett-Packard Development Company, L.P. System and method for management and installation of operating system images for computers
US7376945B1 (en) 2003-12-02 2008-05-20 Cisco Technology, Inc. Software change modeling for network devices
US20050125525A1 (en) 2003-12-09 2005-06-09 International Business Machines Method, system, and storage medium for providing intelligent distribution of software and files
US7404180B2 (en) 2003-12-11 2008-07-22 Sap Ag Trace management in client-server applications
US7568195B2 (en) * 2003-12-16 2009-07-28 Microsoft Corporation Determining a maximal set of dependent software updates valid for installation
US7603668B2 (en) 2004-01-09 2009-10-13 Hewlett-Packard Development Company, L.P. Determining the applicability of patches for installation on a computer system
US7765592B2 (en) 2004-01-10 2010-07-27 Microsoft Corporation Changed file identification, software conflict resolution and unwanted file removal
US7617519B2 (en) * 2004-03-18 2009-11-10 Microsoft Corporation System and method for intelligent recommendation with experts for user trust decisions
US7694291B2 (en) 2004-04-06 2010-04-06 Hewlett-Packard Development Company, L.P. Build optimizer tool for efficient management of software builds for mobile devices
US7735077B2 (en) * 2004-05-05 2010-06-08 Bea Systems, Inc. System and method for inventory services
JP2006099307A (en) 2004-09-29 2006-04-13 Hitachi Ltd Method for installing application set in distribution server
US20060080656A1 (en) 2004-10-12 2006-04-13 Microsoft Corporation Methods and instructions for patch management
US7765538B2 (en) * 2004-10-29 2010-07-27 Hewlett-Packard Development Company, L.P. Method and apparatus for determining which program patches to recommend for installation
US20060140144A1 (en) 2004-12-27 2006-06-29 Motorola, Inc. Method and system for providing an open gateway initiative bundle over the air
US7987459B2 (en) 2005-03-16 2011-07-26 Microsoft Corporation Application programming interface for identifying, downloading and installing applicable software updates
EP1739552A1 (en) 2005-06-21 2007-01-03 Hewlett-Packard Development Company, L.P. Software installation method and computer system
US8291405B2 (en) * 2005-08-30 2012-10-16 Novell, Inc. Automatic dependency resolution by identifying similar machine profiles
US20070101197A1 (en) 2005-11-03 2007-05-03 International Business Machines Corporation System and method for representing system capabilities as software packages in a software package management system
US20070169079A1 (en) * 2005-11-08 2007-07-19 Microsoft Corporation Software update management
US7478093B2 (en) 2006-01-30 2009-01-13 International Business Machines Corporation Design of self-adapting meta descriptors based on real use scenarios and experiences
US20070240134A1 (en) 2006-02-28 2007-10-11 Joydeep Buragohain Software packaging model supporting multiple entity types
US7971202B2 (en) 2006-03-14 2011-06-28 International Business Machines Corporation Method for advanced management of software distribution tasks
US8060871B2 (en) 2006-03-30 2011-11-15 Microsoft Corporation Servicing software through versioning
US20070277167A1 (en) 2006-05-23 2007-11-29 International Business Machines Corporation System and method for computer system maintenance
US7839816B2 (en) 2006-06-12 2010-11-23 Hewlett-Packard Development Company, L.P. Assembly, and associated methodology, for provisioning computer device with operating software
US20070300215A1 (en) 2006-06-26 2007-12-27 Bardsley Jeffrey S Methods, systems, and computer program products for obtaining and utilizing a score indicative of an overall performance effect of a software update on a software host
US8387038B2 (en) 2006-08-14 2013-02-26 Caterpillar Inc. Method and system for automatic computer and user migration
US7865874B2 (en) * 2006-08-28 2011-01-04 Oracle America, Inc. System and method for information collection for an adaptive software dependency model
US7761395B2 (en) * 2006-08-28 2010-07-20 Oracle America, Inc. System and method for scalable processing of collected knowledge by creating knowledge generation nodes
US7752158B2 (en) * 2006-08-28 2010-07-06 Oracle America, Inc. System and method for generating an adaptive software knowledge model incorporating new information with model dependency analysis
US7870539B2 (en) * 2006-08-28 2011-01-11 Oracle America, Inc. System and method for cross-channel dependency resolution in a dependency model
US20080077592A1 (en) 2006-09-27 2008-03-27 Shane Brodie method and apparatus for device authentication
US7987460B2 (en) * 2006-10-10 2011-07-26 Intel Corporation Automation tool for application installations
US8185872B2 (en) 2006-11-27 2012-05-22 Red Hat, Inc. Cross-platform software package generation
US7840942B2 (en) 2006-11-29 2010-11-23 International Business Machines Corporation Configuration file sharing
US20080140732A1 (en) 2006-12-11 2008-06-12 Bentley System, Inc. Method and system for sharing file based data
US20080148248A1 (en) * 2006-12-15 2008-06-19 Michael Volkmer Automatic software maintenance with change requests
US20080201705A1 (en) * 2007-02-15 2008-08-21 Sun Microsystems, Inc. Apparatus and method for generating a software dependency map
US7861231B2 (en) 2007-03-09 2010-12-28 International Business Machines Corporation System and method of identification of dangling pointers
US8245209B2 (en) 2007-05-29 2012-08-14 International Business Machines Corporation Detecting dangling pointers and memory leaks within software
US20090328023A1 (en) 2008-06-27 2009-12-31 Gregory Roger Bestland Implementing optimized installs around pre-install and post-install actions
US20130055202A1 (en) * 2011-08-25 2013-02-28 International Business Machines Corporation Identifying components of a bundled software product

Cited By (216)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US20090037897A1 (en) * 2001-03-30 2009-02-05 International Business Machines Corporation Installing and Upgrading an Application in a Computer System
US8250568B2 (en) * 2001-03-30 2012-08-21 International Business Machines Corporation Installing and upgrading an application in a computer system
US20100011042A1 (en) * 2001-10-29 2010-01-14 Eric Debes Method and Apparatus for Efficient Integer Transform
US9565297B2 (en) 2004-05-28 2017-02-07 Oracle International Corporation True convergence with end to end identity management
US9038082B2 (en) 2004-05-28 2015-05-19 Oracle International Corporation Resource abstraction via enabler and metadata
US20060123409A1 (en) * 2004-12-03 2006-06-08 International Business Machines Corporation Method and apparatus for creating a pluggable, prioritized configuration engine to be used for configuring a software during installation, update and new profile creation
US8156485B2 (en) * 2004-12-03 2012-04-10 Google Inc. Method and apparatus for creating a pluggable, prioritized configuration engine to be used for configuring a software during installation, update and new profile creation
US8321498B2 (en) 2005-03-01 2012-11-27 Oracle International Corporation Policy interface description framework
US8843919B1 (en) 2005-12-30 2014-09-23 United Services Automobile Association (Usaa) Method and system for restoring software
US8726271B1 (en) 2005-12-30 2014-05-13 United Services Automobile Association (Usaa) Method and system for installing software
US7840961B1 (en) 2005-12-30 2010-11-23 United Services Automobile Association (Usaa) Method and system for installing software on multiple computing systems
US7770167B1 (en) * 2005-12-30 2010-08-03 United Services Automobile Association (Usaa) Method and system for installing software
US8566820B1 (en) 2005-12-30 2013-10-22 United Services Automobile Association (Usaa) Method and system for installing software
US9245236B2 (en) 2006-02-16 2016-01-26 Oracle International Corporation Factorization of concerns to build a SDP (service delivery platform)
US8527979B2 (en) * 2007-02-15 2013-09-03 Oracle America, Inc. Apparatus and method fro maintaining a software repository
US20110246982A1 (en) * 2007-02-15 2011-10-06 Oracle America, Inc. Apparatus and method for maintaining a software repository
US8744055B2 (en) 2007-03-23 2014-06-03 Oracle International Corporation Abstract application dispatcher
US8321594B2 (en) 2007-03-23 2012-11-27 Oracle International Corporation Achieving low latencies on network events in a non-real time platform
US20080235327A1 (en) * 2007-03-23 2008-09-25 Oracle International Corporation Achieving low latencies on network events in a non-real time platform
US8675852B2 (en) 2007-03-23 2014-03-18 Oracle International Corporation Using location as a presence attribute
US20100070468A1 (en) * 2007-06-05 2010-03-18 Canon Kabushiki Kaisha Application management method and information processing apparatus
US8954380B2 (en) * 2007-06-05 2015-02-10 Canon Kabushiki Kaisha Application management method and information processing apparatus
US20090113044A1 (en) * 2007-10-31 2009-04-30 Lancaster Arthur L System and method of configuring a network
US20120036240A1 (en) * 2007-10-31 2012-02-09 Affinegy, Inc. System and method of configuring a network
US8069230B2 (en) * 2007-10-31 2011-11-29 Affinegy, Inc. System and method of configuring a network
US8769061B2 (en) * 2007-10-31 2014-07-01 Affinegy, Inc. System and method of configuring a network
US8539097B2 (en) 2007-11-14 2013-09-17 Oracle International Corporation Intelligent message processing
US8370506B2 (en) 2007-11-20 2013-02-05 Oracle International Corporation Session initiation protocol-based internet protocol television
US20090165015A1 (en) * 2007-12-21 2009-06-25 Schlumberger Technology Corporation Managing dependencies among applications using satisfiability engine
US20090183182A1 (en) * 2008-01-10 2009-07-16 Microsoft Corporation Dynamic Composition of Virtualized Applications
US20090187894A1 (en) * 2008-01-21 2009-07-23 International Business Machines Corporation Method, apparatus or software for identifying dependencies between components for a given build of a componentised product
US8464222B2 (en) * 2008-01-21 2013-06-11 International Business Machines Corporation Method, apparatus or software for identifying dependencies between components for a given build of a componentised product
US9654515B2 (en) 2008-01-23 2017-05-16 Oracle International Corporation Service oriented architecture-based SCIM platform
US8966498B2 (en) 2008-01-24 2015-02-24 Oracle International Corporation Integrating operational and business support systems with a service delivery platform
US8589338B2 (en) 2008-01-24 2013-11-19 Oracle International Corporation Service-oriented architecture (SOA) management of data repository
US20110066719A1 (en) * 2008-01-31 2011-03-17 Vitaly Miryanov Automated Applicatin Dependency Mapping
WO2009096970A1 (en) * 2008-01-31 2009-08-06 Hewlett-Packard Development Company, L.P. Automated application dependency mapping
US8401022B2 (en) 2008-02-08 2013-03-19 Oracle International Corporation Pragmatic approaches to IMS
US8683459B2 (en) * 2008-02-26 2014-03-25 Sap Ag Automated virtual appliance sizing
US20090217260A1 (en) * 2008-02-26 2009-08-27 Alexander Gebhart Automated virtual appliance sizing
US20090217235A1 (en) * 2008-02-27 2009-08-27 Sap Ag Apparatus and Method of Generating Self-Debugging Computer Software
US8166459B2 (en) * 2008-02-27 2012-04-24 Sap Ag Apparatus and method of generating self-debugging computer software
US8914493B2 (en) 2008-03-10 2014-12-16 Oracle International Corporation Presence-based event driven architecture
US20090241107A1 (en) * 2008-03-21 2009-09-24 Canon Kabushiki Kaisha License file issuance apparatus, image processing apparatus, license file issuance method, application installation method, and storage medium
US20090265701A1 (en) * 2008-04-18 2009-10-22 Sun Microsystems, Inc. Method and system for platform-agnostic software installation
US8438559B2 (en) * 2008-04-18 2013-05-07 Oracle America, Inc. Method and system for platform-agnostic software installation
US20090265586A1 (en) * 2008-04-18 2009-10-22 Sun Microsystems, Inc. Method and system for installing software deliverables
US8458703B2 (en) 2008-06-26 2013-06-04 Oracle International Corporation Application requesting management function based on metadata for managing enabler or dependency
US20090328051A1 (en) * 2008-06-26 2009-12-31 Oracle International Corporation Resource abstraction via enabler and metadata
US20090328023A1 (en) * 2008-06-27 2009-12-31 Gregory Roger Bestland Implementing optimized installs around pre-install and post-install actions
US9032390B2 (en) * 2008-07-29 2015-05-12 Qualcomm Incorporated Framework versioning
US20100162229A1 (en) * 2008-07-29 2010-06-24 Palm, Inc. Framework versioning
US9779111B2 (en) 2008-08-07 2017-10-03 Code Systems Corporation Method and system for configuration of virtualized software applications
US9864600B2 (en) 2008-08-07 2018-01-09 Code Systems Corporation Method and system for virtualization of software applications
US8505067B2 (en) 2008-08-21 2013-08-06 Oracle International Corporation Service level network quality of service policy enforcement
US20100058310A1 (en) * 2008-08-29 2010-03-04 Samsung Electronics Co., Ltd. Workform management apparatus and method, image forming apparatus, and workform management system
US8930930B2 (en) 2008-09-04 2015-01-06 International Business Machines Corporation Updating a computer system
US8918774B2 (en) * 2008-09-04 2014-12-23 International Business Machines Corporation Updating a computer system
US20100058313A1 (en) * 2008-09-04 2010-03-04 Uwe Hansmann Updating a computer system
US20120192172A1 (en) * 2008-09-04 2012-07-26 International Business Machines Corporation Updating a computer system
US20100083246A1 (en) * 2008-09-29 2010-04-01 Synopsys, Inc. System and method for verifying delivered software
US20100083228A1 (en) * 2008-09-30 2010-04-01 International Business Machines Corporation Mapping a Class, Method, Package, and/or Pattern to a Component
US8166077B2 (en) * 2008-09-30 2012-04-24 International Business Machines Corporation Mapping a class, method, package, and/or pattern to a component
US20100100870A1 (en) * 2008-10-21 2010-04-22 Oracle International Corporation Configuration deployment management
US8290984B2 (en) * 2008-10-21 2012-10-16 Oracle International Corporation Configuration deployment management
US20100107151A1 (en) * 2008-10-24 2010-04-29 Oracle International Corporation Method and system for implementing performance kits
US8739154B2 (en) * 2008-10-24 2014-05-27 Oracle International Corporation Method and system for implementing performance kits
US20100162233A1 (en) * 2008-12-19 2010-06-24 Electronics And Telecommunications Research Institute Method and system for distributing bundled applications
US20100211941A1 (en) * 2009-02-13 2010-08-19 Mobitv, Inc. System for automatic management of applications on remote devices
US8707288B2 (en) * 2009-02-13 2014-04-22 Mobitv, Inc. System for automatic management of applications on remote devices
US20130167136A1 (en) * 2009-03-18 2013-06-27 Adobe Systems Incorporated Component-based installation
US20100306593A1 (en) * 2009-05-29 2010-12-02 Anton Arapov Automatic bug reporting tool
US8694831B2 (en) * 2009-05-29 2014-04-08 Red Hat, Inc. Automatic bug reporting tool
US8879547B2 (en) 2009-06-02 2014-11-04 Oracle International Corporation Telephony application services
US20110010649A1 (en) * 2009-07-07 2011-01-13 Hidehiko Watanabe Information processing apparatus, information processing method, and program
US8930910B2 (en) * 2009-07-07 2015-01-06 Ricoh Company, Ltd. Information processing apparatus, information processing method, and program
US8296399B2 (en) * 2009-07-15 2012-10-23 Microsoft Corporation Connecting galleries to dynamic server-hosted content
US20110016194A1 (en) * 2009-07-15 2011-01-20 Microsoft Corporation Connecting galleries to dynamic server-hosted content
US8806477B2 (en) 2009-10-30 2014-08-12 Red Hat, Inc. Space efficient software package management
US20110107300A1 (en) * 2009-11-02 2011-05-05 Seth Kelby Vidal Systems and methods for utilizing a history of changes associated with software packages and configuration management to manage multiple computing systems
US9727352B2 (en) * 2009-11-02 2017-08-08 Red Hat, Inc. Utilizing history of changes associated with software packages to manage computing systems
US8739298B2 (en) * 2009-11-19 2014-05-27 Adobe Systems Incorporated Method and system for enforcing a license dependency rule for a software application
US8583830B2 (en) 2009-11-19 2013-11-12 Oracle International Corporation Inter-working with a walled garden floor-controlled system
US20140033315A1 (en) * 2009-11-19 2014-01-30 Adobe Systems Incorporated Method and system for enforcing a license dependency rule for a software application
US20110145278A1 (en) * 2009-11-20 2011-06-16 Oracle International Corporation Methods and systems for generating metadata describing dependencies for composable elements
US9269060B2 (en) * 2009-11-20 2016-02-23 Oracle International Corporation Methods and systems for generating metadata describing dependencies for composable elements
US8533773B2 (en) 2009-11-20 2013-09-10 Oracle International Corporation Methods and systems for implementing service level consolidated user information management
US9503407B2 (en) 2009-12-16 2016-11-22 Oracle International Corporation Message forwarding
US9509790B2 (en) 2009-12-16 2016-11-29 Oracle International Corporation Global presence
US20110161953A1 (en) * 2009-12-30 2011-06-30 Lutz Dominick Method for operating a hospital information system
US9773017B2 (en) 2010-01-11 2017-09-26 Code Systems Corporation Method of configuring a virtual application
US20110173594A1 (en) * 2010-01-14 2011-07-14 Microsoft Corporation Selective Loading of Code Elements for Code Analysis
US9710355B2 (en) * 2010-01-14 2017-07-18 Microsoft Technology Licensing, Llc Selective loading of code elements for code analysis
US9081646B2 (en) * 2010-01-22 2015-07-14 Red Hat, Inc. Building packages of functionally different programs from source code of a single program
US20110185352A1 (en) * 2010-01-22 2011-07-28 Glauber Costa Building packages of functionally different programs from source code of a single program
US20110185339A1 (en) * 2010-01-26 2011-07-28 International Business Machines Corporation Automating the creation of an application provisioning model
US8589864B2 (en) * 2010-01-26 2013-11-19 International Business Machines Corporation Automating the creation of an application provisioning model
US9749393B2 (en) 2010-01-27 2017-08-29 Code Systems Corporation System for downloading and executing a virtual application
US20110185304A1 (en) * 2010-01-28 2011-07-28 International Business Machines Corporation Graphical guides to aid user selection of groups of instruction packages
US8495497B2 (en) * 2010-01-28 2013-07-23 International Business Machines Corporation Graphical guides to aid user selection of groups of instruction packages
US9569286B2 (en) 2010-01-29 2017-02-14 Code Systems Corporation Method and system for improving startup performance and interoperability of a virtual application
US20110191762A1 (en) * 2010-02-02 2011-08-04 International Business Machines Corporation Mining dependencies from disk images
US9563434B2 (en) 2010-02-02 2017-02-07 International Business Machines Corporation Mining dependencies from disk images
US20110214118A1 (en) * 2010-02-26 2011-09-01 James Antill Systems and methods for generating and storing translation information as package metadata
US9152484B2 (en) 2010-02-26 2015-10-06 Red Hat, Inc. Generating predictive diagnostics via package update manager
US20110214018A1 (en) * 2010-02-26 2011-09-01 Seth Kelby Vidal Systems and methods for diagnostic notification via package update manager
US20110214112A1 (en) * 2010-02-26 2011-09-01 Seth Kelby Vidal Systems and mehtods for generating predictive diagnostics via package update manager
US20110214116A1 (en) * 2010-02-26 2011-09-01 Seth Kelby Vidal Systems and methods for managing software package updates using communication pipes
US8209564B2 (en) * 2010-02-26 2012-06-26 Red Hat, Inc. Systems and methods for initiating software repairs in conjunction with software package updates
US9092295B2 (en) 2010-02-26 2015-07-28 Red Hat, Inc. Managing software package updates using communication pipes
US20110214021A1 (en) * 2010-02-26 2011-09-01 Seth Kelby Vidal Systems and methods for initiating software repairs in conjunction with software package updates
US9116802B2 (en) 2010-02-26 2015-08-25 Red Hat, Inc. Diagnostic notification via package update manager
US9626237B2 (en) 2010-04-17 2017-04-18 Code Systems Corporation Method of hosting a first application in a second application
US9772834B2 (en) 2010-04-27 2017-09-26 Red Hat, Inc. Exportable encoded identifications of networked machines
US20110271286A1 (en) * 2010-04-30 2011-11-03 Sap Ag System and method for application function consolidation
US8539479B2 (en) * 2010-04-30 2013-09-17 Sap Ag System and method for application function consolidation
US20110296393A1 (en) * 2010-05-25 2011-12-01 Seth Kelby Vidal Systems and methods for generating an encoded package profile based on executing host processes
US9003389B2 (en) * 2010-05-25 2015-04-07 Red Hat, Inc. Generating an encoded package profile based on executing host processes
US8930942B2 (en) * 2010-05-26 2015-01-06 Tibco Software Inc. Capability model for deploying componentized applications
US8762931B2 (en) 2010-05-26 2014-06-24 Red Hat, Inc. Generating an encoded package profile
US20120117560A1 (en) * 2010-05-26 2012-05-10 Tibco Software Inc. Capability model for deploying componentized applications
US20120117539A1 (en) * 2010-05-26 2012-05-10 Tibco Software Inc. Capability model for deploying componentized applications
US8381036B2 (en) 2010-05-26 2013-02-19 Red Hat, Inc. Systems and methods for restoring machine state history related to detected faults in package update process
US9367302B2 (en) 2010-05-27 2016-06-14 Red Hat, Inc. Generating client qualification to execute package update manager
US8429256B2 (en) 2010-05-28 2013-04-23 Red Hat, Inc. Systems and methods for generating cached representations of host package inventories in remote package repositories
US9417865B2 (en) 2010-05-28 2016-08-16 Red Hat, Inc. Determining when to update a package manager software
US20140222904A1 (en) * 2010-07-02 2014-08-07 Code Systems Corporation Method and system for building and distributing application profiles via the internet
US9483296B2 (en) * 2010-07-02 2016-11-01 Code Systems Corporation Method and system for building and distributing application profiles via the internet
US9639387B2 (en) 2010-07-02 2017-05-02 Code Systems Corporation Method and system for prediction of software data consumption patterns
US8856953B2 (en) 2010-09-01 2014-10-07 Red Hat, Inc. Access policy for package update processes
US8713558B2 (en) 2010-09-01 2014-04-29 Red Hat, Inc. Generating package profiles in software package repositories using selective subsets of packages
US8776014B2 (en) 2010-09-23 2014-07-08 Microsoft Corporation Software build analysis
US9632769B2 (en) 2010-09-23 2017-04-25 Microsoft Technology Licensing, Llc Software build optimization
US8806471B2 (en) 2010-09-28 2014-08-12 Red Hat, Inc. Upgrade and downgrade in package update operations
US9792429B2 (en) 2010-10-06 2017-10-17 Red Hat, Inc. Detection of malicious software packages
US20120102569A1 (en) * 2010-10-21 2012-04-26 F-Secure Corporation Computer system analysis method and apparatus
US9747425B2 (en) 2010-10-29 2017-08-29 Code Systems Corporation Method and system for restricting execution of virtual application to a managed process environment
US20120124570A1 (en) * 2010-11-16 2012-05-17 Motorola Mobility, Inc. Method and system for facilitating the providing of software updates to mobile devices
US9003400B2 (en) 2010-11-29 2015-04-07 Red Hat, Inc. Tracking computing systems utilizing software repositories
US20120151418A1 (en) * 2010-12-14 2012-06-14 International Business Machines Corporation Linking of a plurality of items of a user interface to display new information inferred from the plurality of items that are linked
US9256666B2 (en) * 2010-12-14 2016-02-09 International Business Machines Corporation Linking of a plurality of items of a user interface to display new information inferred from the plurality of items that are linked
US20120159468A1 (en) * 2010-12-20 2012-06-21 Microsoft Corporation Software deployment to multiple computing devices
US20120191845A1 (en) * 2010-12-23 2012-07-26 Computer Associates Think, Inc. Methods and Systems for Executing Applications on Personal Digital Assistant Terminals
US20120204149A1 (en) * 2011-02-03 2012-08-09 International Business Machines Corporation Discovery-based migration correctness testing
US20120215831A1 (en) * 2011-02-22 2012-08-23 Julian Michael Urbach Software Application Delivery and Launching System
US9170917B2 (en) * 2011-04-01 2015-10-27 Paypal, Inc. Flow tracing though diverse logical and physical application and infrastructure layers/dependencies
US20120254900A1 (en) * 2011-04-01 2012-10-04 Ebay Inc. Flow tracing though diverse logical and physical application and infrastructure layers/dependencies
US20120311562A1 (en) * 2011-06-01 2012-12-06 Yanlin Wang Extendable event processing
WO2013011401A1 (en) * 2011-07-21 2013-01-24 Lam Research Corporation Data architecture and user interface for plasma processing related software applications
US20150193331A1 (en) * 2011-09-02 2015-07-09 Vu Lam Systems and methods for processing software application metadata associated with a software application
US9118686B2 (en) 2011-09-06 2015-08-25 Microsoft Technology Licensing, Llc Per process networking capabilities
US9679130B2 (en) 2011-09-09 2017-06-13 Microsoft Technology Licensing, Llc Pervasive package identifiers
US9773102B2 (en) 2011-09-09 2017-09-26 Microsoft Technology Licensing, Llc Selective file access for applications
US8990561B2 (en) 2011-09-09 2015-03-24 Microsoft Technology Licensing, Llc Pervasive package identifiers
US9800688B2 (en) 2011-09-12 2017-10-24 Microsoft Technology Licensing, Llc Platform-enabled proximity service
US9535751B2 (en) * 2011-09-15 2017-01-03 International Business Machines Corporation Resource selection advisor mechanism
US20130073713A1 (en) * 2011-09-15 2013-03-21 International Business Machines Corporation Resource Selection Advisor Mechanism
US8949429B1 (en) * 2011-12-23 2015-02-03 Amazon Technologies, Inc. Client-managed hierarchical resource allocation
US9064292B1 (en) 2011-12-30 2015-06-23 hopTo, Inc. System for and method of classifying and translating graphics commands in client-server computing systems
US8922569B1 (en) 2011-12-30 2014-12-30 hopTo Inc. Cloud based system for and method of translating between disparate 3D graphics languages in client-server computing environments
US9183663B1 (en) 2011-12-30 2015-11-10 Graphon Corporation System for and method of classifying and translating graphics commands in client-server computing systems
US9037636B2 (en) 2012-01-19 2015-05-19 Microsoft Technology Licensing, Llc Managing script file dependencies and load times
WO2013109555A1 (en) * 2012-01-19 2013-07-25 Microsoft Corporation Managing script file dependencies and load times
CN104081377A (en) * 2012-01-19 2014-10-01 微软公司 Managing script file dependencies and load times
JP2015508190A (en) * 2012-01-19 2015-03-16 マイクロソフト コーポレーション Management of the script file-dependent and load time
US20140372799A1 (en) * 2012-01-29 2014-12-18 Huawei Device Co., Ltd. System Differential Upgrade Method, Apparatus, and Mobile Terminal
US9804933B2 (en) * 2012-01-29 2017-10-31 Huawei Device Co., Ltd. System differential upgrade method, apparatus, and mobile terminal
EP2821918A4 (en) * 2012-03-01 2015-12-16 Nec Corp Device for creating system construction procedure, method for creating system construction procedure, and program
US20150033204A1 (en) * 2012-03-01 2015-01-29 Nec Corporation System-construction-procedure generating device, system-construction-procedure generating method, and program thereof
US20130262401A1 (en) * 2012-03-30 2013-10-03 Branch Banking and Trust Compnay System and Method for License Reclamation
US9916342B2 (en) * 2012-03-30 2018-03-13 Branch Banking And Trust Company System and method for license reclamation
US8826223B2 (en) 2012-04-18 2014-09-02 International Business Machines Corporation Techniques for objective assessment and improvement of software quality
US9342295B2 (en) 2012-04-23 2016-05-17 Hewlett Packard Enterprise Development Lp Dynamic software updates
US9256419B2 (en) * 2012-04-23 2016-02-09 Hewlett Packard Enterprise Development Lp Dynamic software updates
US20130283252A1 (en) * 2012-04-23 2013-10-24 Sandya Srivilliputtur Mannarswamy Dynamic Software Updates
US20150007197A1 (en) * 2012-04-27 2015-01-01 Travis S. Tripp Mapping application dependencies at runtime
US9355228B2 (en) * 2012-07-13 2016-05-31 Angel Secure Networks, Inc. System and method for policy driven protection of remote computing environments
US20140020049A1 (en) * 2012-07-13 2014-01-16 Angel Secure Networks, Inc. System and method for policy driven protection of remote computing environments
US20140096129A1 (en) * 2012-09-28 2014-04-03 Wal-Mart Stores, Inc. Systems and methods for installing, managing, and provisioning applications
US9128792B2 (en) * 2012-09-28 2015-09-08 Wal-Mart Stores, Inc. Systems and methods for installing, managing, and provisioning applications
US20150373107A1 (en) * 2012-10-02 2015-12-24 Nextbit Systems, Inc. Managing applications on an electronic device
US9717985B2 (en) 2012-10-02 2017-08-01 Razer (Asia-Pacific) Pte. Ltd. Fragment-based mobile device application streaming utilizing crowd-sourcing
US9747000B2 (en) 2012-10-02 2017-08-29 Razer (Asia-Pacific) Pte. Ltd. Launching applications on an electronic device
US9654556B2 (en) * 2012-10-02 2017-05-16 Razer (Asia-Pacific) Pte. Ltd. Managing applications on an electronic device
US20140115151A1 (en) * 2012-10-14 2014-04-24 Empire Technology Development Llc Error-capturing service replacement in datacenter environment for simplified application restructuring
US9858247B2 (en) 2013-05-20 2018-01-02 Microsoft Technology Licensing, Llc Runtime resolution of content references
US9104519B1 (en) * 2013-06-17 2015-08-11 Symantec Corporation Provisioning partner aware apps on sandboxed operating systems
US9942298B2 (en) * 2013-09-10 2018-04-10 International Business Machines Corporation Dynamic help pages using linked data
US20150074229A1 (en) * 2013-09-10 2015-03-12 International Business Machines Corporation Dynamic help pages using linked data
US20150074231A1 (en) * 2013-09-10 2015-03-12 International Business Machines Corporation Dynamic help pages using linked data
US20150082298A1 (en) * 2013-09-19 2015-03-19 Qiu Shi WANG Packaging and deploying hybrid applications
WO2015057188A1 (en) * 2013-10-14 2015-04-23 Hewlett-Packard Development Company, L.P. Package dependency maps for distributed computing
US9548891B2 (en) * 2013-10-30 2017-01-17 1E Limited Configuration of network devices
US20150121485A1 (en) * 2013-10-30 2015-04-30 1E Limited Configuration of network devices
US20150134686A1 (en) * 2013-11-12 2015-05-14 Nikolai Neichev Mechanism for delivery of help content to a cloud landscape
US9471336B2 (en) * 2013-11-12 2016-10-18 Sap Se Mechanism for delivery of help content to a cloud landscape
GB2524798A (en) * 2014-04-03 2015-10-07 Ibm Method and test environment for automatic testing a software product comprising a plurality of software packages
US9170927B1 (en) * 2014-04-03 2015-10-27 International Business Machines Corporation Automatic testing a software product comprising a plurality of software packages
US9274784B2 (en) * 2014-06-02 2016-03-01 Sap Se Automatic deployment and update of hybrid applications
US9882969B2 (en) 2014-07-11 2018-01-30 Vmware, Inc. Methods and apparatus to configure virtual resource managers for use in virtual server rack deployments for virtual computing environments
US9705974B2 (en) 2014-07-11 2017-07-11 Vmware, Inc. Methods and apparatus to transfer physical hardware resources between virtual rack domains in a virtualized server rack
US9942300B2 (en) * 2014-09-05 2018-04-10 International Business Machines Corporation Dynamic help pages using linked data
US9916149B2 (en) * 2014-12-26 2018-03-13 Canon Kabushiki Kaisha Information processing apparatus, control method for information processing apparatus, and storage medium of program for executing control method
US20160188310A1 (en) * 2014-12-26 2016-06-30 Canon Kabushiki Kaisha Information processing apparatus, control method for information processing apparatus, and storage medium of program for executing control method
US9805040B2 (en) * 2014-12-31 2017-10-31 Quest Software Inc. Email and identity migration based on relationship information
US20160188614A1 (en) * 2014-12-31 2016-06-30 Dell Products L.P. Email and Identity Migration Based on Relationship Information
US20160266889A1 (en) * 2015-03-13 2016-09-15 Kony, Inc. Providing updates for natively rendered mobile applications
US9652218B2 (en) * 2015-06-17 2017-05-16 International Business Machines Corporation Feature exploitation evaluator
US9665363B2 (en) * 2015-06-17 2017-05-30 International Business Machines Corporation Feature exploitation evaluator
WO2017004269A1 (en) * 2015-06-30 2017-01-05 Vmware, Inc. Methods and apparatus for software lifecycle management of a virtual computing environment
US9870213B2 (en) * 2015-08-06 2018-01-16 Sap Se Unified consumption experience for software installation
US9792109B2 (en) 2015-09-30 2017-10-17 Apple Inc. Software updating
US9678721B2 (en) * 2015-09-30 2017-06-13 Semmle Limited Implicit software dependency analysis
US9678720B2 (en) * 2015-09-30 2017-06-13 Semmle Limited Implicit software dependency analysis
US20170090901A1 (en) * 2015-09-30 2017-03-30 Apple Inc. Software Updating
US9705978B1 (en) * 2016-07-01 2017-07-11 Red Hat Israel, Ltd. Dependency graph management

Also Published As

Publication number Publication date Type
US20120144386A1 (en) 2012-06-07 application
US8645946B2 (en) 2014-02-04 grant
US8776047B2 (en) 2014-07-08 grant
US20110246982A1 (en) 2011-10-06 application
US20110239212A1 (en) 2011-09-29 application
US20110225577A1 (en) 2011-09-15 application
US8640123B2 (en) 2014-01-28 grant
US20110231838A1 (en) 2011-09-22 application
US8589914B2 (en) 2013-11-19 grant
US20110209142A1 (en) 2011-08-25 application
US8566819B2 (en) 2013-10-22 grant
US20110231836A1 (en) 2011-09-22 application
US8719814B2 (en) 2014-05-06 grant
US8621454B2 (en) 2013-12-31 grant
US20110258619A1 (en) 2011-10-20 application
US20110225461A1 (en) 2011-09-15 application
US8645947B2 (en) 2014-02-04 grant
US8533704B2 (en) 2013-09-10 grant
US8527979B2 (en) 2013-09-03 grant
US20110214119A1 (en) 2011-09-01 application
US8589915B2 (en) 2013-11-19 grant
US20110191766A1 (en) 2011-08-04 application
US8631400B2 (en) 2014-01-14 grant
US20120151469A1 (en) 2012-06-14 application
US8621453B2 (en) 2013-12-31 grant
US20120151468A1 (en) 2012-06-14 application

Similar Documents

Publication Publication Date Title
US7664834B2 (en) Distributed operating system management
US6301710B1 (en) System and method for creating a substitute registry when automatically installing an update program
US7197570B2 (en) System and method to send predicted application streamlets to a client device
US7340520B1 (en) System and method to facilitate manageable and agile deployment of services in accordance with various topologies
US7117486B2 (en) System and method for migration of software
US20070106978A1 (en) Patch management system
US20090222805A1 (en) Methods and systems for dynamically building a software appliance
US20050066015A1 (en) Method and system for automated validation, scripting, dissemination and installation of software
US20090300604A1 (en) System and method for building virtual appliances using a repository metadata server and a dependency resolution service
US20130007216A1 (en) Virtual machine migration tool
US20020124245A1 (en) Method and apparatus for advanced software deployment
US20020174422A1 (en) Software distribution system
US20050289538A1 (en) Deploying an application software on a virtual deployment target
US8347263B1 (en) Repository including installation metadata for executable applications
US7089552B2 (en) System and method for verifying installed software
US20130174117A1 (en) Single development test environment
US20090144718A1 (en) Systems and methods for updating software appliances
US20070260629A1 (en) Portable management
US8296756B1 (en) Patch cycle master records management and server maintenance system
US20120324417A1 (en) Systems and methods for incremental software development
US20080127093A1 (en) Server testing framework
US20050172284A1 (en) Method and system for automated generation of customized factory installable software
US20100058313A1 (en) Updating a computer system
US20060294506A1 (en) Isolating declarative code to preserve customizations
US7761851B2 (en) Computer method and system for integrating software development and deployment

Legal Events

Date Code Title Description
AS Assignment

Owner name: SUN MICROSYSTEMS, INC., CALIFORNIA

Free format text: ASSIGNMENT OF ASSIGNORS INTEREST;ASSIGNOR:WOOKEY, MICHAEL J.;REEL/FRAME:019975/0936

Effective date: 20070925