Application Model (Avalanche - application framework for Java)

"Avalanche - application framework for Java" - implementation of the technology of blurring differences

between calls to local and remote code. Fault tolerance, scalability,

modifiability, continuous availability come bundled with nice bonuses.



The application model considered in this article was born on the basis of our own experience in the implementation and operation of various integration interactions of information systems (IS) and was primarily aimed at reducing the use of various resources (financial, labor, time, etc.) in the implementation of these integration solutions.



Most enterprises operate many different systems that automate individual processes or the work of individual structural units or departments. As a result, there is a need to organize information exchange between these systems or with the information systems of related organizations in order to reduce operating costs, eliminate the introduction of duplicate data and data inconsistency in various systems (for example, NSI), reduce the impact of the human factor, and reduce the time spent on information exchange.



The need for integration arises not only in special software of own or custom development, but also in “boxed” solutions. Implementation costs may exceed the expected reduction in operating costs.



Existing ways to address the integration of IT systems:

• File sharing
• Messaging (a type of file sharing)
• Integration at the data model level, for example, creating special database objects or stored procedures
• Using RCP (remote call procedure) technologies, for example, CORBA, RMI, SOAP, DCOM, etc.

All these methods of implementing integration solutions have the same drawbacks: the complexity of implementation and modification, low repeatability, the need to resolve fault tolerance issues, the inability to work in a multi-version mode during the installation of changes, the complexity of operation, and maintaining operational documentation up to date.



As a result of the search for an alternative to existing solutions, the idea was formulated to convert the MVC model (MODEL - VIEW - CONTROLLER) to the MVFA model (MODEL - VIEW - FUNCTION - APPLICATION), breaking CONTROLLER into two program layers FUNCTION and APPLICATION between which a data transmission network can be placed (SPD )







The division into functions within the controller is present to one degree or another in all modern IT systems, especially if the development is performed using object-oriented programming languages. And the allocation of these functions in a separate software layer solves the problem of their reuse by other IT systems.



Separation of “application” objects into a separate program layer standardizes the call not only to its own functions, but also to the functions of other systems, which erases all the differences in calls of “own” and “alien” functions.



To implement the MVFA model, the following software model is proposed:

1. Function (Function), any object that has methods for implementing any functionality;
2. The adapter (Adapter), the declared object has no implementation. This object provides the connection of the application objects with local or remote functions. To access remote functions, the “interface” object is used;
3. Connector (Connector), provides access to the local functions of remote objects using objects "publication";
4. Publication (Publish), publishes a local function in the connector;
5. Interface (Interface), provides access to adapters to remote functions;
6. Application (Application), performs the transformation of data between the presentation and the function / functions, can also act as a "function" for other objects of the "application".

A pair of “interface” - “connector” form a data channel through a protocol between different systems or different nodes of the same system. An implemented channel must have the ability to pass the required amounts of data.



There are specialized implementations of “interfaces” that do not have paired “connector” elements, for example, a high-availability interface that allows you to create fault-tolerant information systems. The main purpose of the high-availability interface is to redirect the load to duplicate nodes when planning or outside the planned shutdown of one of the system nodes.



The considered MVFA model is implemented in the Avalanche - application framework for Java software product, which belongs to the middle ware category and is designed to create software clusters or fault-tolerant high-availability information systems.



Of course, like any technology, Avalanche - application framework for Java has some limitations:

1. Any objects (types) declared in the adapters (input and return parameters) can be transmitted over the network, and therefore these objects must implement the java.lang.Serializable interface. Local objects are called directly, without using read and write operations to the stream.
2. Not all objects can be transferred over the network. For example, objects whose state or performance depend on the configuration of the system node where they were created. Such objects include objects that implement the javax.sql.DataSource specification.
3. Duplicate system nodes must be located on different hardware.
4. Duplicate system nodes should not be turned off (serviced) at the same time.

An example of a simple application is described in the article - First Application (Avalanche - application framework for Java)