MultiXTpm Application Server
Open Source/Free Software
|MultiXTpm is an Application Server, Message Oriented Middleware (MOM) and Transaction Processing (TP) Monitor. It provides the runtime environment and rich API for developing large, scalable applications that are required to process online transactions originated from various types of computers and devices.
|A MultiXTpm based system is built from various types of processes that run on one or more machines and communicate with each other using the provided API. Among other things, this API enables the developers to build systems that are based on multiple processes that communicate with each other, rather than build one monolithic program that does all processing of all types of activities.
|As an Application Server and Message Oriented Middleware (MOM) in a Distributed Processing environment, MultiXTpm provides a system that is as open and flexible as it can be. MultiXTpm can provide services to all kinds of applications and hardware devices. It does not impose any restrictions or requirements on any part that is external to the main processes of the system. For example, if there is a requirement to connect a specific POS (Point of Sale) terminal to the system but it uses a specific protocol and data format, in that case MultiXTpm provides all the facilities and API to interact with that POS terminal, convert its data to an “understood” format and “inject” the data into the system as it was received from some other internal resource. This flexibility makes MultiXTpm the best solution for large scale systems that are required to support a wide range of devices and input methods. This is in opposite to all object oriented application servers that enforce the developers to use a single or maybe two input methods in order to interact with the main application server.
When it comes to connecting to legacy systems and proprietary applications or hardware
controllers, MultiXTpm provides all the necessary services to:
MultiXTpm ArchitectureMultiXTpm architecture is based on the idea that the entire runtime environment comprises of multiple processes of different types and purposes that communicate with each other using messages. In order to enable efficient use of resources and to enable each process handle as many requests as possible in a short time, MultiXTpm environment provides a special API that is implemented in a special DLL called MultiX. The MultiX API provides the framework for developing event driven processes where all inter process communications and communication related issues are handled by the MultiX DLL and are performed in a NO WAIT manner. This architecture enables a single process to handle many requests in a short time without the process needing to explicitly wait for the data to arrive and without wait for response to be actually sent. Since the application is event driven, MultiX is responsible for receiving the data buffers, assembling it into a logical message and notifying the application on the complete message. When a response needs to be sent, the application just issues a send request, regardless of the message size, and MultiX will send the message, one fragment after the other and at the end, it notifies the application on the success or failure of the send. During this whole time, the application may receive and process many other messages.
Compact and Modular CodeSince MultiXTpm environment is built from many processes that communicate with each other, the designer of a given implementation is encouraged to build a system that comprises of many processes where each process has a well defined function in the system. This approach enables building a very modular system and a very efficient and scalable system. The fact that the system modularity is achieved thru multi processing makes the system very highly distributable and scalable. This architecture also makes it very easy to maintain and debug the modules. Small, functional processes are a lot easier to debug than large processes that are built from thousands of lines of code and it is easier than debugging a DLL that is part of a larger process.
ThreadingAn application designed to run in MultiXTpm environment using the MultiX API, is usually built single threaded. While MultiX itself uses multithreading for processing its events, the application is usually written single threaded. The idea is that multi threading in the application layer is done to achieve concurrency and higher throughput, but in MultiXTpm environment these goals are achieved thru use of multi processing and not multi threading. In MultiXTpm environment it is MultiXTpm's responsibility to launch instances of the same program when needed and stop these instances when the load gets low. This capability of MultiXTpm frees the developer from the burden of developing multithreaded applications. It also frees the designer of the application from the burden of building tools to load balance the system within one process (multi threads), within one machine (how many instances of a given process and when) and within a domain or a cluster (how many processes on each machines and when to launch them).
Never the less, if a developer chooses to use multiple threads for processing multiple requests simultaneously within the same process; MultiX API provides excellent threading support that fits within the entire architecture. A good example for using multiple threads within the same process for achieving better throughput can be found MultiXTpm gSoap Enhancer where each service call is handled by different thread, allowing the main process doing other activities while the Web Service performs its own activities.
MultiXTpm ProcessesWhen building an application for MultiXTpm environment we may define 4 types of processes that can take part in a given system:
MultiXTpmThis process is the heart of the system and it is responsible for the following activities:
Front End ProcessesSince MultiXTpm based applications communicate with each other using the MultiX API, there comes a time that there is a need to communicate with an application or a device that do not use the MultiX API. In such situation, a Front End Process is created. It has two logical end points, one to communicate with the non-MultiX device or application thru using some kind of protocol and data format and the other end point is to communicate with MultiXTpm and the other MultiX based processes.
A typical implementation of a Front End Process is as follows:
Since Front End Processes interact with external applications and devices, there might be a requirement for these interfaces to be secured. To fulfill this requirement, MultiXTpm Application Server provides SSL support using the OpenSSL software package. Front End Processes make use of this capability provided by MultiXTpm Application Server. Read more about SSL Support.
In general, the idea of a Front End Process is that it handles interface issues related remote end applications or devices that do not use the MultiX API. It forwards the “normalized” message to some back-end/application process for the actual processing of the data. This is in contrast to implementing the interface/protocol/data conversion/data processing in a single process. This way, if more than one interface exists for a given service, only a Front End Process needs to be added/modified and the application that handle the data processing/business logic is not modified or touched at all.
Back End / Application / DB Server processesBack End processes are responsible for the actual processing of the requests and only that. When a new requests is received by a Back End Process, it assumes that the request is complete and contains all the data and partial message that needs to be gathered from fragments. A Back End Process has no knowledge on the mechanism used to deliver the request,what protocol was used or what transport used. The same is tru when a Back End Process send its responses to the sender. In MultiXTpm environment, it is possible for more than one Back End Process to receive a request that was forwarded from a Front End Process, each Back End Process can act differently on the same request. Usually, Back End Processes are not aware of the fact that other processes receiving the same message.
A typical implementation of a back end process is as follows:
The idea of implementing a Back End Process is to help the developer separate the development of the business logic from all other issues.
Back End Processes take care only for pure application issues and not for anything else. Some typical scenarios for implementing Back End Processes are:
Gateway / Converter / Adapter processesGateway Processes play almost the same role of Front End Processes except that they are logically located at the back end of the system. They are mainly used in cases where a request is originated at the front end side of the system, then forwarded to some Back End Process which in turn needs to forward the request to some external system for additional processing. In such scenario, the Gateway processes acts like a Back End Process by the fact that it receives its request from the internal processes, but on its other side it behaves like a Front End Process by the fact that it interacts with some external system using some specific protocol and data format.
The main difference between Front End Process and a Gateway Process is the origin of the request. In a Front End Process the request is originated from the remote non-MultiX end, then it is forwarded to an internal Back End Process and when a response is received from the Back End Process, it is sent back to the remote end. In a Gateway Process, the request is originated from some internal Back End or Front End Process, then when received by the Gateway Process, it is forwarded (and maybe converted) to some external non-MultiX remote end. When a response is received from the remote end, it is forwarded back to the internal Back End Process that originated the request.
Some typical scenarios for implementing Gateway processes are:
SummaryMultiXTpm Application Server a high availability, high throughput, scalable server for implementing messages based and service oriented systems. It is built to support large number of processes that can run on one or more machine and platform. It load balances the system thru using multiple processes and multiple machines. It can easily interact with third party systems and with various hardware devices that use a variety of protocols and data formats. Finally, it is open ended and can be customized to support any future requirements for interaction with external systems and improving internal mechanisms for load balancing and message forwarding.
Download informationMultiXTpm Application Server is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version.
MultiXTpm Application Server is distributed in source code format and it supports: Windows OS, Linux, Solaris and HP Nonstop Server OSS.
The source code is packed in ZIP file and can be downloaded from SourceForge.net.
To Access the Download Page at SourceForge.net you may click Here
Navigate to http://sourceforge.net/projects/multixtpm
Contact informationFor more information, Bug Reports, Feature Requests, and Support Requests, please use:
SourceForge.net Project Forums
MultiXTpm group at Yahoo Groups.
you may send an email to: Moshe Shitrit