fix handling of types.

Author: raulk

client.go

@@ -171,7 +171,7 @@ func httpClient(ctx context.Context, addr string, namespace string, outs []inter
 			return clientResponse{}, xerrors.Errorf("http status %s unmarshaling response: %w", httpResp.Status, err)
 		}
 
-		if resp.ID, err = translateID(resp.ID); err != nil {
+		if resp.ID, err = normalizeID(resp.ID); err != nil {
 			return clientResponse{}, xerrors.Errorf("failed to response ID: %w", err)
 		}
 
@@ -471,7 +471,7 @@ func (fn *rpcFunc) processError(err error) []reflect.Value {
 }
 
 func (fn *rpcFunc) handleRpcCall(args []reflect.Value) (results []reflect.Value) {
-	id := atomic.AddInt64(&fn.client.idCtr, 1)
+	var id interface{} = atomic.AddInt64(&fn.client.idCtr, 1)
 	params := make([]param, len(args)-fn.hasCtx)
 	for i, arg := range args[fn.hasCtx:] {
 		enc, found := fn.client.paramEncoders[arg.Type()]
@@ -506,6 +506,16 @@ func (fn *rpcFunc) handleRpcCall(args []reflect.Value) (results []reflect.Value)
 		retVal, chCtor = fn.client.makeOutChan(ctx, fn.ftyp, fn.valOut)
 	}
 
+	// Prepare the ID to send on the wire.
+	// We track int64 ids as float64 in the inflight map (because that's what
+	// they'll be decoded to). encoding/json outputs numbers with their minimal
+	// encoding, avoding the decimal point when possible, i.e. 3 will never get
+	// converted to 3.0.
+	id, err := normalizeID(id)
+	if err != nil {
+		return fn.processError(fmt.Errorf("failed to normalize id")) // should probably panic
+	}
+
 	req := request{
 		Jsonrpc: "2.0",
 		ID:      id,
@@ -529,7 +539,6 @@ func (fn *rpcFunc) handleRpcCall(args []reflect.Value) (results []reflect.Value)
 	}
 
 	var resp clientResponse
-	var err error
 	// keep retrying if got a forced closed websocket conn and calling method
 	// has retry annotation
 	for attempt := 0; true; attempt++ {

handler.go

@@ -174,7 +174,7 @@ func (s *RPCServer) handleReader(ctx context.Context, r io.Reader, w io.Writer,
 		return
 	}
 
-	if req.ID, err = translateID(req.ID); err != nil {
+	if req.ID, err = normalizeID(req.ID); err != nil {
 		rpcError(wf, &req, rpcParseError, xerrors.Errorf("failed to parse ID: %w", err))
 		return
 	}

rpc_test.go

@@ -1130,7 +1130,7 @@ func TestIDHandling(t *testing.T) {
 		t.Run(fmt.Sprintf("%v", tc.expect), func(t *testing.T) {
 			dec := json.NewDecoder(strings.NewReader(tc.str))
 			require.NoError(t, dec.Decode(&decoded))
-			if id, err := translateID(decoded.ID); !tc.expectErr {
+			if id, err := normalizeID(decoded.ID); !tc.expectErr {
 				require.NoError(t, err)
 				require.Equal(t, tc.expect, id)
 			} else {

websocket.go

@@ -297,7 +297,7 @@ func (c *wsConn) cancelCtx(req frame) {
 		log.Warnf("%s call with ID set, won't respond", wsCancel)
 	}
 
-	var id int64
+	var id interface{}
 	if err := json.Unmarshal(req.Params[0].data, &id); err != nil {
 		log.Error("handle me:", err)
 		return
@@ -610,7 +610,7 @@ func (c *wsConn) handleWsConn(ctx context.Context) {
 
 				var frame frame
 				if err = json.NewDecoder(r).Decode(&frame); err == nil {
-					if frame.ID, err = translateID(frame.ID); err == nil {
+					if frame.ID, err = normalizeID(frame.ID); err == nil {
 						c.handleFrame(ctx, frame)
 						go c.nextMessage()
 						continue
@@ -687,11 +687,14 @@ func (c *wsConn) handleWsConn(ctx context.Context) {
 	}
 }
 
-// Takes an ID as received on the wire, validates it, and translates it to a normalized ID appropriate for keying.
-func translateID(id interface{}) (interface{}, error) {
+// Takes an ID as received on the wire, validates it, and translates it to a
+// normalized ID appropriate for keying.
+func normalizeID(id interface{}) (interface{}, error) {
 	switch v := id.(type) {
 	case string, float64, nil:
 		return v, nil
+	case int64: // clients sending int64 need to normalize to float64
+		return float64(v), nil
 	default:
 		return nil, xerrors.Errorf("invalid id type: %T", id)
 	}