Common channels for inter-application communications

• US 5,748,962 A
• Filed: 09/30/1996
• Issued: 05/05/1998
• Est. Priority Date: 09/30/1996
• Status: Expired due to Term

• Current Assignee: Verizon Patent and Licensing Incorporated (Verizon Communications Inc.)
• Original Assignee: MCI Communications Corporation (Verizon Communications Inc.)
• Inventors: La Buhn, Greg, Brechtel, James P.
• Primary Examiner(s): Toplu, Lucien U.
• Assistant Examiner(s): Lao, Sue X.
• Application Number:
  US08/720,479
• Time in Patent Office: 582 Days
• Field of Search: 395/682, 395/683, 395/680, 395/200.15, 395/701, 395/651, 395/684
• US Class Current: 719/328
• CPC Class Codes: G06F 9/465 Distributed object oriented systems remote method invocation [RMI] G06F9/548
• CPC Class Codes: G06F 9/54 Interprogram communication

Abstract

The present invention is a set of common utilities, implemented as object classes, that provide common channels of communications among applications that run on a distributed platform. An application developer can program communications interfaces to other applications by creating a single application interface using these utilities. Creating this single interface simply involves abstracting an object class from a base class, and defining a few key methods. The invention allows an application developer to focus efforts on the application itself and rapidly prototype the application, by removing the need to develop communication interfaces with other applications. All requirements for inter-application communications are contained within the common utilities.

Claims

1. A method for using a set of common utilities implemented as object classes, to provide common channels of communications among applications that run on a distributed platform, comprising the steps:

invoking a common process class (CmnProcess) representing an application code for a particular application (Application X) wherein the code relates to how particular Application Programming Interfaces messages (API) will be processed, and whether responses will be sent;

calling an API processing function (processApi) from CmnProcess, for processing API messages that are sent to and received by the Application X;

invoking a common API class (CmnApi) to create polymorphic API objects that respond to a common verb set, the API objects containing the data that is being sent from Application X to another application;

CmnApi calling generalized virtual send, virtual receive, and virtual data functions for defining the general API functions needed to send and receive data;

at a data sending end, Application X instructing the API object to send itself using the virtual send function and at the receiving end the API object rebuilding itself using the virtual receive function;

CmnApi deriving subclasses with specific functions defined by Application X;

invoking a Common Channel class (CmnChannel) to reference a communications channel to be used to send/receive the API object, the API object using this reference to send or receive itself;

invoking a common service loop class (CmnServiceLoop) operating as a process manager performing a plurality of predefined functions during its servicing loop;

CmnServiceLoop objects processing the input and output from the common channels to extract the API object;

CmnServiceLoop containing its own virtual send and receive functions;

invoking a common event (CmnEvent) class for deriving application-specific classes and instructing the CmnServiceLoop to perform events based on generalized methods as to how and when the events are to be performed;

the derived application-specific classes also specifying which application-specific CmnProcess class to perform the event on;

the CmnServiceLoop, during its execution, determining which events are to be performed and invoking appropriate CmnEvent objects according to event type by calling on the CmnEvent "processEvent" method, the "processEvent" method invoking a CmnProcess "process" method to perform the event;

invoking CmnChannel for representing the actual communications channels that are used for application interfaces;

deriving subclasses specific to a particular communications protocol from CmnChannel;

calling upon functions of the derived subclasses relating to respective communications protocols they support;

encapsulating all data needed to use a protocol communications channel in a CmnChannel object, an application using this communications channel to send or receive data, the application itself not needing to contain any of this data and only needing to reference the name of the channel;

CmnChannel having a function (hasData) to which CmnServiceLoop responds as a reference for indicating that a particular CmnChannel object has data to be received;

a common configuration class (CmnConfig) invoked by CmnChannel to setup the configuration of each channel;

a rules set class (RuleSet) containing rules files for configuring communications channels being invoked by CmnConfig, RuleSet further specifying the types of channels to instantiate from CmnChannel subclasses, channel information made by channel name, and passed on to CmnConfig.

2. The method of claim 1 further comprising the following steps in response to a server application receiving a request from a client application and providing a response to the client, the request and response being in the form of a message contained in an API object:

a CmnServiceLoop object calling a status function (hasData) of a CmnChannel object to determine that there is an API message (data) to receive on the CmnChannel object;

the CmnServiceLoop object calling a receive function of an CmnApi object that builds itself to receive the message;

the CmnApi object calling a receive function of the CmnChannel object to receive the message;

the CmnServiceLoop object calling the processApi function of the CmnProcess object to process the API message in accordance with steps defined specifically for the application that is represented by the CmnProcess object;

the CmnProcess object processing the message resulting in the server answering the client'"'"'s request and preparing a response message, this message processing occurring when the CmnProcess object calls the send function of a common API object which contains the message (response) to be sent;

the CmnApi object calling a send function of a common channel object to send the message, the CmnApi object containing the instructions to send itself thereby relieving the application from executing instructions for doing so;

the CmnProcess object calling a return buffer function (returnApiBuf) of CmnApi for clearing a memory buffer used for the CmnApi object and acknowledging that processing of a message is complete;

the CmnApi object calling the returnApiBuf function of CmnChannel to clear the memory used for the CmnChannel object;

the CmnServiceLoop object calling a process events function (processEvents) of the CmnEvent object, for instructing the CmnServiceLoop object to perform a user-defined event, in accordance with generalized functions of CmnEvent, including specifying the event, its frequency, and CmnProcess to perform it;

the CmnEvent object calling the process function of the CmnProcess object to perform the event, the event being referred to by a unique event type.