"Pure virtual method called" exception about asio-grpc

[eduardokussler]

This was indeed the problem. Thank you! Keep up the good work with the library!

[Tradias]

Hi, thank you for reporting the issue. I have trouble reproducing it. This email conversion in gRPC suggests that you might be doing two asynchronous operations in parallel that are not allowed to be in parallel. E.g. writing and finishing a writer at the same time.

I do not know what you mean by handle one request at a time, since you are using agrpc::repeatedly_request there will be one coroutine for each request from the client. In other words, the following code will co_spawn a coroutine for each client request, all those coroutines will be processed in parallel:

asio::awaitable<void> handle_request(grpc::ServerContext& server_context, auto& request, auto& writer, agrpc::GrpcContext& grpc_context)
{
  // This function will be called for each request from the client as soon as the request has been made, even while 
  // a previous request is still being processed by `handle_request`.
  // It is executing on a thread of the system_context.
  co_return;
}

void register_handler(asio::system_context& ctx, agrpc::GrpcContext& grpc_context, MarketDataAlert::AsyncService& service)
{
    agrpc::repeatedly_request(&MarketDataAlert::AsyncService::Requestsubscribe, service,
                              asio::bind_executor(grpc_context,
                                                  [&]<class T>(agrpc::RepeatedlyRequestContext<T>&& context)
                                                  {
                                                      
                                                      asio::co_spawn(
                                                              ctx,
                                                              [&, context = std::move(context)]()
                                                              {
                                                                  auto&& [server_context, request, responder] = context.args();
                                                                  return std::invoke(handle_request, server_context, request, responder, grpc_context);
                                                              },
                                                              asio::detached);
                                                  }));
}

[eduardokussler]

Thank you for the very quick response! I'll take a look on the link you have sent. What I meant by "handle one request at a time", is that the first request is processed and receives it's messages but the following requests all receive a unable to connect to server, which I assume is because it is occupied by the first request, which is on the while(request_ok) loop. In other words, i can only have one stream active at a time. It is also happening with the code you provided.
This is the error received/generated by the client application: Message: failed to connect to all addresses subscribe rpc failed.

In other words, the following code will co_spawn a coroutine for each client request, all those coroutines will be processed in parallel

I thought that this would happen too, but apparently is not. I can only start another rpc call when the previous one finishes. Could this be a performance issue? I mean by this is: could my system be too slow to co_spawn and process the new request while the other one is running?

[Tradias]

I suspect that something is blocking the GrpcContext. E.g. in your example:

while(request_ok) {
		// If `fill_response` performs blocking operations, e.g. holding a lock on a mutex or calling some long
		// CPU-intensive task then the entire GrpcContext will be blocked, because `agrpc::write` resumes
		// in the thread of the GrpcContext. If that is the case then explicitly switch back to the system_context
		// before doing such tasks.
		co_await asio::post(asio::bind_executor(ctx, asio::use_awaitable));

		co_await fill_response(server_context, request, response, instrumentId);
 
		// do some work
                request_ok = co_await agrpc::write(writer, response,
                                                              boost::asio::bind_executor(grpc_context, boost::asio::use_awaitable));
		
                    
    }
    //after done work
        bool finish_ok = co_await agrpc::finish(writer, grpc::Status::OK, boost::asio::bind_executor(grpc_context, boost::asio::use_awaitable));

I have just adjusted one of the unit test to deliberately verify that repeatedly_request can handle multiple requests at the same time which succeeds on all tested platforms/compilers.

[Tradias]

Great, I am glad we figured it out and thank you for the kind words.