Commit 3743404c authored by Joseph Noir's avatar Joseph Noir

Cleanup file structure & initialization

parent 8113c99c
...@@ -50,6 +50,7 @@ set(LIBCAF_IO_SRCS ...@@ -50,6 +50,7 @@ set(LIBCAF_IO_SRCS
src/newb_tcp.cpp src/newb_tcp.cpp
src/newb_udp.cpp src/newb_udp.cpp
src/newb.cpp src/newb.cpp
src/policies.cpp
) )
add_custom_target(libcaf_io) add_custom_target(libcaf_io)
......
/******************************************************************************
* ____ _ _____ *
* / ___| / \ | ___| C++ *
* | | / _ \ | |_ Actor *
* | |___ / ___ \| _| Framework *
* \____/_/ \_|_| *
* *
* Copyright 2011-2018 Dominik Charousset *
* *
* Distributed under the terms and conditions of the BSD 3-Clause License or *
* (at your option) under the terms and conditions of the Boost Software *
* License 1.0. See accompanying files LICENSE and LICENSE_ALTERNATIVE. *
* *
* If you did not receive a copy of the license files, see *
* http://opensource.org/licenses/BSD-3-Clause and *
* http://www.boost.org/LICENSE_1_0.txt. *
******************************************************************************/
#pragma once
#include "caf/config.hpp"
#include "caf/policy/transport.hpp"
#include "caf/io/network/native_socket.hpp"
namespace caf {
namespace io {
struct newb_base;
} // namespace io
namespace policy {
struct accept {
accept(bool manual_read = false)
: manual_read(manual_read) {
// nop
}
virtual ~accept();
virtual expected<io::network::native_socket>
create_socket(uint16_t port, const char* host, bool reuse = false) = 0;
virtual std::pair<io::network::native_socket, transport_ptr>
accept_event(io::newb_base*) {
return {0, nullptr};
}
/// If `requires_raw_data` is set to true, the acceptor will only call
/// this function for new read event and let the policy handle everything
/// else.
virtual void read_event(io::newb_base*) {
// nop
}
virtual error write_event(io::newb_base*) {
return none;
}
virtual void init(io::newb_base&) {
// nop
}
bool manual_read;
};
using accept_policy_ptr = std::unique_ptr<accept>;
} // namespace policy
} // namespace caf
...@@ -19,7 +19,7 @@ ...@@ -19,7 +19,7 @@
#pragma once #pragma once
#include "caf/actor.hpp" #include "caf/actor.hpp"
#include "caf/io/network/newb.hpp" #include "caf/io/newb.hpp"
#include "caf/binary_deserializer.hpp" #include "caf/binary_deserializer.hpp"
#include "caf/binary_serializer.hpp" #include "caf/binary_serializer.hpp"
...@@ -57,11 +57,11 @@ struct datagram_basp { ...@@ -57,11 +57,11 @@ struct datagram_basp {
static constexpr size_t header_size = basp_header_len; static constexpr size_t header_size = basp_header_len;
using message_type = new_basp_msg; using message_type = new_basp_msg;
using result_type = optional<message_type>; using result_type = optional<message_type>;
io::network::newb<message_type>* parent; io::newb<message_type>* parent;
message_type msg; message_type msg;
datagram_basp(io::network::newb<message_type>* parent) : parent(parent) { void init(io::newb<message_type>* n) {
// nop parent = n;
} }
error read(char* bytes, size_t count) { error read(char* bytes, size_t count) {
...@@ -90,14 +90,14 @@ struct datagram_basp { ...@@ -90,14 +90,14 @@ struct datagram_basp {
return none; return none;
} }
size_t write_header(io::network::byte_buffer& buf, size_t write_header(io::byte_buffer& buf,
io::network::header_writer* hw) { io::header_writer* hw) {
CAF_ASSERT(hw != nullptr); CAF_ASSERT(hw != nullptr);
(*hw)(buf); (*hw)(buf);
return header_size; return header_size;
} }
void prepare_for_sending(io::network::byte_buffer& buf, void prepare_for_sending(io::byte_buffer& buf,
size_t hstart, size_t offset, size_t plen) { size_t hstart, size_t offset, size_t plen) {
stream_serializer<charbuf> out{&parent->backend(), stream_serializer<charbuf> out{&parent->backend(),
buf.data() + hstart + offset, buf.data() + hstart + offset,
...@@ -111,13 +111,12 @@ struct stream_basp { ...@@ -111,13 +111,12 @@ struct stream_basp {
static constexpr size_t header_size = basp_header_len; static constexpr size_t header_size = basp_header_len;
using message_type = new_basp_msg; using message_type = new_basp_msg;
using result_type = optional<message_type>; using result_type = optional<message_type>;
io::network::newb<message_type>* parent; io::newb<message_type>* parent;
message_type msg; message_type msg;
bool expecting_header = true; bool expecting_header = true;
stream_basp(io::network::newb<message_type>* parent) : parent(parent) { void init(io::newb<message_type>* n) {
// TODO: this is dangerous ... parent = n;
// Maybe we need an init function that is called with `start()`?
parent->configure_read(io::receive_policy::exactly(basp_header_len)); parent->configure_read(io::receive_policy::exactly(basp_header_len));
} }
...@@ -157,14 +156,14 @@ struct stream_basp { ...@@ -157,14 +156,14 @@ struct stream_basp {
return none; return none;
} }
size_t write_header(io::network::byte_buffer& buf, size_t write_header(io::byte_buffer& buf,
io::network::header_writer* hw) { io::header_writer* hw) {
CAF_ASSERT(hw != nullptr); CAF_ASSERT(hw != nullptr);
(*hw)(buf); (*hw)(buf);
return header_size; return header_size;
} }
void prepare_for_sending(io::network::byte_buffer& buf, void prepare_for_sending(io::byte_buffer& buf,
size_t hstart, size_t offset, size_t plen) { size_t hstart, size_t offset, size_t plen) {
stream_serializer<charbuf> out{&parent->backend(), stream_serializer<charbuf> out{&parent->backend(),
buf.data() + hstart + offset, buf.data() + hstart + offset,
......
...@@ -26,7 +26,7 @@ ...@@ -26,7 +26,7 @@
#include "caf/binary_serializer.hpp" #include "caf/binary_serializer.hpp"
#include "caf/defaults.hpp" #include "caf/defaults.hpp"
#include "caf/error.hpp" #include "caf/error.hpp"
#include "caf/io/network/newb.hpp" #include "caf/io/newb.hpp"
namespace caf { namespace caf {
namespace policy { namespace policy {
...@@ -80,17 +80,22 @@ struct ordering { ...@@ -80,17 +80,22 @@ struct ordering {
size_t max_pending_messages; size_t max_pending_messages;
bool use_timeouts; bool use_timeouts;
std::chrono::milliseconds pending_to = std::chrono::milliseconds(100); std::chrono::milliseconds pending_to = std::chrono::milliseconds(100);
io::network::newb<message_type>* parent; io::newb<message_type>* parent;
Next next; Next next;
std::map<sequence_type, std::vector<char>, sequence_comperator> pending; std::map<sequence_type, std::vector<char>, sequence_comperator> pending;
ordering(io::network::newb<message_type>* parent, bool use_timeouts = true) void init(io::newb<message_type>* n, bool enable_timeouts = true) {
: max_pending_messages(get_or(parent->config(), this->use_timeouts = enable_timeouts;
"middleman.max-pending-messages", parent = n;
caf::defaults::middleman::max_pending_messages)), next.init(parent);
use_timeouts(use_timeouts), max_pending_messages = get_or(parent->config(),
parent(parent), "middleman.max-pending-messages",
next(parent) { max_pending_messages);
}
ordering()
: max_pending_messages(caf::defaults::middleman::max_pending_messages),
use_timeouts(false) {
// nop // nop
} }
...@@ -152,8 +157,8 @@ struct ordering { ...@@ -152,8 +157,8 @@ struct ordering {
return next.timeout(atm, id); return next.timeout(atm, id);
} }
void write_header(io::network::byte_buffer& buf, void write_header(io::byte_buffer& buf,
io::network::header_writer* hw) { io::header_writer* hw) {
binary_serializer bs(&parent->backend(), buf); binary_serializer bs(&parent->backend(), buf);
bs(ordering_header{seq_write}); bs(ordering_header{seq_write});
seq_write += 1; seq_write += 1;
...@@ -161,7 +166,7 @@ struct ordering { ...@@ -161,7 +166,7 @@ struct ordering {
return; return;
} }
void prepare_for_sending(io::network::byte_buffer& buf, void prepare_for_sending(io::byte_buffer& buf,
size_t hstart, size_t offset, size_t plen) { size_t hstart, size_t offset, size_t plen) {
next.prepare_for_sending(buf, hstart, offset + header_size, plen); next.prepare_for_sending(buf, hstart, offset + header_size, plen);
} }
......
...@@ -19,7 +19,7 @@ ...@@ -19,7 +19,7 @@
#pragma once #pragma once
#include "caf/actor.hpp" #include "caf/actor.hpp"
#include "caf/io/network/newb.hpp" #include "caf/io/newb.hpp"
namespace caf { namespace caf {
namespace policy { namespace policy {
...@@ -37,11 +37,11 @@ typename Inspector::result_type inspect(Inspector& fun, new_raw_msg& data) { ...@@ -37,11 +37,11 @@ typename Inspector::result_type inspect(Inspector& fun, new_raw_msg& data) {
struct raw { struct raw {
using message_type = new_raw_msg; using message_type = new_raw_msg;
using result_type = optional<message_type>; using result_type = optional<message_type>;
io::network::newb<message_type>* parent; io::newb<message_type>* parent;
message_type msg; message_type msg;
raw(io::network::newb<message_type>* parent) : parent(parent) { void init(io::newb<message_type>* n) {
// nop this->parent = n;
} }
error read(char* bytes, size_t count) { error read(char* bytes, size_t count) {
...@@ -55,12 +55,12 @@ struct raw { ...@@ -55,12 +55,12 @@ struct raw {
return none; return none;
} }
size_t write_header(io::network::byte_buffer&, size_t write_header(io::byte_buffer&,
io::network::header_writer*) { io::header_writer*) {
return 0; return 0;
} }
void prepare_for_sending(io::network::byte_buffer&, size_t, size_t, size_t) { void prepare_for_sending(io::byte_buffer&, size_t, size_t, size_t) {
// nop // nop
} }
}; };
......
...@@ -25,7 +25,7 @@ ...@@ -25,7 +25,7 @@
#include "caf/binary_deserializer.hpp" #include "caf/binary_deserializer.hpp"
#include "caf/binary_serializer.hpp" #include "caf/binary_serializer.hpp"
#include "caf/error.hpp" #include "caf/error.hpp"
#include "caf/io/network/newb.hpp" #include "caf/io/newb.hpp"
namespace caf { namespace caf {
namespace policy { namespace policy {
...@@ -57,14 +57,13 @@ struct reliability { ...@@ -57,14 +57,13 @@ struct reliability {
id_type id_write = 0; id_type id_write = 0;
// TODO: Make this configurable. // TODO: Make this configurable.
std::chrono::milliseconds retransmit_to = std::chrono::milliseconds(100); std::chrono::milliseconds retransmit_to = std::chrono::milliseconds(100);
io::network::newb<message_type>* parent; io::newb<message_type>* parent;
Next next; Next next;
std::unordered_map<id_type, io::network::byte_buffer> unacked; std::unordered_map<id_type, io::byte_buffer> unacked;
reliability(io::network::newb<message_type>* parent) void init(io::newb<message_type>* n) {
: parent(parent), parent = n;
next(parent) { next.init(parent);
// nop
} }
error read(char* bytes, size_t count) { error read(char* bytes, size_t count) {
...@@ -106,22 +105,22 @@ struct reliability { ...@@ -106,22 +105,22 @@ struct reliability {
return next.timeout(atm, id); return next.timeout(atm, id);
} }
void write_header(io::network::byte_buffer& buf, void write_header(io::byte_buffer& buf,
io::network::header_writer* hw) { io::header_writer* hw) {
binary_serializer bs(&parent->backend(), buf); binary_serializer bs(&parent->backend(), buf);
bs(reliability_header{id_write, false}); bs(reliability_header{id_write, false});
next.write_header(buf, hw); next.write_header(buf, hw);
return; return;
} }
void prepare_for_sending(io::network::byte_buffer& buf, void prepare_for_sending(io::byte_buffer& buf,
size_t hstart, size_t offset, size_t plen) { size_t hstart, size_t offset, size_t plen) {
next.prepare_for_sending(buf, hstart, offset + header_size, plen); next.prepare_for_sending(buf, hstart, offset + header_size, plen);
// Set timeout for retransmission. // Set timeout for retransmission.
parent->set_timeout(retransmit_to, reliability_atom::value, id_write); parent->set_timeout(retransmit_to, reliability_atom::value, id_write);
// Add to unacked. // Add to unacked.
unacked.emplace(id_write, unacked.emplace(id_write,
io::network::byte_buffer(buf.begin() + hstart, buf.end())); io::byte_buffer(buf.begin() + hstart, buf.end()));
id_write += 1; id_write += 1;
} }
}; };
......
...@@ -18,28 +18,29 @@ ...@@ -18,28 +18,29 @@
#pragma once #pragma once
#include "caf/io/network/newb.hpp"
#include "caf/io/network/native_socket.hpp" #include "caf/io/network/native_socket.hpp"
#include "caf/policy/accept.hpp"
#include "caf/policy/transport.hpp"
namespace caf { namespace caf {
namespace policy { namespace policy {
struct tcp_transport : public io::network::transport_policy { struct tcp_transport : public transport {
tcp_transport(); tcp_transport();
io::network::rw_state read_some(io::network::newb_base* parent) override; io::network::rw_state read_some(io::newb_base* parent) override;
bool should_deliver() override; bool should_deliver() override;
void prepare_next_read(io::network::newb_base*) override; void prepare_next_read(io::newb_base*) override;
void configure_read(io::receive_policy::config config) override; void configure_read(io::receive_policy::config config) override;
io::network::rw_state write_some(io::network::newb_base* parent) override; io::network::rw_state write_some(io::newb_base* parent) override;
void prepare_next_write(io::network::newb_base* parent) override; void prepare_next_write(io::newb_base* parent) override;
void flush(io::network::newb_base* parent) override; void flush(io::newb_base* parent) override;
expected<io::network::native_socket> expected<io::network::native_socket>
connect(const std::string& host, uint16_t port, connect(const std::string& host, uint16_t port,
...@@ -56,18 +57,18 @@ struct tcp_transport : public io::network::transport_policy { ...@@ -56,18 +57,18 @@ struct tcp_transport : public io::network::transport_policy {
size_t written; size_t written;
}; };
struct accept_tcp : public io::network::accept_policy { struct accept_tcp : public accept {
expected<io::network::native_socket> expected<io::network::native_socket>
create_socket(uint16_t port,const char* host,bool reuse = false) override; create_socket(uint16_t port,const char* host,bool reuse = false) override;
std::pair<io::network::native_socket, io::network::transport_policy_ptr> std::pair<io::network::native_socket, transport_ptr>
accept(io::network::newb_base* parent) override; accept_event(io::newb_base* parent) override;
void init(io::network::newb_base& n) override; void init(io::newb_base& n) override;
}; };
template <class T> template <class T>
using tcp_protocol = io::network::generic_protocol<T>; using tcp_protocol = generic_protocol<T>;
} // namespace policy } // namespace policy
} // namespace caf } // namespace caf
...@@ -18,35 +18,37 @@ ...@@ -18,35 +18,37 @@
#pragma once #pragma once
#include "caf/io/network/newb.hpp" #include "caf/io/network/ip_endpoint.hpp"
#include "caf/io/network/native_socket.hpp" #include "caf/io/network/native_socket.hpp"
#include "caf/policy/accept.hpp"
#include "caf/policy/transport.hpp"
namespace caf { namespace caf {
namespace policy { namespace policy {
struct udp_transport : public io::network::transport_policy { struct udp_transport : public transport {
udp_transport(); udp_transport();
io::network::rw_state read_some(io::network::newb_base* parent) override; io::network::rw_state read_some(io::newb_base* parent) override;
inline bool should_deliver() override { inline bool should_deliver() override {
CAF_LOG_TRACE(""); CAF_LOG_TRACE("");
return received_bytes != 0 && sender == endpoint; return received_bytes != 0 && sender == endpoint;
} }
void prepare_next_read(io::network::newb_base*) override; void prepare_next_read(io::newb_base*) override;
inline void configure_read(io::receive_policy::config) override { inline void configure_read(io::receive_policy::config) override {
// nop // nop
} }
io::network::rw_state write_some(io::network::newb_base* parent) override; io::network::rw_state write_some(io::newb_base* parent) override;
void prepare_next_write(io::network::newb_base* parent) override; void prepare_next_write(io::newb_base* parent) override;
io::network::byte_buffer& wr_buf() override; byte_buffer& wr_buf() override;
void flush(io::network::newb_base* parent) override; void flush(io::newb_base* parent) override;
expected<io::network::native_socket> expected<io::network::native_socket>
connect(const std::string& host, uint16_t port, connect(const std::string& host, uint16_t port,
...@@ -68,18 +70,18 @@ struct udp_transport : public io::network::transport_policy { ...@@ -68,18 +70,18 @@ struct udp_transport : public io::network::transport_policy {
io::network::ip_endpoint sender; io::network::ip_endpoint sender;
}; };
struct accept_udp : public io::network::accept_policy { struct accept_udp : public accept {
expected<io::network::native_socket> expected<io::network::native_socket>
create_socket(uint16_t port, const char* host, bool reuse = false) override; create_socket(uint16_t port, const char* host, bool reuse = false) override;
std::pair<io::network::native_socket, io::network::transport_policy_ptr> std::pair<io::network::native_socket, transport_ptr>
accept(io::network::newb_base*) override; accept_event(io::newb_base*) override;
void init(io::network::newb_base& n) override; void init(io::newb_base& n) override;
}; };
template <class T> template <class T>
using udp_protocol = io::network::generic_protocol<T>; using udp_protocol = generic_protocol<T>;
} // namespace policy } // namespace policy
} // namespace caf } // namespace caf
/******************************************************************************
* ____ _ _____ *
* / ___| / \ | ___| C++ *
* | | / _ \ | |_ Actor *
* | |___ / ___ \| _| Framework *
* \____/_/ \_|_| *
* *
* Copyright 2011-2018 Dominik Charousset *
* *
* Distributed under the terms and conditions of the BSD 3-Clause License or *
* (at your option) under the terms and conditions of the Boost Software *
* License 1.0. See accompanying files LICENSE and LICENSE_ALTERNATIVE. *
* *
* If you did not receive a copy of the license files, see *
* http://opensource.org/licenses/BSD-3-Clause and *
* http://www.boost.org/LICENSE_1_0.txt. *
******************************************************************************/
#pragma once
#include "caf/config.hpp"
#include "caf/callback.hpp"
#include "caf/error.hpp"
namespace caf {
namespace io {
struct newb_base;
template <class T>
struct newb;
} // namespace io
namespace policy {
using byte_buffer = std::vector<char>;
using header_writer = caf::callback<byte_buffer&>;
struct protocol_base {
virtual ~protocol_base();
virtual error read(char* bytes, size_t count) = 0;
virtual error timeout(atom_value, uint32_t) = 0;
virtual void write_header(byte_buffer&, header_writer*) = 0;
virtual void prepare_for_sending(byte_buffer&, size_t, size_t, size_t) = 0;
};
template <class T>
struct protocol : protocol_base {
using message_type = T;
virtual ~protocol() override {
// nop
}
virtual void init(io::newb<message_type>* parent) = 0;
};
template <class T>
using protocol_ptr = std::unique_ptr<protocol<T>>;
template <class T>
struct generic_protocol
: public protocol<typename T::message_type> {
void init(io::newb<typename T::message_type>* parent) override {
impl.init(parent);
}
error read(char* bytes, size_t count) override {
return impl.read(bytes, count);
}
error timeout(atom_value atm, uint32_t id) override {
return impl.timeout(atm, id);
}
void write_header(byte_buffer& buf, header_writer* hw) override {
impl.write_header(buf, hw);
}
void prepare_for_sending(byte_buffer& buf, size_t hstart,
size_t offset, size_t plen) override {
impl.prepare_for_sending(buf, hstart, offset, plen);
}
private:
T impl;
};
} // namespace policy
} // namespace caf
/******************************************************************************
* ____ _ _____ *
* / ___| / \ | ___| C++ *
* | | / _ \ | |_ Actor *
* | |___ / ___ \| _| Framework *
* \____/_/ \_|_| *
* *
* Copyright 2011-2018 Dominik Charousset *
* *
* Distributed under the terms and conditions of the BSD 3-Clause License or *
* (at your option) under the terms and conditions of the Boost Software *
* License 1.0. See accompanying files LICENSE and LICENSE_ALTERNATIVE. *
* *
* If you did not receive a copy of the license files, see *
* http://opensource.org/licenses/BSD-3-Clause and *
* http://www.boost.org/LICENSE_1_0.txt. *
******************************************************************************/
#pragma once
#include "caf/config.hpp"
#include "caf/error.hpp"
#include "caf/io/network/native_socket.hpp"
#include "caf/io/network/protocol.hpp"
#include "caf/io/network/rw_state.hpp"
#include "caf/io/receive_policy.hpp"
#include "caf/logger.hpp"
#include "caf/policy/protocol.hpp"
#include "caf/sec.hpp"
namespace caf {
namespace io {
struct newb_base;
} // namespace io
namespace policy {
struct transport {
transport();
virtual ~transport();
virtual io::network::rw_state write_some(io::newb_base*);
virtual io::network::rw_state read_some(io::newb_base*);
virtual bool should_deliver();
virtual bool must_read_more(io::newb_base*);
virtual void prepare_next_read(io::newb_base*);
virtual void prepare_next_write(io::newb_base*);
virtual void configure_read(io::receive_policy::config);
virtual void flush(io::newb_base*);
virtual byte_buffer& wr_buf();
template <class T>
error read_some(io::newb_base* parent, protocol<T>& policy) {
using io::network::rw_state;
CAF_LOG_TRACE("");
size_t reads = 0;
while (reads < max_consecutive_reads || must_read_more(parent)) {
auto read_result = read_some(parent);
switch (read_result) {
case rw_state::success:
if (received_bytes == 0)
return none;
if (should_deliver()) {
auto res = policy.read(receive_buffer.data(), received_bytes);
prepare_next_read(parent);
if (res)
return res;
}
break;
case rw_state::indeterminate:
// No error, but don't continue reading.
return none;
case rw_state::failure:
// Reading failed.
return sec::runtime_error;
}
++reads;
}
return none;
}
virtual expected<io::network::native_socket>
connect(const std::string&, uint16_t,
optional<io::network::protocol::network> = none);
size_t received_bytes;
size_t max_consecutive_reads;
byte_buffer offline_buffer;
byte_buffer receive_buffer;
byte_buffer send_buffer;
};
using transport_ptr = std::unique_ptr<transport>;
} // namespace policy
} // namespace caf
...@@ -16,85 +16,16 @@ ...@@ -16,85 +16,16 @@
* http://www.boost.org/LICENSE_1_0.txt. * * http://www.boost.org/LICENSE_1_0.txt. *
******************************************************************************/ ******************************************************************************/
#include "caf/io/network/newb.hpp" #include "caf/io/newb.hpp"
namespace caf { namespace caf {
namespace io { namespace io {
namespace network {
// -- newb_base ---------------------------------------------------------------- newb_base::newb_base(network::default_multiplexer& dm,
network::native_socket sockfd)
newb_base::newb_base(default_multiplexer& dm, native_socket sockfd)
: event_handler(dm, sockfd) { : event_handler(dm, sockfd) {
// nop // nop
} }
// -- transport_policy ---------------------------------------------------------
transport_policy::transport_policy()
: received_bytes{0},
max_consecutive_reads{50} {
// nop
}
transport_policy::~transport_policy() {
// nop
}
io::network::rw_state transport_policy::write_some(newb_base*) {
return io::network::rw_state::indeterminate;
}
io::network::rw_state transport_policy::read_some(newb_base*) {
return io::network::rw_state::indeterminate;
}
bool transport_policy::should_deliver() {
return true;
}
bool transport_policy::must_read_more(newb_base*) {
return false;
}
void transport_policy::prepare_next_read(newb_base*) {
// nop
}
void transport_policy::prepare_next_write(newb_base*) {
// nop
}
void transport_policy::configure_read(receive_policy::config) {
// nop
}
void transport_policy::flush(newb_base*) {
// nop
}
byte_buffer& transport_policy::wr_buf() {
return offline_buffer;
}
expected<native_socket>
transport_policy::connect(const std::string&, uint16_t,
optional<io::network::protocol::network>) {
return sec::bad_function_call;
}
// -- accept_policy ------------------------------------------------------------
accept_policy::~accept_policy() {
// nop
}
// -- protocol_policy_base -----------------------------------------------------
protocol_policy_base::~protocol_policy_base() {
// nop
}
} // namespace network
} // namespace io } // namespace io
} // namespace caf } // namespace caf
...@@ -17,6 +17,7 @@ ...@@ -17,6 +17,7 @@
******************************************************************************/ ******************************************************************************/
#include "caf/policy/newb_tcp.hpp" #include "caf/policy/newb_tcp.hpp"
#include "caf/io/newb.hpp"
#include "caf/config.hpp" #include "caf/config.hpp"
...@@ -71,7 +72,7 @@ tcp_transport::tcp_transport() ...@@ -71,7 +72,7 @@ tcp_transport::tcp_transport()
configure_read(io::receive_policy::at_most(1024)); configure_read(io::receive_policy::at_most(1024));
} }
io::network::rw_state tcp_transport::read_some(io::network::newb_base* parent) { io::network::rw_state tcp_transport::read_some(io::newb_base* parent) {
CAF_LOG_TRACE(""); CAF_LOG_TRACE("");
size_t len = receive_buffer.size() - collected; size_t len = receive_buffer.size() - collected;
void* buf = receive_buffer.data() + collected; void* buf = receive_buffer.data() + collected;
...@@ -100,7 +101,7 @@ bool tcp_transport::should_deliver() { ...@@ -100,7 +101,7 @@ bool tcp_transport::should_deliver() {
return collected >= read_threshold; return collected >= read_threshold;
} }
void tcp_transport::prepare_next_read(io::network::newb_base*) { void tcp_transport::prepare_next_read(io::newb_base*) {
collected = 0; collected = 0;
received_bytes = 0; received_bytes = 0;
switch (rd_flag) { switch (rd_flag) {
...@@ -130,7 +131,7 @@ void tcp_transport::configure_read(io::receive_policy::config config) { ...@@ -130,7 +131,7 @@ void tcp_transport::configure_read(io::receive_policy::config config) {
maximum = config.second; maximum = config.second;
} }
io::network::rw_state tcp_transport::write_some(io::network::newb_base* parent) { io::network::rw_state tcp_transport::write_some(io::newb_base* parent) {
CAF_LOG_TRACE(""); CAF_LOG_TRACE("");
const void* buf = send_buffer.data() + written; const void* buf = send_buffer.data() + written;
auto len = send_buffer.size() - written; auto len = send_buffer.size() - written;
...@@ -150,7 +151,7 @@ io::network::rw_state tcp_transport::write_some(io::network::newb_base* parent) ...@@ -150,7 +151,7 @@ io::network::rw_state tcp_transport::write_some(io::network::newb_base* parent)
return io::network::rw_state::success; return io::network::rw_state::success;
} }
void tcp_transport::prepare_next_write(io::network::newb_base* parent) { void tcp_transport::prepare_next_write(io::newb_base* parent) {
written = 0; written = 0;
send_buffer.clear(); send_buffer.clear();
if (offline_buffer.empty()) { if (offline_buffer.empty()) {
...@@ -161,7 +162,7 @@ void tcp_transport::prepare_next_write(io::network::newb_base* parent) { ...@@ -161,7 +162,7 @@ void tcp_transport::prepare_next_write(io::network::newb_base* parent) {
} }
} }
void tcp_transport::flush(io::network::newb_base* parent) { void tcp_transport::flush(io::newb_base* parent) {
CAF_ASSERT(parent != nullptr); CAF_ASSERT(parent != nullptr);
CAF_LOG_TRACE(CAF_ARG(offline_buffer.size())); CAF_LOG_TRACE(CAF_ARG(offline_buffer.size()));
if (!offline_buffer.empty() && !writing) { if (!offline_buffer.empty() && !writing) {
...@@ -182,8 +183,8 @@ accept_tcp::create_socket(uint16_t port, const char* host, bool reuse) { ...@@ -182,8 +183,8 @@ accept_tcp::create_socket(uint16_t port, const char* host, bool reuse) {
return io::network::new_tcp_acceptor_impl(port, host, reuse); return io::network::new_tcp_acceptor_impl(port, host, reuse);
} }
std::pair<io::network::native_socket, io::network::transport_policy_ptr> std::pair<io::network::native_socket, transport_ptr>
accept_tcp::accept(io::network::newb_base* parent) { accept_tcp::accept_event(io::newb_base* parent) {
using namespace io::network; using namespace io::network;
sockaddr_storage addr; sockaddr_storage addr;
std::memset(&addr, 0, sizeof(addr)); std::memset(&addr, 0, sizeof(addr));
...@@ -196,11 +197,11 @@ accept_tcp::accept(io::network::newb_base* parent) { ...@@ -196,11 +197,11 @@ accept_tcp::accept(io::network::newb_base* parent) {
return {invalid_native_socket, nullptr}; return {invalid_native_socket, nullptr};
} }
} }
transport_policy_ptr ptr{new tcp_transport}; transport_ptr ptr{new tcp_transport};
return {result, std::move(ptr)}; return {result, std::move(ptr)};
} }
void accept_tcp::init(io::network::newb_base& n) { void accept_tcp::init(io::newb_base& n) {
n.start(); n.start();
} }
......
...@@ -20,6 +20,9 @@ ...@@ -20,6 +20,9 @@
#include "caf/config.hpp" #include "caf/config.hpp"
#include "caf/io/network/native_socket.hpp"
#include "caf/io/newb.hpp"
#ifdef CAF_WINDOWS #ifdef CAF_WINDOWS
# ifndef WIN32_LEAN_AND_MEAN # ifndef WIN32_LEAN_AND_MEAN
# define WIN32_LEAN_AND_MEAN # define WIN32_LEAN_AND_MEAN
...@@ -71,7 +74,7 @@ udp_transport::udp_transport() ...@@ -71,7 +74,7 @@ udp_transport::udp_transport()
// nop // nop
} }
io::network::rw_state udp_transport::read_some(io::network::newb_base* parent) { io::network::rw_state udp_transport::read_some(io::newb_base* parent) {
CAF_LOG_TRACE(CAF_ARG(parent->fd())); CAF_LOG_TRACE(CAF_ARG(parent->fd()));
memset(sender.address(), 0, sizeof(sockaddr_storage)); memset(sender.address(), 0, sizeof(sockaddr_storage));
io::network::socket_size_type len = sizeof(sockaddr_storage); io::network::socket_size_type len = sizeof(sockaddr_storage);
...@@ -97,12 +100,12 @@ io::network::rw_state udp_transport::read_some(io::network::newb_base* parent) { ...@@ -97,12 +100,12 @@ io::network::rw_state udp_transport::read_some(io::network::newb_base* parent) {
return io::network::rw_state::success; return io::network::rw_state::success;
} }
void udp_transport::prepare_next_read(io::network::newb_base*) { void udp_transport::prepare_next_read(io::newb_base*) {
received_bytes = 0; received_bytes = 0;
receive_buffer.resize(maximum); receive_buffer.resize(maximum);
} }
io::network::rw_state udp_transport::write_some(io::network::newb_base* parent) { io::network::rw_state udp_transport::write_some(io::newb_base* parent) {
using namespace caf::io::network; using namespace caf::io::network;
CAF_LOG_TRACE(CAF_ARG(parent->fd()) << CAF_ARG(send_buffer.size())); CAF_LOG_TRACE(CAF_ARG(parent->fd()) << CAF_ARG(send_buffer.size()));
socket_size_type len = static_cast<socket_size_type>(*endpoint.clength()); socket_size_type len = static_cast<socket_size_type>(*endpoint.clength());
...@@ -128,7 +131,7 @@ io::network::rw_state udp_transport::write_some(io::network::newb_base* parent) ...@@ -128,7 +131,7 @@ io::network::rw_state udp_transport::write_some(io::network::newb_base* parent)
return io::network::rw_state::success; return io::network::rw_state::success;
} }
void udp_transport::prepare_next_write(io::network::newb_base* parent) { void udp_transport::prepare_next_write(io::newb_base* parent) {
written = 0; written = 0;
send_buffer.clear(); send_buffer.clear();
send_sizes.clear(); send_sizes.clear();
...@@ -146,7 +149,7 @@ void udp_transport::prepare_next_write(io::network::newb_base* parent) { ...@@ -146,7 +149,7 @@ void udp_transport::prepare_next_write(io::network::newb_base* parent) {
} }
} }
io::network::byte_buffer& udp_transport::wr_buf() { io::byte_buffer& udp_transport::wr_buf() {
if (!offline_buffer.empty()) { if (!offline_buffer.empty()) {
auto chunk_size = offline_buffer.size() - offline_sum; auto chunk_size = offline_buffer.size() - offline_sum;
offline_sizes.push_back(chunk_size); offline_sizes.push_back(chunk_size);
...@@ -155,7 +158,7 @@ io::network::byte_buffer& udp_transport::wr_buf() { ...@@ -155,7 +158,7 @@ io::network::byte_buffer& udp_transport::wr_buf() {
return offline_buffer; return offline_buffer;
} }
void udp_transport::flush(io::network::newb_base* parent) { void udp_transport::flush(io::newb_base* parent) {
CAF_ASSERT(parent != nullptr); CAF_ASSERT(parent != nullptr);
CAF_LOG_TRACE(CAF_ARG(offline_buffer.size())); CAF_LOG_TRACE(CAF_ARG(offline_buffer.size()));
if (!offline_buffer.empty() && !writing) { if (!offline_buffer.empty() && !writing) {
...@@ -183,19 +186,19 @@ accept_udp::create_socket(uint16_t port, const char* host, bool reuse) { ...@@ -183,19 +186,19 @@ accept_udp::create_socket(uint16_t port, const char* host, bool reuse) {
return (*res).first; return (*res).first;
} }
std::pair<io::network::native_socket, io::network::transport_policy_ptr> std::pair<io::network::native_socket, transport_ptr>
accept_udp::accept(io::network::newb_base*) { accept_udp::accept_event(io::newb_base*) {
auto res = io::network::new_local_udp_endpoint_impl(0, nullptr); auto res = io::network::new_local_udp_endpoint_impl(0, nullptr);
if (!res) { if (!res) {
CAF_LOG_DEBUG("failed to create local endpoint"); CAF_LOG_DEBUG("failed to create local endpoint");
return {io::network::invalid_native_socket, nullptr}; return {io::network::invalid_native_socket, nullptr};
} }
auto sock = std::move(res->first); auto sock = std::move(res->first);
io::network::transport_policy_ptr ptr{new udp_transport}; transport_ptr ptr{new udp_transport};
return {sock, std::move(ptr)}; return {sock, std::move(ptr)};
} }
void accept_udp::init(io::network::newb_base& n) { void accept_udp::init(io::newb_base& n) {
n.start(); n.start();
} }
......
/******************************************************************************
* ____ _ _____ *
* / ___| / \ | ___| C++ *
* | | / _ \ | |_ Actor *
* | |___ / ___ \| _| Framework *
* \____/_/ \_|_| *
* *
* Copyright 2011-2018 Dominik Charousset *
* *
* Distributed under the terms and conditions of the BSD 3-Clause License or *
* (at your option) under the terms and conditions of the Boost Software *
* License 1.0. See accompanying files LICENSE and LICENSE_ALTERNATIVE. *
* *
* If you did not receive a copy of the license files, see *
* http://opensource.org/licenses/BSD-3-Clause and *
* http://www.boost.org/LICENSE_1_0.txt. *
******************************************************************************/
#include "caf/policy/accept.hpp"
#include "caf/policy/protocol.hpp"
#include "caf/policy/transport.hpp"
namespace caf {
namespace policy {
// -- transport_policy ---------------------------------------------------------
transport::transport()
: received_bytes{0},
max_consecutive_reads{50} {
// nop
}
transport::~transport() {
// nop
}
io::network::rw_state transport::write_some(io::newb_base*) {
return io::network::rw_state::indeterminate;
}
io::network::rw_state transport::read_some(io::newb_base*) {
return io::network::rw_state::indeterminate;
}
bool transport::should_deliver() {
return true;
}
bool transport::must_read_more(io::newb_base*) {
return false;
}
void transport::prepare_next_read(io::newb_base*) {
// nop
}
void transport::prepare_next_write(io::newb_base*) {
// nop
}
void transport::configure_read(io::receive_policy::config) {
// nop
}
void transport::flush(io::newb_base*) {
// nop
}
byte_buffer& transport::wr_buf() {
return offline_buffer;
}
expected<io::network::native_socket>
transport::connect(const std::string&, uint16_t,
optional<io::network::protocol::network>) {
return sec::bad_function_call;
}
// -- accept_policy ------------------------------------------------------------
accept::~accept() {
// nop
}
// -- protocol_policy_base -----------------------------------------------------
protocol_base::~protocol_base() {
// nop
}
} // namespace policy
} // namespace caf
This diff is collapsed.
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