Jenkinsfile3

pipeline {
    agent {
        label "w-1"  // w-1 ~ worker-1
    }

    environment {
        // Get the latest Git tag for versioning
        GIT_TAG = sh(script: "git describe --tags --abbrev=0 || git rev-parse --short HEAD", returnStdout: true).trim()
        GITHUB_TOKEN = credentials('jenkins-github-integration-demo.2025-03-06.private-key.pem')
        REPO_URL = 'https://github.com/repo.git'  
        ZIP_NAME = "gitea-archive-${GIT_TAG}.tar.gz"  // tar.gz file name based on tag
    }

    tools {
        go '1.24.0'
    }

    stages {
        // Checkout the repository and fetch tags
        stage('Checkout') {
            steps {
                script {
                    sh 'git fetch --tags'  // Explicitly fetch tags from the remote repository
                }
            }
        }

        // Get the Git tag 
        stage('Get Git Tag') {
            steps {
                script {
                    GIT_TAG = sh(script: "git describe --tags --abbrev=0 || git rev-parse --short HEAD", returnStdout: true).trim()
                    echo "Using Git tag: ${GIT_TAG}"
                }
            }
        }

        // Run Go Build
        stage('Go Build') {
            steps {
                script {
                    // Build the Go binary with minimized size
                    sh 'go build -ldflags="-s -w" -o gitea'
                }
            }
        }

        // Create a tar.gz archive 
        stage('Create TAR Archive') {
            steps {
                script {
                    // Define the files to include in the archive
                    def filesToInclude = [
                        "web_src/",   
                        "templates/", 
                        "models/", 
                        "public/", 
                        "options/", 
                        "modules/", 
                        "gitea",  // The built Go binary
                        "custom/"     
                    ]

                    // Build the tar command dynamically, using -C to avoid absolute paths
                    def tarCommand = "tar -czf ${ZIP_NAME} -C $WORKSPACE "
                    filesToInclude.each { file -> 
                        tarCommand += "${file} "
                    }

                    // Run the tar command to create the archive
                    sh tarCommand
                }
            }
        }

        // Create a GitHub release and upload  the tar.gz file
        stage('Create GitHub Release') {
            when { branch 'main' }
            steps {
                script {
                    echo 'Checking if GitHub Release already exists...'

                    // Check if the release already exists using GitHub CLI
                    def releaseExists = sh(
                        script: "gh release view ${GIT_TAG} --repo ${REPO_URL} > /dev/null 2>&1",
                        returnStatus: true
                    ) == 0

                    if (releaseExists) {
                        echo "Release ${GIT_TAG} already exists. Skipping release creation."
                    } else {
                        echo 'Creating GitHub Release...'

                        // Create the GitHub release and upload the tar.gz file
                        sh """
                        gh release create \
                            ${GIT_TAG} \
                            ${ZIP_NAME} \
                            --repo ${REPO_URL} \
                            --generate-notes
                        """
                    }
                }
            }
        }
    }
}