Grpc.Core.RpcException method is unimplemented with C# client and Java Server

I am having trouble finding the source of this error. I implemented a simple service using protobuf:

syntax = "proto3";

package tourism;

service RemoteService {
  rpc Login(LoginUserDTO) returns (Response) {}
}

message AgencyDTO{
  int32 id=1;
  string name=2;
  string email=3;
  string password=4;
}

message LoginUserDTO{
  string password=1;
  string email=2;
}

message SearchAttractionsDTO{
  string name=1;
  int32 start_hour=2;
  int32 start_minute=3;
  int32 stop_hour=4;
  int32 stop_minute=5;
  AgencyDTO loggedUser=6;
}

message AttractionDTO{
  int32 id=1;
  string name=2;
  string agency=3;
  int32 hour=4;
  int32 minute=5;
  int32 seats=6;
  int32 price=7;
}

message ReservationDTO{
  int32 id=1;
  string first_name=2;
  string last_name=3;
  string phone=4;
  int32 seats=5;
  AttractionDTO attraction=6;
  AgencyDTO agency=7;
}

message Response{
  enum ResponseType{
    OK=0;
    NOT_LOGGED_ID=1;
    SERVER_ERROR=2;
    VALIDATOR_ERROR=3;
  }
  ResponseType type=1;
  AgencyDTO user=2;
  string message=3;
}

When using a java client everything works fine, the server receives the request and responds appropriately. When using C# with the same .proto file for generating sources at the client.Login() I get the following errror: Grpc.Core.RpcException Status(StatusCode=Unimplemented, Detail=”Method tourism.RemoteService/Login is unimplemented”). The server receives the request but does not have time to respond and throws:

INFO: Request from [e-mail]
May 22, 2017 12:28:58 AM io.grpc.internal.SerializingExecutor run
SEVERE: Exception while executing runnable io.grpc.internal.ServerImpl$JumpToApplicationThreadServerStreamListener$2@4be43082
java.lang.IllegalStateException: call is closed
    at com.google.common.base.Preconditions.checkState(Preconditions.java:174)
    at io.grpc.internal.ServerCallImpl.sendHeaders(ServerCallImpl.java:103)
    at io.grpc.stub.ServerCalls$ServerCallStreamObserverImpl.onNext(ServerCalls.java:282)
    at ServiceImp.login(ServiceImp.java:20)
    at tourism.RemoteServiceGrpc$MethodHandlers.invoke(RemoteServiceGrpc.java:187)
    at io.grpc.stub.ServerCalls$1$1.onHalfClose(ServerCalls.java:148)
    at io.grpc.internal.ServerCallImpl$ServerStreamListenerImpl.halfClosed(ServerCallImpl.java:262)
    at io.grpc.internal.ServerImpl$JumpToApplicationThreadServerStreamListener$2.runInContext(ServerImpl.java:572)
    at io.grpc.internal.ContextRunnable.run(ContextRunnable.java:52)
    at io.grpc.internal.SerializingExecutor.run(SerializingExecutor.java:117)
    at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1142)
    at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:617)
    at java.lang.Thread.run(Thread.java:745)

Java server:

import io.grpc.Server;
import io.grpc.ServerBuilder;
import io.grpc.stub.StreamObserver;
import tourism.RemoteServiceGrpc;
import tourism.Service;

import java.io.IOException;
import java.util.logging.Level;
import java.util.logging.Logger;

/**
 * Created by Andu on 21/05/2017.
 */
public class ServerGrpc {
    Logger logger= Logger.getLogger(ServerGrpc.class.getName());
    private final Server server;
    private final int port;

    public ServerGrpc(int p){
        port=p;
        server= ServerBuilder.forPort(port).addService(new ServiceImp()).build();
    }

    public void start() throws IOException {
        server.start();
        logger.info("Server started, listening on " + port);
        Runtime.getRuntime().addShutdownHook(new Thread() {
            @Override
            public void run() {
                // Use stderr here since the logger may has been reset by its JVM shutdown hook.
                System.err.println("*** shutting down gRPC server since JVM is shutting down");
                ServerGrpc.this.stop();
                System.err.println("*** server shut down");
            }
        });
    }

    public void stop() {
        if (server != null) {
            server.shutdown();
        }
    }

    void blockUntilShutdown() throws InterruptedException {
        if (server != null) {
            server.awaitTermination();
        }
    }

    private class ServiceImp extends RemoteServiceGrpc.RemoteServiceImplBase {
        Logger log=Logger.getLogger(ServiceImp.class.getName());

        @Override
        public void login(Service.LoginUserDTO request, StreamObserver<Service.Response> responseStreamObserver){
            super.login(request,responseStreamObserver);
            log.log(Level.INFO,"Request from "+request.getEmail());
            Service.Response response= Service.Response.newBuilder().setMessage("Hello "+request.getEmail()+", I know your password: "+request.getPassword()).build();
            responseStreamObserver.onNext(response);
            responseStreamObserver.onCompleted();
        }
    }

}

C# Client:

namespace testGrpc2
{
    class MainClass
    {
        public static void Main(string[] args)
        {
            var channel = new Channel("127.0.0.1:61666",ChannelCredentials.Insecure);
            var client = new RemoteService.RemoteServiceClient(channel);
            Response response=client.Login(new LoginUserDTO{Email="[e-mail]",Password="notmypassword"});
            Console.WriteLine(response);
            Console.ReadKey();
        }
    }
} 

Answer

I managed to find the source of the problem. For anyone else having this problem:

Make sure your .proto file is identical for both client and server and it has the same package. When the client calls a method on the remote server, it uses the full name of the remote class and the package.

However this was not the reason why the method appeared as unimplemented to the client. It was this:

super.login(request,responseStreamObserver);

Calling the super method login sends an async UNIMPLEMENTED error code back to the client. This is the login() method in the generated class:

public void login(LoginUserDTO request,StreamObserver<Response> responseObserver) {
          asyncUnimplementedUnaryCall(METHOD_LOGIN, responseObserver);
}

So make sure in the implementation of your service methods you don’t call the super method as it will appear to the client as UNIMPLEMENTED. If you generate @Override methods using IntelliJ IDEA it will add the super method call. Make sure to delete it.