fix(broadcast): client rpc got wrong method

Author: aleksander-vedvik

broadcast.go

@@ -97,25 +97,6 @@ func (srv *broadcastServer) handleClientResponses() {
 func (srv *broadcastServer) handle(response responseMsg) {
 	broadcastID := response.getBroadcastID()
 	req, handled := srv.clientReqs.GetSet(broadcastID)
-	//srv.clientReqsMutex.Lock()
-	//defer srv.clientReqsMutex.Unlock()
-	//req, ok := srv.clientReqs[response.getBroadcastID()]
-	//if !ok {
-	//	// this server has not received a request directly from a client
-	//	// hence, the response should be ignored
-	//	return
-	//} else if req.status == unhandled {
-	//	// first time it is handled
-	//	req.status = response.getType()
-	//} else if req.status == clientResponse || req.status == timeout {
-	//	// already handled, but got the other response type in the pair: clientResponse & timeout
-	//	// or a duplicate
-	//	req.status = done
-	//	return
-	//} else {
-	//	// already handled and can be removed
-	//	return
-	//}
 	if handled {
 		// this server has not received a request directly from a client
 		// hence, the response should be ignored
@@ -135,14 +116,10 @@ func (srv *broadcastServer) handle(response responseMsg) {
 		log.Println("NOT VALID")
 		return
 	}
-	if req.metadata.BroadcastMsg.Sender == BroadcastClient {
-		SendMessage(req.ctx, req.finished, WrapMessage(req.metadata, protoreflect.ProtoMessage(response.getResponse()), response.getError()))
-	}
-	if req.metadata.BroadcastMsg.OriginAddr == "" {
-		return
-	}
-	if handler, ok := srv.clientHandlers[req.metadata.BroadcastMsg.OriginMethod]; ok {
+	if handler, ok := srv.clientHandlers[req.metadata.BroadcastMsg.OriginMethod]; ok && req.metadata.BroadcastMsg.OriginAddr != "" {
 		handler(req.metadata.BroadcastMsg.OriginAddr, broadcastID, response.getResponse())
+	} else if req.metadata.BroadcastMsg.Sender == BroadcastClient {
+		SendMessage(req.ctx, req.finished, WrapMessage(req.metadata, protoreflect.ProtoMessage(response.getResponse()), response.getError()))
 	}
 }
 

clientserver.go

@@ -128,15 +128,15 @@ func ServerClientRPC(method string) func(addr, broadcastID string, in protorefle
 		if len(tmp) >= 1 {
 			m = tmp[len(tmp)-1]
 		}
-		method = "/protos.ClientServer/Client" + m
+		clientMethod := "/protos.ClientServer/Client" + m
 		cc, err := grpc.Dial(addr, grpc.WithTransportCredentials(insecure.NewCredentials()))
 		if err != nil {
 			return nil, err
 		}
 		out := new(any)
 		md := metadata.Pairs(BroadcastID, broadcastID)
 		ctx := metadata.NewOutgoingContext(context.Background(), md)
-		err = cc.Invoke(ctx, method, in, out, opts...)
+		err = cc.Invoke(ctx, clientMethod, in, out, opts...)
 		if err != nil {
 			return nil, err
 		}

cmd/protoc-gen-gorums/dev/zorums_qspec_gorums.pb.go

@@ -3,7 +3,6 @@ package gorums
 import (
 	"context"
 	"fmt"
-	"log"
 	"time"
 
 	"github.com/relab/gorums/ordering"
@@ -29,43 +28,32 @@ func BroadcastHandler[T RequestTypes, V iBroadcastStruct](impl implementationFun
 		defer srv.broadcastSrv.Unlock()
 		req := in.Message.(T)
 		defer ctx.Release()
-		// guard:
-		// - A broadcastID should be non-empty:
-		// - Maybe the request should be unique? Remove duplicates of the same broadcast? <- Most likely no (up to the implementer)
-		if err := srv.broadcastSrv.validateMessage(in); err != nil {
-			log.Fatalln(err, in.Metadata)
-			return
-		}
-		// this does not work yet:
-		//ctx.update(in.Metadata)
-		// it is better if the client provide this data in the request:
-		//if in.Metadata.BroadcastMsg.Sender == "client" && in.Metadata.BroadcastMsg.OriginAddr == "" {
-		//	p, _ := peer.FromContext(ctx)
-		//	in.Metadata.BroadcastMsg.OriginAddr = p.Addr.String()
-		//}
-		addOriginMethod(in.Metadata)
-		broadcastMetadata := newBroadcastMetadata(in.Metadata)
-		// the client can specify middleware, e.g. authentication, to return early.
-		if err := srv.broadcastSrv.runMiddleware(broadcastMetadata); err != nil {
-			// return if any of the middlewares return an error
-			return
-		}
-		//srv.broadcastSrv.b.reset()
-		//srv.broadcastSrv.b.setMetadata(broadcastMetadata)
-		// add the request as a client request
-		srv.broadcastSrv.bNew.setMetadata(broadcastMetadata)
-		srv.broadcastSrv.addClientRequest(in.Metadata, ctx, finished)
-		impl(ctx, req, srv.broadcastSrv.bNew.(V))
-		//srv.broadcastSrv.determineBroadcast(broadcastMetadata)
-		//// verify whether a server or a client sent the request
-		if in.Metadata.BroadcastMsg.Sender == BroadcastClient {
-			go srv.broadcastSrv.timeoutClientResponse(ctx, in, finished)
-			//	//SendMessage(ctx, finished, WrapMessage(in.Metadata, protoreflect.ProtoMessage(nil), nil))
-		} /*else {
-		//	// server to server communication does not need response?
-		//	SendMessage(ctx, finished, WrapMessage(in.Metadata, protoreflect.ProtoMessage(nil), err))
-		//}*/
-		//srv.broadcastSrv.determineReturnToClient(ctx, in.Metadata.BroadcastMsg.GetBroadcastID())
+		doneChan := make(chan struct{})
+		go func() {
+			defer func() { close(doneChan) }()
+			// guard:
+			// - A broadcastID should be non-empty:
+			// - Maybe the request should be unique? Remove duplicates of the same broadcast? <- Most likely no (up to the implementer)
+			if err := srv.broadcastSrv.validateMessage(in); err != nil {
+				return
+			}
+			addOriginMethod(in.Metadata)
+			broadcastMetadata := newBroadcastMetadata(in.Metadata)
+			// the client can specify middleware, e.g. authentication, to return early.
+			if err := srv.broadcastSrv.runMiddleware(broadcastMetadata); err != nil {
+				// return if any of the middlewares return an error
+				return
+			}
+			srv.broadcastSrv.bNew.setMetadata(broadcastMetadata)
+			// add the request as a client request
+			srv.broadcastSrv.addClientRequest(in.Metadata, ctx, finished)
+			impl(ctx, req, srv.broadcastSrv.bNew.(V))
+			//// verify whether a server or a client sent the request
+			//if in.Metadata.BroadcastMsg.Sender == BroadcastClient {
+			//	go srv.broadcastSrv.timeoutClientResponse(ctx, in, finished)
+			//}
+		}()
+		<-doneChan
 	}
 }