https://github.com/eprosima/integration-service-deprecated
Fast-RTPS Integration Service: A set of services to integrate other protocols with Fast RTPS and connect different domains, LANs, and WANs.
https://github.com/eprosima/integration-service-deprecated
Last synced: over 1 year ago
JSON representation
Fast-RTPS Integration Service: A set of services to integrate other protocols with Fast RTPS and connect different domains, LANs, and WANs.
- Host: GitHub
- URL: https://github.com/eprosima/integration-service-deprecated
- Owner: eProsima
- License: apache-2.0
- Created: 2018-04-17T12:36:21.000Z (over 8 years ago)
- Default Branch: master
- Last Pushed: 2019-02-11T07:30:24.000Z (over 7 years ago)
- Last Synced: 2023-10-20T19:42:23.392Z (almost 3 years ago)
- Language: C++
- Homepage:
- Size: 674 KB
- Stars: 6
- Watchers: 12
- Forks: 1
- Open Issues: 1
-
Metadata Files:
- Readme: README.md
- License: LICENSE
Awesome Lists containing this project
README
# eProsima Integration Service
[](https://github.com/eProsima/Integration-Service/releases)
[](https://opensource.org/licenses/Apache-2.0)
[](https://github.com/eProsima/Integration-Service/issues)
[](https://github.com/eProsima/Integration-Service/network/members)
[](https://github.com/eProsima/Integration-Service/stargazers)
*eProsima Integration Service* is a library based on *Fast RTPS* for creating parameterized
communication bridges between different systems, services and protocols.
It is also able to perform transformations over the messages such as customized routing and
mapping between input and output attributes or data modification.
The main features of *Integration Service* are:
- Connects two different domains.
- Mapping between different data types.
- User-defined operations over the received messages.
- Communication with others environments, like *ROS2*.
## Supported platforms
* Linux [](http://jenkins.eprosima.com:8080/job/Integration-Service%20Manual%20Linux/)
* Windows [](http://jenkins.eprosima.com:8080/job/Integration-Service%20Manual%20Windows/)
### **Table Of Contents**
[Installation](#installation)
[Usage](#usage)
[Example application](#example-application)
[Documentation](#documentation)
[Getting Help](#getting-help)
### **Installation**
Before compiling *eProsima Integration Service* you need to have installed *Fast RTPS* as described in its [documentation](http://eprosima-fast-rtps.readthedocs.io/en/latest/binaries.html). You can use *Fast RTPS*
as third party too, adding `-DTHIRDPARTY=ON` in the cmake command.
To clone this project, just execute:
```bash
$ git clone --recursive https://github.com/eProsima/integration-service
```
Now, for compiling, if you are on Linux you must execute:
```bash
$ mkdir build && cd build
$ cmake ..
$ make
$ sudo make install
```
If you are on Windows you must choose a version of Visual Studio:
```bash
> mkdir build && cd build
> cmake .. -G "Visual Studio 14 2015 Win64"
> cmake --build . --target install
```
If you want to compile *eProsima Integration Service* without an installed version of *Fast RTPS* you can add
`-DTHIRDPARTY=ON` parameter that downloads it as a third party library. If you prefer to use an already installed
*Fast RTPS*, remove that parameter.
If you are on Linux you must execute:
```bash
$ mkdir build && cd build
$ cmake -DTHIRDPARTY=ON ..
$ make
$ sudo make install
```
If you are on Windows you must choose your version of Visual Studio:
```bash
> mkdir build && cd build
> cmake .. -G "Visual Studio 14 2015 Win64" -DTHIRDPARTY=ON
> cmake --build . --target install
```
### **Usage**
Once installed you can execute *Integration Service* from your terminal. It receives an unique *XML configuration
file* as parameter.
```bash
$ integration_service config.xml
```
That *XML configuration file* is needed by *Integration Service* to create all the needed components to do its job.
You should read the [documentation](https://integration-services.readthedocs.io/en/latest/configuration.html)
to know more about how to configure *Integration Service*.
### **Example application**
We will use
[domain_change]() as example.
In this example, we have generated a *Fast RTPS* example application using
[FastRTPSGen](https://eprosima-fast-rtps.readthedocs.io/en/latest/geninfo.html) and then configured
the publisher participant in domain **0**, and the subscriber participant in domain **5**.
This means that if a subscriber and a publisher are executed, there will be no communication between them,
even having the same topic and type.
Executing the *Integration Service* will create a bridge between the publisher (as a writer) and the subscriber
(as a reader), and communicate both applications.
The config file [config.xml](),
provided in this example, defines a connector like this.
```xml
```
To execute the example properly, we must first compile the example itself, from the [domain_change example location]()
Linux:
```bash
$ mkdir build
$ cd build
$ cmake ..
$ make
```
Windows:
```bash
> mkdir build
> cd build
> cmake -G "Visual Studio 14 2015 Win64" ..
> cmake --build .
```
The compilation will generate an example application named DomainChange in the build directory.
When we execute DomainChange as a publisher, it will create its participant in domain 0.
If we launch DomainChange as a subscriber, it will create its participant in domain 5 instead.
Now, we must launch DomainChange in both setups:
```bash
$ ./DomainChange publisher
```
And in another terminal:
```bash
$ ./DomainChange subscriber
```
As both instances are bound to different domains, the applications will not communicate.
But once we launch IS with the config.xml that comes with the example,
both DomainChange instances will begin to communicate.
In another terminal:
```bash
$ cd /examples/domain_change
$ integration_service config.xml
```
### **Documentation**
You can access the documentation online, which is hosted on
[Read the Docs](https://integration-services.readthedocs.io).
### **Getting Help**
If you need support you can reach us by mail at `support@eProsima.com` or by phone at `+34 91 804 34 48`.