JdkRequestAdapter.kt

  1. package com.hexagontk.http.server.jdk

  2. import com.hexagontk.http.model.*
  3. import com.hexagontk.http.model.HttpProtocol.HTTP
  4. import com.hexagontk.http.model.HttpProtocol.HTTPS
  5. import com.hexagontk.http.parseContentType
  6. import com.hexagontk.http.parseQueryString
  7. import com.hexagontk.http.patterns.PathPattern
  8. import com.sun.net.httpserver.HttpExchange
  9. import com.sun.net.httpserver.HttpsExchange
  10. import java.security.cert.X509Certificate
  11. import javax.net.ssl.SSLSession

  12. internal class JdkRequestAdapter(
  13.     methodName: String,
  14.     exchange: HttpExchange,
  15. ) : HttpRequestPort {

  16.     private val sslSession: SSLSession by lazy {
  17.         val x = exchange as? HttpsExchange ?: error("SSL session cannot be access in HTTP request")
  18.         x.sslSession
  19.     }

  20.     override val certificateChain: List<X509Certificate> by lazy {
  21.         sslSession.localCertificates.map { it as X509Certificate }
  22.     }

  23.     override val accept: List<ContentType> by lazy {
  24.         headers.all["accept"]?.map { parseContentType(it.text) } ?: emptyList()
  25.     }

  26.     override val contentLength: Long by lazy {
  27.         (body as ByteArray).size.toLong()
  28.     }

  29.     override val queryParameters: Parameters by lazy {
  30.         exchange.requestURI.query?.let {parseQueryString(it) } ?: Parameters()
  31.     }

  32.     override val parts: List<HttpPart> by lazy {
  33.         emptyList()
  34.     }

  35.     override val formParameters: Parameters by lazy {
  36.         Parameters()
  37.     }

  38.     override val method: HttpMethod by lazy {
  39.         HttpMethod.valueOf(methodName)
  40.     }

  41.     override val protocol: HttpProtocol by lazy {
  42.         if (exchange.protocol.startsWith("HTTPS")) HTTPS
  43.         else HTTP
  44.     }

  45.     override val host: String by lazy {
  46.         exchange.remoteAddress.hostName
  47.     }

  48.     override val port: Int by lazy {
  49.         exchange.requestURI.port
  50.     }

  51.     override val path: String by lazy {
  52.         exchange.requestURI.path
  53.     }

  54.     override val cookies: List<Cookie> by lazy {
  55.         emptyList()
  56.     }

  57.     override val body: Any by lazy {
  58.         exchange.requestBody.readAllBytes()
  59.     }

  60.     override val headers: Headers by lazy {
  61.         Headers(exchange.requestHeaders.flatMap { (k, v) -> v.map { Header(k, it) }})
  62.     }

  63.     override val contentType: ContentType? by lazy {
  64.         headers["content-type"]?.let { parseContentType(it.text) }
  65.     }

  66.     override val authorization: Authorization? by lazy { authorization() }

  67.     override val pathPattern: PathPattern? = null

  68.     override val pathParameters: Map<String, Any> by lazy { throw UnsupportedOperationException() }

  69.     override fun with(
  70.         body: Any,
  71.         headers: Headers,
  72.         contentType: ContentType?,
  73.         method: HttpMethod,
  74.         protocol: HttpProtocol,
  75.         host: String,
  76.         port: Int,
  77.         path: String,
  78.         queryParameters: Parameters,
  79.         parts: List<HttpPart>,
  80.         formParameters: Parameters,
  81.         cookies: List<Cookie>,
  82.         accept: List<ContentType>,
  83.         authorization: Authorization?,
  84.         certificateChain: List<X509Certificate>,
  85.         pathPattern: PathPattern?,
  86.         pathParameters: Map<String, Any>,
  87.     ): HttpRequestPort =
  88.         throw UnsupportedOperationException()
  89. }