Graceful shutdown with Structured Concurrency 47deg.com 

Who am I? 

Graceful shutdown with Structured Concurrency Problem Resources Structured Concurrency Example 

Resources DataSource Application File Handle Socket Handle 

Microservice Scaling Demand Time 

Microservice Staged Rollouts Service A Client 1.0 1.0 1.1 1.1 

Microservice Scaling Microservice Staged Rollouts Graceful Shutdown 

Closeable class MyServer : AutoCloseable { init { println("Initialising server") } fun routes(): Unit = println("Handling incoming requests") override fun close() = println("Closing server") } 

Closeable fun main(): Unit { MyServer().use { it.routes() } } Initialising server Handling incoming requests Closing server Process finished with exit code 0 

Closeable fun main(): Unit = runBlocking { MyServer().use { it.routes() awaitCancellation() } } Initialising server Handling incoming requests Process finished with exit code 143 (interrupted by signal 15: SIGTERM) 

Termination Signals SIGTERM SIGINT SIGKILL 

Structured Concurrency Structured Concurrency Parent Job Child Job A Child Job B Child Job A-1 Child Job A-2 Successful completion Cancellation Failure 

Structured Concurrency Dependency Graph main Database MetricRegistry Server Event Processor … 

SuspendApp Structured Concurrency pattern for Resource safety Multiplatform Library Only depends on KotlinX Coroutines 

SuspendApp fun main(): Unit = SuspendApp { MyServer().use { it.routes() awaitCancellation() } } Initialising server Handling incoming requests Closing Server Process finished with exit code 143 (interrupted by signal 15: SIGTERM) 

Closeable Missing support for Kotlin Multiplatform No support for suspend Structured Concurrency ExitCase indication 

Resource sealed class Resource public fun Resource( acquire: suspend () -> A, release: suspend (A, ExitCase) -> Unit, ): Resource 

Resource - ExitCase Successful completion Cancellation Failure 

Resource sealed class ExitCase { object Completed : ExitCase() data class Cancelled(val exception: CancellationException) : ExitCase() data class Failure(val failure: Throwable) : ExitCase() } 

Resource data class Resource( private val acquire: suspend () -> A, private val finalizer: suspend (ExitCase, A) -> Unit ) { suspend fun use(action: suspend (A) -> B): A = … } 

Resource class MyServer private constructor() { fun routes(): Unit = println("Handling incoming requests") suspend fun shutdown(exitCase: ExitCase) = withContext(Dispatchers.IO){ println("Shutting down server with $exitCase") } companion object { fun create(): Resource = Resource( { MyServer().also { println("Initialising server") } }, { server, exitCase -> server.shutdown(exitCase) } ) } } 

Resource fun main(): Unit = SuspendApp { MyServer.create().use { it.routes() awaitCancellation() } } Initialising server Handling incoming requests Shutting down server with Cancelled(exception=JobCancellationException:--.) Process finished with exit code 143 (interrupted by signal 15: SIGTERM) 

Structurred Concurrency Dependency Graph main Database MetricRegistry Server Event Processor … 

Composing Resource fun database(config: HikariConfig): Resource = Resource.fromAutoCloseable { HikariDataSource(config) } private val metrics: Resource = Resource( acquire = { PrometheusMeterRegistry(PrometheusConfig.DEFAULT) }, release = { p, _: ExitCase -> p.close() } ) 

Composing Resource fun main(): Unit = SuspendApp { resource { val config = loadConfig() val registry: PrometheusMeterRegistry = metrics.bind() val database: HikariDataSource = database(config.hikariConfig).bind() } } 

Composing Resource fun main(): Unit = SuspendApp { resource { val config = loadConfig() val registry: PrometheusMeterRegistry = metrics.bind() val database: HikariDataSource = database(config.hikariConfig).bind() val server = MyServer.create().bind() server.routes(registry, database) }.use { awaitCancellation() } } 

ResourceScope suspend fun ResourceScope.database(config: HikariConfig): HikariDataSource = autoCloseable { HikariDataSource(config) } suspend fun ResourceScope.metrics(): PrometheusMeterRegistry = install({ PrometheusMeterRegistry(PrometheusConfig.DEFAULT) }) { p, _: ExitCase -> p.close() } 

ResourceScope fun main(): Unit = SuspendApp { resource { val config = loadConfig() val registry = metrics() val database = database(config.hikariConfig) val server = MyServer.create() server.routes(registry, database) }.use { awaitCancellation() } } 

ResourceScope fun main(): Unit = SuspendApp { resourceScope { val config = loadConfig() val registry = metrics() val database = database(config.hikariConfig) val server = MyServer.create() server.routes(registry, database) awaitCancellation() } } 

Production Example 

Resource offers type-safe DSL SuspendApp Structured Concurrency for Resource & Closeable Conclusion 

Thanks!