1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
|
---
title: Vaadin OSGi Support
order: 19
layout: page
---
[[advanced.osgi]]
= 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.
[[advanced.osgi.servlet.maven]]
== 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`:
[source, xml]
----
<packaging>jar</packaging>
----
* Change the scope for all vaadin dependencies from default to `provided`, like this:
[source, xml]
----
<dependency>
<groupId>com.vaadin</groupId>
<artifactId>vaadin-server</artifactId>
<scope>provided</scope>
</dependency>
----
* Add OSGi-related dependencies to the project
[source, xml]
----
<groupId>com.vaadin</groupId>
<artifactId>vaadin-osgi-integration</artifactId>
<version>8.1.0.beta1</version>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>org.osgi</groupId>
<artifactId>osgi.core</artifactId>
<version>6.0.0</version>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>org.osgi</groupId>
<artifactId>osgi.annotation</artifactId>
<version>6.0.1</version>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>org.osgi</groupId>
<artifactId>osgi.cmpn</artifactId>
<version>6.0.0</version>
<scope>provided</scope>
</dependency>
----
* Setup necessary plugins for building the project:
[source, xml]
----
<build>
<plugins>
<plugin>
<groupId>biz.aQute.bnd</groupId>
<artifactId>bnd-maven-plugin</artifactId>
<version>3.3.0</version>
<executions>
<execution>
<goals>
<goal>bnd-process</goal>
</goals>
</execution>
</executions>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-jar-plugin</artifactId>
<version>3.0.2</version>
<configuration>
<archive>
<manifestFile>${project.build.outputDirectory}/META-INF/MANIFEST.MF</manifestFile>
</archive>
</configuration>
</plugin>
...
</plugins>
</build>
----
* Add bundle script (`bnd.bnd`) into the project root folder:
[source, text]
----
Bundle-Name: ${project.name}
Bundle-Version: ${project.version}
Bundle-SymbolicName: ${project.groupId}.${project.artifactId}
Export-Package: com.example.osgi.myapplication
Import-Package: *
Web-ContentPath: /myapp
----
[[advanced.osgi.servlet]]
== Publishing a Servlet With OSGi
To deploy the app as a servlet all we need to do is annotate the [classname]#MyUIServlet# class with [literal]#@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 [interfacename]#@Component# declaration.
The [interfacename]#@WebServlet# annotation settings will be used to configure the urlPatterns and async parameters.
[source, java]
----
import org.osgi.service.component.annotations.Component;
...
@Component(service = VaadinServlet.class)
@WebServlet(urlPatterns = "/*", name = "MyUIServlet", asyncSupported = true)
@VaadinServletConfiguration(ui = MyUI.class, productionMode = false)
public static class MyUIServlet extends VaadinServlet {
}
----
[[advanced.osgi.resources]]
== 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 [interfacename]#OsgiVaadinTheme# or [interfacename]#OsgiVaadinWidgetset# and annotating it with [interfacename]#@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.
[source, java]
----
@Component
public class MyTheme extends ValoTheme implements OsgiVaadinTheme {
public static final String THEME_NAME = "mytheme";
@Override
public String getName() {
return THEME_NAME;
}
}
----
Alternatively, an OSGi bundle activator or an SCR Component [interfacename]#@Activate# method can obtain an instance of [classname]#VaadinResourceService# from [classname]#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.
[source, java]
----
VaadinResourceService service = OsgiVaadinResources.getService();
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 [filename]#/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.
[[advanced.osgi.deploy]]
== 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 link:https://karaf.apache.org/[Apache Karaf 4.0.8] console:
[source]
----
feature:install http
feature:install http-whiteboard
bundle:install -s mvn:org.jsoup/jsoup/1.8.3
bundle:install -s mvn:com.vaadin.external/gentyref/1.2.0.vaadin1
bundle:install -s mvn:com.vaadin/vaadin-shared/8.1.0
bundle:install -s mvn:com.vaadin/vaadin-server/8.1.0
bundle:install -s mvn:com.vaadin/vaadin-osgi-integration/8.1.0
bundle:install -s mvn:com.vaadin/vaadin-client-compiled/8.1.0
bundle:install -s mvn:com.vaadin/vaadin-themes/8.1.0
bundle:install -s file:path-to-the-application.jar
----
|
