WAR deployment to WildFly - CUBA Platform. Developer’s Manual

5.3.3. WAR deployment to WildFly

The WAR files with CUBA application can be deployed to the WildFly application server. An example below demonstrates how to deploy a CUBA application using PostgreSQL to the WildFly 18.0.1 server on Windows.

Edit build.gradle and specify dependency in the global module dependencies section:
```
runtime 'org.reactivestreams:reactive-streams:1.0.1'
```
Assemble and deploy the project to the default Tomcat server in order to get all necessary dependencies locally.
Configure the application home directory for the application:
- Create a folder that will be fully available for WildFly server’s process. For example: C:\Users\UserName\app_home.
- Copy the logback.xml file from tomcat/conf to this folder and edit the logDir property:
<property name="logDir" value="${app.home}/logs"/>
Configure the WildFly server
- Install WildFly to a local folder, for example, to C:\wildfly.
- Edit the C:\wildfly\bin\standalone.conf.bat file and add the following line to the end of the file:
set "JAVA_OPTS=%JAVA_OPTS% -Dapp.home=%USERPROFILE%/app_home -Dlogback.configurationFile=%USERPROFILE%/app_home/logback.xml"
Here we define the app.home system property with the application home directory and configure the logging by setting the path to the logback.xml file. You can also use an absolute path instead of %USERPROFILE% variable.
- Compare the Hibernate Validator versions in WildFly and CUBA application. If the platform uses a newer version, replace the C:\wildfly\modules\system\layers\base\org\hibernate\validator\main\hibernate-validator-x.y.z-sometext.jar with the newer file from tomcat\shared\lib, for example, hibernate-validator-6.1.1.Final.jar.
- Update the JAR file version number in the \wildfly\modules\system\layers\base\org\hibernate\validator\main\module.xml file.
- To register PostgreSQL driver in WildFly, copy the postgresql-42.2.5.jar from tomcat\lib to C:\wildfly\standalone\deployments.
- Setup WildFly logger: open the \wildfly\standalone\configuration\standalone.xml file and add two lines to the <subsystem xmlns="urn:jboss:domain:logging:{version}" block:
  
  <subsystem xmlns="urn:jboss:domain:logging:8.0"> <add-logging-api-dependencies value="false"/> <use-deployment-logging-config value="false"/> . . . </subsystem>
Create JDBC Datasource
- Start WildFly by running standalone.bat
- Open the administration console on http://localhost:9990. The first time you log in, you will be asked to create a user and a password.
- Open the Configuration - Subsystems - Datasources and Drivers - Datasources tab and create a new datasource for your application:
Name: Cuba JNDI Name: java:/jdbc/CubaDS JDBC Driver: postgresql-42.2.5.jar Driver Module Name: org.postgresql Driver Class Name: org.postgresql.Driver Connection URL: your database URL Username: your database username Password: your database password
The JDBC driver will be available on the list of detected drivers if you have copied postgresql-x.y.z.jar as described above.

Check the connection by clicking the Test connection button.
- Activate the datasource.
- Alternatively, you can create JDBC Datasource by using the bin/jboss-cli.bat command line utility:
  
  [disconnected /] connect [standalone@localhost:9990 /] data-source add --name=Cuba --jndi-name="java:/jdbc/CubaDS" --driver-name=postgresql-42.2.5.jar --user-name=dblogin --password=dbpassword --connection-url="jdbc:postgresql://dbhost/dbname" [standalone@localhost:9990 /] quit

Build the application

Open CUBA project tree > Project > Deployment > WAR Settings dialog in Studio.
Check Build WAR checkbox.
Save the settings.

Open build.gradle in IDE and add the doAfter property to the buildWar task. This property will copy the WildFly deployment descriptor:

task buildWar(type: CubaWarBuilding) {
    appProperties = ['cuba.automaticDatabaseUpdate' : true]
    singleWar = false
    doAfter = {
        copy {
            from 'jboss-deployment-structure.xml'
            into "${project.buildDir}/tmp/buildWar/core/war/META-INF/"
        }
        copy {
            from 'jboss-deployment-structure.xml'
            into "${project.buildDir}/tmp/buildWar/web/war/META-INF/"
        }
    }
}

For a singleWAR configuration the task will be different:

task buildWar(type: CubaWarBuilding) {
    webXmlPath = 'modules/web/web/WEB-INF/single-war-web.xml'
    appProperties = ['cuba.automaticDatabaseUpdate' : true]
    doAfter = {
        copy {
            from 'jboss-deployment-structure.xml'
            into "${project.buildDir}/tmp/buildWar/META-INF/"
        }
    }
}

If your project also contains a Polymer module, add the following configuration to your single-war-web.xml file:

<servlet>
    <servlet-name>default</servlet-name>
    <init-param>
        <param-name>resolve-against-context-root</param-name>
        <param-value>true</param-value>
    </init-param>
</servlet>

In the project root folder, create the jboss-deployment-structure.xml file and add the WildFly deployment descriptor to it:

<?xml version="1.0" encoding="UTF-8"?>
<jboss-deployment-structure xmlns="urn:jboss:deployment-structure:1.0">
    <deployment>
        <exclusions>
            <module name="org.apache.commons.logging" />
            <module name="org.apache.log4j" />
            <module name="org.jboss.logging" />
            <module name="org.jboss.logging.jul-to-slf4j-stub" />
            <module name="org.jboss.logmanager" />
            <module name="org.jboss.logmanager.log4j" />
            <module name="org.slf4j" />
            <module name="org.slf4j.impl" />
            <module name="org.slf4j.jcl-over-slf4j" />
        </exclusions>
    </deployment>
</jboss-deployment-structure>

Run the buildWar task to create WAR files.

Copy the files app-core.war and app.war from build\distributions\war to WildFly directory \wildfly\standalone\deployments.
Restart the WildFly server.
Your application will become available on http://localhost:8080/app. The log files will be saved in the application home: C:\Users\UserName\app_home\logs.