US11321159B2 - Interchangeable plugins for detecting conflicts between server-side data and client-side data - Google Patents

Interchangeable plugins for detecting conflicts between server-side data and client-side data Download PDF

Info

Publication number
US11321159B2
US11321159B2 US16/503,183 US201916503183A US11321159B2 US 11321159 B2 US11321159 B2 US 11321159B2 US 201916503183 A US201916503183 A US 201916503183A US 11321159 B2 US11321159 B2 US 11321159B2
Authority
US
United States
Prior art keywords
client
server
conflict
interchangeable
side data
Prior art date
Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
Active, expires
Application number
US16/503,183
Other versions
US20210004283A1 (en
Inventor
Wojciech Julian Trocki
Current Assignee (The listed assignees may be inaccurate. Google has not performed a legal analysis and makes no representation or warranty as to the accuracy of the list.)
Red Hat Inc
Original Assignee
Red Hat Inc
Priority date (The priority date is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the date listed.)
Filing date
Publication date
Application filed by Red Hat Inc filed Critical Red Hat Inc
Priority to US16/503,183 priority Critical patent/US11321159B2/en
Assigned to RED HAT, INC. reassignment RED HAT, INC. ASSIGNMENT OF ASSIGNORS INTEREST (SEE DOCUMENT FOR DETAILS). Assignors: TROCKI, WOJCIECH JULIAN
Publication of US20210004283A1 publication Critical patent/US20210004283A1/en
Application granted granted Critical
Publication of US11321159B2 publication Critical patent/US11321159B2/en
Active legal-status Critical Current
Adjusted expiration legal-status Critical

Links

Images

Classifications

    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F11/00—Error detection; Error correction; Monitoring
    • G06F11/07—Responding to the occurrence of a fault, e.g. fault tolerance
    • G06F11/0703—Error or fault processing not based on redundancy, i.e. by taking additional measures to deal with the error or fault not making use of redundancy in operation, in hardware, or in data representation
    • G06F11/079—Root cause analysis, i.e. error or fault diagnosis
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F11/00—Error detection; Error correction; Monitoring
    • G06F11/07—Responding to the occurrence of a fault, e.g. fault tolerance
    • G06F11/0703—Error or fault processing not based on redundancy, i.e. by taking additional measures to deal with the error or fault not making use of redundancy in operation, in hardware, or in data representation
    • G06F11/0706—Error or fault processing not based on redundancy, i.e. by taking additional measures to deal with the error or fault not making use of redundancy in operation, in hardware, or in data representation the processing taking place on a specific hardware platform or in a specific software environment
    • G06F11/0709—Error or fault processing not based on redundancy, i.e. by taking additional measures to deal with the error or fault not making use of redundancy in operation, in hardware, or in data representation the processing taking place on a specific hardware platform or in a specific software environment in a distributed system consisting of a plurality of standalone computer nodes, e.g. clusters, client-server systems
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F11/00—Error detection; Error correction; Monitoring
    • G06F11/07—Responding to the occurrence of a fault, e.g. fault tolerance
    • G06F11/0703—Error or fault processing not based on redundancy, i.e. by taking additional measures to deal with the error or fault not making use of redundancy in operation, in hardware, or in data representation
    • G06F11/0751—Error or fault detection not based on redundancy
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F9/00—Arrangements for program control, e.g. control units
    • G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
    • G06F9/44—Arrangements for executing specific programs
    • G06F9/445—Program loading or initiating
    • G06F9/44521—Dynamic linking or loading; Link editing at or after load time, e.g. Java class loading
    • G06F9/44526—Plug-ins; Add-ons
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F9/00—Arrangements for program control, e.g. control units
    • G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
    • G06F9/46—Multiprogramming arrangements
    • G06F9/54—Interprogram communication
    • G06F9/541—Interprogram communication via adapters, e.g. between incompatible applications
    • H—ELECTRICITY
    • H04—ELECTRIC COMMUNICATION TECHNIQUE
    • H04L—TRANSMISSION OF DIGITAL INFORMATION, e.g. TELEGRAPHIC COMMUNICATION
    • H04L67/00—Network arrangements or protocols for supporting network services or applications
    • H04L67/01—Protocols
    • H—ELECTRICITY
    • H04—ELECTRIC COMMUNICATION TECHNIQUE
    • H04L—TRANSMISSION OF DIGITAL INFORMATION, e.g. TELEGRAPHIC COMMUNICATION
    • H04L67/00—Network arrangements or protocols for supporting network services or applications
    • H04L67/34—Network arrangements or protocols for supporting network services or applications involving the movement of software or configuration parameters 
    • H04L67/42—

Definitions

  • the present disclosure relates generally to resolving data conflicts between clients and servers. More specifically, but not by way of limitation, this disclosure relates to interchangeable plugins for detecting conflicts between server-side data and client-side data.
  • a server provides services to one or more client devices. This often involves sharing data between the server and the client devices.
  • the data stored at the server side can be referred to as server-side data
  • the data stored at the client side can be referred to as client-side data.
  • the server's data may become outdated if the offline client device changes its version of the data (e.g., as a result of executing an application or user input). Either way, the result is a conflict between the server-side data and the client-side data that can lead to a variety of problems. To avoid such problems, system administrators typically employ conflict-handling mechanisms that resolve these types of conflicts.
  • FIG. 1 is a block diagram of an example of a system including interchangeable plugins for detecting conflicts between server-side data and client-side data according to some aspects.
  • FIG. 2 is a sequence diagram of an example of a process for detecting conflicts between server-side data and client-side data according to some aspects.
  • FIG. 3 is a block diagram of another example of a system including interchangeable plugins for detecting conflicts between server-side data and client-side data according to some aspects.
  • FIG. 4 is a flow chart of an example of a process for employing interchangeable plugins for detecting conflicts between server-side data and client-side data according to some aspects.
  • Client-server systems typically employ conflict-detection processes to detect conflicts between server-side data handled by servers and client-side data handled by client devices, so that these conflicts can be resolved.
  • conflict-detection processes are typically highly customized and dependent on the particular characteristics of the client-server systems.
  • the specific conflict-detection process that is employed may depend on the type of database in which the data is stored on the server side, the configuration of the fields in the database, how the server processes and stores the data in the database, and other factors.
  • system administrators often need to create custom programs that implement custom conflict-detection processes suitable to their particular client-server system, which is time consuming, expensive, and error prone.
  • client-side applications designed to interface with these servers must also be customized to adhere to the specific conflict-detection process employed by the client-server system. This tethers the client-side applications to that particular client-server system, which may be problematic if newer or better alternatives become available.
  • a client-server system may rely on a particular type of database and employ a particular conflict-detection process associated with that database. So, a developer of a client-side application may have to expend significant time and resources to customize the client-side application to adhere to the conflict-detection process associated with that particular type of database.
  • Some examples of the present disclosure overcome one or more of the abovementioned problems via a set of preprogrammed, interchangeable plugins that employ a variety of different conflict-detection strategies.
  • Each of the conflict-detection strategies can specify where a conflict is to be detected (e.g., at the client side or the server side), how a conflict is to be detected (e.g., by comparing version fields in a database or by comparing hashed versions of the data), how the conflict is to be resolved (e.g., by prioritizing the server-side data over the client-side data, or vice-versa), or any combination of these.
  • each of the interchangeable plugins can have a corresponding application module configured to be easily integrated into a client-side application.
  • the application module is a preprogrammed code library that can be incorporated into the source code of the client-side application (e.g., during development of the client-side application).
  • the application module can enable the client-side application to cooperate with the server to implement the particular conflict-detection strategy selected by the user.
  • the interchangeable plugins and/or corresponding application modules can provide for a faster, cheaper, more flexible, and less error-prone process for implementing conflict detection than traditional approaches.
  • a developer may be creating a mobile application that can interact with a server via an application programming interface (API).
  • the server can implement backend functionality for the mobile application. Part of the interaction between the mobile application and the server may involve resolving conflicts between client-side data handled by the mobile application and server-side data handled by the server.
  • the developer can access a list of preprogrammed, interchangeable plugins that implement different conflict-detection strategies.
  • at least one of the interchangeable plugins may be written using the GraphQL data query and manipulation language.
  • the developer can obtain (e.g., download) the best interchangeable plugin for the database architecture of the client-server system and easily incorporate that interchangeable plugin into the API, for example, by importing the plugin into API software. Additionally or alternatively, the developer can obtain a preprogrammed application module corresponding to the interchangeable plugin and integrate the application module into the mobile application. For example, the developer can incorporate the application module into the source code for the mobile application and then compile the source code to produce an executable version of the mobile application. After integrating the interchangeable plugin into the API and/or the application module into the mobile application, the server and the mobile application may be capable of cooperating with one another to implement the conflict-detection strategy selected by the developer.
  • the server and the mobile application may be capable of cooperating with one another to implement the conflict-detection strategy selected by the developer.
  • the interchangeable plugins and the application modules are designed to work “out of the box,” such that they require little or no customization by the user.
  • each of the interchangeable plugins may be specifically tailored for a particular database architecture, so that a user need only select the right one for his system.
  • the interchangeable plugins are further customizable using functions and objects that are abstracted from the underlying specifics (e.g., database architectures) of the client-server system, so that the interchangeable plugins and application modules can be easily used by less sophisticated users.
  • FIG. 1 is a block diagram of an example of a system 100 including interchangeable plugins 124 a - c for detecting conflicts between server-side data 114 and client-side data 106 according to some aspects.
  • the system 100 includes a developer device 116 , a server 108 , a repository 122 , and client devices 102 communicatively coupled to one another via a network 120 .
  • the network 120 can include a local area network (LAN) or a wide area network (WAN), such as the Internet.
  • LAN local area network
  • WAN wide area network
  • the developer device 116 is a client device used by a software developer 128 to create an application, such as a client-side application.
  • a client-side application is a software application configured to be executed by one or more client devices 102 , which may be mobile devices (e.g., smartphones, tablets, or e-readers) in some examples.
  • the developer device 116 may include any suitable software components for creating client-side applications, such as software development kits (SDKs), compilers, interpreters, libraries, etc.
  • the developer device 116 includes at least the source code 118 for a client-side application 104 .
  • the software developer 128 may want the client-side application 104 to interact with a server 108 (e.g., a backend server), which can perform various functionality supporting operation of the client-side application 104 . So, the software developer 128 may employ an application programming interface (API) 110 on the server 108 through which the client-side application 104 can communicate with the server 108 . For example, the software developer 128 may employ a RESTful API on the server 108 through which the client device 102 can communicate with the server 108 by issuing REST (Representational State Transfer) commands.
  • API application programming interface
  • REST Real-Representational State Transfer
  • the server 108 can be communicatively coupled to a database 112 for storing server-side data 114 to support operation of the client-side application 104 .
  • the server 108 can respond to read requests received from the client devices 102 via the API 110 by obtaining the appropriate server-side data 114 from the database 112 and transmitting it to the client devices 102 .
  • the server 108 can respond to write requests received from the client devices 102 via the API 110 by storing the appropriate information from the client devices 102 as server-side data 114 in the database 112 .
  • the software developer 129 may also want interactions between the client-side application 104 and the server 108 to include resolving conflicts between the client-side data 106 handled the client device(s) 102 and the server-side data 114 handled by the server 108 . So, the software developer 128 can access a list of preprogrammed, interchangeable plugins 124 a - c that implement different conflict-detection strategies.
  • the software developer 128 can access a repository 122 having any number and combination of interchangeable plugins 124 a - c written in any number and combination of programming languages, with each of the interchangeable plugins 124 a - c being configured for implementing a conflict-detection strategy that is different from the other interchangeable plugins 124 a - c .
  • the repository 122 may have dozens or hundreds of open-source interchangeable plugins created by numerous entities, along with descriptions of each of the interchangeable plugins.
  • Each of the interchangeable plugins 124 a - c may specify how to detect a conflict between the server-side data 114 and the client-side data 106 .
  • an interchangeable plugin 124 a may specify that a conflict is to be detected by comparing a version number associated with the server-side data 114 to a version number associated with the client-side data 106 , or by comparing a hashed version of the server-side data 114 to a hashed version of the client-side data 106 , or by comparing a date at which the client-side data was last updated to a date at which the server-side data 114 was last updated.
  • Each of the interchangeable plugins 124 a - c may additionally or alternatively specify whether conflicts are to be detected by the server 108 or by the client-side application 104 (e.g., the client devices 102 ). Further, each of the interchangeable plugins 124 a - c may additionally or alternatively specify how to resolve a detected conflict. For example, an interchangeable plugin 124 a may specify that a conflict is to be resolved by prioritizing the server-side data 114 over the client-side data 106 , or by prioritizing the client-side data 106 over the server-side data 114 .
  • the software developer 128 can then select the best interchangeable plugin 124 b for the system 100 and easily incorporate that interchangeable plugin 124 b into the API 110 , for example, by downloading the interchangeable plugin 124 b onto the server 108 and integrating the interchangeable plugin 124 b into the API 110 .
  • the software developer 128 can additionally or alternatively obtain an application module 126 b and integrate the application module 126 b into the client-side application 104 to facilitate detection of conflicts between the server-side data 114 and the client-side data 106 .
  • the software developer 128 can access a list of preprogrammed application modules 126 a - c that implement different conflict-detection strategies.
  • the list may be derived from the repository 122 , which may have any number and combination of application modules 126 a - c written in any number and combination of programming languages, with each of the application modules 126 a - c being configured for implementing a conflict-detection strategy that is different from the other application modules 126 a - c .
  • the repository 122 may have dozens or hundreds of open-source application modules created by numerous entities, along with descriptions of each of the application modules.
  • Each of the application modules 126 a - c may specify how to detect a conflict between the server-side data 114 and the client-side data 106 .
  • an application module 126 a may specify that a conflict is to be detected by comparing a version number associated with the server-side data 114 to a version number associated with the client-side data 106 , or by comparing a hashed version of the server-side data 114 to a hashed version of the client-side data 106 , or by comparing a date at which the client-side data was last updated to a date at which the server-side data 114 was last updated.
  • Each of the application modules 126 a - c may additionally or alternatively specify whether conflicts are to be detected by the server 108 or by the client-side application 104 . Further, each of the application modules 126 a - c may additionally or alternatively specify how to resolve a detected conflict. For example, an application module 126 a may specify that a conflict is to be resolved by prioritizing the server-side data 114 over the client-side data 106 , or by prioritizing the client-side data 106 over the server-side data 114 .
  • the software developer 128 can then select the best application module 126 b for the system 100 and easily incorporate that application module 126 b into the client-side application 104 , for example, by downloading the application module 126 b onto the developer device 116 and integrating the application module 126 b into the source code 118 of the client-side application 104 .
  • the developer device 116 can then compile the source code 118 to produce an executable version of the client-side application 104 for implementation on the client device(s) 102 .
  • the interchangeable plugins 124 a - c and the application modules 126 a - c may work independently or in pairs to detect conflicts. For instance, some examples may employ just an interchangeable plugin on the server 108 or just an application module in the client-side application 104 to detect conflicts between the server-side data 114 and the client-side data 106 . And other examples may employ both an interchangeable plugin and an application module working in tandem to detect such conflicts. In such cases, each of the interchangeable plugins 124 a - c may have a corresponding application module 126 a - c designed to work in tandem with the interchangeable plugin to facilitate conflict detection.
  • the interchangeable plugins 124 a - c and the application modules 126 a - c can be designed to work “out of the box,” such that they require little or no customization by the software developer 128 .
  • each of the interchangeable plugins 124 a - c may be specifically tailored for a particular system architecture, so that the software developer 128 need only select the right one for his system 100 .
  • the interchangeable plugins 124 a - c and application modules 126 a - c are further customizable using functions (e.g., routines) and objects that are abstracted from the underlying specifics of the system 100 , so that the interchangeable plugins 124 a - c and application modules 126 a - c can be easily used by less sophisticated users.
  • an interchangeable plugin 124 a can include a series of interrelated functions that accept input parameters, where the user only needs to set the appropriate values for a limited subset of the input parameters to use the interchangeable plugins 124 a - c . This can enable users that have little or no understanding of the low-level details of the system 100 to use the interchangeable plugins 124 a - c.
  • the server 108 and the client-side application 104 can cooperate with one another to implement the conflict-detection strategy selected by the software developer 128 .
  • One example of such a process is shown in FIG. 2 described below.
  • FIG. 2 is a sequence diagram of an example of a process for employing interchangeable plugins for detecting conflicts between server-side data and client-side data according to some aspects.
  • Other examples can include more steps, fewer steps, different steps, or a different combination of steps than are shown in FIG. 2 .
  • steps are described below as being implemented by the client device 102 , it should be understood that the client device 102 is executing an application module in a client-side application to implement at least some of these steps.
  • the server 108 is executing an interchangeable plugin in an API to implement at least some of these steps.
  • the process begins with the client device 102 transmitting an update command to the server 108 .
  • the update command is configured to cause the server 108 to update certain data.
  • Both the client device 102 and the server 108 should have the same version of the data—i.e., the client-side version of the data should be the same as the server-side version of the data.
  • the update command also includes a client version indicator, which indicates the version of the data that is currently stored on the client device 102 (the “client's version”).
  • the server 108 can receive the update command and responsively determine the version of the data that is currently stored in the database 112 (the “server's version”). For example, the server 108 can issue a read command to the database 112 for a server version indicator, which indicates the version of the data that is currently stored in the database 112 . Having determined the client's version and the server's version, the server 108 can then execute an interchangeable plugin to detect a conflict between the two versions. For example, the server 108 can detect that the server's version is newer than the client's version (e.g., based on the server version indicator having a higher numerical value than the client version indicator), and thus that the client's version is outdated.
  • the server's version is newer than the client's version (e.g., based on the server version indicator having a higher numerical value than the client version indicator), and thus that the client's version is outdated.
  • the server 108 can execute the interchangeable plugin to determine whether the server 108 is to resolve the conflict or the client device 102 is to resolve the conflict.
  • the interchangeable plugin specifies that the client device 102 (e.g., the client-side application) is to resolve the conflict. So, the server 108 transmits a conflict indicator to the client device 102 , where the conflict indicator indicates that a conflict occurred.
  • the conflict indicator may include the server's version of the data in some examples.
  • the client device 102 can receive the conflict indicator and responsively resolve the conflict.
  • the client device 102 can execute the application module that is part of its client-side application to resolve the conflict.
  • the client device 102 can overwrite its version of the data with the server's version of the data, thereby synchronizing the two.
  • the client device 102 can then transmit a communication back to the server 108 indicating that the conflict has been resolved (e.g., as shown in FIG. 2 ).
  • the client device 102 can determine that its version of the data is to have priority over the server's version, despite the server's version being newer. So, the client device 102 can transmit a communication back to the server 108 configured to cause the server 108 to overwrite its version of the data with the client's version. Either way, the conflict is resolved at the end of the process.
  • FIG. 3 is a block diagram of another example of a system 300 including interchangeable plugins 124 a - c for detecting conflicts between server-side data 114 and client-side data 106 according to some aspects.
  • the system 300 includes a processor 302 communicatively coupled with a memory 304 .
  • the processor 302 can include one processor or multiple processors. Non-limiting examples of the processor 302 include a Field-Programmable Gate Array (FPGA), an application-specific integrated circuit (ASIC), a microprocessor, etc.
  • the processor 302 can execute instructions 306 stored in the memory 304 to perform operations.
  • the instructions 306 can include processor-specific instructions generated by a compiler or an interpreter from code written in any suitable computer-programming language, such as C, C++, C#, etc.
  • the memory 304 can include one memory or multiple memories.
  • the memory 304 can be non-volatile and may include any type of memory that retains stored information when powered off.
  • Non-limiting examples of the memory 304 include electrically erasable and programmable read-only memory (EEPROM), flash memory, or any other type of non-volatile memory.
  • at least some of the memory can include a medium from which the processor 302 can read instructions 306 .
  • a computer-readable medium can include electronic, optical, magnetic, or other storage devices capable of providing the processor 302 with computer-readable instructions or other program code.
  • Non-limiting examples of a computer-readable medium include magnetic disk(s), memory chip(s), ROM, random-access memory (RAM), an ASIC, a configured processor, optical storage, or any other medium from which a computer processor can read the instructions 306 .
  • the processor 302 can receive an interchangeable plugin 124 b from among a plurality of interchangeable plugins 124 a - c for performing conflict detection between server-side data 114 and client-side data 106 .
  • the server-side data 114 is handled by (e.g., controlled by) a server 108 , which may or may not include the processor 302 and/or the memory 304 .
  • the client-side data 106 is handled by a client device 102 .
  • Each interchangeable plugin 124 a - c can implementing a particular conflict-detection strategy that is different than the other interchangeable plugins.
  • each interchangeable plugin 124 a - c can be selectively integrated into an API 110 through which the client device 102 is to communicate with the server 108 .
  • the processor 302 can integrate the received interchangeable plugin 124 b into the API 110 , thereby enabling the API 110 to implement the particular conflict-detection strategy 308 defined by the interchangeable plugin 124 b .
  • the processor 202 can then detect a conflict between the server-side data 114 and the client-side data 106 in accordance with the particular conflict-detection strategy 308 defined by the interchangeable plugin 124 b.
  • FIG. 4 is a flow chart of an example of a process for employing interchangeable plugins for detecting conflicts between server-side data and client-side data according to some aspects. Other examples can include more steps, fewer steps, different steps, or a different combination of steps than are shown in FIG. 4 . The steps of FIG. 4 are discussed below with reference to the components discussed above in relation to FIG. 3 .
  • a processor 302 receives an interchangeable plugin 124 b from among a plurality of interchangeable plugins 124 a - c for performing conflict detection between server-side data 114 and client-side data 106 .
  • the server-side data 114 is handled by a server 108 and the client-side data 106 is handled by a client device 102 .
  • Each interchangeable plugin 124 a - c can implementing a particular conflict-detection strategy that is different than the other interchangeable plugins. And each interchangeable plugin 124 a - c can be selectively integrated into an API 110 through which the client device 102 is to communicate with the server 108 .
  • the processor 302 can generate a list of the interchangeable plugins 124 a - c that are available to a software developer. The processor 302 can then receive a selection of a particular interchangeable plugin 124 b from the software developer via an input device, such as a keyboard, mouse, or touchscreen. Based on the selection, the processor 302 can download or otherwise obtain the selected interchangeable plugin 124 b.
  • the processor 302 integrates the received interchangeable plugin 124 b into the API 110 , which can enable the API 110 to implement the particular conflict-detection strategy 308 defined by the interchangeable plugin 124 b .
  • the processor 302 can integrate the interchangeable plugin 124 b into the API 110 by importing the interchangeable plugin 124 b into the API 110 .
  • the interchangeable plugin 124 b is a code library configured to be incorporated into source code for the API 110 . So, the processor 302 can integrate the code library of the interchangeable plugin 124 b into the source code of the API 110 .
  • the processor 302 can employ any number and combination of approaches for integrating the interchangeable plugin 124 b into the API 110 .
  • the processor 202 detects a conflict between the server-side data 114 and the client-side data 106 in accordance with the particular conflict-detection strategy 308 defined by the interchangeable plugin 124 b .
  • the particular conflict-detection strategy 308 may include a first series of steps for detecting a conflict between the server-side data 114 and the client-side data 106 . So, the processor 202 can implement the first series of steps to detect whether or not there is a conflict.
  • the particular conflict-detection strategy 308 may also include a second series of steps for resolving the conflict between the server-side data 114 and the client-side data 106 . So, the processor 202 can implement the second series of steps to resolve the conflict, in response to detecting the conflict.

Abstract

Conflicts can be detected between server-side data and client-side data using interchangeable plugins. In one example, a system can receive an interchangeable plugin from among a group of interchangeable plugins for performing conflict detection between server-side data handled by a server and client-side data handled by a client device. Each interchangeable plugin can implement a particular conflict-detection strategy that is different than the other interchangeable plugins and can be selectively integratable into an application programming interface (API) through which the client device is to communicate with the server. The system can integrate the interchangeable plugin into the API to enable the API to implement the particular conflict-detection strategy defined by the interchangeable plugin. The system can then detect a conflict between the server-side data and the client-side data in accordance with the particular conflict-detection strategy defined by the interchangeable plugin.

Description

TECHNICAL FIELD
The present disclosure relates generally to resolving data conflicts between clients and servers. More specifically, but not by way of limitation, this disclosure relates to interchangeable plugins for detecting conflicts between server-side data and client-side data.
BACKGROUND
In a typical client-server architecture, a server provides services to one or more client devices. This often involves sharing data between the server and the client devices. The data stored at the server side can be referred to as server-side data, and the data stored at the client side can be referred to as client-side data. It is typically desirable for the server-side data to match the client-side data so that the two are in synch. But for a variety of reasons, differences can arise between the server-side data and the client-side data, resulting in a conflict between the two. For example, a client device may lose Internet access for a period of time. While the client devices is offline, another client device may submit a request to the server that causes the server-side data to change, resulting in the offline client device having outdated data. Alternatively, the server's data may become outdated if the offline client device changes its version of the data (e.g., as a result of executing an application or user input). Either way, the result is a conflict between the server-side data and the client-side data that can lead to a variety of problems. To avoid such problems, system administrators typically employ conflict-handling mechanisms that resolve these types of conflicts.
BRIEF DESCRIPTION OF THE DRAWINGS
FIG. 1 is a block diagram of an example of a system including interchangeable plugins for detecting conflicts between server-side data and client-side data according to some aspects.
FIG. 2 is a sequence diagram of an example of a process for detecting conflicts between server-side data and client-side data according to some aspects.
FIG. 3 is a block diagram of another example of a system including interchangeable plugins for detecting conflicts between server-side data and client-side data according to some aspects.
FIG. 4 is a flow chart of an example of a process for employing interchangeable plugins for detecting conflicts between server-side data and client-side data according to some aspects.
 DETAILED DESCRIPTION
Client-server systems typically employ conflict-detection processes to detect conflicts between server-side data handled by servers and client-side data handled by client devices, so that these conflicts can be resolved. But these conflict-detection processes are typically highly customized and dependent on the particular characteristics of the client-server systems. For example, the specific conflict-detection process that is employed may depend on the type of database in which the data is stored on the server side, the configuration of the fields in the database, how the server processes and stores the data in the database, and other factors. As a result, system administrators often need to create custom programs that implement custom conflict-detection processes suitable to their particular client-server system, which is time consuming, expensive, and error prone. Further, client-side applications designed to interface with these servers must also be customized to adhere to the specific conflict-detection process employed by the client-server system. This tethers the client-side applications to that particular client-server system, which may be problematic if newer or better alternatives become available. For example, a client-server system may rely on a particular type of database and employ a particular conflict-detection process associated with that database. So, a developer of a client-side application may have to expend significant time and resources to customize the client-side application to adhere to the conflict-detection process associated with that particular type of database. If a better option subsequently becomes available (e.g., a database that is cheaper, faster, or less error-prone), it may be too costly to update the application to making switching databases feasible. This inflexibility impedes progress and results in costly, outdated, and suboptimal applications.
Some examples of the present disclosure overcome one or more of the abovementioned problems via a set of preprogrammed, interchangeable plugins that employ a variety of different conflict-detection strategies. Each of the conflict-detection strategies can specify where a conflict is to be detected (e.g., at the client side or the server side), how a conflict is to be detected (e.g., by comparing version fields in a database or by comparing hashed versions of the data), how the conflict is to be resolved (e.g., by prioritizing the server-side data over the client-side data, or vice-versa), or any combination of these. A user can select whichever of the interchangeable plugins has the conflict-detection strategy that is most suitable for its client-server system and easily integrate the plugin into the client-server system to facilitate conflict detection and resolution. Additionally, each of the interchangeable plugins can have a corresponding application module configured to be easily integrated into a client-side application. The application module is a preprogrammed code library that can be incorporated into the source code of the client-side application (e.g., during development of the client-side application). The application module can enable the client-side application to cooperate with the server to implement the particular conflict-detection strategy selected by the user. The interchangeable plugins and/or corresponding application modules can provide for a faster, cheaper, more flexible, and less error-prone process for implementing conflict detection than traditional approaches.
As one particular example, a developer may be creating a mobile application that can interact with a server via an application programming interface (API). The server can implement backend functionality for the mobile application. Part of the interaction between the mobile application and the server may involve resolving conflicts between client-side data handled by the mobile application and server-side data handled by the server. To effectuate this type of conflict resolution, the developer can access a list of preprogrammed, interchangeable plugins that implement different conflict-detection strategies. In some examples, at least one of the interchangeable plugins may be written using the GraphQL data query and manipulation language. The developer can obtain (e.g., download) the best interchangeable plugin for the database architecture of the client-server system and easily incorporate that interchangeable plugin into the API, for example, by importing the plugin into API software. Additionally or alternatively, the developer can obtain a preprogrammed application module corresponding to the interchangeable plugin and integrate the application module into the mobile application. For example, the developer can incorporate the application module into the source code for the mobile application and then compile the source code to produce an executable version of the mobile application. After integrating the interchangeable plugin into the API and/or the application module into the mobile application, the server and the mobile application may be capable of cooperating with one another to implement the conflict-detection strategy selected by the developer.
In some examples, the interchangeable plugins and the application modules are designed to work “out of the box,” such that they require little or no customization by the user. For example, each of the interchangeable plugins may be specifically tailored for a particular database architecture, so that a user need only select the right one for his system. And in some examples, the interchangeable plugins are further customizable using functions and objects that are abstracted from the underlying specifics (e.g., database architectures) of the client-server system, so that the interchangeable plugins and application modules can be easily used by less sophisticated users.
These illustrative examples are given to introduce the reader to the general subject matter discussed here and are not intended to limit the scope of the disclosed concepts. The following sections describe various additional features and examples with reference to the drawings in which like numerals indicate like elements but, like the illustrative examples, should not be used to limit the present disclosure.
FIG. 1 is a block diagram of an example of a system 100 including interchangeable plugins 124 a-c for detecting conflicts between server-side data 114 and client-side data 106 according to some aspects. The system 100 includes a developer device 116, a server 108, a repository 122, and client devices 102 communicatively coupled to one another via a network 120. The network 120 can include a local area network (LAN) or a wide area network (WAN), such as the Internet.
The developer device 116 is a client device used by a software developer 128 to create an application, such as a client-side application. A client-side application is a software application configured to be executed by one or more client devices 102, which may be mobile devices (e.g., smartphones, tablets, or e-readers) in some examples. The developer device 116 may include any suitable software components for creating client-side applications, such as software development kits (SDKs), compilers, interpreters, libraries, etc. In this example, the developer device 116 includes at least the source code 118 for a client-side application 104.
The software developer 128 may want the client-side application 104 to interact with a server 108 (e.g., a backend server), which can perform various functionality supporting operation of the client-side application 104. So, the software developer 128 may employ an application programming interface (API) 110 on the server 108 through which the client-side application 104 can communicate with the server 108. For example, the software developer 128 may employ a RESTful API on the server 108 through which the client device 102 can communicate with the server 108 by issuing REST (Representational State Transfer) commands.
The server 108 can be communicatively coupled to a database 112 for storing server-side data 114 to support operation of the client-side application 104. For example, the server 108 can respond to read requests received from the client devices 102 via the API 110 by obtaining the appropriate server-side data 114 from the database 112 and transmitting it to the client devices 102. Alternatively, the server 108 can respond to write requests received from the client devices 102 via the API 110 by storing the appropriate information from the client devices 102 as server-side data 114 in the database 112.
In some examples, the software developer 129 may also want interactions between the client-side application 104 and the server 108 to include resolving conflicts between the client-side data 106 handled the client device(s) 102 and the server-side data 114 handled by the server 108. So, the software developer 128 can access a list of preprogrammed, interchangeable plugins 124 a-c that implement different conflict-detection strategies. For example, the software developer 128 can access a repository 122 having any number and combination of interchangeable plugins 124 a-c written in any number and combination of programming languages, with each of the interchangeable plugins 124 a-c being configured for implementing a conflict-detection strategy that is different from the other interchangeable plugins 124 a-c. The repository 122 may have dozens or hundreds of open-source interchangeable plugins created by numerous entities, along with descriptions of each of the interchangeable plugins.
Each of the interchangeable plugins 124 a-c may specify how to detect a conflict between the server-side data 114 and the client-side data 106. For example, an interchangeable plugin 124 a may specify that a conflict is to be detected by comparing a version number associated with the server-side data 114 to a version number associated with the client-side data 106, or by comparing a hashed version of the server-side data 114 to a hashed version of the client-side data 106, or by comparing a date at which the client-side data was last updated to a date at which the server-side data 114 was last updated. Each of the interchangeable plugins 124 a-c may additionally or alternatively specify whether conflicts are to be detected by the server 108 or by the client-side application 104 (e.g., the client devices 102). Further, each of the interchangeable plugins 124 a-c may additionally or alternatively specify how to resolve a detected conflict. For example, an interchangeable plugin 124 a may specify that a conflict is to be resolved by prioritizing the server-side data 114 over the client-side data 106, or by prioritizing the client-side data 106 over the server-side data 114. The software developer 128 can then select the best interchangeable plugin 124 b for the system 100 and easily incorporate that interchangeable plugin 124 b into the API 110, for example, by downloading the interchangeable plugin 124 b onto the server 108 and integrating the interchangeable plugin 124 b into the API 110.
In some examples, the software developer 128 can additionally or alternatively obtain an application module 126 b and integrate the application module 126 b into the client-side application 104 to facilitate detection of conflicts between the server-side data 114 and the client-side data 106. For example, the software developer 128 can access a list of preprogrammed application modules 126 a-c that implement different conflict-detection strategies. The list may be derived from the repository 122, which may have any number and combination of application modules 126 a-c written in any number and combination of programming languages, with each of the application modules 126 a-c being configured for implementing a conflict-detection strategy that is different from the other application modules 126 a-c. The repository 122 may have dozens or hundreds of open-source application modules created by numerous entities, along with descriptions of each of the application modules.
Each of the application modules 126 a-c may specify how to detect a conflict between the server-side data 114 and the client-side data 106. For example, an application module 126 a may specify that a conflict is to be detected by comparing a version number associated with the server-side data 114 to a version number associated with the client-side data 106, or by comparing a hashed version of the server-side data 114 to a hashed version of the client-side data 106, or by comparing a date at which the client-side data was last updated to a date at which the server-side data 114 was last updated. Each of the application modules 126 a-c may additionally or alternatively specify whether conflicts are to be detected by the server 108 or by the client-side application 104. Further, each of the application modules 126 a-c may additionally or alternatively specify how to resolve a detected conflict. For example, an application module 126 a may specify that a conflict is to be resolved by prioritizing the server-side data 114 over the client-side data 106, or by prioritizing the client-side data 106 over the server-side data 114. The software developer 128 can then select the best application module 126 b for the system 100 and easily incorporate that application module 126 b into the client-side application 104, for example, by downloading the application module 126 b onto the developer device 116 and integrating the application module 126 b into the source code 118 of the client-side application 104. The developer device 116 can then compile the source code 118 to produce an executable version of the client-side application 104 for implementation on the client device(s) 102.
The interchangeable plugins 124 a-c and the application modules 126 a-c may work independently or in pairs to detect conflicts. For instance, some examples may employ just an interchangeable plugin on the server 108 or just an application module in the client-side application 104 to detect conflicts between the server-side data 114 and the client-side data 106. And other examples may employ both an interchangeable plugin and an application module working in tandem to detect such conflicts. In such cases, each of the interchangeable plugins 124 a-c may have a corresponding application module 126 a-c designed to work in tandem with the interchangeable plugin to facilitate conflict detection.
The interchangeable plugins 124 a-c and the application modules 126 a-c can be designed to work “out of the box,” such that they require little or no customization by the software developer 128. For example, each of the interchangeable plugins 124 a-c may be specifically tailored for a particular system architecture, so that the software developer 128 need only select the right one for his system 100. And in some examples, the interchangeable plugins 124 a-c and application modules 126 a-c are further customizable using functions (e.g., routines) and objects that are abstracted from the underlying specifics of the system 100, so that the interchangeable plugins 124 a-c and application modules 126 a-c can be easily used by less sophisticated users. For example, an interchangeable plugin 124 a can include a series of interrelated functions that accept input parameters, where the user only needs to set the appropriate values for a limited subset of the input parameters to use the interchangeable plugins 124 a-c. This can enable users that have little or no understanding of the low-level details of the system 100 to use the interchangeable plugins 124 a-c.
After integrating an interchangeable plugin 124 a-c into the API 110 and/or an application module 126 a-c into a client-side application 104, the server 108 and the client-side application 104 can cooperate with one another to implement the conflict-detection strategy selected by the software developer 128. One example of such a process is shown in FIG. 2 described below.
FIG. 2 is a sequence diagram of an example of a process for employing interchangeable plugins for detecting conflicts between server-side data and client-side data according to some aspects. Other examples can include more steps, fewer steps, different steps, or a different combination of steps than are shown in FIG. 2. While various steps are described below as being implemented by the client device 102, it should be understood that the client device 102 is executing an application module in a client-side application to implement at least some of these steps. Likewise, while various steps are described below as being implemented by the server 108, it should be understood that the server 108 is executing an interchangeable plugin in an API to implement at least some of these steps.
As shown, the process begins with the client device 102 transmitting an update command to the server 108. The update command is configured to cause the server 108 to update certain data. Both the client device 102 and the server 108 should have the same version of the data—i.e., the client-side version of the data should be the same as the server-side version of the data. To help prevent conflicts, the update command also includes a client version indicator, which indicates the version of the data that is currently stored on the client device 102 (the “client's version”).
The server 108 can receive the update command and responsively determine the version of the data that is currently stored in the database 112 (the “server's version”). For example, the server 108 can issue a read command to the database 112 for a server version indicator, which indicates the version of the data that is currently stored in the database 112. Having determined the client's version and the server's version, the server 108 can then execute an interchangeable plugin to detect a conflict between the two versions. For example, the server 108 can detect that the server's version is newer than the client's version (e.g., based on the server version indicator having a higher numerical value than the client version indicator), and thus that the client's version is outdated.
After detecting the conflict, the server 108 can execute the interchangeable plugin to determine whether the server 108 is to resolve the conflict or the client device 102 is to resolve the conflict. In this example, the interchangeable plugin specifies that the client device 102 (e.g., the client-side application) is to resolve the conflict. So, the server 108 transmits a conflict indicator to the client device 102, where the conflict indicator indicates that a conflict occurred. The conflict indicator may include the server's version of the data in some examples.
The client device 102 can receive the conflict indicator and responsively resolve the conflict. For example, the client device 102 can execute the application module that is part of its client-side application to resolve the conflict. In one such example, the client device 102 can overwrite its version of the data with the server's version of the data, thereby synchronizing the two. The client device 102 can then transmit a communication back to the server 108 indicating that the conflict has been resolved (e.g., as shown in FIG. 2). Alternatively, the client device 102 can determine that its version of the data is to have priority over the server's version, despite the server's version being newer. So, the client device 102 can transmit a communication back to the server 108 configured to cause the server 108 to overwrite its version of the data with the client's version. Either way, the conflict is resolved at the end of the process.
The process described above is just one possible example of conflict detection and resolution, and numerous modifications and variations are contemplated within the scope of this disclosure. For instance, an alternative example may involve the client device 102 detecting the conflict, server 108 resolving the conflict, or both of these.
FIG. 3 is a block diagram of another example of a system 300 including interchangeable plugins 124 a-c for detecting conflicts between server-side data 114 and client-side data 106 according to some aspects. The system 300 includes a processor 302 communicatively coupled with a memory 304. The processor 302 can include one processor or multiple processors. Non-limiting examples of the processor 302 include a Field-Programmable Gate Array (FPGA), an application-specific integrated circuit (ASIC), a microprocessor, etc. The processor 302 can execute instructions 306 stored in the memory 304 to perform operations. In some examples, the instructions 306 can include processor-specific instructions generated by a compiler or an interpreter from code written in any suitable computer-programming language, such as C, C++, C#, etc.
The memory 304 can include one memory or multiple memories. The memory 304 can be non-volatile and may include any type of memory that retains stored information when powered off. Non-limiting examples of the memory 304 include electrically erasable and programmable read-only memory (EEPROM), flash memory, or any other type of non-volatile memory. In some examples, at least some of the memory can include a medium from which the processor 302 can read instructions 306. A computer-readable medium can include electronic, optical, magnetic, or other storage devices capable of providing the processor 302 with computer-readable instructions or other program code. Non-limiting examples of a computer-readable medium include magnetic disk(s), memory chip(s), ROM, random-access memory (RAM), an ASIC, a configured processor, optical storage, or any other medium from which a computer processor can read the instructions 306.
In some examples, the processor 302 can receive an interchangeable plugin 124 b from among a plurality of interchangeable plugins 124 a-c for performing conflict detection between server-side data 114 and client-side data 106. The server-side data 114 is handled by (e.g., controlled by) a server 108, which may or may not include the processor 302 and/or the memory 304. The client-side data 106 is handled by a client device 102. Each interchangeable plugin 124 a-c can implementing a particular conflict-detection strategy that is different than the other interchangeable plugins. And each interchangeable plugin 124 a-c can be selectively integrated into an API 110 through which the client device 102 is to communicate with the server 108.
After receiving the interchangeable plugin 124 b, the processor 302 can integrate the received interchangeable plugin 124 b into the API 110, thereby enabling the API 110 to implement the particular conflict-detection strategy 308 defined by the interchangeable plugin 124 b. The processor 202 can then detect a conflict between the server-side data 114 and the client-side data 106 in accordance with the particular conflict-detection strategy 308 defined by the interchangeable plugin 124 b.
FIG. 4 is a flow chart of an example of a process for employing interchangeable plugins for detecting conflicts between server-side data and client-side data according to some aspects. Other examples can include more steps, fewer steps, different steps, or a different combination of steps than are shown in FIG. 4. The steps of FIG. 4 are discussed below with reference to the components discussed above in relation to FIG. 3.
In block 402, a processor 302 receives an interchangeable plugin 124 b from among a plurality of interchangeable plugins 124 a-c for performing conflict detection between server-side data 114 and client-side data 106. The server-side data 114 is handled by a server 108 and the client-side data 106 is handled by a client device 102.
Each interchangeable plugin 124 a-c can implementing a particular conflict-detection strategy that is different than the other interchangeable plugins. And each interchangeable plugin 124 a-c can be selectively integrated into an API 110 through which the client device 102 is to communicate with the server 108.
As one particular example, the processor 302 can generate a list of the interchangeable plugins 124 a-c that are available to a software developer. The processor 302 can then receive a selection of a particular interchangeable plugin 124 b from the software developer via an input device, such as a keyboard, mouse, or touchscreen. Based on the selection, the processor 302 can download or otherwise obtain the selected interchangeable plugin 124 b.
In block 404, the processor 302 integrates the received interchangeable plugin 124 b into the API 110, which can enable the API 110 to implement the particular conflict-detection strategy 308 defined by the interchangeable plugin 124 b. In some examples, the processor 302 can integrate the interchangeable plugin 124 b into the API 110 by importing the interchangeable plugin 124 b into the API 110. In other examples, the interchangeable plugin 124 b is a code library configured to be incorporated into source code for the API 110. So, the processor 302 can integrate the code library of the interchangeable plugin 124 b into the source code of the API 110. The processor 302 can employ any number and combination of approaches for integrating the interchangeable plugin 124 b into the API 110.
In block 406, the processor 202 detects a conflict between the server-side data 114 and the client-side data 106 in accordance with the particular conflict-detection strategy 308 defined by the interchangeable plugin 124 b. For example, the particular conflict-detection strategy 308 may include a first series of steps for detecting a conflict between the server-side data 114 and the client-side data 106. So, the processor 202 can implement the first series of steps to detect whether or not there is a conflict. The particular conflict-detection strategy 308 may also include a second series of steps for resolving the conflict between the server-side data 114 and the client-side data 106. So, the processor 202 can implement the second series of steps to resolve the conflict, in response to detecting the conflict.
The foregoing description of certain examples, including illustrated examples, has been presented only for the purpose of illustration and description and is not intended to be exhaustive or to limit the disclosure to the precise forms disclosed. Numerous modifications, adaptations, and uses thereof will be apparent to those skilled in the art without departing from the scope of the disclosure. For instance, any example(s) described herein can be combined with any other example(s) to yield further examples.

Claims (20)

The invention claimed is:
1. A system comprising:
a processor; and
a memory including instructions that are executable by the processor for causing the processor to:
receive an interchangeable plugin from among a plurality of interchangeable plugins for performing conflict detection between server-side data handled by a server and client-side data handled by a client device, wherein the client-side data and the server-side data correspond to a client-side application, each interchangeable plugin being configured for implementing a particular conflict-detection strategy that is different than the other interchangeable plugins and being selectively integratable into an application programming interface (API) of the server to facilitate operation of the client-side application, wherein the interchangeable plugin is associated with a corresponding application module configured to be integrated into the client-side application for facilitating conflict detection between the client-side data and the server-side data in accordance with the particular conflict-detect strategy of the interchangeable plugin;
integrate the interchangeable plugin into the API to enable the API to implement the particular conflict-detection strategy defined by the interchangeable plugin; and
detect a conflict between the server-side data and the client-side data in accordance with the particular conflict-detection strategy defined by the interchangeable plugin.
2. The system of claim 1, wherein the particular conflict-detection strategy further specifies how to detect the conflict between the server-side data and the client-side data.
3. The system of claim 2, wherein the particular conflict-detection strategy includes a setting that further specifies whether the conflict is to be detected by the server or by the client device.
4. The system of claim 1, wherein the particular conflict-detection strategy specifies how to resolve the conflict between the server-side data and the client-side data.
5. The system of claim 1, wherein the corresponding application module includes a code library configured to be incorporated into source code of the client-side application for enabling the client-side application to cooperate with the server to effectuate the particular conflict-detection strategy.
6. The system of claim 1, wherein the client-side application is a native mobile application, the client device is a mobile device, and the server is configured to implement backend functionality for the mobile application.
7. The system of claim 1, wherein the plurality of interchangeable plugins are created by a plurality of entities.
8. The system of claim 1, wherein the particular conflict-detection strategy indicates that the conflict is to be detected by comparing hashed versions of the server-side data and the client-side data.
9. The system of claim 1, wherein the particular conflict-detection strategy indicates that the conflict is to be detected by comparing a first date associated with the server-side data with a second date associated with the client-side data.
10. The system of claim 1, wherein the particular conflict-detection strategy indicates that the conflict is to be resolved by prioritizing the client-side data over the server-side data.
11. A method comprising:
receiving, by a processor, an interchangeable plugin from among a plurality of interchangeable plugins for performing conflict detection between server-side data handled by a server and client-side data handled by a client device, wherein the client-side data and the server-side data correspond to a client-side application, each interchangeable plugin being configured for implementing a particular conflict-detection strategy that is different than the other interchangeable plugins and being selectively integratable into an application programming interface (API) of the server to facilitate operation of the client-side application, wherein the interchangeable plugin is associated with a corresponding application module configured to be integrated into the client-side application for facilitating conflict detection between the client-side data and the server-side data in accordance with the particular conflict-detect strategy of the interchangeable plugin;
integrating, by the processor, the interchangeable plugin into the API to enable the API to implement the particular conflict-detection strategy defined by the interchangeable plugin; and
detecting, by the processor, a conflict between the server-side data and the client-side data in accordance with the particular conflict-detection strategy defined by the interchangeable plugin.
12. The method of claim 11, wherein the particular conflict-detection strategy further specifies how to detect the conflict between the server-side data and the client-side data.
13. The method of claim 12, wherein the particular conflict-detection strategy includes a setting that further specifies whether the conflict is to be detected by the server or by the client device.
14. The method of claim 13, wherein the particular conflict-detection strategy specifies how to resolve the conflict between the server-side data and the client-side data.
15. The method of claim 11, wherein the corresponding application module includes a code library configured to be incorporated into source code of the client-side application for enabling the client-side application to cooperate with the server and thereby effectuate the particular conflict-detection strategy.
16. The method of claim 11, wherein the client-side application is a mobile application, the client device is a mobile device, and the server is configured to implement functionality supporting the mobile application.
17. The method of claim 11, wherein the plurality of interchangeable plugins are created by a plurality of entities.
18. A non-transitory computer-readable medium comprising program code that is executable by a processor for causing the processor to:
receive an interchangeable plugin from among a plurality of interchangeable plugins for performing conflict detection between server-side data handled by a server and client-side data handled by a client device, wherein the client-side data and the server-side data correspond to a client-side application, each interchangeable plugin being configured for implementing a particular conflict-detection strategy that is different than the other interchangeable plugins and being selectively integratable into an application programming interface (API) of the server to facilitate operation of the client-side application, wherein the interchangeable plugin is associated with a corresponding application module configured to be integrated into the client-side application for facilitating conflict detection between the client-side data and the server-side data in accordance with the particular conflict-detect strategy of the interchangeable plugin;
integrate the interchangeable plugin into the API to enable the API to implement the particular conflict-detection strategy defined by the interchangeable plugin; and
detect a conflict between the server-side data and the client-side data in accordance with the particular conflict-detection strategy defined by the interchangeable plugin.
19. The non-transitory computer-readable medium of claim 18, wherein the particular conflict-detection strategy further specifies whether the conflict is to be detected by the server or by the client device.
20. The non-transitory computer-readable medium of claim 18, wherein the corresponding application module includes a code library configured to be incorporated into source code of the client-side application for enabling the client-side application to cooperate with the server and thereby effectuate the particular conflict-detection strategy.
US16/503,183 2019-07-03 2019-07-03 Interchangeable plugins for detecting conflicts between server-side data and client-side data Active 2039-12-04 US11321159B2 (en)

Priority Applications (1)

Application Number Priority Date Filing Date Title
US16/503,183 US11321159B2 (en) 2019-07-03 2019-07-03 Interchangeable plugins for detecting conflicts between server-side data and client-side data

Applications Claiming Priority (1)

Application Number Priority Date Filing Date Title
US16/503,183 US11321159B2 (en) 2019-07-03 2019-07-03 Interchangeable plugins for detecting conflicts between server-side data and client-side data

Publications (2)

Publication Number Publication Date
US20210004283A1 US20210004283A1 (en) 2021-01-07
US11321159B2 true US11321159B2 (en) 2022-05-03

Family

ID=74066422

Family Applications (1)

Application Number Title Priority Date Filing Date
US16/503,183 Active 2039-12-04 US11321159B2 (en) 2019-07-03 2019-07-03 Interchangeable plugins for detecting conflicts between server-side data and client-side data

Country Status (1)

Country Link
US (1) US11321159B2 (en)

Families Citing this family (1)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
CN112860346B (en) * 2021-03-05 2023-04-28 成都云隆科技有限公司 Plug-in desktop client system and access method thereof

Citations (15)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US6393434B1 (en) * 1999-09-14 2002-05-21 International Business Machines Corporation Method and system for synchronizing data using fine-grained synchronization plans
US20070088707A1 (en) * 2004-09-15 2007-04-19 Scott Durgin Method for providing extensible software components within a distributed synchronization system
US20070277115A1 (en) * 2006-05-23 2007-11-29 Bhp Billiton Innovation Pty Ltd. Method and system for providing a graphical workbench environment with intelligent plug-ins for processing and/or analyzing sub-surface data
US7509638B2 (en) * 2004-08-02 2009-03-24 International Business Machines Corporation Method and apparatus for providing a pluggable and extendable J2EE architecture
US7512638B2 (en) 2003-08-21 2009-03-31 Microsoft Corporation Systems and methods for providing conflict handling for peer-to-peer synchronization of units of information manageable by a hardware/software interface system
US7559034B1 (en) * 2000-10-19 2009-07-07 DG FastChannel, Inc. Method and system for using a hyperlink, banner, or graphical icon to initiate the overlaying of an object on a window
US20100281487A1 (en) * 2009-05-03 2010-11-04 Research In Motion Limited Systems and methods for mobility server administration
US7840633B2 (en) * 2004-01-21 2010-11-23 Computer Associates Think, Inc. Communicating messages between components in a client/server environment using an object broker
US8161107B2 (en) * 2008-12-29 2012-04-17 Microsoft Corporation Roaming personal information items across multiple computing devices using an IMAP server
US8776166B1 (en) * 2006-07-17 2014-07-08 Juniper Networks, Inc. Plug-in based policy evaluation
US9336228B2 (en) * 2013-12-18 2016-05-10 Verizon Patent And Licensing Inc. Synchronization of program code between revision management applications utilizing different version-control architectures
US20170161313A1 (en) 2015-12-08 2017-06-08 Sap Se Detection and Resolution of Conflicts in Data Synchronization
US9710673B2 (en) 2013-01-18 2017-07-18 Apple Inc. Conflict resolution for keychain syncing
CN109587212A (en) 2018-10-31 2019-04-05 武汉艺果互动科技股份有限公司 A kind of micro services architecture design method based on GraphQL, equipment and storage equipment
US10740297B2 (en) * 2015-12-17 2020-08-11 Box, Inc. Adaptive tool selection for conflict resolution in a multi-session collaboration setting

Patent Citations (16)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US6393434B1 (en) * 1999-09-14 2002-05-21 International Business Machines Corporation Method and system for synchronizing data using fine-grained synchronization plans
US7559034B1 (en) * 2000-10-19 2009-07-07 DG FastChannel, Inc. Method and system for using a hyperlink, banner, or graphical icon to initiate the overlaying of an object on a window
US7512638B2 (en) 2003-08-21 2009-03-31 Microsoft Corporation Systems and methods for providing conflict handling for peer-to-peer synchronization of units of information manageable by a hardware/software interface system
US7840633B2 (en) * 2004-01-21 2010-11-23 Computer Associates Think, Inc. Communicating messages between components in a client/server environment using an object broker
US7509638B2 (en) * 2004-08-02 2009-03-24 International Business Machines Corporation Method and apparatus for providing a pluggable and extendable J2EE architecture
US20070088707A1 (en) * 2004-09-15 2007-04-19 Scott Durgin Method for providing extensible software components within a distributed synchronization system
US20070277115A1 (en) * 2006-05-23 2007-11-29 Bhp Billiton Innovation Pty Ltd. Method and system for providing a graphical workbench environment with intelligent plug-ins for processing and/or analyzing sub-surface data
US8776166B1 (en) * 2006-07-17 2014-07-08 Juniper Networks, Inc. Plug-in based policy evaluation
US8161107B2 (en) * 2008-12-29 2012-04-17 Microsoft Corporation Roaming personal information items across multiple computing devices using an IMAP server
US20100281487A1 (en) * 2009-05-03 2010-11-04 Research In Motion Limited Systems and methods for mobility server administration
US9201669B2 (en) * 2009-05-03 2015-12-01 Blackberry Limited Systems and methods for mobility server administration
US9710673B2 (en) 2013-01-18 2017-07-18 Apple Inc. Conflict resolution for keychain syncing
US9336228B2 (en) * 2013-12-18 2016-05-10 Verizon Patent And Licensing Inc. Synchronization of program code between revision management applications utilizing different version-control architectures
US20170161313A1 (en) 2015-12-08 2017-06-08 Sap Se Detection and Resolution of Conflicts in Data Synchronization
US10740297B2 (en) * 2015-12-17 2020-08-11 Box, Inc. Adaptive tool selection for conflict resolution in a multi-session collaboration setting
CN109587212A (en) 2018-10-31 2019-04-05 武汉艺果互动科技股份有限公司 A kind of micro services architecture design method based on GraphQL, equipment and storage equipment

Non-Patent Citations (3)

* Cited by examiner, † Cited by third party
Title
"Developing a Data Sync App," Red Hat, Inc., 2019, https://access.redhat.com/documentation/en-us/red_heat_mobile_developer_services/1/html-single/developing_a_data_sync_app/index.
Kalapos, G., "Database Synchronization Between Mobile Devices and Classical Relational Database Management Systems," Faculty of Engineering and Natural Sciences, Jan. 2015, https://kalapos.net/Media/Default/pds/Db_sync_between_mobile_devices_and_classical_dbmss_Gergely_Kalapos_Public.pdf.
McCormack, D., "Data Synchronization," objc.io, Mar. 2014, https://www.objc.io/issues/10-syncing-data/data-synchronization/#conflict-resolution.

Also Published As

Publication number Publication date
US20210004283A1 (en) 2021-01-07

Similar Documents

Publication Publication Date Title
US11106455B2 (en) Integration of containers with external elements
US11373127B2 (en) Connection multiplexing for a parallel processing environment
US11467816B1 (en) Method and system of running an application
US10929117B2 (en) Container image building using shared resources
US10216514B2 (en) Identification of a component for upgrade
EP2955627B1 (en) Managing versions of components of a software suite
US20190332367A1 (en) Method and apparatus for installing application
US10305731B2 (en) System and method for provisioning cloud services across heterogeneous environments using partitioned provisioning instructions stored on a configuration management server
CN107291481B (en) Component updating method, device and system
US20150154077A1 (en) Automated application update checks based on unexpected errors and crashes
US10635779B2 (en) Devices, methods and computer readable mediums for flexible delivery and deployment of medical applications
US10514940B2 (en) Virtual application package reconstruction
US11321159B2 (en) Interchangeable plugins for detecting conflicts between server-side data and client-side data
US10013259B2 (en) User initiated data rollback using operating system partitions
US11900089B2 (en) Automatically configuring and deploying a software operator in a distributed computing environment from a package
US11334334B2 (en) Generating a software release based on controller metadata
US8745620B2 (en) Software tool and method for updating a virtual appliance
US11288092B2 (en) Dynamically adjusting reconciliation time-delays
US20200344305A1 (en) Commissioning a virtualised network function
US20230359452A1 (en) Systems and methods for software distribution
US11609935B2 (en) Managing configuration datasets from multiple, distinct computing systems
CN115103028B (en) SaaS application request processing method and device and computer equipment
US11907707B2 (en) Methods and systems for orchestrating software application variant configuration
CN113805858A (en) Method and device for continuously deploying software developed by scripting language

Legal Events

Date Code Title Description
AS Assignment

Owner name: RED HAT, INC., NORTH CAROLINA

Free format text: ASSIGNMENT OF ASSIGNORS INTEREST;ASSIGNOR:TROCKI, WOJCIECH JULIAN;REEL/FRAME:049667/0219

Effective date: 20190703

FEPP Fee payment procedure

Free format text: ENTITY STATUS SET TO UNDISCOUNTED (ORIGINAL EVENT CODE: BIG.); ENTITY STATUS OF PATENT OWNER: LARGE ENTITY

STPP Information on status: patent application and granting procedure in general

Free format text: NON FINAL ACTION MAILED

STPP Information on status: patent application and granting procedure in general

Free format text: RESPONSE TO NON-FINAL OFFICE ACTION ENTERED AND FORWARDED TO EXAMINER

STPP Information on status: patent application and granting procedure in general

Free format text: RESPONSE TO NON-FINAL OFFICE ACTION ENTERED AND FORWARDED TO EXAMINER

STPP Information on status: patent application and granting procedure in general

Free format text: FINAL REJECTION MAILED

STPP Information on status: patent application and granting procedure in general

Free format text: RESPONSE AFTER FINAL ACTION FORWARDED TO EXAMINER

STPP Information on status: patent application and granting procedure in general

Free format text: ADVISORY ACTION MAILED

STPP Information on status: patent application and granting procedure in general

Free format text: DOCKETED NEW CASE - READY FOR EXAMINATION

STPP Information on status: patent application and granting procedure in general

Free format text: NOTICE OF ALLOWANCE MAILED -- APPLICATION RECEIVED IN OFFICE OF PUBLICATIONS

STPP Information on status: patent application and granting procedure in general

Free format text: PUBLICATIONS -- ISSUE FEE PAYMENT VERIFIED

STCF Information on status: patent grant

Free format text: PATENTED CASE