Software vault

• US 7,010,693 B1
• Filed: 11/14/2000
• Issued: 03/07/2006
• Est. Priority Date: 12/02/1998
• Status: Expired due to Term

• Current Assignee: Avolin LLC
• Original Assignee: SupportSoft, Inc. (Greenidge Generation Holdings, Inc.)
• Inventors: Dale, Scott William, Lee, Cadir Batista
• Primary Examiner(s): REVAK, CHRISTOPHER A
• Application Number:
  US09/712,855
• Time in Patent Office: 1,939 Days
• Field of Search: 717/170, 707/2, 707/1, 707/9, 707200-204, 713/168, 713/176, 713181-185, 380/277, 380/44, 714/5, 714/6, 714/16, 714/17, 714/19
• US Class Current: 713/176
• CPC Class Codes: G06F 21/00 Security arrangements for protecting computers, components thereof, programs or data against unauthorised activity
• CPC Class Codes: Y10S 707/99953 Recoverability
• CPC Class Codes: Y10S 707/99955 Archiving or backup

Abstract

A computer-implemented vault centrally archives an application from a client. Each application may be formed from one or more files, and each application has a unique meta description for reconstructing the application using the one or more files. The vault has one or more files which may be shared among applications; an access controller for allowing the client to retrieve a file from the vault based on the meta description; and a post controller for allowing the client to store a single instance of a uniquely indexed file based on the meta description.

Claims

1. A computer-implemented vault for archiving software components, the vault comprising:

one or more software components stored in the vault;

an access controller for performing a direct, random access retrieval of the one or more software components from the vault; and

a post controller for performing a direct, random access insertion of a software component to the vault wherein the post controller generates a unique key from the new component and optimizes storage if the unique key exists.

2. A computer-implemented vault for archiving software components, the vault comprising:

one or more software components stored in the vault;

an access controller for performing a direct, random access retrieval of the one or more software components from the vault; and

a client coupled to the vault, the client having a physical software component residing on the client, the client generating a key from the physical software component.

3. A computer-implemented vault for archiving software components, the vault comprising:

one or more software components stored in the vault;

an access controller for performing a direct, random access retrieval of the one or more software components from the vault;

one or more secondary vaults coupled to the vault;

a fault-tolerant rollover system for sequentially searching each vault for the presence of a target software component; and

a client for generating a key, the client applying the key to recover the target software component from the most accessible of the vaults.

4. The computer-implemented vault of claim 3, wherein the secondary vaults are ordered based on accessibility of the vaults.

5. The computer-implemented vault of claim 3, wherein the client uses a metadata description to generate the key.

6. The computer-implemented vault of claim 3 wherein the search of a determined vault fails to locate the target software component, and wherein the client skips the determined vault and modifies the search order of the vaults in recovering the target software component.

7. A computer-implemented vault for archiving software components, the vault comprising:

means for storing one or more software components on the vault;

access means for performing a direct, random access retrieval of the one or more software components from the vault; and

a post means for performing a direct, random access insertion of a software component to the vault wherein the post means generates a unique key from the new component and optimizes storage if the unique key exists.

8. A computer-implemented vault for archiving software components, the vault comprising:

means for storing one or more software components on the vault;

access means for performing a direct, random access retrieval of the one or more software components from the vault; and

a client coupled to the vault, the client having a physical software component residing on the client, the client generating a key from the physical software component.

9. The computer-implemented vault of claim 8, wherein the secondary vaults are ordered based on accessibility of the vaults.

10. A computer-implemented vault for archiving software components, the vault comprising:

means for storing one or more software components on the vault;

access means for performing a direct, random access retrieval of the one or more software components from the vault;

one or more secondary vaults coupled to the vault;

means for sequentially searching each vault for the presence of a target software component; and

a client for generating a key, the client having a means for applying the key to recover the target software component from the most accessible of the vaults.

11. The computer-implemented vault of claim 10, wherein the client uses a metadata description to generate the key.

12. The computer-implemented vault of claim 10, wherein the search of a determined vault fails to locate the target software component, and wherein the client skips the determined vault and modifies the search order of the vaults in recovering the target software component.

13. A computer-implemented method for archiving software components, the method comprising:

storing one or more software components in a vault; and

performing a direct, random access retrieval of the one or more software components from the vault; and

performing a direct, random access insertion of a software component to the vault wherein said step of performing an insertion generates a unique key from the new component and optimizes storage if the key exists.

14. A method for archiving software components, the method comprising:

storing unique instances of the one or more software components in a vault;

performing a direct, random access retrieval of the one or more software components from the vault; and

generating a key from a physical software component residing on a client coupled to the vault.

15. A method for archiving software components, the method comprising:

storing unique instances of the one or more software components in a vault that is coupled to one or more secondary vaults;

performing a direct, random access retrieval of the one or more software components from the vault;

sequentially searching each vault for the presence of a target software component; and

generating a key that can be applied to recover the target software from the most accessible of the vaults.

16. The method of claim 15, wherein the secondary vaults are ordered based on accessibility of the vaults.

17. The method of claim 15, wherein metadata description is used to generate the key.

18. The method of claim 15, wherein a search of a determined vault fails to locate the target software component, and wherein the client skips the determined vault and modifies the search order of the vaults in recovering the target software component.

19. A computer-implemented method for managing one or more software components of a software application, the method comprising:

analyzing run-time states of an application that includes one or more components and generating, for each component of the application and based on a result of analyzing run-time states, current metadata that describes the component, the analyzing and generating being performed by a client computer, and the components being stored on one or more software vaults associated with and remote from the client computer;

creating a first key for each of the one or more components of the application, each first key of a component being created from and unique to the current metadata that describes the component;

creating a second key for each of the one or more components of the application, each second key being created from and unique to metadata that was previously generated in conjunction with a previous determination of run-time states of the application; and

for each first key, comparing the first key to the second keys and, if the first key does not match any of the second keys, storing the first key'"'"'s corresponding component on one of the software vaults by performing a direct random-access storage operation.

20. The method of claim 19, wherein performing a storage operation comprises:

storing the first key along with the first key'"'"'s corresponding component in the first-accessed software vault.

21. The method of claim 19, wherein:

generating metadata for a component includes generating information about the size, name, and attributes of the component, and

creating a key includes verifying the integrity of the respective software component and generating an integrity checksum, and incorporating into the unique key the integrity checksum as well as information about the size, name and attributes of the respective software component.

22. A computer-implemented method for retrieving one or more software components of a software application, the method comprising:

analyzing run-time states of an application that includes one or more components and generating, for each component of the application and based on a result of analyzing run-time states, metadata that describes the component, the analyzing and generating being performed by a client computer, and the components being stored on one or more software vaults associated with and remote from the client computer;

creating a key for one of the one or more components of the application, the component being one that is to be accessed from the one or more software vaults, the key being created from and unique to the metadata that describes the component and including location attributes;

using the key to look up the software component sequentially on the one or more software vaults; and

accessing and retrieving the software component from a first software vault on which the component is found.

23. A computer-implemented method for locating one or more software components of a software application, the method comprising:

analyzing run-time states of an application that includes one or more components and generating, for each component of the application and based on a result of analyzing run-time states, metadata that describes the component, the analyzing and generating being performed by a client computer, and the components being stored on one or more software vaults associated with and remote from the client computer;

creating a key for one of the one or more components of the application, the component being one that is to be located in the one or more software vaults, the key being created from and unique to the metadata that describes the component and including location attributes;

determining an order of accessibility for the software vaults;

for each software vault, using the location of the software vault and the key, forming a uniform resource locator (URL); and

looking-up the URL in the software vaults, based on the order of accessibility, until the is located.

24. A computer-implemented method for retrieving software components of a software application, the method including comprising:

analyzing run-time states of an application that includes one or more components and generating, for each component of the application and based on a result of analyzing run-time states, metadata that describes the component the analyzing and generating being performed by a client computer, and the components being stored on one or more software vaults associated with and remote from the client computer;

transforming, for each of the one or more components, the metadata that describes the component into a key that that includes location attributes of the component; and

using the location attributes of each key, and retrieving the software components from one or more software vaults accessible to the client computer through the communications network.

25. The method of claim 24, further comprising:

determining an order of accessibility of the software vaults and retrieving the software components from the most accessible software vaults.

26. A computer-implemented method for recreating a software application, the method comprising:

analyzing run-time states of an application that includes one or more components and generating, for each component of the application and based on a result of analyzing run-time states, metadata that describes the component, the analyzing and generating being performed by a client computer, and the components being stored on one or more software vaults associated with and remote from the client computer;

transforming, for each of the one or more components, the metadata that describes the component into a first key that that includes location attributes of the component;

determining if the software components consume a large amount of file space and, upon a determination that the software components do consume a large amount of file space;

looking up, on the client computer, a second key for each of the one or more components;

for each of the one or more components, comparing the first key to the second key and, if the first and second keys do not match, retrieving the component from one or more remotely accessible software vaults, and, if the first and second keys do match, retrieving the component from the client computer; and

using the retrieved software components to recreate the software application.

27. The method of claim 26, comprising:

initializing a difference flag;

determining whether first binary data associated with the software components stored on the client computer and second binary data associated with the software components stored on the remotely accessible software vaults differ;

if the first and second binary data differ, comparing the first and second keys based on sequence attributes including date created, date modified, date last accessed or version number;

if the sequence attributes are equal, if one of the sequence attributes is newer than another, or if one of the sequence attributes is older than the other and the software components with the older attribute may be overwritten, setting the difference flag; and

determining that there is not a match between the first key and the second key if the difference flag is set.

28. A computer program product tangibly stored on machine-readable medium, the product comprising instructions to:

determine current run-times state of an application and generating, for each component of the application and based on a result of analyzing run-time states, metadata that describes the component; and

generate a key for each component of the application, the key including a hash of the metadata, wherein a same key is generated for the same metadata; and

compare a first key for a first of the application'"'"'s components that is stored on a client computer with a second key for a second of the application'"'"'s components that is stored on a storage device that is remote from the client computer, the keys being generated from metadata generated by determining run-time states of the application, and determine that the first and second of the application'"'"'s components are the same if the keys match.

29. A computer program product tangibly stored on machine-readable medium, the product comprising instructions to:

analyze run-time states of an application that includes one or more components and generate, for each component of the application and based on a result of analyzing run-time states, current metadata that describes the component, the analyzing and generating being performed by a client computer, and the components being stored on one or more software vaults associated with and remote from the client computer;

create a first key for each of the one or more components of the application, each first key of a component being created from and unique to the current metadata that describes the component; and

for each first key, compare the first key to the second keys and, if the first key does not match any of the second keys, store the first key'"'"'s corresponding component on one of the software vaults by performing a direct random-access storage operation.