In development mode we need to bootstrap the CDI environment on our own and make both Errai and CDI available through JNDI (common denominator across all runtimes). GWT by default uses Jetty, that only supports read only JNDI. The current solution for this is to use a custom launcher to control a JBoss AS 7 or Wildfly 8 instance instead of GWT’s built-in Jetty.

To do this, requires the following configurations in the gwt-maven-plugin configuration:

<plugin>

  <groupId>org.codehaus.mojo</groupId>

  <artifactId>gwt-maven-plugin</artifactId>

  <version>${gwt.version}</version>



  <configuration>

  ...

    <extraJvmArgs>-Derrai.jboss.home=$JBOSS_HOME -Derrai.jboss.javaagent.path=${settings.localRepository}/org/jboss/errai/errai-client-local-class-hider/$ERRAI_VERSION/errai-client-local-class-hider-$ERRAI_VERSION.jar</extraJvmArgs>

    <noServer>false</noServer>

    <server>org.jboss.errai.cdi.server.gwt.JBossLauncher</server>

  </configuration>

  <executions>

  ...

  </executions>

</plugin>

What does all this mean?

Here are some additional JVM arguments that can be passed to the JBossLauncher:

We provide integration with the JBoss Application Server, but the requirements are basically the same for other vendors. When running a GWT client app that leverages CDI beans on a Java EE 6 application server, CDI is already part of the container and accessible through JNDI (java:/BeanManager).

An ErraiApp.propertiesfile must appear at the root of each classpath location that contains an Errai module. The contents of JAR and directory classpath entries that do not contain an ErraiApp.properties are effectively invisible to Errai’s classpath scanner.

ErraiApp.properties is usually left empty, but it can contain configuration settings for both the core of Errai and any of its extensions. Configuration properties defined and used by Errai components have keys that start with " errai. ". Third party extensions should each choose their own prefix for keys in ErraiApp.properties.

The following compile-time dependency is required for Errai Messaging:

  <dependency>

    <groupId>org.jboss.errai</groupId>

    <artifactId>errai-bus</artifactId>

    <version>${errai.version}</version>

  </dependency>

Or if you are not using Maven, have errai-bus-${errai.version}.jar on the classpath.

If you are also using Errai IOC or Errai CDI and wish to use inject Errai Messaging dependencies, you will also want this dependency:

  <dependency>

    <groupId>org.jboss.errai</groupId>

    <artifactId>erria-ioc-bus-support</artifactId>

    <version>${errai.version}</version>

  </dependency>

Or if you are not using Maven, have errai-ioc-bus-support-${errai.version}.jar on the classpath.

In some cases it might be desirable to prevent the client bus from communicating with the server. One use case for this is when all communication with the server is handled using JAX-RS and the constant long polling requests for message exchange are not needed.

To turn off remote communication in the client bus the following JavaScript variable can be set in the HTML host page:

<script type="text/javascript">

  erraiBusRemoteCommunicationEnabled = false;

</script>

By default the remote bus is expected at the GWT web application’s context path. In case the remote bus is part of a different web application or deployed on a different server, the following configuration can be used in the HTML host page to configure the remote bus endpoint used on the client.

<script type="text/javascript">

  erraiBusApplicationRoot = "/MyRemoteMessageBusEnpoint";

</script>

The ErraiService.properties file contains basic configuration for the bus itself. Unlike ErraiApp.properties, there should be at most one ErraiService.properties file on the classpath of a deployed application. If you do not need to set any properties to their non-default values, this file can be omitted from the deployment entirely.

##
## Request dispatcher implementation (default is SimpleDispatcher)
##
#errai.dispatcher_implementation=org.jboss.errai.bus.server.SimpleDispatcher
errai.dispatcher_implementation=org.jboss.errai.bus.server.AsyncDispatcher

#
## Worker pool size. This is the number of threads the asynchronous worker pool should provide for
processing
## incoming messages. This option is only valid when using the AsyncDispatcher implementation.
##
errai.async.thread_pool_size=5

##
## Worker timeout (in seconds). This defines the time that a single asychronous process may run,
before the worker pool
## terminates it and reclaims the thread. This option is only valid when using the AsyncDispatcher
implementation.
##
errai.async.worker.timeout=5

##
## Specify the Authentication/Authorization Adapter to use
##
#errai.authentication_adapter=org.jboss.errai.persistence.server.security.HibernateAuthenticationAdapter
#errai.authentication_adapter=org.jboss.errai.bus.server.security.auth.JAASAdapter

##
## This property indicates whether or not authentication is required for all communication with the
bus. Set this
## to 'true' if all access to your application should be secure.
##
#errai.require_authentication_for_all=true

Errai has several different implementations for HTTP traffic to and from the bus. We provide a universally-compatible blocking implementation that provides fully synchronous communication to/from the server-side bus. Where this introduces scalability problems, we have implemented many webserver-specific implementations that take advantage of the various proprietary APIs to provide true asynchrony.

These included implementations are packaged at: org.jboss.errai.bus.server.servlet .

<servlet>

  <servlet-name>ErraiServlet</servlet-name>

  <servlet-class>org.jboss.errai.bus.server.servlet.DefaultBlockingServlet</servlet-class>

  <load-on-startup>1</load-on-startup>

</servlet>



<servlet-mapping>

  <servlet-name>ErraiServlet</servlet-name>

  <url-pattern>*.erraiBus</url-pattern>

</servlet-mapping>

<filter>

  <filter-name>ErraiServlet</filter-name>

  <filter-class>org.jboss.errai.bus.server.servlet.DefaultBlockingServlet</filter-class>

</filter>



<filter-mapping>

  <filter-name>ErraiServlet</filter-name>

  <url-pattern>*.erraiBus</url-pattern>

</filter-mapping>

<servlet>

  <servlet-name>ErraiServlet</servlet-name>

  <servlet-class>org.jboss.errai.bus.server.servlet.JettyContinuationsServlet</servlet-class>

  <load-on-startup>1</load-on-startup>

</servlet>



<servlet-mapping>

  <servlet-name>ErraiServlet</servlet-name>

  <url-pattern>*.erraiBus</url-pattern>

</servlet-mapping>

<servlet>

  <servlet-name>ErraiServlet</servlet-name>

  <servlet-class>org.jboss.errai.bus.server.servlet.StandardAsyncServlet</servlet-class>

  <load-on-startup>1</load-on-startup>

  <async-supported>true</async-supported>

</servlet>



<servlet-mapping>

  <servlet-name>ErraiServlet</servlet-name>

  <url-pattern>*.erraiBus</url-pattern>

</servlet-mapping>

    <init-param>

      <param-name>auto-discover-services</param-name>

      <param-value>true</param-value>

    </init-param>

To use Errai JAX-RS, you must include it on the compile-time classpath. If you are using Maven for your build, add this dependency:

    <dependency>

      <groupId>org.jboss.errai</groupId>

      <artifactId>errai-jaxrs-client</artifactId>

      <version>${errai.version}</version>

      <scope>provided</scope>

    </dependency>

Or if you are not using Maven for dependency management, add errai-jaxrs-client-${errai.version}.jar to your classpath.

If you intend to use Errai’s JSON format on the wire you will need to add Errai’s JAX-RS JSON provider to your classpath and make sure it gets deployed to the server.

    <dependency>

      <groupId>org.jboss.errai</groupId>

      <artifactId>errai-jaxrs-provider</artifactId>

      <version>${errai.version}</version>

    </dependency>

Or manually add errai-jaxrs-provider-${errai.version}.jar in case you’re not using Maven. If your REST service returns Jackson generated JSON you do not need the errai-jaxrs-provider (see Configuration ) .

Once you have Errai JAX-RS on your classpath, ensure your application inherits the GWT module as well. Add this line to your application’s *.gwt.xml file:

  <inherits name="org.jboss.errai.enterprise.Jaxrs"/>

To use Errai JPA, you must include it on the compile-time classpath. If you are using Maven for your build, add this dependency:

    <dependency>

      <groupId>org.jboss.errai</groupId>

      <artifactId>errai-jpa-client</artifactId>

      <version>${errai.version}</version>

    </dependency>

If you are not using Maven for dependency management, add errai-jpa-client-${errai.version}.jar , Hibernate 4.1.1, and Google Guava for GWT 12.0 to your compile-time classpath.

Once you have Errai JPA on your classpath, ensure your application inherits the GWT module as well. Add this line to your application’s *.gwt.xml file:

   <inherits name="org.jboss.errai.jpa.JPA"/>

First, ensure your pom.xml includes a dependency on the Data Sync module. This module must be packaged in your application’s WAR file, so include it with the default scope (compile):

  <dependency>

    <groupId>org.jboss.errai</groupId>

    <artifactId>errai-jpa-datasync</artifactId>

    <version>${errai.version}</version>

  </dependency>

Then, ensure your project’s *.gwt.xml module descriptor includes a dependency on the Data Sync GWT module:

  <inherits name="org.jboss.errai.jpa.sync.DataSync"/>

To use Errai’s data binding module, you must include it on the compile-time classpath. If you are using Maven for your build, add this dependency:

    <dependency>

      <groupId>org.jboss.errai</groupId>

      <artifactId>errai-data-binding</artifactId>

      <version>${errai.version}</version>

    </dependency>

If you are not using Maven for dependency management, add errai-data-binding-${errai.version}.jar to your classpath.

You must also inherit the Errai data binding module by adding the following line to your GWT module descriptor (gwt.xml).

<inherits name="org.jboss.errai.databinding.DataBinding" />

The easiest way to get Errai UI on your classpath is to depend on the special errai-javaee-all artifact, which brings in most Errai modules:

<dependency>

  <groupId>org.jboss.errai</groupId>

  <artifactId>errai-javaee-all</artifactId>

  <version>${errai.version}</version>

</dependency>

Or if you prefer to manage your project’s dependency in a finer-grained way, you can depend on errai-ui directly:

<dependency>

  <groupId>org.jboss.errai</groupId>

  <artifactId>errai-ui</artifactId>

  <version>${errai.version}</version>

</dependency>

Once you have Errai UI on your classpath, ensure your application inherits the GWT module as well. Add this line to your application’s *.gwt.xml file:

<inherits name="org.jboss.errai.ui.UI" />

To use Errai UI Navigation, you must include it on the compile-time classpath. If you are using Maven for your build, add these dependencies:

    <dependency>

      <groupId>org.jboss.errai</groupId>

      <artifactId>errai-navigation</artifactId>

      <version>${errai.version}</version>

      <scope>provided</scope>

    </dependency>

    <dependency>

      <groupId>org.jboss.errai</groupId>

      <artifactId>errai-cdi-client</artifactId>

      <version>${errai.version}</version>

      <scope>provided</scope>

    </dependency>

If you are not using Maven for dependency management, add errai-navigation-${errai.version}.jar to the compile-time classpath of a project that’s already set up for Errai UI templating.

Once you have Errai UI Navigation on your classpath, ensure your application inherits the GWT module as well. Add this line to your application’s *.gwt.xml file:

   <inherits name="org.jboss.errai.ui.nav.Navigation"/>

Using Errai Cordova requires the following compile-time dependency:

  <dependency>

    <groupId>org.jboss.errai</groupId>

    <artifactId>errai-cordova</artifactId>

    <version>${errai.verison}</version>

  </dependency>

Errai Cordova allows you build an Errai app to natively run on a device. In order to make this as easy as possible we have a maven plugin that will create a native binary that you can install on a device. It will put the html and javascript of you application in a cordova application.

<build>

 ...

    <plugins>

      <plugin>

        <groupId>org.jboss.errai</groupId>

        <artifactId>cordova-maven-plugin</artifactId>

        <version>${errai.version}</version>

      </plugin>

Add the following to your application’s *.gwt.xml module file:

<inherits name="org.jboss.errai.ui.Cordova"/>

Because the client is no longer served by the server the client will need to know how it can reach the server to do that place the following in your gwt.xml:

<replace-with class="com.company.application.Config">

   <when-type-is class="org.jboss.errai.bus.client.framework.Configuration" />

</replace-with>

This class must implement org.jboss.errai.bus.client.framework.Configuration and return the url where the server is configured.

import org.jboss.errai.bus.client.framework.Configuration;


public class Config implements Configuration {

    @Override

    public String getRemoteLocation() {

        // you probably want to do something environment specify here instead of something like this:

        return "https://grocery-edewit.rhcloud.com/errai-jpa-demo-grocery-list";

    }

}

Now you can execute a native build with the following maven command:

#will build all supported platforms for now only ios and android
mvn cordova:build-project

#only build android
mvn cordova:build-project -Dplatform=android

#start the ios emulator with the deployed application
mvn cordova:emulator -Dplatform=ios