Phase 1: ShellScript Modularization & Initialization Stage

Basic Information

Table of Contents

1. Goal
2. Commit List
3. Step-by-Step Detailed Analysis
4. 3.1 Step 1: Initialization Stage Initial Implementation
5. 3.2 Step 2: ShellScript Modularization
6. 3.3 Step 3: Package Structure and Annotation Modifications
7. 3.4 Step 4: Naming Convention Establishment and Logging Improvement
8. New Files
9. Architecture Significance
10. Core Patterns
11. Benefits
12. Next Steps

1. Goal

Separate Shell script execution logic from pipeline code and modularize common initialization logic into Stage

2. Commit List

3. Step-by-Step Detailed Analysis

3.1 Step 1: Initialization Stage Initial Implementation

3.2 Step 2: ShellScript Modularization

Before: vars/Initialization.groovy (includes shell logic)
After:  vars/Initialization.groovy
        vars/ShellScriptHelper.groovy (handles shell execution)
        src/utils/ShellParams.groovy (parameter data class)

3.3 Step 3: Package Structure and Annotation Modifications

// Before: Groovy @Canonical annotation
@Canonical
class ShellParams {
    String script
    String label
}

// After: Manual implementation (Jenkins CPS compatible)
class ShellParams {
    String script
    String label

    ShellParams(String script, String label) {
        this.script = script
        this.label = label
    }
}

3.4 Step 4: Naming Convention Establishment and Logging Improvement

vars/ File Naming Convention:
- Stage modules: stage{StageName}.groovy (e.g., stageInitialization.groovy)
- Helpers: helper{HelperName}.groovy (e.g., helperShellScript.groovy)

4. New Files

4.1 sharedLibraries/src/utils/ShellParams.groovy (43 lines)

Parameter data class for Shell command execution

class ShellParams {
    String script
    String label
    boolean returnStdout = false
    boolean returnStatus = false
}

4.2 sharedLibraries/vars/helperShellScript.groovy (100 lines)

Shell script execution helper - Executes sh commands in a standardized way

def execute(Map params) {
    // params: script, label, returnStdout, returnStatus
    // Integrated logging, error handling
}

4.3 sharedLibraries/vars/stageInitialization.groovy (41 lines)

Pipeline initialization Stage - Environment variable setup, Git information collection

def call() {
    echo "▶️ Stage '${env.STAGE_NAME}' Starting"
    // Initialize environment variables like TICKET_NUMBER, FOLDER_NAME
    // Git origin fetch
}

5. Architecture Significance

5.1 Layer 2 & 4 Established

sharedLibraries/
├── vars/                    # Layer 2: Orchestration
│   ├── helperShellScript.groovy      # Helper
│   └── stageInitialization.groovy    # Stage Module
└── src/
    └── utils/               # Layer 4: Utilities
        └── ShellParams.groovy

5.2 Separation of Concerns Begins

• Before: sh commands written directly in Jenkinsfile
• After: sh execution abstracted in vars/, integrated logging/error handling

6. Core Patterns

6.1 Shell Execution Standardization

// Before (inside Jenkinsfile)
sh 'git fetch origin'

// After (using vars/helperShellScript.groovy)
helperShellScript.execute([
    script: 'git fetch origin',
    label: 'Fetch origin branches'
])

6.2 Stage Modularization

// Before (logic written inside Jenkinsfile)
stage('Initialization') {
    steps {
        script {
            // 10-20 lines of initialization code
        }
    }
}

// After (calling vars/stageInitialization.groovy)
stage('Initialization') {
    steps {
        stageInitialization()
    }
}

7. Benefits

1. Code Reuse: All pipelines use the same Shell execution logic
2. Consistent Logging: Automatically outputs label during Shell execution
3. Integrated Error Handling: Same error handling for all Shell executions
4. Testability: Separated modules can be unit tested

8. Next Steps

→ Phase 2: 3-Level Logger System Implementation