Vaadin OSGi Support

Vaadin applications can be deployed on an OSGi compatible servlet container, or on Liferay 7 as OSGi portlets.

An OSGi application typically consists of multiple bundles that can be deployed separately. Multiple versions of each bundle can be present, and the OSGi runtime resolves their dependencies at run-time based on bundle manifests.

To deploy Vaadin applications as OSGi bundles, static resources (including themes and widget sets) must be published using the appropriate APIs to enable using multiple Vaadin versions on the same server.

The application is typically packaged as a JAR file, and needs to have a valid OSGi bundle manifest which can be created e.g. by the bnd-maven-plugin. All the dependencies of the application should be available as OSGi bundles.

Minimal Vaadin Project For OSGi

Vaadin application for OSGi should be a valid bundle, i.e. it should be packaged as a .jar file, and it should have a proper OSGi manifest inside. The easiest way to convert regular maven-based Vaadin application into a valid OSGi bundle consists of five steps:

  • Change packaging type to jar in your pom.xml:

XML

  1.     <packaging>jar</packaging>
  • Change the scope for all vaadin dependencies from default to provided, like this:

XML

  1.         <dependency>
  2.             <groupId>com.vaadin</groupId>
  3.             <artifactId>vaadin-server</artifactId>
  4.             <scope>provided</scope>
  5.         </dependency>
  • Add OSGi-related dependencies to the project

XML

  1.         <groupId>com.vaadin</groupId>
  2.             <artifactId>vaadin-osgi-integration</artifactId>
  3.             <version>8.1.0.beta1</version>
  4.             <scope>provided</scope>
  5.         </dependency>
  6.         <dependency>
  7.             <groupId>org.osgi</groupId>
  8.             <artifactId>osgi.core</artifactId>
  9.             <version>6.0.0</version>
  10.             <scope>provided</scope>
  11.         </dependency>
  12.         <dependency>
  13.             <groupId>org.osgi</groupId>
  14.             <artifactId>osgi.annotation</artifactId>
  15.             <version>6.0.1</version>
  16.             <scope>provided</scope>
  17.         </dependency>
  18.         <dependency>
  19.             <groupId>org.osgi</groupId>
  20.             <artifactId>osgi.cmpn</artifactId>
  21.             <version>6.0.0</version>
  22.             <scope>provided</scope>
  23.         </dependency>
  • Setup necessary plugins for building the project:

XML

  1.  <build>
  2.         <plugins>
  3.             <plugin>
  4.                 <groupId>biz.aQute.bnd</groupId>
  5.                 <artifactId>bnd-maven-plugin</artifactId>
  6.                 <version>3.3.0</version>
  7.                 <executions>
  8.                     <execution>
  9.                         <goals>
  10.                             <goal>bnd-process</goal>
  11.                         </goals>
  12.                     </execution>
  13.                 </executions>
  14.             </plugin>
  15.             <plugin>
  16.                 <groupId>org.apache.maven.plugins</groupId>
  17.                 <artifactId>maven-jar-plugin</artifactId>
  18.                 <version>3.0.2</version>
  19.                 <configuration>
  20.                     <archive>
  21.                         <manifestFile>${project.build.outputDirectory}/META-INF/MANIFEST.MF</manifestFile>
  22.                     </archive>
  23.                 </configuration>
  24.             </plugin>
  25.             ...
  26.         </plugins>
  27.     </build>
  • Add bundle script (bnd.bnd) into the project root folder:

text

  1. Bundle-Name: ${project.name}
  2. Bundle-Version: ${project.version}
  3. Bundle-SymbolicName: ${project.groupId}.${project.artifactId}
  4. Export-Package: com.example.osgi.myapplication
  5. Import-Package: *
  6. Web-ContentPath: /myapp

Publishing a Servlet With OSGi

To deploy the app as a servlet all we need to do is annotate the MyUIServlet class with @Component(service = VaadinServlet.class). The Vaadin integration will track this registration and use HttpWhiteboard specification to register a servlet with the location of the Vaadin resources properly configured. This means that the user can specify a set of HttpWhiteboard properties in the @Component declaration.

The @WebServlet annotation settings will be used to configure the urlPatterns and async parameters.

Java

  1. import org.osgi.service.component.annotations.Component;
  2. ...
  3. @Component(service = VaadinServlet.class)
  4. @WebServlet(urlPatterns = "/*", name = "MyUIServlet", asyncSupported = true)
  5. @VaadinServletConfiguration(ui = MyUI.class, productionMode = false)
  6. public static class MyUIServlet extends VaadinServlet {
  7. }

Publishing Static Resources With OSGi

Vaadin Framework 8.1 and later versions provide two supported ways of publishing static resources for OSGi: by making OSGi services implementing an interface or by explicit calls to a service.

The easiest way to publish a theme or a widgetset is to create a class implementing the interface OsgiVaadinTheme or OsgiVaadinWidgetset and annotating it with @Component to make it an OSGi service. This automatically publishes the theme or the widget set from the bundle at a path that contains the Vaadin Framework version used by the application.

Java

  1. @Component
  2. public class MyTheme extends ValoTheme implements OsgiVaadinTheme {
  3.     public static final String THEME_NAME = "mytheme";
  5.     @Override
  6.     public String getName() {
  7.         return THEME_NAME;
  8.     }
  10. }

Alternatively, an OSGi bundle activator or an SCR Component @Activate method can obtain an instance of VaadinResourceService from OsgiVaadinResources and explicitly call its methods to publish a theme, a widget set or an individual file in the bundle as a static resource at the correct path.

Java

  1.   VaadinResourceService service = OsgiVaadinResources.getService();
  2.   service.publishTheme("mytheme", httpService);

In addition to these approaches, it is also possible to repackage all the static resources of an application to a single bundle and export the /VAADIN directory. This can be useful e.g. when migrating an old Vaadin OSGi application in an environment that does not support parallel deployments of multiple versions of the application.

Deployment to OSGi container.

In order to have your application running under OSGi container, you need to have Vaadin framework bundles deployed, and then the application bundle can be deployed and started. Here is a list of required Vaadin bundles, in order of loading:

  • jsoup-1.8.3.jar

  • gentyref-1.2.0.vaadin1.jar

  • vaadin-shared-8.1.x.jar

  • vaadin-server-8.1.x.jar-8.1.x.jar

  • vaadin-osgi-integration-8.1.x.jar

  • vaadin-client-compiled-8.1.x.jar (not required, if your project uses its own widgetset)

  • vaadin-themes-8.1.x.jar

And here is a complete script to have Vaadin application up and running using Apache Karaf 4.0.8 console:

  1. feature:install http
  2. feature:install http-whiteboard
  3. bundle:install -s mvn:org.jsoup/jsoup/1.8.3
  4. bundle:install -s mvn:com.vaadin.external/gentyref/1.2.0.vaadin1
  5. bundle:install -s mvn:com.vaadin/vaadin-shared/8.1.0
  6. bundle:install -s mvn:com.vaadin/vaadin-server/8.1.0
  7. bundle:install -s mvn:com.vaadin/vaadin-osgi-integration/8.1.0
  8. bundle:install -s mvn:com.vaadin/vaadin-client-compiled/8.1.0
  9. bundle:install -s mvn:com.vaadin/vaadin-themes/8.1.0
  10. bundle:install -s file:path-to-the-application.jar