IDM (Inter-Domain Messaging) is an approach to transport messages between different devices, using heterogeneous (even incompatible) underlaying network technologies and protocols.
The main target of IDM is intercommunicate many networks, each one with different devices, maybe from different providers, and using incompatible technologies and protocols.
In order to achieve this, there must be gateways with interfaces to interconnect some networks. IDM can handle the details of transport, so the upper layers doesn’t need to. This way, the messaging transport is transparent to end nodes.
The addressing scheme is independent of those used in physical o logical layers beyond this. Therefore, is necessary a translation of IDM address to real address.
In order to avoid the centralized use of a registry, a node discovery protocol, called ALP, should be implemented. Each node has an associated service which handles the broadcast petitions and makes the convenient translations.
Each object is represented using an IDM address. There are two ways of use. The simplest one is based on the standard Socket-Like method. The server makes a listener socket, on which clients will connect. The data passed using this model is semantic-less, so there is flexibility for applications which need it. The second case of use is based on RMI, where clients and servers have an interface in common which must use. This way, there is no need to change the code of applications which use RMI in order to use IDM, so the adaptation is easy and fast.
Because of using heterogeneous protocols, there must be an uniform addressing scheme. IDM gives each object an identifier, which may be unique if required. The given address is a byte sequence, compound of fields for organization, network, adapter, etc. This make the addressing hierarchical. Some of this fields may be omitted, if the node has not power enough to compute it.
There are many scenarios where is needed to intercommunicate different devices, each one from a different provider, which may use very different technologies, protocols, etc. This presents a big problem, which can be solved using IDM.
IDM uses an object oriented approach. Devices and routers are modeled as objects, using a standard midleware. It makes the messaging independent of any network or protocol technologies, making those transparent to implementation stage.
The current prototype uses the midleware ZeroC Ice. Its build on C++, with some partial binding to Python. Each node address is used as Identity in the actual Ice Object. The networks upon with it has been tested use the TCP/IP stack. It have been used IceGrid and IcePatch to distribute the nodes on the network.
Sample scenarios & benchmarks
This is the real environment used: two first level IDM networks, with different organizations: six IDM routers, which travel through two IP networks; eleven final nodes, which share ALP services; bidirectional ways through routers.
- Initial version, early prototype: idm v0.1.tar.gz