sync capy and corosio changes

include/boost/burl/detail/circular_buffer.hpp

@@ -41,6 +41,9 @@ struct circular_buffer
     std::array<capy::const_buffer, 2>
     data() const noexcept;
 
+    capy::const_buffer
+    first(std::size_t n) const noexcept;
+
     std::array<capy::mutable_buffer, 2>
     prepare() const noexcept;
 

include/boost/burl/detail/connection_pool.hpp

@@ -16,7 +16,6 @@
 #include <boost/capy/detail/buffer_array.hpp>
 #include <boost/capy/io/any_stream.hpp>
 #include <boost/capy/io_task.hpp>
-#include <boost/capy/timeout.hpp>
 
 #include <chrono>
 #include <cstddef>
@@ -38,30 +37,21 @@ class connection_pool;
 class connection
 {
     using duration = std::chrono::steady_clock::duration;
-
-    capy::detail::buffer_array<8, false> rba_; // TODO
-    capy::detail::buffer_array<8, true> wba_;  // TODO
     std::optional<duration> io_timeout_;
 
 public:
     template<capy::MutableBufferSequence MB>
     capy::io_task<std::size_t>
     read_some(MB buffers)
     {
-        rba_ = buffers;
-        if(io_timeout_)
-            return capy::timeout(do_read_some(rba_), *io_timeout_);
-        return do_read_some(rba_);
+        return read_some_impl(buffers);
     }
 
     template<capy::ConstBufferSequence CB>
     capy::io_task<std::size_t>
     write_some(CB buffers)
     {
-        wba_ = buffers;
-        if(io_timeout_)
-            return capy::timeout(do_write_some(wba_), *io_timeout_);
-        return do_write_some(wba_);
+        return write_some_impl(buffers);
     }
 
     void
@@ -79,6 +69,12 @@ class connection
     virtual ~connection() = default;
 
 private:
+    capy::io_task<std::size_t>
+    read_some_impl(capy::detail::mutable_buffer_array<8>);
+
+    capy::io_task<std::size_t>
+    write_some_impl(capy::detail::const_buffer_array<8>);
+
     virtual capy::io_task<std::size_t>
     do_read_some(std::span<capy::mutable_buffer const> buffers) = 0;
 

include/boost/burl/detail/parser.hpp

@@ -23,7 +23,6 @@
 #include <boost/http/header_limits.hpp>
 #include <boost/http/static_response.hpp>
 #include <boost/http/static_request.hpp>
-#include <boost/compat/function_ref.hpp>
 
 #include <memory>
 
@@ -132,6 +131,8 @@ class parser
     get_request() const;
 
 private:
+    struct chunk_fn;
+
     std::size_t
     raw_limit_rem() const noexcept;
 
@@ -151,10 +152,7 @@ class parser
     refill();
 
     std::error_code
-    walk_chunks(
-        compat::function_ref<capy::io_result<std::size_t>(
-            capy::const_buffer, bool last)> f,
-        bool dry = false);
+    walk_chunks(chunk_fn f, bool dry = false);
 
     std::error_code
     flatten_chunks();

include/boost/burl/response.hpp

@@ -19,6 +19,7 @@
 #include <boost/capy/io/any_buffer_source.hpp>
 #include <boost/capy/io/any_read_source.hpp>
 #include <boost/capy/io_task.hpp>
+#include <boost/corosio/timeout.hpp>
 #include <boost/http/fields_base.hpp>
 #include <boost/http/metadata.hpp>
 #include <boost/http/status.hpp>
@@ -332,18 +333,17 @@ class response
     {
         if(deadline_)
         {
-            auto dur = *deadline_ - clock::now();
-            if(dur <= clock::duration::zero())
-                return []() -> capy::io_task<T>
-                {
-                    co_return { capy::error::timeout, {} };
-                }();
-            return capy::timeout(
+            co_return co_await corosio::timeout(
                 tag_invoke(
-                    body_to_tag<T>{}, *this, std::forward<Args>(args)...),
-                dur);
+                    body_to_tag<T>{},
+                    *this,
+                    std::forward<Args>(args)...),
+                deadline_.value() - clock::now());
         }
-        return tag_invoke(body_to_tag<T>{}, *this, std::forward<Args>(args)...);
+        co_return co_await tag_invoke(
+            body_to_tag<T>{},
+            *this,
+            std::forward<Args>(args)...);
     }
 
     /** Asynchronously convert the body.

include/boost/burl/test/detail/buffer_connection.hpp

@@ -72,7 +72,7 @@ class buffer_connection final : public burl::detail::connection
         {
             auto const b = capy::make_buffer(head_);
             auto const n = capy::buffer_copy(
-                bufs, capy::buffer_slice(b, head_pos_).data());
+                bufs, capy::buffer_slice(b, head_pos_));
             head_pos_ += n;
             co_return { {}, n };
         }
@@ -85,7 +85,7 @@ class buffer_connection final : public burl::detail::connection
 
         auto const b = capy::make_buffer(chunks_[idx_]);
         auto const n = capy::buffer_copy(
-            bufs, capy::buffer_slice(b, pos_).data());
+            bufs, capy::buffer_slice(b, pos_));
         pos_ += n;
         if(pos_ == b.size())
         {

src/client.cpp

@@ -20,8 +20,8 @@
 
 #include <boost/capy/buffers/make_buffer.hpp>
 #include <boost/capy/ex/execution_context.hpp>
-#include <boost/capy/timeout.hpp>
 #include <boost/capy/write.hpp>
+#include <boost/corosio/timeout.hpp>
 #include <boost/burl/detail/response_parser.hpp>
 #include <boost/http/field.hpp>
 #include <boost/http/request.hpp>
@@ -178,10 +178,11 @@ client::execute(burl::request request)
     auto timeout =
         request.options.timeout ? request.options.timeout : config_.timeout;
     if(!timeout)
-        return execute_impl(std::move(request), std::nullopt);
+        co_return co_await execute_impl(std::move(request), std::nullopt);
 
     auto deadline = config::clock::now() + *timeout;
-    return capy::timeout(execute_impl(std::move(request), deadline), *timeout);
+    co_return co_await corosio::timeout(
+        execute_impl(std::move(request), deadline), *timeout);
 }
 
 capy::io_task<response>
@@ -318,7 +319,7 @@ client::execute_impl(
         }
 
         // Read and discard small bodies so the connection can be reused
-        auto [dec, drained] = co_await capy::timeout(
+        auto [dec, drained] = co_await corosio::timeout(
             detail::drain_body(parser, 3),
             std::chrono::seconds(2));
         if(drained && detail::can_reuse_conn(parser))

src/detail/circular_buffer.cpp

@@ -9,6 +9,8 @@
 
 #include <boost/burl/detail/circular_buffer.hpp>
 
+#include "util.hpp"
+
 namespace boost
 {
 namespace burl
@@ -47,6 +49,14 @@ data() const noexcept
         { ptr, len - (cap - pos) } } };
 }
 
+capy::const_buffer
+circular_buffer::
+first(std::size_t n) const noexcept
+{
+    auto const k = (pos + len <= cap) ? len : cap - pos;
+    return { ptr + pos, clamp(k, n) };
+}
+
 std::array<capy::mutable_buffer, 2>
 circular_buffer::
 prepare() const noexcept

src/detail/connection_pool.cpp

@@ -16,13 +16,13 @@
 #include "socks5_tunnel.hpp"
 
 #include <boost/capy/io/any_stream.hpp>
-#include <boost/capy/timeout.hpp>
 #include <boost/corosio/connect.hpp>
 #include <boost/corosio/openssl_stream.hpp>
 #include <boost/corosio/resolver.hpp>
 #include <boost/corosio/shutdown_type.hpp>
 #include <boost/corosio/socket_option.hpp>
 #include <boost/corosio/tcp_socket.hpp>
+#include <boost/corosio/timeout.hpp>
 #include <boost/url/scheme.hpp>
 #include <boost/url/url_view.hpp>
 
@@ -198,6 +198,26 @@ class stream_connection final : public connection
 
 } // namespace
 
+capy::io_task<std::size_t>
+connection::
+read_some_impl(capy::detail::mutable_buffer_array<8> rba)
+{
+    if(io_timeout_)
+        co_return co_await corosio::timeout(
+            do_read_some(rba), *io_timeout_);
+    co_return co_await do_read_some(rba);
+}
+
+capy::io_task<std::size_t>
+connection::
+write_some_impl(capy::detail::const_buffer_array<8> wba)
+{
+    if(io_timeout_)
+        co_return co_await corosio::timeout(
+            do_write_some(wba), *io_timeout_);
+    co_return co_await do_write_some(wba);
+}
+
 connection_pool::connection_pool(
     capy::executor_ref exec,
     corosio::tls_context tls_ctx,
@@ -234,7 +254,8 @@ connection_pool::acquire(urls::url_view url)
     }
 
     auto [ec, conn] =
-        co_await capy::timeout(connect(url), config_.connect_timeout);
+        co_await corosio::timeout(
+            connect(url), config_.connect_timeout);
     if(ec)
         co_return { ec, {} };