1. Create a directory for the application and navigate to it:

   $ mkdir myApp
   $ cd myApp

   We recommend you start tracking the directory contents with Git. For more information, see Git tutorial.

2. In the directory, create a pom.xml file with the following content.

   <?xml version="1.0" encoding="UTF-8"?>
   <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
     <modelVersion>4.0.0</modelVersion>
   
     <groupId>com.example</groupId>
     <artifactId>restful-endpoint</artifactId>
     <version>1.0.0-SNAPSHOT</version>
     <packaging>war</packaging>
   
     <name>Thorntail Example</name>
   
     <properties>
       <version.thorntail>2.2.0.Final-redhat-00021</version.thorntail>
       <maven.compiler.source>1.8</maven.compiler.source>
       <maven.compiler.target>1.8</maven.compiler.target>
       <failOnMissingWebXml>false</failOnMissingWebXml>
       <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
       <fabric8.generator.from>registry.access.redhat.com/redhat-openjdk-18/openjdk18-openshift:1.2</fabric8.generator.from>
     </properties>
   
     <dependencyManagement>
       <dependencies>
         <dependency>
           <groupId>io.thorntail</groupId>
           <artifactId>bom</artifactId>
           <version>${version.thorntail}</version>
           <scope>import</scope>
           <type>pom</type>
         </dependency>
       </dependencies>
     </dependencyManagement>
     <dependencies>
       <dependency>
         <groupId>io.thorntail</groupId>
         <artifactId>jaxrs</artifactId>
       </dependency>
     </dependencies>
   
     <build>
       <finalName>restful-endpoint</finalName>
       <plugins>
         <plugin>
           <groupId>io.thorntail</groupId>
           <artifactId>thorntail-maven-plugin</artifactId>
           <version>${version.thorntail}</version>
           <executions>
             <execution>
               <goals>
                 <goal>package</goal>
               </goals>
             </execution>
           </executions>
         </plugin>
       </plugins>
     </build>
   
     <!-- Specify the repositories containing RHOAR artifacts -->
     <repositories>
       <repository>
         <id>redhat-ga</id>
         <name>Red Hat GA Repository</name>
         <url>https://maven.repository.redhat.com/ga/</url>
       </repository>
     </repositories>
   
     <pluginRepositories>
       <pluginRepository>
         <id>redhat-ga</id>
         <name>Red Hat GA Repository</name>
         <url>https://maven.repository.redhat.com/ga/</url>
       </pluginRepository>
     </pluginRepositories>
   
     <profiles>
       <profile>
         <id>openshift</id>
         <build>
           <plugins>
             <plugin>
               <groupId>io.fabric8</groupId>
               <artifactId>fabric8-maven-plugin</artifactId>
               <executions>
                 <execution>
                   <goals>
                     <goal>resource</goal>
                     <goal>build</goal>
                   </goals>
                 </execution>
               </executions>
             </plugin>
           </plugins>
         </build>
       </profile>
     </profiles>
   </project>

3. Create a directory structure for your application:

   mkdir -p src/main/java/com/example/rest

4. In the src/main/java/com/example/rest directory, create the source files:

   • HelloWorldEndpoint.java with the class that serves the HTTP endpoint:

     package com.example.rest;
     
     import javax.ws.rs.Path;
     import javax.ws.rs.core.Response;
     import javax.ws.rs.GET;
     import javax.ws.rs.Produces;
     
     @Path("/hello")
     public class HelloWorldEndpoint {
     
       @GET
       @Produces("text/plain")
       public Response doGet() {
         return Response.ok("Hello from Thorntail!").build();
       }
     }

   • RestApplication.java with the application context:

     package com.example.rest;
     
     import javax.ws.rs.core.Application;
     import javax.ws.rs.ApplicationPath;
     
     @ApplicationPath("/rest")
     public class RestApplication extends Application {
     }

5. Execute the application using Maven:

   $ mvn thorntail:run

Procedure

1. Log in to your OpenShift instance with the oc client.

   $ oc login ...

2. Create a new project.

   $ oc new-project MY_PROJECT_NAME

3. In a terminal application, navigate to the directory containing your application:

   $ cd myApp

4. Use Maven to start the deployment to OpenShift.

   $ mvn clean fabric8:deploy -Popenshift

   This command uses the Fabric8 Maven Plugin to launch the S2I process on OpenShift and to start the pod.

5. Check the status of your booster and ensure your pod is running.

   $ oc get pods -w
   NAME                             READY     STATUS      RESTARTS   AGE
   MY_APP_NAME-1-aaaaa               1/1       Running     0          58s
   MY_APP_NAME-s2i-1-build           0/1       Completed   0          2m

   The MY_APP_NAME-1-aaaaa pod should have a status of Running once it is fully deployed and started. Your specific pod name will vary. The number in the middle will increase with each new build. The letters at the end are generated when the pod is created.

6. Once your booster is deployed and started, determine its route.

   Example Route Information

   $ oc get routes
   NAME                 HOST/PORT                                                     PATH      SERVICES        PORT      TERMINATION
   MY_APP_NAME         MY_APP_NAME-MY_PROJECT_NAME.OPENSHIFT_HOSTNAME      MY_APP_NAME      8080

   The route information of a pod gives you the base URL which you use to access it. In the example above, you would use http://MY_APP_NAME-MY_PROJECT_NAME.OPENSHIFT_HOSTNAME as the base URL to access the application.

7. Using curl or your browser, verify your application is running in OpenShift.

   $ curl http://MY_APP_NAME-MY_PROJECT_NAME.OPENSHIFT_HOSTNAME/rest/hello
   Hello from Thorntail!

1. Add the thorntail-maven-plugin to your pom.xml in a <plugin> block, with an <execution> specifying the package goal.

   <plugins>
     <plugin>
       <groupId>io.thorntail</groupId>
       <artifactId>thorntail-maven-plugin</artifactId>
       <version>${version.thorntail}</version>
       <executions>
         <execution>
           <id>package</id>
           <goals>
             <goal>package</goal>
           </goals>
         </execution>
       </executions>
     </plugin>
   </plugins>

2. Perform a normal Maven build:

   $ mvn package

3. Execute the resulting uberjar:

   $ java -jar ./target/myapp-thorntail.jar

Procedure

1. Add the BOM to your pom.xml. For more information, see Section 4.5, “Using a BOM”.
2. Add the Thorntail Maven plugin to your pom.xml. For more information, see Section 5.2, “Creating an uberjar”.

3. Add one or more dependencies on Thorntail fractions to the pom.xml file:

   <dependencies>
     <dependency>
       <groupId>io.thorntail</groupId>
       <artifactId>jaxrs</artifactId>
     </dependency>
   </dependencies>

4. Perform a normal Maven build:

   $ mvn package

5. Execute the resulting uberjar:

   $ java -jar ./target/myapp-thorntail.jar

Procedure

1. Include a bom artifact in your pom.xml.

   Tracking the current version of Thorntail through a property in your pom.xml is recommended.

   <properties>
     <version.thorntail>2.2.0.Final-redhat-00021</version.thorntail>
   </properties>

   Import BOMs in the <dependencyManagement> section. Specify the <type>pom</type> and <scope>import</scope>.

   <dependencyManagement>
     <dependencies>
       <dependency>
         <groupId>io.thorntail</groupId>
         <artifactId>bom</artifactId>
         <version>${version.thorntail}</version>
         <type>pom</type>
         <scope>import</scope>
       </dependency>
     </dependencies>
   </dependencyManagement>

   In the example above, the bom artifact is imported to ensure that only stable fractions are available.

   By including the BOMs of your choice in the <dependencyManagement> section, you have:

   • Provided version-management for any Thorntail artifacts you subsequently choose to use.
   • Provided support to your IDE for auto-completing known artifacts when you edit your the pom.xml file of your application.

2. Include Thorntail dependencies.

   Even though you imported the Thorntail BOMs in the <dependencyManagement> section, your application still has no dependencies on Thorntail artifacts.

   To include Thorntail artifact dependencies based on the capabilities your application, enter the relevant artifacts as <dependency> elements:

   Note

   You do not have to specify the version of the artifacts because the BOM imported in <dependencyManagement> handles that.

   <dependencies>
     <dependency>
       <groupId>io.thorntail</groupId>
       <artifactId>jaxrs</artifactId>
     </dependency>
     <dependency>
       <groupId>io.thorntail</groupId>
       <artifactId>datasources</artifactId>
     </dependency>
   </dependencies>

   In the example above, we include explicit dependencies on the jaxrs and datasources fractions, which will provide transitive inclusion of others, for example undertow.

Procedure

1. Find the <dependencies> section in the pom.xml file of your application. Verify it contains the following coordinates. If it does not, add them.

   <dependency>
     <groupId>io.thorntail</groupId>
     <artifactId>logging</artifactId>
   </dependency>

2. If you want to log messages of a level other than INFO, launch the application while specifying the swarm.logging system property:

   $ mvn thorntail:run -Dswarm.logging=FINE

   See the org.wildfly.swarm.config.logging.Level class for the list of available levels.

1. Open a YAML profile file of your choice. If you do not know which one to use, open project-defaults.yml in the src/main/resources directory in your application sources. In the YAML file, add the following section:

   swarm:
     logging:

2. Configure a formatter (optional). The following formatters are configured by default:

   PATTERN

   Useful for logging into a file.

   COLOR_PATTERN

   Color output. Useful for logging to the console.

   To configure a custom formatter, add a new formatter with a pattern of your choice in the logging section. In this example, it is called LOG_FORMATTER:

   pattern-formatters:
     LOG_FORMATTER:
       pattern: "%p [%c] %s%e%n"

3. Configure a file handler to use with the loggers. This example shows the configuration of a periodic rotating file handler. Under logging, add a periodic-rotating-file-handlers section with a new handler.

   periodic-rotating-file-handlers:
     FILE:
       file:
         path: target/MY_APP_NAME.log
       suffix: .yyyy-MM-dd
       named-formatter: LOG_FORMATTER
       level: INFO

   Here, a new handler named FILE is created, logging events of the INFO level and higher. It logs in the target directory, and each log file is named MY_APP_NAME.log with the suffix .yyyy-MM-dd. Thorntail automatically parses the log rotation period from the suffix, so ensure you use a format compatible with the java.text.SimpleDateFormat class.

4. Configure the root logger.

   The root logger is by default configured to use the CONSOLE handler only. Under logging, add a root-logger section with the handlers you wish to use:

   root-logger:
     handlers:
     - CONSOLE
     - FILE

   Here, the FILE handler from the previous step is used, along with the default console handler.