Refactor justfiles and introduce running mode to avoid metrics in local

bsdata-parser/justfile

@@ -0,0 +1,23 @@
+set dotenv-load := true
+set export := true
+
+# Build the BSData parser application
+build:
+    #!/usr/bin/env bash
+    set -euxo pipefail
+    cd ..
+    mvn clean package -pl bsdata-parser -am
+    cd bsdata-parser
+    ./jpackage.sh
+
+# Run the BSData parser to generate game data
+run:
+    #!/usr/bin/env bash
+    set -euxo pipefail
+    cd ..
+    rm -rf wh40k-10e
+    rm -rf 40k10thdata
+    mkdir -p 40k10thdata
+    git clone https://github.com/BSData/wh40k-10e.git
+    ./bsdata-parser/dist/40kcalculator-bsdataparser/bin/40kcalculator-bsdataparser --catalogue-folder wh40k-10e \
+      --output-data-folder 40k10thdata

core/justfile

@@ -0,0 +1,9 @@
+set dotenv-load := true
+set export := true
+
+# Publish the core module to Maven repository
+publish:
+    #!/usr/bin/env bash
+    cd ..
+    set -euxo pipefail
+    mvn -pl core deploy

justfile

@@ -1,126 +1,8 @@
 set dotenv-load := true
 set export := true
 
-# Packages web-client, push image docker and update the application in the remote server
-webclient-backend-package-and-push: package-webclient-backend build-webclient-backend-docker upload-webclient-backend-docker provision-webclient-backend-application
-
-package-bsdataparser:
-    #!/usr/bin/env bash
-    set -euxo pipefail
-    mvn clean package -pl bsdata-parser -am
-    cd bsdata-parser
-    ./jpackage.sh
-
-build-data-files:
-    #!/usr/bin/env bash
-    set -euxo pipefail
-    rm -rf wh40k-10e
-    rm -rf 40k10thdata
-    mkdir -p 40k10thdata/weapons
-    git clone https://github.com/BSData/wh40k-10e.git
-    ./bsdata-parser/dist/40kcalculator-bsdataparser/bin/40kcalculator-bsdataparser --catalogue-folder wh40k-10e \
-      --output-data-folder 40k10thdata/weapons
-
-package-webclient-backend:
-    #!/usr/bin/env bash
-    set -euxo pipefail
-    mvn clean package -am -pl web-client-backend
-    cd web-client-backend
-    ./jpackage.sh
-
-build-webclient-backend-docker:
-    #!/usr/bin/env bash
-    # This needs package-webclient-backend to have been invoked
-    set -euxo pipefail
-    export web_version=$(mvn -pl web-client-backend help:evaluate -q -DforceStdout -Dexpression=project.version 2>/dev/null)
-    docker buildx build -t 40kcalculator-webclient-backend:${web_version} -f web-client-backend/infrastructure/docker/Dockerfile \
-    --build-arg "APP_API_PORT=${APP_API_PORT}" \
-    --build-arg "APP_METRICS_PORT=${APP_METRICS_PORT}" \
-    --build-arg "APP_STACK_NAME=${APP_STACK_NAME}" \
-    .
-    docker tag 40kcalculator-webclient-backend:${web_version} $DOCKER_REGISTRY/loic/40kcalculator-webclient-backend:${web_version}
-
-upload-webclient-backend-docker:
-    #!/usr/bin/env bash
-    set -euxo pipefail
-    export web_version=$(mvn -pl web-client-backend help:evaluate -q -DforceStdout -Dexpression=project.version 2>/dev/null)
-    docker login -u "$DOCKER_REGISTRY_USER" -p "${DOCKER_REGISTRY_PASSWORD}" "${DOCKER_REGISTRY}"
-    docker push $DOCKER_REGISTRY/loic/40kcalculator-webclient-backend:${web_version}
-
-webclient-backend-docker-try:
-    #!/usr/bin/env bash
-    set -euxo pipefail
-    export web_version=$(mvn help:evaluate -pl web-client-backend -q -DforceStdout -Dexpression=project.version 2>/dev/null)
-    docker run -p ${APP_API_PORT}:${APP_API_PORT} -p ${APP_METRICS_PORT}:${APP_METRICS_PORT} -d --name 40kcalculator 40kcalculator-webclient-backend:${web_version}
-
-deploy-webclient-backend-infra:
-    #!/usr/bin/env bash
-    set -euxo pipefail
-    cd web-client-backend/infrastructure/tofu
-    tofu init -var-file app-server-1-main.tfvars
-    tofu apply -var-file app-server-1-main.tfvars
-    tofu output -var-file app-server-1-main.tfvars -raw application_dns > ../application_dns
-
-provision-webclient-backend-application:
-    #!/usr/bin/env bash
-    set -uexo pipefail
-    export APP_VERSION=$(mvn -pl web-client-backend help:evaluate -q -DforceStdout -Dexpression=project.version 2>/dev/null)
-    export APPLICATION_DNS=$(cat web-client-backend/infrastructure/application_dns)
-    echo "Application DNS: ${APPLICATION_DNS}"
-    cd web-client-backend/infrastructure/ansible
-    echo "${APP_SERVER_NAME}.servers.the-fire-archmage.ninja ansible_user=root" > inventory
-    ansible-playbook -i inventory --private-key ../app-server-1.key \
-        --extra-vars "app_version=${APP_VERSION}" \
-        --extra-vars "registry_host=${DOCKER_REGISTRY}" \
-        --extra-vars "registry_username=${DOCKER_REGISTRY_USER}" \
-        --extra-vars "registry_password=${DOCKER_REGISTRY_PASSWORD}" \
-        --extra-vars "application_dns=${APPLICATION_DNS}" \
-        --extra-vars "stack_name=${APP_STACK_NAME}" \
-        40k-damage-calculator.yaml
-
-publish-core:
-    #!/usr/bin/env bash
-    set -euxo pipefail
-    mvn -pl core deploy
-
-webclient-frontend-build environment="local":
-    #!/usr/bin/env bash
-    set -uexo pipefail
-    # First retrieve the backend api DNS, depending on stack name and app server
-    if [[ "{{environment}}" = "remote" ]]; then
-        # We assume that any non local is always going to be https
-        export VITE_API_SCHEMA=https
-        export VITE_API_PORT=443
-        export VITE_API_HOST=$(cd web-client-backend/infrastructure/tofu && tofu output -var-file ${APP_SERVER_NAME}-${APP_STACK_NAME}.tfvars -raw application_dns)
-    elif [[ "{{environment}}" == "local" ]]; then
-        # The api is hosted locally on port 80
-        export VITE_API_SCHEMA=http
-        export VITE_API_PORT=7070
-        export VITE_API_HOST=localhost
-    fi
-    cd web-client-frontend
-    npm run build
-
-webclient-frontend-docker-build:
-    #!/usr/bin/env bash
-    set -uexo pipefail
-    cd web-client-frontend
-    export web_version=$(jq -r '.version' package.json)
-    docker buildx build -t 40kcalculator-webclient-frontend:${web_version} -f infrastructure/docker/Dockerfile .
-    docker tag 40kcalculator-webclient-frontend:${web_version} $DOCKER_REGISTRY/loic/40kcalculator-webclient-frontend:${web_version}
-
-webclient-frontend-docker-push:
-    #!/usr/bin/env bash
-    set -uexo pipefail
-    export web_version=$(jq -r '.version' web-client-frontend/package.json)
-    docker login -u "$DOCKER_REGISTRY_USER" -p "${DOCKER_REGISTRY_PASSWORD}" "${DOCKER_REGISTRY}"
-    docker push $DOCKER_REGISTRY/loic/40kcalculator-webclient-frontend:${web_version}
-
-webclient-frontend-docker-try:
-    #!/usr/bin/env bash
-    set -uexo pipefail
-    cd web-client-frontend
-    export web_version=$(jq -r '.version' package.json)
-    docker stop 40kcalculator-webclient-frontend 2>/dev/null || true
-    docker rm 40kcalculator-webclient-frontend 2>/dev/null || true
-    docker run --name 40kcalculator-webclient-frontend -d -p 80:80 40kcalculator-webclient-frontend:${web_version}
+# Import subproject justfiles
+import 'bsdata-parser/justfile'
+import 'core/justfile'
+import 'web-client-backend/justfile'
+import 'web-client-frontend/justfile'

web-client-backend/justfile

@@ -0,0 +1,73 @@
+set dotenv-load := true
+set export := true
+
+# Packages web-client backend, builds docker image and pushes to registry
+build-and-push: build docker-build docker-push
+
+# Build the web client backend application
+build:
+    #!/usr/bin/env bash
+    set -euxo pipefail
+    cd ..
+    mvn clean package -am -pl web-client-backend
+    cd web-client-backend
+    ./jpackage.sh
+
+# Build Docker image for backend
+docker-build:
+    #!/usr/bin/env bash
+    # This needs build to have been invoked
+    set -euxo pipefail
+    cd ..
+    export web_version=$(mvn -pl web-client-backend help:evaluate -q -DforceStdout -Dexpression=project.version 2>/dev/null)
+    docker buildx build -t 40kcalculator-webclient-backend:${web_version} -f web-client-backend/infrastructure/docker/Dockerfile \
+    --build-arg "APP_API_PORT=${APP_API_PORT}" \
+    --build-arg "APP_METRICS_PORT=${APP_METRICS_PORT}" \
+    --build-arg "APP_STACK_NAME=${APP_STACK_NAME}" \
+    .
+    docker tag 40kcalculator-webclient-backend:${web_version} $DOCKER_REGISTRY/loic/40kcalculator-webclient-backend:${web_version}
+
+# Push Docker image to registry
+docker-push:
+    #!/usr/bin/env bash
+    set -euxo pipefail
+    cd ..
+    export web_version=$(mvn -pl web-client-backend help:evaluate -q -DforceStdout -Dexpression=project.version 2>/dev/null)
+    docker login -u "$DOCKER_REGISTRY_USER" -p "${DOCKER_REGISTRY_PASSWORD}" "${DOCKER_REGISTRY}"
+    docker push $DOCKER_REGISTRY/loic/40kcalculator-webclient-backend:${web_version}
+
+# Try running the Docker container locally
+docker-try:
+    #!/usr/bin/env bash
+    set -euxo pipefail
+    cd ..
+    export web_version=$(mvn help:evaluate -pl web-client-backend -q -DforceStdout -Dexpression=project.version 2>/dev/null)
+    docker run -p ${APP_API_PORT}:${APP_API_PORT} -p ${APP_METRICS_PORT}:${APP_METRICS_PORT} -d --name 40kcalculator 40kcalculator-webclient-backend:${web_version}
+
+# Provision infrastructure with Terraform/OpenTofu
+provision-infra:
+    #!/usr/bin/env bash
+    set -euxo pipefail
+    cd infrastructure/tofu
+    tofu init -var-file app-server-1-main.tfvars
+    tofu apply -var-file app-server-1-main.tfvars
+    tofu output -var-file app-server-1-main.tfvars -raw application_dns > ../application_dns
+
+# Deploy application using Ansible
+provision-application:
+    #!/usr/bin/env bash
+    set -uexo pipefail
+    cd ..
+    export APP_VERSION=$(mvn -pl web-client-backend help:evaluate -q -DforceStdout -Dexpression=project.version 2>/dev/null)
+    export APPLICATION_DNS=$(cat web-client-backend/infrastructure/application_dns)
+    echo "Application DNS: ${APPLICATION_DNS}"
+    cd web-client-backend/infrastructure/ansible
+    echo "${APP_SERVER_NAME}.servers.the-fire-archmage.ninja ansible_user=root" > inventory
+    ansible-playbook -i inventory --private-key ../app-server-1.key \
+        --extra-vars "app_version=${APP_VERSION}" \
+        --extra-vars "registry_host=${DOCKER_REGISTRY}" \
+        --extra-vars "registry_username=${DOCKER_REGISTRY_USER}" \
+        --extra-vars "registry_password=${DOCKER_REGISTRY_PASSWORD}" \
+        --extra-vars "application_dns=${APPLICATION_DNS}" \
+        --extra-vars "stack_name=${APP_STACK_NAME}" \
+        40k-damage-calculator.yaml

web-client-backend/src/main/java/ninja/thefirearchmage/games/fourtykcalculator/webclient/Warhammer40kCalculatorWebApp.java

@@ -50,6 +50,9 @@ public class Warhammer40kCalculatorWebApp implements Runnable, CommandLine.IVers
     @Option(names = "--stack-name", description = "The application can be deployed several times in the same server, and the way to distinguish them is by stack name",
             defaultValue = "main")
     private String stackName;
+    @Option(names = "--running-mode", description = "If not running in production mode, disable metrics",
+            defaultValue = "production")
+    private String runMode;
 
     private String bootstrapDataJsonPrerender;
     private Validator inputValidator;
@@ -77,7 +80,9 @@ public class Warhammer40kCalculatorWebApp implements Runnable, CommandLine.IVers
             });
         });
 
-        configureMetrics(app);
+        if(runMode.equals("production")) {
+            configureMetrics(app);
+        }
         configureRoutes(app);
 
         app.start(port);
@@ -91,8 +96,8 @@ public class Warhammer40kCalculatorWebApp implements Runnable, CommandLine.IVers
                 .getResourceAsStream("META-INF/maven/ninja.thefirearchmage.games.fourtykcalculator/web-client-backend/pom.properties")) {
 
             if(input == null) {
-                log.error("Could not load pom.properties file from the resources");
-                throw new IllegalStateException("Could not load pom.properties file");
+                log.error("Could not load pom.properties file from the resources, version is not available");
+                return "unavailable version";
             }
 
             Properties props = new Properties();

web-client-frontend/justfile

@@ -0,0 +1,50 @@
+set dotenv-load := true
+set export := true
+
+# Build the frontend for given environment (local or remote)
+build environment="local":
+    #!/usr/bin/env bash
+    set -uexo pipefail
+    # First retrieve the backend api DNS, depending on stack name and app server
+    if [[ "{{environment}}" = "remote" ]]; then
+        # We assume that any non local is always going to be https
+        export VITE_API_SCHEMA=https
+        export VITE_API_PORT=443
+        export VITE_API_HOST=$(cd ../web-client-backend/infrastructure/tofu && tofu output -var-file ${APP_SERVER_NAME}-${APP_STACK_NAME}.tfvars -raw application_dns)
+    elif [[ "{{environment}}" == "local" ]]; then
+        # The api is hosted locally on port 7070
+        export VITE_API_SCHEMA=http
+        export VITE_API_PORT=7070
+        export VITE_API_HOST=localhost
+    fi
+    npm run build
+
+run:
+    #!/usr/bin/env bash
+    set -uexo pipefail
+    npm run dev
+
+# Build Docker image for frontend
+docker-build:
+    #!/usr/bin/env bash
+    set -uexo pipefail
+    export web_version=$(jq -r '.version' package.json)
+    docker buildx build -t 40kcalculator-webclient-frontend:${web_version} -f infrastructure/docker/Dockerfile .
+    docker tag 40kcalculator-webclient-frontend:${web_version} $DOCKER_REGISTRY/loic/40kcalculator-webclient-frontend:${web_version}
+
+# Push Docker image to registry
+docker-push:
+    #!/usr/bin/env bash
+    set -uexo pipefail
+    export web_version=$(jq -r '.version' package.json)
+    docker login -u "$DOCKER_REGISTRY_USER" -p "${DOCKER_REGISTRY_PASSWORD}" "${DOCKER_REGISTRY}"
+    docker push $DOCKER_REGISTRY/loic/40kcalculator-webclient-frontend:${web_version}
+
+# Try running the Docker container locally
+docker-try:
+    #!/usr/bin/env bash
+    set -uexo pipefail
+    export web_version=$(jq -r '.version' package.json)
+    docker stop 40kcalculator-webclient-frontend 2>/dev/null || true
+    docker rm 40kcalculator-webclient-frontend 2>/dev/null || true
+    docker run --name 40kcalculator-webclient-frontend -d -p 80:80 40kcalculator-webclient-frontend:${web_version}