FORM 2
THE PATENTS ACT, 1970
(39 of 1970)
&
THE PATENT RULES, 2003
COMPLETE SPECIFICATION
(See Section 10 and Rule 13)
TITLE OF INVENTION:
"A System and Method for Application Packaging and Deployment for Oracle
Applications"
Applicant
TATA Consultancy Services Limited A company Incorporated in India under The Companies Act, 1956
Having address:
Nirmal Building, 9th Floor,
Nariman Point, Mumbai 400021,
Maharashtra, India
The following specification particularly describes the invention and the manner in which it is to be performed.

FIELD OF THE INVENTION
This invention relates in general to the field of Software Development Life Cycle Automation. More particularly, the invention relates to a system and method for automating the packaging and deployment of Oracle application.
BACKGROUND OF THE INVENTION
Software d evelopment life cycle also abbreviated as SDLC is a process utilized by system analysts, developers, testers and deployment managers to create, test, deploy and maintain an information system. The SDLC framework provides a sequence of activities for system designers, developers, testers and deployment managers to follow throughout the lifecycle of an information system. It consists of a set of steps or phases in which each phase utilizes the results of the previous phase. The main phases of a Software development life cycle are planning, analysis, design, development, testing, implementation, packaging and deployment.
In planning phase, a project management plan and other planning documents are prepared for the life cycle of the information system. The project goals are defined based on the end user requirements into functions and operation of the intended application in the analysis phase. In the system design phase, the desired features and operations are prepared in detail, including screen layouts, business rules, process diagrams, pseudo code and other documentation. Development phase involves converting the design prepared after the system design phase into a complete information system. The development and test plan phase includes acquiring and installing systems environment, creating and testing databases, preparing test case procedures, preparing test files, coding, compiling, refining programs, performing test readiness review and procurement activities. In testing phase, all the pieces of the generated code are brought together into a special testing environment, to check for errors, bugs and interoperability. In case any errors, bugs and interoperability issues are identified, the code is rectified to remove such issues and may be re tested in the testing environment. The software then goes through the

implementation phase wherein the software may be implemented in environments such as development, test, user acceptance, and the like. Once the problems related to the information system are resolved the system is packaged, a deployment guide is prepared for providing instructions for deployment in the production environment. The packaged software may then be tested in the production acceptance environments and any bugs found may be rectified. Once, all the bugs are fixed, the software is deployed in the production environment.
The software packaging phase involves the preparation of standard, structured software installations targeted for deployment of scripts. The scripts may be standardized and formatted during the development phase itself. In the deployment phase the packaged application is installed in the production environment such as on a client server system. Similar SDLC phases are applicable for any Oracle application. The Oracle scripts may be either manually created or generated using configuration management database (CMDB) which acts as repository of information related to the information system. Such scripts comprise of SQL scripts having scripts for functions, packages, DML, DDL. and the like. A deployment guide is then prepared which shows the sequence for the script to be run and the necessary instruction to be followed while the executation of such scripts. After the deployment guide is prepared the application and the deployment guide is packaged together for delivery. During this exercise, various bugs of deployment scripts, standardization errors and gaps in deployment guide are fixed. On delivery of the packaged software to the customer, the customer installs the packaged software in accordance to the deployment guide in their environments.
A number of problems are incurred while packaging and deployment specifically for an Oracle application. Managing/Organizing scripts according to the framework followed at present are difficult specifically challenges are faced while deciding the hierarchy of scripts. As the packaging is performed manually there is interdependency of the scripts which makes it difficult to deploy the application. Moreover, scanning of the script logs is done manual that may lead to troubles will deployment. The conventional way of deploying software is highly dependent on the skills and experience of the administrator

deploying the application and also there may be gaps in instruction to be followed as mentioned in deployment manual. Unavailability of a strong process and structure for deployment makes deployment of an application dependent on personal skills and require manual review leading to wastage of associate productivity. The available frameworks do not provide fine grained activity logging for deployment activity and no alerts are available in case of missed steps during deployment thus the available deployment methods are not very user friendly.
As a result, there is a growing need for an improved method and system providing a framework for creating scripts based on the specified hierarchy of scripts mentioned/desired by the packaging team. There is a further need for an improved framework for integrating all standards of scripting based on the rules fed into the system for script creation that will also create the deployment guide based on the instructions of the deployment team. Moreover, there is a need for fine grained activity logging mechanism which will keeps a track of all user activities and such activity log files may provide support to administrators deploying the Oracle applications which leads to reduction of dependency on persona] skills and experience.
OBJECTIVES OF THE INVENTION
The principle objective of the present invention is to provide a framework for automated creation of Oracle scripts based on the specified hierarchy of scripts as per the instructions of a packaging team.
Another objective of the invention is to integrate all the standards of the scripting based on the rules provided for script creation.
Yet another objective of the invention is automated generation of deployment guide based on the instructions provided by a deployment team.

Yet another objective of the invention is to provide a user drive menu structure in order to deploy the delivered software on client machine.
Yet another objective of the invention is to enable a fine grained activity logging mechanism for tracing the user activities on system during installation of delivered software.
Still another objective of the invention is to provide a self check mechanism in order to alert the user regarding any change in the deployment scripts.
SUMMARY
Embodiments of the present invention provides a system for application packaging and deployment comprising of at least a script preparation and packaging engine (104) and an application deployment engine (108) wherein the script preparation and packaging engine (104) is adapted to receive a script hierarchy, basic SQL scripts along with commands and messages to be displayed during deployment via an input layer (102); and the script preparation and packaging engine (104) is adapted to atleast generate formatted and standardized scripts, a deployment guide and a master deployment file, the script preparation and packaging engine (104) is also adapted to compress the formatted and standardized scripts, the deployment guide and the master deployment file into a compressed file; the application deployment engine (108) is adapted to receive and uncompress the compressed file and perform a plurality of checks, execute the formatted and standardized scripts, to create a user activity log, a spool file for a corresponding formatted and standardized script during execution and is also adapted to provide one or more script execution status messages.
In an aspect, the user activity log is created at the beginning of the deployment of the application and may include the various inputs provided by the user deploying the application, scripts to be executed, status messages, error messages and the like. The user activity logging ends at the time the user exits the deployment phase. In another

embodiment, the application deployment engine (108) may also facilitate a user friendly interface that provides one or more menus. The application deployment engine (108) may also transmit one or more queries to a user deploying the application for receiving inputs from the user to determine the baseline of the deployment. For example, the application deployment engine (108) may transmit one or more queries or messages for confirming the correctness of the user using or running the deployment script, whether the environment settings are correct for the deployment to be run successfully, in case multiple deployments are present then which deployment would the user like to deploy, in case a deployment was left incomplete at a previous time will the user like to continue from the point he/she had left last or resume from the last terminated point or have a new deployment starting from scratch. In case the deployment is to be started from scratch, the old deployment will be zip/tar and stored and new deployment will begin. This is done in order to keep records of any deployments being done. A user interface may also be provided that is adapted to display the list of scripts that can be deployed as a part of a particular deployment. The deployment engine enables the user to choose the script to be deployed and execute the same. The current status of script execution may also be displayed to the user. As the script execution is completed, the application deployment engine scans through the spool file generated by the script just executed. The spool file contains a list of all the activities that were performed by the script. The application deployment engine may scan through the spool files for any errors, and in case any errors are found, the same is displayed as the script execution status and is made visible to the user. In case no errors are found, the script status is displayed as success. The framework also informs the user if a situation arises wherein systems users are being changed and transactions will be saved automatically. This saves time and effort and missing out of errors from detection by users during deployment.
In another embodiment, the present application provides a method for application packaging and deployment, wherein the method comprises the steps of receiving a script hierarchy for execution; receiving basic SQL scripts along with commands and messages to be displayed during deployment; creating standardized and formatted scripts based on received script hierarchy, and a deployment guide; compressing the standardized and

formatted scripts and the deployment guide into a compressed file; automatically creating a user activity log file and a spool file for every script; compressing the script files. activity log file and spool files; creating a deployment setup having a self-check mechanism.
In an aspect, the self check mechanism may enable the user to correctly deploy the application, for example, in case the deployment script is altered to by-pass any check, the script may fail to execute.
BRIEF DESCRIPTION OF THE DRAWINGS
The foregoing summary, as well as the following detailed description of preferred embodiments, is better understood when read in conjunction with the appended drawings. For the purpose of illustrating the invention, there is shown in the drawings example constructions of the invention; however, the invention is not limited to the specific system and method disclosed in the drawings:
FIG. 1 is a diagram illustrating a block diagram representation application packaging and deployment system in accordance with an illustrative embodiment.
Figure 2 illustrates an exemplary script hierarchy representation.
Figures 3a and 3b depict an exemplary flowchart diagram of application packaging and deployment.
DETAILED DESCRIPTION OF THE INVENTION
Some embodiments of this invention, illustrating all its features, will now be discussed in detail. The words "comprising," "having," "containing," and "including," and other forms thereof, are intended to be equivalent in meaning and be open ended in that an item or items following any one

of these words is not meant to be an exhaustive listing of such item or items, or meant to be limited to only the listed item or items.
It must also be noted that as used herein and in the appended claims, the singular forms "a," "an," and "the" include plural references unless the context clearly dictates otherwise. Although any systems and methods similar or equivalent to those described herein can be used in the practice or testing of embodiments of the present invention, the preferred, systems and methods are now described.
Although any systems and methods similar or equivalent to those described herein can be used in the practice or testing of embodiments of the present invention, the preferred, systems and methods are now described.
During the Software development life cycle of an Oracle application upon the development and testing the application undergoes a plurality of phases such as Packaging, Deployment Guide preparation, Deployment in internal environments, Testing of Deployment, Delivery to customer, Deployment in customer environments. The scripts of the Oracle application may be generated manually or directly from a configuration management database also referred to as CMDB. Such scripts generally comprise of SQL scripts having scripts for functions, packages, DML sc ripts, DDL scripts, and the like. Once, these scripts have been created a deployment guide is prepared stating the sequence in which the scripts are to be executed. The deployment guide also includes the instructions to be followed while executing the scripts. Thereupon, test rounds of deployment are performed in internal environments during which various bugs existing in the deployment scripts and deployment guide are fixed. Once the deployment is successful, the Oracle application is tested to check whether the packaged and deployed software is working as desired. On. delivery of the packaged Oracle application, usually an administrator on the customer end installs the packaged application in accordance to the deployment guide.

In an embodiment, the present invention provides a framework for creating scripts based on a hierarchy of scripts specified by a packaging team. Figure 1 illustrates the application packaging and deployment system in accordance with the present embodiment. The system may enable integrating all standards of scripting for creating scripts based on a set of script creation rules provided in a script preparation and packaging engine. Once the scripts are created by the script preparation and packaging engine, the system may enable creating a deployment guide based on the instructions provided by the deployment team. Since the deployment guide is automatically created by the framework, the formatting and consistency are maintained. At this stage, the deployment is ready with the instructions. Conventionally, the process of deployment is dependent on specific people such as administrators deploying the Oracle applications this makes the process of deployment dependent on the skills and experience of the administrator. In an aspect, the present framework may provide a user driven menu structure for deployment of the application package. Therefore, the system not only eliminates possible errors by administrators but also gives a process and structure to any ad-hoc deployment processes being followed. In an aspect, a fine grained activity logging mechanism is facilitated by the system that enables keeping track of all user activities. The log files generated by such an activity logging mechanism may also be utilized for providing support to administrator without directly access their systems.
FIG. 1 depicts a block diagram representation of an application packaging and deployment system in which illustrative embodiments may be implemented. The system comprises of at least a script preparation and packaging engine (104), and an application deployment engine (108). The script preparation and packaging engine (104) receives at least a hierarchical script setup with instructions, and core script content from the packaging team via an input layer (102). Figure 2 illustrates an exemplary script hierarchy representation. The packaging team may also provide a set of script creation rules for creation of scripts in a desired format. The script preparation and packaging engine (104) generates an output (106) that may include at least a deployment guide with instructions for deploying the packaged application, formatted and standardized scripts. Once the scripts are generated a master deployment file is also created. In an aspect, the

master deployment file may contain the details of the change/deployment name, the scripts to be executed, instructions and users for the same and execution status of the scripts set to 'To be Executed' or 'To be Executed (Optional)' and a checksum having a count of the number of scripts in the deployment master File. This is done in order to prevent any tampering of the files and to maintain consistency across the packaging and deployment framework. The formatted and standardized scripts along with the master deployment file may be provided in a compressed format such a TAR or ZIP file. The Deployment guide and the compressed file are then provided to the application deployment engine (108) for deployment.
In an embodiment, a user activity log may be created that records and stores the steps taken by a user during the deployment phase. The user activity log starts with the start of execution of the deployment script and upon the completion or termination of the deployment setup, the user activity log terminates. The log files may log each and every activity performed by the user during the deployment using the deployment setup framework. The log file may be maintained till the microsecond level. All the files created during deployment may also be compressed and stored upon successful completion in the server directory for audit purpose. Further, every script available in the application package may have a corresponding spool file. In an embodiment, the spool file may include information regarding the execution of the corresponding script such as details regarding any error occurred while execution of the script, details regarding any activity done by the script in the system, number of errors, and the like. The spool files may be created by the application deployment engine while executing the scripts and an error message may be displayed to the user while deployment. The spool files contain a list of all the activities that were performed by the script. The framework scans through the spool files for any errors, if any errors are found; the same may be displayed in the script execution status and is made visible to the user. In case no errors are found, the script status is shown as success. The framework also informs the user if a situation arises wherein systems users are being changed and transactions will be saved automatically. This saves time and effort and missing out of errors from detection by users during deployment. In an aspect, the deployment setup script may be provided a self-check

mechanism. For example, if the deployment script has been altered to by-pass any checks deployment, the script may fail to execute.
With reference now to the figure and in particular with reference to figures 3a and 3b, exemplary flowchart diagram of application packaging, and deployment are provided in which illustrative embodiments may be implemented. It should be appreciated that the figures are only exemplary and are not intended to assert or imply any limitation with regard to the environments in which different embodiments may be implemented. Many modifications to the depicted environments may be made.
The method for application packaging and deployment is divided into two sub phases namely application packaging and application deployment. In an embodiment, a developer or a developing team may initially provide via an input layer a script hierarchy that may enable determining the script name and the hierarchy in which the scripts are to be executed. Such a hierarchy may also provide details regarding the calling of various scripts and sub scripts. For example, the hierarchy may determine the calling of a child script from a parent script. In an aspect, the hierarchy provided by the developing team may contain a column of remarks wherein the developer may mention the instructions to be followed while executing the scripts and information related to the script, expected results etc. Figure 2 illustrates an exemplary script hierarchy representation. The script creation status may be updated to 'pass' when a script successfully transforms to the required standard and format. The developing team may also provide basic SQL scripts having a plurality of SQL commands to be executed and also messages to be displayed during execution of the script. The packaging phase enables accepting the input scripts with commands and messages to be provided at the time of execution. For example, a plurality of SQL scripts and commands may be provided by the development team. A plurality of messages may also be provided that may be displayed during the execution of the files during deployment. Upon receiving the input, a set of standardized and formatted scripts based on the provided hierarchy are created by utilizing the script preparation and packaging engine. A deployment guide is also created that provides the instructions to be followed while deployment. In an aspect, a master deployment file may

also be created. Such a master file may contain the details of the change/deployment name, the scripts to be executed, instructions, execution status of the scripts and a checksum having a count of the number of scripts. Finally, all the SQL scripts and the master deployment files along with the deployment guide are packaged into a compressed format such as TAR or ZIP by the script preparation and packaging engine. In an aspect, the compressed file may be stored at a convenient storage means such as a server for deployment.
The second phase Script Deployment starts with accepting the compressed file. Once the compressed file is accessed, a self-check mechanism checks for any errors in the scripts to be deployed. During the deployment phase a plurality of user activity log files are created during the SQL script execution. A plurality of user activity log files is automatically created during the execution of the deployment file. Such user activity log files may contain each and every activity done by the user during the deployment using the deployment setup framework. Upon the initial self-check the compressed file is uncompressed and a self-check is performed for the master deployment file. In an aspect, a plurality of checks may be performed including but not limited to user checks, path, setups, and the like. Once the master deployment file is checked for errors, the master deployment file is executed. During the execution of the SQL scripts in the master deployment file, a spool file is created for every SQL script. Such spool files may include information regarding the execution of the corresponding script such as details regarding any error occurred while execution of the script, details regarding any activity done by the script in the system, number of errors, and the like. The spool files may be created by the application deployment engine while executing the scripts and an error message may be displayed to the user while deployment. The spool files contain a list of all the activities that were performed by the script. The framework scans through the spool files for any errors, if any errors are found; the same may be displayed in the script execution status and is made visible to the user. In case no errors are found, the script status is shown as success. On completion or termination of the deployment setup, the user activity log is also closed. Once the master deployment file has been successfully executed all the scripts, deployment guide, user activity files and spool files are

compressed in a TAR or ZIP file format. Such a compressed file containing the scripts, deployment guide, user activity files and spool files is then successfully ready to be deployed in production environment.
One or more components of the invention are described as module for the understanding of the specification. For example, a module may include self-contained component in a hardware circuit comprising of logical gate, semiconductor device, integrated circuits or any other discrete component. The module may also be a part of any software program executed by any hardware entity for example processor. The implementation of module as a software program may include a set of logical instructions to be executed by the processor or any other hardware entity. Further a module may be incorporated with the set of instructions or a program by means of an interface.
Moreover, although the present invention and its advantages have been described in detail, it should be understood that various changes, substitutions and alterations can be made herein without departing from the invention as defined by the appended claims. Moreover, the scope of the present application is not intended to be limited to the particular embodiments of the process, machine, manufacture, composition of matter, means, methods and steps described in the specification. As one will readily appreciate from the disclosure, processes, machines, manufacture, compositions of matter, means, methods, or steps, presently existing or later to be developed that perform substantially the same function or achieve substantially the same result as the corresponding embodiments described herein may be utilized. Accordingly, the appended claims are intended to include within their scope such processes, machines, manufacture, compositions of matter, means, methods, or steps.
The preceding description has been presented with reference to various embodiments. Persons skilled in the art and technology to which this application pertains will appreciate that alterations and changes in the described structures and methods of operation can be practiced without meaningfully departing from the principle, spirit and scope.

We Claim:
1. A system for application packaging and deployment comprising of at least a script
preparation and packaging engine (104) and an application deployment engine
(108) wherein
the script preparation and packaging engine (104) is adapted to receive a script hierarchy, basic SQL scripts along with commands and messages to be displayed during deployment via an input layer (102); and the script preparation and packaging engine (104) is adapted to atleast generate formatted and standardized scripts, a deployment guide and a master deployment file, the script preparation and packaging engine (104) is also adapted to compress the formatted and standardized scripts, the deployment guide and the master deployment file into a compressed file;
the application deployment engine (108) is adapted to receive and uncompress the compressed file and perform a plurality of checks, execute the formatted and standardized scripts, to create a user activity log, a spool file for a corresponding formatted and standardized script during execution and is also adapted to provide one or more script execution status messages.
2. The system as claimed in claim 1 wherein, the master deployment file contains the details of the change/deployment name, the details of scripts to be executed, instructions and users for the same and execution status of the scripts and a checksum.
3. The system as claimed in claim 1 wherein the script hierarchy includes the script name, details regarding the hierarchy of scripts execution, and details regarding the calling of various scripts and sub scripts.
4. The system as claimed in claim 1 wherein, the script preparation and packaging engine (104) is adapted to compress the files into a TAR or ZIP file.
5. The system as claimed in claim 1 wherein, the application deployment engine (108) is adapted to perform one or more checks selected from the group

comprising of User checks, path, setups, and checks for various permissions on the deployment compressed software.
6. The system as claimed in claim I wherein, the application deployment engine (108) is adapted to display the progress of the deployment and instructions along with the execution status of the script.
7. The system as claimed in claim 1 wherein, the application deployment engine (108) is adapted to display error messages in case of any errors.
8. The system as claimed in claim 1 wherein, the application deployment engine
(108) is adapted to resume the deployment from a previous state stored in the
spool files.
9. A method for application packaging and deployment, wherein the method
comprises the steps of
a. receiving a script hierarchy for execution;
b. receiving basic SQL scripts along with commands and messages to be
displayed during deployment;
c. creating standardized and formatted scripts based on received script
hierarchy, and a deployment guide;
d. compressing the standardized and formatted scripts and the
deployment guide into a compressed file;
e. automatically creating a user activity log file and a spool file for every
script;
f. compressing the script files, activity log file and spool files;
g. creating a deployment setup having a self-check mechanism.