KR101599076B1 - A system and method for providing quality-of-services in a multi-event processing environment - Google Patents

Abstract

To a system and method for providing quality of service (QoS) functionality to concurrent event processing applications in a multi-processing database environment. The system includes an event listener interface that determines a quality of service capability applicable to the event being processed and an event service interface that invokes the determined quality of service function. The event service interface loads, initializes, and invokes the quality of service function. The quality of service function is based on the service definition. The event service interface also initializes the service provider and sends events requiring service quality support to each service provider for processing. The quality of service function includes services typically required in a clustered event processing database system such as event sequencing, event isolation, high availability, event filtering and flow control. Other service quality functions may be added to the database system using the same interface provided by the present invention.

Description

[0001] SYSTEM AND METHOD FOR PROVIDING QUALITY OF SERVICES IN A MULTI-EVENT PROCESSING ENVIRONMENT [0002]

The present invention relates generally to databases and, more particularly, to a system and method for providing Quality of Service (QoS) to concurrent event processing applications in a multi-processing database environment.

Event handling is a key task for database applications, such as handling online bookings and financial transactions. In a bank database system, many events related to a customer's bank account may need to be processed and updated simultaneously for that account. For example, the customer may proceed to the same account in the service window while the customer's bill payment is being processed by the bank's automatic bill payment service. Both payment settlement and account deposit transactions are events that affect the account balance when they are processed by the banking system and need to be processed by the system's concurrent event handling application. In addition, the results of such transactions must be accurately updated in the banking database to accurately reflect the balance of the account.

Gradually, database applications are hosted in a clustered computer environment, typically to accommodate a large number of changing workloads and to support multiple computers in an enterprise network. These computer clusters facilitate workload balancing and system scaling according to user needs. For example, a bank database system will have many instances of event processing applications running on several servers supporting each branch of the bank. These servers can be connected to a bank network and can be in different physical locations or in the same physical location.

Alternatively, while one server functions as a main processing server, other servers may act as a backup system for the main server. In addition, other instances of the event processing application may be added to the system during periods of high user demand, such as Friday or the last few days of the month where a large increase in transaction volume is anticipated.

Because of the concurrent occurrence of event processing applications, the quality of service features are generally associated with failover, racing condition, and poor system performance caused by unbalanced workload allocation during event processing It is required to handle the same system problems. In general, these quality of service functions are individually developed and embedded in an event processing application or middleware that supports the application. For example, in a WebSphere product manufactured by International Business Machines Corporation, Armonk, NY, these services are individually handled and embedded in the product.

From the foregoing, it can be seen that there is a need for a system and method for eliminating the aforementioned drawbacks and for providing a quality of service function to a concurrent event processing application in a database environment.

The present invention relates to a system and method for providing a quality of service function in a multiprocessing environment having a plurality of concurrently running event processing applications. Each event processing application includes an event-listener interface and an event service interface. The event service interface is accessible from the event listener interface. During the processing of an incoming event, the event listener interface identifies events that require quality of service functionality and invokes the event service interface to provide applicable quality of service features. The event service interface sends these events to the appropriate service provider so that the service provider can supply the desired service quality characteristics to the event processing applications that require these service quality features.

The event service interface includes components that load the quality of service functionality into memory and invoke the function when the event service interface is called to provide support. The quality of service function is generally a service that helps improve the overall performance of the system by helping to prevent or treat certain problems when the event is processed. For example, the quality of service function may be an Event-Sequencing service for managing the order of events processed by concurrent applications. For certain types of events, such as financial transactions, the order of the events being processed is very important because the ordering sometimes affects the processing results. The other service quality function may be an event-isolation function for closely managing the processing of related events that may cause potentially racing conditions in the system. A race condition occurs when system resources can not process two events correctly at the same time. Simultaneous processing of two events will produce inconsistent results. To avoid a race condition, the processing of one event can only start after the processing of another event has ended.

The system also includes a High-Availability Quality of Service feature for handling failover conditions to avoid loss of events and duplication events. Another quality of service function provided by the system of the present invention is event-filtering which improves the overall performance of the system by selectively applying a quality of service function to a subset of events rather than to all incoming events ) Service. In addition, a flow-control quality of service function is provided to monitor and control the rate of incoming events processed by the application so that the system is not overwhelmed by the mass inflow of events.

In another aspect of the present invention, a computer implemented method is provided for providing a quality of service function in a multiprocessing environment having a plurality of concurrent event processing applications running concurrently. The method preferably includes identifying a quality of service function applicable to the application via an event listener interface and invoking a quality of service function via an event service interface. The event listener interface is associated with the event processing application and accesses the event service interface.

In a preferred embodiment of the present invention, the method provides a set of service quality functions commonly required by concurrent event processing applications. The quality of service features of the preferred embodiment include event sequencing, event isolation, high availability, event filtering and flow control. Additional quality of service functions may similarly be implemented and invoked using an event listener interface and an event service interface.

The method further comprises loading and activating a quality of service function when the event service interface invokes a quality of service function. Activation of the quality of service function involves initialization of the declared service. If the event service interface determines that the event requires a quality of service function, the method of the present invention loads the service provider associated with that service function and sends the event to the service provider for processing.

In another aspect of the present invention, a computer program product for providing a quality of service function to a concurrent event processing application in a multiprocessing environment is described. The computer program product includes a computer usable storage medium for storing the readable program code. The program code identifies a service quality function applicable to an event processing application through an event listener interface and invokes the service function through an event service interface. The event listener interface and the event service interface are associated with the event processing application, wherein the event service interface is accessible from the event listener interface during the processing of the incoming event.

The details of a preferred embodiment of the present invention, such as the configuration and operation of an embodiment of the present invention, are described in the Detailed Description section of the specification with reference to the accompanying drawings, wherein like reference numerals refer to like Quot; &Quot; Solution to the problem " represents a core feature of the inventive subject matter recited in the claims, but is not intended to limit the scope of the inventive subject matter recited in the claims.

A system and method for providing a quality of service function in a multiprocessing environment having multiple event processing applications running concurrently is provided.

1 is a block diagram illustrating a database environment in which aspects of the present invention may be applied;
2 is a block diagram illustrating a database environment having multiple servers running in a cluster, each running a query processing application provided with aspects of the present invention;
3 is a block diagram illustrating a core interface within each query processing application in a clustered environment for providing quality of service functionality, in accordance with an aspect of the present invention.
4 is a block diagram illustrating an event sequencing service quality function supporting a query processing application in a clustered environment, in accordance with an aspect of the present invention.
5 is a block diagram illustrating event sequencing and event isolation service quality functionality supporting a query processing application in a clustered environment, in accordance with an aspect of the present invention.
6 is a block diagram illustrating event sequencing, event isolation, and event filtering service quality functions supporting a query processing application in a cluster environment, in accordance with an aspect of the present invention.
Figure 7 is a block diagram illustrating event sequencing, event isolation, event filtering, and high availability quality of service functionality supporting query processing applications in a clustered environment, in accordance with an aspect of the present invention.
Figure 8 is a block diagram illustrating event sequencing, event isolation, event filtering, high availability, and flow control quality of service features supporting query processing applications in a clustered environment, in accordance with an aspect of the present invention.
9 is a block diagram illustrating an exemplary embodiment of an event listener interface, an event service interface, and a set of quality of service functions, in accordance with an aspect of the present invention.
10 is a flow diagram illustrating an exemplary process for providing a service quality function to an event processing application in accordance with an aspect of the present invention.
Figure 11 is a flow chart illustrating, in more detail, an exemplary process for providing a service quality feature as shown in Figure 10 and a service quality feature with high availability, in accordance with an aspect of the present invention.

The present invention generally relates to systems and methods for providing quality of service functionality to event processing applications in a database environment. More specifically, the present invention provides a framework for identifying and invoking quality of service features for event processing applications in a multi-processing database environment.

As one of ordinary skill in the art will appreciate, aspects of the present invention may be implemented as systems, methods, and computer program products. Accordingly, aspects of the present invention may take the form of a complete hardware embodiment, a form of complete software embodiment (including firmware, resident software, microcode, etc.), or an embodiment of a mixture of software and hardware , And for all these types we will use the terms "circuit", "module" or "system" in this specification. Further, aspects of the present invention may take the form of a computer program product embodied in one or more computer readable media embodying computer readable program code.

Any combination of one or more computer readable media may be used. The computer-readable medium can be a computer-readable signal medium or a computer-readable storage medium. The computer-readable storage medium can be, for example and without limitation, an electronic, magnetic, optical, electromagnetic, infrared, or semiconductor system, device or element, or any suitable combination of the foregoing. A more specific example (non-volatile list) of computer-readable storage media includes, but is not limited to, an electrical connection with one or more wires, a portable computer diskette, a hard disk, a random access memory (RAM), a read only memory (ROM), an erasable programmable read- (EPROM or flash memory), an optical fiber, a portable compact disc read-only memory (CD-ROM), an optical storage element, a magnetic storage element, or any suitable combination of the foregoing. In the context of this specification, the computer-readable storage medium can be any tangible medium that can contain or store a program used by or in connection with an instruction execution system, apparatus, or element.

The computer-readable signal medium may include a propagated data signal in which the computer readable program code is embedded, e.g., in the baseband or as a carrier portion. Such a radio wave signal may take any form among various forms including, for example, electromagnetic, optical, or a proper combination thereof, for non-limiting examples. The computer-readable signal medium may be any computer-readable medium that can communicate, propagate, or transport a program used by or in connection with an instruction execution system, apparatus, or element, but not a computer-readable storage medium.

The program code embodied in the computer readable medium may be transmitted using any suitable medium including, but not limited to, wireless, wired, fiber optic cable, RF, etc., or any suitable combination thereof.

Computer program code for performing the operations of aspects of the present invention may be implemented in one or more programming languages, including object-oriented programming languages such as Java, Smalltalk, C ++, etc., and conventional procedural programming languages such as "C" May be recorded in any combination. The program code is a stand-alone software package that can run entirely on a user's computer, run some on a user's computer, run some on a user's computer, run some on a remote computer, or run entirely on a remote computer or server. In the latter scenario, the remote computer may be connected to the user's computer via any type of network, including a local area network (LAN) or a wide area network (WAN) Lt; / RTI > to the external computer).

DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS In the following, aspects of the present invention are described with reference to flowcharts and / or block diagrams of methods, apparatus (systems), and computer program products according to embodiments of the invention. The blocks of the flowcharts and / or block diagrams and combinations of blocks in the flowchart illustrations and / or block diagrams may be implemented by computer program instructions. These computer program instructions may be provided to a processor of a general purpose computer, special purpose computer, or other programmable data processing apparatus to create a machine so that instructions executing via a processor of the computer or other programmable data processing apparatus may be stored in a flow diagram and / Thereby creating means for implementing functions / acts specified in a single block or multiple blocks of < RTI ID = 0.0 >

These computer program instructions may also be stored in a computer readable medium, which may direct a computer, other programmable data processing apparatus, or other components to function in a particular manner, and instructions stored in the computer readable medium may be stored in a computer- A manufacturing item is generated that includes instructions that implement a function / action specified in a single block or multiple blocks of the block diagram.

The computer program instructions may also be loaded into a computer, other programmable data processing apparatus, or other device so that a series of operating steps may be performed on the computer, other programmable apparatus, or other device to create a computer implemented process, The instructions executing on a possible device provide a process for implementing functions / acts specified in a single block or multiple blocks of a flowchart and / or block diagram.

The flowcharts and block diagrams of the figures described below illustrate the structure, function, and operation of possible implementations of systems, methods, and computer program products in accordance with various embodiments of the present invention. In this regard, each block of the flowchart or block diagram may represent a module, segment, or portion of code that includes one or more executable instructions for implementing a particular logical function (s). It should also be noted that in some alternative embodiments, the functions indicated in the blocks may occur in an order different from that shown in the figures. For example, two consecutively shown blocks may in fact be executed substantially concurrently, or a plurality of blocks may sometimes be executed in reverse order according to the associated function. Each block in the block diagrams and / or flowcharts, and combinations of blocks in the block diagrams and / or flowchart illustrations, may be implemented by a special purpose hardware-based system that performs a particular function or function, or by a combination of special purpose hardware and computer instructions It should also be noted.

1 is a high-level block diagram of a multi-processing database environment including aspects of the present invention. At the base software level, the computer 115 interfaces with the operating system 114. Typically, a middleware platform 112 is installed, through which a number of different user applications interact with the operating system 114. An example of a middleware platform 112 is the WebSphere product line manufactured by International Business Machines Corporation, Armonk, NY, USA.

A number of event processing applications 110 are illustrated that are interfaced with and running concurrently with the middleware platform 112. The middleware platform 112 accesses the event storage unit 113 to retrieve data items from the event storage unit 113 or to store new data items in the data storage unit 113, The existing data items in the storage unit 113 can be updated. During the processing of the event, the middleware platform 112 can obtain data from the data store 113 and provide the data to the event processing application, as well as receive data from the event processing application 110, And may be stored in the storage unit 113.

2 is a block diagram illustrating a clustered computing environment in which aspects of the present invention are implemented. As an example, the clustered computing environment of FIG. 2 includes three servers 210, 211, and 212, but may have more servers depending on the needs of the user and environment. Each server has an instance of an event processing application running on top of the middleware platform. The middleware platform interfaces to the operating system of the server. For example, in the server 210, the event processing application 213 interacts with the middleware platform 216 and the middleware platform 216 interfaces with the operating system 219 of the server. Similarly, servers 211 and 212 host event processing applications 214 and 215, respectively. The applications 214 and 215 interact with the operating systems 220 and 221 through the middleware platforms 217 and 218, respectively.

Figure 2 also shows an event store 222 that not only holds event data generated by the event processing application 210-212 but also provides data to the application while the application processes the event. The event storage unit 222 is sometimes called a data storage unit or a database in general.

3 is a block diagram illustrating a preferred embodiment of an event processing system for providing a quality of service function in a multiprocessing environment in accordance with the present invention. Similar to the system of FIG. 2, the computing environment of FIG. 3 is a clustered computing environment with three servers 310-312. Each server 310-312 hosts an event processing application 313-315. The event processing application 313-315 may store the event data in the event storage unit 322 or retrieve data from the event storage unit 322. [

The event processing application 313-315 preferably includes an event listener interface for identifying an event to be processed by an application that requires service quality function support. In addition, the event processing application 313-315 preferably has an event service interface that invokes an appropriate quality of service function for the event to be processed. For example, the event processing application 313 includes an event listener interface 316 and an event service interface 319. Similarly, event processing applications 314 and 315 include event listener interfaces 317 and 318 and event service interfaces 320 and 321, respectively. More specific contents of the event listener interface 316-318 and the event service interface 319-321 will be described later with reference to Figs. 9 to 11. Fig.

Figure 4 is a block diagram illustrating a preferred embodiment of the present invention having a quality of service function 423 called event sequencing, supporting the event processing applications 413-415. The event processing application 413-415 includes an event listener interface 416-418 and an event service interface 419-421, respectively. These interfaces have been described above with reference to FIG. The event sequencing service quality function 423 is shown separately from the event processing applications 413-415 to clarify and show its commonality among the event handling applications 413-415. Alternatively, the event sequencing service quality function 423 may be part of a database container. In another embodiment of the present invention, the event sequencing service quality function 423 may be part of the middleware supporting the event processing application.

The event sequencing service quality function 423 is responsible for managing the sequence of incoming events processed by the event processing application 413-415 to ensure a consistent processing result. There are several options to ensure the order of the events being processed. One option is to use a single-threaded event to be processed at the entry point to the system. The other option is to associate a tag or timestamp with each event at its source, and to trust the event tag or event timestamp to determine the order of events to be processed. However, in an integrated event processing system, the source of some events and the data store are sometimes not under the control of middleware during runtime. As a result, it may not be possible to tag or timestamp all events. Thus, a single event thread is a good option for implementing the event sequencing service quality function.

FIG. 5 is a block diagram illustrating a preferred embodiment of a system with an additional quality of service function 524, which is a system that provides quality of service similar to that shown in FIG. As shown in FIG. 4, the server 510 is an active server while the servers 511 and 512 are backup systems. Other components of the system shown in Fig. 5 have been described above with reference to Fig. 4 and will not be repeated here. The main purpose of the event separation service quality function 524 is to prevent contention during event processing. A race condition is a situation where concurrent processing of two events produces inaccurate or inconsistent results. As a result, the processing of one event will not start until the processing of another event is finished. One example where a race condition occurs is when two bank transactions are processed that update the same bank account together. If two transactions are processed simultaneously by two separate event processing applications, the account related results generated by these applications are sometimes inconsistent and unreliable.

FIG. 6 is a block diagram illustrating a preferred embodiment of a system with an additional quality of service function 625, which is a system that provides quality of service similar to the system shown in FIG. 5, but with event filtering. As shown in FIG. 5, the server 610 is an active server while the servers 611 and 612 are backup systems for the server 610. Other components of the system have been described above with reference to Figures 4 and 5. The event filtering function 625 is invoked by the event processing application 613-615 and applies special quality of service functions to the processing of the selected subset of the incoming events to improve overall system performance. This quality of service function may be considered to be unrelated to other incoming events being processed and therefore not invoked for these events. As a result, the computing resources of the system can be efficiently directed to events that actually require service.

For example, the event sequencing function 623 and the event separation function 624 described above are typically needed when an application processes an event that updates information for a single account or individual, such as in a bank account. This type of event takes on only a small part of the incoming events handled by the application. Accordingly, the event filtering service 625 can greatly improve the performance of the system by selectively applying the two service qualities to a small group of events that update information on an account or an individual rather than on all events.

FIG. 7 is a block diagram illustrating a preferred embodiment of a system with an additional quality of service function 726, which is a system that provides quality of service similar to the system depicted in FIG. 6 but high availability. Other components of the system have been described above with reference to FIGS. 4 to 6 and will not be repeated here. The highly available quality of service function 726 is used by the event processing applications 713-715 to handle the failover conditions of the system and to avoid loss of events and duplicate processing of the same event.

As an example, consider a service quality function of event sequencing 723 and event separation 724 that is called by applications 713-715 to control the processing order of events and avoid concurrent processing of two events. One possible way to achieve this goal is for the system to retrieve incoming events from a single thread. However, this single event thread is susceptible to system failover, i.e., single point failure in the system, which causes some events to be lost and other events to be processed more than once after the system has recovered from failover. The highly available quality of service function 726 resolves the failover condition by providing a backup processing channel as indicated by the path from the event processing application 714, 715 to the highly available quality of service function 726.

FIG. 8 is a block diagram illustrating a preferred embodiment of a system with a flow control quality of service function 827, although it is a system that provides quality of service similar to the system shown in FIG. Other components of the system have been described above with reference to Figures 4-7. The flow control service quality function 827 is used in the event processing applications 813-815 to manage the rate of incoming events processed by these applications. Depending on the computing resources available to each of the event processing applications 813-815 and their capacity, the application may use the flow control function 827 to increase or decrease the rate of events processed by the application.

9 is a block diagram illustrating a preferred embodiment of an event listener base in an event processing application 918 for invoking an event listener interface and an event service interface in accordance with aspects of the present invention. The event listener base 910 has an application 918 and is coupled to its own event listener interface 911 to test the processing of incoming events. If event listener base 910 determines that more than one service quality function is applicable to this application, event listener base 910 calls event service interface 912. Depending on the type of quality of service required, one or more quality of service functions may be initiated by the event service interface 912. For example, FIG. 9 shows the quality of service features of event sequencing 913, event separation 914, event filtering 915, high availability 916, and flow control 917. The service quality functions are described above with reference to FIGS. Other service quality functions using the same event listener base 910, event listener interface 911 and event service interface 912 may be added to the system to support event processing applications in the system.

10 is a flow diagram illustrating an exemplary process for providing a quality of service function in a multiprocessing environment having multiple event processing applications running concurrently as described hereinabove. At block 1010, the server hosting the event processing application begins processing. At block 1011, the event service interface is bootstrapped. At block 1012, the event service interface tests the event processing application before the event processing application starts. At block 1013, the event service interface determines whether the event processing application includes an event listener interface. If there is no event listener interface, the event processing application is started normally (block 1014). If there is an event listener interface, the event listener interface is initialized (block 1015). A service provider supporting the event processing application is also initialized (block 1016). At block 1017, the event listener interface begins. At block 1018, the event service interface registers with the event store that supports the application to allow the event store to prepare to accept event data generated by the service provider. At block 1019, events requiring a quality of service function are sent to the service provider by the event service interface for processing.

11 is a flow chart that more specifically illustrates operations performed in FIG. 10 for an exemplary process for providing a quality of service function in a multiprocessing environment. In block 1110, as part of initializing the event listener interface, the event listener interface loads the declared service (block 1115). The declared service is then initialized (block 1116). The flow proceeds to block 1111 where the service provider is initialized. In a preferred embodiment of the present invention, the initialization of the service provider includes the provision of services based on the XML definition (block 1117). The service provider also joins the service groups (block 1118) and comes under the control of the service group (block 1119). Once initialization of the service provider is completed at block 1111, an event listener interface is started at block 1112. The event listener then registers in the event storage unit at block 1113. [ All events requiring quality of service support are then sent to the applicable service provider for service (block 1114).

The embodiments of the present invention described above are provided for explanation purposes only and should not be construed as limiting the scope of the present invention. It will be apparent to those skilled in the art that various changes and modifications may be made therein without departing from the spirit and scope of the invention as defined in the following claims and their equivalents, And should be interpreted broadly to cover the configuration. As will be appreciated by those skilled in the art, the systems, methods and procedures described herein may be embodied in a programmable computer, computer-executable software, or digital circuitry. The software may be stored on a computer readable medium. For example, the computer readable medium can include a floppy disk, RAM, ROM, hard disk, removable media, flash memory, memory stick, optical media, magneto-optical media, CD-ROM,

110, 313-315, 413-415, 513-515, 613-615, 713-715, 813-815:
112, 216-218: Middleware,
113, 222, 322, 422, 522, 622, 722, 822:
114, 219-221: operating system,
115: Computer,
210-212, 310-312, 410-412, 510-512, 610-612, 710-712, 810-812: server,
316-318, 416-418, 516-518, 616-618, 716-718, 816-818, 911: Event Listener Interface,
319-321, 419-421, 519-521, 619-621, 719-721, 819-821, 912: Event service interface,
423, 523, 623, 723, 823, 913: event sequencing service quality function,
524, 624, 724, 824, 914: event separation service quality function,
625, 725, 825, 915: event filtering service quality function,
726, 826, 916: Highly available quality of service features,
827, 917: flow control service quality function,
910: Event listener base.

Claims (10)

In a multi-processing database system that provides Quality-of-Service functions,
A processor; And
A plurality of concurrent database event-processing applications operable on the processor, each of the plurality of event processing applications having a corresponding event-listener interface, And an event-service interface,
Wherein each of the plurality of event listener interfaces is configured to identify a service quality function that is applicable to each of the corresponding event processing applications, An event-sequencing service for managing the order of events, and
Wherein each of the plurality of event service interfaces is accessible from each of the plurality of event listener interfaces belonging to the same corresponding event-processing application to provide a service quality function to each of the database event-processing applications. 7. The system of claim 1, wherein the event-service interface comprises a component for loading and activating the identified quality of service function. Each of the plurality of event processing applications is a multi-processing system having a plurality of concurrent event processing applications including a corresponding event-listener interface and an event-service interface. 1. A computer-implemented method for providing Quality-of-Service functions in a database system, the method comprising:
Identifying an applicable quality of service function for a database event-processing application using each of the event listener interfaces, the quality of service function identifying a financial transaction event that is to be processed by each of the database event processing applications An event-sequencing service for managing the sequence; And
Invoking a service quality function using each of the event service interfaces, wherein each of the event-service interfaces is accessible from each of the event listener interfaces. 4. The computer implemented method of claim 3, wherein the quality of service function is provided based on a set of service definitions. 4. The method of claim 3, further comprising: loading the service quality function when the event service interface calls the service quality function;
Activating the service quality function
Lt; / RTI > 4. The computer-implemented method of claim 3, further comprising: loading a service provider associated with the quality of service function; And
Further comprising: sending an event to the service provider for processing. 4. The system of claim 3, wherein the quality of service function is an Event-Isolation service that manages processing of the financial transaction database events to avoid a racing condition between the applications. Implementation method. 4. The method of claim 3, wherein the quality of service function is a high-availability service that handles fail-over conditions by providing backup processing channels from the event- a High-Availability service. 4. The method of claim 3, wherein the quality of service function comprises an Event-Filtering service () that selectively applies a different quality of service function to a subset of incoming database events to improve system performance ). ≪ / RTI > A plurality of concurrent event processing applications, each of the plurality of event processing applications comprising a corresponding event-listener interface and an event-service interface, 17. A non-transitory computer usable storage medium having embedded therein readable program code for use, the medium comprising:
Identifying an applicable quality of service function for each of the database event-processing applications using each of the event listener interfaces, the quality of service function further comprising: An event-sequencing service for managing the order of the events; And
Wherein the event-service interfaces are invoked by using each of the event service interfaces, and wherein each of the event-service interfaces is accessible from each of the event listener interfaces. media.

Images