update wsh code for easier creation of client servers (for readfile/readdir/fileinfo) (#218)

pkg/wshrpc/wshserver/wshserver.go

@@ -23,12 +23,49 @@ import (
 	"github.com/wavetermdev/thenextwave/pkg/waveobj"
 	"github.com/wavetermdev/thenextwave/pkg/wps"
 	"github.com/wavetermdev/thenextwave/pkg/wshrpc"
+	"github.com/wavetermdev/thenextwave/pkg/wshrpc/wshclient"
 	"github.com/wavetermdev/thenextwave/pkg/wshutil"
 	"github.com/wavetermdev/thenextwave/pkg/wstore"
 )
 
 const SimpleId_This = "this"
 
+func (ws *WshServer) TestCommand(ctx context.Context, data string) error {
+	defer func() {
+		if r := recover(); r != nil {
+			log.Printf("panic in TestCommand: %v", r)
+		}
+	}()
+	rpc := wshutil.GetWshRpcFromContext(ctx)
+	if rpc == nil {
+		return nil
+	}
+	go func() {
+		wshclient.MessageCommand(rpc, wshrpc.CommandMessageData{Message: "test message"}, &wshrpc.WshRpcCommandOpts{NoResponse: true})
+		resp, err := wshclient.RemoteFileInfoCommand(rpc, "~/work/wails/thenextwave/README.md", nil)
+		if err != nil {
+			log.Printf("error getting remote file info: %v", err)
+			return
+		}
+		log.Printf("remote file info: %#v\n", resp)
+
+		rch := wshclient.RemoteStreamFileCommand(rpc, wshrpc.CommandRemoteStreamFileData{Path: "~/work/wails/thenextwave/README.md"}, nil)
+		for msg := range rch {
+			if msg.Error != nil {
+				log.Printf("error in stream: %v", msg.Error)
+				break
+			}
+			if msg.Response.FileInfo != nil {
+				log.Printf("stream resp (fileinfo): %v\n", msg.Response.FileInfo)
+			}
+			if msg.Response.Data64 != "" {
+				log.Printf("stream resp (data): %v\n", len(msg.Response.Data64))
+			}
+		}
+	}()
+	return nil
+}
+
 func (ws *WshServer) AuthenticateCommand(ctx context.Context, data string) error {
 	w := wshutil.GetWshRpcFromContext(ctx)
 	if w == nil {

pkg/wshrpc/wshserver/wshserverutil.go

@@ -10,7 +10,6 @@ import (
 	"net"
 	"reflect"
 
-	"github.com/wavetermdev/thenextwave/pkg/util/utilfn"
 	"github.com/wavetermdev/thenextwave/pkg/wshrpc"
 	"github.com/wavetermdev/thenextwave/pkg/wshutil"
 )
@@ -24,6 +23,8 @@ const (
 
 type WshServer struct{}
 
+func (*WshServer) WshServerImpl() {}
+
 type WshServerMethodDecl struct {
 	Command                 string
 	CommandType             string
@@ -88,75 +89,6 @@ func decodeRtnVals(rtnVals []reflect.Value) (any, error) {
 	}
 }
 
-func mainWshServerHandler(handler *wshutil.RpcResponseHandler) bool {
-	command := handler.GetCommand()
-	methodDecl := wshCommandDeclMap[command]
-	if methodDecl == nil {
-		handler.SendResponseError(fmt.Errorf("command %q not found", command))
-		return true
-	}
-	var callParams []reflect.Value
-	callParams = append(callParams, reflect.ValueOf(handler.Context()))
-	if methodDecl.CommandDataType != nil {
-		commandData := reflect.New(methodDecl.CommandDataType).Interface()
-		err := utilfn.ReUnmarshal(commandData, handler.GetCommandRawData())
-		if err != nil {
-			handler.SendResponseError(fmt.Errorf("error re-marshalling command data: %w", err))
-			return true
-		}
-		wshrpc.HackRpcContextIntoData(commandData, handler.GetRpcContext())
-		callParams = append(callParams, reflect.ValueOf(commandData).Elem())
-	}
-	implVal := reflect.ValueOf(&WshServerImpl)
-	implMethod := implVal.MethodByName(methodDecl.MethodName)
-	if !implMethod.IsValid() {
-		if !handler.NeedsResponse() {
-			// we also send an out of band message here since this is likely unexpected and will require debugging
-			handler.SendMessage(fmt.Sprintf("command %q method %q not found", handler.GetCommand(), methodDecl.MethodName))
-		}
-		handler.SendResponseError(fmt.Errorf("method %q not found", methodDecl.MethodName))
-		return true
-	}
-	if methodDecl.CommandType == wshrpc.RpcType_Call {
-		rtnVals := implMethod.Call(callParams)
-		rtnData, rtnErr := decodeRtnVals(rtnVals)
-		if rtnErr != nil {
-			handler.SendResponseError(rtnErr)
-			return true
-		}
-		handler.SendResponse(rtnData, true)
-		return true
-	} else if methodDecl.CommandType == wshrpc.RpcType_ResponseStream {
-		rtnVals := implMethod.Call(callParams)
-		rtnChVal := rtnVals[0]
-		if rtnChVal.IsNil() {
-			handler.SendResponse(nil, true)
-			return true
-		}
-		go func() {
-			defer handler.Finalize()
-			// must use reflection here because we don't know the generic type of RespOrErrorUnion
-			for {
-				respVal, ok := rtnChVal.Recv()
-				if !ok {
-					break
-				}
-				errorVal := respVal.FieldByName("Error")
-				if !errorVal.IsNil() {
-					handler.SendResponseError(errorVal.Interface().(error))
-					break
-				}
-				respData := respVal.FieldByName("Response").Interface()
-				handler.SendResponse(respData, false)
-			}
-		}()
-		return false
-	} else {
-		handler.SendResponseError(fmt.Errorf("unsupported command type %q", methodDecl.CommandType))
-		return true
-	}
-}
-
 func RunWshRpcOverListener(listener net.Listener) {
 	defer log.Printf("domain socket listener shutting down\n")
 	for {
@@ -167,10 +99,10 @@ func RunWshRpcOverListener(listener net.Listener) {
 		}
 		log.Print("got domain socket connection\n")
 		// TODO deal with closing connection
-		go wshutil.SetupConnRpcClient(conn, mainWshServerHandler)
+		go wshutil.SetupConnRpcClient(conn, &WshServerImpl)
 	}
 }
 
 func MakeWshServer(inputCh chan []byte, outputCh chan []byte, initialCtx wshrpc.RpcContext) {
-	wshutil.MakeWshRpc(inputCh, outputCh, initialCtx, mainWshServerHandler)
+	wshutil.MakeWshRpc(inputCh, outputCh, initialCtx, &WshServerImpl)
 }