Tengo una request de Vertx y necesito calcular una URL externa visible (pública)

Este es un problema más complicado, y la lógica es la misma para la mayoría de los serveres de aplicaciones si aún no proporcionan una function de externalización de URL.

Para hacerlo correctamente, necesita manejar todos estos encabezados:

• X-Forwarded-Proto (o X-Forwarded-Scheme: https , y quizás oddballs como X-Forwarded-Ssl: on , Front-End-Https: on )
• X-Forwarded-Host (como "myhost.com" o "myhost.com:port")
• X-Forwarded-Port

Y si desea resolver y devolver una URL que no es la actual, también debe considerar:

• parcial sin host, por ejemplo "/ something / here" o "under / me" resolviendo a los serveres protocolo público, host, puerto así como aquel abosolute o ruta relativa
• parcial con host / puerto, por ejemplo "//somehost.com:8983/thing" agregaría el mismo esquema (http / https) como este server y mantendría el rest
• completo, las URL que están totalmente calificadas se devuelven intactas, por lo que son seguras para pasar a esta function ("http: // …", "https: // …") y no se modificarán

Aquí hay un par de funciones de extensión para RoutingContext que manejarán todos estos casos y retrocederán cuando los encabezados del equilibrador de carga / proxy no estén presentes, por lo que funcionarán tanto en los casos de conexiones directas al server como en los que atraviesan el intermediario. Usted pasa la URL absoluta o relativa (a la página actual) y devolverá una versión pública de la misma.

 // return current URL as public URL fun RoutingContext.externalizeUrl(): String { return externalizeUrl(URI(request().absoluteURI()).pathPlusParmsOfUrl()) } // resolve a related URL as a public URL fun RoutingContext.externalizeUrl(resolveUrl: String): String { val cleanHeaders = request().headers().filter { it.value.isNullOrBlank() } .map { it.key to it.value }.toMap() return externalizeURI(URI(request().absoluteURI()), resolveUrl, cleanHeaders).toString() } 

Que llama a una function interna que hace el trabajo real ( y es más comprobable ya que no hay necesidad de burlarse de RoutingContext ):

 internal fun externalizeURI(requestUri: URI, resolveUrl: String, headers: Map<String, String>): URI { // special case of not touching fully qualified resolve URL's if (resolveUrl.startsWith("http://") || resolveUrl.startsWith("https://")) return URI(resolveUrl) val forwardedScheme = headers.get("X-Forwarded-Proto") ?: headers.get("X-Forwarded-Scheme") ?: requestUri.getScheme() // special case of //host/something URL's if (resolveUrl.startsWith("//")) return URI("$forwardedScheme:$resolveUrl") val (forwardedHost, forwardedHostOptionalPort) = dividePort(headers.get("X-Forwarded-Host") ?: requestUri.getHost()) val fallbackPort = requestUri.getPort().let { explicitPort -> if (explicitPort <= 0) { if ("https" == forwardedScheme) 443 else 80 } else { explicitPort } } val requestPort = headers.get("X-Forwarded-Port")?.toInt() ?: forwardedHostOptionalPort ?: fallbackPort val finalPort = when { forwardedScheme == "https" && requestPort == 443 -> "" forwardedScheme == "http" && requestPort == 80 -> "" else -> ":$requestPort" } val restOfUrl = requestUri.pathPlusParmsOfUrl() return URI("$forwardedScheme://$forwardedHost$finalPort$restOfUrl").resolve(resolveUrl) } 

Y algunas funciones auxiliares relacionadas:

 internal fun URI.pathPlusParmsOfUrl(): String { val path = this.getRawPath().let { if (it.isNullOrBlank()) "" else it.mustStartWith('/') } val query = this.getRawQuery().let { if (it.isNullOrBlank()) "" else it.mustStartWith('?') } val fragment = this.getRawFragment().let { if (it.isNullOrBlank()) "" else it.mustStartWith('#') } return "$path$query$fragment" } internal fun dividePort(hostWithOptionalPort: String): Pair<String, String?> { val parts = if (hostWithOptionalPort.startsWith('[')) { // ipv6 Pair(hostWithOptionalPort.substringBefore(']') + ']', hostWithOptionalPort.substringAfter("]:", "")) } else { // ipv4 Pair(hostWithOptionalPort.substringBefore(':'), hostWithOptionalPort.substringAfter(':', "")) } return Pair(parts.first, if (parts.second.isNullOrBlank()) null else parts.second) } fun String.mustStartWith(prefix: Char): String { return if (this.startsWith(prefix)) { this } else { prefix + this } }