View source for Tutorial: Creating Custom Distribution Providers

<!-- This CSS wraps code blocks in pretty boxes -->
<css>
.mw-code { 
  background-color: #fafafa; 
  padding: 20px; 
  border-color: #ddd; 
  border-width: 3px; 
  border-style: solid; 
  border-radius: 5px; 
  margin-left: 10px; 
  margin-right: 10px; 
  overflow-x: auto; 
}

.mw-headline {
  font-family: Helvetica Neue,Helvetica,Arial,sans-serif;
  color: rgb(51, 51, 51);
}

p {
  font-family: Helvetica Neue,Helvetica,Arial,sans-serif;
  text-align: justify;
}

h1 {
  border-bottom-color: rgb(238, 238, 238);
  font-weight: bold;
  padding-bottom: 17px;
  font-size: 30px;
  line-height: 36px;
}

h2 {
  border-bottom-color: rgb(238, 238, 238);
  padding-bottom: 12px;
  font-weight: bold;
  font-size: 24px;
  line-height: 36px;
}

h3 {
  border-bottom-width: 1px;
  border-bottom-style: solid;
  border-bottom-color: rgb(238, 238, 238);
  padding-bottom: 8px;
  font-size: 18px;
  line-height: 27px;
}

h4 {
  font-size: 14px;
}

h5 {
  font-size: 12px;
}

h6 {
  font-size: 11px;
  color: #EBEBEB;
  text-transform: uppercase;
}

a {
  color: rgb(0, 105, 214);
  font-family: Helvetica Neue,Helvetica,Arial,sans-serif;
}

a:visited {
  color: rgb(0, 105, 214);
}
</css>

==Introduction==

The ECF project provides an implementation of the OSGi R6 [https://www.osgi.org/developer/specifications/ Remote Services and Remote Service Admin specifications].  The RSA specification defines two major subsystems:  discovery and distribution.   Discovery concerns finding remote services exported by other processes on the network.  The distribution subsystem is responsible for the actual communication of invoking a remote call:  serializing remote method parameters, communicating with the remote service host via some network transport protocol, unmarshalling and invoking the service method with provided parameters, and returning a result to the consumer.

ECF's implementation of RSA defines an API to create new distribution providers.  This API is declared in the [[Distribution_Providers#Remote_Services_API | ECF remote services API, provided by the org.eclipse.ecf.remoteservices bundle]].  Custom distribution providers implement a portion of this API and then will be used at runtime to supply the necessary functions of the distribution provider.

This tutorial will describe the creation of a simple custom distribution provider using the relevant portions of the ECF remote services API.

==Remote Service Containers, IDs, and Namespaces==

ECF has the concept of a 'container' ([http://download.eclipse.org/rt/ecf/3.13.0/javadoc/org/eclipse/ecf/core/IContainer.html IContainer]), which is an object instance that implements the remote services API and represents a network-accessible endpoint.

Containers have unique transport-specific [http://download.eclipse.org/rt/ecf/3.13.0/javadoc/org/eclipse/ecf/core/identity/ID.html ID].  Some examples of transport-specific container IDs:<br>

https://myhost.com/v1/path/to/service<br>
ecftcp://localhost:3282/server<br>
mqtt://mybroker.com/mytopic<br>
jms:tcp://jmsbroker.com:6686/jmstopic<br>
r_osgi://somehost/<br>
hazelcast:///mytopicname<br>
g6YuiWAjkk34je1lJlNmv==<br>
uuid:de305d54-75b4-431b-adb2-eb6b9e546014<br>
241<br>

Each ID instance must be unique within a [http://download.eclipse.org/rt/ecf/latest/javadoc/org/eclipse/ecf/core/identity/Namespace.html Namespace].  Distribution providers must define a new Namespace that enforces the expected syntax requirements of the endpoint identifier.

==Registering a new Namespace==

The first thing a distribution provider must do is to register a new type of Namespace.  ECF provides a number of Namespace classes that can be extended to make this easy.  For example, the URIIDNamespace can handle any ID syntax that can be represented as a URI, like all of the above.  Here is an example Namespace class that extends the URIIDNamespace:

<source lang="java">
public class Example1Namespace extends URIIDNamespace {

	private static final long serialVersionUID = 2460015768559081873L;

	public static final String NAME = "ecf.example1.namespace";
	private static final String SCHEME = "ecf.example1";
	private static Example1Namespace INSTANCE;
	
	/**
	 * The singleton instance of this namespace is created (and registered
	 * as a Namespace service) in the Activator class for this bundle.
	 * The singleton INSTANCE may then be used by both server and client.
	 */
	public Example1Namespace() {
		super(NAME, "Example 1 Namespace");
		INSTANCE = this;
	}

	public static Example1Namespace getInstance() {
		return INSTANCE;
	}
	
	@Override
	public String getScheme() {
		return SCHEME;
	}
}
</source>

In bundle Activator start, the singleton Example1Namespace is created and registered:

<source lang="java">
// Create and register the Example1Namespace
context.registerService(org.eclipse.ecf.core.identity.Namespace.class, new Example1Namespace(),  null);
</source>

The same Example1Namespace type must be used by both servers and clients, and so it typically makes sense to define the Namespace in a small common bundle, which can be deployed on both servers and clients.   For the source code for this example, see the [https://github.com/ECF/ExampleRSADistributionProviders/tree/master/bundles/org.eclipse.ecf.example1.provider.dist.common bundle here].

Note that other type of ID syntax can be easily supported by either inheriting from other Namespace classes (e.g. LongIDNamespace, StringIDNamespace, etc.), or creating one's own Namespace subclass.

==Registering the Distribution Provider Server==

==Service-Level Concerns==

Although frequently of secondary concern to service implementers, service-level concerns are typically of primary importance to service '''consumers'''.  For example, before I can use any REST-based service, I have to know about (discover) the service and needed meta-data:  the service location (i.e. it's URL), what methods exist and arguments are required, and what can be expected in response.  Additionally, what version of the service is being accessed, what credentials/security are required, what are the run-time qualities of the remote service? 

===OSGi Remote Services===

In recent releases the OSGi Alliance has defined a specification called [http://www.osgi.org/Specifications/HomePage Remote Services] (chapter 100 in the enterprise spec).  Along with the Remote Service Admin specification (chapter 122 in enterprise spec), Remote Services defines ways to express answers to service-level concerns in an implementation-independent way, similar to what JAX-RS does for transport-level concerns.  For example, the Remote Service spec allows meta-data for service type, service version, service endpoint/URL identification, security, and quality of service properties to be communicated between service implementer and service consumer without referring to any Remote Services implementation.   Further, Remote Services/RSA defines a way to dynamically discover and un-discover remote services, allowing for easy consumer support for networked and frequently unreliable services.

Several implementations of OSGi Remote Services exist, including open source [https://wiki.eclipse.org/ECF#OSGi_Remote_Services ECF], [http://cxf.apache.org/ CXF], [http://www.amdatu.org/ Amdatu] and commercial implementations.

OSGi RSA has the concept of a distribution system responsible for exporting a local service and making it available for remote access.  According to the specification, many distributions systems may be used even for a single service.  ECF's implementation is unique because it has an open API for creating/adding new distribution providers.  Currently, ECF committers have implemented the following distribution providers

*[https://www.eclipse.org/ecf/downloads.php ECF 'generic']
*[https://www.eclipse.org/ecf/downloads.php r-OSGi]
*[https://github.com/ECF/JMS Java Messaging Service (JMS)]
*[https://github.com/ECF/Mqtt-Provider MQTT]
*[https://github.com/ECF/HazelcastProvider Hazelcast]
*[https://github.com/ECF/JGroups JavaGroups]
*[https://github.com/ECF/JaxRSProviders Jax-RS/Jersey and Jax-RS/CXF ]

==Jax-RS with OSGi Remote Services==

Since ECF's RSA implementation implements the OSGi RS and RSA specifications, and Jersey implements the Jax-RS specification, it's possible create and export a remote service that deals with both the transport and service-level concerns in a way completely standardized, and not dependent upon either the OSGi RS/RSA implementation (e.g. ECF), nor on the distribution system provider implementation (Jersey).

For example, here is some example OSGi code for exporting a remote service using the [https://github.com/ECF/JaxRSProviders Jax-RS/Jersey] provider:

<source lang="java">
BundleContext bundleContext;
Dictionary<String, String> props = new Hashtable<String,String>();
// osgi rs property to signal to distribution system 
// that this is a remote service
props.put("service.exported.interfaces","*");
// specify the distribution provider with osgi rs property
props.put("service.exported.configs", "ecf.jaxrs.jersey.server");
// as per spec, <provider>.<prop> represents a property intended for use by this provider
props.put("ecf.jaxrs.jersey.server.alias", "/jersey");
// register (and export) HelloImpl as remote service described by Hello interface
bundleContext.registerService(HelloWorldService.class, new HelloWorldResource(), props);
</source>

HelloWorldResource implements a HelloWorldService interface which is defined

<source lang="java">
import javax.ws.rs.GET;
import javax.ws.rs.Produces;
import javax.ws.rs.Path;

// The Java class will be hosted at the URI path "/helloworld"
@Path("/helloworld")
public interface HelloWorldService {
    
    // The Java method will process HTTP GET requests
    @GET
    // The Java method will produce content identified by the MIME Media
    // type "text/plain"
    @Produces("text/plain")
    public String getMessage();
}
</source>

Note that the HelloWorldService has exactly the same Jax-RS annotations as the HelloWorldResource implementation class.

With the Jax-RS/Jersey distribution provider, the above registerService call will dynamically export the remote service (via Jersey) so that remote clients (Java/OSGi-based or not) can access getMessage by sending a GET to an URL like this:

curl http://localhost:8080/jersey/helloworld/1

Would respond with "Hello World"

The use of Jax-RS annotations to implement an ECF distribution provider, and the use of OSGi Remote Services has several important advantages for the service implementer and the service consumer:

#An ability to flexibly handle both transport-level and service-level concerns in a way appropriate to the application
#A clean separation between service contract (HelloWorldService interface), and service implementation (HelloWorldResource)
#A clean separation between application concerns from transport '''or''' service-level concerns 
#Alternative implementations of Jax-RS and/or OSGi RS/RSA may be substituted at any time without application changes

==Using the Remote Service==

Since the HelloWorldService is exported via Jax-RS/Jersey provider, it may be accessed by any client (e.g. javascript, java, curl, etc) that can access via http calls.  If, however, it is an OSGi client (or a non-OSGi Java Client) ECF Remote Service can automatically construct a proxy for the remote service, and make the proxy available as an OSGi Service on the client.   For a description and example of doing this, see
[[Tutorial:_Exposing_a_Jax_REST_service_as_an_OSGi_Remote_Service | Exposing a Jax REST Service as an OSGi Service]].

==A More Complete Example==

A more complex example exists in the [https://github.com/ECF/JaxRSProviders Jax-RS/Jersey Provider] repo.  The remote service host/server is in the [https://github.com/ECF/JaxRSProviders/tree/master/examples/com.mycorp.examples.student.remoteservice.host com.mycorp.examples.student.remoteservice.host] bundle.  The remote service consumer/client is in [https://github.com/ECF/JaxRSProviders/tree/master/examples/com.mycorp.examples.student.client com.mycorp.examples.student.client] bundle.  Notice that neither of these bundles has references to ECF, Jersey, or even OSGi classes, but rather only to Jax-RS standard annotation types (javax.*) and model classes defined in the [https://github.com/ECF/JaxRSProviders/tree/master/examples/com.mycorp.examples.student com.mycorp.examples.student] bundle.

==Background and Related Articles==

[[Tutorial: Exposing a Jax REST service as an OSGi Remote Service]]

[[Getting Started with ECF's OSGi Remote Services Implementation]]

[[OSGi Remote Services and ECF]]

[[Asynchronous Proxies for Remote Services]]

[[File-based Discovery | Static File-based Discovery of Remote Service Endpoints]]

[[EIG:Download|Download ECF Remote Services/RSA Implementation]]

[[EIG:Add to Target Platform|How to Add Remote Services/RSA to Your Target Platform]]