HAL Foundation

This repository contains the foundation for the next major version of the HAL management console (halOP) and the upcoming OpenShift version (halOS). To distinguish between the two editions, we introduce the following names:

• halOP: HAL on premise
• halOS: HAL on OpenShift

The work on the new consoles is in an early state and very much in progress.

Technical Stack

• Java 21
• J2CL
• Crysknife CDI
• Elemento
• PatternFly Java
• Maven, Vite, and PNPM

halOP (HAL On Premise)

This edition is the successor of the current HAL management console.

Get Started

There are many ways to get started with halOP, but essentially there are two ways to use the console:

1. Bundled – as part of a WildFly installation
2. Standalone – as a single-page application (SPA) running on its own

Bundled

In this mode halOP is bundled with WildFly and can be used out of the box. halOP is available as an experimental feature pack that can be provisioned with Galleon. The feature pack mounts an additional HTTP endpoint on the management interface at http://localhost:9990/halop.

1. Build or use the latest feature pack from Maven Central org.jboss.hal:hal-op-feature-pack:0.3.8

   mvn install -P op,feature-pack

2. Provision a WildFly server. You can use the provided provision.xml as an example. It provisions a default standalone server plus the halOP feature pack. If you haven't built the feature pack in step 1 and used the latest version from Maven Central, you have to run mvn process-resources in op/feature-pack in order to resolve the versions in provision.xml.

   galleon.sh provision op/feature-pack/target/provision.xml \
       --dir=$TMPDIR/wildfly \
       --stability-level=experimental

3. Prepare and start the server

   cd $TMPDIR/wildfly
   bin/add-user.sh -u admin -p admin --silent
   bin/standalone.sh --stability=experimental

4. Open http://localhost:9990/halop

Standalone

halOP can run on its own. In this mode halOP starts a local web server and serves the console on its own without being part of a WildFly installation. halOP is "just" a single-page application (SPA) without any server side dependencies. The only requirement is a management interface of a running WIldFly instance.

By default, the standalone mode runs at http://localhost:9090. If you want to customize the port, please use -Dquarkus.http.port=<port>.

There are many ways to run halOP in standalone mode:

Build and run on your own (JVM)

mvn install -P op,standalone
java -jar op/standalone/target/quarkus-app/quarkus-run.jar

Build and run on your own (native)

mvn install -P op,standalone,native
op/standalone/target/hal-op-standalone-0.3.8-runner

Please make sure that you have a recent version of GraalVM installed. See https://quarkus.io/guides/building-native-image#configuring-graalvm for details.

Use the latest release (JVM)

The latest release is deployed as Uber-Jar using the runner classifier to Maven Central: org.jboss.hal:hal-op-standalone:0.3.8. You can download and run it with

mvn dependency:copy -Dartifact=org.jboss.hal:hal-op-standalone:0.3.8:jar:runner -DoutputDirectory=.
java -jar hal-op-standalone-0.3.8-runner.jar

Use the latest release (native)

Native binaries for Linux, macOS, and Windows are attached to every release. Download the binary for your platform, make it executable, and run it. To make the binary executable, you might need to run something like this (depending on your OS):

chmod +x hal-op-*
xattr -d com.apple.quarantine hal-op-*

JBang

halOP can also be started using JBang.

jbang org.jboss.hal:hal-op-standalone:0.3.8:runner

If you want it even simpler, you can make use of the JBang catalog for halOP:

jbang hal-op@hal

Finally, you can also install it as a command using jbang app install hal-op@hal. Then all you have to do is to run

hal-op

and you'll always be up to date.

Container

halOP is also available as a container image at https://quay.io/repository/halconsole/hal-op.

podman run -it -p 9090:9090 quay.io/halconsole/hal-op

Development

If you want to contribute to halOP, follow these steps to start halOP in development mode. In the development mode, the Java code is transpiled to JavaScript using J2CL. The HTML and CSS are transpiled to JavaScript using Vite. Changes to HTML and CSS will be detected by Vite, and the browser reloads the page automatically. Changes to the Java code will be detected by the J2CL Maven plugin, but you need to reload the browser manually.

To start halOP in development mode, run

mvn compile j2cl:watch -P op

and wait until you see the message

[INFO] -----  Build Complete: ready for browser refresh  -----

In another shell run

cd op/console
npm run watch

This will open a browser at http://localhost:1234.

halOS (HAL on OpenShift)

This version of HAL integrates with the OpenShift console. It can be used to manage WildFly insstances running on OpenShift.

halOS is not yet implemented!

Maven Profiles

The build uses Maven profiles to select editions, packaging targets, and build options. Profiles are layered across three levels: the root pom.xml sets J2CL and environment properties, op/pom.xml activates modules, and op/console/pom.xml runs the appropriate Vite build and assembly.

Edition Profiles

Profile	Purpose
op	Activates the op/ module tree (halOP edition)
os	Activates the os/ module tree (halOS edition — not yet implemented)

Packaging Profiles

Each packaging profile requires op as a prerequisite. They are mutually exclusive for local development.

Profile	Purpose	J2CL Compilation
standalone	Builds the Quarkus standalone edition	ADVANCED (production)
feature-pack	Builds the Galleon feature pack and the WildFly subsystem	ADVANCED (production)
test-suite	Builds the test-suite edition for dave	BUNDLE_JAR (development)

Modifier Profiles

These can be combined with the profiles above.

Profile	Purpose
format	Auto-formats source files (editorconfig, import sort, license headers)
check	Validates source files (enforcer, editorconfig, import sort, license, checkstyle)
native	GraalVM native image build (use with -P op,standalone,native)
jbang	Uber-JAR packaging for JBang execution (use with -P op,standalone,jbang)
quick-build	Skips tests and npm (also activatable via -Dquickly)
release	Source/Javadoc JARs, GPG signing, Maven Central publishing

Common Combinations

mvn verify                                  # Code modules only (no edition)
mvn compile -P op                           # Compile halOP
mvn install -P op,standalone                # Standalone edition (JVM)
mvn install -P op,standalone,native         # Standalone edition (native binary)
mvn install -P op,feature-pack              # Galleon feature pack
mvn package -P op,test-suite                # Test suite container
mvn install -P quick-build                  # Fast build, skip tests
mvn process-sources -P format,op            # Auto-format halOP sources
mvn process-sources -P check,op             # Validate halOP sources

Scripts

Script	Purpose
format.sh	Auto-format source files (license headers, editorconfig, import sorting) using the format Maven profile
check.sh	Validate source files (enforcer, checkstyle, license headers, editorconfig, import sorting) using the check Maven profile
bump-pfj.sh	Bump PatternFly Java to a new version (Maven property, pnpm catalog, lockfile)
versionBump.sh	Bump the project version in Maven POMs
release.sh	Create a new release (version bump, changelog, tag, push, snapshot bump)
unrelease.sh	Undo a failed release (delete tag, revert version bump)

Contributing

This is an open-source project. That means that everybody can contribute. It's not hard to get started. So start contributing today!

Licenses

This project uses the following licenses:

• Apache License 2.0