Obtain Response URL

[0xifarouk]

how can I get the response url?
in URLSession we can say:

let (data, response) = try await URLSession.shared.data(for: request)
print(response.url)

how to do that using AsyncHttpClient?

[Lukasa]

Unfortunately, this information is not exposed today. We'd need some new API surface on the response to expose it, which in my view should also expose the rest of the redirect history.

[gregcotten]

This is particularly bumpy problem when trying to replace URLSession with async-http-client. @Lukasa do you have any ideas on where this API surface should go?

[Lukasa]

Response would be a fine place to put it, I think.

[gregcotten]

Unfortunately, this information is not exposed today. We'd need some new API surface on the response to expose it, which in my view should also expose the rest of the redirect history.

@Lukasa, I'll probably take a stab at this.

In Response, would we want a simple list of URLs?

var visitedURLs: [String]

var url: String? {
     get {
          self.visitedURLs.last
     }
}

or actually pairing a url with its corresponding HTTPResponseHead

var visitedURLs: [(url: String, head: HTTPResponseHead)]

or something really wild

var visitedURLs: [(request: HTTPClient.Request, head: HTTPResponseHead)]

[Lukasa]

So we should definitely avoid using a non-nominal type here, so I think the tuples are out: they will be hard to evolve if we want to add other things.

I wonder if we should go whole-hog and offer:

var history: [RedirectedRequest]

struct RedirectedRequest {
    var request: HTTPClient.Request
    var response: HTTPResponseHead
}

[gregcotten]

So we should definitely avoid using a non-nominal type here, so I think the tuples are out: they will be hard to evolve if we want to add other things.

I wonder if we should go whole-hog and offer:

var history: [RedirectedRequest]

struct RedirectedRequest {
var request: HTTPClient.Request
var response: HTTPResponseHead
}

That could work! There are some cases where we would have no history (for example, no redirects occur), and we'd still want to be able to access the URL of the response (as desired in this issue).

We could rename this struct something like RequestResult or VisitedURL, and always store the "ultimate" request/response as the last one so we can have some nice API like:

/// The target URL after redirects
var url: URL? {
   get {
      self.history.last?.request.url
   }
}

Another cause for concern: none of the HTTPClientResponseDelegate methods actually pass a HTTPClient.Request with a corresponding HTTPResponseHead, nor do they ever call existing delegate methods if the Task is simply redirecting. We would probably need to design a new delegate method that is called for every request/response including redirects. What should we name it?

func didReceiveHead(task: HTTPClient.Task<Response>, _ head: HTTPResponseHead, _ request: HTTPClient.Request) -> EventLoopFuture<Void>

Would we need the EventLoopFuture<Void>?

[Lukasa]

Your proposal generally sounds reasonable.

Extending the delegate should probably be done in a separate PR to avoid making the size get out of hand, as it will require somewhat meaningful surgery and testing. The name you propose is fine, but we do still want it to return a Future to enable delaying the I/O.