Patent Application
20080154574
1. Technical Field
The present invention relates in general to the field of computers, and more particularly to software programs. Still more particularly, the present invention relates to emulating an application, which is running on a production computer system, in a non-production computer system, thus permitting testing of the application without disrupting the production computer system.
2. Description of the Related Art
While components of a software application can be categorized in many ways, a useful concept, when describing the present invention, is to consider an application as being composed of an instructions file, data files and configuration files. As the name implies, an instructions file contains lines of code (instructions) that “tell” (instruct) a computer how to manipulate data in the data files. Examples of such instructions are “add,” “subtract,” “compare,” etc. By utilizing many such instructions in a logical manner, a computer can perform complex operations, including database management, word processing, graphic design, telecommunication, etc.
While instructions tell a computer how to function (i.e., how to process data in the data files), a configuration file tells the instructions what parameters to use. Examples of such parameters include file names used for various application components, page lengths, fonts used by the application, what operating system is to be used, etc. There are literally hundreds of parameters that are described and controlled by the entries in the configuration files.
Different operating systems name and utilize their configuration files differently. For example, Unix® user applications often create a configuration file in a home directory of the user upon startup. Unix® server processes often use configuration files in an installation directory, a root directory, or a location defined by a system administrator. Furthermore, some Unix® configuration files run a set of commands upon startup, such as commands to change directories, run certain programs, create or delete certain files, etc., in order to customize the Unix® session.
Microsoft® Windows® operating systems typically use a Windows® registry to store configuration information. The Windows® registry is a database that contains information and settings for hardware, software, users, and preferences of a computer that is running Window®. For example, whenever a user makes changes to “Control Panel” settings, or file associations, system policies, or installed software, the changes are reflected and stored in the registry.
IBM®'s OS/2® operating system uses a binary formatted registry file named INI (for “initialization”). Unlike the Window® registry, the OS/2® profile (registry) contains a list of key-value pairs, which describe string, data and Boolean operative properties.
Although technically different in some ways, for the purposes of the presently described invention, the terms “registry,” “registry file,” “configuration file,” and “profile” are used interchangeably to describe a configuration file.
At times, a software developer may desire to test some or all of an application by simulating changes to a configuration file, data changes, performance of an upgrade/maintenance on the application, etc. When such testing is performed in a production computer system that is “on line” with an enterprise's activities, problems are likely to occur. At a minimum, such testing changes files, registers, buffers, environmental settings, etc., when compared to running the application without the testing changes. In a worst case, such testing can cause the entire system to crash.
To address the problem described above, the present invention provides for a method, system and computer-readable medium for emulating an application in a non-production computer system. In a preferred embodiment, the method includes the steps of: receiving a first input that selects an application from all applications on a production computer system; receiving a second input that selects specific control files and data files that are to be utilized in an emulated version of a selected application on a non-production computer system; migrating a copy of instructions file from the selected application from the production computer system to the non-production computer system; migrating a copy of the specific control files and data files from the production computer system to the non-production computer system; and executing the copy of instructions files, while using the copy of the specific control files and data files, in the non-production computer system.
The above, as well as additional purposes, features, and advantages of the present invention will become apparent in the following detailed written description.
The novel features believed characteristic of the invention are set forth in the appended claims. The invention itself, however, as well as a preferred mode of use, further purposes and advantages thereof, will best be understood by reference to the following detailed description of an illustrative embodiment when read in conjunction with the accompanying drawings, where:
The present invention allows a software developer to simulate changes made to an application (e.g., system hardware configuration changes, date changes, software maintenance, updates to instruction code, etc.), and to test those changes, without affecting production activities.
In a preferred embodiment of the present invention, an inventory of all applications on the system is made. Once the inventory is completed, a window is created, which displays all of the applications installed on a production computer system. From this window, the software developer is able to choose a specific application for testing in a non-production computer system. (A production computer system is defined as a computer system that is “on line,” and thus is executing an application in real-time in accordance with a commercial utilization that produces a product or service for an enterprise. A non-production computer system is defined as a computer system that is “off line,” and thus does not produce a product or service of the enterprise when executing an application.) Once an application is selected for emulation, the software developer is presented with multiple data files and control files that are used by the selected application. The software developer selects specific selected data files and/or control files, which are then used when emulating the selected application in the non-production computer system. A copy of the instruction, data and control files of the application are then migrated to the non-production computer. Preferably, the copy of the instructions file is pre-migrated, and the copy of the data/control files are transferred at a specific point in time using a fast replication service. Once the application copy is migrated to the non-production computer, the copied instruction, data and/or control files can be altered for testing purposes. By making such changes, subsequent execution results from the unadulterated version of the application, running on the production computer system, can be compared with subsequent execution results from the adulterated version of the application, which is running on the non-production computer system, thus giving the software developer the ability to evaluate the effects of alterations to the application.
With reference now to the figures, and in particular to
Referring now to
Referring now to
Referring now to
Instruction files for the selected application are first migrated from the production computer system to the non-production computer system (block 210). (Note that in an alternate embodiment, only certain portions of the instructions file 108 are migrated to the non-production computer 106 for emulation.) A snapshot of the user-selected control and data files is then taken, through the use of a fast replication service (block 212), such as FRS 352 shown in
As indicated in block 216, the migrated application (including the migrated instructions file, selected data files, and selected control files) is executed in the non-production computer. Note that, in a preferred embodiment, the original version of the application is allowed to continue to execute unfettered in the production computer system while the copied application is executing in the non-production computer system.
Optionally, as illustrated in block 218, the migrated control and data files in the non-production computer system can be altered, thus providing a means for testing the selected application in the non-production environment while using different control and data files.
As depicted in block 220, the output of the application in the production computer system can be compared with the output of the copy of the application in the non-production computer system, whether the control and data files are altered or not. This output may be output to an IO register, a change to control and/or data files, or any other captured output, including fine grain data captures from a scan chain.
Regardless of whether the control and data files have been altered, the differences in the output of the original application and the copied application can then be evaluated, in order to determine what faults may lie in the original unaltered application and/or the migrated altered application (block 222), thus ending the process (terminator block 224).
With reference now to
Production computer 102 is able to communicate with a software deploying server 350 via a network 328 using a network interface 330, which is coupled to system bus 306. Network 328 may be an external network such as the Internet, or an internal network such as an Ethernet or a Virtual Private Network (VPN).
A hard drive interface 332 is also coupled to system bus 306. Hard drive interface 332 interfaces with a hard drive 334. In a preferred embodiment, hard drive 334 populates a system memory 336, which is also coupled to system bus 306. System memory is defined as a lowest level of volatile memory in production computer 102. This volatile memory includes additional higher levels of volatile memory (not shown), including, but not limited to, cache memory, registers and buffers. Data that populates system memory 336 includes production computer 102's operating system (OS) 338 and application programs 344.
OS 338 includes a shell 340, for providing transparent user access to resources such as application programs 344. Generally, shell 340 is a program that provides an interpreter and an interface between the user and the operating system. More specifically, shell 340 executes commands that are entered into a command line user interface or from a file. Thus, shell 340 (as it is called in UNIX®), also called a command processor in Windows®, is generally the highest level of the operating system software hierarchy and serves as a command interpreter. The shell provides a system prompt, interprets commands entered by keyboard, mouse, or other user input media, and sends the interpreted command(s) to the appropriate lower levels of the operating system (e.g., a kernel 342) for processing. Note that while shell 340 is a text-based, line-oriented user interface, the present invention will equally well support other user interface modes, such as graphical, voice, gestural, etc.
As depicted, OS 338 also includes kernel 342, which includes lower levels of functionality for OS 338, including providing essential services required by other parts of OS 338 and application programs 344, including memory management, process and task management, disk management, and mouse and keyboard management.
Application programs 344 include a browser 346. Browser 346 includes program modules and instructions enabling a World Wide Web (WWW) client (i.e., production computer 102) to send and receive network messages to the Internet using HyperText Transfer Protocol (HTTP) messaging, thus enabling communication with software deploying server 350.
Application programs 344 also include applications 104a-c, described above.
Application programs 344 in production computer 102's system memory (as well as software deploying server 350's system memory) also include an Application Emulator (AE) 348. EA 348 includes code for implementing the processes described in
The hardware elements depicted in production computer 102 are not intended to be exhaustive, but rather are representative to highlight essential components required by the present invention. For instance, production computer 102 may include alternate memory storage devices such as magnetic cassettes, Digital Versatile Disks (DVDs), Bernoulli cartridges, and the like. These and other variations are intended to be within the spirit and scope of the present invention. Note that non-production computer 106 may utilize a same or substantially similar architecture as that depicted for production computer 102. Similarly, software deploying server 350 may utilize a same or substantially similar architecture as that depicted for production computer 102.
Note that, in a preferred embodiment of the present invention, software deploying server 350 performs all of the functions associated with the present invention (including execution of EA 348), thus freeing production computer 102 from having to use its own internal computing resources to execute EA 348.
Non-production computer 106 may be coupled to system bus 306, in order to facilitate the operation of a Fast Replication Service (FRS) 352 by directly tapping into system bus 306 to access the application programs 104. Alternatively, non-production computer 106 can be coupled to 10 bus 314, either directly or via 10 interface 316, to access the application programs 104.
It should be understood that at least some aspects of the present invention may alternatively be implemented in a computer-readable medium that contains a program product. Programs defining functions on the present invention can be delivered to a data storage system or a computer system via a variety of tangible signal-bearing media, which include, without limitation, non-writable storage media (e.g., CD-ROM), writable storage media (e.g., hard disk drive, read/write CD ROM, optical media), as well as non-tangible communication media, such as computer and telephone networks including Ethernet, the Internet, wireless networks, and like network systems. It should be understood, therefore, that such signal-bearing media when carrying or encoding computer readable instructions that direct method functions in the present invention, represent alternative embodiments of the present invention. Further, it is understood that the present invention may be implemented by a system having means in the form of hardware, software, or a combination of software and hardware as described herein or their equivalent.
The present invention thus provides for a method, system, and computer-readable medium for emulating an application in a non-production computer system. In a preferred embodiment, the method includes the steps of: receiving a first input that selects an application from all applications on a production computer system; receiving a second input that selects specific control files and data files that are to be utilized in an emulated version of a selected application on a non-production computer system; migrating a copy of instructions file from the selected application from the production computer system to the non-production computer system; subsequently migrating a copy of the specific control files and data files from the production computer system to the non-production computer system; and executing the copy of instructions files, while using the copy of the specific control files and data files, in the non-production computer system. The method may further include the step of taking a snapshot of the specific control files and data files when a copy of the specific control files and data files are migrated to the non-production computer system; synchronizing execution of the application in the production computer system with execution of the copy of the application in the non-production computer system; and upon the application and the copy of the application completing execution of same instructions, comparing a first output from the application in the production computer system with a second output from the copy of the application in the non-production computer system.
In another embodiment, the method further includes the steps of evaluating differences between the first output from the application in the production computer system and the second output from the copy of the application in the non-production computer system, wherein the evaluating provides information regarding faults in the selected application.
In another embodiment, the method includes the steps of altering the copy of the specific control files and data files before executing the copy of the instructions file in the non-production computer system; and evaluating differences between the specific control files and data files and their altered copies in the non-production computer system, wherein the evaluating provides information regarding faults caused by altered copies of the specific control files and data files.
While the present invention has been particularly shown and described with reference to a preferred embodiment, it will be understood by those skilled in the art that various changes in form and detail may be made therein without departing from the spirit and scope of the invention. Furthermore, as used in the specification and the appended claims, the term “computer” or “system” or “computer system” or “computing device” includes any data processing system including, but not limited to, personal computers, servers, workstations, network computers, main frame computers, routers, switches, Personal Digital Assistants (PDA's), telephones, and any other system capable of processing, transmitting, receiving, capturing and/or storing data.
