Kotlin DSLでGradleタスクのリトライロジックを実装する方法を徹底解説

tasks.register("hello") {
    doLast {
        println("Hello, Kotlin DSL!")
    }
}

val maxRetries = 3

val retryInterval = 2000L // 2秒

val retryableErrors = listOf("TimeoutException", "IOException")

tasks.register("retryableTask") {
    doLast {
        var attempt = 0
        val maxRetries = 3
        val retryInterval = 2000L

        while (attempt < maxRetries) {
            try {
                // 実行するタスクロジック
                println("Executing task. Attempt: ${attempt + 1}")
                if (Math.random() > 0.7) {
                    throw RuntimeException("Simulated error")
                }
                println("Task succeeded")
                break
            } catch (e: Exception) {
                attempt++
                if (attempt >= maxRetries) {
                    println("Task failed after $maxRetries attempts: ${e.message}")
                    throw e
                } else {
                    println("Retrying in ${retryInterval / 1000} seconds...")
                    Thread.sleep(retryInterval)
                }
            }
        }
    }
}

tasks.named("existingTask").configure {
    doLast {
        var attempt = 0
        val maxRetries = 3

        while (attempt < maxRetries) {
            try {
                // 既存タスクの処理を呼び出し
                println("Running existing task. Attempt: ${attempt + 1}")
                // タスクが成功した場合
                break
            } catch (e: Exception) {
                attempt++
                if (attempt >= maxRetries) {
                    println("Task failed after $maxRetries attempts")
                    throw e
                }
                println("Retrying...")
            }
        }
    }
}

tasks.register("retryTask") {
    doLast {
        val maxRetries = 3
        val retryInterval = 2000L
        var attempt = 0

        while (attempt < maxRetries) {
            try {
                // タスクロジック
                println("Attempt ${attempt + 1}: Running task")
                if (Math.random() > 0.7) {
                    throw RuntimeException("Simulated error")
                }
                println("Task succeeded")
                return
            } catch (e: Exception) {
                attempt++
                if (attempt >= maxRetries) {
                    println("Task failed after $maxRetries attempts: ${e.message}")
                    throw e
                } else {
                    println("Retrying in ${retryInterval / 1000} seconds...")
                    Thread.sleep(retryInterval)
                }
            }
        }
    }
}

fun retryableTask(action: () -> Unit, maxRetries: Int = 3, retryInterval: Long = 2000L) {
    var attempt = 0
    while (attempt < maxRetries) {
        try {
            action()
            return
        } catch (e: Exception) {
            attempt++
            if (attempt >= maxRetries) {
                println("Task failed after $maxRetries attempts: ${e.message}")
                throw e
            } else {
                println("Retrying in ${retryInterval / 1000} seconds...")
                Thread.sleep(retryInterval)
            }
        }
    }
}

tasks.register("customTask") {
    doLast {
        retryableTask {
            // タスクロジック
            println("Executing custom task")
            if (Math.random() > 0.7) {
                throw RuntimeException("Simulated error")
            }
            println("Custom task succeeded")
        }
    }
}

val maxRetries = project.findProperty("maxRetries")?.toString()?.toInt() ?: 3
val retryInterval = project.findProperty("retryInterval")?.toString()?.toLong() ?: 2000L

tasks.register("flexibleRetryTask") {
    doLast {
        retryableTask(maxRetries = maxRetries, retryInterval = retryInterval) {
            println("Executing flexible retry task")
            if (Math.random() > 0.7) {
                throw RuntimeException("Simulated error")
            }
            println("Flexible retry task succeeded")
        }
    }
}

println("[Retry Task] Attempt ${attempt + 1} of $maxRetries")

tasks.register("testRetryLogic") {
    doLast {
        retryableTask(maxRetries = 3, retryInterval = 1000L) {
            if (Math.random() > 0.5) {
                throw RuntimeException("Simulated error for testing")
            }
            println("Test succeeded")
        }
    }
}

println("[Retry Task] Attempt ${attempt + 1} of $maxRetries")
println("[Retry Task] Encountered error: ${e.message}")

tasks.register("mockErrorTask") {
    doLast {
        retryableTask {
            println("Executing task")
            throw RuntimeException("Mocked error")
        }
    }
}

class RetryLogicTest {
    @Test
    fun `test retry logic succeeds`() {
        var attempt = 0
        retryableTask(maxRetries = 3) {
            attempt++
            if (attempt < 2) {
                throw RuntimeException("Simulated error")
            }
        }
        assertEquals(2, attempt)
    }

    @Test(expected = RuntimeException::class)
    fun `test retry logic fails`() {
        retryableTask(maxRetries = 3) {
            throw RuntimeException("Always fail")
        }
    }
}

tasks.register("fetchDependencies") {
    doLast {
        retryableTask(maxRetries = 3, retryInterval = 3000L) {
            println("Fetching dependencies...")
            // リモートサーバーへのリクエスト（例として例外をスロー）
            if (Math.random() > 0.5) {
                throw RuntimeException("Network error")
            }
            println("Dependencies fetched successfully")
        }
    }
}

tasks.register("callExternalApi") {
    doLast {
        retryableTask(maxRetries = 5, retryInterval = 1000L) {
            println("Calling external API...")
            // 模擬的なAPIエラーをスロー
            if (Math.random() > 0.6) {
                throw RuntimeException("API Timeout")
            }
            println("API call succeeded")
        }
    }
}

tasks.register("runIntegrationTests") {
    doLast {
        retryableTask(maxRetries = 2, retryInterval = 5000L) {
            println("Running integration tests...")
            // 模擬的なテストエラーをスロー
            if (Math.random() > 0.4) {
                throw RuntimeException("Test error")
            }
            println("Integration tests passed")
        }
    }
}

tasks.register("checkDatabaseConnection") {
    doLast {
        retryableTask(maxRetries = 3, retryInterval = 2000L) {
            println("Checking database connection...")
            // 模擬的な接続エラーをスロー
            if (Math.random() > 0.7) {
                throw RuntimeException("Database connection failed")
            }
            println("Database connection successful")
        }
    }
}

val maxRetries = project.findProperty("maxRetries")?.toString()?.toInt() ?: 5
val retryInterval = project.findProperty("retryInterval")?.toString()?.toLong() ?: 2000L

println("[Task Log] Attempt $attempt: ${if (success) "Succeeded" else "Failed"}")

val retryableErrors = listOf("TimeoutException", "IOException")

fun retryableTask(action: () -> Unit, maxRetries: Int = 3, retryInterval: Long = 2000L) {
    var attempt = 0
    while (attempt < maxRetries) {
        try {
            action()
            return
        } catch (e: Exception) {
            if (++attempt >= maxRetries) throw e
            Thread.sleep(retryInterval)
        }
    }
}