INTELLIGENT CLIENT ARCHITECTURE COMPUTER SYSTEM AND METHOD

• US 20090292709A1
• Filed: 04/10/2009
• Published: 11/26/2009
• Est. Priority Date: 10/31/2003
• Status: Active Grant

• Current Assignee: Igor Tsinman, Jamie Mazur, Robert E. Mcgill
• Original Assignee: Igor Tsinman, Jamie Mazur, Robert E. Mcgill
• Inventors: Tsinman, Igor, McGill, Robert E., Mazur, Jamie
• Granted Patent: US 8,156,078 B2
• Time in Patent Office: Days
• US Class Current: 1/1
• CPC Class Codes: G06F 16/2322 using timestamps
• CPC Class Codes: G06F 16/27 Replication, distribution or synchronisation of data between databases or within a distributed database system; Distributed database system architectures therefor
• CPC Class Codes: G06F 16/273 Asynchronous replication or reconciliation
• CPC Class Codes: G06F 9/466 Transaction processing
• CPC Class Codes: Y10S 707/99952 Coherency, e.g. same view to multiple users

Abstract

A collision detection and data synchronization mechanism operates to expand the speed and capability of distributed applications. The execution environment employs collision detection and data synchronization to distribute data objects to appropriate network nodes to support local processing. The collision detection and data synchronization mechanism defines the set of processes and algorithms used to track distributed data objects and to manage changes to the distributed objects throughout a network of intelligent computing devices. Data and code are distributed to local computing devices necessitating tracking and synchronizing updates. The system and method ensures that data updates received during the course of a local transaction do not unwillingly affect the results of other transactions by notifying the local computing devices of changes to the data that are subject of the transaction. These conflicts are then resolved in the applications, and notification of the resolution is sent to the remaining intelligent computing devices.

Claims

1. A method of implementing synchronized distributed objects comprising:

a local computing device requests data from a remote computing device to be used in a transaction;

the local computing device checks local resources for the data required;

upon failing to locate the required data locally, the local computing device formats a request to the remote computing device;

the local computing device sends the request to the remote computing device;

the remote computing device receives the request and unpacks the request to remove formatting elements needed for transport;

the remote computing device interprets the data request from the local computing device by comparing the data request to the object model on the remote computing device;

the remote computing devices resolve the data request to a set of data access instructions that operate on database management software;

the database management software retrieves the requested data;

the remote computing device registers interest in the data retrieved by the local computing device that requested the data;

the remote computing device packages the data for transport to the local computing device;

the remote computing device delivers the data to the local computing device;

the local computing device receives the data and unpacks the request to remove formatting elements needed for transport;

the local computing device adds the data to local data storage resources device;

the local computing device copies the data and delivers the data to the requested transaction;

the local computing device stores the data in a transaction data cache used to support the transaction, the transaction data cache being separate from a main local data cache and separate from a main local data mass storage area;

the local computing device registers the data as used by the transaction;

the local data storage resources are updated to reflect changes made at the remote data source by other users and processes;

the local computing device operates the transaction, thereby accumulating changes in the data stored in the transaction data cache;

the changes in the data stored in the transaction data cache are compared against a log of data changes to the local data storage resources device since the remote data was retrieved;

the local computing device detects a local data collision conflict based upon the comparison of the data stored in the transaction data cache and the local data storage resources device;

the local computing device notifies the transaction that the local data collision conflict occurred;

the transaction resolves the local data collision conflict in an application-specific manner;

the local computing device formats the resolved local data collision conflict for transport to the remote computing device;

the local computing device transports the resolved local data collision conflict to the remote computing device for remote data conflict checking and long-term persistence;

the remote computing device receives the resolved local data collision conflicts and unpacks formatting elements added for transport;

the remote computing device compares the resolved local data collision conflicts to data items changed by other users or by automated processes;

the remote computing device stores the data items changed by other users or by automated processes as queued data changes;

the remote computing device detects a remote data change collision conflict based upon the comparison of the resolved local data collision conflicts and the queued data changes;

the remote computing device notifies the local computing device that a remote data change collision conflict occurred;

the local computing device forwards the notification to the transaction for resolution in an application-specific manner and sends a message to the remote computing device indicating resolution of the remote data collision conflict;

the remote computing device then detects remote data base collision conflicts based upon comparison of the results of the local data collision conflict resolutions and the persistent data store on the remote computing device

the remote computing device notifies the local computing device that a remote data base collision conflict occurred;

the local computing device forwards the notification to the transaction for resolution in an application-specific manner and sends a message to the remote computing device indicating resolution of the remote data collision conflict;

the remote computing device updates the persistent data store on the remote computing device;

the remote computing device checks a registration table to determine other computing devices that must be notified of the resolution performed by the local and remote computing devices;

the remote computing device transmits the results of the data collision conflict resolutions to the local computing device and other computing devices affected by the remote data collision resolutions; and

the local computing device and other computing devices update the local main cache based upon the data collision conflict resolution; and

the local computing device purges data from the transaction cache.

2. A method of implementing synchronized distributed objects comprising:

requesting data from a remote computing device to be delivered to a local computing device that initiated the request, the requested data to be used in a transaction;

checking local resources available to the local computing device for the data required;

formatting a data request to the remote computing device from the local computing device upon failing to locate the required data locally;

sending the data request from the local computing device to the remote computing device;

receiving the data request at the remote computing device and unpacking the data request to remove formatting elements needed for transport;

interpreting the data request using the remote computing device to compare the data request to an object model on the remote computing device;

resolving the data request to a set of data access instructions that operate on database management software;

retrieving the requested data using the database management software as a retrieval tool;

registering interest of the local computing device that requested the data;

packaging the data for transport from the remote computing device to the local computing device;

delivering the data to the local computing device;

receiving the data at the local computing device and unpacking the requested data to remove formatting elements needed for transport;

adding the data to a local storage resources device available to the local computing device;

copying the data and delivering the data to the requested transaction;

storing the data in a transaction data cache used to support the transaction, the local computing device storing the data, and the transaction data cache being separate from a main local data cache and separate from a main local data mass storage area;

registering the data as used by the transaction;

operating the transaction, thereby accumulating changes in the data stored in the transaction data cache;

comparing the changes in the data stored in the transaction data cache against a log of data changes to the local data storage resources device since the data was retrieved from the remote computing device;

detecting a local data collision conflict by using the local computing device to compare the data stored in the transaction data cache and the local data storage resources device;

notifying the transaction that the local data collision occurred;

resolving the local data collision conflict utilizing the transaction to resolve the local data collision conflict in an application-specific manner;

formatting the resolved local data collision conflict for transport from the local computing device to the remote computing device;

transporting the resolved local data collision conflict from the local computing device to the remote computing device for remote data conflict checking and long-term persistence;

receiving the resolved local data collision conflicts at the remote computing device and unpacking formatting elements that were added for transport;

comparing the resolved local data collision conflicts to data items changed by other users or by automated processes;

storing the data items changed by other users or by automated processes as queued data changes;

detecting a remote data change collision conflict by using the remote computing device to compare the resolved local data collision conflicts and the queued data changes;

detecting a remote data base collisions conflict by using the remote computing device to compare the local data change conflict resolution to the persistent data store;

sending notification of a remote data collision conflict from the remote computing device to the local computing device;

forwarding the notification from the local computing device to the transaction for resolution of the remote data collision conflict in an application-specific manner;

sending a message from the local computing device to the remote computing device indicating resolution of the remote data collision conflict;

updating the persistent data store on the remote computing device;

checking a registration table available to the remote computing device to determine if other computing devices must be notified of the resolution performed by the local computing device;

transmitting the results of the remote data collision conflict resolutions from the remote computing device to the local computing device and to other computing devices affected by the remote data collision conflict; and

updating the main cache at the local and other computing devices based upon the remote data collision conflict resolution; and

cleaning data from the transaction cache at the local device.

3. The method of implementing synchronized distributed objects of claim 2, where the step of checking local resources further comprises checking a local file system.

4. The method of implementing synchronized distributed objects of claim 3, where the step of checking local resource check further comprises checking a local data cache.

5. The method of implementing synchronized distributed objects of claim 3, where the step of requesting data from a remote computing device further comprising checking multiple remote devices to locate the data.

6. The method of implementing synchronized distributed objects of claim 5, further comprising checking a directory of multiple remote devices to locate the data and using an address provided by the directory to resolve to the remote computing device containing the data.

7. The method of implementing synchronized distributed objects of claim 2, wherein the request for data from a remote computing device is formed using a data model and object model that is duplicated between the local and remote computing devices thereby employing the syntax determined from the local model to request the needed data, and wherein the remote computing device uses an exact copy of the model to interpret the request for data.

8. The method of implementing synchronized distributed objects of claim 2, wherein the database management software resides on the same computing device that received the data request.

9. The method of implementing synchronized distributed objects of claim 2, wherein the database management software resides on a second remote computing device connected to the computing device receiving the data request.

10. The method of implementing synchronized distributed objects of claim 2, wherein registering interest of the local computing device further comprises updating the registration of interest in the data retrieved by the local computing device to persistent storage.

11. The method of implementing synchronized distributed objects of claim 10, wherein the step of updating to persistent storage further comprises indexing by a local computing device session identifier and a data identifier related to the data delivered to the local computing device.

12. The method of implementing synchronized distributed objects of claim 2, wherein the local data storage resources device is a memory data cache.

13. The method of implementing synchronized distributed objects of claim 2, wherein the local data storage resources device is a local file system.

14. The method of implementing synchronized distributed objects of claim 2, wherein the log of data changes to the local data storage resources device since the remote data was retrieved comprises a before value, an after value, and a date and time stamp for individual data items.

15. The method of implementing synchronized distributed objects of claim 2, wherein the step of the local computing device notifying the transaction that the local data collision conflict occurred further comprises the local computing device notifying the transaction of the conflicting values of the data item.

16. A method for synchronizing data for a transaction in a distributed applications network, the method comprising:

requesting, by a local computing device, data resident in a remote computing device;

copying the requested data into a transaction data cache and a main data cache of the local computing device;

accumulating changes in the data stored in the transaction data cache based on transaction processing in the local computing device;

updating the main data cache with data changes made at the remote computing device by other users or processes;

detecting local data collision conflicts based upon comparisons of the main data cache and the data changes stored in the transaction data cache;

resolving the local data collision conflicts; and

transporting results of the local data collision conflict resolutions to the remote computing device.

17. The method for synchronizing data for a transaction in a distributed applications network as recited in claim 16, further comprising:

detecting remote data collision conflicts based upon comparisons of the results of the local data collision conflict resolutions and data items changed by other users and automatic processes;

resolving the remote data collision conflicts;

detecting remote database collision conflicts based upon comparisons of the results of the local data collision conflict resolutions and a persistent data store on the remote computing device;

resolving the remote database collision conflicts;

updating the persistent data store on the remote computing device;

transmitting results of the remote data collision conflict resolutions to the local computing device and other computing devices affected by the remote data collision conflict; and

updating local data based upon the remote data collision conflict resolutions.

18. A method for accomplishing a transaction in a distributed applications network comprising:

determining a transaction process to be executed by a local computing device;

determining a transaction data set for the transaction to be executed by the local computing device;

transferring the data objects in the transaction data set from a database on a remote computing device to the local computing device;

processing the transaction at the local computer and making changes to the data set reflect the transaction processing;

resolving local data conflicts due to the changes to the data set;

committing the transaction after resolving the local data conflicts; and

resolving data conflicts between the database and the local computing device.