client handler / reverse handler alias support

Author: magik6k

client.go

@@ -229,6 +229,7 @@ func websocketClient(ctx context.Context, addr string, namespace string, outs []
 	var hnd reqestHandler
 	if len(config.reverseHandlers) > 0 {
 		h := makeHandler(defaultServerConfig())
+		h.aliasedMethods = config.aliasedHandlerMethods
 		for _, reverseHandler := range config.reverseHandlers {
 			h.register(reverseHandler.ns, reverseHandler.hnd)
 		}
@@ -534,7 +535,7 @@ func (fn *rpcFunc) handleRpcCall(args []reflect.Value) (results []reflect.Value)
 	req := request{
 		Jsonrpc: "2.0",
 		ID:      id,
-		Method:  fn.client.namespace + "." + fn.name,
+		Method:  fn.name,
 		Params:  params,
 	}
 
@@ -590,17 +591,27 @@ func (fn *rpcFunc) handleRpcCall(args []reflect.Value) (results []reflect.Value)
 	return fn.processResponse(resp, retVal())
 }
 
+const (
+	ProxyTagRetry     = "retry"
+	ProxyTagRPCMethod = "rpc_method"
+)
+
 func (c *client) makeRpcFunc(f reflect.StructField) (reflect.Value, error) {
 	ftyp := f.Type
 	if ftyp.Kind() != reflect.Func {
 		return reflect.Value{}, xerrors.New("handler field not a func")
 	}
 
+	name := c.namespace + "." + f.Name
+	if tag, ok := f.Tag.Lookup(ProxyTagRPCMethod); ok {
+		name = tag
+	}
+
 	fun := &rpcFunc{
 		client: c,
 		ftyp:   ftyp,
-		name:   f.Name,
-		retry:  f.Tag.Get("retry") == "true",
+		name:   name,
+		retry:  f.Tag.Get(ProxyTagRetry) == "true",
 	}
 	fun.valOut, fun.errOut, fun.nout = processFuncOut(ftyp)
 

options.go

@@ -23,7 +23,8 @@ type Config struct {
 	paramEncoders map[reflect.Type]ParamEncoder
 	errors        *Errors
 
-	reverseHandlers []clientHandler
+	reverseHandlers       []clientHandler
+	aliasedHandlerMethods map[string]string
 
 	httpClient *http.Client
 
@@ -40,6 +41,8 @@ func defaultConfig() Config {
 		pingInterval: 5 * time.Second,
 		timeout:      30 * time.Second,
 
+		aliasedHandlerMethods: map[string]string{},
+
 		paramEncoders: map[reflect.Type]ParamEncoder{},
 
 		httpClient: _defaultHTTPClient,
@@ -94,6 +97,14 @@ func WithClientHandler(ns string, hnd interface{}) func(c *Config) {
 	}
 }
 
+// WithClientHandlerAlias creates an alias for a client HANDLER method - for handlers created
+// with WithClientHandler
+func WithClientHandlerAlias(alias, original string) func(c *Config) {
+	return func(c *Config) {
+		c.aliasedHandlerMethods[alias] = original
+	}
+}
+
 func WithHTTPClient(h *http.Client) func(c *Config) {
 	return func(c *Config) {
 		c.httpClient = h

rpc_test.go

@@ -1142,10 +1142,39 @@ func TestIDHandling(t *testing.T) {
 	}
 }
 
+func TestAliasedCall(t *testing.T) {
+	// setup server
+
+	rpcServer := NewServer()
+	rpcServer.Register("ServName", &SimpleServerHandler{n: 3})
+
+	// httptest stuff
+	testServ := httptest.NewServer(rpcServer)
+	defer testServ.Close()
+
+	// setup client
+	var client struct {
+		WhateverMethodName func(int) (int, error) `rpc_method:"ServName.AddGet"`
+	}
+	closer, err := NewMergeClient(context.Background(), "ws://"+testServ.Listener.Addr().String(), "Server", []interface{}{
+		&client,
+	}, nil)
+	require.NoError(t, err)
+
+	// do the call!
+
+	n, err := client.WhateverMethodName(1)
+	require.NoError(t, err)
+
+	require.Equal(t, 4, n)
+
+	closer()
+}
+
 // 1. make server call on client **
 // 2. make client handle **
-// 3. alias on client
-// 4. alias call on server
+// 3. alias on client **
+// 4. alias call on server **
 // 6. custom/object param type
 // 7. notif mode proxy tag
 
@@ -1208,3 +1237,56 @@ func TestReverseCall(t *testing.T) {
 
 	closer()
 }
+
+type RevCallTestServerHandlerAliased struct {
+}
+
+func (h *RevCallTestServerHandlerAliased) Call(ctx context.Context) error {
+	revClient, ok := ExtractReverseClient[RevCallTestClientProxyAliased](ctx)
+	if !ok {
+		return fmt.Errorf("no reverse client")
+	}
+
+	r, err := revClient.CallOnClient(8) // multiply by 2 on client
+	if err != nil {
+		return xerrors.Errorf("call on client: %w", err)
+	}
+
+	if r != 16 {
+		return fmt.Errorf("unexpected result: %d", r)
+	}
+
+	return nil
+}
+
+type RevCallTestClientProxyAliased struct {
+	CallOnClient func(int) (int, error) `rpc_method:"rpc_thing"`
+}
+
+func TestReverseCallAliased(t *testing.T) {
+	// setup server
+
+	rpcServer := NewServer(WithReverseClient[RevCallTestClientProxyAliased]("Client"))
+	rpcServer.Register("Server", &RevCallTestServerHandlerAliased{})
+
+	// httptest stuff
+	testServ := httptest.NewServer(rpcServer)
+	defer testServ.Close()
+
+	// setup client
+
+	var client struct {
+		Call func() error
+	}
+	closer, err := NewMergeClient(context.Background(), "ws://"+testServ.Listener.Addr().String(), "Server", []interface{}{
+		&client,
+	}, nil, WithClientHandler("Client", &RevCallTestClientHandler{}), WithClientHandlerAlias("rpc_thing", "Client.CallOnClient"))
+	require.NoError(t, err)
+
+	// do the call!
+
+	e := client.Call()
+	require.NoError(t, e)
+
+	closer()
+}