From b1f9f77a174a1ed8733216a56ff53c236a0095d1 Mon Sep 17 00:00:00 2001 From: Konrad Malawski Date: Thu, 24 Sep 2015 15:29:29 +0200 Subject: [PATCH 1/2] =htc #18533 make configuration of parsing less confusing --- akka-docs-dev/rst/java/http/http-model.rst | 11 + .../rst/scala/http/common/http-model.rst | 11 + .../src/main/resources/reference.conf | 336 ++++++++++++++---- .../akka/http/ConnectionPoolSettings.scala | 2 +- .../main/scala/akka/http/scaladsl/Http.scala | 48 ++- .../client/ClientConfigurationSpec.scala | 27 ++ 6 files changed, 358 insertions(+), 77 deletions(-) create mode 100644 akka-http-core/src/test/scala/akka/http/impl/engine/client/ClientConfigurationSpec.scala diff --git a/akka-docs-dev/rst/java/http/http-model.rst b/akka-docs-dev/rst/java/http/http-model.rst index ce52320bfb..9be44c5f3b 100644 --- a/akka-docs-dev/rst/java/http/http-model.rst +++ b/akka-docs-dev/rst/java/http/http-model.rst @@ -254,3 +254,14 @@ Parsing / Rendering Parsing and rendering of HTTP data structures is heavily optimized and for most types there's currently no public API provided to parse (or render to) Strings or byte arrays. + +.. note:: + Various parsing and rendering settings are available to tweak in the configuration under ``akka.http.client[.parsing]``, + ``akka.http.server[.parsing]`` and ``akka.http.host-connection-pool[.client.parsing]``. Please note that while each of + these sections expose the same parsing options, they will only be used for their respective APIs. For example, changing + a setting inside ``akka.http.client.parsing`` **does not** change the same value in ``akka.http.host-connection-pool.client.parsing``, + as they are different APIs. + + You can check which settings to tweak for which method exposed on the Http object by inspecting their ScalaDoc. + In general though it's as simple as "pool" backed services use the ``host-connection-pool`` section, other clients + which expose ``Flow`` use the ``client`` section, and the server side uses the ``server`` configuration section. \ No newline at end of file diff --git a/akka-docs-dev/rst/scala/http/common/http-model.rst b/akka-docs-dev/rst/scala/http/common/http-model.rst index 39dbd13d79..6dce80d3d9 100644 --- a/akka-docs-dev/rst/scala/http/common/http-model.rst +++ b/akka-docs-dev/rst/scala/http/common/http-model.rst @@ -250,3 +250,14 @@ Parsing / Rendering Parsing and rendering of HTTP data structures is heavily optimized and for most types there's currently no public API provided to parse (or render to) Strings or byte arrays. + +.. note:: + Various parsing and rendering settings are available to tweak in the configuration under ``akka.http.client[.parsing]``, + ``akka.http.server[.parsing]`` and ``akka.http.host-connection-pool[.client.parsing]``. Please note that while each of + these sections expose the same parsing options, they will only be used for their respective APIs. For example, changing + a setting inside ``akka.http.client.parsing`` **does not** change the same value in ``akka.http.host-connection-pool.client.parsing``, + as they are different APIs. + + You can check which settings to tweak for which method exposed on the Http object by inspecting their ScalaDoc. + In general though it's as simple as "pool" backed services use the ``host-connection-pool`` section, other clients + which expose ``Flow`` use the ``client`` section, and the server side uses the ``server`` configuration section. \ No newline at end of file diff --git a/akka-http-core/src/main/resources/reference.conf b/akka-http-core/src/main/resources/reference.conf index 4cd7e35465..558c216f99 100644 --- a/akka-http-core/src/main/resources/reference.conf +++ b/akka-http-core/src/main/resources/reference.conf @@ -88,7 +88,77 @@ akka.http { } # Modify to tweak parsing settings on the server-side only. - parsing = ${akka.http.parsing} + # + # IMPORTANT: + # Please note that this section is replicated in `client` and `http-connection-pool` + parsing { + # The limits for the various parts of the HTTP message parser. + max-uri-length = 2k + max-method-length = 16 + max-response-reason-length = 64 + max-header-name-length = 64 + max-header-value-length = 8k + max-header-count = 64 + max-chunk-ext-length = 256 + max-chunk-size = 1m + + # Maximum content length which should not be exceeded by incoming HttpRequests. + # For file uploads which use the entityBytes Source of an incoming HttpRequest it is safe to + # set this to a very high value (or to `infinite` if feeling very adventurous) as the streaming + # upload will be back-pressured properly by Akka Streams. + # Please note however that this setting is a global property, and is applied to all incoming requests, + # not only file uploads consumed in a streaming fashion, so pick this limit wisely. + max-content-length = 8m + + # Sets the strictness mode for parsing request target URIs. + # The following values are defined: + # + # `strict`: RFC3986-compliant URIs are required, + # a 400 response is triggered on violations + # + # `relaxed`: all visible 7-Bit ASCII chars are allowed + # + # `relaxed-with-raw-query`: like `relaxed` but additionally + # the URI query is not parsed, but delivered as one raw string + # as the `key` value of a single Query structure element. + # + uri-parsing-mode = strict + + # Enables/disables the logging of warning messages in case an incoming + # message (request or response) contains an HTTP header which cannot be + # parsed into its high-level model class due to incompatible syntax. + # Note that, independently of this settings, akka-http will accept messages + # with such headers as long as the message as a whole would still be legal + # under the HTTP specification even without this header. + # If a header cannot be parsed into a high-level model instance it will be + # provided as a `RawHeader`. + # If logging is enabled it is performed with the configured + # `error-logging-verbosity`. + illegal-header-warnings = on + + # Configures the verbosity with which message (request or response) parsing + # errors are written to the application log. + # + # Supported settings: + # `off` : no log messages are produced + # `simple`: a condensed single-line message is logged + # `full` : the full error details (potentially spanning several lines) are logged + error-logging-verbosity = full + + # limits for the number of different values per header type that the + # header cache will hold + header-cache { + default = 12 + Content-MD5 = 0 + Date = 0 + If-Match = 0 + If-Modified-Since = 0 + If-None-Match = 0 + If-Range = 0 + If-Unmodified-Since = 0 + User-Agent = 32 + } + } } client { @@ -142,7 +212,77 @@ akka.http { } # Modify to tweak parsing settings on the client-side only. - parsing = ${akka.http.parsing} + # + # IMPORTANT: + # Please note that this section is replicated in `server` and `http-connection-pool`. + parsing { + # The limits for the various parts of the HTTP message parser. + max-uri-length = 2k + max-method-length = 16 + max-response-reason-length = 64 + max-header-name-length = 64 + max-header-value-length = 8k + max-header-count = 64 + max-chunk-ext-length = 256 + max-chunk-size = 1m + + # Maximum content length which should not be exceeded by incoming HttpRequests. + # For file uploads which use the entityBytes Source of an incoming HttpRequest it is safe to + # set this to a very high value (or to `infinite` if feeling very adventurous) as the streaming + # upload will be back-pressured properly by Akka Streams. + # Please note however that this setting is a global property, and is applied to all incoming requests, + # not only file uploads consumed in a streaming fashion, so pick this limit wisely. + max-content-length = 8m + + # Sets the strictness mode for parsing request target URIs. + # The following values are defined: + # + # `strict`: RFC3986-compliant URIs are required, + # a 400 response is triggered on violations + # + # `relaxed`: all visible 7-Bit ASCII chars are allowed + # + # `relaxed-with-raw-query`: like `relaxed` but additionally + # the URI query is not parsed, but delivered as one raw string + # as the `key` value of a single Query structure element. + # + uri-parsing-mode = strict + + # Enables/disables the logging of warning messages in case an incoming + # message (request or response) contains an HTTP header which cannot be + # parsed into its high-level model class due to incompatible syntax. + # Note that, independently of this settings, akka-http will accept messages + # with such headers as long as the message as a whole would still be legal + # under the HTTP specification even without this header. + # If a header cannot be parsed into a high-level model instance it will be + # provided as a `RawHeader`. + # If logging is enabled it is performed with the configured + # `error-logging-verbosity`. + illegal-header-warnings = on + + # Configures the verbosity with which message (request or response) parsing + # errors are written to the application log. + # + # Supported settings: + # `off` : no log messages are produced + # `simple`: a condensed single-line message is logged + # `full` : the full error details (potentially spanning several lines) are logged + error-logging-verbosity = full + + # limits for the number of different values per header type that the + # header cache will hold + header-cache { + default = 12 + Content-MD5 = 0 + Date = 0 + If-Match = 0 + If-Modified-Since = 0 + If-None-Match = 0 + If-Range = 0 + If-Unmodified-Since = 0 + User-Agent = 32 + } + } } host-connection-pool { @@ -179,81 +319,131 @@ akka.http { idle-timeout = 30 s # Modify to tweak client settings for host connection pools only. - client = ${akka.http.client} - } - - # The (default) configuration of the HTTP message parser for the server and the client. - # IMPORTANT: These settings (i.e. children of `akka.http.parsing`) can't be directly - # overridden in `application.conf` to change the parser settings for client and server - # at the same time. Instead, override the concrete settings beneath - # `akka.http.server.parsing` and `akka.http.client.parsing` - # where these settings are copied to. - parsing { - # The limits for the various parts of the HTTP message parser. - max-uri-length = 2k - max-method-length = 16 - max-response-reason-length = 64 - max-header-name-length = 64 - max-header-value-length = 8k - max-header-count = 64 - max-chunk-ext-length = 256 - max-chunk-size = 1m - - # Maximum content length which should not be exceeded by incoming HttpRequests. - # For file uploads which use the entityBytes Source of an incoming HttpRequest it is safe to - # set this to a very high value (or to `infinite` if feeling very adventurous) as the streaming - # upload will be back-pressured properly by Akka Streams. - # Please note however that this setting is a global property, and is applied to all incoming requests, - # not only file uploads consumed in a streaming fashion, so pick this limit wisely. - max-content-length = 8m - - # Sets the strictness mode for parsing request target URIs. - # The following values are defined: # - # `strict`: RFC3986-compliant URIs are required, - # a 400 response is triggered on violations - # - # `relaxed`: all visible 7-Bit ASCII chars are allowed - # - # `relaxed-with-raw-query`: like `relaxed` but additionally - # the URI query is not parsed, but delivered as one raw string - # as the `key` value of a single Query structure element. - # - uri-parsing-mode = strict + # IMPORTANT: + # Please note that this section mirrors `akka.http.client` however is used only for pool-based APIs, + # such as `Http().superPool` or `Http().singleRequest`. + client = { + # The default value of the `User-Agent` header to produce if no + # explicit `User-Agent`-header was included in a request. + # If this value is the empty string and no header was included in + # the request, no `User-Agent` header will be rendered at all. + user-agent-header = akka-http/${akka.version} - # Enables/disables the logging of warning messages in case an incoming - # message (request or response) contains an HTTP header which cannot be - # parsed into its high-level model class due to incompatible syntax. - # Note that, independently of this settings, akka-http will accept messages - # with such headers as long as the message as a whole would still be legal - # under the HTTP specification even without this header. - # If a header cannot be parsed into a high-level model instance it will be - # provided as a `RawHeader`. - # If logging is enabled it is performed with the configured - # `error-logging-verbosity`. - illegal-header-warnings = on + # The time period within which the TCP connecting process must be completed. + connecting-timeout = 10s - # Configures the verbosity with which message (request or response) parsing - # errors are written to the application log. - # - # Supported settings: - # `off` : no log messages are produced - # `simple`: a condensed single-line message is logged - # `full` : the full error details (potentially spanning several lines) are logged - error-logging-verbosity = full + # The time after which an idle connection will be automatically closed. + # Set to `infinite` to completely disable idle timeouts. + idle-timeout = 60 s - # limits for the number of different values per header type that the - # header cache will hold - header-cache { - default = 12 - Content-MD5 = 0 - Date = 0 - If-Match = 0 - If-Modified-Since = 0 - If-None-Match = 0 - If-Range = 0 - If-Unmodified-Since = 0 - User-Agent = 32 + # The initial size of the buffer to render the request headers in. + # Can be used for fine-tuning request rendering performance but probably + # doesn't have to be fiddled with in most applications. + request-header-size-hint = 512 + + # The proxy configurations to be used for requests with the specified + # scheme. + proxy { + # Proxy settings for unencrypted HTTP requests + # Set to 'none' to always connect directly, 'default' to use the system + # settings as described in http://docs.oracle.com/javase/6/docs/technotes/guides/net/proxies.html + # or specify the proxy host, port and non proxy hosts as demonstrated + # in the following example: + # http { + # host = myproxy.com + # port = 8080 + # non-proxy-hosts = ["*.direct-access.net"] + # } + http = default + + # Proxy settings for HTTPS requests (currently unsupported) + https = default + } + + # Socket options to set for the listening socket. If a setting is left + # undefined, it will use whatever the default on the system is. + socket-options { + so-receive-buffer-size = undefined + so-send-buffer-size = undefined + so-reuse-address = undefined + so-traffic-class = undefined + tcp-keep-alive = undefined + tcp-oob-inline = undefined + tcp-no-delay = undefined + } + + + # IMPORTANT: Please note that this section is replicated in `client` and `server`. + parsing { + # The limits for the various parts of the HTTP message parser. + max-uri-length = 2k + max-method-length = 16 + max-response-reason-length = 64 + max-header-name-length = 64 + max-header-value-length = 8k + max-header-count = 64 + max-chunk-ext-length = 256 + max-chunk-size = 1m + + # Maximum content length which should not be exceeded by incoming HttpRequests. + # For file uploads which use the entityBytes Source of an incoming HttpRequest it is safe to + # set this to a very high value (or to `infinite` if feeling very adventurous) as the streaming + # upload will be back-pressured properly by Akka Streams. + # Please note however that this setting is a global property, and is applied to all incoming requests, + # not only file uploads consumed in a streaming fashion, so pick this limit wisely. + max-content-length = 8m + + # Sets the strictness mode for parsing request target URIs. + # The following values are defined: + # + # `strict`: RFC3986-compliant URIs are required, + # a 400 response is triggered on violations + # + # `relaxed`: all visible 7-Bit ASCII chars are allowed + # + # `relaxed-with-raw-query`: like `relaxed` but additionally + # the URI query is not parsed, but delivered as one raw string + # as the `key` value of a single Query structure element. + # + uri-parsing-mode = strict + + # Enables/disables the logging of warning messages in case an incoming + # message (request or response) contains an HTTP header which cannot be + # parsed into its high-level model class due to incompatible syntax. + # Note that, independently of this settings, akka-http will accept messages + # with such headers as long as the message as a whole would still be legal + # under the HTTP specification even without this header. + # If a header cannot be parsed into a high-level model instance it will be + # provided as a `RawHeader`. + # If logging is enabled it is performed with the configured + # `error-logging-verbosity`. + illegal-header-warnings = on + + # Configures the verbosity with which message (request or response) parsing + # errors are written to the application log. + # + # Supported settings: + # `off` : no log messages are produced + # `simple`: a condensed single-line message is logged + # `full` : the full error details (potentially spanning several lines) are logged + error-logging-verbosity = full + + # limits for the number of different values per header type that the + # header cache will hold + header-cache { + default = 12 + Content-MD5 = 0 + Date = 0 + If-Match = 0 + If-Modified-Since = 0 + If-None-Match = 0 + If-Range = 0 + If-Unmodified-Since = 0 + User-Agent = 32 + } + } } } + } diff --git a/akka-http-core/src/main/scala/akka/http/ConnectionPoolSettings.scala b/akka-http-core/src/main/scala/akka/http/ConnectionPoolSettings.scala index 7161854889..95f8a2c0b3 100644 --- a/akka-http-core/src/main/scala/akka/http/ConnectionPoolSettings.scala +++ b/akka-http-core/src/main/scala/akka/http/ConnectionPoolSettings.scala @@ -42,7 +42,7 @@ final case class ConnectionPoolSettings( require(maxRetries >= 0, "max-retries must be >= 0") require(maxOpenRequests > 0 && (maxOpenRequests & (maxOpenRequests - 1)) == 0, "max-open-requests must be a power of 2 > 0") require(pipeliningLimit > 0, "pipelining-limit must be > 0") - require(idleTimeout >= Duration.Zero, "idleTimeout must be >= 0") + require(idleTimeout >= Duration.Zero, "idle-timeout must be >= 0") } object ConnectionPoolSettings extends SettingsCompanion[ConnectionPoolSettings]("akka.http.host-connection-pool") { diff --git a/akka-http-core/src/main/scala/akka/http/scaladsl/Http.scala b/akka-http-core/src/main/scala/akka/http/scaladsl/Http.scala index b94926ecd8..e231f5013a 100644 --- a/akka-http-core/src/main/scala/akka/http/scaladsl/Http.scala +++ b/akka-http-core/src/main/scala/akka/http/scaladsl/Http.scala @@ -37,6 +37,8 @@ class HttpExt(config: Config)(implicit system: ActorSystem) extends akka.actor.E // SYNCHRONIZED ACCESS ONLY! private[this] var _defaultClientHttpsContext: HttpsContext = _ + // ** SERVER ** // + /** * Creates a [[Source]] of [[IncomingConnection]] instances which represents a prospective HTTP server binding * on the given `endpoint`. @@ -52,6 +54,9 @@ class HttpExt(config: Config)(implicit system: ActorSystem) extends akka.actor.E * * If no ``port`` is explicitly given (or the port value is negative) the protocol's default port will be used, * which is 80 for HTTP and 443 for HTTPS. + * + * To configure additional settings for a server started using this method, + * use the `akka.http.server` config section or pass in a [[ServerSettings]] explicitly. */ def bind(interface: String, port: Int = -1, settings: ServerSettings = ServerSettings(system), @@ -76,6 +81,9 @@ class HttpExt(config: Config)(implicit system: ActorSystem) extends akka.actor.E * * The number of concurrently accepted connections can be configured by overriding * the `akka.http.server.max-connections` setting. + * + * To configure additional settings for a server started using this method, + * use the `akka.http.server` config section or pass in a [[ServerSettings]] explicitly. */ def bindAndHandle(handler: Flow[HttpRequest, HttpResponse, Any], interface: String, port: Int = -1, @@ -114,6 +122,9 @@ class HttpExt(config: Config)(implicit system: ActorSystem) extends akka.actor.E * * The number of concurrently accepted connections can be configured by overriding * the `akka.http.server.max-connections` setting. + * + * To configure additional settings for a server started using this method, + * use the `akka.http.server` config section or pass in a [[ServerSettings]] explicitly. */ def bindAndHandleSync(handler: HttpRequest ⇒ HttpResponse, interface: String, port: Int = -1, @@ -128,6 +139,9 @@ class HttpExt(config: Config)(implicit system: ActorSystem) extends akka.actor.E * * The number of concurrently accepted connections can be configured by overriding * the `akka.http.server.max-connections` setting. + * + * To configure additional settings for a server started using this method, + * use the `akka.http.server` config section or pass in a [[ServerSettings]] explicitly. */ def bindAndHandleAsync(handler: HttpRequest ⇒ Future[HttpResponse], interface: String, port: Int = -1, @@ -140,8 +154,10 @@ class HttpExt(config: Config)(implicit system: ActorSystem) extends akka.actor.E type ServerLayer = Http.ServerLayer /** - * Constructs a [[ServerLayer]] stage using the configured default [[ServerSettings]]. The returned [[BidiFlow]] - * can only be materialized once. + * Constructs a [[ServerLayer]] stage using the configured default [[ServerSettings]], + * configured using the `akka.http.server` config section. + * + * The returned [[BidiFlow]] can only be materialized once. */ def serverLayer()(implicit mat: Materializer): ServerLayer = serverLayer(ServerSettings(system)) @@ -155,9 +171,14 @@ class HttpExt(config: Config)(implicit system: ActorSystem) extends akka.actor.E log: LoggingAdapter = system.log)(implicit mat: Materializer): ServerLayer = HttpServerBluePrint(settings, remoteAddress, log) + // ** CLIENT ** // + /** * Creates a [[Flow]] representing a prospective HTTP client connection to the given endpoint. * Every materialization of the produced flow will attempt to establish a new outgoing connection. + * + * To configure additional settings for requests made using this method, + * use the `akka.http.client` config section or pass in a [[ClientConnectionSettings]] explicitly. */ def outgoingConnection(host: String, port: Int = 80, localAddress: Option[InetSocketAddress] = None, @@ -170,6 +191,9 @@ class HttpExt(config: Config)(implicit system: ActorSystem) extends akka.actor.E * * If an explicit [[HttpsContext]] is given then it rather than the configured default [[HttpsContext]] will be used * for encryption on the connection. + * + * To configure additional settings for requests made using this method, + * use the `akka.http.client` config section or pass in a [[ClientConnectionSettings]] explicitly. */ def outgoingConnectionTls(host: String, port: Int = 443, localAddress: Option[InetSocketAddress] = None, @@ -196,7 +220,8 @@ class HttpExt(config: Config)(implicit system: ActorSystem) extends akka.actor.E type ClientLayer = Http.ClientLayer /** - * Constructs a [[ClientLayer]] stage using the configured default [[ClientConnectionSettings]]. + * Constructs a [[ClientLayer]] stage using the configured default [[ClientConnectionSettings]], + * configured using the `akka.http.client` config section. */ def clientLayer(hostHeader: Host): ClientLayer = clientLayer(hostHeader, ClientConnectionSettings(system)) @@ -209,6 +234,8 @@ class HttpExt(config: Config)(implicit system: ActorSystem) extends akka.actor.E log: LoggingAdapter = system.log): ClientLayer = OutgoingConnectionBlueprint(hostHeader, settings, log) + // ** CONNECTION POOL ** // + /** * Starts a new connection pool to the given host and configuration and returns a [[Flow]] which dispatches * the requests from all its materializations across this pool. @@ -222,6 +249,9 @@ class HttpExt(config: Config)(implicit system: ActorSystem) extends akka.actor.E * response for A. * In order to allow for easy response-to-request association the flow takes in a custom, opaque context * object of type ``T`` from the application which is emitted together with the corresponding response. + * + * To configure additional settings for the pool (and requests made using it), + * use the `akka.http.host-connection-pool` config section or pass in a [[ConnectionPoolSettings]] explicitly. */ def newHostConnectionPool[T](host: String, port: Int = 80, settings: ConnectionPoolSettings = ConnectionPoolSettings(system), @@ -235,6 +265,9 @@ class HttpExt(config: Config)(implicit system: ActorSystem) extends akka.actor.E * * If an explicit [[HttpsContext]] is given then it rather than the configured default [[HttpsContext]] will be used * for encryption on the connections. + * + * To configure additional settings for the pool (and requests made using it), + * use the `akka.http.host-connection-pool` config section or pass in a [[ConnectionPoolSettings]] explicitly. */ def newHostConnectionPoolTls[T](host: String, port: Int = 443, settings: ConnectionPoolSettings = ConnectionPoolSettings(system), @@ -280,6 +313,9 @@ class HttpExt(config: Config)(implicit system: ActorSystem) extends akka.actor.E * response for A. * In order to allow for easy response-to-request association the flow takes in a custom, opaque context * object of type ``T`` from the application which is emitted together with the corresponding response. + * + * To configure additional settings for the pool (and requests made using it), + * use the `akka.http.host-connection-pool` config section or pass in a [[ConnectionPoolSettings]] explicitly. */ def cachedHostConnectionPool[T](host: String, port: Int = 80, settings: ConnectionPoolSettings = ConnectionPoolSettings(system), @@ -294,6 +330,9 @@ class HttpExt(config: Config)(implicit system: ActorSystem) extends akka.actor.E * * If an explicit [[HttpsContext]] is given then it rather than the configured default [[HttpsContext]] will be used * for encryption on the connections. + * + * To configure additional settings for the pool (and requests made using it), + * use the `akka.http.host-connection-pool` config section or pass in a [[ConnectionPoolSettings]] explicitly. */ def cachedHostConnectionPoolTls[T](host: String, port: Int = 443, settings: ConnectionPoolSettings = ConnectionPoolSettings(system), @@ -338,6 +377,9 @@ class HttpExt(config: Config)(implicit system: ActorSystem) extends akka.actor.E * response for A. * In order to allow for easy response-to-request association the flow takes in a custom, opaque context * object of type ``T`` from the application which is emitted together with the corresponding response. + * + * To configure additional settings for the pool (and requests made using it), + * use the `akka.http.host-connection-pool` config section or pass in a [[ConnectionPoolSettings]] explicitly. */ def superPool[T](settings: ConnectionPoolSettings = ConnectionPoolSettings(system), httpsContext: Option[HttpsContext] = None, diff --git a/akka-http-core/src/test/scala/akka/http/impl/engine/client/ClientConfigurationSpec.scala b/akka-http-core/src/test/scala/akka/http/impl/engine/client/ClientConfigurationSpec.scala new file mode 100644 index 0000000000..3966940314 --- /dev/null +++ b/akka-http-core/src/test/scala/akka/http/impl/engine/client/ClientConfigurationSpec.scala @@ -0,0 +1,27 @@ +/* + * Copyright (C) 2009-2014 Typesafe Inc. + */ + +package akka.http.impl.engine.client + +import akka.stream.testkit.AkkaSpec + +class ClientConfigurationSpec extends AkkaSpec { + "Reference configurations" should { + for { + (first, second) ← "akka.http.client" -> "akka.http.host-connection-pool.client" :: + "akka.http.client.parsing" -> "akka.http.host-connection-pool.client.parsing" :: + "akka.http.server.parsing" -> "akka.http.client.parsing" :: + Nil + } s"be consistent for: `$first` and `$second`" in { + configShouldBeEqual("akka.http.client.parsing", "akka.http.host-connection-pool.client.parsing") + } + } + + private def configShouldBeEqual(first: String, second: String): Unit = { + val config = system.settings.config + withClue(s"Config [$first] did not equal [$second]!") { + config.getConfig(first) should ===(config.getConfig(second)) + } + } +} \ No newline at end of file From cad852025d358cabdbaa6ada9e282994caa2293d Mon Sep 17 00:00:00 2001 From: Konrad Malawski Date: Fri, 25 Sep 2015 15:50:11 +0200 Subject: [PATCH 2/2] Actually implement proper cascading --- akka-docs-dev/rst/java/http/http-model.rst | 17 +- .../rst/scala/http/common/http-model.rst | 17 +- .../src/main/resources/reference.conf | 280 +++++------------- .../akka/http/ClientConnectionSettings.scala | 7 +- .../akka/http/ConnectionPoolSettings.scala | 15 +- .../main/scala/akka/http/ParserSettings.scala | 3 +- .../main/scala/akka/http/ServerSettings.scala | 6 +- .../http/impl/util/SettingsCompanion.scala | 6 +- .../http/impl/util/SocketOptionSettings.scala | 6 +- .../client/ClientConfigurationSpec.scala | 27 -- .../engine/client/HttpConfigurationSpec.scala | 141 +++++++++ .../scaladsl/server/RoutingSettings.scala | 2 +- 12 files changed, 260 insertions(+), 267 deletions(-) delete mode 100644 akka-http-core/src/test/scala/akka/http/impl/engine/client/ClientConfigurationSpec.scala create mode 100644 akka-http-core/src/test/scala/akka/http/impl/engine/client/HttpConfigurationSpec.scala diff --git a/akka-docs-dev/rst/java/http/http-model.rst b/akka-docs-dev/rst/java/http/http-model.rst index 9be44c5f3b..4c9deba41a 100644 --- a/akka-docs-dev/rst/java/http/http-model.rst +++ b/akka-docs-dev/rst/java/http/http-model.rst @@ -257,11 +257,14 @@ provided to parse (or render to) Strings or byte arrays. .. note:: Various parsing and rendering settings are available to tweak in the configuration under ``akka.http.client[.parsing]``, - ``akka.http.server[.parsing]`` and ``akka.http.host-connection-pool[.client.parsing]``. Please note that while each of - these sections expose the same parsing options, they will only be used for their respective APIs. For example, changing - a setting inside ``akka.http.client.parsing`` **does not** change the same value in ``akka.http.host-connection-pool.client.parsing``, - as they are different APIs. + ``akka.http.server[.parsing]`` and ``akka.http.host-connection-pool[.client.parsing]``, with defaults for all of these + being defined in the ``akka.http.parsing`` configuration section. - You can check which settings to tweak for which method exposed on the Http object by inspecting their ScalaDoc. - In general though it's as simple as "pool" backed services use the ``host-connection-pool`` section, other clients - which expose ``Flow`` use the ``client`` section, and the server side uses the ``server`` configuration section. \ No newline at end of file + For example, if you want to change a parsing setting for all components, you can set the ``akka.http.parsing.illegal-header-warnings = off`` + value. However this setting can be stil overriden by the more specific sections, like for example ``akka.http.server.parsing.illegal-header-warnings = on``. + In this case both ``client`` and ``host-connection-pool`` APIs will see the setting ``off``, however the server will see ``on``. + + In the case of ``akka.http.host-connection-pool.client`` settings, they default to settings set in ``akka.http.client``, + and can override them if needed. This is useful, since both ``client`` and ``host-connection-pool`` APIs, + such as the Client API ``Http.get(sys).outgoingConnection`` or the Host Connection Pool APIs ``Http.get(sys).singleRequest`` + or ``Http.get(sys).superPool``, usually need the same settings, however the ``server`` most likely has a very different set of settings. diff --git a/akka-docs-dev/rst/scala/http/common/http-model.rst b/akka-docs-dev/rst/scala/http/common/http-model.rst index 6dce80d3d9..152a0b764b 100644 --- a/akka-docs-dev/rst/scala/http/common/http-model.rst +++ b/akka-docs-dev/rst/scala/http/common/http-model.rst @@ -253,11 +253,14 @@ provided to parse (or render to) Strings or byte arrays. .. note:: Various parsing and rendering settings are available to tweak in the configuration under ``akka.http.client[.parsing]``, - ``akka.http.server[.parsing]`` and ``akka.http.host-connection-pool[.client.parsing]``. Please note that while each of - these sections expose the same parsing options, they will only be used for their respective APIs. For example, changing - a setting inside ``akka.http.client.parsing`` **does not** change the same value in ``akka.http.host-connection-pool.client.parsing``, - as they are different APIs. + ``akka.http.server[.parsing]`` and ``akka.http.host-connection-pool[.client.parsing]``, with defaults for all of these + being defined in the ``akka.http.parsing`` configuration section. - You can check which settings to tweak for which method exposed on the Http object by inspecting their ScalaDoc. - In general though it's as simple as "pool" backed services use the ``host-connection-pool`` section, other clients - which expose ``Flow`` use the ``client`` section, and the server side uses the ``server`` configuration section. \ No newline at end of file + For example, if you want to change a parsing setting for all components, you can set the ``akka.http.parsing.illegal-header-warnings = off`` + value. However this setting can be stil overriden by the more specific sections, like for example ``akka.http.server.parsing.illegal-header-warnings = on``. + In this case both ``client`` and ``host-connection-pool`` APIs will see the setting ``off``, however the server will see ``on``. + + In the case of ``akka.http.host-connection-pool.client`` settings, they default to settings set in ``akka.http.client``, + and can override them if needed. This is useful, since both ``client`` and ``host-connection-pool`` APIs, + such as the Client API ``Http().outgoingConnection`` or the Host Connection Pool APIs ``Http().singleRequest`` or ``Http().superPool``, + usually need the same settings, however the ``server`` most likely has a very different set of settings. diff --git a/akka-http-core/src/main/resources/reference.conf b/akka-http-core/src/main/resources/reference.conf index 558c216f99..34a6e5a77e 100644 --- a/akka-http-core/src/main/resources/reference.conf +++ b/akka-http-core/src/main/resources/reference.conf @@ -88,76 +88,8 @@ akka.http { } # Modify to tweak parsing settings on the server-side only. - # - # IMPORTANT: - # Please note that this section is replicated in `client` and `http-connection-pool` parsing { - # The limits for the various parts of the HTTP message parser. - max-uri-length = 2k - max-method-length = 16 - max-response-reason-length = 64 - max-header-name-length = 64 - max-header-value-length = 8k - max-header-count = 64 - max-chunk-ext-length = 256 - max-chunk-size = 1m - - # Maximum content length which should not be exceeded by incoming HttpRequests. - # For file uploads which use the entityBytes Source of an incoming HttpRequest it is safe to - # set this to a very high value (or to `infinite` if feeling very adventurous) as the streaming - # upload will be back-pressured properly by Akka Streams. - # Please note however that this setting is a global property, and is applied to all incoming requests, - # not only file uploads consumed in a streaming fashion, so pick this limit wisely. - max-content-length = 8m - - # Sets the strictness mode for parsing request target URIs. - # The following values are defined: - # - # `strict`: RFC3986-compliant URIs are required, - # a 400 response is triggered on violations - # - # `relaxed`: all visible 7-Bit ASCII chars are allowed - # - # `relaxed-with-raw-query`: like `relaxed` but additionally - # the URI query is not parsed, but delivered as one raw string - # as the `key` value of a single Query structure element. - # - uri-parsing-mode = strict - - # Enables/disables the logging of warning messages in case an incoming - # message (request or response) contains an HTTP header which cannot be - # parsed into its high-level model class due to incompatible syntax. - # Note that, independently of this settings, akka-http will accept messages - # with such headers as long as the message as a whole would still be legal - # under the HTTP specification even without this header. - # If a header cannot be parsed into a high-level model instance it will be - # provided as a `RawHeader`. - # If logging is enabled it is performed with the configured - # `error-logging-verbosity`. - illegal-header-warnings = on - - # Configures the verbosity with which message (request or response) parsing - # errors are written to the application log. - # - # Supported settings: - # `off` : no log messages are produced - # `simple`: a condensed single-line message is logged - # `full` : the full error details (potentially spanning several lines) are logged - error-logging-verbosity = full - - # limits for the number of different values per header type that the - # header cache will hold - header-cache { - default = 12 - Content-MD5 = 0 - Date = 0 - If-Match = 0 - If-Modified-Since = 0 - If-None-Match = 0 - If-Range = 0 - If-Unmodified-Since = 0 - User-Agent = 32 - } + # no overrides by default, see `akka.http.parsing` for default values } } @@ -212,76 +144,8 @@ akka.http { } # Modify to tweak parsing settings on the client-side only. - # - # IMPORTANT: - # Please note that this section is replicated in `server` and `http-connection-pool`. parsing { - # The limits for the various parts of the HTTP message parser. - max-uri-length = 2k - max-method-length = 16 - max-response-reason-length = 64 - max-header-name-length = 64 - max-header-value-length = 8k - max-header-count = 64 - max-chunk-ext-length = 256 - max-chunk-size = 1m - - # Maximum content length which should not be exceeded by incoming HttpRequests. - # For file uploads which use the entityBytes Source of an incoming HttpRequest it is safe to - # set this to a very high value (or to `infinite` if feeling very adventurous) as the streaming - # upload will be back-pressured properly by Akka Streams. - # Please note however that this setting is a global property, and is applied to all incoming requests, - # not only file uploads consumed in a streaming fashion, so pick this limit wisely. - max-content-length = 8m - - # Sets the strictness mode for parsing request target URIs. - # The following values are defined: - # - # `strict`: RFC3986-compliant URIs are required, - # a 400 response is triggered on violations - # - # `relaxed`: all visible 7-Bit ASCII chars are allowed - # - # `relaxed-with-raw-query`: like `relaxed` but additionally - # the URI query is not parsed, but delivered as one raw string - # as the `key` value of a single Query structure element. - # - uri-parsing-mode = strict - - # Enables/disables the logging of warning messages in case an incoming - # message (request or response) contains an HTTP header which cannot be - # parsed into its high-level model class due to incompatible syntax. - # Note that, independently of this settings, akka-http will accept messages - # with such headers as long as the message as a whole would still be legal - # under the HTTP specification even without this header. - # If a header cannot be parsed into a high-level model instance it will be - # provided as a `RawHeader`. - # If logging is enabled it is performed with the configured - # `error-logging-verbosity`. - illegal-header-warnings = on - - # Configures the verbosity with which message (request or response) parsing - # errors are written to the application log. - # - # Supported settings: - # `off` : no log messages are produced - # `simple`: a condensed single-line message is logged - # `full` : the full error details (potentially spanning several lines) are logged - error-logging-verbosity = full - - # limits for the number of different values per header type that the - # header cache will hold - header-cache { - default = 12 - Content-MD5 = 0 - Date = 0 - If-Match = 0 - If-Modified-Since = 0 - If-None-Match = 0 - If-Range = 0 - If-Unmodified-Since = 0 - User-Agent = 32 - } + # no overrides by default, see `akka.http.parsing` for default values } } @@ -376,74 +240,82 @@ akka.http { # IMPORTANT: Please note that this section is replicated in `client` and `server`. parsing { - # The limits for the various parts of the HTTP message parser. - max-uri-length = 2k - max-method-length = 16 - max-response-reason-length = 64 - max-header-name-length = 64 - max-header-value-length = 8k - max-header-count = 64 - max-chunk-ext-length = 256 - max-chunk-size = 1m - - # Maximum content length which should not be exceeded by incoming HttpRequests. - # For file uploads which use the entityBytes Source of an incoming HttpRequest it is safe to - # set this to a very high value (or to `infinite` if feeling very adventurous) as the streaming - # upload will be back-pressured properly by Akka Streams. - # Please note however that this setting is a global property, and is applied to all incoming requests, - # not only file uploads consumed in a streaming fashion, so pick this limit wisely. - max-content-length = 8m - - # Sets the strictness mode for parsing request target URIs. - # The following values are defined: - # - # `strict`: RFC3986-compliant URIs are required, - # a 400 response is triggered on violations - # - # `relaxed`: all visible 7-Bit ASCII chars are allowed - # - # `relaxed-with-raw-query`: like `relaxed` but additionally - # the URI query is not parsed, but delivered as one raw string - # as the `key` value of a single Query structure element. - # - uri-parsing-mode = strict - - # Enables/disables the logging of warning messages in case an incoming - # message (request or response) contains an HTTP header which cannot be - # parsed into its high-level model class due to incompatible syntax. - # Note that, independently of this settings, akka-http will accept messages - # with such headers as long as the message as a whole would still be legal - # under the HTTP specification even without this header. - # If a header cannot be parsed into a high-level model instance it will be - # provided as a `RawHeader`. - # If logging is enabled it is performed with the configured - # `error-logging-verbosity`. - illegal-header-warnings = on - - # Configures the verbosity with which message (request or response) parsing - # errors are written to the application log. - # - # Supported settings: - # `off` : no log messages are produced - # `simple`: a condensed single-line message is logged - # `full` : the full error details (potentially spanning several lines) are logged - error-logging-verbosity = full - - # limits for the number of different values per header type that the - # header cache will hold - header-cache { - default = 12 - Content-MD5 = 0 - Date = 0 - If-Match = 0 - If-Modified-Since = 0 - If-None-Match = 0 - If-Range = 0 - If-Unmodified-Since = 0 - User-Agent = 32 - } + # no overrides by default, see `akka.http.parsing` for default values } } } + # Modify to tweak default parsing settings. + # + # IMPORTANT: + # Please note that this sections settings can be overriden by the corresponding settings in: + # `akka.http.server.parsing`, `akka.http.client.parsing` or `akka.http.http-connection-pool.client.parsing`. + parsing { + # The limits for the various parts of the HTTP message parser. + max-uri-length = 2k + max-method-length = 16 + max-response-reason-length = 64 + max-header-name-length = 64 + max-header-value-length = 8k + max-header-count = 64 + max-chunk-ext-length = 256 + max-chunk-size = 1m + + # Maximum content length which should not be exceeded by incoming HttpRequests. + # For file uploads which use the entityBytes Source of an incoming HttpRequest it is safe to + # set this to a very high value (or to `infinite` if feeling very adventurous) as the streaming + # upload will be back-pressured properly by Akka Streams. + # Please note however that this setting is a global property, and is applied to all incoming requests, + # not only file uploads consumed in a streaming fashion, so pick this limit wisely. + max-content-length = 8m + + # Sets the strictness mode for parsing request target URIs. + # The following values are defined: + # + # `strict`: RFC3986-compliant URIs are required, + # a 400 response is triggered on violations + # + # `relaxed`: all visible 7-Bit ASCII chars are allowed + # + # `relaxed-with-raw-query`: like `relaxed` but additionally + # the URI query is not parsed, but delivered as one raw string + # as the `key` value of a single Query structure element. + # + uri-parsing-mode = strict + + # Enables/disables the logging of warning messages in case an incoming + # message (request or response) contains an HTTP header which cannot be + # parsed into its high-level model class due to incompatible syntax. + # Note that, independently of this settings, akka-http will accept messages + # with such headers as long as the message as a whole would still be legal + # under the HTTP specification even without this header. + # If a header cannot be parsed into a high-level model instance it will be + # provided as a `RawHeader`. + # If logging is enabled it is performed with the configured + # `error-logging-verbosity`. + illegal-header-warnings = on + + # Configures the verbosity with which message (request or response) parsing + # errors are written to the application log. + # + # Supported settings: + # `off` : no log messages are produced + # `simple`: a condensed single-line message is logged + # `full` : the full error details (potentially spanning several lines) are logged + error-logging-verbosity = full + + # limits for the number of different values per header type that the + # header cache will hold + header-cache { + default = 12 + Content-MD5 = 0 + Date = 0 + If-Match = 0 + If-Modified-Since = 0 + If-None-Match = 0 + If-Range = 0 + If-Unmodified-Since = 0 + User-Agent = 32 + } + } } diff --git a/akka-http-core/src/main/scala/akka/http/ClientConnectionSettings.scala b/akka-http-core/src/main/scala/akka/http/ClientConnectionSettings.scala index dc1aacaa74..1718e7a41f 100644 --- a/akka-http-core/src/main/scala/akka/http/ClientConnectionSettings.scala +++ b/akka-http-core/src/main/scala/akka/http/ClientConnectionSettings.scala @@ -29,14 +29,15 @@ final case class ClientConnectionSettings( } object ClientConnectionSettings extends SettingsCompanion[ClientConnectionSettings]("akka.http.client") { - def fromSubConfig(c: Config) = { + def fromSubConfig(root: Config, inner: Config) = { + val c = inner.withFallback(root.getConfig(prefix)) apply( c.getString("user-agent-header").toOption.map(`User-Agent`(_)), c getFiniteDuration "connecting-timeout", c getPotentiallyInfiniteDuration "idle-timeout", c getIntBytes "request-header-size-hint", - SocketOptionSettings fromSubConfig c.getConfig("socket-options"), - ParserSettings fromSubConfig c.getConfig("parsing")) + SocketOptionSettings.fromSubConfig(root, c.getConfig("socket-options")), + ParserSettings.fromSubConfig(root, c.getConfig("parsing"))) } /** diff --git a/akka-http-core/src/main/scala/akka/http/ConnectionPoolSettings.scala b/akka-http-core/src/main/scala/akka/http/ConnectionPoolSettings.scala index 95f8a2c0b3..b990bd4383 100644 --- a/akka-http-core/src/main/scala/akka/http/ConnectionPoolSettings.scala +++ b/akka-http-core/src/main/scala/akka/http/ConnectionPoolSettings.scala @@ -5,15 +5,14 @@ package akka.http import java.lang.{ Iterable ⇒ JIterable } -import akka.http.scaladsl.HttpsContext -import com.typesafe.config.Config -import scala.collection.immutable -import scala.concurrent.duration.Duration -import akka.japi.Util._ + import akka.actor.ActorSystem import akka.event.LoggingAdapter import akka.http.impl.util._ -import akka.io.Inet +import akka.http.scaladsl.HttpsContext +import com.typesafe.config.Config + +import scala.concurrent.duration.Duration final case class HostConnectionPoolSetup(host: String, port: Int, setup: ConnectionPoolSetup) @@ -46,14 +45,14 @@ final case class ConnectionPoolSettings( } object ConnectionPoolSettings extends SettingsCompanion[ConnectionPoolSettings]("akka.http.host-connection-pool") { - def fromSubConfig(c: Config) = { + def fromSubConfig(root: Config, c: Config) = { apply( c getInt "max-connections", c getInt "max-retries", c getInt "max-open-requests", c getInt "pipelining-limit", c getPotentiallyInfiniteDuration "idle-timeout", - ClientConnectionSettings fromSubConfig c.getConfig("client")) + ClientConnectionSettings.fromSubConfig(root, c.getConfig("client"))) } /** diff --git a/akka-http-core/src/main/scala/akka/http/ParserSettings.scala b/akka-http-core/src/main/scala/akka/http/ParserSettings.scala index 99b74b19a6..9d08dd499a 100644 --- a/akka-http-core/src/main/scala/akka/http/ParserSettings.scala +++ b/akka-http-core/src/main/scala/akka/http/ParserSettings.scala @@ -55,7 +55,8 @@ final case class ParserSettings( } object ParserSettings extends SettingsCompanion[ParserSettings]("akka.http.parsing") { - def fromSubConfig(c: Config) = { + def fromSubConfig(root: Config, inner: Config) = { + val c = inner.withFallback(root.getConfig(prefix)) val cacheConfig = c getConfig "header-cache" apply( diff --git a/akka-http-core/src/main/scala/akka/http/ServerSettings.scala b/akka-http-core/src/main/scala/akka/http/ServerSettings.scala index baba8b8152..e1d4a3197a 100644 --- a/akka-http-core/src/main/scala/akka/http/ServerSettings.scala +++ b/akka-http-core/src/main/scala/akka/http/ServerSettings.scala @@ -45,7 +45,7 @@ object ServerSettings extends SettingsCompanion[ServerSettings]("akka.http.serve } implicit def timeoutsShortcut(s: ServerSettings): Timeouts = s.timeouts - def fromSubConfig(c: Config) = apply( + def fromSubConfig(root: Config, c: Config) = apply( c.getString("server-header").toOption.map(Server(_)), Timeouts( c getPotentiallyInfiniteDuration "idle-timeout", @@ -57,7 +57,7 @@ object ServerSettings extends SettingsCompanion[ServerSettings]("akka.http.serve c getBoolean "verbose-error-messages", c getIntBytes "response-header-size-hint", c getInt "backlog", - SocketOptionSettings fromSubConfig c.getConfig("socket-options"), + SocketOptionSettings.fromSubConfig(root, c.getConfig("socket-options")), defaultHostHeader = HttpHeader.parse("Host", c getString "default-host-header") match { case HttpHeader.ParsingResult.Ok(x: Host, Nil) ⇒ x @@ -65,7 +65,7 @@ object ServerSettings extends SettingsCompanion[ServerSettings]("akka.http.serve val info = result.errors.head.withSummary("Configured `default-host-header` is illegal") throw new ConfigurationException(info.formatPretty) }, - ParserSettings fromSubConfig c.getConfig("parsing")) + ParserSettings.fromSubConfig(root, c.getConfig("parsing"))) def apply(optionalSettings: Option[ServerSettings])(implicit actorRefFactory: ActorRefFactory): ServerSettings = optionalSettings getOrElse apply(actorSystem) diff --git a/akka-http-core/src/main/scala/akka/http/impl/util/SettingsCompanion.scala b/akka-http-core/src/main/scala/akka/http/impl/util/SettingsCompanion.scala index 0d3069f084..0b17652f46 100644 --- a/akka-http-core/src/main/scala/akka/http/impl/util/SettingsCompanion.scala +++ b/akka-http-core/src/main/scala/akka/http/impl/util/SettingsCompanion.scala @@ -15,7 +15,7 @@ import akka.actor.ActorSystem /** * INTERNAL API */ -private[http] abstract class SettingsCompanion[T](prefix: String) { +private[http] abstract class SettingsCompanion[T](protected val prefix: String) { private final val MaxCached = 8 private[this] var cache = ListMap.empty[ActorSystem, T] @@ -41,9 +41,9 @@ private[http] abstract class SettingsCompanion[T](prefix: String) { .withFallback(defaultReference(getClass.getClassLoader))) def apply(config: Config): T = - fromSubConfig(config getConfig prefix) + fromSubConfig(config, config getConfig prefix) - def fromSubConfig(c: Config): T + def fromSubConfig(root: Config, c: Config): T } private[http] object SettingsCompanion { diff --git a/akka-http-core/src/main/scala/akka/http/impl/util/SocketOptionSettings.scala b/akka-http-core/src/main/scala/akka/http/impl/util/SocketOptionSettings.scala index d79e02e6f1..f07d29c182 100644 --- a/akka-http-core/src/main/scala/akka/http/impl/util/SocketOptionSettings.scala +++ b/akka-http-core/src/main/scala/akka/http/impl/util/SocketOptionSettings.scala @@ -12,11 +12,11 @@ import akka.io.Inet.SocketOption import com.typesafe.config.Config private[http] object SocketOptionSettings { - def fromSubConfig(config: Config): immutable.Traversable[SocketOption] = { + def fromSubConfig(root: Config, c: Config): immutable.Traversable[SocketOption] = { def so[T](setting: String)(f: (Config, String) ⇒ T)(cons: T ⇒ SocketOption): List[SocketOption] = - config.getString(setting) match { + c.getString(setting) match { case "undefined" ⇒ Nil - case x ⇒ cons(f(config, setting)) :: Nil + case x ⇒ cons(f(c, setting)) :: Nil } so("so-receive-buffer-size")(_ getIntBytes _)(Inet.SO.ReceiveBufferSize) ::: diff --git a/akka-http-core/src/test/scala/akka/http/impl/engine/client/ClientConfigurationSpec.scala b/akka-http-core/src/test/scala/akka/http/impl/engine/client/ClientConfigurationSpec.scala deleted file mode 100644 index 3966940314..0000000000 --- a/akka-http-core/src/test/scala/akka/http/impl/engine/client/ClientConfigurationSpec.scala +++ /dev/null @@ -1,27 +0,0 @@ -/* - * Copyright (C) 2009-2014 Typesafe Inc. - */ - -package akka.http.impl.engine.client - -import akka.stream.testkit.AkkaSpec - -class ClientConfigurationSpec extends AkkaSpec { - "Reference configurations" should { - for { - (first, second) ← "akka.http.client" -> "akka.http.host-connection-pool.client" :: - "akka.http.client.parsing" -> "akka.http.host-connection-pool.client.parsing" :: - "akka.http.server.parsing" -> "akka.http.client.parsing" :: - Nil - } s"be consistent for: `$first` and `$second`" in { - configShouldBeEqual("akka.http.client.parsing", "akka.http.host-connection-pool.client.parsing") - } - } - - private def configShouldBeEqual(first: String, second: String): Unit = { - val config = system.settings.config - withClue(s"Config [$first] did not equal [$second]!") { - config.getConfig(first) should ===(config.getConfig(second)) - } - } -} \ No newline at end of file diff --git a/akka-http-core/src/test/scala/akka/http/impl/engine/client/HttpConfigurationSpec.scala b/akka-http-core/src/test/scala/akka/http/impl/engine/client/HttpConfigurationSpec.scala new file mode 100644 index 0000000000..fb8699ebc9 --- /dev/null +++ b/akka-http-core/src/test/scala/akka/http/impl/engine/client/HttpConfigurationSpec.scala @@ -0,0 +1,141 @@ +/* + * Copyright (C) 2009-2014 Typesafe Inc. + */ + +package akka.http.impl.engine.client + +import akka.actor.ActorSystem +import akka.http.{ ClientConnectionSettings, ConnectionPoolSettings, ServerSettings } +import akka.stream.testkit.AkkaSpec +import com.typesafe.config.ConfigFactory + +class HttpConfigurationSpec extends AkkaSpec { + + val On = true + val Off = false + + "Reference configurations" should { + "have default client and server `parsing` settings" in { + ServerSettings(system).parserSettings.toString should ===(ClientConnectionSettings(system).parserSettings.toString) + } + "have default client and pool `parsing` settings" in { + ServerSettings(system).parserSettings.toString should ===(ConnectionPoolSettings(system).connectionSettings.parserSettings.toString) + } + "have default client and pool `client` settings" in { + ClientConnectionSettings(system).toString should ===(ConnectionPoolSettings(system).connectionSettings.toString) + } + + "override value from `akka.http.parsing` by setting `akka.http.client.parsing`" in { + configuredSystem("""akka.http.client.parsing.illegal-header-warnings = off""") { sys ⇒ + val client = ClientConnectionSettings(sys) + client.parserSettings.illegalHeaderWarnings should ===(Off) + + val pool = ConnectionPoolSettings(sys) + pool.connectionSettings.parserSettings.illegalHeaderWarnings should ===(Off) + + val server = ServerSettings(sys) + server.parserSettings.illegalHeaderWarnings should ===(On) + } + } + + "override `akka.http.parsing` by setting `akka.http.host-connection-pool.client.parsing` setting" in { + configuredSystem("""akka.http.host-connection-pool.client.parsing.illegal-header-warnings = off""") { sys ⇒ + val client = ClientConnectionSettings(sys) + client.parserSettings.illegalHeaderWarnings should ===(On) + + val pool = ConnectionPoolSettings(sys) + pool.connectionSettings.parserSettings.illegalHeaderWarnings should ===(Off) + + val server = ServerSettings(sys) + server.parserSettings.illegalHeaderWarnings should ===(On) + } + } + + "set `akka.http.host-connection-pool.client.idle-timeout` only" in { + configuredSystem("""akka.http.host-connection-pool.client.idle-timeout = 1337s""") { sys ⇒ + import scala.concurrent.duration._ + + val client = ClientConnectionSettings(sys) + client.idleTimeout should ===(60.seconds) + + val pool = ConnectionPoolSettings(sys) + pool.connectionSettings.idleTimeout should ===(1337.seconds) + + val server = ServerSettings(sys) + server.idleTimeout should ===(60.seconds) // no change, default akka.http.server.idle-timeout + } + } + "set `akka.http.server.idle-timeout` only" in { + configuredSystem("""akka.http.server.idle-timeout = 1337s""") { sys ⇒ + import scala.concurrent.duration._ + + val client = ClientConnectionSettings(sys) + client.idleTimeout should ===(60.seconds) + + val pool = ConnectionPoolSettings(sys) + pool.connectionSettings.idleTimeout should ===(60.seconds) + + val server = ServerSettings(sys) + server.idleTimeout should ===(1337.seconds) + } + } + + "change parser settings for all by setting `akka.http.parsing`" in { + configuredSystem("""akka.http.parsing.illegal-header-warnings = off""") { sys ⇒ + val client = ClientConnectionSettings(sys) + client.parserSettings.illegalHeaderWarnings should ===(Off) + + val pool = ConnectionPoolSettings(sys) + pool.connectionSettings.parserSettings.illegalHeaderWarnings should ===(Off) + + val server = ServerSettings(sys) + server.parserSettings.illegalHeaderWarnings should ===(Off) + } + } + + "change parser settings for all by setting `akka.http.parsing`, unless client/server override it" in { + configuredSystem(""" + akka.http { + parsing.illegal-header-warnings = off + server.parsing.illegal-header-warnings = on + client.parsing.illegal-header-warnings = on // also affects host-connection-pool.client + }""") { sys ⇒ + val client = ClientConnectionSettings(sys) + client.parserSettings.illegalHeaderWarnings should ===(On) + + val pool = ConnectionPoolSettings(sys) + pool.connectionSettings.parserSettings.illegalHeaderWarnings should ===(On) + + val server = ServerSettings(sys) + server.parserSettings.illegalHeaderWarnings should ===(On) + } + } + + "change parser settings for all by setting `akka.http.parsing`, unless all override it" in { + configuredSystem(""" + akka.http { + parsing.illegal-header-warnings = off + server.parsing.illegal-header-warnings = on + client.parsing.illegal-header-warnings = on + host-connection-pool.client.parsing.illegal-header-warnings = off + }""") { sys ⇒ + val client = ClientConnectionSettings(sys) + client.parserSettings.illegalHeaderWarnings should ===(On) + + val pool = ConnectionPoolSettings(sys) + pool.connectionSettings.parserSettings.illegalHeaderWarnings should ===(Off) + + val server = ServerSettings(sys) + server.parserSettings.illegalHeaderWarnings should ===(On) + } + } + } + + def configuredSystem(overrides: String)(block: ActorSystem ⇒ Unit) = { + val config = ConfigFactory.parseString(overrides).withFallback(ConfigFactory.load()) + // we go via ActorSystem in order to hit the settings caching infrastructure + val sys = ActorSystem("config-testing", config) + try block(sys) finally sys.shutdown() + } + +} \ No newline at end of file diff --git a/akka-http/src/main/scala/akka/http/scaladsl/server/RoutingSettings.scala b/akka-http/src/main/scala/akka/http/scaladsl/server/RoutingSettings.scala index 7fbd156524..fe88fc878f 100644 --- a/akka-http/src/main/scala/akka/http/scaladsl/server/RoutingSettings.scala +++ b/akka-http/src/main/scala/akka/http/scaladsl/server/RoutingSettings.scala @@ -18,7 +18,7 @@ case class RoutingSettings( fileIODispatcher: String) object RoutingSettings extends SettingsCompanion[RoutingSettings]("akka.http.routing") { - def fromSubConfig(c: Config) = apply( + def fromSubConfig(root: Config, c: Config) = apply( c getBoolean "verbose-error-messages", c getBoolean "file-get-conditional", c getBoolean "render-vanity-footer",