Commit e8ca5421 authored by Jakob Otto's avatar Jakob Otto

Refactor basp::application

parent bddef5ec
...@@ -34,6 +34,7 @@ ...@@ -34,6 +34,7 @@
#include "caf/net/basp/header.hpp" #include "caf/net/basp/header.hpp"
#include "caf/net/basp/message_type.hpp" #include "caf/net/basp/message_type.hpp"
#include "caf/net/endpoint_manager.hpp" #include "caf/net/endpoint_manager.hpp"
#include "caf/net/packet_writer.hpp"
#include "caf/net/receive_policy.hpp" #include "caf/net/receive_policy.hpp"
#include "caf/node_id.hpp" #include "caf/node_id.hpp"
#include "caf/proxy_registry.hpp" #include "caf/proxy_registry.hpp"
...@@ -77,11 +78,14 @@ public: ...@@ -77,11 +78,14 @@ public:
if (!std::is_base_of<test_tag, Parent>::value) if (!std::is_base_of<test_tag, Parent>::value)
manager_ = &parent.manager(); manager_ = &parent.manager();
// Write handshake. // Write handshake.
if (auto err = generate_handshake()) auto header_buf = parent.next_header_buffer();
auto payload_buf = parent.next_buffer();
if (auto err = generate_handshake(payload_buf))
return err; return err;
auto hdr = to_bytes(header{message_type::handshake, to_bytes(header{message_type::handshake,
static_cast<uint32_t>(buf_.size()), version}); static_cast<uint32_t>(payload_buf.size()), version},
parent.write_packet(hdr, buf_); header_buf);
parent.write_packet(header_buf, payload_buf);
parent.transport().configure_read(receive_policy::exactly(header_size)); parent.transport().configure_read(receive_policy::exactly(header_size));
return none; return none;
} }
...@@ -89,52 +93,50 @@ public: ...@@ -89,52 +93,50 @@ public:
template <class Parent> template <class Parent>
error write_message(Parent& parent, error write_message(Parent& parent,
std::unique_ptr<endpoint_manager_queue::message> ptr) { std::unique_ptr<endpoint_manager_queue::message> ptr) {
auto write_packet = make_callback([&](byte_span hdr, byte_span payload) { return write(parent, std::move(ptr));
parent.write_packet(hdr, payload);
return none;
});
return write(write_packet, std::move(ptr));
} }
template <class Parent> template <class Parent>
error handle_data(Parent& parent, byte_span bytes) { error handle_data(Parent& parent, byte_span bytes) {
auto write_packet = make_callback([&](byte_span hdr, byte_span payload) { static_assert(std::is_base_of<packet_writer, Parent>::value,
parent.write_packet(hdr, payload); "parent must implement packet_writer");
return none;
});
size_t next_read_size = header_size; size_t next_read_size = header_size;
if (auto err = handle(next_read_size, write_packet, bytes)) if (auto err = handle(next_read_size, parent, bytes))
return err; return err;
parent.transport().configure_read(receive_policy::exactly(next_read_size)); parent.transport().configure_read(receive_policy::exactly(next_read_size));
return none; return none;
} }
// TODO: unessecary indirection
template <class Parent> template <class Parent>
void resolve(Parent& parent, string_view path, actor listener) { void resolve(Parent& parent, string_view path, const actor& listener) {
auto write_packet = make_callback([&](byte_span hdr, byte_span payload) { static_assert(std::is_base_of<packet_writer, Parent>::value,
parent.write_packet(hdr, payload); "parent must implement `packet_writer`");
return none; resolve_remote_path(parent, path, listener);
});
resolve_remote_path(write_packet, path, listener);
} }
// TODO: can be packet_writer&?
template <class Parent> template <class Parent>
void new_proxy(Parent& parent, actor_id id) { void new_proxy(Parent& parent, actor_id id) {
header hdr{message_type::monitor_message, 0, static_cast<uint64_t>(id)}; header hdr{message_type::monitor_message, 0, static_cast<uint64_t>(id)};
auto bytes = to_bytes(hdr); auto header_buf = parent.next_header_buffer();
parent.write_packet(make_span(bytes), span<const byte>{}); to_bytes(hdr, header_buf);
parent.write_packet(header_buf);
} }
// TODO: can be packet_writer&?
template <class Parent> template <class Parent>
void local_actor_down(Parent& parent, actor_id id, error reason) { void local_actor_down(Parent& parent, actor_id id, error reason) {
buf_.clear(); auto header_buf = parent.next_header_buffer();
serializer_impl<buffer_type> sink{system(), buf_}; auto payload_buf = parent.next_buffer();
serializer_impl<buffer_type> sink{system(), payload_buf};
if (auto err = sink(reason)) if (auto err = sink(reason))
CAF_RAISE_ERROR("unable to serialize an error"); CAF_RAISE_ERROR("unable to serialize an error");
header hdr{message_type::down_message, static_cast<uint32_t>(buf_.size()), header hdr{message_type::down_message,
static_cast<uint32_t>(payload_buf.size()),
static_cast<uint64_t>(id)}; static_cast<uint64_t>(id)};
auto bytes = to_bytes(hdr); to_bytes(hdr, header_buf);
parent.write_packet(make_span(bytes), make_span(buf_)); parent.write_packet(header_buf, payload_buf);
} }
template <class Parent> template <class Parent>
...@@ -153,8 +155,8 @@ public: ...@@ -153,8 +155,8 @@ public:
strong_actor_ptr resolve_local_path(string_view path); strong_actor_ptr resolve_local_path(string_view path);
void resolve_remote_path(write_packet_callback& write_packet, void resolve_remote_path(packet_writer& writer, string_view path,
string_view path, actor listener); const actor& listener);
// -- properties ------------------------------------------------------------- // -- properties -------------------------------------------------------------
...@@ -169,37 +171,34 @@ public: ...@@ -169,37 +171,34 @@ public:
private: private:
// -- handling of outgoing messages ------------------------------------------ // -- handling of outgoing messages ------------------------------------------
error write(write_packet_callback& write_packet, error write(packet_writer& writer,
std::unique_ptr<endpoint_manager_queue::message> ptr); std::unique_ptr<endpoint_manager_queue::message> ptr);
// -- handling of incoming messages ------------------------------------------ // -- handling of incoming messages ------------------------------------------
error handle(size_t& next_read_size, write_packet_callback& write_packet, error handle(size_t& next_read_size, packet_writer& writer, byte_span bytes);
byte_span bytes);
error handle(write_packet_callback& write_packet, header hdr, error handle(packet_writer& writer, header hdr, byte_span payload);
byte_span payload);
error handle_handshake(write_packet_callback& write_packet, header hdr, error handle_handshake(packet_writer& writer, header hdr, byte_span payload);
byte_span payload);
error handle_actor_message(write_packet_callback& write_packet, header hdr, error handle_actor_message(packet_writer& writer, header hdr,
byte_span payload); byte_span payload);
error handle_resolve_request(write_packet_callback& write_packet, header hdr, error handle_resolve_request(packet_writer& writer, header hdr,
byte_span payload); byte_span payload);
error handle_resolve_response(write_packet_callback& write_packet, header hdr, error handle_resolve_response(packet_writer& writer, header hdr,
byte_span payload); byte_span payload);
error handle_monitor_message(write_packet_callback& write_packet, header hdr, error handle_monitor_message(packet_writer& writer, header hdr,
byte_span payload); byte_span payload);
error handle_down_message(write_packet_callback& write_packet, header hdr, error handle_down_message(packet_writer& writer, header hdr,
byte_span payload); byte_span payload);
/// Writes the handshake payload to `buf_`. /// Writes the handshake payload to `buf_`.
error generate_handshake(); error generate_handshake(std::vector<byte>& buf);
// -- member variables ------------------------------------------------------- // -- member variables -------------------------------------------------------
...@@ -212,14 +211,11 @@ private: ...@@ -212,14 +211,11 @@ private:
/// Caches the last header while waiting for the matching payload. /// Caches the last header while waiting for the matching payload.
header hdr_; header hdr_;
/// Re-usable buffer for storing payloads.
buffer_type buf_;
/// Stores the ID of our peer. /// Stores the ID of our peer.
node_id peer_id_; node_id peer_id_;
/// Tracks which local actors our peer monitors. /// Tracks which local actors our peer monitors.
std::unordered_set<actor_addr> monitored_actors_; std::unordered_set<actor_addr> monitored_actors_; // TODO: this is unused
/// Caches actor handles obtained via `resolve`. /// Caches actor handles obtained via `resolve`.
std::unordered_map<uint64_t, response_promise> pending_resolves_; std::unordered_map<uint64_t, response_promise> pending_resolves_;
......
...@@ -32,6 +32,7 @@ ...@@ -32,6 +32,7 @@
#include "caf/logger.hpp" #include "caf/logger.hpp"
#include "caf/net/basp/constants.hpp" #include "caf/net/basp/constants.hpp"
#include "caf/net/basp/ec.hpp" #include "caf/net/basp/ec.hpp"
#include "caf/net/packet_writer.hpp"
#include "caf/no_stages.hpp" #include "caf/no_stages.hpp"
#include "caf/none.hpp" #include "caf/none.hpp"
#include "caf/sec.hpp" #include "caf/sec.hpp"
...@@ -78,34 +79,34 @@ strong_actor_ptr application::resolve_local_path(string_view path) { ...@@ -78,34 +79,34 @@ strong_actor_ptr application::resolve_local_path(string_view path) {
return nullptr; return nullptr;
} }
void application::resolve_remote_path(write_packet_callback& write_packet, void application::resolve_remote_path(packet_writer& writer, string_view path,
string_view path, actor listener) { const actor& listener) {
CAF_LOG_TRACE(CAF_ARG(path) << CAF_ARG(listener)); CAF_LOG_TRACE(CAF_ARG(path) << CAF_ARG(listener));
buf_.clear(); auto header_buf = writer.next_header_buffer();
serializer_impl<buffer_type> sink{&executor_, buf_}; auto payload_buf = writer.next_buffer();
serializer_impl<buffer_type> sink{&executor_, payload_buf};
if (auto err = sink(path)) { if (auto err = sink(path)) {
CAF_LOG_ERROR("unable to serialize path"); CAF_LOG_ERROR("unable to serialize path" << CAF_ARG(err));
return; return;
} }
auto req_id = next_request_id_++; auto req_id = next_request_id_++;
auto hdr = to_bytes(header{message_type::resolve_request, to_bytes(header{message_type::resolve_request,
static_cast<uint32_t>(buf_.size()), req_id}); static_cast<uint32_t>(payload_buf.size()), req_id},
if (auto err = write_packet(hdr, buf_)) { header_buf);
CAF_LOG_ERROR("unable to write resolve_request header"); writer.write_packet(header_buf, payload_buf);
return;
}
response_promise rp{nullptr, actor_cast<strong_actor_ptr>(listener), response_promise rp{nullptr, actor_cast<strong_actor_ptr>(listener),
no_stages, make_message_id()}; no_stages, make_message_id()};
pending_resolves_.emplace(req_id, std::move(rp)); pending_resolves_.emplace(req_id, std::move(rp));
} }
error application::write(write_packet_callback& write_packet, error application::write(packet_writer& writer,
std::unique_ptr<endpoint_manager_queue::message> ptr) { std::unique_ptr<endpoint_manager_queue::message> ptr) {
CAF_ASSERT(ptr != nullptr); CAF_ASSERT(ptr != nullptr);
CAF_ASSERT(ptr->msg != nullptr); CAF_ASSERT(ptr->msg != nullptr);
CAF_LOG_TRACE(CAF_ARG2("content", ptr->msg->content())); CAF_LOG_TRACE(CAF_ARG2("content", ptr->msg->content()));
buf_.clear(); auto header_buf = writer.next_header_buffer();
serializer_impl<buffer_type> sink{system(), buf_}; auto payload_elem_buf = writer.next_buffer();
serializer_impl<buffer_type> sink{system(), payload_elem_buf};
const auto& src = ptr->msg->sender; const auto& src = ptr->msg->sender;
const auto& dst = ptr->receiver; const auto& dst = ptr->receiver;
if (dst == nullptr) { if (dst == nullptr) {
...@@ -121,16 +122,18 @@ error application::write(write_packet_callback& write_packet, ...@@ -121,16 +122,18 @@ error application::write(write_packet_callback& write_packet,
if (auto err = sink(node_id{}, actor_id{0}, dst->id(), ptr->msg->stages)) if (auto err = sink(node_id{}, actor_id{0}, dst->id(), ptr->msg->stages))
return err; return err;
} }
// TODO: avoid extra copy of the payload // TODO: Is this size correct?
buf_.insert(buf_.end(), ptr->payload.begin(), ptr->payload.end()); header hdr{message_type::actor_message,
header hdr{message_type::actor_message, static_cast<uint32_t>(buf_.size()), static_cast<uint32_t>(payload_elem_buf.size()
+ ptr->payload.size()),
ptr->msg->mid.integer_value()}; ptr->msg->mid.integer_value()};
auto bytes = to_bytes(hdr); to_bytes(hdr, header_buf);
return write_packet(make_span(bytes), make_span(buf_)); // TODO: OK to move payload out of message?
writer.write_packet(header_buf, payload_elem_buf, ptr->payload);
return none;
} }
error application::handle(size_t& next_read_size, error application::handle(size_t& next_read_size, packet_writer& writer,
write_packet_callback& write_packet,
byte_span bytes) { byte_span bytes) {
CAF_LOG_TRACE(CAF_ARG(state_) << CAF_ARG2("bytes.size", bytes.size())); CAF_LOG_TRACE(CAF_ARG(state_) << CAF_ARG2("bytes.size", bytes.size()));
switch (state_) { switch (state_) {
...@@ -149,7 +152,7 @@ error application::handle(size_t& next_read_size, ...@@ -149,7 +152,7 @@ error application::handle(size_t& next_read_size,
return none; return none;
} }
case connection_state::await_handshake_payload: { case connection_state::await_handshake_payload: {
if (auto err = handle_handshake(write_packet, hdr_, bytes)) if (auto err = handle_handshake(writer, hdr_, bytes))
return err; return err;
state_ = connection_state::await_header; state_ = connection_state::await_header;
return none; return none;
...@@ -159,7 +162,7 @@ error application::handle(size_t& next_read_size, ...@@ -159,7 +162,7 @@ error application::handle(size_t& next_read_size,
return ec::unexpected_number_of_bytes; return ec::unexpected_number_of_bytes;
hdr_ = header::from_bytes(bytes); hdr_ = header::from_bytes(bytes);
if (hdr_.payload_len == 0) if (hdr_.payload_len == 0)
return handle(write_packet, hdr_, byte_span{}); return handle(writer, hdr_, byte_span{});
next_read_size = hdr_.payload_len; next_read_size = hdr_.payload_len;
state_ = connection_state::await_payload; state_ = connection_state::await_payload;
return none; return none;
...@@ -168,29 +171,29 @@ error application::handle(size_t& next_read_size, ...@@ -168,29 +171,29 @@ error application::handle(size_t& next_read_size,
if (bytes.size() != hdr_.payload_len) if (bytes.size() != hdr_.payload_len)
return ec::unexpected_number_of_bytes; return ec::unexpected_number_of_bytes;
state_ = connection_state::await_header; state_ = connection_state::await_header;
return handle(write_packet, hdr_, bytes); return handle(writer, hdr_, bytes);
} }
default: default:
return ec::illegal_state; return ec::illegal_state;
} }
} }
error application::handle(write_packet_callback& write_packet, header hdr, error application::handle(packet_writer& writer, header hdr,
byte_span payload) { byte_span payload) {
CAF_LOG_TRACE(CAF_ARG(hdr) << CAF_ARG2("payload.size", payload.size())); CAF_LOG_TRACE(CAF_ARG(hdr) << CAF_ARG2("payload.size", payload.size()));
switch (hdr.type) { switch (hdr.type) {
case message_type::handshake: case message_type::handshake:
return ec::unexpected_handshake; return ec::unexpected_handshake;
case message_type::actor_message: case message_type::actor_message:
return handle_actor_message(write_packet, hdr, payload); return handle_actor_message(writer, hdr, payload);
case message_type::resolve_request: case message_type::resolve_request:
return handle_resolve_request(write_packet, hdr, payload); return handle_resolve_request(writer, hdr, payload);
case message_type::resolve_response: case message_type::resolve_response:
return handle_resolve_response(write_packet, hdr, payload); return handle_resolve_response(writer, hdr, payload);
case message_type::monitor_message: case message_type::monitor_message:
return handle_monitor_message(write_packet, hdr, payload); return handle_monitor_message(writer, hdr, payload);
case message_type::down_message: case message_type::down_message:
return handle_down_message(write_packet, hdr, payload); return handle_down_message(writer, hdr, payload);
case message_type::heartbeat: case message_type::heartbeat:
return none; return none;
default: default:
...@@ -198,7 +201,7 @@ error application::handle(write_packet_callback& write_packet, header hdr, ...@@ -198,7 +201,7 @@ error application::handle(write_packet_callback& write_packet, header hdr,
} }
} }
error application::handle_handshake(write_packet_callback&, header hdr, error application::handle_handshake(packet_writer&, header hdr,
byte_span payload) { byte_span payload) {
CAF_LOG_TRACE(CAF_ARG(hdr) << CAF_ARG2("payload.size", payload.size())); CAF_LOG_TRACE(CAF_ARG(hdr) << CAF_ARG2("payload.size", payload.size()));
if (hdr.type != message_type::handshake) if (hdr.type != message_type::handshake)
...@@ -224,7 +227,7 @@ error application::handle_handshake(write_packet_callback&, header hdr, ...@@ -224,7 +227,7 @@ error application::handle_handshake(write_packet_callback&, header hdr,
return none; return none;
} }
error application::handle_actor_message(write_packet_callback&, header hdr, error application::handle_actor_message(packet_writer&, header hdr,
byte_span payload) { byte_span payload) {
CAF_LOG_TRACE(CAF_ARG(hdr) << CAF_ARG2("payload.size", payload.size())); CAF_LOG_TRACE(CAF_ARG(hdr) << CAF_ARG2("payload.size", payload.size()));
// Deserialize payload. // Deserialize payload.
...@@ -257,8 +260,8 @@ error application::handle_actor_message(write_packet_callback&, header hdr, ...@@ -257,8 +260,8 @@ error application::handle_actor_message(write_packet_callback&, header hdr,
return none; return none;
} }
error application::handle_resolve_request(write_packet_callback& write_packet, error application::handle_resolve_request(packet_writer& writer, header hdr,
header hdr, byte_span payload) { byte_span payload) {
CAF_LOG_TRACE(CAF_ARG(hdr) << CAF_ARG2("payload.size", payload.size())); CAF_LOG_TRACE(CAF_ARG(hdr) << CAF_ARG2("payload.size", payload.size()));
CAF_ASSERT(hdr.type == message_type::resolve_request); CAF_ASSERT(hdr.type == message_type::resolve_request);
size_t path_size = 0; size_t path_size = 0;
...@@ -273,7 +276,8 @@ error application::handle_resolve_request(write_packet_callback& write_packet, ...@@ -273,7 +276,8 @@ error application::handle_resolve_request(write_packet_callback& write_packet,
remainder.size()}; remainder.size()};
// Write result. // Write result.
auto result = resolve_local_path(path); auto result = resolve_local_path(path);
buf_.clear(); auto header_buf = writer.next_header_buffer();
auto payload_buf = writer.next_buffer();
actor_id aid; actor_id aid;
std::set<std::string> ifs; std::set<std::string> ifs;
if (result) { if (result) {
...@@ -283,16 +287,18 @@ error application::handle_resolve_request(write_packet_callback& write_packet, ...@@ -283,16 +287,18 @@ error application::handle_resolve_request(write_packet_callback& write_packet,
aid = 0; aid = 0;
} }
// TODO: figure out how to obtain messaging interface. // TODO: figure out how to obtain messaging interface.
serializer_impl<buffer_type> sink{&executor_, buf_}; serializer_impl<buffer_type> sink{&executor_, payload_buf};
if (auto err = sink(aid, ifs)) if (auto err = sink(aid, ifs))
return err; return err;
auto out_hdr = to_bytes(header{message_type::resolve_response, to_bytes(header{message_type::resolve_response,
static_cast<uint32_t>(buf_.size()), static_cast<uint32_t>(payload_buf.size()),
hdr.operation_data}); hdr.operation_data},
return write_packet(out_hdr, buf_); header_buf);
writer.write_packet(header_buf, payload_buf);
return none;
} }
error application::handle_resolve_response(write_packet_callback&, header hdr, error application::handle_resolve_response(packet_writer&, header hdr,
byte_span payload) { byte_span payload) {
CAF_LOG_TRACE(CAF_ARG(hdr) << CAF_ARG2("payload.size", payload.size())); CAF_LOG_TRACE(CAF_ARG(hdr) << CAF_ARG2("payload.size", payload.size()));
CAF_ASSERT(hdr.type == message_type::resolve_response); CAF_ASSERT(hdr.type == message_type::resolve_response);
...@@ -319,8 +325,8 @@ error application::handle_resolve_response(write_packet_callback&, header hdr, ...@@ -319,8 +325,8 @@ error application::handle_resolve_response(write_packet_callback&, header hdr,
return none; return none;
} }
error application::handle_monitor_message(write_packet_callback& write_packet, error application::handle_monitor_message(packet_writer& writer, header hdr,
header hdr, byte_span payload) { byte_span payload) {
CAF_LOG_TRACE(CAF_ARG(hdr) << CAF_ARG2("payload.size", payload.size())); CAF_LOG_TRACE(CAF_ARG(hdr) << CAF_ARG2("payload.size", payload.size()));
if (!payload.empty()) if (!payload.empty())
return ec::unexpected_payload; return ec::unexpected_payload;
...@@ -334,19 +340,21 @@ error application::handle_monitor_message(write_packet_callback& write_packet, ...@@ -334,19 +340,21 @@ error application::handle_monitor_message(write_packet_callback& write_packet,
}); });
} else { } else {
error reason = exit_reason::unknown; error reason = exit_reason::unknown;
buf_.clear(); auto header_buf = writer.next_header_buffer();
serializer_impl<buffer_type> sink{&executor_, buf_}; auto payload_buf = writer.next_buffer();
serializer_impl<buffer_type> sink{&executor_, payload_buf};
if (auto err = sink(reason)) if (auto err = sink(reason))
return err; return err;
auto out_hdr = to_bytes(header{message_type::down_message, to_bytes(header{message_type::down_message,
static_cast<uint32_t>(buf_.size()), static_cast<uint32_t>(payload_buf.size()),
hdr.operation_data}); hdr.operation_data},
return write_packet(out_hdr, buf_); header_buf);
writer.write_packet(header_buf, payload_buf);
} }
return none; return none;
} }
error application::handle_down_message(write_packet_callback&, header hdr, error application::handle_down_message(packet_writer&, header hdr,
byte_span payload) { byte_span payload) {
CAF_LOG_TRACE(CAF_ARG(hdr) << CAF_ARG2("payload.size", payload.size())); CAF_LOG_TRACE(CAF_ARG(hdr) << CAF_ARG2("payload.size", payload.size()));
error reason; error reason;
...@@ -357,9 +365,9 @@ error application::handle_down_message(write_packet_callback&, header hdr, ...@@ -357,9 +365,9 @@ error application::handle_down_message(write_packet_callback&, header hdr,
return none; return none;
} }
error application::generate_handshake() { error application::generate_handshake(std::vector<byte>& buf) {
buf_.clear(); buf.clear(); // TODO: really necessary?
serializer_impl<buffer_type> sink{&executor_, buf_}; serializer_impl<buffer_type> sink{&executor_, buf};
return sink(system().node(), return sink(system().node(),
get_or(system().config(), "middleman.app-identifiers", get_or(system().config(), "middleman.app-identifiers",
defaults::middleman::app_identifiers)); defaults::middleman::app_identifiers));
......
...@@ -29,6 +29,7 @@ ...@@ -29,6 +29,7 @@
#include "caf/net/basp/connection_state.hpp" #include "caf/net/basp/connection_state.hpp"
#include "caf/net/basp/constants.hpp" #include "caf/net/basp/constants.hpp"
#include "caf/net/basp/ec.hpp" #include "caf/net/basp/ec.hpp"
#include "caf/net/packet_writer.hpp"
#include "caf/none.hpp" #include "caf/none.hpp"
#include "caf/uri.hpp" #include "caf/uri.hpp"
...@@ -43,7 +44,8 @@ namespace { ...@@ -43,7 +44,8 @@ namespace {
struct fixture : test_coordinator_fixture<>, struct fixture : test_coordinator_fixture<>,
proxy_registry::backend, proxy_registry::backend,
basp::application::test_tag { basp::application::test_tag,
public packet_writer {
using buffer_type = std::vector<byte>; using buffer_type = std::vector<byte>;
fixture() : proxies(sys, *this), app(proxies) { fixture() : proxies(sys, *this), app(proxies) {
...@@ -66,11 +68,6 @@ struct fixture : test_coordinator_fixture<>, ...@@ -66,11 +68,6 @@ struct fixture : test_coordinator_fixture<>,
input = to_buf(xs...); input = to_buf(xs...);
} }
void write_packet(span<const byte> hdr, span<const byte> payload) {
output.insert(output.end(), hdr.begin(), hdr.end());
output.insert(output.end(), payload.begin(), payload.end());
}
void handle_handshake() { void handle_handshake() {
CAF_CHECK_EQUAL(app.state(), CAF_CHECK_EQUAL(app.state(),
basp::connection_state::await_handshake_header); basp::connection_state::await_handshake_header);
...@@ -114,6 +111,14 @@ struct fixture : test_coordinator_fixture<>, ...@@ -114,6 +111,14 @@ struct fixture : test_coordinator_fixture<>,
CAF_FAIL("unexpected function call"); CAF_FAIL("unexpected function call");
} }
buffer_type next_buffer() override {
return {};
}
buffer_type next_header_buffer() override {
return {};
}
template <class... Ts> template <class... Ts>
void configure_read(Ts...) { void configure_read(Ts...) {
// nop // nop
...@@ -130,6 +135,12 @@ struct fixture : test_coordinator_fixture<>, ...@@ -130,6 +135,12 @@ struct fixture : test_coordinator_fixture<>,
// nop // nop
} }
protected:
void write_impl(span<buffer_type*> buffers) override {
for (auto buf : buffers)
output.insert(output.end(), buf->begin(), buf->end());
}
buffer_type input; buffer_type input;
buffer_type output; buffer_type output;
......
Markdown is supported
0%
or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment