# Patent

## Title
Hierarchical system manager rollback

## Abstract

Data state rollover is performed based on data state snapshots and deltas. A series of snapshots is taken of the current data state, an original data state, and data states in between. Deltas are then generated between two sequential snapshots. This results in numerous deltas which represent the difference between consecutive snapshots. Once the deltas are acquired, the deltas may be stored along with the snapshot of the present data state. As such, previous data states may be rolled back to by determining the number of deltas to apply to the current data state to achieve the desired previous data state. In cases where the rollback or rollover fails, deltas may be played against the current data state to a point where the last known trusted and working data point existed.

## Background
BACKGROUND OF THE INVENTION
Field of the Invention
The present invention relates to data backup systems. In particular, the present invention relates to performing data rollbacks.
Description of the Related Art
As companies create more and more data, data storage systems reliability become more important. As technology improves, the data storage systems improve as well. Sometimes, the data storage systems transition between a first data format to a second data format. This creates challenges when a company's important data is stored in a first format or technology and the data storage company is transitioning to a second storage format.
When transitioning from a first format to a second format, it is very important to a data storage company to not lose any client information or data. To do so would risk the stability of a product, as well as risk the company's track record and reputation. Therefore, providing a safe and reliable means to transition from one data state to another is very important.
What is needed is an improved method for transitioning from one data state to another.
SUMMARY OF THE CLAIMED INVENTION
The present technology allows for data state rollover using snapshots and deltas. A series of snapshots is taken of the current data state, an original data state, and data states in between. Deltas are then generated between two sequential snapshots. This results in numerous deltas which represent the difference between consecutive snapshots. Once the deltas are acquired, the deltas may be stored along with the snapshot of the present data state. As such, previous data states may be rolled back to by determining the number of deltas to apply to the current data state to achieve the desired previous data state. In cases where the rollback or rollover fails, deltas may be played against the current data state to a point where the last known trusted and working data point existed.
An embodiment for performing a data state rollback beings with capturing a multitude of snapshots of workflow data from an original data state to a present data state. A series of deltas are created which represents the difference between each successive state. The deltas are wrapped between the current state and a desired state in a transaction framework to be replayed. The deltas and then played back to completion against the current snapshot.



BRIEF DESCRIPTION OF THE DRAWINGS
FIG. 1 is a block diagram of a system for performing rollback.
FIG. 2 is a method for storing rollback data.
FIG. 3 is a method for performing rollback.
FIG. 4 is a method for processing a failed rollback.
FIG. 5 is a block diagram of a computing system for implementing a server.



DETAILED DESCRIPTION
Data state rollover is performed using snapshots and deltas. A series of snapshots is taken of the current data state, an original data state, and data states in between. Deltas are then generated between two sequential snapshots. This results in numerous deltas which represent the difference between consecutive snapshots. Once the deltas are acquired, the deltas may be stored along with the snapshot of the present data state. As such, previous data states may be rolled back to by determining the number of deltas to apply to the current data state to achieve the desired previous data state. In cases where the rollback or rollover fails, deltas may be played against the current data state to a point where the last known trusted and working data point existed.
FIG. 1 is a block diagram of a system for performing rollback. The system of FIG. 1 includes server 100 and data storage device 140. Server 100 and data storage device 140 may communicate over a network, such as a private network, a public network, an intranet, the internet, or some other network or combination of networks.
Server 100 includes rollback engine 110, delta 120 and snapshot 130. Rollback engine 110 may include one or more modules that are stored in memory and executed by a processor to perform rollback operations. Rollback engine 110 may also be executed to collect rollback data. The rollback data may include delta data 120 and snapshot 130. Snapshots 130 may include snapshots of the current state of data, a snapshot of the original state of data and snapshots contained periodically in between. The snapshots may be obtained at policy driven intervals to ensure that enough data is collected to rollback to any particular state desired by a user. In some embodiments, snapshots may be acquired periodically, based on specific policies or volume of changed data, or based on other reasons. Delta 120 may represent a measure of the distance between successive snapshots. For example a first delta may be taken between the current snapshot and the most recent snapshot other than the current snapshot. Only the current snapshot is stored in server 100, as the base snapshot and deltas 120 are all that is needed in order to perform a rollback operation.
FIG. 2 is a method for storing rollback data. The method of FIG. 2 begins with capturing a plurality of snapshots of workflow data from an original data state to a present data state at step 210. The snapshots may be taken periodically, based on specific policies or volume of changed data, or based on other active or passive events. In some embodiments, the two states of data may have different formats. For example, the original data may be in a NoSQL data store while the present data state is managed by a relational database management system (RDBMS) format of data.
Deltas may then be created representing the differences between the successive states at step 220. The deltas may be determined simply by taking the difference of two consecutive snapshots. The snapshot of the current period and the deltas are stored at step 230. The other snapshots are not needed as the other states can be determined based on the deltas and the current snapshot.
An embodiment may be used to rollback new data in a new state to old data in an old state. An original data state and format is formatted by a particular software program. The data may initially be converted to a new data state and format, and the later data states may be formatted differently by upgraded or changed software programs. The deltas may be taken in the new format and convert the new data, if a rollback is desired, into a neutral format. In some embodiments, the deltas may be generated in the neutral data format representing the difference between each successive state. The deltas can then be wrapped between the current state and the desired state in a transaction framework to be replayed. This allows for replay of the deltas against the original data state and format as well, and the original software can access the data, regardless of which state the data is originally formatted in. An application written to use the original format may still be used to access the data. The application may be able to pickup from the current data state, but in the old data format.
FIG. 3 is a method for performing rollback. First, a request to rollback to a previous desired state is received at step 310. In some embodiments, the request may be received from a user. The deltas between the current state and the previous desired state are identified at step 310. In some embodiments, the deltas may be time stamped to identify their approximate association in time. Identified deltas may be added at step 330. The deltas may be added up to one delta in some embodiments. The deltas may be wrapped up in a transaction framework to be replayed at step 340. The deltas are replayed to completion against the current snapshot at step 350. In some embodiments, a single delta is played against a current snapshot at step 350.
FIG. 4 is a method for processing a failed rollback. The method of FIG. 4 begins with determining that a rollback operation was not successful at step 410. The deltas between the current state and the last known good state are identified at step 420. The identified deltas are then replayed to completion against a current snapshot at step 430.
FIG. 5 is a block diagram of a computing system for implementing a server 100. The computing system 500 of FIG. 5 includes one or more processors 510 and memory 520. Main memory 520 stores, in part, instructions and data for execution by processor 510. Main memory 520 can store the executable code when in operation. The system 500 of FIG. 5 further includes a mass storage device 530, portable storage medium drive(s) 540, output devices 550, user input devices 560, a graphics display 570, and peripheral devices 580.
The components shown in FIG. 5 are depicted as being connected via a single bus 590. However, the components may be connected through one or more data transport means. For example, processor unit 510 and main memory 520 may be connected via a local microprocessor bus, and the mass storage device 530, peripheral device(s) 580, portable storage device 540, and display system 570 may be connected via one or more input/output (I/O) buses.
Mass storage device 530, which may be implemented with a magnetic disk drive or an optical disk drive, is a non-volatile storage device for storing data and instructions for use by processor unit 510. Mass storage device 530 can store the system software for implementing embodiments of the present invention for purposes of loading that software into main memory 520.
Portable storage device 540 operates in conjunction with a portable non-volatile storage medium, such as a floppy disk, compact disk or Digital video disc, to input and output data and code to and from the computer system 500 of FIG. 5. The system software for implementing embodiments of the present invention may be stored on such a portable medium and input to the computer system 500 via the portable storage device 540.
Input devices 560 provide a portion of a user interface. Input devices 560 may include an alpha-numeric keypad, such as a keyboard, for inputting alpha-numeric and other information, or a pointing device, such as a mouse, a trackball, stylus, or cursor direction keys. Additionally, the system 500 as shown in FIG. 5 includes output devices 550. Examples of suitable output devices include speakers, printers, network interfaces, and monitors.
Display system 570 may include a liquid crystal display (LCD) or other suitable display device. Display system 570 receives textual and graphical information, and processes the information for output to the display device.
Peripherals 580 may include any type of computer support device to add additional functionality to the computer system. For example, peripheral device(s) 580 may include a modem or a router.
The components contained in the computer system 500 of FIG. 5 are those typically found in computer systems that may be suitable for use with embodiments of the present invention and are intended to represent a broad category of such computer components that are well known in the art. Thus, the computer system 500 of FIG. 5 can be a personal computer, hand held computing device, telephone, mobile computing device, workstation, server, minicomputer, mainframe computer, or any other computing device. The computer can also include different bus configurations, networked platforms, multi-processor platforms, etc. Various operating systems can be used including Unix, Linux, Windows, Macintosh OS, Palm OS, and other suitable operating systems.
The foregoing detailed description of the technology herein has been presented for purposes of illustration and description. It is not intended to be exhaustive or to limit the technology to the precise form disclosed. Many modifications and variations are possible in light of the above teaching. The described embodiments were chosen in order to best explain the principles of the technology and its practical application to thereby enable others skilled in the art to best utilize the technology in various embodiments and with various modifications as are suited to the particular use contemplated. It is intended that the scope of the technology be defined by the claims appended hereto.

## Claims

1. A method for performing a data state rollback, the method comprising a processor executing instructions out of a memory to:
capture a plurality of snapshots of workflow data from an original data state, wherein each snapshot of the plurality of snapshots are captured based on a volume of changed data since a previous snapshot was captured according to a policy that identifies that a subsequent snapshot should be taken according to the policy, and the workflow data from the original data state is formatted according to a data format associated with a non-relational database;
convert the workflow data into a present data state, wherein the present data state is formatted according to a data format associated with a relational database;
creating create one or more deltas representing the difference between each successive state;
wrapping the deltas between a current state and a desired state in a transaction framework to be replayed; and
replaying replay the deltas to completion against the current snapshot, wherein the replaying of the deltas performs a rollback operation that rollbacks the workflow data to a previous desired state.

2. The method of claim 1, wherein the original data state included non-SOL (NoSQL) data and the present data state includes relational database management system (RDBMS) data.

3. The method of claim 1, wherein the processor executing instructions out of the memory identifies the deltas between the current state and the previous desired state.

4. The method of claim 3, wherein the processor executing instructions out of the memory sums the identified deltas.

5. The method of claim 1, wherein the processor also receives a request to rollback to the previous desired state.

6. The method of claim 1, wherein the processor stores the snapshot of the current state and a delta in the memory, wherein the delta includes information that identifies changes in the workflow data from a previous state to the current state.

7. The method of claim 1, wherein the processor executing instructions out of the memory: further comprising:
identifies that the rollback operation was not successful; and
rolls back to a last good recovery point after identifying that the rollback operation was not successful.

8. A non-transitory computer readable storage medium having embodied thereon a program, the program being executable by a processor to perform a method for performing a data state rollback, the method comprising:
capturing a plurality of snapshots of workflow data from an original data state, wherein each snapshot of the plurality of snapshots are captured based on a volume of changed data since a previous snapshot was captured according to a policy that identifies that a subsequent snapshot should be taken according to the policy, and the workflow data from the original data state is formatted according to a data format associated with a non-relational database;
converting the workflow data into a present data state, wherein the present data state is formatted according to a data format associated with a relational database;
creating deltas representing the difference between each successive state;
wrapping the deltas between a current state and a desired state in a transaction framework to be replayed; and
replaying the deltas to completion against the current snapshot, wherein the replaying of the deltas performs a rollback operation that rollbacks the workflow data to a previous desired state.

9. The computer readable non-transitory computer readable storage medium of claim 8, wherein the original data state included non-SQL (NoSQL) data and the present data state includes relational database management system (RDBMS) data.

10. The non-transitory computer readable storage medium of claim 8, the program is further executable to identify the deltas between the current state and the previous desired state.

11. The non-transitory computer readable storage medium of claim 10, the program is further executable to sum the identified deltas.

12. The non-transitory computer readable storage medium of claim 8, the program is further executable to receive a request to rollback to the previous desired state.

13. The non-transitory computer readable storage medium of claim 8, the program further executable to store the snapshot of the current state and a delta, wherein the delta includes information that identifies changes in the workflow data from a previous state to the current state.

14. The computer readable non-transitory computer readable storage medium of claim 8, the program further executable to:
identify that the rollback operation was not successful; and
roll back to a last good recovery point after identifying that the rollback operation was not successful.

15. An apparatus for performing a data state rollback, the apparatus comprising:
a memory; and
a processor, wherein the processor executing instructions out of the memory:
captures a plurality of snapshots of workflow data from an original data state, wherein each snapshot of the plurality of snapshots are captured based on a volume of changed data since a previous snapshot was captured according to a policy that identifies that a subsequent snapshot should be taken according to the policy, and the workflow data from the original data state is formatted according to a data format associated with a non-relational database;
converts the workflow data into a present data state, wherein the present data state is formatted according to a data format associated with a relational database;
creates one or more deltas representing the difference between each successive state;
wrapping the deltas between a current state and a desired state in a transaction framework to be replayed; and
replays the deltas to completion against the current snapshot, wherein the replaying of the deltas performs a rollback operation that rollbacks the workflow data to a previous desired state.

16. The apparatus of claim 15, wherein the original data state included non-SOL (NoSQL) data and the present data state includes relational database management system (RDBMS) data.

17. The apparatus of claim 15, wherein the deltas between the current state and the previous desired state are identified.

18. The apparatus of claim 17, wherein the processor executing instructions out of the memory also sums the identified deltas.

19. The apparatus of claim 15, wherein the processor receives a request to rollback to the previous desired state.

20. The apparatus of claim 15, wherein the snapshot of the current state and a delta are store in the memory, and the delta includes information that identifies changes in the workflow data from a previous state to the current state.