KIARA - FIWARE Advanced Middleware

Overview

KIARA Fiware Advanced Middleware is a Java based communication middleware for modern, efficient and secure applications. It is an implementation of the FIWARE Advanced Middleware Generic Enabler (GE).

The Advanced Middleware GE is a set of compile-time and run-time tools, and a communication library to be integrated with the application. Thus, the requirements are rather minimal. In particular it requires no service running in the background.

KIARA implements transparent, fast, secure and standard conform communication between applications or services running on multiple machines using different Operating Systems. It also provides a friendly and extensible API.

The FIWARE platform offers a powerful set of components (Generic Enablers) providing APIs (Application Programming Interfaces) that ease the development of Smart Applications in multiple vertical sectors.

The FIWARE catalogue contains a rich library of reference implementations of the components (Generic Enablers) that allow developers to implement functionalities such as the connection to the Internet of Things or Big Data analysis, making programming much easier.

Features

This first release focuses on the basic features of RPC and Publish/Subscribe communication:

• Easy to use and extensible Application Programmer Interface (API). Synchronous and Asynchronous function calls.
• Modern Interface Definition Language (IDL) → based on Corba IDL.
  • OMG compliant
  • Extended primitive types.
• IDL derived operation mode for the RPC Client/Server communication pattern
  • By generating Stubs and Skeletons at compile time → RPC API
  • By using proxies to provide and call the functions at runtime → RPC Dynamic Types API
• IDL derived operation mode for the Publish/Subscribe communication pattern
• TLS encryption for secure communication

Roadmap

Upcoming versions will include additional features:

• Advanced security features, like field encryption and authentication
• Application derived and mapped operation mode providing dynamic declaration of functions and data type mapping in source code.

Getting started

Hello World Video

The following video shows a basic Hello World implementation using KIARA. For more details see the example below or check the documentation section.

A quick example

In the IDL derived approach, first the IDL (Interface Definition Language) definition of the remote functions has to be created:

service Calculator {
     float32 add (float32 n1, float32 n2);
     float32 subtract (float32 n1, float32 n2);
};

The developer has to implement the server side functions of the class CalculatorServantImpl:

public static class CalculatorServantImpl extends CalculatorServant
{
     @Override
     public float add (/*in*/ float n1, /*in*/ float n2) {
          return (float) n1 + n2;
     }

     @Override
     public float subtract (/*in*/ float n1, /*in*/ float n2) {
         return (float) n1 - n2;
     }
     ...
}

Now the server can be started:

// Create context, server and service
Context context = Kiara.createContext();
Server server = context.createServer();
Service service = context.createService();

// Create and register an instance of the CalculatorServant implementation.
CalculatorServant Calculator_impl = new CalculatorServantImpl();
service.register(Calculator_impl);

// register the service on port 9090 using CDR serialization 
server.addService(service, "tcp://0.0.0.0:9090", "cdr");

// run the server
server.run();

The client can connect and call the remote functions via the generated proxy class:

// Create context
Context context = Kiara.createContext();

// setup the connection to the server
Connection connection = context.connect("tcp://192.168.1.18:9090?serialization=cdr");

// get the client Proxy implementation
CalculatorClient client = connection.getServiceProxy(CalculatorClient.class);

// Call the remote methods
float result = client.add(3, 5);

Documentation

Find the full documentation on Read The Docs:

• Installation and Administration Guide
• User and Programmer Guide
• Open Specification
• API Specifications:
  • RPC API Specification
  • RPC Dynamic Types API Specification
  • Publish/Subscribe API Specification
  • IDL Specification

Download

KIARA is implemented as a Java Library and published on Maven-Central. It can be used with every modern build management tool like Maven or Gradle. For basic usage please check our Installation Manual and User Guide.

To download the source code check out the KIARA Github repository or download the archive:

Download.zip file Download.tar.gz file

Community & Support

To report bugs or request features, submit issues here on GitHub. For additional resources, you can contact the maintainers directly. For general questions and discussions please use the KIARA-discuss mailing list. Once you subscribe to the list, you can send mail to the list address: icclab-KIARA@dornbirn.zhaw.ch. The mailing list archives are also available on the web.

And of course you can follow us on the ICCLab blog for news and updates.

License

KIARA is licensed under the Lesser GNU Public License (LGPL).

Provided by

in colaboration with

Supported by