acceptor | accepts TCP connections | TCP library

Known bug on the Apache Kafka side. Nothing to do from Spring perspective. See more info here: https://github.com/spring-projects/spring-kafka/discussions/2027. And here: https://issues.apache.org/jira/browse/KAFKA-13391

You need to wait until Apache Kafka 3.0.1 or don't use embedded Kafka and just rely on the Testcontainers, for example, or fully external Apache Kafka broker.

The server closes the connection after sending the (empty) response. That leads to EOF on the client, naturally. Just handle it.

There's loads of code smells

• delete this; is an abomination, just make Service shared_from_this.

• No need to use shared_ptrs other than that

• When you use smart pointers, use them. Don't "convert to raw pointer" just to dereference (so *m_socket instead of *m_socket.get()).

• In fact, there should be no need to use new, delete or get() in your code

• You are accessing the m_request immediately after async_read_until which is too early,

  • it is a data race (so Undefined Behaviour)
  • it doesn't get the request, because async_read_until didn't complete yet.

  So move that code into onRequestReceived at a minimum

• It's pretty unnecessary to use an istream to read the line from the request when you already have bytes_transferred. I'd suggest

The connector named "netty_connector" shouldn't use 0.0.0.0. This is the address that will be sent to other nodes in the cluster to tell them how to connect back to the node who sent it. The address 0.0.0.0 will be meaningless in that context. It needs to be the actual IP address or hostname where the broker is listening for network connections.

If the async chain of operations creates a logical strand, then often you don't need explicit strands.

Also, if the execution context is only ever run/polled from a single thread then all async operations will effective be on that implicit strand.

The examples serve more than one purpose.

• On the one hand. they're obviously kept simple. Naturally there will be minimum number of threads or simplistic chains of operations.

• However, that leads to over-simplified examples that have too little relation to real life.

• Therefore, even if it's not absolutely required, the samples often show good practice or advanced patterns. Sometimes (often IME) this is even explicitly commented. E.g. in your very linked example L277:

You can catch the exception:

You may use this sed:

It all depends on the implementation of the types.

We can loosely describe the intent of a move as "the compiler is allowed to cannibalize". But really, for user-defined types we're going to have to tell it how to do that, exactly.

In language "doctrine" a moved-from object may only be assumed safe to destruct, but in practice many libraries make more lenient guarantees (e.g. keeping all the invariants, or making sure that a moved-from object is comparable to a newly constructed one).

Indeed, ASIO documents this:

Remarks

Following the move, the moved-from object is in the same state as if constructed using the basic_stream_socket(const executor_type&) constructor.

You only have 1 thread running the IO service. Everything is on an implicit strand (Why do I need strand per connection when using boost::asio?), no need to worry UNTIL you start using a new thread.

The simplest fix, then, would seem to make sure sending the replies happens on the IO service as well:

This awk does the job: