Link to two Felix instances

Here is yet another post in Maven + Apache Felix + CXF + DOSGi series.

Here I will show how to use Apache CXF DOSGi for cosuming remote services. You may see the sources on my GitHub account.

We will have three projects dosgiRemote.service, dosgiRemote.service.api and dosgiRemote.consumer. dosgiRemote.service.api provides an interface for a service. dosgiRemote.service provides implementation for the service. dosgiRemote.consume will consume the service.
dosgiRemote.service.api has to be shared between dosgiRemote.service and dosgiRemote.consumer as both has to know which service they are publishing and consuming. dosgiRemote.service.api and dosgiRemote.service will run in one OSGi container. dosgiRemote.service.api and dosgiRemote.consumer will run in another OSGi container. You may see how to do that in Eclipse in the previous post.

dosgiRemote.service.api contains the following interface to a service:

package dk.sorokin.maksim.dosgiRemote.service.api;

import javax.ws.rs.GET;
import javax.ws.rs.Path;
import javax.ws.rs.PathParam;
import javax.ws.rs.Produces;
import javax.ws.rs.core.MediaType;

@Path("greeter")
public interface Greeter {

  @GET
  @Path("sayHello/{name}")
  @Produces(MediaType.TEXT_PLAIN)
  String sayHello(@PathParam("name") String name);
}

dosgiRemote.service provides the following implementation:

package dk.sorokin.maksim.dosgiRemote.internal.service;

import dk.sorokin.maksim.dosgiRemote.service.api.Greeter;

public class GreeterImpl implements Greeter {

  public String sayHello(String name) {
    return "Hello, " + name;
  }
}

Also, dosgiRemote.service registers a service in the following way:

package dk.sorokin.maksim.dosgiRemote.internal;

import java.util.Dictionary;
import java.util.Hashtable;

import org.osgi.framework.BundleActivator;
import org.osgi.framework.BundleContext;

import dk.sorokin.maksim.dosgiRemote.internal.service.GreeterImpl;
import dk.sorokin.maksim.dosgiRemote.service.api.Greeter;

public class Activator implements BundleActivator {

  public void start(BundleContext context) throws Exception {
    Dictionary<String, String> restProps = new Hashtable<String, String>();

    restProps.put("service.exported.interfaces", "*");
    restProps.put("service.exported.configs", "org.apache.cxf.rs");
    restProps.put("service.exported.intents", "HTTP");
    restProps.put("org.apache.cxf.rs.address", "http://localhost:8080/");
    context.registerService(Greeter.class.getName(), new GreeterImpl(), restProps);
  }

  public void stop(BundleContext context) throws Exception {
    //
  }
}

dosgiRemote.consumer will have OSGI-INF\remote-service\remote-services.xml, according to DOSGi documentation:

<?xml version="1.0" encoding="UTF-8"?>
<service-descriptions xmlns="http://www.osgi.org/xmlns/sd/v1.0.0">
  <service-description>
    <provide interface="dk.sorokin.maksim.dosgiRemote.service.api.Greeter" />
    <property name="service.exported.interfaces">*</property>
    <property name="service.exported.configs">org.apache.cxf.rs</property>
    <property name="service.exported.intents">HTTP</property>
    <property name="org.apache.cxf.rs.address">http://localhost:8080</property>
  </service-description>
</service-descriptions>

And the Activator class for dosgiRemote.consumer will be:

package dk.sorokin.maksim.dosgiRemote.consumer.internal;

import org.osgi.framework.BundleActivator;
import org.osgi.framework.BundleContext;
import org.osgi.framework.ServiceReference;
import org.osgi.util.tracker.ServiceTracker;

import dk.sorokin.maksim.dosgiRemote.service.api.Greeter;

public class Activator implements BundleActivator {

  @Override
  public void start(BundleContext context) throws Exception {
    ServiceTracker serviceTracker = new ServiceTracker(context, Greeter.class.getName(), null) {
      @Override
      public Object addingService(ServiceReference reference) {
        Object result = super.addingService(reference);

        Object svc = context.getService(reference);
        if (svc instanceof Greeter) {
          final Greeter greeter = (Greeter) svc;
          System.out.println(greeter.sayHello("Max"));
        }

        return result;
      }
    };
    serviceTracker.open();
  }

  public void stop(BundleContext context) throws Exception {
    //
  }
}

We will have two startup configuration for Apache Felix, as described above. The first one:

felix.auto.deploy.action=install,start
felix.log.level=1

org.osgi.framework.storage.clean=onFirstInit

felix.auto.start.1 = \
 assembly:/C:/projects/dosgiRemote/dosgiRemote.service.api/target/classes \
 assembly:/C:/projects/dosgiRemote/dosgiRemote.service/target/classes

And the second one:

felix.auto.deploy.action=install,start
felix.log.level=1

org.osgi.framework.storage.clean=onFirstInit

felix.auto.start.1 = \
 assembly:/C:/projects/dosgiRemote/dosgiRemote.service.api/target/classes \
 assembly:/C:/projects/dosgiRemote/dosgiRemote.service/target/classes

Launch the first configuration and then the second. You should see the following message in the console:

Hello, Max

You could also see the same message in the browser on http://localhost:8080/greeter/sayHello/Max.

You may pass objects as well. Refer to previous posts to do that.

You can take the sources from may GitHub account.

We will have three projects here. The first one defines an interface for a service. Another one provides implementation for it. And the third one will provide security.

dosgiSecurity
    dosgiSecurity-api
    dosgiSecurity-impl
    dosgiSecurity-security

dosgiSecurity will be just a holder project.

Our interface HelloService in bundle dosgiSecurity-api will be similar to the one we defined in previous posts:

package dk.sorokin.maksim.dosgiSecurity.api;

import javax.ws.rs.GET;
import javax.ws.rs.Path;
import javax.ws.rs.PathParam;
import javax.ws.rs.Produces;
import javax.ws.rs.core.MediaType;

@Path("helloService")
public interface HelloService {

  @GET
  @Path("sayHello/{name}")
  @Produces(MediaType.TEXT_PLAIN)
  String sayHello(@PathParam("name") String name);
}

And implementation class HelloServiceImpl in bundle dosgiSecurity-impl:

package dk.sorokin.maksim.dosgiSecurity.impl.internal.service;

import dk.sorokin.maksim.dosgiSecurity.api.HelloService;

public class HelloServiceImpl implements HelloService {

  public String sayHello(String name) {
    return "Hello " + name;
  }
}

And SecurityFilter in bundle dosgiSecurity-security, is just a servlet filter. It checks for Authorization header and verifies it:

package dk.sorokin.maksim.dosgiSecurity.impl.internal.service;

import dk.sorokin.maksim.dosgiSecurity.api.HelloService;

public class HelloServiceImpl implements HelloService {

  public String sayHello(String name) {
    return "Hello " + name;
  }
}

The service is published in an Activator in dosgiSecurity.impl:

package dk.sorokin.maksim.dosgiSecurity.impl.internal;

import java.util.Dictionary;
import java.util.Hashtable;

import javax.servlet.Filter;

import org.osgi.framework.BundleActivator;
import org.osgi.framework.BundleContext;

import dk.sorokin.maksim.dosgiSecurity.api.HelloService;
import dk.sorokin.maksim.dosgiSecurity.impl.internal.service.HelloServiceImpl;
import dk.sorokin.maksim.dosgiSecurity.security.SecurityFilter;

public class Activator implements BundleActivator {

  public void start(BundleContext context) throws Exception {
    Dictionary<String, String> restProps = new Hashtable<String, String>();

    restProps.put("service.exported.interfaces", "*");
    restProps.put("service.exported.configs", "org.apache.cxf.rs");
    restProps.put("service.exported.intents", "HTTP");
    restProps.put("org.apache.cxf.rs.httpservice.context", "/secured");
    restProps.put("org.apache.cxf.rs.address", "http://localhost:8080/");
    context.registerService(HelloService.class.getName(), new HelloServiceImpl(), restProps);

    Dictionary<String, String> filterProps = new Hashtable<String, String>();
    filterProps.put("org.apache.cxf.httpservice.filter", Boolean.TRUE.toString());
    filterProps.put("servletNames", "none");
    context.registerService(Filter.class.getName(), new SecurityFilter(), filterProps);
  }

  public void stop(BundleContext context) throws Exception {
    //
  }
}

And a Felix Launcher (refer to the first post in series) is:

felix.auto.deploy.action=install,start
felix.log.level=1

org.osgi.framework.storage.clean=onFirstInit

felix.auto.start.1 = \
 assembly:/C:/projects/dosgiSecurity/dosgiSecurity.security/target/classes \
 assembly:/C:/projects/dosgiSecurity/dosgiSecurity.api/target/classes \
 assembly:/C:/projects/dosgiSecurity/dosgiSecurity.impl/target/classes

Now build all that with Maven using mvn clean install and run it (assuming that you have DOSGi Single Bundle Distribution in Felix, as we discussed in previous posts). When Felix is launched, go to http://localhost:8080/secured/helloService/sayHello/Max. You should see:

HTTP ERROR: 403

FORBIDDEN
RequestURI=/secured/helloService/sayHello/Max

Powered by Jetty://

Now launch Fiddler2 (or similar program) and build custom request with Request Builder with the same url as shown above. And add the following line in "Request Headers":

Authorization: Basic U3V6eTpyb2NrZXQ=

You should get:

HTTP/1.1 200 OK
Content-Type: text/plain
Date: Tue, 02 Aug 2011 15:15:43 GMT
Content-Length: 9
Server: Jetty(6.1.x)

Hello max

Source files can be found here

@echo off

:: At this point you can place assumptions about Java version. It is still better than nothing anyway. In this particular case, we rely on a knowledge of Java version during installation time (with IzPack). Or you can just specify default value here, for example by default assume that 32 version is being run
set JVM_VERSION=""
if $SYSTEM_os_arch==x86 (
  set JVM_VERSION=32
) else (
  set JVM_VERSION=64
)
:: End of assumption section

:: Now trying to find out, what is current jvm version.

set TEMP_FILE=%TEMP%\javaCheck%RANDOM%%TIME:~9,5%.txt

java -version 2>%TEMP_FILE%
FOR /F "tokens=*" %%i in (%TEMP_FILE%) do (
  echo %%i | find "HotSpot" >nul
  if not errorlevel 1 (
    echo %%i | find "64-Bit" >nul
    if not errorlevel 1 (
      set JVM_VERSION=64
    ) else (
      set JVM_VERSION=32
    )
  )
)

del %TEMP_FILE%

if %JVM_VERSION%==32 (
  set NATIVE_JARS=$INSTALL_PATH/lib/32
) else (
  set NATIVE_JARS=$INSTALL_PATH/lib/64
)

start "App" javaw -classpath .;"%NATIVE_JARS%/*" my.app.App

The trick is to redirect java -version to a temporary file. Then try to find a line with "HotSpot" substring. If that line contains "64-Bit", then it is 64bit version Java. Otherwise it is 32bit.

The motivation is quite simple. One may need an estimate of the distance between two points on the map using ZIP codes. This may be because you do not have any real addresses. Or just you are totally fine with just a direct distance between two ZIP codes areas.
One could go several ways. Hire a lady to query all possible into Google Maps and get coordinates from there. Or try getting some information from the post office. Or just try finding coordinates on the Internet. But we will go slightly different way using the power of Yahoo Query Language (YQL).

First, let's have some tests. We will query Google Maps for a zip code and compare coordinates with Yahoo Query Language (YQL) results.
Let's test with Hellerup. We go to Google Maps and query for "2900, Denmark".

Now we go to YQL Console and use "get san francisco geo data" example from the right. And change the query to the following select centroid from geo.places where text="2900, Denmark". After querying, we check centroid tag from XML output:

<centroid>
	<latitude>55.736462</latitude>
	<longitude>12.561010</longitude>
</centroid>

Then we use these coordinates in Google Maps to check the location.

One may also try querying select centroid from geo.places where text="2900, Hellerup Denmark" (Hellerup was added to the query), which would result in a little North-East location. But it actually does not really matter. First of all, 500-1000 meters error is tolerable. The second thing, both results can be right since the real ZIP code center may not exist.

We will use YQL the rest query. So for instance Hellerup ZIP code query url would look like:

http://query.yahooapis.com/v1/public/yql?q=select%20centroid%20from%20geo.places%20where%20text%3D%222900%2C%20Denmark%22

The HTTP response to this query is the following:

<?xml version="1.0" encoding="UTF-8"?>
<query xmlns:yahoo="http://www.yahooapis.com/v1/base.rng"
	yahoo:count="1" yahoo:created="2011-04-18T07:34:03Z" yahoo:lang="en-US">
	<results>
		<place xmlns="http://where.yahooapis.com/v1/schema.rng">
			<centroid>
				<latitude>55.650162</latitude>
				<longitude>12.534110</longitude>
			</centroid>
		</place>
	</results>
</query>
<!-- total: 124 -->
<!-- engine5.yql.ird.yahoo.com -->

Next what we need are Denmark's ZIP codes. One may find them somwhere on the internet.
We write a simple Java program which would use the YQL rest query with all ZIP codes.

In our case we have 580 ZIP codes, so for easier maintenance we move them to a separate class.

package dk.sorokin.maksim.zipCodes;

public class ZipCodes {

  static int ZIP_CODES[] = { 1000, 1600, 2000, 2100, 2200, ...};
}

And then querying class. YQL has some limits and restrictions. Since we are not using any authentication, we are not allowed to make queries rapidly. Therefore, in current case we limit querying to 1 time per 4 seconds:

package dk.sorokin.maksim.zipCodes;

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.URI;
import java.net.URL;

public class App {

  private final static String YQL_ZIP_QUERY_SCHEME = "http";
  private final static String YQL_ZIP_QUERY_HOST = "query.yahooapis.com";
  private final static String YQL_ZIP_QUERY_PATH = "/v1/public/yql";
  private final static String YQL_ZIP_QUERY_QUERY = "q=select centroid from geo.places where text=\"%d, Denmark\"";

  private final static String CENTROID_TAG_OPEN = "<centroid>";
  private final static String LATITUDE_TAG_OPEN = "<latitude>";
  private final static String LATITUDE_TAG_CLOSE = "</latitude>";
  private final static String LONGITUDE_TAG_OPEN = "<longitude>";
  private final static String LONGITUDE_TAG_CLOSE = "</longitude>";

  public static void main(String[] args) throws Exception {
    for (int zipCode : ZipCodes.ZIP_CODES) {
      Thread.sleep(4000);
      URL url = buildYQLURL(zipCode);
      // System.out.println(url);

      BufferedReader in = new BufferedReader(new InputStreamReader(url.openStream()));
      String str;
      while ((str = in.readLine()) != null) {
        tryParsingCentroid(str);
      }
      System.out.println(zipCode + ";");
      in.close();
    }
  }

  private static URL buildYQLURL(int zipCode) throws Exception {
    return new URI(
        YQL_ZIP_QUERY_SCHEME,
        YQL_ZIP_QUERY_HOST,
        YQL_ZIP_QUERY_PATH,
        String.format(YQL_ZIP_QUERY_QUERY, zipCode), null).toURL();
  }

  private static void tryParsingCentroid(String s) {
    if (s.contains(CENTROID_TAG_OPEN)) {
      System.out.print(
          s.substring(
              s.indexOf(LATITUDE_TAG_OPEN) + LATITUDE_TAG_OPEN.length(),
              s.indexOf(LATITUDE_TAG_CLOSE)));
      System.out.print(",");
      System.out.print(
          s.substring(
              s.indexOf(LONGITUDE_TAG_OPEN) + LONGITUDE_TAG_OPEN.length(),
              s.indexOf(LONGITUDE_TAG_CLOSE)));
      System.out.print(",");
    }
  }
}

And our output is the following:

55.676239,12.567470,1000;
55.680271,12.561970,1600;
55.681770,12.516840,2000;
55.706051,12.580990,2100;
55.697071,12.548240,2200;
55.651428,12.582240,2300;
...

What we can do with it? Import to a database as CSV or using regular expressions generate SQL insert statements.

Add a maven-artifact dependency

<dependency>
  <groupId>org.apache.maven</groupId>
  <artifactId>maven-artifact</artifactId>
  <version>3.0.3</version>
</dependency>

Then you could write something like this:

public int compare(String version1, String version2) {
  ArtifactVersion mavenVersion1 = new DefaultArtifactVersion(version1);
  ArtifactVersion mavenVersion2 = new DefaultArtifactVersion(version2);

  int result = mavenVersion1.compareTo(mavenVersion2);

  return result;
}

You will of course need to depend on IzPack standalone compiler.

Basically, what do you need to do is to have some directory for staging. This is useful, when you want to run some filtering or putting some additional resources from somewhere else to the installer. You can use %TEMP% directory (File.createTempFile(...)) for that. Do not forget to wipe it afterwards!
When you have all your installer resources in some staging directory and you know the direct path to your install.xml you are ready to build a installer:

CompilerConfig compilerConfig = new CompilerConfig(installXmlPath, stagingDirPath, null, targetFilePath);
compilerConfig.executeCompiler();

<registryReader>
  <registry key="SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\myApp"
      name="DisplayVersion" default="null" variable="myApp.version" />
</registryReader>

You may have several registry entries to read multiple keys. name specifies registry key. variable specifies to which variable to store the value. default specifies what should be a default value, when key was not found.

You will also need to provide COI dlls in install.xml:

<native type="3rdparty" name="COIOSHelper.dll" stage="both">
  <os family="windows" />
</native>
<native type="3rdparty" name="COIOSHelper_x64.dll" stage="both">
  <os family="windows" />
</native>

You will need to separate COI package yourself and add it to your Maven repository.

And here is the panel source:izpackExtensions-registryReader

You will need to add AutomationHelper class. Here is how you can do it. Assuming you have custom panel with a name MyPanel, create class MyPanelAutomationHelper in the same package. This class has to extend PanelAutomationHelper and implement PanelAutomation. And then you will have to specify how to run the panel silently.
Basically, you can just repeat all the routine from panelActivate method in MyPanel panel (or if you do not want to repeat yourself, invoke/call MyPanel smartly). But you cannot use UI stuff like emitWarning or emitError. If you need to inform user about something -- write it directly to the output. Silent installer should be silent.

Here is AutomationHelper class for MyPanel panel, which we developed previously:

package com.izforge.izpack.panels;

import java.util.List;

import com.coi.tools.os.win.MSWinConstants;
import com.izforge.izpack.adaptator.IXMLElement;
import com.izforge.izpack.installer.AutomatedInstallData;
import com.izforge.izpack.installer.InstallerException;
import com.izforge.izpack.installer.PanelAutomation;
import com.izforge.izpack.installer.PanelAutomationHelper;

public class MyPanelAutomationHelper extends PanelAutomationHelper implements PanelAutomation {

  @Override
  public void makeXMLData(AutomatedInstallData installData, IXMLElement panelRoot) {
    //
  }

  @Override
  public void runAutomated(AutomatedInstallData installData, IXMLElement panelRoot) throws InstallerException {
    System.out.println("Hello, IzPack");
  }
}

  @Override
  public void panelActivate() {
    ...
    parent.skipPanel();
  }