tessl/maven-io-ktor--ktor-server-core-iosarm64

Ktor server core module for iOS ARM64 target providing essential server-side functionality for building asynchronous web applications and microservices in Kotlin Multiplatform

—

Pending

Overview

Eval results

Files

Server Engines and Embedded Servers

Name: tessl/maven-io-ktor--ktor-server-core-iosarm64
Author: tessl

Application engine abstraction and embedded server functionality for hosting Ktor applications. Provides pluggable server engines with unified configuration and lifecycle management.

Capabilities

Application Engine Interface

Core interface for all server engines that can host Ktor applications.

/**
 * An engine which runs an application
 */
interface ApplicationEngine {
    /** Application environment configuration */
    val environment: ApplicationEnvironment
    
    /** Get resolved connector configurations for this engine */
    suspend fun resolvedConnectors(): List<EngineConnectorConfig>
    
    /** Start the engine, optionally wait for completion */
    fun start(wait: Boolean = false): ApplicationEngine
    
    /** Start the engine in suspending fashion */
    suspend fun startSuspend(wait: Boolean = false): ApplicationEngine
    
    /** Stop the engine with configurable grace and timeout periods */
    fun stop(gracePeriodMillis: Long = 500, timeoutMillis: Long = 500)
}

Engine Configuration

Configuration classes for customizing engine behavior and performance characteristics.

/**
 * Configuration for ApplicationEngine instances
 */
open class ApplicationEngine.Configuration {
    /** Number of parallel processing threads */
    val parallelism: Int
    
    /** Size of connection group thread pool */
    var connectionGroupSize: Int
    
    /** Size of worker group thread pool */  
    var workerGroupSize: Int
    
    /** Size of call processing thread pool */
    var callGroupSize: Int
    
    /** Grace period for shutdown in milliseconds */
    var shutdownGracePeriod: Long
    
    /** Timeout for shutdown in milliseconds */
    var shutdownTimeout: Long
    
    /** List of connector configurations */
    var connectors: MutableList<EngineConnectorConfig>
}

Base Engine Implementation

Abstract base class providing common engine functionality.

/**
 * Base class for implementing ApplicationEngine
 */
abstract class BaseApplicationEngine : ApplicationEngine {
    /** Application environment */
    val environment: ApplicationEnvironment
    
    /** Engine-specific processing pipeline */
    val pipeline: EnginePipeline
    
    /** Monitor for engine events */
    val monitor: Events
    
    /** Application instance hosted by this engine */
    val application: Application
}

Embedded Server

High-level embedded server functionality for easy application hosting.

/**
 * Represents an embedded server that hosts an application
 */
class EmbeddedServer<TEngine : ApplicationEngine, TConfiguration : ApplicationEngine.Configuration> {
    /** Event monitor for server lifecycle events */
    val monitor: Events
    
    /** Application environment */
    val environment: ApplicationEnvironment
    
    /** Hosted application instance */
    val application: Application
    
    /** Underlying engine instance */
    val engine: TEngine
}

Engine Factory Interface

Factory interface for creating ApplicationEngine instances with specific configurations.

/**
 * Factory interface for creating ApplicationEngine instances
 */
interface ApplicationEngineFactory<TEngine : ApplicationEngine, TConfiguration : ApplicationEngine.Configuration> {
    /** Create configuration instance */
    fun configuration(configure: TConfiguration.() -> Unit = {}): TConfiguration
    
    /** Create engine instance */
    fun create(
        environment: ApplicationEnvironment,
        monitor: Events,
        developmentMode: Boolean,
        configuration: TConfiguration,
        applicationProvider: () -> Application
    ): TEngine
}

Embedded Server Factory Functions

Factory functions for creating embedded server instances with various configuration options.

/**
 * Create embedded server with basic configuration
 */
fun <TEngine : ApplicationEngine, TConfiguration : ApplicationEngine.Configuration> 
embeddedServer(
    factory: ApplicationEngineFactory<TEngine, TConfiguration>,
    port: Int = 80,
    host: String = "0.0.0.0",
    watchPaths: List<String> = emptyList(),
    configure: TConfiguration.() -> Unit = {},
    module: Application.() -> Unit
): EmbeddedServer<TEngine, TConfiguration>

/**
 * Create embedded server with connector configuration
 */
fun <TEngine : ApplicationEngine, TConfiguration : ApplicationEngine.Configuration>
embeddedServer(
    factory: ApplicationEngineFactory<TEngine, TConfiguration>,
    connectors: List<EngineConnectorConfig>,
    watchPaths: List<String> = emptyList(),
    parentCoroutineContext: CoroutineContext = EmptyCoroutineContext,
    configure: TConfiguration.() -> Unit = {},
    module: Application.() -> Unit = {}
): EmbeddedServer<TEngine, TConfiguration>

/**
 * Create embedded server with custom environment
 */
fun <TEngine : ApplicationEngine, TConfiguration : ApplicationEngine.Configuration>
embeddedServer(
    factory: ApplicationEngineFactory<TEngine, TConfiguration>,
    environment: ApplicationEnvironment,
    configure: TConfiguration.() -> Unit = {},
    module: Application.() -> Unit = {}
): EmbeddedServer<TEngine, TConfiguration>

/**
 * Create embedded server with ServerConfig
 */
fun <TEngine : ApplicationEngine, TConfiguration : ApplicationEngine.Configuration>
embeddedServer(
    factory: ApplicationEngineFactory<TEngine, TConfiguration>,
    rootConfig: ServerConfig,
    configure: TConfiguration.() -> Unit = {}
): EmbeddedServer<TEngine, TConfiguration>

Usage Examples

Basic Embedded Server

import io.ktor.server.application.*
import io.ktor.server.engine.*
import io.ktor.server.response.*
import io.ktor.server.routing.*

fun main() {
    embeddedServer(Netty, port = 8080, host = "0.0.0.0") {
        routing {
            get("/") {
                call.respondText("Hello, World!")
            }
        }
    }.start(wait = true)
}

Embedded Server with Custom Configuration

import io.ktor.server.application.*
import io.ktor.server.engine.*
import io.ktor.server.netty.*

fun main() {
    embeddedServer(Netty, port = 8080) {
        // Engine-specific configuration
        connectionGroupSize = 2
        workerGroupSize = 5
        callGroupSize = 10
        shutdownGracePeriod = 2000
        shutdownTimeout = 5000
        
        // Application configuration
    }.apply {
        // Configure application modules
        application.module {
            configureRouting()
            configurePlugins()
        }
    }.start(wait = true)
}

fun Application.configureRouting() {
    routing {
        get("/health") {
            call.respondText("OK")
        }
    }
}

fun Application.configurePlugins() {
    install(CallLogging)
}

Multiple Connectors

import io.ktor.server.application.*
import io.ktor.server.engine.*

fun main() {
    val httpConnector = EngineConnectorBuilder().apply {
        port = 8080
        host = "0.0.0.0"
    }
    
    val httpsConnector = EngineConnectorBuilder().apply {
        port = 8443
        host = "0.0.0.0"
        // SSL configuration would go here
    }
    
    embeddedServer(
        factory = Netty,
        connectors = listOf(httpConnector, httpsConnector)
    ) {
        routing {
            get("/") {
                call.respondText("Available on both HTTP and HTTPS")
            }
        }
    }.start(wait = true)
}

Custom Environment and Configuration

import io.ktor.server.application.*
import io.ktor.server.config.*
import io.ktor.server.engine.*

fun main() {
    // Create custom configuration
    val config = MapApplicationConfig().apply {
        put("app.name", "MyKtorApp")
        put("app.version", "1.0.0")
        put("server.features.compression", "true")
        put("database.url", "jdbc:postgresql://localhost/myapp")
    }
    
    // Create custom environment
    val environment = createApplicationEnvironment {
        this.config = config
        this.log = LoggerFactory.getLogger("MyKtorApp")
    }
    
    embeddedServer(Netty, environment = environment) {
        // Configure based on custom environment
        val appName = environment.config.property("app.name").getString()
        val version = environment.config.property("app.version").getString()
        
        routing {
            get("/info") {
                call.respondText("$appName v$version")
            }
        }
    }.start(wait = true)
}

Development Server with Auto-Reload

import io.ktor.server.application.*
import io.ktor.server.engine.*

fun main() {
    embeddedServer(
        factory = Netty,
        port = 8080,
        host = "0.0.0.0",
        watchPaths = listOf("classes", "resources"), // Auto-reload on changes
        configure = {
            // Development-specific engine settings
            connectionGroupSize = 1
            workerGroupSize = 1
            callGroupSize = 1
        }
    ) {
        configureForDevelopment()
    }.start(wait = true)
}

fun Application.configureForDevelopment() {
    // Development mode enables additional features
    val isDevelopment = environment.developmentMode
    
    if (isDevelopment) {
        install(CallLogging) {
            level = Level.DEBUG
        }
        
        install(CORS) {
            allowMethod(HttpMethod.Options)
            allowMethod(HttpMethod.Put)
            allowMethod(HttpMethod.Delete)
            allowMethod(HttpMethod.Patch)
            allowHeader(HttpHeaders.Authorization)
            allowCredentials = true
            anyHost() // Don't do this in production!
        }
    }
    
    routing {
        get("/dev-info") {
            if (isDevelopment) {
                call.respond(mapOf(
                    "development" to true,
                    "autoReload" to true,
                    "javaVersion" to System.getProperty("java.version")
                ))
            } else {
                call.respond(HttpStatusCode.NotFound)
            }
        }
    }
}

Server Configuration with ServerConfig

import io.ktor.server.application.*
import io.ktor.server.engine.*

fun main() {
    val serverConfig = serverConfig {
        developmentMode = false
        rootPath = "/api/v1" 
        
        // Configure application modules
        module {
            configureAuthentication()
            configureRouting()
            configurePlugins()
        }
        
        module {
            configureDatabase()
        }
        
        // Watch paths for development
        watchPaths = listOf("build/classes")
    }
    
    embeddedServer(Netty, rootConfig = serverConfig) {
        // Additional engine configuration
        shutdownGracePeriod = 3000
        shutdownTimeout = 10000
    }.start(wait = true)
}

fun Application.configureAuthentication() {
    install(Authentication) {
        jwt("auth-jwt") {
            realm = "ktor app"
            verifier(makeJwtVerifier())
            validate { credential ->
                if (credential.payload.getClaim("username").asString() != "") {
                    JWTPrincipal(credential.payload)
                } else {
                    null
                }
            }
        }
    }
}

Graceful Shutdown Handling

import io.ktor.server.application.*
import io.ktor.server.engine.*
import kotlinx.coroutines.*

fun main() {
    val server = embeddedServer(Netty, port = 8080) {
        routing {
            get("/") {
                call.respondText("Hello, World!")
            }
        }
    }
    
    // Handle shutdown gracefully
    Runtime.getRuntime().addShutdownHook(Thread {
        println("Shutting down server...")
        server.stop(
            gracePeriodMillis = 5000,
            timeoutMillis = 10000
        )
        println("Server stopped")
    })
    
    server.start(wait = true)
}

Custom Engine Factory

import io.ktor.server.application.*
import io.ktor.server.engine.*

// Custom engine factory wrapper
class CustomEngineFactory<TEngine : ApplicationEngine, TConfiguration : ApplicationEngine.Configuration>(
    private val delegate: ApplicationEngineFactory<TEngine, TConfiguration>
) : ApplicationEngineFactory<TEngine, TConfiguration> {
    
    override fun configuration(configure: TConfiguration.() -> Unit): TConfiguration {
        return delegate.configuration {
            // Apply default configuration
            shutdownGracePeriod = 5000
            shutdownTimeout = 10000
            configure()
        }
    }
    
    override fun create(
        environment: ApplicationEnvironment,
        monitor: Events,
        developmentMode: Boolean,
        configuration: TConfiguration,
        applicationProvider: () -> Application
    ): TEngine {
        // Add custom monitoring
        monitor.subscribe(ServerReady) { server ->
            println("Custom server started: ${server.environment.config}")
        }
        
        return delegate.create(environment, monitor, developmentMode, configuration, applicationProvider)
    }
}

fun main() {
    val customNetty = CustomEngineFactory(Netty)
    
    embeddedServer(customNetty, port = 8080) {
        routing {
            get("/") {
                call.respondText("Custom engine!")
            }
        }
    }.start(wait = true)
}

Install with Tessl CLI

npx tessl i tessl/maven-io-ktor--ktor-server-core-iosarm64

docs