Automatic Object Model Generation for Storage Controllers
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
The manual creation of test libraries for storage applications is resource-intensive and time-consuming, requiring extensive documentation reading and resulting in delayed updates when changes occur in the product code, thereby delaying future testing.
Innovation Solution
Automatically generating object models and object-oriented libraries in real-time during runtime, allowing test code to remotely perform commands on storage controllers by accessing and evaluating the storage API's interface to identify modeling information about storage objects, such as volume objects, thereby providing remote access to manipulate these objects.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Reliability
If test libraries are manually created based on product code documentation, then test code can be developed, but the process requires extensive manual resources and time, delaying testing
Solution Approach 1:
The system automatically generates test libraries by having the product code itself generate the test library code through code generation modules. The product code includes metadata and interface definitions that automatically drive the creation of corresponding test code, eliminating the need for manual test library development while ensuring the test library stays synchronized with product code changes
Solution Approach 2:
The product code is structured with embedded metadata, interface definitions, and code generation modules that prepare all necessary information in advance. This preliminary structuring allows the test library to be automatically generated when needed, rather than requiring manual creation from scratch each time
2Adaptability or versatility
If test libraries are manually updated when product code changes, then testing can continue, but updates are delayed until manual revision is completed
Solution Approach 1:
The system establishes a feedback loop where changes in product code automatically trigger regeneration of the test library. The code generation modules continuously monitor product code modifications and initiate test library updates, ensuring the test library remains compatible with the latest product code version without manual intervention
Solution Approach 2:
The test library automatically updates itself by using the updated product code as input to the code generation process. When product code changes, the system self-generates an updated test library that reflects the new interfaces and functionality, maintaining compatibility while enabling immediate testing
3Ease of operation
If developers read documentation to identify API functionality, then test code can be created, but the process is resource-intensive and time-consuming
Solution Approach 1:
Instead of manually reading and interpreting documentation, the system automatically copies and transforms the product code's own interface definitions and metadata into test library code. The code generation modules parse the product code structure and generate corresponding test code that mirrors the actual API functionality, eliminating manual documentation analysis
Solution Approach 2:
The product code serves its own documentation by containing embedded interface definitions and metadata that automatically drive test code generation. The system uses the product code's own structure as the source material for generating test libraries, eliminating the need for separate documentation reading and interpretation processes
Data Source
AI summary
A target device, such as a storage controller, may host an interface that manages objects, such as storage objects (e.g., logical unit numbers (LUNs), volumes, etc.), maintained by the storage controller. Accordingly, an object on the storage controller may be modeled as an object model, such as an object oriented library, based upon modeling information mined from the storage controller. The object model may be automatically generated, such as by discovering the interface to the object using available information in a command line interface (CLI) and/or an XML file (e.g., an XML help file). In this way, the object model may use hosted/exported interfaces to manage the object.