Building a reflection client to interact with a reflection server made in C++

[Maniacobra]

Hello, I'm trying to make a small Rust program which could interact with a C++ reflection server, I'm trying to get the list of functions or calling a method "GetVersion()" to start with, but any requests sent to the C++ server ends up with "Unimplemented" despite that the server implements all these features considering that another program manages to interact with this server successfully.

Here's an example test of .proto file in the server :

import "google/protobuf/empty.proto";                               
                                                                    
package com.test;                                                   
                                                                    
service Broker {                                                    
  rpc GetVersion(google.protobuf.Empty) returns (Version) {}        
}                                                                   
                                                                    
message Version {                                                   
  int32 major = 1;                                                  
  int32 minor = 2;                                                  
  int32 patch = 3;                                                  
}

There's actually way more and the C++ server is a complex program that I cannot change but it's just for illustration.
Key goal would be to not need the .proto files for the client program, and using only reflection to send and receive requests.

use prost::Message;
use std::net::SocketAddr;
use tokio::sync::oneshot;
use tokio_stream::{wrappers::TcpListenerStream, StreamExt};
use tonic::{transport::Server, Request};
use tonic_reflection::{
    pb::{
        server_reflection_client::ServerReflectionClient,
        server_reflection_request::MessageRequest, server_reflection_response::MessageResponse,
        ServerReflectionRequest, ServiceResponse, FILE_DESCRIPTOR_SET,
    },
    server::Builder,
};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {

    let local_addr = String::from("http://localhost:51001");
    
    let conn = tonic::transport::Endpoint::new(local_addr)
        .unwrap()
        .connect()
        .await
        .unwrap();
    let mut client = ServerReflectionClient::new(conn);

    let request = ServerReflectionRequest {
        // Set the desired fields of the request
        host: "".into(),
        message_request: Some(tonic_reflection::pb::server_reflection_request::MessageRequest::ListServices(String::new())),
    };
    let request = Request::new(tokio_stream::once(request));

    let mut inbound = client
        .server_reflection_info(request)
        .await
        .unwrap()
        .into_inner();

    let response = inbound
        .next()
        .await
        .unwrap().unwrap()
        .message_response;
    dbg!(response);

    // Process each response from the server (assuming there might be more than one for illustration)
    while let Some(response) = inbound.message().await? {
        // Process the response here
        println!("{:?}", response);
    }

    Ok(())
}

I think the missing thing that makes the "Unimplemented" error is the lack of service descriptors, in the C++ client able to communicate with the server, it is specified "com.test.Broker".

The lack of examples and documentation makes all of that particularly tough to figure out, do you have any idea ?
Thanks.