Change HTTPClient handler factory creation

.release-notes/106.md

@@ -0,0 +1,34 @@
+## Change HTTPClient handler factory creation
+
+The handler factory for creating handlers for new requests is now provided in the constructor of the client instead of the apply method. This makes it more clear, that the client will use the same handler for all requests.
+
+The old version would look similar to this:
+
+```pony
+let client = HTTPClient(auth)
+
+// Later
+let handler_factory = ...
+
+client(payload, handler_factory)?
+
+// Even later
+client(other_payload, other_factory)
+```
+
+In the new version the handler factory needs to be supplied at the creation of the client:
+
+```pony
+let handler_factory = ...
+let client = HTTPClient(auth, handler_factory)
+
+client(payload)
+
+// This will use the handler_factory
+client(other_payload)
+
+// To use a different handler factory, create a new client
+
+let other_client = Client(auth, other_factory)
+other_client(other_payload)
+```

examples/httpget/httpget.pony

@@ -90,13 +90,19 @@ actor _GetWork
       env.exitcode(1)
     end
 
-    // The Client manages all links.
-    let client = HTTPClient(TCPConnectAuth(env.root), consume sslctx where keepalive_timeout_secs = timeout.u32())
     // The Notify Factory will create HTTPHandlers as required.  It is
     // done this way because we do not know exactly when an HTTPSession
     // is created - they can be re-used.
     let dumpMaker = recover val NotifyFactory.create(this) end
 
+    // The Client manages all links.
+    let client = HTTPClient(
+      TCPConnectAuth(env.root),
+      dumpMaker,
+      consume sslctx
+      where keepalive_timeout_secs = timeout.u32()
+    )
+
     try
       // Start building a GET request.
       let req = Payload.request("GET", url)
@@ -119,7 +125,7 @@ actor _GetWork
       end
 
       // Submit the request
-      let sentreq = client(consume req, dumpMaker)?
+      let sentreq = client(consume req)?
 
       // Could send body data via `sentreq`, if it was a POST
     else

http/_test.pony

@@ -435,13 +435,13 @@ class \nodoc\ iso _HTTPConnTest is UnitTest
           let url = URL.build(us)?
           h.log("url.string()=" + url.string())
           let hf = _HTTPConnTestHandlerFactory(h)
-          client = recover iso HTTPClient(TCPConnectAuth(h.env.root)) end
+          client = recover iso HTTPClient(TCPConnectAuth(h.env.root), hf) end
 
           for _ in Range(0, loops) do
             let payload: Payload iso = Payload.request("GET", url)
             payload.set_length(0)
             try
-              (client as HTTPClient iso)(consume payload, hf)?
+              (client as HTTPClient iso)(consume payload)?
             end
           end
         else

http/_test_client.pony

@@ -58,16 +58,14 @@ class \nodoc\ iso _ClientStreamTransferTest is UnitTest
         try
           let client = HTTPClient(
             TCPConnectAuth(_h.env.root),
+            _StreamTransferHandlerFactory(_h),
             None
             where keepalive_timeout_secs = U32(2)
           )
           (let host, let port) = listen.local_address().name()?
           _h.log("connecting to server at " + host + ":" + port)
           let req = Payload.request("GET", URL.build("http://" + host + ":" + port  + "/bla")?)
-          client(
-            consume req,
-            _StreamTransferHandlerFactory(_h)
-          )?
+          client(consume req)?
         else
           _h.fail("request building failed")
         end

http/_test_client_error_handling.pony

@@ -53,17 +53,15 @@ class \nodoc\ iso _ConnectionClosedTest is UnitTest
         try
           let client = HTTPClient(
             TCPConnectAuth(_h.env.root),
+            _ConnectionClosedHandlerFactory(_h),
             None
             where keepalive_timeout_secs = U32(2)
           )
           (let host, let port) = listen.local_address().name()?
           let req = Payload.request("GET",
             URL.build("http://" + host + ":" + port  + "/bla")?)
           req.add_chunk("CHUNK")
-          client(
-            consume req,
-            _ConnectionClosedHandlerFactory(_h)
-          )?
+          client(consume req)?
         else
           _h.fail("request building failed")
         end
@@ -123,13 +121,14 @@ actor \nodoc\ _Connecter
     try
       let client = HTTPClient(
         TCPConnectAuth(_h.env.root),
+        _ConnectFailedHandlerFactory(_h),
         None
         where keepalive_timeout_secs = U32(2)
       )
       let req = Payload.request("GET",
         URL.build("http://" + host + ":" + port' + "/bla")?)
       req.add_chunk("CHUNK")
-      client(consume req, _ConnectFailedHandlerFactory(_h))?
+      client(consume req)?
     else
       _h.fail("request building failed")
     end
@@ -303,17 +302,15 @@ class \nodoc\ iso _SSLAuthFailedTest is UnitTest
             end
             let client = HTTPClient(
               TCPConnectAuth(_h.env.root),
+              _SSLAuthFailedHandlerFactory(_h),
               ssl_ctx
               where keepalive_timeout_secs = U32(2)
             )
             let req = Payload.request(
               "GET",
               URL.build("https://" + host + ":" + port  + "/bla")?)
             req.add_chunk("CHUNK")
-            client(
-              consume req,
-              _SSLAuthFailedHandlerFactory(_h)
-            )?
+            client(consume req)?
           else
             _h.fail("request building failed")
           end

http/http_client.pony

@@ -12,17 +12,24 @@ class HTTPClient
   let _pipeline: Bool
   let _keepalive_timeout_secs: U32
   let _sessions: Map[_HostService, _ClientConnection] = _sessions.create()
+  let _handlermaker: HandlerFactory val
 
   new create(
     auth: TCPConnectAuth,
+    handlermaker: HandlerFactory val,
     sslctx: (SSLContext | None) = None,
     pipeline: Bool = true,
     keepalive_timeout_secs: U32 = 0)
   =>
     """
-    Create the context in which all HTTP sessions will originate.
+    Create the context in which all HTTP sessions will originate. The `handlermaker`
+    is used to create the `HTTPHandler` that is applied with each received
+    payload after making a request. All requests made with one client are created
+    using the same handler factory, if you need different handlers for different
+    requests, you need to create different clients.
 
     Parameters:
+
     - keepalive_timeout_secs: Use TCP Keepalive and check if the other side is down
                               every `keepalive_timeout_secs` seconds.
     """
@@ -40,12 +47,9 @@ class HTTPClient
 
     _pipeline = pipeline
     _keepalive_timeout_secs = keepalive_timeout_secs
+    _handlermaker = handlermaker
 
-  fun ref apply(
-    request: Payload trn,
-    handlermaker: HandlerFactory val)
-    : Payload val ?
-  =>
+  fun ref apply(request: Payload trn) : Payload val ? =>
     """
     Schedule a request on an HTTP session. If a new connection is created,
     a new instance of the application's Receive Handler will be created
@@ -54,7 +58,7 @@ class HTTPClient
     This is useful in Stream and Chunked transfer modes, so that the
     application can follow up with calls to `Client.send_body`.
     """
-    let session = _get_session(request.url, handlermaker)?
+    let session = _get_session(request.url)?
     let mode = request.transfer_mode
     request.session = session
     let valrequest: Payload val = consume request
@@ -80,11 +84,7 @@ class HTTPClient
     end
 */
 
-  fun ref _get_session(
-    url: URL,
-    handlermaker: HandlerFactory val)
-    : _ClientConnection ?
-  =>
+  fun ref _get_session(url: URL) : _ClientConnection ? =>
     """
     Gets or creates an HTTP Session for the given URL. If a new session
     is created, a new Receive Handler instance is created too.
@@ -100,10 +100,10 @@ class HTTPClient
         match url.scheme
         | "http" =>
           _ClientConnection(_auth, hs.host, hs.service,
-            None, _pipeline, _keepalive_timeout_secs, handlermaker)
+            None, _pipeline, _keepalive_timeout_secs, _handlermaker)
         | "https" =>
           _ClientConnection(_auth, hs.host, hs.service,
-            _sslctx, _pipeline, _keepalive_timeout_secs, handlermaker)
+            _sslctx, _pipeline, _keepalive_timeout_secs, _handlermaker)
         else
           error
         end

http/test_netssl_105_regression.pony

@@ -40,9 +40,9 @@ class \nodoc\ iso _NetSSL105RegressionTest is UnitTest
     try
       let url = URL.build("https://echo.sacovo.ch")?
       let auth = TCPConnectAuth(h.env.root)
-      let client = HTTPClient(auth)
+      let client = HTTPClient(auth, _NetSSL105RegressionHandlerFactory(h))
       let payload = Payload.request("GET", url)
-      client.apply(consume payload, _NetSSL105RegressionHandlerFactory(h))?
+      client.apply(consume payload)?
     else
       h.fail("Unable to setup test")
     end