Phase 3: Bitbucket API & Shell Library Integration

Basic Information

Table of Contents

1. Goal
2. Commit List (by Phase)
3. Phase-by-Phase Detailed Analysis
4. 3.1 Phase 1: Jenkins Environment Test and Bitbucket API Initial Implementation
5. 3.2 Phase 2: Bitbucket API HTTP Communication Implementation and Debugging
6. 3.3 Phase 3: ShellScript Helper Refactoring
7. 3.4 Phase 4: Git Shell Scripts Implementation and stageProjectPrepare
8. 3.5 Phase 5: GitLibrary/ShellLibrary Separation and BitbucketApiService
9. 3.6 Phase 6: Shell Library Cleanup and Completion
10. New Files
11. 4-Layer Architecture Established
12. Core Patterns
13. Bitbucket API Integration
14. Benefits
15. Next Steps

1. Goal

1. Bitbucket Cloud API integration for automatic build status reporting
2. Abstract Git/Shell commands into reusable libraries
3. Establish src/service/, src/utils/ layer architecture

2. Commit List (by Phase)

3. Phase-by-Phase Detailed Analysis

3.1 Phase 1: Jenkins Environment Test and Bitbucket API Initial Implementation

3.2 Phase 2: Bitbucket API HTTP Communication Implementation and Debugging

3.3 Phase 3: ShellScript Helper Refactoring

// Before: ShellParams class
ShellParams params = new ShellParams(script: 'git fetch', label: 'Fetch')

// After: Using Map
shellScriptHelper.execute([script: 'git fetch', label: 'Fetch'])

3.4 Phase 4: Git Shell Scripts Implementation and stageProjectPrepare

3.5 Phase 5: GitLibrary/ShellLibrary Separation and BitbucketApiService

Before:  src/utils/ShellScripts.groovy (all Shell commands)
After:   src/utils/GitLibrary.groovy
         src/utils/ShellLibrary.groovy
         src/service/general/BitbucketApiService.groovy

3.6 Phase 6: Shell Library Cleanup and Completion

4. New Files

4.1 Layer 3: Service (Business Logic)

sharedLibraries/src/service/general/BitbucketApiService.groovy (155 lines)

Bitbucket Cloud REST API client

class BitbucketApiService {
    def pipeline

    BitbucketApiService(pipeline) {
        this.pipeline = pipeline
    }

    void sendBuildStatusForCommit(String commitHash, String state, String key, String url, String description) {
        // HTTP POST to Bitbucket Cloud API
        // /2.0/repositories/{workspace}/{repo}/commit/{commit}/statuses/build
    }
}

4.2 Layer 4: Utils (Libraries)

sharedLibraries/src/utils/GitLibrary.groovy (258 lines)

Git command library

class GitLibrary {
    // Check branch existence
    static Closure GIT_CHECK_ORIGIN_BRANCH_EXISTS = { branchName ->
        "git ls-remote --heads origin ${branchName} | grep -q ${branchName}"
    }

    // Get default branch
    static Closure GIT_GET_ORIGIN_DEFAULT_BRANCH = {
        "git remote show origin | grep 'HEAD branch' | cut -d' ' -f5"
    }

    // Check if remote branch is ancestor
    static Closure GIT_CHECK_IS_REMOTE_BRANCH_ANCESTOR = { baseBranch, targetBranch ->
        "git merge-base --is-ancestor origin/${baseBranch} origin/${targetBranch}"
    }

    // Merge remote branch
    static Closure GIT_MERGE_ORIGIN_BRANCH = { branchName ->
        "git merge origin/${branchName} --no-edit"
    }

    // Git LFS fetch and checkout
    static Closure GIT_LFS_FETCH_AND_CHECKOUT = {
        "git lfs fetch --all && git lfs checkout"
    }

    // Check if local branch is synced with remote
    static Closure GIT_CHECK_UP_TO_DATE_WITH_REMOTE = { branchName ->
        '''
        LOCAL=$(git rev-parse HEAD)
        REMOTE=$(git rev-parse origin/${branchName})
        [ "$LOCAL" = "$REMOTE" ]
        '''
    }
}

sharedLibraries/src/utils/ShellLibrary.groovy (210 lines)

General Shell command library

class ShellLibrary {
    // Get Docker info
    static Closure DOCKER_INFO = {
        "docker info"
    }

    // Execute Groovy Lint
    static Closure GROOVY_LINT = { targetPath, configPath ->
        "npm-groovy-lint --path ${targetPath} --config ${configPath}"
    }

    // Copy file
    static Closure COPY_FILE = { source, destination ->
        "cp ${source} ${destination}"
    }

    // Check directory existence
    static Closure CHECK_DIR_EXISTS = { path ->
        "[ -d ${path} ]"
    }
}

4.3 Layer 2: vars/ (Entry Points)

sharedLibraries/vars/bitbucketApiHelper.groovy (33 lines)

def sendBuildStatus(String state, String description) {
    BitbucketApiService service = new BitbucketApiService(this)
    service.sendBuildStatusForCommit(
        env.GIT_COMMIT,
        state,
        env.BUILD_TAG,
        env.BUILD_URL,
        description
    )
}

sharedLibraries/vars/stageProjectPrepare.groovy (84 lines)

Git checkout and project preparation Stage

def call(Map config = [:]) {
    logger.stageStart(env.STAGE_NAME)

    logger.stepsGroupStart('Git Repository Setup')
    // Use GitLibrary functions
    shellScriptHelper.execute(GitLibrary.GIT_CHECK_ORIGIN_BRANCH_EXISTS(env.PR_BRANCH))
    // ...

    logger.stepsGroupEnd('Git Repository Setup')
    logger.stageEnd(env.STAGE_NAME)
}

5. 4-Layer Architecture Established

devops-jenkins-linux/
├── */Jenkinsfile                      # Layer 1: Entry Point
│   ├── DLXJenkins/Jenkinsfile
│   ├── DLXJenkins/JenkinsfileDeployment
│   ├── JsJenkins/Jenkinsfile
│   ├── JsJenkins/JenkinsfileDeployment
│   └── PipelineForJenkins/Jenkinsfile
│
└── sharedLibraries/
    ├── vars/                          # Layer 2: Orchestration
    │   ├── stageInitialization.groovy
    │   ├── stageProjectPrepare.groovy
    │   ├── shellScriptHelper.groovy
    │   ├── bitbucketApiHelper.groovy
    │   └── logger.groovy (Cross-Cutting)
    │
    └── src/
        ├── service/                   # Layer 3: Services
        │   └── general/
        │       └── BitbucketApiService.groovy
        │
        ├── utils/                     # Layer 4: Utilities
        │   ├── GitLibrary.groovy
        │   └── ShellLibrary.groovy
        │
        └── resource/                  # Layer 4: Utilities (Constants)
            └── Status.groovy

6. Core Patterns

6.1 Shell Command Abstraction Using Closure

// Definition (GitLibrary.groovy)
static Closure GIT_FETCH_ORIGIN = { branchName ->
    "git fetch origin ${branchName}"
}

// Usage (stageProjectPrepare.groovy)
shellScriptHelper.execute([
    script: GitLibrary.GIT_FETCH_ORIGIN(env.PR_BRANCH),
    label: 'Fetch PR branch from origin'
])

6.2 Advantages

1. Type Safety: Clearly define parameters with Closure
2. Reusability: Use same Git commands in multiple Stages
3. Testability: Test Shell command string generation logic independently
4. Documentation: Can add descriptions for each command

7. Bitbucket API Integration

7.1 Build Status Reporting Flow

Pipeline Start
    ↓
bitbucketApiHelper.sendBuildStatus('INPROGRESS', 'Build started')
    ↓
... (build execution) ...
    ↓
bitbucketApiHelper.sendBuildStatus('SUCCESSFUL', 'Build completed')
    or
bitbucketApiHelper.sendBuildStatus('FAILED', 'Build failed')

7.2 Verification in Bitbucket PR

• Build status badge displayed on PR page
• Per-commit build result verification possible

8. Benefits

1. Centralization: Git/Shell commands managed in one place
2. Consistency: All pipelines use same commands
3. Visibility: Real-time build status verification in Bitbucket
4. Maintainability: Only modify library when changing commands

9. Next Steps

→ Phase 4: Full Pipeline Refactoring and Stage Modularization