GitHub Git Status Check Action

Overview

The actions/github/gitStatusCheck action determines whether specific files have been modified by checking git status for YAML files (.yml and .yaml). This action is useful for conditional workflow execution, allowing subsequent jobs to run only when relevant files have changed.

Language/Tool Support

Git: Git repository status checking
YAML: Focuses on YAML file changes (.yml, .yaml)
Shell Scripts: Bash-based implementation
GitHub Actions: Integration with GitHub Actions workflow logic

Features

Selective File Monitoring: Monitors only YAML files for changes
Branch-based Checking: Configurable branch for comparison
Output Generation: Provides boolean output for workflow decisions
Lightweight Execution: Fast execution with minimal resource usage
Conditional Workflows: Enables conditional job execution

Usage

- name: Check YAML File Changes
  id: yaml-check
  uses: ./actions/github/gitStatusCheck
  with:
    branch: main

- name: Run YAML Processing
  if: steps.yaml-check.outputs.shouldRun == 'true'
  run: echo "YAML files have changed, processing..."

Inputs

Input	Type	Required	Default	Description
`branch`	string	❌	`main`	Branch to compare changes against

Outputs

Output	Type	Description
`shouldRun`	boolean	Whether YAML files were modified (true/false)

Action Implementation

Script: Bash entrypoint script (entrypoint.sh)
File Types: Monitors *.yml and *.yaml files
Git Commands: Uses git status and diff commands
Environment: Uses BRANCH_NAME environment variable

Usage Examples

Conditional Workflow Execution

name: YAML File Processing
on:
  pull_request:
    branches: [main]

jobs:
  check-yaml-changes:
    runs-on: ubuntu-latest
    outputs:
      yaml-changed: ${{ steps.check.outputs.shouldRun }}
    steps:
      - uses: actions/checkout@v4

      - name: Check for YAML Changes
        id: check
        uses: ./actions/github/gitStatusCheck
        with:
          branch: main

  process-yaml:
    needs: check-yaml-changes
    if: needs.check-yaml-changes.outputs.yaml-changed == 'true'
    runs-on: ubuntu-latest
    steps:
      - name: Process YAML Files
        run: echo "Processing YAML files..."

Workflow Configuration Validation

name: Workflow Validation
on:
  pull_request:
    paths:
      - '.github/workflows/**'

jobs:
  check-workflow-changes:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Check Workflow File Changes
        id: workflow-check
        uses: ./actions/github/gitStatusCheck
        with:
          branch: ${{ github.base_ref }}

      - name: Validate Workflows
        if: steps.workflow-check.outputs.shouldRun == 'true'
        run: |
          echo "Workflow files changed, running validation..."
          # Add workflow validation logic here

Docker Compose Updates

name: Docker Compose Validation
on:
  push:
    branches: [develop, staging]

jobs:
  check-compose-changes:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Check Docker Compose Changes
        id: compose-check
        uses: ./actions/github/gitStatusCheck
        with:
          branch: main

      - name: Validate Docker Compose
        if: steps.compose-check.outputs.shouldRun == 'true'
        run: |
          echo "Docker Compose files changed"
          docker-compose config --quiet

Kubernetes Manifest Updates

name: Kubernetes Validation
on:
  pull_request:
    paths:
      - 'k8s/**'
      - 'kubernetes/**'

jobs:
  check-k8s-changes:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Check Kubernetes Manifest Changes
        id: k8s-check
        uses: ./actions/github/gitStatusCheck
        with:
          branch: ${{ github.base_ref }}

      - name: Validate Kubernetes Manifests
        if: steps.k8s-check.outputs.shouldRun == 'true'
        run: |
          echo "Kubernetes manifests changed"
          kubectl apply --dry-run=client -f k8s/

Integration Patterns

Multi-Stage Conditional Pipeline

name: Conditional Pipeline
on:
  pull_request:

jobs:
  detect-changes:
    runs-on: ubuntu-latest
    outputs:
      yaml-changed: ${{ steps.yaml.outputs.shouldRun }}
    steps:
      - uses: actions/checkout@v4

      - name: Check YAML Changes
        id: yaml
        uses: ./actions/github/gitStatusCheck

  validate-yaml:
    needs: detect-changes
    if: needs.detect-changes.outputs.yaml-changed == 'true'
    runs-on: ubuntu-latest
    steps:
      - name: Validate YAML Syntax
        run: yamllint .

  deploy-config:
    needs: [detect-changes, validate-yaml]
    if: needs.detect-changes.outputs.yaml-changed == 'true'
    runs-on: ubuntu-latest
    steps:
      - name: Deploy Configuration
        run: echo "Deploying updated configuration..."

Branch-Specific Validation

name: Branch-Specific Checks
on:
  push:
    branches: [main, develop, release/*]

jobs:
  check-changes:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Check Changes Against Main
        id: main-check
        uses: ./actions/github/gitStatusCheck
        with:
          branch: main

      - name: Production Deployment
        if: github.ref == 'refs/heads/main' && steps.main-check.outputs.shouldRun == 'true'
        run: echo "Deploying to production..."

      - name: Staging Deployment
        if: github.ref == 'refs/heads/develop' && steps.main-check.outputs.shouldRun == 'true'
        run: echo "Deploying to staging..."

Performance Optimization

name: Optimized Pipeline
on:
  pull_request:

jobs:
  quick-checks:
    runs-on: ubuntu-latest
    outputs:
      should-run-expensive: ${{ steps.check.outputs.shouldRun }}
    steps:
      - uses: actions/checkout@v4

      - name: Check for Configuration Changes
        id: check
        uses: ./actions/github/gitStatusCheck

  expensive-validation:
    needs: quick-checks
    if: needs.quick-checks.outputs.should-run-expensive == 'true'
    runs-on: ubuntu-latest
    steps:
      - name: Run Expensive Validation
        run: |
          echo "Running comprehensive validation..."
          # Resource-intensive validation only when needed

File Detection Logic

The action checks for changes in:

Included File Types

*.yml - YAML files
*.yaml - YAML files (alternative extension)

Common Use Cases

GitHub Workflows: .github/workflows/*.yml
Docker Compose: docker-compose.yml, docker-compose.yaml
Kubernetes: *.yaml, *.yml in k8s directories
Configuration: config.yml, application.yaml
CI/CD: Various pipeline configuration files

Branch Comparison

The action compares the current state against the specified branch:

Default Behavior

# Compares against main branch
uses: ./actions/github/gitStatusCheck

Custom Branch

# Compares against develop branch
uses: ./actions/github/gitStatusCheck
with:
  branch: develop

Dynamic Branch

# Compares against PR base branch
uses: ./actions/github/gitStatusCheck
with:
  branch: ${{ github.base_ref }}

Environment Configuration

The action uses environment variables:

BRANCH_NAME: Branch to compare against (from input)

Use Cases

Configuration Management

Monitor configuration file changes:

name: Config Change Detection
on:
  pull_request:
    paths:
      - 'config/**'

jobs:
  config-check:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Check Config Changes
        id: config
        uses: ./actions/github/gitStatusCheck

      - name: Validate Configuration
        if: steps.config.outputs.shouldRun == 'true'
        run: echo "Configuration changed, validating..."

Infrastructure as Code

Monitor infrastructure changes:

name: Infrastructure Validation
on:
  pull_request:
    paths:
      - 'infrastructure/**'
      - 'terraform/**'

jobs:
  infra-check:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Check Infrastructure Changes
        id: infra
        uses: ./actions/github/gitStatusCheck

      - name: Plan Infrastructure
        if: steps.infra.outputs.shouldRun == 'true'
        run: terraform plan

Deployment Automation

Conditional deployment based on changes:

name: Smart Deployment
on:
  push:
    branches: [main]

jobs:
  check-deployment-needed:
    runs-on: ubuntu-latest
    outputs:
      deploy: ${{ steps.check.outputs.shouldRun }}
    steps:
      - uses: actions/checkout@v4

      - name: Check Deployment Files
        id: check
        uses: ./actions/github/gitStatusCheck

  deploy:
    needs: check-deployment-needed
    if: needs.check-deployment-needed.outputs.deploy == 'true'
    runs-on: ubuntu-latest
    steps:
      - name: Deploy Application
        run: echo "Deploying application..."

Troubleshooting

Common Issues

Action Always Returns False

Check that YAML files actually exist in the repository
Ensure the branch comparison is correct

Action Always Returns True

Check if git history is available
Verify branch exists and is accessible
Ensure proper git configuration

Permission Issues

Ensure repository checkout is performed
Verify git commands can access repository
Check working directory is correct

Debugging

Check Git Status Manually

# Debug git status locally
git status --porcelain | grep -E '\.(yml|yaml)$'
git diff --name-only origin/main | grep -E '\.(yml|yaml)$'

Verify Branch Existence

# Check if branch exists
git branch -r | grep origin/main

Test File Detection

# Test file pattern matching
find . -name "*.yml" -o -name "*.yaml"

Performance Considerations

Execution Time

Fast: Minimal git operations
Lightweight: Simple shell script execution
Efficient: Early termination when files found

Resource Usage

Low Memory: Minimal memory footprint
Quick I/O: Limited file system operations
Network: No external network calls

Optimization Tips

Place Early: Run early in workflow for maximum benefit
Combine Checks: Use outputs in multiple subsequent jobs

Best Practices

Workflow Design

Early Execution: Run checks early in the workflow
Output Reuse: Share outputs between multiple jobs
Clear Naming: Use descriptive step IDs and names
Documentation: Document conditional logic clearly

Branch Strategy

Consistent Branches: Use consistent branch names for comparison
Dynamic References: Use dynamic branch references in PRs
Default Branches: Align with repository default branch

Migration Guide

From Path Filters

Replace workflow path filters with dynamic checks:

# Before: Static path filtering
on:
  pull_request:
    paths:
      - '*.yml'
      - '*.yaml'

# After: Dynamic checking
on:
  pull_request:

jobs:
  check:
    steps:
      - uses: ./actions/github/gitStatusCheck
        id: yaml-check
      - if: steps.yaml-check.outputs.shouldRun == 'true'
        run: echo "Process YAML files"

From Manual Git Commands

Replace manual git status checks:

# Before: Manual git commands
- name: Check Changes
  run: |
    if git diff --name-only origin/main | grep -E '\.(yml|yaml)$'; then
      echo "yaml_changed=true" >> $GITHUB_OUTPUT
    fi

# After: Use action
- name: Check Changes
  id: check
  uses: ./actions/github/gitStatusCheck