feat: add version check for destination gitlab

The execution now fails gracefully if the version of the destination GitLab instance is not at least 17.6
This is required for pull mirroring via API call

NOTE: update go version to current latest (1.24.3)

Author: BoxBoxJason

Containerfile

@@ -1,4 +1,4 @@
-FROM docker.io/golang:1.24.2-alpine AS build
+FROM docker.io/golang:1.24.3-alpine AS build
 
 ARG VERSION="dev"
 

go.mod

@@ -1,8 +1,9 @@
 module gitlab-sync
 
-go 1.24.2
+go 1.24.3
 
 require (
+	github.com/Masterminds/semver/v3 v3.3.1
 	github.com/hashicorp/go-retryablehttp v0.7.7
 	github.com/spf13/cobra v1.9.1
 	gitlab.com/gitlab-org/api/client-go v0.128.0

internal/mirroring/get.go

@@ -7,9 +7,14 @@ import (
 	"strings"
 	"sync"
 
+	"github.com/Masterminds/semver/v3"
 	"go.uber.org/zap"
 )
 
+const (
+	INSTANCE_SEMVER_THRESHOLD = "17.6"
+)
+
 // fetchAll retrieves all projects and groups from the GitLab instance
 // that match the filters and stores them in the instance cache.
 func (g *GitlabInstance) fetchAll(projectFilters map[string]struct{}, groupFilters map[string]struct{}, mirrorMapping *utils.MirrorMapping) []error {
@@ -77,3 +82,25 @@ func checkPathMatchesFilters(resourcePath string, projectFilters *map[string]str
 	}
 	return "", false
 }
+
+func (g *GitlabInstance) CheckVersion() error {
+	metadata, _, err := g.Gitlab.Metadata.GetMetadata()
+	if err != nil {
+		return fmt.Errorf("failed to get GitLab version: %w", err)
+	}
+	zap.L().Debug("GitLab Instance version", zap.String(ROLE, g.Role), zap.String("version", metadata.Version))
+
+	currentVer, err := semver.NewVersion(metadata.Version)
+	if err != nil {
+		return fmt.Errorf("failed to parse GitLab version: %w", err)
+	}
+	thresholdVer, err := semver.NewVersion(INSTANCE_SEMVER_THRESHOLD)
+	if err != nil {
+		return fmt.Errorf("failed to parse version threshold: %w", err)
+	}
+
+	if currentVer.LessThan(thresholdVer) {
+		return fmt.Errorf("GitLab version %s is below required threshold %s", currentVer, thresholdVer)
+	}
+	return nil
+}

internal/mirroring/get_test.go

@@ -2,6 +2,7 @@ package mirroring
 
 import (
 	"gitlab-sync/internal/utils"
+	"net/http"
 	"testing"
 )
 
@@ -64,11 +65,10 @@ func TestCheckPathMatchesFilters(t *testing.T) {
 			}
 		})
 	}
-
 }
 
 func TestGetParentNamespaceID(t *testing.T) {
-	gitlabInstance := setupTestGitlabInstance(t, ROLE_DESTINATION, INSTANCE_SIZE_SMALL)
+	_, gitlabInstance := setupEmptyTestServer(t, ROLE_DESTINATION, INSTANCE_SIZE_SMALL)
 	gitlabInstance.addGroup(TEST_GROUP)
 	gitlabInstance.addProject(TEST_PROJECT)
 
@@ -194,3 +194,59 @@ func TestFetchAll(t *testing.T) {
 	}
 
 }
+
+func TestCheckVersion(t *testing.T) {
+	tests := []struct {
+		name          string
+		version       string
+		expectedError bool
+	}{
+		{
+			name:          "Valid version under threshold",
+			version:       "15.0.0",
+			expectedError: true,
+		},
+		{
+			name:          "Valid version above threshold",
+			version:       "17.9.3-ce.0",
+			expectedError: false,
+		},
+		{
+			name:          "Invalid version format with 1 dot",
+			version:       "invalid.version",
+			expectedError: true,
+		},
+		{
+			name:          "Invalid version format with 2 dots",
+			version:       "invalid.version.1",
+			expectedError: true,
+		},
+		{
+			name:          "Invalid empty version",
+			version:       "",
+			expectedError: true,
+		},
+	}
+
+	// Iterate over the test cases
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			t.Parallel()
+
+			mux, gitlabInstance := setupEmptyTestServer(t, ROLE_DESTINATION, INSTANCE_SIZE_SMALL)
+			mux.HandleFunc("/api/v4/metadata", func(w http.ResponseWriter, r *http.Request) {
+				w.Header().Set("Content-Type", "application/json")
+				w.WriteHeader(http.StatusOK)
+				_, err := w.Write([]byte(`{"version": "` + test.version + `"}`))
+				if err != nil {
+					t.Errorf("failed to write response: %v", err)
+				}
+			})
+
+			err := gitlabInstance.CheckVersion()
+			if (err != nil) != test.expectedError {
+				t.Errorf("expected error: %v, got: %v", test.expectedError, err)
+			}
+		})
+	}
+}

internal/mirroring/helper_test.go

@@ -265,6 +265,29 @@ var (
 		}`}
 )
 
+func setupEmptyTestServer(t *testing.T, role string, instanceSize string) (*http.ServeMux, *GitlabInstance) {
+	// mux is the HTTP request multiplexer used with the test server.
+	mux := http.NewServeMux()
+
+	// server is a test HTTP server used to provide mock API responses.
+	server := httptest.NewServer(mux)
+	t.Cleanup(server.Close)
+
+	gitlabInstance, err := newGitlabInstance(&GitlabInstanceOpts{
+		GitlabURL:    server.URL,
+		GitlabToken:  "test-token",
+		Role:         role,
+		InstanceSize: instanceSize,
+		MaxRetries:   0,
+	})
+
+	if err != nil {
+		t.Fatalf("Failed to create client: %v", err)
+	}
+
+	return mux, gitlabInstance
+}
+
 // setup sets up a test HTTP server along with a gitlab.Client that is
 // configured to talk to that test server.  Tests should register handlers on
 // mux which provide mock responses for the API method being tested.
@@ -531,19 +554,22 @@ func setupTestProject(mux *http.ServeMux, project *gitlab.Project, stringRespons
 	})
 }
 
-// setupTestGitlabInstance sets up a test Gitlab instance with the given role and instance size.
-func setupTestGitlabInstance(t *testing.T, role string, instanceSize string) *GitlabInstance {
-	gitlabInstance, err := newGitlabInstance(&GitlabInstanceOpts{
-		GitlabURL:    "https://gitlab.example.com",
-		GitlabToken:  "test-token",
-		Role:         role,
-		InstanceSize: instanceSize,
-		MaxRetries:   0,
+// setupMetadata sets up the test HTTP server with handlers for metadata-related actions.
+// This includes the version endpoint.
+func setupMetadata(mux *http.ServeMux) {
+	// Setup the version endpoint to return a mock response.
+	mux.HandleFunc("/api/v4/metadata", func(w http.ResponseWriter, r *http.Request) {
+		switch r.Method {
+		case http.MethodGet:
+			w.Header().Set(HEADER_CONTENT_TYPE, HEADER_ACCEPT)
+			// Set response status to 200 OK
+			w.WriteHeader(http.StatusOK)
+			fmt.Fprint(w, `{"version": "18.0.0"}`)
+		default:
+			// Set response status to 405 Method Not Allowed
+			w.WriteHeader(http.StatusMethodNotAllowed)
+		}
 	})
-	if err != nil {
-		t.Fatalf("Failed to create Gitlab instance: %v", err)
-	}
-	return gitlabInstance
 }
 
 func TestReverseGroupMirrorMap(t *testing.T) {

internal/mirroring/main.go

@@ -46,6 +46,10 @@ func MirrorGitlabs(gitlabMirrorArgs *utils.ParserArgs) []error {
 	if err != nil {
 		return []error{err}
 	}
+	err = destinationGitlabInstance.CheckVersion()
+	if err != nil {
+		return []error{err}
+	}
 
 	sourceProjectFilters, sourceGroupFilters, destinationProjectFilters, destinationGroupFilters := processFilters(gitlabMirrorArgs.MirrorMapping)