Jenkins Git Hub 연동

git@rev-devel:~/git/hmlf/ai_client.git/hooks$ cat post-receive 
JENKINS_URL="https://33e1-218-233-16-216.ngrok-free.app"
JENKINS_JOB="ai_client"
JENKINS_USER="admin"
JENKINS_TOKEN="<my_token>"

TRIGGER_URL="${JENKINS_URL}/job/${JENKINS_JOB}/build?token=${JENKINS_TOKEN}"


LOG_FILE="/tmp/post-receive.log"

{
  echo "[$(date)] Triggering Jenkins Job"
  echo "Jenkins URL: ${TRIGGER_URL}"

  RESPONSE=$(curl -X POST "${TRIGGER_URL}" --user "${JENKINS_USER}:${JENKINS_TOKEN}" -w "%{http_code}")

  echo "Jenkins Response: ${RESPONSE}"
} >> "${LOG_FILE}" 2>&1

def unit_test_failed = false

pipeline {
    agent any
    environment {
        SERVER_IP = "192.168.x.x"
        REPORT_IP = "http://192.168.x.x:8080"
        SERVER_USER = "test"
        REPO_URL = 'ssh://git@192.168.x.x/git/ai_core_service.git'
        ENGINE_REPO_URL = 'ssh://git@192.168.x.x/ai_engine.git'
        TRAIN_REPO_URL = 'ssh://git@192.168.x.x/ai_train_engine.git'
        COMMON_LIB_REPO = 'ssh://git@192.168.x.x/ai_fw_utility.git'
        AUTHENTICATION_REPO = 'ssh://git@192.168.x.x/ai_sw.git'
        STARTKIT_REPO = 'ssh://git@192.168.x.x/ai_starterkit.git'
        CUSTOM_BUILD_URL = "${REPORT_IP}/job/${env.JOB_NAME}/${env.BUILD_NUMBER}/"
    }
    stages {
        stage('Notify Build Start') {
            steps {
                script {
                    slackSend (channel: 'C078T1XJE57', color: 'good', message: "Build STARTED: Job '${env.JOB_NAME} [${env.BUILD_NUMBER}]' (${CUSTOM_BUILD_URL})")
                }
            }
        }
        stage('Prepare Environment') {
            steps {
                script {
                    sshagent(['jenkins_to_service_key']) {
                        sh """
                        ssh -o StrictHostKeyChecking=no ${SERVER_USER}@${SERVER_IP} '
                        set -e
                        HOME_DIR=\$(echo ~${SERVER_USER})
                        WORKSPACE_DIR="\${HOME_DIR}/workspace"
                        REPO_NAME=\$(basename -s .git ${REPO_URL})
                        VENV_DIR="\${WORKSPACE_DIR}/\${REPO_NAME}_venv"

                        if [ ! -d "\${WORKSPACE_DIR}" ]; then
                            echo "Directory does not exist. Creating workspace directory..."
                            mkdir -p \${WORKSPACE_DIR}
                            echo "\${WORKSPACE_DIR} successfully created"
                        fi

                        if [ ! -d "\${VENV_DIR}" ]; then
                            echo "Creating virtual environment..."
                            /usr/bin/python3.11 -m venv --system-site-packages \${VENV_DIR}
                        fi
                        '
                        """
                    }
                }
            }
            post {
                failure {
                    script {
                        slackSend (channel: 'C078T1XJE57', color: 'danger', message: "Build FAILED in stage '${env.STAGE_NAME}': Job '${env.JOB_NAME} [${env.BUILD_NUMBER}]' (${CUSTOM_BUILD_URL})")
                    }
                }
            }
        }
        stage('Pip install Project') {
            steps {
                script {
                    sshagent(['jenkins_to_service_key']) {
                        sh """
                        ssh -o StrictHostKeyChecking=no ${SERVER_USER}@${SERVER_IP} '
                        set -e
                        HOME_DIR=\$(echo ~${SERVER_USER})
                        WORKSPACE_DIR="\${HOME_DIR}/workspace"
                        REPO_NAME=\$(basename -s .git ${REPO_URL})
                        PROJECT_DIR="\${WORKSPACE_DIR}/\${REPO_NAME}"
                        VENV_DIR="\${WORKSPACE_DIR}/\${REPO_NAME}_venv"

                        source \${VENV_DIR}/bin/activate
                        pip3 install setuptools wheel

                        if [ ! -d "\${PROJECT_DIR}" ]; then
                            echo "Project directory does not exist. Cloning repository..."
                            cd \${WORKSPACE_DIR}
                            git clone ${REPO_URL}
                            cd \${PROJECT_DIR}
                            pip3 install ./
                        else
                            echo "Project directory exists. Pulling latest changes..."
                            cd \${PROJECT_DIR}
                            git pull
                            pip3 uninstall \${REPO_NAME} -y || true
                            pip3 install ./
                        fi
                        deactivate
                        '
                        """
                    }
                }
            }
            post {
                failure {
                    script {
                        slackSend (channel: 'C078T1XJE57', color: 'danger', message: "Build FAILED in stage '${env.STAGE_NAME}': Job '${env.JOB_NAME} [${env.BUILD_NUMBER}]' (${CUSTOM_BUILD_URL})")
                    }
                }
            }
        }
        stage('Pip install Dependency') {
            steps {
                script {
                    sshagent(['jenkins_to_service_key']) {
                        sh """
                        ssh -o StrictHostKeyChecking=no ${SERVER_USER}@${SERVER_IP} '
                        set -e
                        HOME_DIR=\$(echo ~${SERVER_USER})
                        WORKSPACE_DIR="\${HOME_DIR}/workspace"
                        REPO_NAME=\$(basename -s .git ${REPO_URL})
                        VENV_DIR="\${WORKSPACE_DIR}/\${REPO_NAME}_venv"
                        
                        source \${VENV_DIR}/bin/activate
                        pip3 install torch torchvision torchaudio

                        for REPO_URL in ${COMMON_LIB_REPO} ${ENGINE_REPO_URL} ${TRAIN_REPO_URL}; do
                            REPO_NAME=\$(basename -s .git \${REPO_URL})
                            REPO_DIR="\${WORKSPACE_DIR}/\${REPO_NAME}"
                            if [ ! -d "\${REPO_DIR}" ]; then
                                echo "Cloning repository \${REPO_NAME}..."
                                cd \${WORKSPACE_DIR}
                                git clone \${REPO_URL}
                            else
                                echo "Repository \${REPO_NAME} exists. Pulling latest changes..."
                                cd \${REPO_DIR}
                                git pull
                                pip3 uninstall \${REPO_NAME} -y || true
                            fi
                            cd \${REPO_DIR}
                            pip3 install ./
                        done

                        pip3 install -U Pillow
                        deactivate
                        '
                        """
                    }
                }
            }
            post {
                failure {
                    script {
                        slackSend (channel: 'C078T1XJE57', color: 'danger', message: "Build FAILED in stage '${env.STAGE_NAME}': Job '${env.JOB_NAME} [${env.BUILD_NUMBER}]' (${CUSTOM_BUILD_URL})")
                    }
                }
            }
        }
        stage('Pip install Authentication') {
            steps {
                script {
                    sshagent(['jenkins_to_service_key']) {
                        sh """
                        ssh -o StrictHostKeyChecking=no ${SERVER_USER}@${SERVER_IP} '
                        set -e
                        HOME_DIR=\$(echo ~${SERVER_USER})
                        WORKSPACE_DIR="\${HOME_DIR}/workspace"
                        REPO_NAME=\$(basename -s .git ${REPO_URL})
                        VENV_DIR="\${WORKSPACE_DIR}/\${REPO_NAME}_venv"
                        
                        source \${VENV_DIR}/bin/activate
                        for REPO_URL in ${AUTHENTICATION_REPO}; do
                            REPO_NAME=\$(basename -s .git \${REPO_URL})
                            REPO_DIR="\${WORKSPACE_DIR}/\${REPO_NAME}"
                            if [ ! -d "\${REPO_DIR}" ]; then
                                echo "Cloning repository \${REPO_NAME}..."
                                cd \${WORKSPACE_DIR}
                                git clone \${REPO_URL}
                            else
                                echo "Repository \${REPO_NAME} exists. Pulling latest changes..."
                                cd \${REPO_DIR}
                                git pull
                                pip3 uninstall \${REPO_NAME} -y || true
                            fi
                            cd \${REPO_DIR}
                            pip3 install ./
                        done
                        deactivate
                        '
                        """
                    }
                }
            }
            post {
                failure {
                    script {
                        slackSend (channel: 'C078T1XJE57', color: 'danger', message: "Build FAILED in stage '${env.STAGE_NAME}': Job '${env.JOB_NAME} [${env.BUILD_NUMBER}]' (${CUSTOM_BUILD_URL})")
                    }
                }
            }
        }
        stage('Unit Test') {
            steps {
                script {
                    sshagent(['jenkins_to_service_key']) {
                        def result = sh(
                            script: """
                            ssh -o StrictHostKeyChecking=no ${SERVER_USER}@${SERVER_IP} '
                            set -e
                            HOME_DIR=\$(echo ~${SERVER_USER})
                            WORKSPACE_DIR="\${HOME_DIR}/workspace"
                            REPO_NAME=\$(basename -s .git ${REPO_URL})
                            VENV_DIR="\${WORKSPACE_DIR}/\${REPO_NAME}_venv"
                            PROJECT_DIR="\${WORKSPACE_DIR}/\${REPO_NAME}"
                            source \${VENV_DIR}/bin/activate
                            cd \${PROJECT_DIR}
                            pip3 install pytest
                            pip3 install pytest-mock
                            pip3 install pytest-html
                            pytest --html=\${REPO_NAME}_report.html --self-contained-html
                            RESULT=\$?
                            if [ \${RESULT} -ne 0 ]; then
                                echo "Error: Unit test failed"
                                # exit 1
                            fi
                            deactivate
                            exit \${RESULT}
                            '
                            """, returnStatus: true
                        )

                        if (result != 0) {
                            unit_test_failed = true
                        }
                    }
                }
            }
            post {
                always {
                    sshagent(['jenkins_to_service_key']) {
                        script {
                            def HOME_DIR = sh(script: "ssh -o StrictHostKeyChecking=no ${SERVER_USER}@${SERVER_IP} 'echo ~${SERVER_USER}'", returnStdout: true).trim()
                            def WORKSPACE_DIR = "${HOME_DIR}/workspace"
                            def REPO_NAME = sh(script: "basename -s .git ${REPO_URL}", returnStdout: true).trim()
                            def REMOTE_FILE_PATH = "${WORKSPACE_DIR}/${REPO_NAME}/${REPO_NAME}_report.html"
                            def LOCAL_FILE_PATH = "${env.WORKSPACE}/${REPO_NAME}_report.html"

                            echo "HOME_DIR: ${HOME_DIR}"
                            echo "WORKSPACE_DIR: ${WORKSPACE_DIR}"
                            echo "REPO_NAME: ${REPO_NAME}"
                            echo "REMOTE_FILE_PATH: ${REMOTE_FILE_PATH}"
                            echo "LOCAL_FILE_PATH: ${LOCAL_FILE_PATH}"
                            
                            sh "scp -o StrictHostKeyChecking=no ${SERVER_USER}@${SERVER_IP}:${REMOTE_FILE_PATH} ${LOCAL_FILE_PATH}"

                            slackUploadFile (
                                channel: 'C078T1XJE57',
                                filePath: "${REPO_NAME}_report.html",
                                initialComment: "Unit Test Report for Job '${env.JOB_NAME} [${env.BUILD_NUMBER}]' (${CUSTOM_BUILD_URL})"
                            )

                            if (unit_test_failed) {
                                slackSend (
                                    channel: 'C078T1XJE57',
                                    attachments: [
                                        [
                                            color: "warning",
                                            text: "Unit Test Failed for Job '${env.JOB_NAME} [${env.BUILD_NUMBER}]'. Please check the report for details."
                                        ]
                                    ]
                                )
                            } else {
                                slackSend (
                                    channel: 'C078T1XJE57',
                                    attachments: [
                                        [
                                            color: "success",
                                            text: "Unit Test Succeeded for Job '${env.JOB_NAME} [${env.BUILD_NUMBER}]'. Please check the report for details."
                                        ]
                                    ]
                                )
                            }
                        }
                    }
                }
            }
        }
        stage('Clone StartKit') {
            steps {
                script {
                    sshagent(['jenkins_to_service_key']) {
                        sh """
                        ssh -o StrictHostKeyChecking=no ${SERVER_USER}@${SERVER_IP} '
                        set -e
                        HOME_DIR=\$(echo ~${SERVER_USER})
                        WORKSPACE_DIR="\${HOME_DIR}/workspace"
                        STARTERKIT_REPO_NAME=\$(basename -s .git ${STARTKIT_REPO})
                        STARTERKIT_DIR="\${WORKSPACE_DIR}/\${STARTERKIT_REPO_NAME}"

                        if [ ! -d "\${STARTERKIT_DIR}" ]; then
                            echo "Starter Kit does not exist. Cloning repository ..."
                            cd \${WORKSPACE_DIR}
                            git clone ${STARTKIT_REPO}
                        else
                            echo "Starter Kit exists. Pulling latest changes..."
                            cd \${STARTERKIT_DIR}
                            git pull
                        fi
                        '
                        """
                    }
                }
            }
            post {
                failure {
                    script {
                        slackSend (channel: 'C078T1XJE57', color: 'danger', message: "Build FAILED in stage '${env.STAGE_NAME}': Job '${env.JOB_NAME} [${env.BUILD_NUMBER}]' (${CUSTOM_BUILD_URL})")
                    }
                }
            }
        }
        stage('Install Nuitka') {
            steps {
                script {
                    sshagent(['jenkins_to_service_key']) {
                        sh """
                        ssh -o StrictHostKeyChecking=no ${SERVER_USER}@${SERVER_IP} '
                        set -e
                        HOME_DIR=\$(echo ~${SERVER_USER})
                        WORKSPACE_DIR="\${HOME_DIR}/workspace"
                        REPO_NAME=\$(basename -s .git ${REPO_URL})
                        VENV_DIR="\${WORKSPACE_DIR}/\${REPO_NAME}_venv"

                        source \${VENV_DIR}/bin/activate
                        pip3 install nuitka==2.3.2
                        deactivate
                        '
                        """
                    }
                }
            }
            post {
                failure {
                    script {
                        slackSend (channel: 'C078T1XJE57', color: 'danger', message: "Build FAILED in stage '${env.STAGE_NAME}': Job '${env.JOB_NAME} [${env.BUILD_NUMBER}]' (${CUSTOM_BUILD_URL})")
                    }
                }
            }
        }
        stage('Run Nuitka Script') {
            steps {
                script {
                    sshagent(['jenkins_to_service_key']) {
                        sh """
                        ssh -o StrictHostKeyChecking=no ${SERVER_USER}@${SERVER_IP} '
                        set -e
                        HOME_DIR=\$(echo ~${SERVER_USER})
                        WORKSPACE_DIR="\${HOME_DIR}/workspace"
                        REPO_NAME=\$(basename -s .git ${REPO_URL})
                        VENV_DIR="\${WORKSPACE_DIR}/\${REPO_NAME}_venv"
                        PROJECT_DIR="\${WORKSPACE_DIR}/\${REPO_NAME}"
                        STARTERKIT_REPO_NAME=\$(basename -s .git ${STARTKIT_REPO})

                        source \${VENV_DIR}/bin/activate
                        
                        NUITKA_SCRIPT="\${WORKSPACE_DIR}/\${STARTERKIT_REPO_NAME}/packaging/nuitka/\${REPO_NAME}.sh"
                        
                        cd \${PROJECT_DIR}
                        bash \${NUITKA_SCRIPT}

                        echo "\${REPO_NAME} Packing Finished!"
                        deactivate
                        '
                        """
                    }
                }
            }
            post {
                failure {
                    script {
                        slackSend (channel: 'C078T1XJE57', color: 'danger', message: "Build FAILED in stage '${env.STAGE_NAME}': Job '${env.JOB_NAME} [${env.BUILD_NUMBER}]' (${CUSTOM_BUILD_URL})")
                    }
                }
            }
        }
        stage('Test Nuitka') {
            steps {
                script {
                    sshagent(['jenkins_to_service_key']) {
                        sh """
                        ssh -o StrictHostKeyChecking=no ${SERVER_USER}@${SERVER_IP} '
                        set -e
                        HOME_DIR=\$(echo ~${SERVER_USER})
                        WORKSPACE_DIR="\${HOME_DIR}/workspace"
                        REPO_NAME=\$(basename -s .git ${REPO_URL})
                        PROJECT_DIR="\${WORKSPACE_DIR}/\${REPO_NAME}"

                        DST_DIR=\$(find \${PROJECT_DIR} -type d -name "*.dist")
                        BIN_FILE=\$(find \${DST_DIR} -type f -name "*.bin")

                        if [ -z "\${DST_DIR}" ] || [ -z "\${BIN_FILE}" ]; then
                            echo "Error: .dist directory or .bin file not found"
                            exit 1
                        fi

                        \${BIN_FILE} -help
                        RESULT=\$?
                        if [ \${RESULT} -ne 0 ]; then
                            echo "Error: .bin file execution failed"
                            exit 1
                        fi

                        echo "Nuitka script executed successfully"
                        '
                        """
                    }
                }
            }
            post {
                failure {
                    script {
                        slackSend (channel: 'C078T1XJE57', color: 'danger', message: "Build FAILED in stage '${env.STAGE_NAME}': Job '${env.JOB_NAME} [${env.BUILD_NUMBER}]' (${CUSTOM_BUILD_URL})")
                    }
                }
            }
        }
        stage('Notify Build Result') {
            steps {
                script {
                    slackSend (channel: 'C078T1XJE57', color: 'good', message: "Build Finished: Job '${env.JOB_NAME} [${env.BUILD_NUMBER}]' (${CUSTOM_BUILD_URL})")
                }
            }
        }
    }
}