Ktor server upgrade (#9088)

* Update to new ktor version #9087

* Update doc #9087

* Cleanup #9087

Author: rsinukov1

docs/generators/kotlin-server.md

@@ -16,6 +16,7 @@ These options may be applied as additional-properties (cli) or configOptions (pl
 |featureCompression|Adds ability to compress outgoing content using gzip, deflate or custom encoder and thus reduce size of the response.| |true|
 |featureConditionalHeaders|Avoid sending content if client already has same content, by checking ETag or LastModified properties.| |false|
 |featureHSTS|Avoid sending content if client already has same content, by checking ETag or LastModified properties.| |true|
+|featureLocations|Generates routes in a typed way, for both: constructing URLs and reading the parameters.| |true|
 |groupId|Generated artifact package's organization (i.e. maven groupId).| |org.openapitools|
 |library|library template (sub-template)|<dl><dt>**ktor**</dt><dd>ktor framework</dd></dl>|ktor|
 |modelMutable|Create mutable models| |false|

modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/KotlinServerCodegen.java

@@ -42,15 +42,17 @@ public class KotlinServerCodegen extends AbstractKotlinCodegen {
     private Boolean hstsFeatureEnabled = true;
     private Boolean corsFeatureEnabled = false;
     private Boolean compressionFeatureEnabled = true;
+    private Boolean locationsFeatureEnabled = true;
 
-    // This is here to potentially warn the user when an option is not supoprted by the target framework.
+    // This is here to potentially warn the user when an option is not supported by the target framework.
     private Map<String, List<String>> optionsSupportedPerFramework = new ImmutableMap.Builder<String, List<String>>()
             .put(Constants.KTOR, Arrays.asList(
                     Constants.AUTOMATIC_HEAD_REQUESTS,
                     Constants.CONDITIONAL_HEADERS,
                     Constants.HSTS,
                     Constants.CORS,
-                    Constants.COMPRESSION
+                    Constants.COMPRESSION,
+                    Constants.LOCATIONS
             ))
             .build();
 
@@ -85,6 +87,8 @@ public KotlinServerCodegen() {
         artifactId = "kotlin-server";
         packageName = "org.openapitools.server";
 
+        typeMapping.put("array", "kotlin.collections.List");
+
         // cliOptions default redefinition need to be updated
         updateOption(CodegenConstants.ARTIFACT_ID, this.artifactId);
         updateOption(CodegenConstants.PACKAGE_NAME, this.packageName);
@@ -110,6 +114,7 @@ public KotlinServerCodegen() {
         addSwitch(Constants.HSTS, Constants.HSTS_DESC, getHstsFeatureEnabled());
         addSwitch(Constants.CORS, Constants.CORS_DESC, getCorsFeatureEnabled());
         addSwitch(Constants.COMPRESSION, Constants.COMPRESSION_DESC, getCompressionFeatureEnabled());
+        addSwitch(Constants.LOCATIONS, Constants.LOCATIONS_DESC, getLocationsFeatureEnabled());
     }
 
     public Boolean getAutoHeadFeatureEnabled() {
@@ -156,6 +161,14 @@ public void setHstsFeatureEnabled(Boolean hstsFeatureEnabled) {
         this.hstsFeatureEnabled = hstsFeatureEnabled;
     }
 
+    public Boolean getLocationsFeatureEnabled() {
+        return locationsFeatureEnabled;
+    }
+
+    public void setLocationsFeatureEnabled(Boolean locationsFeatureEnabled) {
+        this.locationsFeatureEnabled = locationsFeatureEnabled;
+    }
+
     public String getName() {
         return "kotlin-server";
     }
@@ -209,6 +222,12 @@ public void processOpts() {
             additionalProperties.put(Constants.COMPRESSION, getCompressionFeatureEnabled());
         }
 
+        if (additionalProperties.containsKey(Constants.LOCATIONS)) {
+            setLocationsFeatureEnabled(convertPropertyToBooleanAndWriteBack(Constants.LOCATIONS));
+        } else {
+            additionalProperties.put(Constants.LOCATIONS, getLocationsFeatureEnabled());
+        }
+
         boolean generateApis = additionalProperties.containsKey(CodegenConstants.GENERATE_APIS) && (Boolean) additionalProperties.get(CodegenConstants.GENERATE_APIS);
         String packageFolder = (sourceFolder + File.separator + packageName).replace(".", File.separator);
         String resourcesFolder = "src/main/resources"; // not sure this can be user configurable.
@@ -223,7 +242,7 @@ public void processOpts() {
         supportingFiles.add(new SupportingFile("AppMain.kt.mustache", packageFolder, "AppMain.kt"));
         supportingFiles.add(new SupportingFile("Configuration.kt.mustache", packageFolder, "Configuration.kt"));
 
-        if (generateApis) {
+        if (generateApis && locationsFeatureEnabled) {
             supportingFiles.add(new SupportingFile("Paths.kt.mustache", packageFolder, "Paths.kt"));
         }
 
@@ -247,6 +266,8 @@ public static class Constants {
         public final static String CORS_DESC = "Ktor by default provides an interceptor for implementing proper support for Cross-Origin Resource Sharing (CORS). See enable-cors.org.";
         public final static String COMPRESSION = "featureCompression";
         public final static String COMPRESSION_DESC = "Adds ability to compress outgoing content using gzip, deflate or custom encoder and thus reduce size of the response.";
+        public final static String LOCATIONS = "featureLocations";
+        public final static String LOCATIONS_DESC = "Generates routes in a typed way, for both: constructing URLs and reading the parameters.";
     }
 
     @Override

modules/openapi-generator/src/main/resources/kotlin-server/README.mustache

@@ -2,8 +2,8 @@
 
 ## Requires
 
-* Kotlin 1.1.2
-* Gradle 3.3
+* Kotlin 1.4.31
+* Gradle 6.8.2
 
 ## Build
 

modules/openapi-generator/src/main/resources/kotlin-server/data_class.mustache

@@ -15,7 +15,7 @@ import java.io.Serializable
 {{#parcelizeModels}}
 @Parcelize
 {{/parcelizeModels}}
-data class {{classname}} (
+data class {{classname}}(
 {{#requiredVars}}
 {{>data_class_req_var}}{{^-last}},
 {{/-last}}{{/requiredVars}}{{#hasRequired}}{{#hasOptional}},

modules/openapi-generator/src/main/resources/kotlin-server/enum_class.mustache

@@ -2,7 +2,7 @@
 * {{{description}}}
 * Values: {{#allowableValues}}{{#enumVars}}{{&name}}{{^-last}},{{/-last}}{{/enumVars}}{{/allowableValues}}
 */
-enum class {{classname}}(val value: {{dataType}}){
+enum class {{classname}}(val value: {{dataType}}) {
 {{#allowableValues}}{{#enumVars}}
     {{&name}}({{{value}}}){{^-last}},{{/-last}}{{#-last}};{{/-last}}
 {{/enumVars}}{{/allowableValues}}

modules/openapi-generator/src/main/resources/kotlin-server/libraries/ktor/ApiKeyAuth.kt.mustache

@@ -1,85 +1,105 @@
 package {{packageName}}.infrastructure
 
-import io.ktor.application.ApplicationCall
-import io.ktor.application.call
-import io.ktor.auth.Authentication
-import io.ktor.auth.AuthenticationFailedCause
-import io.ktor.auth.AuthenticationPipeline
-import io.ktor.auth.AuthenticationProvider
-import io.ktor.auth.Credential
-import io.ktor.auth.Principal
-import io.ktor.auth.UnauthorizedResponse
-import io.ktor.http.auth.HeaderValueEncoding
-import io.ktor.http.auth.HttpAuthHeader
-import io.ktor.request.ApplicationRequest
-import io.ktor.response.respond
+import io.ktor.application.*
+import io.ktor.auth.*
+import io.ktor.http.auth.*
+import io.ktor.request.*
+import io.ktor.response.*
 
 enum class ApiKeyLocation(val location: String) {
     QUERY("query"),
     HEADER("header")
 }
-data class ApiKeyCredential(val value: String): Credential
-data class ApiPrincipal(val apiKeyCredential: ApiKeyCredential?) : Principal
-
 
+data class ApiKeyCredential(val value: String) : Credential
+data class ApiPrincipal(val apiKeyCredential: ApiKeyCredential?) : Principal
 
 /**
 * Represents a Api Key authentication provider
 * @param name is the name of the provider, or `null` for a default provider
 */
-class ApiKeyAuthenticationProvider(name: String?) : AuthenticationProvider(name) {
-    internal var authenticationFunction: suspend ApplicationCall.(ApiKeyCredential) -> Principal? = { null }
+class ApiKeyAuthenticationProvider(configuration: Configuration) : AuthenticationProvider(configuration) {
 
-    var apiKeyName: String = "";
+    private val authenticationFunction = configuration.authenticationFunction
 
-    var apiKeyLocation: ApiKeyLocation = ApiKeyLocation.QUERY;
+    private val apiKeyName: String = configuration.apiKeyName
 
-    /**
-    * Sets a validation function that will check given [ApiKeyCredential] instance and return [Principal],
-    * or null if credential does not correspond to an authenticated principal
-    */
-    fun validate(body: suspend ApplicationCall.(ApiKeyCredential) -> Principal?) {
-        authenticationFunction = body
-    }
-}
+    private val apiKeyLocation: ApiKeyLocation = configuration.apiKeyLocation
 
-fun Authentication.Configuration.apiKeyAuth(name: String? = null, configure: ApiKeyAuthenticationProvider.() -> Unit) {
-    val provider = ApiKeyAuthenticationProvider(name).apply(configure)
-    val apiKeyName = provider.apiKeyName
-    val apiKeyLocation = provider.apiKeyLocation
-    val authenticate = provider.authenticationFunction
+    internal fun install() {
+        pipeline.intercept(AuthenticationPipeline.RequestAuthentication) { context ->
+            val credentials = call.request.apiKeyAuthenticationCredentials(apiKeyName, apiKeyLocation)
+            val principal = credentials?.let { authenticationFunction(call, it) }
 
-    provider.pipeline.intercept(AuthenticationPipeline.RequestAuthentication) { context ->
-        val credentials = call.request.apiKeyAuthenticationCredentials(apiKeyName, apiKeyLocation)
-        val principal = credentials?.let { authenticate(call, it) }
+            val cause = when {
+                credentials == null -> AuthenticationFailedCause.NoCredentials
+                principal == null -> AuthenticationFailedCause.InvalidCredentials
+                else -> null
+            }
 
-        val cause = when {
-            credentials == null -> AuthenticationFailedCause.NoCredentials
-            principal == null -> AuthenticationFailedCause.InvalidCredentials
-            else -> null
-        }
+            if (cause != null) {
+                context.challenge(apiKeyName, cause) {
+                    call.respond(
+                        UnauthorizedResponse(
+                            HttpAuthHeader.Parameterized(
+                                "API_KEY",
+                                mapOf("key" to apiKeyName),
+                                HeaderValueEncoding.QUOTED_ALWAYS
+                            )
+                        )
+                    )
+                    it.complete()
+                }
+            }
 
-        if (cause != null) {
-            context.challenge(apiKeyName, cause) {
-                // TODO: Verify correct response structure here.
-                call.respond(UnauthorizedResponse(HttpAuthHeader.Parameterized("API_KEY", mapOf("key" to apiKeyName), HeaderValueEncoding.QUOTED_ALWAYS)))
-                it.complete()
+            if (principal != null) {
+                context.principal(principal)
             }
         }
+    }
+
+    class Configuration internal constructor(name: String?) : AuthenticationProvider.Configuration(name) {
+
+        internal var authenticationFunction: suspend ApplicationCall.(ApiKeyCredential) -> Principal? = {
+            throw NotImplementedError(
+                "Api Key auth validate function is not specified. Use apiKeyAuth { validate { ... } } to fix."
+            )
+        }
 
-        if (principal != null) {
-            context.principal(principal)
+        var apiKeyName: String = ""
+
+        var apiKeyLocation: ApiKeyLocation = ApiKeyLocation.QUERY
+
+        /**
+        * Sets a validation function that will check given [ApiKeyCredential] instance and return [Principal],
+        * or null if credential does not correspond to an authenticated principal
+        */
+        fun validate(body: suspend ApplicationCall.(ApiKeyCredential) -> Principal?) {
+            authenticationFunction = body
         }
     }
 }
 
-fun ApplicationRequest.apiKeyAuthenticationCredentials(apiKeyName: String, apiKeyLocation: ApiKeyLocation): ApiKeyCredential? {
-    val value: String? = when(apiKeyLocation) {
+fun Authentication.Configuration.apiKeyAuth(
+    name: String? = null,
+    configure: ApiKeyAuthenticationProvider.Configuration.() -> Unit
+) {
+    val configuration = ApiKeyAuthenticationProvider.Configuration(name).apply(configure)
+    val provider = ApiKeyAuthenticationProvider(configuration)
+    provider.install()
+    register(provider)
+}
+
+fun ApplicationRequest.apiKeyAuthenticationCredentials(
+    apiKeyName: String,
+    apiKeyLocation: ApiKeyLocation
+): ApiKeyCredential? {
+    val value: String? = when (apiKeyLocation) {
         ApiKeyLocation.QUERY -> this.queryParameters[apiKeyName]
         ApiKeyLocation.HEADER -> this.headers[apiKeyName]
     }
-    when (value) {
-        null -> return null
-        else -> return ApiKeyCredential(value)
+    return when (value) {
+        null -> null
+        else -> ApiKeyCredential(value)
     }
 }

modules/openapi-generator/src/main/resources/kotlin-server/libraries/ktor/AppMain.kt.mustache

@@ -28,39 +28,40 @@ import io.ktor.features.HSTS
 {{/featureHSTS}}
 import io.ktor.gson.GsonConverter
 import io.ktor.http.ContentType
+{{#featureLocations}}
 import io.ktor.locations.KtorExperimentalLocationsAPI
 import io.ktor.locations.Locations
-import io.ktor.metrics.Metrics
+{{/featureLocations}}
 import io.ktor.routing.Routing
 import java.util.concurrent.TimeUnit
-import io.ktor.util.KtorExperimentalAPI
 {{#hasAuthMethods}}
 import io.ktor.auth.Authentication
 import io.ktor.auth.oauth
+import io.ktor.metrics.dropwizard.DropwizardMetrics
 import org.openapitools.server.infrastructure.ApiKeyCredential
 import org.openapitools.server.infrastructure.ApiPrincipal
 import org.openapitools.server.infrastructure.apiKeyAuth
 {{/hasAuthMethods}}
 {{#generateApis}}{{#apiInfo}}{{#apis}}import {{apiPackage}}.{{classname}}
 {{/apis}}{{/apiInfo}}{{/generateApis}}
 
-@KtorExperimentalAPI
 internal val settings = HoconApplicationConfig(ConfigFactory.defaultApplication(HTTP::class.java.classLoader))
 
 object HTTP {
     val client = HttpClient(Apache)
 }
 
-@KtorExperimentalAPI
+{{#featureLocations}}
 @KtorExperimentalLocationsAPI
+{{/featureLocations}}
 fun Application.main() {
     install(DefaultHeaders)
-    install(Metrics) {
+    install(DropwizardMetrics) {
         val reporter = Slf4jReporter.forRegistry(registry)
-                .outputTo(log)
-                .convertRatesTo(TimeUnit.SECONDS)
-                .convertDurationsTo(TimeUnit.MILLISECONDS)
-                .build()
+            .outputTo(log)
+            .convertRatesTo(TimeUnit.SECONDS)
+            .convertDurationsTo(TimeUnit.MILLISECONDS)
+            .build()
         reporter.start(10, TimeUnit.SECONDS)
     }
 {{#generateApis}}
@@ -82,7 +83,9 @@ fun Application.main() {
     {{#featureCompression}}
     install(Compression, ApplicationCompressionConfiguration()) // see http://ktor.io/features/compression.html
     {{/featureCompression}}
+    {{#featureLocations}}
     install(Locations) // see http://ktor.io/features/locations.html
+    {{/featureLocations}}
     {{#hasAuthMethods}}
     install(Authentication) {
     {{#authMethods}}
@@ -117,8 +120,8 @@ fun Application.main() {
             client = HttpClient(Apache)
             providerLookup = { ApplicationAuthProviders["{{{name}}}"] }
             urlProvider = { _ ->
-            // TODO: define a callback url here.
-            "/"
+                // TODO: define a callback url here.
+                "/"
             }
         }
             {{/bodyAllowed}}
@@ -138,8 +141,7 @@ fun Application.main() {
 
 {{/generateApis}}
 
-    environment.monitor.subscribe(ApplicationStopping)
-    {
+    environment.monitor.subscribe(ApplicationStopping) {
         HTTP.client.close()
     }
 }

modules/openapi-generator/src/main/resources/kotlin-server/libraries/ktor/Configuration.kt.mustache

@@ -8,11 +8,7 @@ import io.ktor.features.deflate
 import io.ktor.features.gzip
 import io.ktor.features.minimumSize
 import io.ktor.http.HttpMethod
-import io.ktor.util.KtorExperimentalAPI
-import java.time.Duration
-import java.util.concurrent.Executors
-
-import {{packageName}}.settings
+import java.util.concurrent.TimeUnit
 
 {{#featureCORS}}
 /**
@@ -49,7 +45,7 @@ internal fun ApplicationCORSConfiguration(): CORS.Configuration.() -> Unit {
  */
 internal fun ApplicationHstsConfiguration(): HSTS.Configuration.() -> Unit {
     return {
-        maxAge = Duration.ofDays(365)
+        maxAgeInSeconds = TimeUnit.DAYS.toSeconds(365)
         includeSubDomains = true
         preload = false
 
@@ -82,7 +78,6 @@ internal fun ApplicationCompressionConfiguration(): Compression.Configuration.()
 {{/featureCompression}}
 
 // Defines authentication mechanisms used throughout the application.
-@KtorExperimentalAPI
 val ApplicationAuthProviders: Map<String, OAuthServerSettings> = listOf<OAuthServerSettings>(
 {{#authMethods}}
     {{#isOAuth}}
@@ -109,6 +104,3 @@ val ApplicationAuthProviders: Map<String, OAuthServerSettings> = listOf<OAuthSer
 //                defaultScopes = listOf("public_profile")
 //        )
 ).associateBy { it.name }
-
-// Provides an application-level fixed thread pool on which to execute coroutines (mainly)
-internal val ApplicationExecutors = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors() * 4)