freeleaps-ops/first-class-pipeline/vars/pipelineCall.groovy

#!groovy

import com.freeleaps.devops.EnvironmentVars
import com.freeleaps.devops.SourceFetcher
import com.freeleaps.devops.DependenciesResolver
import com.freeleaps.devops.enums.DependenciesManager

def call(configurations) {
  def configurationMap = [:]
  configurations.resolveStrategy = Closure.DELEGATE_FIRST
  configurations.delegate = configurationMap
  configurations()

  def environmentVars = new EnvironmentVars(this)

  pipeline {
    agent any
    options {
      buildDiscarder(logRotator(numToKeepStr: '25'))
      timeout(time: 30, unit: 'MINUTES')
    }

    stages {

      stage("Source Codes Checkout") {
        steps {
          script {
            def sourceFetcher = new SourceFetcher(this)
            sourceFetcher.fetch(configurationMap)
          }
        }
      }

      stage("Prepared Environment Variables") {
        steps {
          script {
            environmentVars.injectVars(configurationMap)
          }
        }
      }

      stage("Commit Linting If Enabled") {
        steps {
          script {
            def enabled = configurations.COMMIT_MESSAGE_LINT_ENABLED
            
            if (enabled != null && enabled == "true") {
              print("Commit Linting is enabled")
            }
          }
        }
      }

      stage("Build Agent Setup") {
        steps {
          script {
            def buildAgentImage = configurationMap.BUILD_AGENT_IMAGE
            if (buildAgentImage != null && !buildAgentImage.isEmpty()) {
              echo "Not set BUILD_AGENT_IMAGE, using default build agent image"

              def language = env.SERVICE_LANG
              switch(language) {
                case PYTHON:
                  buildAgentImage = "python:3.10-slim-buster"
                case NODE:
                  buildAgentImage = "node:lts-alpine"
                default:
                  error("Unknown service language")
              }

              env.BUILD_AGENT_IMAGE = buildAgentImage
            }
          }
        }
      }

      stage("Dependencies Resolving") {
        agent {
          kubernetes {
            defaultContainer 'dep-resolver'
            yaml """
apiVersion: v1
kind: Pod
metadata:
  labels:
    freeleaps-devops-system/stage: dependencies-resolving
spec:
  containers:
  - name: dep-resolver
    image: ${env.BUILD_AGENT_IMAGE}
    command:
    - cat
    tty: true
    volumeMounts:
    - name: workspace
      mountPath: /workspace
  volumes:
    - name: workspace
      emptyDir: {} 
"""
          }
        }
        steps {
          script {
            def language = env.SERVICE_LANG

            def depManager = DependenciesManager.parse(configurationMap.DEPENDENCIES_MANAGER)
            if (depManager == DependenciesManager.UNKNOWN) {
              error("Unknown dependencies manager")
            }

            def dependenciesResolver = new DependenciesResolver(this, language)
            dependenciesResolver.useManager(depManager)
            
            if (configurationMap.BUILD_CACHE_ENABLED == "true") {
              dependenciesResolver.enableCachingSupport()
            } else {
              dependenciesResolver.disableCachingSupport()
            }

            dependenciesResolver.resolve(configurationMap)
          }
        }
      }

    }
  }
}