jenkins普通流水模版

pipeline {
    agent any

    environment {
        // 基础配置
        DOCKER_IMAGE = '192.168.73.100:38080/label/test-project'
        PROJECT_URL = '192.168.73.100:48080/testproject/test-project.git'
        PROJECT_BRANCH = 'main'
        REGISTRY_CREDENTIALS_ID = '3a6d2e5c-1b9f-4e8a-9c2d-7e4f6a8b9c3d'
        JENKINS_PROJECT_NAME = 'test-project-正式服'
        K8S_FILE = '/data/kubelet/test-project.yaml'
        DOCKER_FILE_PATH = './'

        // 构建信息
        BUILD_TIMESTAMP = "${new Date().format('yyyyMMdd-HHmmss')}"
        GIT_COMMIT_SHORT = ''
        GIT_TAG = ''
        IMAGE_TAG = ''
        IMAGE_FULL_NAME = ''
    }

    options {
        // 构建选项
        timeout(time: 30, unit: 'MINUTES')
        timestamps()
        ansiColor('xterm')
        disableConcurrentBuilds()
    }

    stages {
        stage('初始化') {
            steps {
                script {
                    echo "🚀 开始构建项目: ${JENKINS_PROJECT_NAME}"
                    echo "📅 构建时间: ${BUILD_TIMESTAMP}"
                    echo "🌿 目标分支: ${PROJECT_BRANCH}"
                }
            }
        }

        stage('代码检出') {
            steps {
                script {
                    withCredentials([string(credentialsId: '2b1c8d7e-9c4f-41a2-8a3b-6d5e1f4a7b8c', variable: 'GITLAB_TOKEN')]) {
                        // 检出代码
                        checkout([
                            $class: 'GitSCM',
                            branches: [[name: "*/${PROJECT_BRANCH}"]],
                            userRemoteConfigs: [[
                                url: "http://oauth2:${GITLAB_TOKEN}@${PROJECT_URL}",
                                credentialsId: '2b1c8d7e-9c4f-41a2-8a3b-6d5e1f4a7b8c'
                            ]],
                            extensions: [
                                [$class: 'CleanBeforeCheckout'],
                                [$class: 'SubmoduleOption', recursiveSubmodules: true]
                            ]
                        ])

                        // 获取Git信息
                        env.GIT_COMMIT_SHORT = sh(script: 'git rev-parse --short HEAD', returnStdout: true).trim()

                        // 检查当前提交是否有标签
                        def currentTags = sh(script: 'git tag --points-at HEAD', returnStdout: true).trim()

                        if (currentTags) {
                            // 如果有多个标签，取最新的一个
                            env.GIT_TAG = currentTags.split('\n').last()
                            env.IMAGE_TAG = env.GIT_TAG
                            echo "🏷️  当前提交有标签: ${env.GIT_TAG}"
                        } else {
                            // 检查最近的标签
                            def latestTag = sh(script: 'git describe --tags --abbrev=0 2>/dev/null || echo ""', returnStdout: true).trim()

                            if (latestTag) {
                                // 计算距离最新标签的提交数
                                def commitCount = sh(script: "git rev-list --count ${latestTag}..HEAD", returnStdout: true).trim()
                                if (commitCount == "0") {
                                    // 当前提交就是最新标签
                                    env.GIT_TAG = latestTag
                                    env.IMAGE_TAG = env.GIT_TAG
                                    echo "🏷️  使用最新标签: ${env.GIT_TAG}"
                                } else {
                                    // 有新的提交，使用commit ID
                                    env.IMAGE_TAG = env.GIT_COMMIT_SHORT
                                    echo "📝 距离最新标签 ${latestTag} 有 ${commitCount} 个提交，使用commit ID: ${env.GIT_COMMIT_SHORT}"
                                }
                            } else {
                                // 没有任何标签，使用commit ID
                                env.IMAGE_TAG = env.GIT_COMMIT_SHORT
                                echo "📝 没有找到任何标签，使用commit ID: ${env.GIT_COMMIT_SHORT}"
                            }
                        }

                        // 构建完整镜像名称
                        env.IMAGE_FULL_NAME = "${DOCKER_IMAGE}:${env.IMAGE_TAG}"

                        echo "🐳 镜像名称: ${env.IMAGE_FULL_NAME}"
                        echo "📋 Git信息:"
                        echo "   - 提交ID: ${env.GIT_COMMIT_SHORT}"
                        echo "   - 标签: ${env.GIT_TAG ?: '无'}"
                        echo "   - 镜像标签: ${env.IMAGE_TAG}"
                    }
                }
            }
        }

        stage('代码质量检查') {
            parallel {
                stage('代码规范检查') {
                    steps {
                        script {
                            echo "🔍 执行代码规范检查..."
                            // 这里可以添加具体的代码检查命令
                            // 例如: npm run lint, pylint, sonarqube等

                            // 模拟检查过程
                            sleep(5)
                            echo "✅ 代码规范检查完成"
                        }
                    }
                }

                stage('安全扫描') {
                    steps {
                        script {
                            echo "🛡️  执行安全扫描..."
                            // 这里可以添加安全扫描工具
                            // 例如: OWASP ZAP, Trivy等

                            // 模拟扫描过程
                            sleep(8)
                            echo "✅ 安全扫描完成"
                        }
                    }
                }
            }
        }

        stage('构建测试') {
            parallel {
                stage('单元测试') {
                    steps {
                        script {
                            echo "🧪 执行单元测试..."
                            // 这里添加具体的测试命令
                            // 例如: npm test, pytest等

                            // 模拟测试过程
                            sleep(10)
                            echo "✅ 单元测试完成"
                        }
                    }
                }

                stage('集成测试') {
                    steps {
                        script {
                            echo "🔗 执行集成测试..."
                            // 这里添加集成测试命令

                            // 模拟测试过程
                            sleep(12)
                            echo "✅ 集成测试完成"
                        }
                    }
                }
            }
        }

        stage('构建应用') {
            steps {
                script {
                    echo "🔨 开始构建应用..."
                    echo "📦 构建镜像: ${env.IMAGE_FULL_NAME}"

                    // 这里添加具体的构建命令
                    // 例如: docker build, npm run build等

                    // 模拟构建过程
                    sleep(15)
                    echo "✅ 应用构建完成"
                }
            }
        }

        stage('构建Docker镜像') {
            steps {
                script {
                    echo "🐳 构建Docker镜像..."
                    /*
                    withCredentials([usernamePassword(credentialsId: REGISTRY_CREDENTIALS_ID, usernameVariable: 'REGISTRY_USER', passwordVariable: 'REGISTRY_PASS')]) {
                        // 构建Docker镜像
                        sh """
                            docker build -t ${env.IMAGE_FULL_NAME} ${DOCKER_FILE_PATH}
                            docker tag ${env.IMAGE_FULL_NAME} ${DOCKER_IMAGE}:latest
                        """
                    }
                    */
                    echo "✅ Docker镜像构建完成: ${env.IMAGE_FULL_NAME}"
                }
            }
        }

        stage('推送镜像') {
            steps {
                script {
                    echo "📤 推送Docker镜像到仓库..."
                    /*
                    withCredentials([usernamePassword(credentialsId: REGISTRY_CREDENTIALS_ID, usernameVariable: 'REGISTRY_USER', passwordVariable: 'REGISTRY_PASS')]) {
                        // 登录镜像仓库
                        sh "echo '${REGISTRY_PASS}' | docker login 192.168.73.100:38080 -u ${REGISTRY_USER} --password-stdin"

                        // 推送镜像
                        sh """
                            docker push ${env.IMAGE_FULL_NAME}
                            docker push ${DOCKER_IMAGE}:latest
                        """
                    }
                    */
                    echo "✅ 镜像推送完成"
                }
            }
        }

        stage('部署到测试环境') {
            steps {
                script {
                    echo "🚀 部署到测试环境..."
                    /*
                    // 更新Kubernetes配置文件中的镜像标签
                    sh """
                        sed -i 's|image: ${DOCKER_IMAGE}:.*|image: ${env.IMAGE_FULL_NAME}|g' ${K8S_FILE}
                    """

                    // 应用Kubernetes配置
                    sh "kubectl apply -f ${K8S_FILE}"

                    // 等待部署完成
                    sh "kubectl rollout status deployment/test-project --timeout=300s"
                    */
                    echo "✅ 测试环境部署完成"
                }
            }
        }

        stage('健康检查') {
            steps {
                script {
                    echo "🏥 执行健康检查..."

                    // 等待服务启动
                    // sleep(30)

                    // 这里可以添加具体的健康检查逻辑
                    // 例如: curl检查API端点，数据库连接测试等

                    echo "✅ 健康检查通过"
                }
            }
        }

        stage('创建Git标签') {
            when {
                expression {
                    // 只有在没有标签且构建成功时才创建标签
                    return !env.GIT_TAG && currentBuild.result == 'SUCCESS'
                }
            }
            steps {
                script {
                    echo "🏷️  创建Git标签..."

                    withCredentials([string(credentialsId: '2b1c8d7e-9c4f-41a2-8a3b-6d5e1f4a7b8c', variable: 'GITLAB_TOKEN')]) {
                        // 创建新标签
                        def newTag = "v${BUILD_TIMESTAMP}"
                        sh """
                            git config user.email "jenkins@example.com"
                            git config user.name "Jenkins"
                            git tag -a ${newTag} -m "Auto-generated tag for build ${BUILD_NUMBER}"
                            git push origin ${newTag}
                        """

                        echo "✅ 创建标签: ${newTag}"
                    }
                }
            }
        }
    }

    post {
        always {
            script {
                echo "🧹 清理工作空间..."
                // 注释掉Docker镜像清理
                /*
                // 清理Docker镜像
                sh "docker rmi ${env.IMAGE_FULL_NAME} || true"
                sh "docker rmi ${DOCKER_IMAGE}:latest || true"

                // 清理未使用的Docker镜像
                sh "docker image prune -f || true"
                */

                echo "✅ 工作空间清理完成"
            }
        }

        success {
            script {
                echo "🎉 构建成功！"
                echo "📊 构建信息:"
                echo "   - 构建号: ${BUILD_NUMBER}"
                echo "   - 镜像: ${env.IMAGE_FULL_NAME}"
                echo "   - 标签: ${env.IMAGE_TAG}"
                echo "   - 耗时: ${currentBuild.durationString}"

                // 这里可以添加成功通知
                // 例如: 发送邮件、钉钉、企业微信等
            }
        }

        failure {
            script {
                echo "❌ 构建失败！"
                echo "🔍 请检查构建日志以获取详细信息"

                // 这里可以添加失败通知
                // 例如: 发送邮件、钉钉、企业微信等
            }
        }

        unstable {
            script {
                echo "⚠️  构建不稳定"
            }
        }

        aborted {
            script {
                echo "⏹️  构建被中断"
            }
        }
    }
}

// 工具函数
def notify(String message, String type = 'info') {
    def emoji = [
        'info': 'ℹ️',
        'success': '✅',
        'warning': '⚠️',
        'error': '❌'
    ]

    echo "${emoji[type]} ${message}"
}

def getBuildDuration() {
    def duration = currentBuild.duration
    def minutes = duration.intdiv(60000)
    def seconds = (duration % 60000).intdiv(1000)
    return "${minutes}分${seconds}秒"
}