GRPC Objective-C not calling handler on response - objective-c

Question

I'm running into an issue where I'm sending the message to the server (golang) but the response is not getting to the client (objective-c). To be clear, I see the log statement from the server with the correct message from the client. However, I don't see the response on the client. Furthermore, I've noticed that if my server is shutdown, the client does not have any issues getting to the same wait(), but that may be just my lack of understanding of the API. One important thing to note is that I'm not using cocopods or any other build tool for the client. As a learning exercise I'm attempting to build directly against the grpc objective-c source. I've attached my Makefile. Take note of the GRPC_CLIENT_SOURCE variable in the Makefile. I've had to do that as there are header files included there that do not exist in the grpc repo. That "feels" like where the problem is but I've learning that my feelings were useless through the years.
Many thanks in advance!
Here is my code:
Server:
package main
import (
"context"
"log"
"net"
"github.com/asharif/chatterbox/pb"
"google.golang.org/grpc"
)
// UserService is used for creating accounts and logins
type UserService struct{}
func main() {
initLogger()
startServer()
}
func initLogger() {
log.SetFlags(log.Ldate | log.Ltime | log.Lmicroseconds | log.Llongfile)
}
func startServer() {
log.Println("Starting server on port 9000")
lis, err := net.Listen("tcp", ":9000")
if err != nil {
log.Fatalf("failed to listen: %v", err)
}
s := grpc.NewServer()
pb.RegisterUserServiceServer(s, &UserService{})
if err := s.Serve(lis); err != nil {
log.Fatalf("failed to serve: %v", err)
}
}
// Create creates a new user
func (i *UserService) Create(ctx context.Context, req *pb.Request) (*pb.Response, error) {
log.Printf("Received: %v", req.Username)
return &pb.Response{Success: true, Msg: "Hello from server"}, nil
}
// Login attempts a login
func (i *UserService) Login(ctx context.Context, req *pb.Request) (*pb.Response, error) {
return &pb.Response{Success: true, Msg: "Hello "}, nil
}
Client:
#import <Foundation/Foundation.h>
#import "pb/User.pbobjc.h"
#import "pb/User.pbrpc.h"
int main (int argc, const char * argv[]) {
#autoreleasepool {
NSString* host = #"localhost:9000";
[GRPCCall useInsecureConnectionsForHost:host];
UserService* client = [[UserService alloc] initWithHost:host];
Request* req = [Request message];
req.username = #"yo from obj-c";
NSLog(#"callling server yo...");
NSCondition* cond = [[NSCondition alloc] init];
__block BOOL done = NO;
[client createWithRequest:req handler:^(Response *response, NSError *error) {
if (response) {
// Successful response received
NSLog(#"YES");
} else {
// RPC error
NSLog(#"GAH");
}
[cond lock];
done=YES;
[cond signal];
[cond unlock];
}];
[cond lock];
while(!done)
[cond wait];
[cond unlock];
}
return 0;
}
Makefile:
SHELL:=/bin/bash
VERSION:=local
BIN_DIR:=bin
# Protobuf stuff
PB_SOURCE_DIR:=/opt/protobuf/objectivec/
PB_SOURCE:=$(PB_SOURCE_DIR)/GPBProtocolBuffers.m
PB_DIR:=`pwd`/src/protobuf
PB_DEF_DIR:=`pwd`/src/protobuf/def
DEF:=$(shell find $(PB_DEF_DIR) -name '*.proto')
PB:=$(patsubst %.proto, %.pb, $(DEF))
# GRPC stuff
GRPC_SOURCE_DIR:=/opt/grpc/src/objective-c
GRPC_INC:=-I $(GRPC_SOURCE_DIR)
GRPC_CLIENT_SOURCE:=$(GRPC_SOURCE_DIR)/GRPCClient/GRPCCall.m $(GRPC_SOURCE_DIR)/GRPCClient/GRPCCallOptions.m $(GRPC_SOURCE_DIR)/GRPCClient/private/GRPCCallInternal.m $(GRPC_SOURCE_DIR)/GRPCClient/GRPCInterceptor.m $(GRPC_SOURCE_DIR)/GRPCClient/private/GRPCChannelPool.m $(GRPC_SOURCE_DIR)/GRPCClient/private/GRPCChannel.m $(GRPC_SOURCE_DIR)/GRPCClient/private/GRPCCompletionQueue.m $(GRPC_SOURCE_DIR)/GRPCClient/private/GRPCCronetChannelFactory.m $(GRPC_SOURCE_DIR)/GRPCClient/GRPCCall+ChannelCredentials.m $(GRPC_SOURCE_DIR)/GRPCClient/private/GRPCHost.m $(GRPC_SOURCE_DIR)/GRPCClient/private/GRPCInsecureChannelFactory.m $(GRPC_SOURCE_DIR)/GRPCClient/private/ChannelArgsUtil.m $(GRPC_SOURCE_DIR)/GRPCClient/private/GRPCWrappedCall.m $(GRPC_SOURCE_DIR)/GRPCClient/private/GRPCRequestHeaders.m $(GRPC_SOURCE_DIR)/GRPCClient/private/GRPCSecureChannelFactory.m $(GRPC_SOURCE_DIR)/GRPCClient/private/NSError+GRPC.m $(GRPC_SOURCE_DIR)/GRPCClient/GRPCCall+Interceptor.m $(GRPC_SOURCE_DIR)/GRPCClient/private/NSDictionary+GRPC.m $(GRPC_SOURCE_DIR)/GRPCClient/private/NSData+GRPC.m $(GRPC_SOURCE_DIR)/GRPCClient/GRPCCall+Tests.m
GRPC_PROTORPC_SOURCE:=$(shell find $(GRPC_SOURCE_DIR)/ProtoRPC -name '*.m')
GRPC_RXLIBRARY_SOURCE:=$(shell find $(GRPC_SOURCE_DIR)/RxLibrary -name '*.m')
GRPC_CLIENT_OBJ:=$(patsubst %.m, %.o, $(GRPC_CLIENT_SOURCE))
GRPC_PROTORPC_OBJ:=$(patsubst %.m, %.o, $(GRPC_PROTORPC_SOURCE))
GRPC_RXLIBRARY_OBJ:=$(patsubst %.m, %.o, $(GRPC_RXLIBRARY_SOURCE))
# Server stuff
SERVER_DIR:=`pwd`/src/server
SERVER_PB_DIR:=$(SERVER_DIR)/pb
SERVER_BIN:=$(shell basename $(CURDIR))-server
# Client stuff
CC:=clang
grpc: CFLAGS:=-fobjc-arc
PB_OBJ:=$(patsubst %.m, %.o, $(PB_SOURCE))
CLIENT_DIR:=`pwd`/src/client
CLIENT_PB_DIR:=$(CLIENT_DIR)/pb
CLIENT_INC:=-I $(PB_SOURCE_DIR) $(GRPC_INC)
CLIENT_LIBS:=-lgrpc
CLIENT_SOURCE:=$(shell find $(CLIENT_DIR) -name '*.m')
CLIENT_OBJ:=$(patsubst %.m, %.o, $(CLIENT_SOURCE))
CLIENT_FRAMEWORKS:=-framework Foundation
CLIENT_OBJ_DIR:=$(CLIENT_DIR)/obj
CLIENT_BIN:=$(shell basename $(CURDIR))-client
# Build the protobuf dist
protobuf: $(PB)
#mv $(PB_DIR)/*.go $(SERVER_PB_DIR)
#mv $(PB_DIR)/*.h $(CLIENT_PB_DIR)
#mv $(PB_DIR)/*.m $(CLIENT_PB_DIR)
%.pb : %.proto
#protoc -I $(PB_DEF_DIR) $< --go_out=plugins=grpc:$(PB_DIR)
#protoc -I $(PB_DEF_DIR) $< --objc_out=$(PB_DIR) --objcgrpc_out=$(PB_DIR)
# Build the server
server:
#mkdir -p $(BIN_DIR)
#cd src/server/; go build -o ../../$(BIN_DIR)/$(SERVER_BIN)-$(VERSION)
# Build the client
client: |dir pb grpc $(CLIENT_OBJ)
#mv *.o $(CLIENT_OBJ_DIR)
#$(CC) $(CFLAGS) $(CLIENT_FRAMEWORKS) $(CLIENT_LIBS) -o $(BIN_DIR)/$(CLIENT_BIN)-$(VERSION) $(CLIENT_OBJ_DIR)/**
pb: $(PB_OBJ)
grpc: $(GRPC_PROTORPC_OBJ) $(GRPC_CLIENT_OBJ) $(GRPC_RXLIBRARY_OBJ)
%.o: %.m
$(CC) $(CFLAGS) -c $(CLIENT_INC) $<
dir:
#mkdir -p $(BIN_DIR)
#mkdir -p $(CLIENT_OBJ_DIR)
clean:
#rm -f bin/*
#rm -f src/server/pb/**
#rm -f src/client/pb/**
#for i in `find . -iname "*.o"`; do rm $$i; done;
#for i in `find $(PB_SOURCE_DIR)/ -iname "*.o"`; do rm $$i; done;

Answer 1

GRPC puts your handler methods in dispatch_queue. You need to process your dispatch queue since your are using a command line application.
Just replace return 0 with dispatch_main() and you should be able to get into your handler.
Once you used dispatch_main() your program has no idea if all the handlers are processed or not so it blocks forever. You can do this to exit your program normally once all your handlers has been processed.
// create a dispatch group
dispatch_group_t serviceGroup = dispatch_group_create();
dispatch_group_enter(serviceGroup);
[client createWithRequest:req handler:^(Response *response, NSError *error) {
...
dispatch_group_leave(serviceGroup);
}];
...
// exit once the main queue is dispatched
dispatch_group_notify(serviceGroup, dispatch_get_main_queue(), ^{
exit(EXIT_SUCCESS);
});
This is the link to another example.