Dezvoltarea Microserviciilor Asincrone de Mare Viteză cu Ktor Server și Kotlin Coroutines în Kotlin

# Arhitectura Fluxului de Cereri Ktor:
# [Client HTTP Request]
#        │
#        ▼
# [Netty EventLoop Engine] (I/O non-blocant bazat pe epoll/kqueue)
#        │
#        ▼
# [ApplicationCall Pipeline]
#    ├── Routing Plugin: Mapare URL către handler corutină
#    ├── ContentNegotiation: Deserializare JSON automată (kotlinx.serialization)
#    ├── CallLogging: Logare structurată cu corelare de cereri (MDC traceId)
#    └── StatusPages: Interceptare globală excepții și transformare în coduri HTTP RFC 7807
#        │
#        ▼
# [Suspendable Route Handler] (Rulează pe corutină ușoară, fără a bloca thread-ul Netty!)

package ro.dexblog.orders

import io.ktor.http.*
import io.ktor.serialization.kotlinx.json.*
import io.ktor.server.application.*
import io.ktor.server.engine.*
import io.ktor.server.netty.*
import io.ktor.server.plugins.calllogging.*
import io.ktor.server.plugins.contentnegotiation.*
import io.ktor.server.plugins.statuspages.*
import io.ktor.server.request.*
import io.ktor.server.response.*
import io.ktor.server.routing.*
import kotlinx.coroutines.delay
import kotlinx.coroutines.flow.flow
import kotlinx.serialization.Serializable
import kotlinx.serialization.json.Json
import org.slf4j.event.Level
import java.util.UUID

@Serializable
data class OrderRequest(val customerId: String, val amount: Double, val items: List)

@Serializable
data class OrderResponse(val orderId: String, val status: String, val timestamp: Long)

@Serializable
data class ErrorDetails(val status: Int, val message: String, val code: String)

fun main() {
    embeddedServer(Netty, port = 8080, host = "0.0.0.0") {
        configurePlugins()
        configureRouting()
    }.start(wait = true)
}

fun Application.configurePlugins() {
    // 1. Negocierea Conținutului JSON cu kotlinx.serialization
    install(ContentNegotiation) {
        json(Json {
            prettyPrint = false
            isLenient = true
            ignoreUnknownKeys = true
        })
    }

    // 2. Logare detaliată a fiecărei cereri
    install(CallLogging) {
        level = Level.INFO
        filter { call -> call.request.path().startsWith("/api") }
    }

    // 3. StatusPages: Gestionare centralizată a erorilor
    install(StatusPages) {
        exception { call, cause ->
            call.respond(
                HttpStatusCode.BadRequest,
                ErrorDetails(HttpStatusCode.BadRequest.value, cause.message ?: "Date invalide", "INVALID_INPUT")
            )
        }
        exception { call, cause ->
            call.application.environment.log.error("Eroare neprevăzută de sistem", cause)
            call.respond(
                HttpStatusCode.InternalServerError,
                ErrorDetails(500, "A apărut o eroare internă de procesare.", "INTERNAL_ERROR")
            )
        }
    }
}

fun Application.configureRouting() {
    routing {
        route("/api/v1/orders") {
            // Endpoint asincron de creare comandă
            post {
                val req = call.receive()
                require(req.amount > 0) { "Valoarea comenzii trebuie să fie pozitivă!" }
                require(req.items.isNotEmpty()) { "Comanda trebuie să conțină cel puțin un produs!" }

                // Simulare persistență asincronă non-blocantă
                delay(15)

                val response = OrderResponse(
                    orderId = UUID.randomUUID().toString(),
                    status = "ACCEPTED",
                    timestamp = System.currentTimeMillis()
                )
                call.respond(HttpStatusCode.Created, response)
            }

            // Endpoint de streaming de date în timp real prin Server-Sent Events / Flow
            get("/stream") {
                val eventsFlow = flow {
                    for (i in 1..5) {
                        delay(200) // Emitere asincronă la fiecare 200ms
                        emit("Eveniment comanda #$i: generat la ${System.currentTimeMillis()}\n")
                    }
                }
                call.respondTextWriter(ContentType.Text.Plain) {
                    eventsFlow.collect { event ->
                        write(event)
                        flush()
                    }
                }
            }
        }

        // Endpoint de Health Check pentru Kubernetes Liveness / Readiness Probes
        get("/health") {
            call.respond(HttpStatusCode.OK, mapOf("status" to "UP", "engine" to "Ktor-Netty-3.0"))
        }
    }
}

# Etapa 1: Build cu Gradle
FROM gradle:8.7-jdk21-alpine AS builder
WORKDIR /app
COPY build.gradle.kts settings.gradle.kts ./
COPY src ./src
RUN gradle build --no-daemon -x test

# Etapa 2: Imagine Distroless ultra-securizată și minimală
FROM gcr.io/distroless/java21-debian12:nonroot
WORKDIR /app
COPY --from=builder /app/build/libs/*-all.jar app.jar

EXPOSE 8080
USER nonroot:nonroot

# Lansare directă cu tuning de containere
ENTRYPOINT ["java", "-XX:MaxRAMPercentage=75.0", "-XX:+UseZGC", "-XX:+ZGenerational", "-jar", "app.jar"]