ECF 3.11.0 - Custom Remote Services Distribution Providers

ECF 3.11.0 is released.

What's New:  A new distribution provider api to simplify the creation of Remote Services distribution providers.    We've used this new API to recently create distribution providers based upon Jax Rest Services standard (with CXF, Jersey, and RestEasy implementations) and Hazelcast.

Exposing an OSGi Service as a REST Service

In a previous tutorial I showed how to use ECF Remote Services and Jax-RS client technology to import and consume/use a REST service.

In more recent companion tutorial, I show how to use ECF Remote Services and Jax-RS server technology to export an OSGi service as a REST service.

Together, these tutorials show the use of ECF Remote Services and Jax-RS standards to easily but flexibly create, export, import, understand, and consume REST-based services.

Exposing a REST service as an OSGi Service

I've produced a tutorial describing an additional use case for Remote Services:  Exposing a Jax REST service as an OSGi Remote Service.

This describes how one can take an existing REST service and expose to consumers as an OSGi Remote Service.

ECF 3.10.1 released

ECF 3.10.1 has been released.

This is a maintenance/bug fix release since the 3.10.0/Mars release in late June.

One notable addition has been the simplification and refactoring of Karaf features, supporting the easy deployment of OSGi Remote Services in a variety of environments (e.g. Eclipse, RCP apps, Karaf servers, Equinox servers or clients, etc).

ECF 3.10/Mars Released

ECF 3.10 has been released as part of Mars.   Some highlights:

Remote Services Tooling - A new Remote Services perspective with views to help design, test, discover, and debug Remote Services

OSGi R6 - Full support for OSGi R6 Remote Services/Remote Service Admin specifications.   Full spec compliance via the OSGi compatibility test suite

New Providers - Support added for websockets and MQTT-based distribution providers, and etcd-based discovery

Apache Karaf - ECF Remote Services can now be easily installed into Apache Karaf

New Tutorials, Examples, and Documentation

More on the New and Noteworthy.  Download here or via repository included in Eclipse Mars.

ECF 3.9.3 release

ECF 3.9.3 was just released.   See here for download.

This was a maintenance/bug-fix release.  Even though a maintenance release, there have been several new non-EF code developments with ECF Remote Services since our previous release:

• Additional Remote Service tutorials
• OSGI Remote Services for OSGi Server Runtime Management
• A Websockets-based Distribution Provider for Remote Services over http/https websockets
• A MQTT-based Distribution Provider for Remote Services over MQTT

There is also work going on to create Eclipse-based Tooling for Remote Services for and after the Mars simultaneous release.  Since the design and implementation work is happening now, if you are interested in providing ideas, guidance, input, and/or contributions, please join the ecf-dev mailing list and contribute your ideas and/or expertise!

ECF 3.9.2 Released

ECF 3.9.2 was just released.  See here for download.

Along with 3.9.2 maintenance release, there is a new tutorial entitled ECF Remote Services for Accessing Existing REST Services.

Happy Holidays

ECF Remote Services for Accessing Existing REST Services

The ECF community has asked about the use of Remote Services for accessing existing web/REST-based services.   To address some of these questions, I've created a tutorial showing how ECF's open APIs can be used to easily expose an existing REST+JSON service as an OSGi Remote Service.

For this tutorial, the public Geonames Timezone service was used, but the techniques shown can be used for exposing any web-based service as an OSGi Remote Service.

ECF 3.9.1 Released

ECF 3.9.1 is now available.   See the New and Noteworthy.

Internet of Things and ECF Remote Services

Last week at EclipseCon Europe ECF committer Wim Jongman gave a talk where he cooked an egg using a hotplate, a Raspberry Pi, ECF Remote Services, and Eclipse Nebula.   Here's a screenshot of the RCP app he created to remotely control the Raspberry Pi and the connected hotplate:

Although I wasn't able to attend, I understand that after cooking, Wim consumed the egg onstage...and it went down pretty easy.  I'm looking forward to watching the video of the talk.  Congrats Wim.

Also, the Eclipse Newsletter has articles focused on Internet of Things, and we have an article about using ECF Remote Services with Raspberry Pi GPIO, which was also used to implement some of the behavior underneath Wim's egg cooker.

For other tutorials on using Remote Services with the Raspberry Pi as well as in other runtime contexts, see the ECF wiki documentation page.

ECF Remote Services Architecture

With the many updates, improvements in ECF's Remote Services releases, along with the tutorials and documentation added recently, it was time to update the Remote Services Architecture diagram.

Shellshock bug, open source maintenance and quality

Interesting NY Times article about shellshock bug, and it's relationship to open source maintenance and quality

ECF 3.9 Released

ECF 3.9.0 is released.   The release provides an update to our implementation of the OSGi Remote Services and Remote Service Admin specifications.   For RS/RSA the latest (R6) version of the specification included additions and changes, and this release supports them.

The implementation has been tested against and passed the OSGi RS RS/RSA compatibility test suite (CT).

To download and install go here.  

Note also that we now have a several tutorials focused on developing your own OSGi Remote Services.  A couple of these tutorials show how to use Remote Services with the Raspberry Pi.

Raspberry Pi GPIO using OSGi Services

I've created an API that abstracts individual GPIO Pins as OSGi services, and made it available via the ECF github repository.  This allows applications to easily use the Raspberry Pi's GPIO to send output to or receive input from peripherals.

I've also created a short tutorial on how to use these services to control a single LED.

This tutorial now has a short demonstration of how to use OSGi Remote Services to do remote control of a single GPIO Pin with Eclipse as the user interface.

ECF 3.8.1 Released

ECF's 3.8.1/Luna has been released.   Some of the highlights

• Fully compliant implementation of OSGi Remote Services and Remote Service Admin standards
• Support for Java8's CompleteableFuture for Asynchronous Remote Services
• Tutorials and documentation for OSGi Remote Services
• Support for creating and running standard remote services on MQTT protocol

A more complete list is provided by the New and Noteworthy

Congratulations to the ECF community

OSGi Remote Services on Raspberry Pi

ECF has created an example and tutorial showing the use of Java 8, OSGi, and OSGi Remote Services on the Raspberry Pi.   Any comments, suggestions, or other contributions are always welcome.

The costs of open source maintenance

Another very interesting story about Heartbleed/OpenSSL...wrt maintenance and support

• Who Should Pay to Keep the Internet's Locks Secure

Open Source In News

Two interesting articles about Heartbleed bug/OpenSSL and the Linux Foundation and OpenSSL Foundation in today's NYTimes:

• Heartbleed Highlights a Contradiction in the Web 
• OpenSSL and Linux: A Tale of Two Open-Source Projects

New tutorial on using Java8 and Asynchronous Remote Services

ECF has a new tutorial explaining how OSGi service designers may now use Java8 CompletableFuture for non-blocking remote services in ECF 3.8.1/Luna. Also present in the ECF wiki is page with additional examples and details on Asynchronous Remote Services.

CompletableFuture for OSGi Remote Services

As some of you may know, ECF's implementation of OSGi Remote Services has support for asynchronous proxies.   This allows consumers of remote services to easily use asynchronous/non-blocking invocation to access a remote service.  For example...here's a simple service interface that's used in our remote service tutorial:

public interface ITimeService {
    public Long getCurrentTime();
}

As with any OSGi Remote Service, any consumer that discovers this service will potentially block when they call getCurrentTime(). This is just the nature of call/return semantics applied to remoting...and so will be true for any implementation of OSGi remote services.

ECF's impl of OSGi Remote Service offers asynchronous proxies, meaning that iff a related service interface is defined...e.g.

public interface ITimeServiceAsync {
    public Future getCurrentTimeAsync();
}

then consumers will be able to use ITimeServiceAsync to access the service...e.g:

ITimeServiceAsync tsa = ... get ITimeServiceAsync reference

Future timeFuture = tsa.getCurrentTimeAsync();
...do work...
Long time = timeFuture.get();

With ECF 3.8.0 we further added [3]...i.e. the ability to have ITimeServiceAsync be registered as a service automatically on the consumer...so that (e.g.) the ITimeServiceAsync reference can be injected via declarative services...e.g.

...ds component impl...

void bindTimeServiceAsync(ITimeServiceAsync tsa) {
     ...use or store tsa...
}

This [3] is all available in ECF 3.8.0.   Note that the service interfaces have absolutely no reference to ECF classes, nor to OSGi classes.   None are needed now.

As many of you certainly know...java8 just came out, and a big part of java8 is improved support for concurrency, functional programming, and lambdas.    This support for concurrency in java8 is potentially very useful for users of OSGi Remote Services.

Consider CompletableFuture, which as the name implies is a type of java.util.concurrent.Future.    It has some very nice properties for API/service designers...the main one being that it's not at all necessary to call Future.get directly...but rather you can write nice, succinct and *guaranteed to be non-blocking but asynchronous* usage such as:

CompletableFuture cf = ...get CompletableFuture....

cf.thenAccept((time) -> System.out.println("time is: " + time));

This is nice...it's completely non-blocking...and very succinct.  Also you can do very interesting things with asynchronous/event-driven chaining/filtering, etc., etc. All guaranteed to be non-blocking...which is a key guarantee for remoting.

Yesterday I realized that with Java8, our asynchronous proxies could be easily generalized to allow this:

public interface ITimeServiceAsync {
    public CompletableFuture getCurrentTimeAsync();
}

I made some minor additions to the ECF remote service implementation of asynchronous proxies and now this is working. What I mean by this is that consumers of an arbitrary remote service can now do this

...service component impl...

void bindTimeServiceAsync(ITimeServiceAsync tsa) {
       // Get the CompletableFuture...no blocking here
       CompletableFuture cf = tsa.getCurrentTimeAsync();
       // print out time when done...no blocking anywhere!
       cf.thenAccept((time) -> System.out.println("Remote time is: " + time));
}

Note a few things:

1. There is no blocking anywhere.  This is true even though the actual time value is retrieved via a remote OSGi service
2. The remote service host doesn't have to provide any implementation of ITimeServiceAsync.  It's constructed by ECF's RS impl automatically
3. It's very easy to handle failure (e.g. network/io failure) via CompletableFuture.handle.  This is obviously a big deal for remote services...which are much more inclined to fail because of the network.
4. No reference to either OSGi classes or ECF classes anywhere in host or consumer code

This is nice for remote service consumers, because it gives them strong no blocking guarantees, and can be very efficiently implemented (no additional threads) by remote service providers using asynchronous messaging (e.g. JMS, etc).   It also allows them to use all of CompletableFuture's APIs (see CompletableFuture javadoc).

This will obviously be part of ECF Luna...and I've created some test code (like above) that I intend to use to create another tutorial over the next month. Watch the ECF wiki for that tutorial.

The only drawback is that this does, of course, depend upon Java8...and so requires that both the remote service host and consumer use Java8, and that the distribution provider be enhanced slightly to use CompletableFuture.   Fortunately it's not technically challenging to make these enhancements, and we will make support classes available for those that wish to Java8 enhance existing or their own RS provider.

[1] https://wiki.eclipse.org/ECF/Asynchronous_Remote_Services
[2] https://wiki.eclipse.org/Tutorial:_Building_your_first_OSGi_Remote_Service
[3] https://bugs.eclipse.org/bugs/show_bug.cgi?id=420785