.github/dependabot.yml

@@ -11,12 +11,12 @@ updates:
     interval: weekly
   open-pull-requests-limit: 10
 - package-ecosystem: docker
-  directory: "/windows/nanoserver-ltsc2019"
+  directory: "/windows/nanoserver"
   schedule:
     interval: weekly
   open-pull-requests-limit: 10
 - package-ecosystem: docker
-  directory: "/windows/windowsservercore-ltsc2019"
+  directory: "/windows/windowsservercore"
   schedule:
     interval: weekly
   open-pull-requests-limit: 10

.github/workflows/release-drafter.yml

@@ -14,6 +14,6 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       # Drafts your next Release notes as Pull Requests are merged into the default branch
-      - uses: release-drafter/release-drafter@v5.25.0
+      - uses: release-drafter/release-drafter@v6.1.0
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/updatecli.yaml

@@ -15,15 +15,15 @@ jobs:
         uses: actions/checkout@v4
 
       - name: Install Updatecli in the runner
-        uses: updatecli/updatecli-action@v2.54.0
+        uses: updatecli/updatecli-action@v2.78.1
 
       - name: Run Updatecli in Dry Run mode
-        run: updatecli diff --config ./updatecli/updatecli.d --values ./updatecli/values.github-action.yaml
+        run: updatecli diff --config ./updatecli/updatecli.d --values ./updatecli/values.github-action.yaml --values ./updatecli/values.temurin.yaml
         env:
           UPDATECLI_GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
 
       - name: Run Updatecli in Apply mode
         if: github.ref == 'refs/heads/master'
-        run: updatecli apply --config ./updatecli/updatecli.d --values ./updatecli/values.github-action.yaml
+        run: updatecli apply --config ./updatecli/updatecli.d --values ./updatecli/values.github-action.yaml --values ./updatecli/values.temurin.yaml
         env:
           UPDATECLI_GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.gitignore

@@ -3,3 +3,4 @@ bats-core/
 bats/
 target/
 /.vscode/
+build-windows.yaml

Jenkinsfile

@@ -1,85 +1,95 @@
+def agentSelector(String imageType) {
+    // Linux agent
+    if (imageType == 'linux') {
+        return 'linux'
+    }
+    // Windows Server Core 2022 agent
+    if (imageType.contains('2022')) {
+        return 'windows-2022'
+    }
+    // Windows Server Core 2019 agent (for nanoserver 1809 & ltsc2019 and for windowservercore ltsc2019)
+    return 'windows-2019'
+}
+
 pipeline {
     agent none
 
     options {
         buildDiscarder(logRotator(daysToKeepStr: '10'))
-        timestamps()
     }
 
     stages {
-        stage('Build Docker Image') {
-            parallel {
-                stage('Windows') {
-                    agent {
-                        label "docker-windows"
-                    }
-                    options {
-                        timeout(time: 60, unit: 'MINUTES')
-                    }
-                    environment {
-                        DOCKERHUB_ORGANISATION = "${infra.isTrusted() ? 'jenkins' : 'jenkins4eval'}"
+        stage('docker-ssh-agent') {
+            environment {
+                DOCKERHUB_ORGANISATION = "${infra.isTrusted() ? 'jenkins' : 'jenkins4eval'}"
+            }
+            matrix {
+                axes {
+                    axis {
+                        name 'IMAGE_TYPE'
+                        values 'linux', 'nanoserver-1809', 'nanoserver-ltsc2019', 'nanoserver-ltsc2022', 'windowsservercore-ltsc2019', 'windowsservercore-ltsc2022'
                     }
-                    steps {
-                        powershell '& ./make.ps1 test'
-                        script {
-                            def branchName = "${env.BRANCH_NAME}"
-                            if (branchName ==~ 'master') {
-                                // we can't use dockerhub builds for windows
-                                // so we publish here
-                                infra.withDockerCredentials {
-                                    powershell '& ./make.ps1 publish'
+                }
+                stages {
+                    stage('Main') {
+                        agent {
+                            label agentSelector(env.IMAGE_TYPE)
+                        }
+                        options {
+                            timeout(time: 60, unit: 'MINUTES')
+                        }
+                        stages {
+                            stage('Prepare Docker') {
+                                when {
+                                    environment name: 'IMAGE_TYPE', value: 'linux'
                                 }
-                            }
-
-                            def tagName = "${env.TAG_NAME}"
-                            if(tagName =~ /\d(\.\d)+(-\d+)?/) {
-                                // we need to build and publish the tagged version
-                                infra.withDockerCredentials {
-                                    powershell "& ./make.ps1 -PushVersions -VersionTag $tagName publish"
+                                steps {
+                                    sh 'make docker-init'
                                 }
                             }
-                        }
-                    }
-                }
-                stage('Linux') {
-                    agent {
-                        label "docker&&linux"
-                    }
-                    options {
-                        timeout(time: 30, unit: 'MINUTES')
-                    }
-                    steps {
-                        script {
-                            infra.withDockerCredentials {
-                                def branchName = "${env.BRANCH_NAME}"
-                                if (infra.isTrusted()) {
-                                    if (branchName ==~ 'master') {
-                                        sh '''
-                                            docker buildx create --use
-                                            docker run --rm --privileged multiarch/qemu-user-static --reset -p yes
-                                            docker buildx bake --push --file docker-bake.hcl linux
-                                        '''
-                                    } else if (env.TAG_NAME != null)  {
-                                        sh """
-                                            export ON_TAG=true
-                                            export VERSION=$TAG_NAME
-                                            docker buildx create --use
-                                            docker run --rm --privileged multiarch/qemu-user-static --reset -p yes
-                                            docker buildx bake --push --file docker-bake.hcl linux
-                                        """
+                            stage('Build and Test') {
+                                // This stage is the "CI" and should be run on all code changes triggered by a code change
+                                when {
+                                    not { buildingTag() }
+                                }
+                                steps {
+                                    script {
+                                        if(isUnix()) {
+                                            sh 'make build'
+                                            sh 'make test'
+                                            // If the tests are passing for Linux AMD64, then we can build all the CPU architectures
+                                            sh 'make every-build'
+                                        } else {
+                                            powershell '& ./build.ps1 test'
+                                        }
                                     }
-                                } else {
-                                    sh 'make build'
-                                    try {
-                                        sh 'make test'
-                                    } finally {
-                                        junit('target/*.xml')
+                                }
+                                post {
+                                    always {
+                                        junit(allowEmptyResults: true, keepLongStdio: true, testResults: 'target/**/junit-results.xml')
+                                    }
+                                }
+                            }
+                            stage('Deploy to DockerHub') {
+                                // This stage is the "CD" and should only be run when a tag triggered the build
+                                when {
+                                    buildingTag()
+                                }
+                                environment {
+                                    ON_TAG = 'true'
+                                    VERSION = "${env.TAG_NAME}"
+                                }
+                                steps {
+                                    script {
+                                        // This function is defined in the jenkins-infra/pipeline-library
+                                        infra.withDockerCredentials {
+                                            if (isUnix()) {
+                                                sh 'make publish'
+                                            } else {
+                                                powershell '& ./build.ps1 publish'
+                                            }
+                                        }
                                     }
-                                    sh '''
-                                        docker buildx create --use
-                                        docker run --rm --privileged multiarch/qemu-user-static --reset -p yes
-                                        docker buildx bake --file docker-bake.hcl linux
-                                    '''
                                 }
                             }
                         }

Makefile

@@ -22,10 +22,11 @@ check_cli = type "$(1)" >/dev/null 2>&1 || { echo "Error: command '$(1)' require
 ## Check if a given image exists in the current manifest docker-bake.hcl
 check_image = make --silent list | grep -w '$(1)' >/dev/null 2>&1 || { echo "Error: the image '$(1)' does not exist in manifest for the platform 'linux/$(ARCH)'. Please check the output of 'make list'. Exiting." ; exit 1 ; }
 ## Base "docker buildx base" command to be reused everywhere
-bake_base_cli := docker buildx bake -f docker-bake.hcl --load
+bake_base_cli := docker buildx bake --file docker-bake.hcl
+bake_cli := $(bake_base_cli) --load
 
 .PHONY: build
-.PHONY: test test-alpine test-archlinux test-debian test-jdk11 test-jdk11-alpine
+.PHONY: test test-alpine test-debian
 
 check-reqs:
 ## Build requirements
@@ -37,26 +38,37 @@ check-reqs:
 	@$(call check_cli,curl)
 	@$(call check_cli,jq)
 
+## This function is specific to Jenkins infrastructure and isn't required in other contexts
+docker-init: check-reqs
+	@set -x; docker buildx create --use
+	docker run --rm --privileged multiarch/qemu-user-static --reset -p yes
+
 build: check-reqs
-	@set -x; $(bake_base_cli) --set '*.platform=linux/$(ARCH)' $(shell make --silent list)
+	@set -x; $(bake_cli) $(shell make --silent list) --set '*.platform=linux/$(ARCH)'
 
 build-%:
 	@$(call check_image,$*)
-	@set -x; $(bake_base_cli) --set '*.platform=linux/$(ARCH)' '$*'
+	@set -x; $(bake_cli) '$*' --set '*.platform=linux/$(ARCH)'
+
+every-build: check-reqs
+	@set -x; $(bake_base_cli) linux
 
 show:
-	@$(bake_base_cli) linux --print
+	@$(bake_cli) linux --print
 
 list: check-reqs
 	@set -x; make --silent show | jq -r '.target | path(.. | select(.platforms[] | contains("linux/$(ARCH)"))?) | add'
 
 bats:
-	git clone --branch v1.10.0 https://github.com/bats-core/bats-core bats
+	git clone --branch v1.11.1 https://github.com/bats-core/bats-core bats
 
 prepare-test: bats check-reqs
 	git submodule update --init --recursive
 	mkdir -p target
 
+publish:
+	@set -x; $(bake_base_cli) linux --push
+
 ## Define bats options based on environment
 # common flags for all tests
 bats_flags := $(TEST_SUITES)

README.md

@@ -94,6 +94,7 @@ Should you want to build this image on your machine (before submitting a pull re
 * Docker BuildX plugin [installed](https://github.com/docker/buildx#installing) on older versions of Docker (from `19.03`). Docker Buildx is included in recent versions of Docker Desktop for Windows, macOS, and Linux. Docker Linux packages also include Docker Buildx when installed using the DEB or RPM packages.
 * [GNU Make](https://www.gnu.org/software/make/) [installed](https://command-not-found.com/make)
 * jq [installed](https://command-not-found.com/jq)
+* yq [installed](https://github.com/mikefarah/yq) (for Windows)
 * [GNU Bash](https://www.gnu.org/software/bash/) [installed](https://command-not-found.com/bash)
 * git [installed](https://command-not-found.com/git)
 * curl [installed](https://command-not-found.com/curl)
@@ -120,22 +121,23 @@ If you want to build a specific image, you can issue the following command:
 make build-<OS>_<JDK_VERSION>
 ```
 
-That would give for JDK 11 on Alpine Linux:
+That would give for JDK 17 on Alpine Linux:
 
 ```bash
-make build-alpine_jdk11
+make build-alpine_jdk17
 ```
 
-#### Building all images
-Then, you can build all the images by running:
+#### Building images supported by your current architecture
+
+Then, you can build the images supported by your current architecture by running:
 
 ```bash
 make build
 ```
 
 #### Testing all images
 
-If you want to test the images, you can run:
+If you want to test these images, you can run:
 
 ```bash
 make test
@@ -148,10 +150,18 @@ If you want to test a specific image, you can run:
 make test-<OS>_<JDK_VERSION>
 ```
 
-That would give for JDK 11 on Alpine Linux:
+That would give for JDK 17 on Alpine Linux:
 
 ```bash
-make test-alpine_jdk11
+make test-alpine_jdk17
+```
+
+#### Building all images
+
+You can build all images (even those unsupported by your current architecture) by running:
+
+```bash
+make every-build
 ```
 
 #### Other `make` targets
@@ -196,6 +206,58 @@ make bats
 make: 'bats' is up to date.
 ```
 
+`publish` allows the publication of all images targeted by 'linux' to a registry.
+
+`docker-init` is dedicated to Jenkins infrastructure for initializing docker and isn't required in other contexts.
+
+### Building and testing on Windows
+
+#### Building all images
+
+Run `.\build.ps1` to launch the build of the images corresponding to the "windows" target of docker-bake.hcl.
+
+Internally, the first time you'll run this script and if there is no build-windows.yaml file in your repository, it will use a combination of `docker buildx bake` and `yq` to generate a  build-windows.yaml docker compose file containing all Windows image definitions from docker-bake.hcl. Then it will run `docker compose` on this file to build these images.
+
+You can modify this docker compose file as you want, then rerun `.\build.ps1`.
+It won't regenerate the docker compose file from docker-bake.hcl unless you add the `-OverwriteDockerComposeFile` build.ps1 parameter:  `.\build.ps1 -OverwriteDockerComposeFile`.
+
+Note: you can generate this docker compose file from docker-bake.hcl yourself with the following command (require `docker buildx` and `yq`):
+
+```console
+# - Use docker buildx bake to output image definitions from the "windows" bake target
+# - Convert with yq to the format expected by docker compose
+# - Store the result in the docker compose file
+
+$ docker buildx bake --progress=plain --file=docker-bake.hcl windows --print `
+    | yq --prettyPrint '.target[] | del(.output) | {(. | key): {\"image\": .tags[0], \"build\": .}}' | yq '{\"services\": .}' `
+    | Out-File -FilePath build-windows.yaml
+```
+
+Note that you don't need build.ps1 to build (or to publish) your images from this docker compose file, you can use `docker compose --file=build-windows.yaml build`.
+
+#### Testing all images
+
+Run `.\build.ps1 test` if you also want to run the tests harness suit.
+
+Run `.\build.ps1 test -TestsDebug 'debug'` to also get commands & stderr of tests, displayed on top of them.
+You can set it to `'verbose'` to also get stdout of every test command.
+
+Note that instead of passing `-TestsDebug` parameter to build.ps1, you can set the  $env:TESTS_DEBUG environment variable to the desired value.
+
+Also note that contrary to the Linux part, you have to build the images before testing them.
+
+#### Dry run
+
+Add the `-DryRun` parameter to print out any build, publish or tests commands instead of executing them: `.\build.ps1 test -DryRun`
+
+#### Building and testing a specific image
+
+You can build (and test) only one image type by setting `-ImageType` to a combination of Windows flavors ("nanoserver" & "windowsservercore") and Windows versions ("1809", "ltsc2019", "ltsc2022").
+
+Ex: `.\build.ps1 -ImageType 'nanoserver-ltsc2019'`
+
+Warning: trying to build `windowsservercore-1809` will fail as there is no corresponding image from Microsoft.
+
 ## Changelog
 
 See [GitHub Releases](https://github.com/jenkinsci/docker-ssh-agent/releases/latest).