How do I resolve "unimplemented" error, when using gRPC? - rust

Question

I have created a gRPC server and client in Rust and it was working, but then I made changes to the .proto file, then updated all the type names etc accordingly but now I run into an "unimplemented" error.
The error occurs when checking that the response is okay, but the root cause must be something when actually send the request. The server never prints "got a request..."
I suspect it's something really stupid.
ERROR MESSAGE
Ok(Err(Status { code: Unimplemented, metadata: MetadataMap { headers: {"date": "Wed, 27 Jul 2022 09:20:55 GMT", "content-type": "application/grpc", "content-length": "0"} }, source: None }))
thread 'main' panicked at 'assertion failed: resp.unwrap().is_ok()', src/Rust/client.rs:52:9
PROTO BUFFER
syntax = "proto3";
package Labels;
service Labelling {
rpc storeLabel (StoreLabelRequest) returns (StoreLabelResponse);
rpc getLabel (GetLabelRequest) returns (GetLabelResponse);
}
message StoreLabelRequest{
string header = 1;
}
message StoreLabelResponse{
bool successful = 1;
string new_id = 2;
}
message GetLabelRequest{
string label_id = 1;
}
message GetLabelResponse{
string header = 1;
}
SERVER
pub mod documents{
tonic::include_proto!("labels");
}
#[derive(Debug, Default)]
pub struct LabelService {}
#[tonic::async_trait]
impl Labelling for LabelService {
async fn store_label(
&self,
request: Request<StoreLabelRequest>,
) -> Result<Response<StoreLabelResponse>, Status> {
println!("Got a request: {:?}", request);
let req = request.into_inner();
let reply = StoreLabelResponse {
successful: true,
new_id: format!("Document received with header: {}", req.header).into()
};
Ok(Response::new(reply))
}
async fn get_label(
&self,
request: tonic::Request<GetLabelRequest>,
) -> Result<tonic::Response<GetLabelResponse>, tonic::Status>{
let req = request.into_inner();
let reply = GetLabelResponse {
header: format!("Document received with header: {}", req.label_id).into()
};
Ok(Response::new(reply))
}
}
#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
let args: Vec<String> = env::args().collect();
let addr: SocketAddr = args[1].parse()?;
let service = LabelService::default();
Server::builder()
.add_service(LabellingServer::new(service))
.serve(addr)
.await?;
Ok(())
}
CLIENT
pub mod documents{
tonic::include_proto!("label");
}
#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
let args: Vec<String> = env::args().collect();
let message_count: usize = args[1].parse().unwrap();
let address: String = args[2].parse().unwrap();
let full_address: String = "http://".to_string() + address.as_str();
let client = LabellingClient::connect(full_address).await?;
let mut responses = Vec::with_capacity(message_count);
for _ in 0..message_count {
let mut client = client.clone();
let header = "Hello"; // This will be replaced with a file reader but is simplified for the question
let request = tonic::Request::new(StoreLabelRequest {
header: header.to_string()});
responses.push(spawn(async move {
client.store_label(request).await
}));
}
for resp in responses {
let resp = resp.await;
assert!(resp.is_ok());
assert!(resp.unwrap().is_ok()); // <-- This is where the Panic occurs
}
Ok(())
}

Answer 1

As pointed out, the included protos were not lined up, which is not caught at compile-time.