Methods, systems, and computer program products for identifying and enforcing software feature limits across different hardware platforms, software releases, and tiers

• US 8,132,266 B2
• Filed: 03/28/2006
• Issued: 03/06/2012
• Est. Priority Date: 03/28/2006
• Status: Active Grant

• Current Assignee: Emc IP Holding Company LLC (Dell Technologies Inc.)
• Original Assignee: EMC Corporation (Dell Technologies Inc.)
• Inventors: Vook, Eric R., Kan, Victor, Goudreau, Robert F., Myers, J. Brandon
• Primary Examiner(s): Srivastava, Vivek
• Assistant Examiner(s): Woldemariam, Nega
• Application Number:
  US11/391,704
• Publication Number:
  US 20070240233A1
• Time in Patent Office: 2,170 Days
• Field of Search: 380/200, 380/30, 713/192, 713/168, 713/182, 726/31, 726/24, 726/30, 709/12, 709/14, 705/59, 717/117, 717/168, 717/174, 717/122
• US Class Current: 726/31
• CPC Class Codes: G06F 21/629 to features or functions of an application
• CPC Class Codes: G06F 9/445 Program loading or initiating bootstrapping G06F9/4401; security arrangements for program loading or initiating G06F21/57

Abstract

Methods, systems, and computer program products for identifying and enforcing software feature limits across different hardware platforms, software releases, and tiers are disclosed. According to one method, a feature limit data structure is stored on the hardware platform. Each entry in the feature limit data structure is indexed by at least a software program identifier, a software release level identifier, and a feature name. When software is initialized, its release level is determined. A feature limit manager separate from the software being initialized is invoked. At least the software program identifier, the release level, and the feature identifier are provided as input to the feature limit manager. The feature limit manager provides a feature limit value. The feature limit value is stored and the software uses the feature limit value to enforce the feature limit during execution.

Claims

1. A method for identifying and enforcing a software feature limit, the method comprising:

(a) storing a data structure on a hardware platform, the data structure including a plurality of feature limits for a plurality of software features, each feature limit being indexed by at least a software program identifier, a software release level identifier, and a feature identifier;

(b) initializing software on the hardware platform;

(c) determining a release level of the software, wherein the release level identifies a software version having a set of operational capabilities;

(d) determining a commit level, wherein the commit level identifies a software release level for determining feature limits to be enforced on the set of operational capabilities, wherein the commit level is determined by the software version that is committed to the hardware platform;

(e) invoking a feature limit manager independent from the software and providing at least a software program identifier, a commit level identifier, and a feature identifier as input to the feature limit manager, wherein the feature limit manager uses the input to query the data structure for a feature limit;

(f) receiving the feature limit from the feature limit manager corresponding to the commit level and based on the input; and

(g) enforcing the feature limit during execution of the software corresponding to the commit level, wherein enforcing the feature limit includes monitoring a value of a variable associated with the feature limit during execution of the software, determining whether the feature limit has been met, and in response to determining that feature limit has been met, preventing the feature limit from being exceeded.

2. The method of claim 1 wherein the hardware platform comprises a disk array.

3. The method of claim 1 comprising repeating steps (d)-(f) for each feature of a plurality of features provided by the software.

4. The method of claim 1 wherein the release level is equal to x, x being an integer, wherein the commit level is any integer y less than x, wherein executing the software using feature limits corresponding to the commit level includes executing the software using feature limits corresponding to release level y, and in response to committing the software being initialized, switching to feature limits corresponding to release level x.

5. The method of claim 1 comprising repeating steps (d)-(f) for each feature of a plurality of features provided by the software.

6. A system for identifying and enforcing software feature limits, the system comprising:

(a) a computer storing a feature limit data structure for storing limits for a plurality of different software features corresponding to a commit level, each entry in the data structure being indexed by at least a software program identifier, a software release level, and a feature identifier, wherein the software release level identifies a software version having a set of operational capabilities;

(b) a feature limit manager for receiving as input at least a program identifier, a commit level identifier, and a feature identifier, for using the input to query the data structure for a feature limit, and for accessing the feature limit data structure to obtain feature limits corresponding to the commit level to be enforced by software being initialized on a hardware platform, wherein the commit level identifies a software release level for determining feature limits to be enforced on the set of operational capabilities, wherein the commit level is determined by the software version that is committed to the hardware platform; and

(c) a software program independent from the feature limit manager for invoking the feature limit manager, for providing the feature limit manager with the at least a program identifier, a commit level identifier, and a feature identifier as input, for receiving a corresponding feature limit from the feature limit manager, and for enforcing the feature limit corresponding to the commit level, wherein enforcing the feature limit includes monitoring a value of a variable associated with the feature limit during execution of the software, determining whether the feature limit has been met, and in response to determining that feature limit has been met, preventing the feature limit from being exceeded.

7. The system of claim 6 wherein the software program comprises a copy application for copying data from one location to another location in a disk array.

8. A computer program product comprising computer executable instructions embodied in a non-transitory computer readable medium for performing steps comprising:

(a) storing a data structure on a hardware platform, the data structure including a plurality of feature limits for a plurality of software features, each feature limit being indexed by at least a software program identifier, a software release level identifier and a feature identifier;

(b) initializing software on the hardware platform;

(c) determining a release level of the software, wherein the release level identifies a software version having a set of operational capabilities;

(d) determining a commit level, wherein the commit level identifies a software release level for determining feature limits to be enforced on the set of operational capabilities, wherein the commit level is determined by the software version that is committed to the hardware platform;

(e) invoking a feature limit manager independent from the software and providing at least a software program identifier, a commit level identifier, and a feature identifier as input to the feature limit manager, wherein the feature limit manager uses the input to query the data structure for a feature limit;

(f) receiving the feature limit from the feature limit manager corresponding to the commit level and based on the input; and

(g) enforcing the feature limit during execution of the software corresponding to the commit level, wherein enforcing the feature limit includes monitoring a value of a variable associated with the feature limit during execution of the software, determining whether the feature limit has been met, and in response to determining that feature limit has been met, preventing the feature limit from being exceeded.

9. A method for identifying a feature limit associated with software being initialized on a hardware platform, the method comprising:

(a) storing, on a hardware platform, a feature limit data structure having a plurality of entries specifying feature limits for software features, each entry being indexed by at least a software program identifier, a software release level, and a feature identifier, wherein the software release level identifies a software version having a set of operational capabilities;

(b) determining a commit level for software being initialized on a hardware platform, wherein the commit level identifies a software release level for determining feature limits to be enforced on the set of operational capabilities, wherein the commit level is determined by the software version that is committed to the hardware platform;

(c) receiving, from software being initialized on the hardware platform, a call requesting a value for a feature limit, the call including at least a software program identifier, the commit level, and a feature identifier as input;

(d) accessing the feature limit data structure, locating an entry corresponding to the software program identifier, the commit level, and the feature identifier; and

(e) providing the feature limit to the software being initialized, wherein the software being initialized enforces the feature limit, where enforcing the feature limit includes monitoring a value of a variable associated with the feature limit during execution of the software, determining whether the feature limit has been met, and in response to determining that feature limit has been met, preventing the feature limit from being exceeded.

10. The method of claim 9 wherein storing a data structure on a hardware platform includes storing a data structure having entries indexed by a plurality of different hardware platform identifiers, software program identifiers, software release level identifiers, and feature identifiers.

11. The method of claim 9 wherein storing a feature limit data structure on a hardware platform includes storing a data structure that is specific to the hardware platform having entries indexed by software program identifiers, software release level identifiers, and feature identifiers.

12. The method of claim 9 wherein storing a feature limit data structure on a hardware platform includes storing the data structure on a disk array.

13. The method of claim 9 wherein at least some of the entries in the feature limit data structure are indexed by software tier identifiers and wherein accessing a the feature limit data structure includes accessing the feature limit data structure using the software tier identifiers, wherein each software tier identifier is usable to distinguish between versions of software of the same release level with different capabilities.

14. The method of claim 9 wherein steps (b) and (c) are performed in response to initialization of the software.

15. A method for identifying and enforcing software feature limits based on a commit level, the method comprising:

(a) storing a feature limit data structure on a hardware platform, the feature limit data structure including a plurality of feature limits for a plurality of software features, each feature limit being indexed by at least a software program identifier, a software release level identifier, and a feature identifier;

(b) initializing software on the hardware platform;

(c) determining a release level of the software, wherein the release level identifies a software version having a set of operational capabilities;

(d) determining a commit level, wherein the commit level identifies a software release level for determining feature limits to be enforced on the set of operational capabilities, wherein the commit level is determined by the software version that is committed to the hardware platform;

(e) obtaining, from the feature limit data structure, feature limits corresponding to the commit level and based on at least a software program identifier, the commit level, and a feature identifier; and

(f) executing the software using the feature limits corresponding to the commit level, wherein enforcing the feature limit includes monitoring a value of a variable associated with the feature limit during execution of the software, determining whether the feature limit has been met, and in response to determining that feature limit has been met, preventing the feature limit from being exceeded.

16. The method of claim 15 wherein the commit level is different from the release level.

17. The method of claim 15 wherein the commit level is the same as the release level.

18. The method of claim 15 wherein the release level is equal to x, x being an integer, wherein the commit level is any integer y less than x, wherein executing the software using feature limits corresponding to the commit level includes executing the software using feature limits corresponding to release level y, and in response to committing the software being initialized, switching to feature limits corresponding to release level x.

19. A system for identifying and enforcing software feature limits, the system comprising:

(a) a computer storing a feature limit data structure for storing limits for a plurality of different software features, each entry in the data structure being indexed by at least a software program identifier, a software release level, and a feature identifier;

(b) a feature limit manager for accessing the feature limit data structure to obtain feature limits to be enforced by software being initialized on a hardware platform; and

(c) a software program independent from the feature limit manager for invoking the feature limit manager, for providing the feature limit manager with at least a program identifier, a software release level identifier, and a feature identifier as input, for receiving a corresponding feature limit from the feature limit manager based on the input, and for enforcing the feature limit, wherein enforcing the feature limit includes monitoring a value of a variable associated with the feature limit during execution of the software, determining whether the feature limit has been met, and in response to determining that feature limit has been met, preventing the feature limit from being exceeded, wherein the software release level identifier identifies a software version having a set of operational capabilities, wherein the software release level identifier comprises a commit level, wherein the commit level identifies a software release level for determining feature limits to be enforced on the set of operational capabilities, wherein the commit level is determined by the software version that is committed to the hardware platform.

20. The system of claim 19 wherein the feature limit data structure includes entries indexed by a combination of hardware platform identifier, program identifier, software release level identifier, and feature identifier.

21. The system of claim 19 wherein the feature limit data structure is specific to a hardware platform and includes entries indexed by software program identifier, software release level identifier, and feature identifier.

22. The system of claim 19 wherein the feature limit data structure includes at least some entries indexed by a software tier identifier, wherein the feature limit manager is adapted to provide the software tier identifier as input when requesting a limit for a given feature and wherein the tier identifier is usable to distinguish being software of the same release level with different capabilities.

23. The system of claim 19 wherein the software program comprises a copy application for copying data from one location to another location in a disk array.

24. The system of claim 19 wherein the software program is adapted to call the feature limit manager with different input to obtain limits for different features.

25. A universal system for identifying and enforcing software version feature limits across different hardware platforms, software releases, and tiers, the system comprising:

(a) a computer storing a feature limit data structure including entries containing feature limits for software operational parameters, each entry in the data structure being indexed by at least a hardware platform identifier, a software program identifier, a software release level identifier, and a feature identifier; and

(b) a feature limit manager being callable by a plurality of different applications for obtaining software feature limits for different release levels of the applications from the feature limit data structure, wherein an application of the plurality of different applications is adapted to provide to the feature limit manager at least a software program identifier, a software release level identifier, and a feature identifier as input and wherein the feature limit manager is adapted to provide, based on the input, a corresponding feature limit to the application, wherein the application enforces the feature limit, wherein enforcing the feature limit includes monitoring a value of a variable associated with the feature limit during execution of the software, determining whether the feature limit has been met, and in response to determining that feature limit has been met, preventing the feature limit from being exceeded, wherein the software release level identifier identifies a software version having a set of operational capabilities, wherein the software release level identifier comprises a commit level, wherein the commit level identifies a software release level for determining feature limits to be enforced on the set of operational capabilities, wherein the commit level is determined by the software version that is committed to the hardware platform.

26. The system of claim 25 wherein the feature limit data structure includes at least some entries that are indexed by software tier identifiers and wherein the limit manager is adapted to use a software tier identifier to access the feature limit data structure and obtain a feature limit corresponding to the software tier identifier and wherein each tier identifier is usable to distinguish between programs with different capabilities that are of the same software release level.

27. A computer program product comprising computer executable instructions embodied in a non-transitory computer readable medium for performing steps comprising:

(a) storing a data structure on a hardware platform, the data structure including a plurality of feature limits for a plurality of software features, each feature limit being indexed by at least a software program identifier, a software release level identifier and a feature identifier;

(b) initializing software on the hardware platform;

(c) determining a release level of the software, wherein the release level identifies a software version having a set of operational capabilities;

(d) determining a commit level, wherein the commit level identifies a software release level for determining feature limits to be enforced on the set of operational capabilities, wherein the commit level is determined by the software version that is committed to the hardware platform;

(e) obtaining feature limits corresponding to the commit level;

(f) invoking a feature limit manager independent from the software and providing at least a software program identifier, a software release level identifier, and a feature identifier as input to the feature limit manager, wherein the feature limit manager uses the input to query the data structure for a feature limit;

(g) receiving a feature limit from the feature limit manager based on the input; and

(h) enforcing the feature limit during execution of the software, wherein enforcing the feature limit includes monitoring a value of a variable associated with the feature limit during execution of the software, determining whether the feature limit has been met, and in response to determining that feature limit has been met, preventing the feature limit from being exceeded.

28. A computer program product comprising computer executable instructions embodied in a non-transitory computer readable medium for performing steps comprising:

(a) storing, on a hardware platform, a feature limit data structure having a plurality of entries specifying feature limits for software features, each entry being indexed by at least a software program identifier, a software release level identifier, and a feature identifier;

(b) receiving, from software being initialized on the hardware platform, a call requesting a value for a feature limit, the call including at least a software program identifier, a software release level identifier, and a feature identifier as input, wherein the software release level identifier identifies a software version having a set of operational capabilities, wherein the software release level identifier comprises a commit level, wherein the commit level identifies a software release level for determining feature limits to be enforced on the set of operational capabilities, wherein the commit level is determined by the software version that is committed to the hardware platform;

(c) accessing the feature limit data structure and locating an entry corresponding to the software program identifier, release level identifier, and the feature identifier; and

(d) providing the feature limit to the software being initialized, wherein the software being initialized enforces the feature limit, wherein enforcing the feature limit includes monitoring a value of a variable associated with the feature limit during execution of the software, determining whether the feature limit has been met, and in response to determining that feature limit has been met, preventing the feature limit from being exceeded.