From 244c52c226b4793d9b20408b669f99343ece0f2a Mon Sep 17 00:00:00 2001 From: Konrad Malawski Date: Thu, 21 Jan 2016 18:44:12 +0200 Subject: [PATCH] !htc #19514 more case class => class boilerplate --- .../akka/http/ClientConnectionSettings.scala | 47 ++++++++ .../akka/http/ConnectionPoolSettings.scala | 42 ++++++++ .../main/scala/akka/http/ParserSettings.scala | 60 ++++++++++- .../main/scala/akka/http/ServerSettings.scala | 101 ++++++++++++++++++ .../engine/client/ConnectionPoolSpec.scala | 2 +- .../scaladsl/server/RoutingSettings.scala | 30 ++++++ 6 files changed, 280 insertions(+), 2 deletions(-) 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 9d147e6c8a..cfbcd4aedc 100644 --- a/akka-http-core/src/main/scala/akka/http/ClientConnectionSettings.scala +++ b/akka-http-core/src/main/scala/akka/http/ClientConnectionSettings.scala @@ -30,6 +30,35 @@ final class ClientConnectionSettings( require(connectingTimeout >= Duration.Zero, "connectingTimeout must be >= 0") require(requestHeaderSizeHint > 0, "request-size-hint must be > 0") + + def copy( + userAgentHeader: Option[`User-Agent`] = userAgentHeader, + connectingTimeout: FiniteDuration = connectingTimeout, + idleTimeout: Duration = idleTimeout, + requestHeaderSizeHint: Int = requestHeaderSizeHint, + websocketRandomFactory: () ⇒ Random = websocketRandomFactory, + socketOptions: immutable.Traversable[SocketOption] = socketOptions, + parserSettings: ParserSettings = parserSettings) = + new ClientConnectionSettings( + userAgentHeader = userAgentHeader, + connectingTimeout = connectingTimeout, + idleTimeout = idleTimeout, + requestHeaderSizeHint = requestHeaderSizeHint, + websocketRandomFactory = websocketRandomFactory, + socketOptions = socketOptions, + parserSettings = parserSettings) + + override def toString = { + getClass.getSimpleName + "(" + + userAgentHeader + "," + + connectingTimeout + "," + + idleTimeout + "," + + requestHeaderSizeHint + "," + + websocketRandomFactory + "," + + socketOptions + "," + + parserSettings + "," + + ")" + } } object ClientConnectionSettings extends SettingsCompanion[ClientConnectionSettings]("akka.http.client") { @@ -68,4 +97,22 @@ object ClientConnectionSettings extends SettingsCompanion[ClientConnectionSettin * Java API */ def create(configOverrides: String): ClientConnectionSettings = ClientConnectionSettings(configOverrides) + + def apply( + userAgentHeader: Option[`User-Agent`], + connectingTimeout: FiniteDuration, + idleTimeout: Duration, + requestHeaderSizeHint: Int, + websocketRandomFactory: () ⇒ Random, + socketOptions: immutable.Traversable[SocketOption], + parserSettings: ParserSettings) = + new ClientConnectionSettings( + userAgentHeader = userAgentHeader, + connectingTimeout = connectingTimeout, + idleTimeout = idleTimeout, + requestHeaderSizeHint = requestHeaderSizeHint, + websocketRandomFactory = websocketRandomFactory, + socketOptions = socketOptions, + parserSettings = parserSettings) + } \ No newline at end of file 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 c1bbc94ceb..6d7f861c59 100644 --- a/akka-http-core/src/main/scala/akka/http/ConnectionPoolSettings.scala +++ b/akka-http-core/src/main/scala/akka/http/ConnectionPoolSettings.scala @@ -40,6 +40,33 @@ final class ConnectionPoolSettings( 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, "idle-timeout must be >= 0") + + def copy( + maxConnections: Int = maxConnections, + maxRetries: Int = maxRetries, + maxOpenRequests: Int = maxOpenRequests, + pipeliningLimit: Int = pipeliningLimit, + idleTimeout: Duration = idleTimeout, + connectionSettings: ClientConnectionSettings = connectionSettings) = + new ConnectionPoolSettings( + maxConnections = maxConnections, + maxRetries = maxRetries, + maxOpenRequests = maxOpenRequests, + pipeliningLimit = pipeliningLimit, + idleTimeout = idleTimeout, + connectionSettings = connectionSettings) + + // TODO we should automate generating those + override def toString = { + getClass.getSimpleName + "(" + + maxConnections + "," + + maxRetries + "," + + maxOpenRequests + "," + + pipeliningLimit + "," + + idleTimeout + "," + + connectionSettings + + ")" + } } object ConnectionPoolSettings extends SettingsCompanion[ConnectionPoolSettings]("akka.http.host-connection-pool") { @@ -76,4 +103,19 @@ object ConnectionPoolSettings extends SettingsCompanion[ConnectionPoolSettings]( * Java API */ def create(configOverrides: String): ConnectionPoolSettings = ConnectionPoolSettings(configOverrides) + + def apply( + maxConnections: Int, + maxRetries: Int, + maxOpenRequests: Int, + pipeliningLimit: Int, + idleTimeout: Duration, + connectionSettings: ClientConnectionSettings) = + new ConnectionPoolSettings( + maxConnections: Int, + maxRetries: Int, + maxOpenRequests: Int, + pipeliningLimit: Int, + idleTimeout: Duration, + connectionSettings: ClientConnectionSettings) } \ No newline at end of file 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 545ef85c15..ea369d8a41 100644 --- a/akka-http-core/src/main/scala/akka/http/ParserSettings.scala +++ b/akka-http-core/src/main/scala/akka/http/ParserSettings.scala @@ -90,6 +90,29 @@ final class ParserSettings( includeTlsSessionInfoHeader, customMethods, customStatusCodes) + + // TODO we should automate generating those + override def toString = { + getClass.getSimpleName + "(" + + maxUriLength + "," + + maxMethodLength + "," + + maxResponseReasonLength + "," + + maxHeaderNameLength + "," + + maxHeaderValueLength + "," + + maxHeaderCount + "," + + maxContentLength + "," + + maxChunkExtLength + "," + + maxChunkSize + "," + + uriParsingMode + "," + + cookieParsingMode + "," + + illegalHeaderWarnings + "," + + errorLoggingVerbosity + "," + + headerValueCacheLimits + "," + + includeTlsSessionInfoHeader + "," + + customMethods + "," + + customStatusCodes + + ")" + } } object ParserSettings extends SettingsCompanion[ParserSettings]("akka.http.parsing") { @@ -97,7 +120,7 @@ object ParserSettings extends SettingsCompanion[ParserSettings]("akka.http.parsi val c = inner.withFallback(root.getConfig(prefix)) val cacheConfig = c getConfig "header-cache" - new ParserSettings( + ParserSettings( c getIntBytes "max-uri-length", c getIntBytes "max-method-length", c getIntBytes "max-response-reason-length", @@ -169,5 +192,40 @@ object ParserSettings extends SettingsCompanion[ParserSettings]("akka.http.parsi implicit def default(implicit refFactory: ActorRefFactory): ParserSettings = apply(actorSystem) + + def apply(maxUriLength: Int, + maxMethodLength: Int, + maxResponseReasonLength: Int, + maxHeaderNameLength: Int, + maxHeaderValueLength: Int, + maxHeaderCount: Int, + maxContentLength: Long, + maxChunkExtLength: Int, + maxChunkSize: Int, + uriParsingMode: Uri.ParsingMode, + cookieParsingMode: ParserSettings.CookieParsingMode, + illegalHeaderWarnings: Boolean, + errorLoggingVerbosity: ParserSettings.ErrorLoggingVerbosity, + headerValueCacheLimits: Map[String, Int], + includeTlsSessionInfoHeader: Boolean, + customMethods: String ⇒ Option[HttpMethod], + customStatusCodes: Int ⇒ Option[StatusCode]): ParserSettings = + new ParserSettings(maxUriLength, + maxMethodLength, + maxResponseReasonLength, + maxHeaderNameLength, + maxHeaderValueLength, + maxHeaderCount, + maxContentLength, + maxChunkExtLength, + maxChunkSize, + uriParsingMode, + cookieParsingMode, + illegalHeaderWarnings, + errorLoggingVerbosity, + headerValueCacheLimits, + includeTlsSessionInfoHeader, + customMethods, + customStatusCodes) } 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 bd5c826c4d..fee85addaf 100644 --- a/akka-http-core/src/main/scala/akka/http/ServerSettings.scala +++ b/akka-http-core/src/main/scala/akka/http/ServerSettings.scala @@ -42,6 +42,58 @@ final class ServerSettings( require(0 < pipeliningLimit && pipeliningLimit <= 1024, "pipelining-limit must be > 0 and <= 1024") require(0 < responseHeaderSizeHint, "response-size-hint must be > 0") require(0 < backlog, "backlog must be > 0") + + def copy( + serverHeader: Option[Server] = serverHeader, + timeouts: ServerSettings.Timeouts = timeouts, + maxConnections: Int = maxConnections, + pipeliningLimit: Int = pipeliningLimit, + remoteAddressHeader: Boolean = remoteAddressHeader, + rawRequestUriHeader: Boolean = rawRequestUriHeader, + transparentHeadRequests: Boolean = transparentHeadRequests, + verboseErrorMessages: Boolean = verboseErrorMessages, + responseHeaderSizeHint: Int = responseHeaderSizeHint, + backlog: Int = backlog, + socketOptions: immutable.Traversable[SocketOption] = socketOptions, + defaultHostHeader: Host = defaultHostHeader, + websocketRandomFactory: () ⇒ Random = websocketRandomFactory, + parserSettings: ParserSettings = parserSettings) = + new ServerSettings( + serverHeader = serverHeader, + timeouts = timeouts, + maxConnections = maxConnections, + pipeliningLimit = pipeliningLimit, + remoteAddressHeader = remoteAddressHeader, + rawRequestUriHeader = rawRequestUriHeader, + transparentHeadRequests = transparentHeadRequests, + verboseErrorMessages = verboseErrorMessages, + responseHeaderSizeHint = responseHeaderSizeHint, + backlog = backlog, + socketOptions = socketOptions, + defaultHostHeader = defaultHostHeader, + websocketRandomFactory = websocketRandomFactory, + parserSettings = parserSettings) + + // TODO we should automate generating those + override def toString: String = { + getClass.getSimpleName + "(" + + serverHeader + "," + + timeouts + "," + + maxConnections + "," + + pipeliningLimit + "," + + remoteAddressHeader + "," + + rawRequestUriHeader + "," + + transparentHeadRequests + "," + + verboseErrorMessages + "," + + responseHeaderSizeHint + "," + + backlog + "," + + socketOptions + "," + + defaultHostHeader + "," + + websocketRandomFactory + "," + + parserSettings + "," + + ")" + } + } object ServerSettings extends SettingsCompanion[ServerSettings]("akka.http.server") { @@ -52,6 +104,23 @@ object ServerSettings extends SettingsCompanion[ServerSettings]("akka.http.serve require(idleTimeout > Duration.Zero, "idleTimeout must be infinite or > 0") require(requestTimeout > Duration.Zero, "requestTimeout must be infinite or > 0") require(bindTimeout > Duration.Zero, "bindTimeout must be > 0") + + def copy( + idleTimeout: Duration = idleTimeout, + requestTimeout: Duration = requestTimeout, + bindTimeout: FiniteDuration = bindTimeout) = + new Timeouts( + idleTimeout, + requestTimeout, + bindTimeout) + + override def toString = { + "Timeouts(" + + idleTimeout + "," + + requestTimeout + "," + + bindTimeout + "," + + ")" + } } implicit def timeoutsShortcut(s: ServerSettings): Timeouts = s.timeouts @@ -106,5 +175,37 @@ object ServerSettings extends SettingsCompanion[ServerSettings]("akka.http.serve * Java API */ def create(configOverrides: String): ServerSettings = ServerSettings(configOverrides) + + def apply( + serverHeader: Option[Server], + timeouts: ServerSettings.Timeouts, + maxConnections: Int, + pipeliningLimit: Int, + remoteAddressHeader: Boolean, + rawRequestUriHeader: Boolean, + transparentHeadRequests: Boolean, + verboseErrorMessages: Boolean, + responseHeaderSizeHint: Int, + backlog: Int, + socketOptions: immutable.Traversable[SocketOption], + defaultHostHeader: Host, + websocketRandomFactory: () ⇒ Random, + parserSettings: ParserSettings) = + new ServerSettings( + serverHeader = serverHeader, + timeouts = timeouts, + maxConnections = maxConnections, + pipeliningLimit = pipeliningLimit, + remoteAddressHeader = remoteAddressHeader, + rawRequestUriHeader = rawRequestUriHeader, + transparentHeadRequests = transparentHeadRequests, + verboseErrorMessages = verboseErrorMessages, + responseHeaderSizeHint = responseHeaderSizeHint, + backlog = backlog, + socketOptions = socketOptions, + defaultHostHeader = defaultHostHeader, + websocketRandomFactory = websocketRandomFactory, + parserSettings = parserSettings) + } diff --git a/akka-http-core/src/test/scala/akka/http/impl/engine/client/ConnectionPoolSpec.scala b/akka-http-core/src/test/scala/akka/http/impl/engine/client/ConnectionPoolSpec.scala index 01e434f9e5..e5922936d5 100644 --- a/akka-http-core/src/test/scala/akka/http/impl/engine/client/ConnectionPoolSpec.scala +++ b/akka-http-core/src/test/scala/akka/http/impl/engine/client/ConnectionPoolSpec.scala @@ -326,7 +326,7 @@ class ConnectionPoolSpec extends AkkaSpec(""" pipeliningLimit: Int = 1, idleTimeout: Duration = 5.seconds, ccSettings: ClientConnectionSettings = ClientConnectionSettings(system)) = { - val settings = ConnectionPoolSettings(maxConnections, maxRetries, maxOpenRequests, pipeliningLimit, + val settings = new ConnectionPoolSettings(maxConnections, maxRetries, maxOpenRequests, pipeliningLimit, idleTimeout, ClientConnectionSettings(system)) flowTestBench(Http().cachedHostConnectionPool[T](serverHostName, serverPort, settings)) } 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 5d95bcd26d..a528e5276d 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 @@ -33,6 +33,19 @@ final class RoutingSettings( rangeCoalescingThreshold, decodeMaxBytesPerChunk, fileIODispatcher) + + // TODO we should automate generating those + override def toString = { + getClass.getSimpleName + "(" + + verboseErrorMessages + "," + + fileGetConditional + "," + + renderVanityFooter + "," + + rangeCountLimit + "," + + rangeCoalescingThreshold + "," + + decodeMaxBytesPerChunk + "," + + fileIODispatcher + + ")" + } } object RoutingSettings extends SettingsCompanion[RoutingSettings]("akka.http.routing") { @@ -47,4 +60,21 @@ object RoutingSettings extends SettingsCompanion[RoutingSettings]("akka.http.rou implicit def default(implicit refFactory: ActorRefFactory): RoutingSettings = apply(actorSystem) + + def apply( + verboseErrorMessages: Boolean, + fileGetConditional: Boolean, + renderVanityFooter: Boolean, + rangeCountLimit: Int, + rangeCoalescingThreshold: Long, + decodeMaxBytesPerChunk: Int, + fileIODispatcher: String): RoutingSettings = + new RoutingSettings( + verboseErrorMessages, + fileGetConditional, + renderVanityFooter, + rangeCountLimit, + rangeCoalescingThreshold, + decodeMaxBytesPerChunk, + fileIODispatcher) }