18#include <boost/asio/executor_work_guard.hpp>
25using namespace std::chrono_literals;
50 boost::asio::executor_work_guard<boost::asio::io_context::executor_type>
_work_to_do;
55TEST(streaming, low_level_sending_strings) {
61 constexpr auto number_of_messages = 100u;
62 const std::string message_text =
"Hello client!";
64 std::atomic_size_t message_count{0u};
76 ASSERT_EQ(message.size(), message_text.size());
77 const std::string msg = as_string(message);
78 ASSERT_EQ(msg, message_text);
81 carla::Buffer Buf(boost::asio::buffer(message_text.c_str(), message_text.size()));
83 for (
auto i = 0u; i < number_of_messages; ++i) {
84 std::this_thread::sleep_for(2ms);
89 std::this_thread::sleep_for(2ms);
90 ASSERT_GE(message_count, number_of_messages - 3u);
101 constexpr auto number_of_messages = 50u;
102 const std::string message_text =
"Hello client!";
110 for (
auto n = 0u; n < 10u; ++n) {
112 std::atomic_size_t message_count{0u};
116 ASSERT_EQ(message.size(), message_text.size());
117 const std::string msg = as_string(message);
118 ASSERT_EQ(msg, message_text);
121 carla::Buffer Buf(boost::asio::buffer(message_text.c_str(), message_text.size()));
123 for (
auto i = 0u; i < number_of_messages; ++i) {
124 std::this_thread::sleep_for(4ms);
129 std::this_thread::sleep_for(4ms);
132 for (
auto i = 0u; i < number_of_messages; ++i) {
133 std::this_thread::sleep_for(2ms);
138 ASSERT_GE(message_count, number_of_messages - 3u);
148 boost::asio::io_context io_context;
153 std::atomic_bool done{
false};
154 std::atomic_size_t message_count{0u};
156 const std::string msg =
"Hola!";
158 srv.
Listen([&](std::shared_ptr<tcp::ServerSession> session) {
159 ASSERT_EQ(session->get_stream_id(), 1u);
161 carla::Buffer Buf(boost::asio::buffer(msg.c_str(), msg.size()));
164 std::this_thread::sleep_for(1ns);
166 session->Write(View);
168 std::cout <<
"done!\n";
169 }, [](std::shared_ptr<tcp::ServerSession>) { std::cout <<
"session closed!\n"; });
172 Dispatcher dispatcher{make_endpoint<tcp::Client::protocol_type>(
175 auto c = std::make_shared<tcp::Client>(io_context, stream.token(), [&](
carla::Buffer message) {
177 ASSERT_FALSE(message.empty());
178 ASSERT_EQ(message.size(), 5u);
179 const std::string received = util::buffer::as_string(message);
180 ASSERT_EQ(received, msg);
187 std::max(2u, std::thread::hardware_concurrency()),
188 [&]() { io_context.run(); });
190 std::this_thread::sleep_for(2s);
193 std::cout <<
"client received " << message_count <<
" messages\n";
194 ASSERT_GT(message_count, 10u);
205 boost::asio::io_context io_context;
210 std::atomic_bool done{
false};
211 std::atomic_size_t message_count{0u};
213 const std::string msg =
"Hola!";
215 srv.
Listen([&](std::shared_ptr<tcp::ServerSession> session) {
216 carla::Buffer Buf(boost::asio::buffer(msg.c_str(), msg.size()));
219 std::this_thread::sleep_for(1ns);
221 session->Write(View);
223 }, [](std::shared_ptr<tcp::ServerSession>) {});
226 Dispatcher dispatcher{make_endpoint<tcp::Client::protocol_type>(
229 auto c = std::make_shared<tcp::Client>(io_context, stream.token(), [&](
carla::Buffer) {
230 if (++message_count == 1u) {
231 throw std::runtime_error(
"callback failure on the first message");
239 std::max(2u, std::thread::hardware_concurrency()),
240 [&]() { io_context.run(); });
243 const auto deadline = std::chrono::steady_clock::now() + 15s;
244 while (message_count <= 10u && std::chrono::steady_clock::now() < deadline) {
245 std::this_thread::sleep_for(10ms);
249 std::cout <<
"client received " << message_count <<
" messages\n";
250 ASSERT_GT(message_count, 10u);
262 constexpr size_t iterations = 10u;
263 std::atomic_bool done{
false};
264 const std::string message =
"Hello client, how are you?";
265 std::shared_ptr<Stream> stream;
271 carla::Buffer Buf(boost::asio::buffer(message.c_str(), message.size()));
275 const auto next_write = std::chrono::steady_clock::now() + 1ms;
276 while (!done && std::chrono::steady_clock::now() < next_write) {
277 std::this_thread::yield();
279 auto s = std::atomic_load_explicit(&stream, std::memory_order_relaxed);
287 for (
auto i = 0u; i < iterations; ++i) {
291 auto s = std::make_shared<Stream>(srv.
MakeStream());
292 std::atomic_store_explicit(&stream, s, std::memory_order_relaxed);
294 std::atomic_size_t messages_received{0u};
299 const std::string result = as_string(buffer);
300 ASSERT_EQ(result, message);
303 std::this_thread::sleep_for(20ms);
305 ASSERT_GT(messages_received, 0u);
310 std::atomic_store_explicit(&stream, std::shared_ptr<Stream>(), std::memory_order_relaxed);
311 std::this_thread::sleep_for(20ms);
319 constexpr size_t number_of_messages = 100u;
320 constexpr size_t number_of_clients = 6u;
321 constexpr size_t iterations = 10u;
322 const std::string message =
"Hi y'all!";
328 for (
auto i = 0u; i < iterations; ++i) {
329 std::vector<std::pair<std::atomic_size_t, std::unique_ptr<Client>>> v(number_of_clients);
331 for (
auto &pair : v) {
333 pair.second = std::make_unique<Client>();
334 pair.second->AsyncRun(1u);
335 pair.second->Subscribe(stream.token(), [&](
auto buffer) {
336 const std::string result = as_string(buffer);
337 ASSERT_EQ(result, message);
342 carla::Buffer Buf(boost::asio::buffer(message.c_str(), message.size()));
344 std::this_thread::sleep_for(6ms);
345 for (
auto j = 0u; j < number_of_messages; ++j) {
346 std::this_thread::sleep_for(6ms);
350 std::this_thread::sleep_for(6ms);
352 for (
auto &pair : v) {
353 ASSERT_GE(pair.first, number_of_messages - 3u);
421 constexpr auto timeout = 1s;
424 const std::string big(32u * 1024u * 1024u,
'x');
432 std::promise<void> release;
433 std::shared_future<void> released = release.get_future().share();
434 std::atomic_size_t stuck_count{0u};
437 stuck.
Subscribe(stream.token(), [&](
auto) {
442 std::atomic_size_t healthy_count{0u};
445 healthy.
Subscribe(stream.token(), [&](
auto) { ++healthy_count; });
447 std::this_thread::sleep_for(200ms);
449 carla::Buffer Buf(boost::asio::buffer(big.c_str(), big.size()));
451 constexpr size_t number_of_messages = 6u;
452 const auto start = std::chrono::steady_clock::now();
453 for (
auto i = 0u; i < number_of_messages; ++i) {
457 const auto elapsed = std::chrono::steady_clock::now() - start;
460 EXPECT_LT(elapsed, 3 * timeout);
461 EXPECT_GE(stuck_count, 1u);
462 for (
auto i = 0; i < 100 && healthy_count < number_of_messages - 1u; ++i) {
463 std::this_thread::sleep_for(20ms);
467 EXPECT_GE(healthy_count, number_of_messages - 1u);
static std::shared_ptr< BufferView > CreateFrom(Buffer &&buffer)
void CreateThreads(size_t count, F functor)
void CreateThread(F &&functor)
A client able to subscribe to multiple streams.
void AsyncRun(size_t worker_threads)
void Subscribe(const Token &token, Functor &&callback)
token_type GetToken(stream_id sensor_id)
void SetTimeout(time_duration timeout)
bool IsEnabledForROS(stream_id sensor_id)
void EnableForROS(stream_id sensor_id)
void SetROS2TopicVisibilityDefaultEnabled(bool enabled)
void AsyncRun(size_t worker_threads)
void DisableForROS(stream_id sensor_id)
void SetSynchronousMode(bool is_synchro)
Keeps the mapping between streams and sessions.
carla::streaming::Stream MakeStream()
void SetTimeout(time_duration timeout)
Set session time-out.
boost::asio::ip::tcp::endpoint endpoint
endpoint GetLocalEndpoint() const
void Listen(FunctorT1 on_session_opened, FunctorT2 on_session_closed)
Start listening for connections.
Serializes a stream endpoint.
const auto & get_stream_id() const
A client able to subscribe to multiple streams.
void Subscribe(boost::asio::io_context &io_context, token_type token, Functor &&callback)
void UnSubscribe(token_type token)
A low-level streaming server.
void SetTimeout(time_duration timeout)
boost::asio::executor_work_guard< boost::asio::io_context::executor_type > _work_to_do
boost::asio::io_context service
carla::ThreadGroup _threads
io_context_running(size_t threads=2u)
std::shared_ptr< BufferView > SharedBufferView
constexpr uint16_t TESTING_PORT
TEST(agents_types, road_option_values_match_python)