Patent Publication Number: US-7908514-B2

Title: Minimizing data loss in asynchronous replication solution using distributed redundancy

Description:
BACKGROUND 
     Large messaging solutions are typically deployed across multiple machines, creating a distributed solution. The storage component of a solution often times requires a replication solution to protect against outages and/or data loss due to failures within the system. 
     Asynchronous log shipping has been used to provide an effective replication solution at a relatively low cost. However, asynchronous log shipping can experience data loss in the event of failure. This is because the asynchronous nature of the solution does not guarantee that all changes performed by an active data copy are immediately replicated to other servers. Users are thus forced to make a tradeoff between these recovery characteristics versus costs and complexity. 
     An email deployment can employ redundant frontend and backend servers, where mailbox storage is provided by the backend servers. The frontend servers can provide protocol services (e.g., POP and IMAP) and also client access services (e.g., browser-based mail reading and mobile device mail synchronization). 
     The backend servers can employ asynchronous log shipping to replicate the mail database between the configured copies and use an active/passive mechanism to manage changes to both copies. However, a log shipping solution can result in some amount of user data being lost if a server crash causes a failover. 
     SUMMARY 
     The following presents a simplified summary in order to provide a basic understanding of some novel embodiments described herein. This summary is not an extensive overview, and it is not intended to identify key/critical elements or to delineate the scope thereof. Its sole purpose is to present some concepts in a simplified form as a prelude to the more detailed description that is presented later. 
     To that end, architecture is disclosed for a computer-implemented data replication system that reduces data loss resulting from failover in an asynchronous replication (e.g., log shipping) operation. The architecture facilitates the asynchronous replication of data between backend servers. 
     A short history of recent changes (e.g., replication operations) made to the backend servers is maintained at a storage component (e.g., frontend server, a middle-tier server, etc.). This short history can be resubmitted to the backend servers after the failover at the backend servers has occurred. The architecture facilitates the automatic detection of the lossy failover and initiates resubmission of the recent changes. The history of recent changes is managed by maintaining the history for a short period of time (e.g., the duration of the time used for the changes to be correctly replicated). 
     By combining asynchronous replication with a short term history of changes, the short term history can be resubmitted on demand to fill in data changes that were lost on failover. These mechanisms can include new object creation and object update cases. The resubmission of the short term history is coordinated with the replication history by integrating a feedback loop. By including replication progress with the history mechanism the burden of information storage and processing is reduced. 
     The history of recent changes can be maintained on servers for resubmission (e.g., on demand) to the backend servers. For example, the servers can include frontend severs (e.g., web access) and mid-tier servers (e.g., client access). 
     To the accomplishment of the foregoing and related ends, certain illustrative aspects are described herein in connection with the following description and the annexed drawings. These aspects are indicative of the various ways in which the principles disclosed herein can be practiced, all aspects and equivalents of which are intended to be within the scope of the claimed subject matter. Other advantages and novel features will become apparent from the following detailed description when considered in conjunction with the drawings. 
    
    
     
       BRIEF DESCRIPTION OF THE DRAWINGS 
         FIG. 1  illustrates a computer-implemented data management system in accordance with the disclosed architecture. 
         FIG. 2  illustrates a more detailed implementation of the storage component. 
         FIG. 3  illustrates additional components for a data management system. 
         FIG. 4  illustrates a more detailed system showing frontend and mid-tier server systems that employ pruning and replication feedback for minimizing data loss. 
         FIG. 5  illustrates an alternative embodiment of the changes performed by the computer-implemented data management system. 
         FIG. 6  illustrates a method of processing Group One changes. 
         FIG. 7  illustrates a method of pruning the history based on replication progress. 
         FIG. 8  illustrates a method of processing a detected failover at the backend servers. 
         FIG. 9  illustrates a method of updating an existing object. 
         FIG. 10  illustrates a method of resubmitting history for Group Two changes. 
         FIG. 11  illustrates a method of processing Group Three changes. 
         FIG. 12  illustrates a method of computer-implemented data management. 
         FIG. 13  illustrates a block diagram of a computing system operable to execute computer-implemented data management systems in accordance with the disclosed architecture. 
         FIG. 14  illustrates a schematic block diagram of an exemplary computing environment that interacts with a computer-implemented data replication system. 
     
    
    
     DETAILED DESCRIPTION 
     The disclosed architecture relates to a computer-implemented data replication system that reduces data loss resulting from failover in an asynchronous log shipping operation. For example, in an asynchronous log shipping operation in a messaging embodiment, messaging data is asynchronously replicated to backend servers in accordance with one or more replication operations, which can be updates to databases on the backend server. For example, these databases can be associated with messaging data, such as email address books, mailboxes, etc. 
     Reference is now made to the drawings, wherein like reference numerals are used to refer to like elements throughout. In the following description, for purposes of explanation, numerous specific details are set forth in order to provide a thorough understanding thereof. It may be evident, however, that the novel embodiments can be practiced without these specific details. In other instances, well known structures and devices are shown in block diagram form in order to facilitate a description thereof. The intention is to cover all modifications, equivalents, and alternatives falling within the spirit and scope of the claimed subject matter. 
       FIG. 1  illustrates a computer-implemented data management system  100  in accordance with the disclosed architecture. The system  100  finds use with a messaging solution (e.g., email address books, mailboxes, etc.). However, it is to be appreciated that the system  100  can also be employed with any type of server-driven database system. The system  100  includes a history component  102  for maintaining a history  104  of changes made by clients  106  to backend servers  108 , and a storage component  110  for storing the history  104  of the changes for resubmission of the changes in response to a lossy failover at the data stores  112  of the backend servers  108 . 
     The clients  106  can include applications associated with desktop computers, portable computers, cell phones, and messaging devices, for example, for accessing associated servers, such as frontend servers and mid-tier servers. Applications/servers such as for communications (e.g., email, instant messaging, etc.), collaboration, document management, etc., can benefit from the history and replication processes of the architecture. 
       FIG. 2  illustrates a more detailed implementation of the storage component  110 . The storage component  110  can include storage mechanisms (e.g., chip memory, mass storage, etc.) of a frontend server system  200  as well as the storage mechanisms (e.g., chip memory, mass storage, etc.) associated with a mid-tier server system  202 . Thus, changes made to the frontend system  200  by frontend clients  204  will be saved temporarily in a frontend history component  206  as frontend history  208 . Similarly, changes made to the mid-tier system  202  by mid-tier clients  210  will be saved temporarily in a mid-tier history component  212  as mid-tier history  214 . The histories ( 208  and  214 ) are maintained only as needed. For example, as soon as replication processes on the backend servers  108  are deemed to be successful, the histories ( 208  and  214 ) are deleted. Note that the histories ( 208  and  214 ) do not need to be the entire history of the client interactions or changes, thereby reducing the amount of data stored as the histories ( 208  and  214 ). Only recent changes are maintained, as can be determined by time/date information, for example. 
       FIG. 3  illustrates additional components for a data management system  300 . The system  300  includes a replication component  302  associated with the backend servers  108  for asynchronously replicating changes received at a backend server to the remaining backend servers according to replication operations. The replication operations can include recent changes (updates) received at the backend servers from the frontend servers and/or mid-tier servers as related to log shipping, for example, to one or more of the data stores  112  (also referred to herein as databases) of the backend servers  108 . In operation, the mid-tier server, for example, makes a change to the backend database and in the process saves the data locally as well. 
     A failover detection component  304  detects problems associated with the replication process, such as lossy failover that results in changes (updates) that do not get replicated to one or all of the backend databases during the replication process. 
       FIG. 3  illustrates that, generally, the replication component  302 , failover detection component  304 , and duplicate detection component  308  reside local to the backend servers  108 . In a more specific depiction, each of the backend servers  108  can include one or more of the components, such as the replication component  302  and failover detection component  304 . 
     On the storage component side, when lossy failover is detected at the backend server  108 , a resubmission component  306  queries (or requests) the resubmission of the history  104  from the storage component  110 . Note that the history  104  represents a single history file from a single server (e.g., frontend server or mid-tier server) or multiple history files from correspondingly multiple frontend and/or mid-tier servers. Accordingly, the resubmission component  306  (as can be deployed on each frontend server, mid-tier server or groups of such servers) processes requests from the backend servers  108  for history from the frontend/mid-tier servers that contributed to the replicated data on the backend servers  108 . 
     A duplicate detection component  308  monitors and eliminates duplicates during the resubmission process that utilizes the most recent changes according to time window communicated as part of the resubmission request. In other words, if during resubmission an item from the history  104  is determined to be a duplicate of the item already successfully updated on the backend servers  108 , the resubmission duplicate will be skipped (or discarded). Resubmission processing then continues to the next recent history item. 
     A pruning component  310  is provided for pruning outdated changes (or updates) from the history  104 . Upon determining a particular time (e.g., based on a timestamp) at which all replication operations are up-to-date and correct, the pruning component  310  removes (or expires) items from the history  104  that are older than that timestamp. 
     A replication feedback channel  312  defines a time interval for which items in the history  104  will be considered for resubmission. The selected items in the history  104  are pruned (using the pruning component  310 ) based on the replication feedback channel  312 . Resubmission progress is periodically obtained from the backend servers  108 , which can be represented as a timestamp (or a logical equivalent) of the changes successfully resubmitted. Items in the history  104  that are older than the provided timestamp can be pruned. The replication feedback channel  312  ensures that the history  104  does not become excessively large according to predetermined criteria. For example, history file sizes in the range of gigabytes can be unwieldy; thus, a file size limit can be imposed (e.g., in addition to, or alternatively, to a time lime) so as to not negatively impact performance and transport input/output. 
     The history  104  stored in the history component  102  can include operational transactions selected from operations that create a new messaging object, operations that update an existing object, and/or operations that are performed on an original item and are distributed to recipients, such as associated with a messaging implementation for management, replication, and resubmission of email messages. 
     The backend servers  108  can typically include multiple different databases (e.g., fifty) over which replication losses can occur and for which losses can be different from database to database, and resubmission processing accommodates this situation by properly handling duplicates. Once the resubmission process has been deemed successful, the recent change items in the history  104  can be pruned or the history  104  deleted entirely. For efficiency, the history  104  can be maintained by the history component  102  no longer than the duration of the time utilized to resubmit the changes. This can be on the order of minutes, or less, for example. 
     By configuring the history component  102  to interact with the mid-tier servers and frontend servers, the history of committed changes maintained in the history  104  is outside the transactional storage infrastructure of the backend servers  108 , and is able to fill in missing changes in the event of replication failover. 
       FIG. 4  illustrates a more detailed system  400  showing frontend and mid-tier server systems that employ pruning and replication feedback for minimizing data loss. The system  400  includes the frontend server system  200 , and the associated frontend history component  206  for storing frontend change history  208  by frontend clients. Additionally, the system  400  includes the mid-tier system  202 , the associated mid-tier history component  212  for saving recent mid-tier client changes in the mid-tier history  214 . 
     The frontend server system  200  is further associated with a frontend pruning component  402  for pruning the frontend history  208 , and a frontend replication feedback channel  404  for receiving and processing progress information related to the processing of change resubmissions from the frontend history  208  to the backend servers  108 . Similarly, the mid-tier server system  202  is further associated with a mid-tier pruning component  406  for pruning the mid-tier history  214 , and a mid-tier replication feedback channel  408  for receiving and processing progress information related to the processing of change resubmissions from the mid-tier history  214  to the backend servers  108 . The backend servers  108  components ( 302 ,  304  and  308 ) operate according to the previous description of the system  300  of  FIG. 3 . 
       FIG. 5  illustrates an alternative embodiment of the changes  500  performed by the computer-implemented data management system. The changes  500  can be distinguished into three groups, for example, and be processed in an interspersed way. Group One changes  502  are related to creating a new messaging object. The Group One changes can include a new appointment, contact, task and/or a draft message, for example. Group Two changes  504  are related to updating an existing object. Group Three changes  506  are related to ensuring that items of an originator are accounted for and can be resubmitted if received by a recipient entity, but not showing in the sender&#39;s message store. The originator is included in the distribution of updates through the messaging service, for example, so that all involved parties receive and see the change. 
     Included herein are flow charts that are representative of methodologies for performing novel aspects of the disclosed architecture. While, for purposes of simplicity of explanation, the one or more methodologies shown herein, for example, in the form of a flow chart or flow diagram, are shown and described as a series of acts, it is to be understood and appreciated that the methodologies are not limited by the order of acts, as some acts may, in accordance therewith, occur in a different order and/or concurrently with other acts from that shown and described herein. For example, those skilled in the art will understand and appreciate that a methodology could alternatively be represented as a series of interrelated states or events, such as in a state diagram. Moreover, not all acts illustrated in a methodology may be required for a novel implementation. 
       FIG. 6  illustrates a method of processing Group One changes. The description is in the context of a frontend server; however, it applies equally as well to a mid-tier server. As described hereinabove, the Group One changes are related to the creation of a new data object (e.g., messaging). At  600 , a frontend server creates a globally unique ID (GUID) for all new objects created. A variation to this flow is that the backend server creates the GUID and returns the GUID to the requester (e.g., frontend server, mid-tier server, etc.), at which point, the requestor inserts the GUID into the history. At  602 , a copy of the new data object, along with identity information of the data object and GUID, are stored in the frontend server history file. The GUID is a portion of feedback from a backend server. Upon resubmission of some or all of the history, the GUID is provided back to the backend servers or used by the frontend server. 
     At  604 , the new object is created with the GUID included in the object. If the object fails to be created due to anything other than a service failure then the history object is flagged as “failed to be created.” At  606 , a timestamp, or logical equivalent, is entered in the history when the creation operation completes. This behavior continues for each new object, as indicated at  608 . 
       FIG. 7  illustrates a method of pruning the history based on replication progress. The pruning component prunes the history based on the replication feedback channel. At  700 , pruning of the history on the frontend server is initiated based on the replication feedback channel. At  702 , the frontend server periodically collects replication progress from the backend server via the feedback channel. This progress can be logically represented as a timestamp (or other logical equivalent) of the changes successfully applied. At  704 , items older than the provided timestamp can be deleted from the history. 
       FIG. 8  illustrates a method of processing a detected failover at the backend servers. At  800 , the detection component detects failover that does not include all backend database updates. At  802 , the frontend servers are queried to resubmit the associated history, the query including the time range of the items to play. The frontend servers hold history data for an amount of time, alternatively or in combination therewith, a certain amount of space, in order to simplify deployment and management. At  804 , the resubmission component resubmits the history files from the frontend servers beginning with the oldest entry in the files, and using the object identity information to access the object. At  806 , a check is made for the object, and if the object exists, a check is made at  808  for a matching GUID. If a matching GUID exists, flow is to  810  where the history entry is skipped. At  812 , the next entry in the history is selected and flow is to  806  to repeat the process. If the object exists (at  806 ), but has a different GUID, flow is from  808  to  814  where the new object is created or the object is compared to determine if it is identical. At  816 , continue processing for each item. At  818 , the resubmission event of the history is also placed into the history in case a new failover occurs. If at  806 , an object does not exist, flow is to  820  to create a new object. Flow is then to  816  to continue processing, as before. 
     As described hereinabove, the Group Two changes include changes that update an existing messaging object.  FIG. 9  illustrates a method of updating an existing object. At  900 , the frontend server maintains a history of the changes the server performs. The history includes the change and version information of the backend object at the time of the change. The version information can be provided as a version vector, which is returned by the backend to be saved in the history. The version information is used to detect conflicts and/or determine if the change has already been performed. At  902 , a timestamp or the like is entered in the history when the update operation completes. At  904 , this process is repeated for every object. 
     The version information describes how an object has been changed. The sets of version pairs are compared to determine whether or not the changes are present at the backend servers. When a change is made, there is feedback from the backend servers indicating a version of an object created with that change. Upon replay following a lossy failover, the version information and the information describing the change are compared to determine if the associated operation is present on the backend server. An operational mechanism for processing Group Two changes is explained as follows. 
     The pruning component prunes the history in the same way as for the Group One changes described above. Similarly, failover detection and processing can be the same as described above for the Group One changes. 
       FIG. 10  illustrates a method of resubmitting history for Group Two changes. At  1000 , the frontend server history component is configured to maintain the history for a predetermined period of time and/or according to predetermined file size. At  1002 , history resubmission is initiated for the Group Two changes. At  1004 , the frontend server processes the history starting at the oldest item within the range of time specified in the query from the backend servers. At  1006 , for each item, the frontend server compares the version information for object it has to the version information of the object on the backend server. 
     At  1008 , if the version information of the backend object shows the version to be a superset of the object from the history, flow is to  1010 , where the update is skipped. Flow is then back to  1006  to continue processing items. If the version on the backend servers is a subset of the history&#39;s version, as indicated at  1012 , then flow is to  1014 , where the update is performed. Flow is then back to  1006  to continue processing items. If two versions are not a superset or a subset, flow is from  1012  to  1016 , where the versions are determined to be in conflict, and then conflict resolution is employed on the two items to resolve the conflict. At  1018 , completely processed items are pruned according to the pruning procedure described herein, and resubmitted updates are retained in the history again for failover. 
     Version information can be maintained as a vector of the entities that perform the updates. For example, the backend server is represented as one element of the vector, each caching client is represented as another entry, and optionally, each frontend server can also be another entry in the vector. 
     As described hereinabove, the Group Three includes changes performed on an item of an originator. These changes are distributed to messaging system recipients.  FIG. 11  illustrates a method of processing Group Three changes. The method is in the context of an email item; however, it is to be understood that the method applies to data, in general, as well. 
     Changes might result in a state where everyone but the originator knows about the changes. For example, consider a meeting appointment or the addition of a recipient to a distribution list. If an object is updated and just the object knows about the update, this can be resolved. When a meeting request is created, two things happen: the meeting request is entered in the calendar and then is sent to everybody invited to the meeting. Thus, when the originator user schedules a meeting with other users, there will be an indication in the calendar and a message is sent in the inbox. The system handles this case correctly where the indication disappears out of the calendar. 
     In processing the history, the indication gets put into the calendar and invites are sent to all the users that were invited to the meeting. This causes duplicate meeting requests to appear in the originator&#39;s inbox. The system detects and deletes these duplicates. Thus, Group Three changes are managed by ensuring that in the process of putting a meeting request back, there may be information sent out that already exists elsewhere in the system. The system manages this by detecting and deleting the duplicates to prevent further complications that could result if duplicates where disseminated through the system. 
     At  1100 , an originator is added to a distribution list of a notification email. At  1102 , a check is performed to determine if an item is received but no indication of the item is found within the senders messaging store. At  1104 , if no indication is found, a new object is created based on the content of the item, as indicated at  1106 . At  1108 , the re-created item replaces the originally lost item for all subsequent actions. At  1110 , the received item is discarded if the original item is detected. Additionally, the received item is not made visible to the user. If there is an indication of the item in the sender message store, flow is from  1104  to  1112  to process the item normally. 
       FIG. 12  illustrates a method of computer-implemented data management. At  1200 , a recent history of client changes is maintained at a server location. At  1202 , lost replication data is detected during lossy failover of backend servers. At  1204 , resubmission of the changes is requested from the history of the server location to the backend servers. At  1206 , changes from the history are resubmitted to the backend servers to replace the lost replicated data. 
     As used in this application, the terms “component” and “system” are intended to refer to a computer-related entity, either hardware, a combination of hardware and software, software, or software in execution. For example, a component can be, but is not limited to being, a process running on a processor, a processor, a hard disk drive, multiple storage drives (of optical and/or magnetic storage medium), an object, an executable, a thread of execution, a program, and/or a computer. By way of illustration, both an application running on a server and the server can be a component. One or more components can reside within a process and/or thread of execution, and a component can be localized on one computer and/or distributed between two or more computers. The word “exemplary” may be used herein to mean serving as an example, instance, or illustration. Any aspect or design described herein as “exemplary” is not necessarily to be construed as preferred or advantageous over other aspects or designs. 
     Referring now to  FIG. 13 , there is illustrated a block diagram of a computing system  1300  operable to execute computer-implemented data management systems in accordance with the disclosed architecture. In order to provide additional context for various aspects thereof,  FIG. 13  and the following discussion are intended to provide a brief, general description of a suitable computing system  1300  in which the various aspects can be implemented. While the description above is in the general context of computer-executable instructions that may run on one or more computers, those skilled in the art will recognize that a novel embodiment also can be implemented in combination with other program modules and/or as a combination of hardware and software. 
     Generally, program modules include routines, programs, components, data structures, etc., that perform particular tasks or implement particular abstract data types. Moreover, those skilled in the art will appreciate that the inventive methods can be practiced with other computer system configurations, including single-processor or multiprocessor computer systems, minicomputers, mainframe computers, as well as personal computers, hand-held computing devices, microprocessor-based or programmable consumer electronics, and the like, each of which can be operatively coupled to one or more associated devices. 
     The illustrated aspects can also be practiced in distributed computing environments where certain tasks are performed by remote processing devices that are linked through a communications network. In a distributed computing environment, program modules can be located in both local and remote memory storage devices. 
     A computer typically includes a variety of computer-readable media. Computer-readable media can be any available media that can be accessed by the computer and includes volatile and non-volatile media, removable and non-removable media. By way of example, and not limitation, computer-readable media can comprise computer storage media and communication media. Computer storage media includes volatile and non-volatile, removable and non-removable media implemented in any method or technology for storage of information such as computer-readable instructions, data structures, program modules or other data. Computer storage media includes, but is not limited to, RAM, ROM, EEPROM, flash memory or other memory technology, CD-ROM, digital video disk (DVD) or other optical disk storage, magnetic cassettes, magnetic tape, magnetic disk storage or other magnetic storage devices, or any other medium which can be used to store the desired information and which can be accessed by the computer. 
     With reference again to  FIG. 13 , the exemplary computing system  1300  for implementing various aspects includes a computer  1302  having a processing unit  1304 , a system memory  1306  and a system bus  1308 . The system bus  1308  provides an interface for system components including, but not limited to, the system memory  1306  to the processing unit  1304 . The processing unit  1304  can be any of various commercially available processors. Dual microprocessors and other multi-processor architectures may also be employed as the processing unit  1304 . 
     The system bus  1308  can be any of several types of bus structure that may further interconnect to a memory bus (with or without a memory controller), a peripheral bus, and a local bus using any of a variety of commercially available bus architectures. The system memory  1306  can include non-volatile memory (NON-VOL)  1310  and/or volatile memory  1312  (e.g., random access memory (RAM)). A basic input/output system (BIOS) can be stored in the non-volatile memory  1310  (e.g., ROM, EPROM, EEPROM, etc.), which BIOS are the basic routines that help to transfer information between elements within the computer  1302 , such as during start-up. The volatile memory  1312  can also include a high-speed RAM such as static RAM for caching data. 
     The computer  1302  further includes an internal hard disk drive (HDD)  1314  (e.g., EIDE, SATA), which internal HDD  1314  may also be configured for external use in a suitable chassis, a magnetic floppy disk drive (FDD)  1316 , (e.g., to read from or write to a removable diskette  1318 ) and an optical disk drive  1320 , (e.g., reading a CD-ROM disk  1322  or, to read from or write to other high capacity optical media such as a DVD). The HDD  1314 , FDD  1316  and optical disk drive  1320  can be connected to the system bus  1308  by a HDD interface  1324 , an FDD interface  1326  and an optical drive interface  1328 , respectively. The HDD interface  1324  for external drive implementations can include at least one or both of Universal Serial Bus (USB) and IEEE 1394 interface technologies. 
     The drives and associated computer-readable media provide nonvolatile storage of data, data structures, computer-executable instructions, and so forth. For the computer  1302 , the drives and media accommodate the storage of any data in a suitable digital format. Although the description of computer-readable media above refers to a HDD, a removable magnetic diskette (e.g., FDD), and a removable optical media such as a CD or DVD, it should be appreciated by those skilled in the art that other types of media which are readable by a computer, such as zip drives, magnetic cassettes, flash memory cards, cartridges, and the like, may also be used in the exemplary operating environment, and further, that any such media may contain computer-executable instructions for performing novel methods of the disclosed architecture. 
     A number of program modules can be stored in the drives and volatile memory  1312 , including an operating system  1330 , one or more application programs  1332 , other program modules  1334 , and program data  1336 . All or portions of the operating system, applications, modules, and/or data can also be cached in the volatile memory  1312 . It is to be appreciated that the disclosed architecture can be implemented with various commercially available operating systems or combinations of operating systems. 
     The aforementioned application programs  1332 , other program modules  1334 , and program data  1336 , when implemented as a server system, can include the history component  102 , the history  104 , the backend servers  108 , and the storage component  110  from  FIG. 1 , the frontend server system  200  and associated entities ( 206  and  208 ), the mid-tier server system  202  and associated entities ( 212  and  214 ), the replication component  302 , failover detection component  304 , resubmission component  306 , duplicate detection component  308  for the backend servers  108 , the pruning component  310  and replication feedback channel  312  for the storage component  110 , the frontend pruning component  402 , the frontend replication feedback channel  404 , the mid-tier pruning component  406 , and the mid-tier replication feedback channel  408 , for example. 
     The application programs  1332 , other program modules  1334 , and program data  1336 , when implemented as a server system, can also include methods described in  FIGS. 7-12 . 
     A user can enter commands and information into the computer  1302  through one or more wire/wireless input devices, for example, a keyboard  1338  and a pointing device, such as a mouse  1340 . Other input devices (not shown) may include a microphone, an IR remote control, a joystick, a game pad, a stylus pen, touch screen, or the like. These and other input devices are often connected to the processing unit  1304  through an input device interface  1342  that is coupled to the system bus  1308 , but can be connected by other interfaces such as a parallel port, IEEE 1394 serial port, a game port, a USB port, an IR interface, etc. 
     A monitor  1344  or other type of display device is also connected to the system bus  1308  via an interface, such as a video adaptor  1346 . In addition to the monitor  1344 , a computer typically includes other peripheral output devices (not shown), such as speakers, printers, etc. 
     The computer  1302  may operate in a networked environment using logical connections via wire and/or wireless communications to one or more remote computers, such as a remote computer(s)  1348 . The remote computer(s)  1348  can be a workstation, a server computer, a router, a personal computer, portable computer, microprocessor-based entertainment appliance, a peer device or other common network node, and typically includes many or all of the elements described relative to the computer  1302 , although, for purposes of brevity, only a memory/storage device  1350  is illustrated. The logical connections depicted include wire/wireless connectivity to a local area network (LAN)  1352  and/or larger networks, for example, a wide area network (WAN)  1354 . Such LAN and WAN networking environments are commonplace in offices and companies, and facilitate enterprise-wide computer networks, such as intranets, all of which may connect to a global communications network, for example, the Internet. 
     When used in a LAN networking environment, the computer  1302  is connected to the LAN  1352  through a wire and/or wireless communication network interface or adaptor  1356 . The adaptor  1356  can facilitate wire and/or wireless communications to the LAN  1352 , which may also include a wireless access point disposed thereon for communicating with the wireless functionality of the adaptor  1356 . 
     When used in a WAN networking environment, the computer  1302  can include a modem  1358 , or is connected to a communications server on the WAN  1354 , or has other means for establishing communications over the WAN  1354 , such as by way of the Internet. The modem  1358 , which can be internal or external and a wire and/or wireless device, is connected to the system bus  1308  via the input device interface  1342 . In a networked environment, program modules depicted relative to the computer  1302 , or portions thereof, can be stored in the remote memory/storage device  1350 . It will be appreciated that the network connections shown are exemplary and other means of establishing a communications link between the computers can be used. 
     The computer  1302  is operable to communicate with wire and wireless devices or entities using the IEEE 802 family of standards, such as wireless devices operatively disposed in wireless communication (e.g., IEEE 802.11 over-the-air modulation techniques) with, for example, a printer, scanner, desktop and/or portable computer, personal digital assistant (PDA), communications satellite, any piece of equipment or location associated with a wirelessly detectable tag (e.g., a kiosk, news stand, restroom), and telephone. This includes at least Wi-Fi (or Wireless Fidelity), WiMax, and Bluetooth™ wireless technologies. Thus, the communication can be a predefined structure as with a conventional network or simply an ad hoc communication between at least two devices. Wi-Fi networks use radio technologies called IEEE 802.11x (a, b, g, etc.) to provide secure, reliable, fast wireless connectivity. A Wi-Fi network can be used to connect computers to each other, to the Internet, and to wire networks (which use IEEE 802.3-related media and functions). 
     Referring now to  FIG. 14 , there is illustrated a schematic block diagram of an exemplary computing environment  1400  that interacts with a computer-implemented data replication system. The environment  1400  includes one or more client(s)  1402 . The client(s)  1402  can be hardware and/or software (e.g., threads, processes, computing devices). The client(s)  1402  can house cookie(s) and/or associated contextual information, for example. 
     The environment  1400  also includes one or more server(s)  1404 . The server(s)  1404  can also be hardware and/or software (e.g., threads, processes, computing devices). The servers  1404  can house threads to perform transformations by employing the architecture, for example. One possible communication between a client  1402  and a server  1404  can be in the form of a data packet adapted to be transmitted between two or more computer processes. The data packet may include a cookie and/or associated contextual information, for example. The environment  1400  includes a communication framework  1406  (e.g., a global communication network such as the Internet) that can be employed to facilitate communications between the client(s)  1402  and the server(s)  1404 . 
     Communications can be facilitated via a wire (including optical fiber) and/or wireless technology. The client(s)  1402  are operatively connected to one or more client data store(s)  1408  that can be employed to store information local to the client(s)  1402  (e.g., cookie(s) and/or associated contextual information). Similarly, the server(s)  1404  are operatively connected to one or more server data store(s)  1410  that can be employed to store information local to the servers  1404 . 
     The server data store(s)  1410  can be part of the storage component  110  for storing histories of changes. The server data store(s)  1410  can also represent the backend databases that failover, such as for messaging databases or mailboxes. The server(s)  1404  can include the frontend server system  200  and mid-tier server system  202 , and backend servers  108 , for example. 
     What has been described above includes examples of the disclosed architecture. It is, of course, not possible to describe every conceivable combination of components and/or methodologies, but one of ordinary skill in the art may recognize that many further combinations and permutations are possible. Accordingly, the novel architecture is intended to embrace all such alterations, modifications and variations that fall within the spirit and scope of the appended claims. Furthermore, to the extent that the term “includes” is used in either the detailed description or the claims, such term is intended to be inclusive in a manner similar to the term “comprising” as “comprising” is interpreted when employed as a transitional word in a claim.