Kotlinスクリプトを使ったCI/CDパイプライン設定の完全ガイド

plugins {
    kotlin("jvm") version "1.8.0"
}

dependencies {
    implementation(kotlin("stdlib"))
}

println("Initializing CI/CD pipeline...")

fun build() {
    println("Building project...")
    // ビルド処理
}

fun test() {
    println("Running tests...")
    // テスト処理
}

fun deploy() {
    println("Deploying application...")
    // デプロイ処理
}

fun main() {
    build()
    test()
    deploy()
}

main()

kotlinc -script pipeline.kts

pipeline {
    stages {
        stage("Build") {
            steps {
                println("Building project...")
                sh("gradle build")
            }
        }
        stage("Test") {
            steps {
                println("Running tests...")
                sh("gradle test")
            }
        }
        stage("Deploy") {
            steps {
                println("Deploying application...")
                sh("gradle deploy")
            }
        }
    }
}

name: Kotlin CI/CD Pipeline

on:
  push:
    branches:
      - main

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout code
        uses: actions/checkout@v3
      - name: Set up Kotlin
        uses: actions/setup-java@v3
        with:
          distribution: 'zulu'
          java-version: '11'
      - name: Build project
        run: |
          kotlinc -script pipeline.kts
      - name: Run tests
        run: |
          ./gradlew test
      - name: Deploy application
        run: |
          ./gradlew deploy

fun deploy(environment: String) {
    println("Deploying application to $environment environment...")
    when (environment) {
        "staging" -> {
            // ステージング環境へのデプロイ処理
            println("Deploying to Staging Server...")
            // 例: SSHコマンドを実行
            executeCommand("ssh user@staging-server 'docker-compose up -d'")
        }
        "production" -> {
            // 本番環境へのデプロイ処理
            println("Deploying to Production Server...")
            executeCommand("ssh user@production-server 'docker-compose up -d'")
        }
        else -> {
            println("Unknown environment: $environment")
        }
    }
}

fun executeCommand(command: String) {
    val process = Runtime.getRuntime().exec(command)
    process.inputStream.bufferedReader().use { it.lines().forEach(::println) }
    process.waitFor()
}

val environment = System.getenv("DEPLOY_ENV") ?: "staging"
deploy(environment)

deploy("staging")

deploy("production")

DEPLOY_ENV=production kotlinc -script deploy.kts

fun deployToKubernetes() {
    println("Deploying to Kubernetes cluster...")
    executeCommand("kubectl apply -f deployment.yaml")
}
deployToKubernetes()

dependencies {
    testImplementation("org.jetbrains.kotlin:kotlin-test")
    testImplementation("org.jetbrains.kotlin:kotlin-test-junit")
}

import kotlin.test.*

fun add(a: Int, b: Int): Int = a + b

@Test
fun testAdd() {
    assertEquals(5, add(2, 3), "2 + 3 should equal 5")
}

@Test
fun testAddNegative() {
    assertEquals(-1, add(-3, 2), "-3 + 2 should equal -1")
}

./gradlew test

import kotlin.test.*

fun multiply(a: Int, b: Int): Int = a * b

@Test
fun testMultiply() {
    listOf(
        Pair(2, 3) to 6,
        Pair(-1, 5) to -5,
        Pair(0, 7) to 0
    ).forEach { (input, expected) ->
        val (a, b) = input
        assertEquals(expected, multiply(a, b), "Multiplication test failed for $a and $b")
    }
}

import io.mockk.*

class Service {
    fun fetchData(): String = "real data"
}

@Test
fun testFetchData() {
    val service = mockk<Service>()
    every { service.fetchData() } returns "mocked data"

    assertEquals("mocked data", service.fetchData())
}

fun executeCommand(command: String) {
    try {
        println("Executing command: $command")
        val process = Runtime.getRuntime().exec(command)
        process.inputStream.bufferedReader().use { it.lines().forEach(::println) }
        process.waitFor()
        if (process.exitValue() != 0) {
            throw RuntimeException("Command failed with exit code ${process.exitValue()}")
        }
    } catch (e: Exception) {
        println("Error occurred: ${e.message}")
    }
}

class DeploymentException(message: String) : Exception(message)

fun deploy(environment: String) {
    if (environment.isBlank()) {
        throw DeploymentException("Environment must not be blank")
    }
    println("Deploying to $environment environment...")
}

fun log(message: String) {
    println("[DEBUG] $message")
}

log("Starting deployment process")
deploy("staging")
log("Deployment completed successfully")

val isDebugMode = System.getenv("DEBUG_MODE")?.toBoolean() ?: false

fun logDebug(message: String) {
    if (isDebugMode) {
        println("[DEBUG] $message")
    }
}

fun notifyError(message: String) {
    println("Sending error notification: $message")
    // Slack APIやメール送信コードを実装
}

try {
    deploy("production")
} catch (e: DeploymentException) {
    notifyError("Deployment failed: ${e.message}")
}

fun rollback() {
    println("Rolling back to the previous stable state...")
    executeCommand("ssh user@production-server 'docker-compose down && docker-compose up -d previous-version'")
}

try {
    deploy("production")
} catch (e: Exception) {
    println("Deployment failed: ${e.message}")
    rollback()
}

{
  "development": {
    "host": "dev-server",
    "user": "dev-user",
    "branch": "develop"
  },
  "staging": {
    "host": "staging-server",
    "user": "staging-user",
    "branch": "release"
  },
  "production": {
    "host": "prod-server",
    "user": "prod-user",
    "branch": "main"
  }
}

import java.io.File
import kotlinx.serialization.*
import kotlinx.serialization.json.*

@Serializable
data class EnvironmentConfig(val host: String, val user: String, val branch: String)

fun loadConfig(environment: String): EnvironmentConfig {
    val json = File("environments.json").readText()
    val configs = Json.decodeFromString<Map<String, EnvironmentConfig>>(json)
    return configs[environment] ?: throw IllegalArgumentException("Unknown environment: $environment")
}

fun deploy(environment: String) {
    val config = loadConfig(environment)
    println("Deploying to ${config.host} as ${config.user} on branch ${config.branch}...")
    executeCommand("ssh ${config.user}@${config.host} 'git checkout ${config.branch} && ./deploy.sh'")
}

fun main() {
    val environment = System.getenv("DEPLOY_ENV") ?: "development"
    try {
        deploy(environment)
    } catch (e: Exception) {
        println("Deployment failed: ${e.message}")
    }
}

fun postDeployTasks(environment: String) {
    when (environment) {
        "staging" -> println("Enabling monitoring tools for staging...")
        "production" -> println("Starting traffic monitoring for production...")
        else -> println("No post-deploy tasks for $environment.")
    }
}

fun main() {
    val environment = System.getenv("DEPLOY_ENV") ?: "development"
    try {
        deploy(environment)
        postDeployTasks(environment)
    } catch (e: Exception) {
        println("Deployment failed: ${e.message}")
    }
}

fun deployToKubernetes(environment: String) {
    val namespace = when (environment) {
        "development" -> "dev-namespace"
        "staging" -> "staging-namespace"
        "production" -> "prod-namespace"
        else -> throw IllegalArgumentException("Unknown environment: $environment")
    }
    executeCommand("kubectl apply -f deployment.yaml -n $namespace")
}