From f5d0f9096290f5583235cb9cc61dcbb3aa942d61 Mon Sep 17 00:00:00 2001 From: Kegan Dougal <7190048+kegsay@users.noreply.github.com> Date: Fri, 12 Jul 2024 14:46:12 +0100 Subject: [PATCH] Move RPC code to its own package And rename to avoid stuttering. --- cmd/rpc/main.go | 4 +- internal/cc/test_context.go | 3 +- .../deploy/{rpc_client.go => rpc/client.go} | 66 +++++++++---------- .../deploy/{rpc_server.go => rpc/server.go} | 64 +++++++++--------- internal/tests/client_test.go | 3 +- 5 files changed, 71 insertions(+), 69 deletions(-) rename internal/deploy/{rpc_client.go => rpc/client.go} (84%) rename internal/deploy/{rpc_server.go => rpc/server.go} (79%) diff --git a/cmd/rpc/main.go b/cmd/rpc/main.go index 6ba4309..7bced3f 100644 --- a/cmd/rpc/main.go +++ b/cmd/rpc/main.go @@ -7,11 +7,11 @@ import ( "net/http" "net/rpc" - "github.com/matrix-org/complement-crypto/internal/deploy" + crpc "github.com/matrix-org/complement-crypto/internal/deploy/rpc" ) func main() { - srv := deploy.NewRPCServer() + srv := crpc.NewServer() rpc.Register(srv) rpc.HandleHTTP() listener, err := net.Listen("tcp", ":0") diff --git a/internal/cc/test_context.go b/internal/cc/test_context.go index da55ed1..169b356 100644 --- a/internal/cc/test_context.go +++ b/internal/cc/test_context.go @@ -8,6 +8,7 @@ import ( "github.com/matrix-org/complement-crypto/internal/api" "github.com/matrix-org/complement-crypto/internal/api/langs" "github.com/matrix-org/complement-crypto/internal/deploy" + "github.com/matrix-org/complement-crypto/internal/deploy/rpc" "github.com/matrix-org/complement/client" "github.com/matrix-org/complement/ct" "github.com/matrix-org/complement/helpers" @@ -113,7 +114,7 @@ func (c *TestContext) mustCreateMultiprocessClient(t *testing.T, req *ClientCrea return nil } ctxPrefix := fmt.Sprintf("%d", c.RPCInstance.Add(1)) - remoteBindings, err := deploy.NewRPCLanguageBindings(c.RPCBinaryPath, req.User.ClientType.Lang, ctxPrefix) + remoteBindings, err := rpc.NewLanguageBindings(c.RPCBinaryPath, req.User.ClientType.Lang, ctxPrefix) if err != nil { t.Fatalf("Failed to create new RPC language bindings: %s", err) } diff --git a/internal/deploy/rpc_client.go b/internal/deploy/rpc/client.go similarity index 84% rename from internal/deploy/rpc_client.go rename to internal/deploy/rpc/client.go index 8675bdf..392faf7 100644 --- a/internal/deploy/rpc_client.go +++ b/internal/deploy/rpc/client.go @@ -1,4 +1,4 @@ -package deploy +package rpc import ( "bufio" @@ -15,27 +15,27 @@ import ( "github.com/matrix-org/complement/ct" ) -// RPCLanguageBindings implements api.LanguageBindings and instead issues RPC calls to a remote server. -type RPCLanguageBindings struct { +// LanguageBindings implements api.LanguageBindings and instead issues RPC calls to a remote server. +type LanguageBindings struct { binaryPath string clientType api.ClientTypeLang contextPrefix string } -func NewRPCLanguageBindings(rpcBinaryPath string, clientType api.ClientTypeLang, contextPrefix string) (*RPCLanguageBindings, error) { - return &RPCLanguageBindings{ +func NewLanguageBindings(rpcBinaryPath string, clientType api.ClientTypeLang, contextPrefix string) (*LanguageBindings, error) { + return &LanguageBindings{ binaryPath: rpcBinaryPath, clientType: clientType, contextPrefix: contextPrefix, }, nil } -func (r *RPCLanguageBindings) PreTestRun(contextID string) { +func (r *LanguageBindings) PreTestRun(contextID string) { // do nothing, as PreTestRun for all tests is meaningless for RPC clients. // If we were to call the underlying bindings, we would delete logs prematurely. // Instead, we do this call when RPC clients are made. } -func (r *RPCLanguageBindings) PostTestRun(contextID string) { +func (r *LanguageBindings) PostTestRun(contextID string) { // do nothing, as PostTestRun for all tests is meaningless for RPC clients. // If we were to call the underlying bindings, we would delete logs prematurely. // Instead, we do this call when RPC clients are closed. @@ -47,7 +47,7 @@ func (r *RPCLanguageBindings) PostTestRun(contextID string) { // - the server cannot be started // - IPC via stdout fails (used to extract the random high numbered port) // - the client cannot talk to the rpc server -func (r *RPCLanguageBindings) MustCreateClient(t ct.TestLike, cfg api.ClientCreationOpts) api.Client { +func (r *LanguageBindings) MustCreateClient(t ct.TestLike, cfg api.ClientCreationOpts) api.Client { contextID := fmt.Sprintf("%s%s_%s", r.contextPrefix, strings.Replace(cfg.UserID[1:], ":", "_", -1), cfg.DeviceID) // security: check it is a file not a random bash script... if _, err := os.Stat(r.binaryPath); err != nil { @@ -122,7 +122,7 @@ func (r *RPCLanguageBindings) MustCreateClient(t ct.TestLike, cfg api.ClientCrea t.Fatalf("DialHTTP: %s", err) } - err = client.Call("RPCServer.MustCreateClient", RPCClientCreationOpts{ + err = client.Call("Server.MustCreateClient", ClientCreationOpts{ ClientCreationOpts: cfg, ContextID: contextID, Lang: r.clientType, @@ -164,7 +164,7 @@ func (c *RPCClient) Close(t ct.TestLike) { t.Helper() var void int fmt.Println("RPCClient.Close") - err := c.client.Call("RPCServer.Close", t.Name(), &void) + err := c.client.Call("Server.Close", t.Name(), &void) if err != nil { t.Fatalf("RPCClient.Close: %s", err) } @@ -177,13 +177,13 @@ func (c *RPCClient) GetNotification(t ct.TestLike, roomID, eventID string) (*api RoomID: roomID, EventID: eventID, } - err := c.client.Call("RPCServer.GetNotification", input, ¬ification) + err := c.client.Call("Server.GetNotification", input, ¬ification) return ¬ification, err } func (c *RPCClient) CurrentAccessToken(t ct.TestLike) string { var token string - err := c.client.Call("RPCServer.CurrentAccessToken", t.Name(), &token) + err := c.client.Call("Server.CurrentAccessToken", t.Name(), &token) if err != nil { ct.Fatalf(t, "RPCServer.CurrentAccessToken: %s", err) } @@ -205,7 +205,7 @@ func (c *RPCClient) InviteUser(t ct.TestLike, roomID, userID string) error { // Remove any persistent storage, if it was enabled. func (c *RPCClient) DeletePersistentStorage(t ct.TestLike) { var void int - err := c.client.Call("RPCServer.DeletePersistentStorage", t.Name(), &void) + err := c.client.Call("Server.DeletePersistentStorage", t.Name(), &void) if err != nil { t.Fatalf("RPCClient.DeletePersistentStorage: %s", err) } @@ -213,7 +213,7 @@ func (c *RPCClient) DeletePersistentStorage(t ct.TestLike) { func (c *RPCClient) Login(t ct.TestLike, opts api.ClientCreationOpts) error { var void int fmt.Printf("RPCClient Calling login with %+v\n", opts) - err := c.client.Call("RPCServer.Login", opts, &void) + err := c.client.Call("Server.Login", opts, &void) fmt.Println("RPCClient login returned => ", err) return err } @@ -224,12 +224,12 @@ func (c *RPCClient) Login(t ct.TestLike, opts api.ClientCreationOpts) error { // Fails the test if there was a problem syncing. func (c *RPCClient) MustStartSyncing(t ct.TestLike) (stopSyncing func()) { var void int - err := c.client.Call("RPCServer.MustStartSyncing", t.Name(), &void) + err := c.client.Call("Server.MustStartSyncing", t.Name(), &void) if err != nil { t.Fatalf("RPCClient.MustStartSyncing: %s", err) } return func() { - err := c.client.Call("RPCServer.StopSyncing", t.Name(), &void) + err := c.client.Call("Server.StopSyncing", t.Name(), &void) if err != nil { t.Fatalf("RPCClient.StopSyncing: %s", err) } @@ -242,12 +242,12 @@ func (c *RPCClient) MustStartSyncing(t ct.TestLike) (stopSyncing func()) { // Returns an error if there was a problem syncing. func (c *RPCClient) StartSyncing(t ct.TestLike) (stopSyncing func(), err error) { var void int - err = c.client.Call("RPCServer.StartSyncing", t.Name(), &void) + err = c.client.Call("Server.StartSyncing", t.Name(), &void) if err != nil { return } return func() { - err := c.client.Call("RPCServer.StopSyncing", t.Name(), &void) + err := c.client.Call("Server.StopSyncing", t.Name(), &void) if err != nil { t.Logf("RPCClient.StopSyncing: %s", err) } @@ -258,14 +258,14 @@ func (c *RPCClient) StartSyncing(t ct.TestLike) (stopSyncing func(), err error) // provide a bogus room ID. func (c *RPCClient) IsRoomEncrypted(t ct.TestLike, roomID string) (bool, error) { var isEncrypted bool - err := c.client.Call("RPCServer.IsRoomEncrypted", roomID, &isEncrypted) + err := c.client.Call("Server.IsRoomEncrypted", roomID, &isEncrypted) return isEncrypted, err } // SendMessage sends the given text as an m.room.message with msgtype:m.text into the given // room. Returns the event ID of the sent event, so MUST BLOCK until the event has been sent. func (c *RPCClient) SendMessage(t ct.TestLike, roomID, text string) (eventID string) { - err := c.client.Call("RPCServer.SendMessage", RPCSendMessage{ + err := c.client.Call("Server.SendMessage", RPCSendMessage{ TestName: t.Name(), RoomID: roomID, Text: text, @@ -278,7 +278,7 @@ func (c *RPCClient) SendMessage(t ct.TestLike, roomID, text string) (eventID str // TrySendMessage tries to send the message, but can fail. func (c *RPCClient) TrySendMessage(t ct.TestLike, roomID, text string) (eventID string, err error) { - err = c.client.Call("RPCServer.TrySendMessage", RPCSendMessage{ + err = c.client.Call("Server.TrySendMessage", RPCSendMessage{ TestName: t.Name(), RoomID: roomID, Text: text, @@ -290,7 +290,7 @@ func (c *RPCClient) TrySendMessage(t ct.TestLike, roomID, text string) (eventID // a pre-defined one like api.CheckEventHasMembership, api.CheckEventHasBody, or api.CheckEventHasEventID. func (c *RPCClient) WaitUntilEventInRoom(t ct.TestLike, roomID string, checker func(e api.Event) bool) api.Waiter { var waiterID int - err := c.client.Call("RPCServer.WaitUntilEventInRoom", RPCWaitUntilEvent{ + err := c.client.Call("Server.WaitUntilEventInRoom", RPCWaitUntilEvent{ TestName: t.Name(), RoomID: roomID, }, &waiterID) @@ -307,7 +307,7 @@ func (c *RPCClient) WaitUntilEventInRoom(t ct.TestLike, roomID string, checker f // Backpaginate in this room by `count` events. func (c *RPCClient) MustBackpaginate(t ct.TestLike, roomID string, count int) { var void int - err := c.client.Call("RPCServer.MustBackpaginate", RPCBackpaginate{ + err := c.client.Call("Server.MustBackpaginate", RPCBackpaginate{ TestName: t.Name(), RoomID: roomID, Count: count, @@ -320,7 +320,7 @@ func (c *RPCClient) MustBackpaginate(t ct.TestLike, roomID string, count int) { // MustGetEvent will return the client's view of this event, or fail the test if the event cannot be found. func (c *RPCClient) MustGetEvent(t ct.TestLike, roomID, eventID string) api.Event { var ev api.Event - err := c.client.Call("RPCServer.MustGetEvent", RPCGetEvent{ + err := c.client.Call("Server.MustGetEvent", RPCGetEvent{ TestName: t.Name(), RoomID: roomID, EventID: eventID, @@ -333,7 +333,7 @@ func (c *RPCClient) MustGetEvent(t ct.TestLike, roomID, eventID string) api.Even // MustBackupKeys will backup E2EE keys, else fail the test. func (c *RPCClient) MustBackupKeys(t ct.TestLike) (recoveryKey string) { - err := c.client.Call("RPCServer.MustBackupKeys", 0, &recoveryKey) + err := c.client.Call("Server.MustBackupKeys", 0, &recoveryKey) if err != nil { t.Fatalf("RPCClient.MustBackupKeys: %v", err) } @@ -343,7 +343,7 @@ func (c *RPCClient) MustBackupKeys(t ct.TestLike) (recoveryKey string) { // MustLoadBackup will recover E2EE keys from the latest backup, else fail the test. func (c *RPCClient) MustLoadBackup(t ct.TestLike, recoveryKey string) { var void int - err := c.client.Call("RPCServer.MustLoadBackup", recoveryKey, &void) + err := c.client.Call("Server.MustLoadBackup", recoveryKey, &void) if err != nil { t.Fatalf("RPCClient.MustLoadBackup: %v", err) } @@ -352,7 +352,7 @@ func (c *RPCClient) MustLoadBackup(t ct.TestLike, recoveryKey string) { // LoadBackup will recover E2EE keys from the latest backup, else return an error. func (c *RPCClient) LoadBackup(t ct.TestLike, recoveryKey string) error { var void int - return c.client.Call("RPCServer.LoadBackup", recoveryKey, &void) + return c.client.Call("Server.LoadBackup", recoveryKey, &void) } // Log something to stdout and the underlying client log file @@ -360,7 +360,7 @@ func (c *RPCClient) Logf(t ct.TestLike, format string, args ...interface{}) { str := fmt.Sprintf(format, args...) str = t.Name() + ": " + str var void int - err := c.client.Call("RPCServer.Logf", str, &void) + err := c.client.Call("Server.Logf", str, &void) if err != nil { t.Fatalf("RPCClient.Logf: %s", err) } @@ -368,17 +368,17 @@ func (c *RPCClient) Logf(t ct.TestLike, format string, args ...interface{}) { func (c *RPCClient) UserID() string { var userID string - c.client.Call("RPCServer.UserID", 0, &userID) + c.client.Call("Server.UserID", 0, &userID) return userID } func (c *RPCClient) Type() api.ClientTypeLang { var lang api.ClientTypeLang - c.client.Call("RPCServer.Type", 0, &lang) + c.client.Call("Server.Type", 0, &lang) return lang } func (c *RPCClient) Opts() api.ClientCreationOpts { var opts api.ClientCreationOpts - c.client.Call("RPCServer.Opts", 0, &opts) + c.client.Call("Server.Opts", 0, &opts) return opts } @@ -401,7 +401,7 @@ func (w *RPCWaiter) TryWaitf(t ct.TestLike, s time.Duration, format string, args var void int msg := fmt.Sprintf(format, args...) t.Logf("RPCWaiter.TryWaitf: calling RPCServer.WaiterStart") - err := w.client.Call("RPCServer.WaiterStart", RPCWait{ + err := w.client.Call("Server.WaiterStart", RPCWait{ TestName: t.Name(), WaiterID: w.waiterID, Msg: msg, @@ -415,7 +415,7 @@ func (w *RPCWaiter) TryWaitf(t ct.TestLike, s time.Duration, format string, args for { var eventsToCheck []api.Event t.Logf("RPCWaiter.TryWaitf: calling RPCServer.WaiterPoll") - err := w.client.Call("RPCServer.WaiterPoll", w.waiterID, &eventsToCheck) + err := w.client.Call("Server.WaiterPoll", w.waiterID, &eventsToCheck) if err != nil { return fmt.Errorf("%s: %s", err, msg) } diff --git a/internal/deploy/rpc_server.go b/internal/deploy/rpc/server.go similarity index 79% rename from internal/deploy/rpc_server.go rename to internal/deploy/rpc/server.go index 442c3f3..976e470 100644 --- a/internal/deploy/rpc_server.go +++ b/internal/deploy/rpc/server.go @@ -1,4 +1,4 @@ -package deploy +package rpc import ( "fmt" @@ -13,12 +13,12 @@ import ( const InactivityThreshold = 30 * time.Second -// RPCServer exposes the api.Client interface over the wire, consumed via net/rpc. +// Server exposes the api.Client interface over the wire, consumed via net/rpc. // Args and return params must be encodable with encoding/gob. // All functions on this struct must meet the form: // // func (t *T) MethodName(argType T1, replyType *T2) error -type RPCServer struct { +type Server struct { contextID string // test|user|device bindings api.LanguageBindings activeClient api.Client @@ -30,8 +30,8 @@ type RPCServer struct { lastCmdRecvMu *sync.Mutex } -func NewRPCServer() *RPCServer { - srv := &RPCServer{ +func NewServer() *Server { + srv := &Server{ waiters: make(map[int]*RPCServerWaiter), waitersMu: &sync.Mutex{}, lastCmdRecv: time.Now(), @@ -41,7 +41,7 @@ func NewRPCServer() *RPCServer { return srv } -type RPCClientCreationOpts struct { +type ClientCreationOpts struct { api.ClientCreationOpts Lang api.ClientTypeLang // need to know the type for pulling out the corret bindings ContextID string @@ -50,7 +50,7 @@ type RPCClientCreationOpts struct { // When the RPC server is run locally, we want to make sure we don't persist as an orphan process // if the test suite crashes. We do this by checking that we have seen an RPC command within // InactivityThreshold duration. -func (s *RPCServer) checkKeepAlive() { +func (s *Server) checkKeepAlive() { ticker := time.NewTicker(time.Second) for range ticker.C { s.lastCmdRecvMu.Lock() @@ -62,14 +62,14 @@ func (s *RPCServer) checkKeepAlive() { } } -func (s *RPCServer) keepAlive() { +func (s *Server) keepAlive() { s.lastCmdRecvMu.Lock() defer s.lastCmdRecvMu.Unlock() s.lastCmdRecv = time.Now() } // MustCreateClient creates a given client and returns it to the caller, else returns an error. -func (s *RPCServer) MustCreateClient(opts RPCClientCreationOpts, void *int) error { +func (s *Server) MustCreateClient(opts ClientCreationOpts, void *int) error { defer s.keepAlive() fmt.Printf("RPCServer: Received MustCreateClient: %+v\n", opts) if s.activeClient != nil { @@ -86,7 +86,7 @@ func (s *RPCServer) MustCreateClient(opts RPCClientCreationOpts, void *int) erro return nil } -func (s *RPCServer) Close(testName string, void *int) error { +func (s *Server) Close(testName string, void *int) error { defer s.keepAlive() s.activeClient.Close(&api.MockT{TestName: testName}) // write logs @@ -94,30 +94,30 @@ func (s *RPCServer) Close(testName string, void *int) error { return nil } -func (s *RPCServer) DeletePersistentStorage(testName string, void *int) error { +func (s *Server) DeletePersistentStorage(testName string, void *int) error { defer s.keepAlive() s.activeClient.DeletePersistentStorage(&api.MockT{TestName: testName}) return nil } -func (s *RPCServer) CurrentAccessToken(testName string, token *string) error { +func (s *Server) CurrentAccessToken(testName string, token *string) error { defer s.keepAlive() *token = s.activeClient.CurrentAccessToken(&api.MockT{TestName: testName}) return nil } -func (s *RPCServer) Login(opts api.ClientCreationOpts, void *int) error { +func (s *Server) Login(opts api.ClientCreationOpts, void *int) error { defer s.keepAlive() return s.activeClient.Login(&api.MockT{}, opts) } -func (s *RPCServer) MustStartSyncing(testName string, void *int) error { +func (s *Server) MustStartSyncing(testName string, void *int) error { defer s.keepAlive() s.stopSyncing = s.activeClient.MustStartSyncing(&api.MockT{TestName: testName}) return nil } -func (s *RPCServer) StartSyncing(testName string, void *int) error { +func (s *Server) StartSyncing(testName string, void *int) error { defer s.keepAlive() stopSyncing, err := s.activeClient.StartSyncing(&api.MockT{TestName: testName}) if err != nil { @@ -127,7 +127,7 @@ func (s *RPCServer) StartSyncing(testName string, void *int) error { return nil } -func (s *RPCServer) StopSyncing(testName string, void *int) error { +func (s *Server) StopSyncing(testName string, void *int) error { defer s.keepAlive() if s.stopSyncing == nil { return fmt.Errorf("%s RPCServer.StopSyncing: cannot stop syncing as StartSyncing wasn't called", testName) @@ -137,7 +137,7 @@ func (s *RPCServer) StopSyncing(testName string, void *int) error { return nil } -func (s *RPCServer) IsRoomEncrypted(roomID string, isEncrypted *bool) error { +func (s *Server) IsRoomEncrypted(roomID string, isEncrypted *bool) error { defer s.keepAlive() var err error *isEncrypted, err = s.activeClient.IsRoomEncrypted(&api.MockT{}, roomID) @@ -150,13 +150,13 @@ type RPCSendMessage struct { Text string } -func (s *RPCServer) SendMessage(msg RPCSendMessage, eventID *string) error { +func (s *Server) SendMessage(msg RPCSendMessage, eventID *string) error { defer s.keepAlive() *eventID = s.activeClient.SendMessage(&api.MockT{TestName: msg.TestName}, msg.RoomID, msg.Text) return nil } -func (s *RPCServer) TrySendMessage(msg RPCSendMessage, eventID *string) error { +func (s *Server) TrySendMessage(msg RPCSendMessage, eventID *string) error { defer s.keepAlive() var err error *eventID, err = s.activeClient.TrySendMessage(&api.MockT{TestName: msg.TestName}, msg.RoomID, msg.Text) @@ -171,7 +171,7 @@ type RPCWaitUntilEvent struct { RoomID string } -func (s *RPCServer) WaitUntilEventInRoom(input RPCWaitUntilEvent, waiterID *int) error { +func (s *Server) WaitUntilEventInRoom(input RPCWaitUntilEvent, waiterID *int) error { defer s.keepAlive() waiter := s.activeClient.WaitUntilEventInRoom(&api.MockT{TestName: input.TestName}, input.RoomID, func(e api.Event) bool { s.waitersMu.Lock() @@ -208,7 +208,7 @@ type RPCWait struct { // WaiterStart is the RPC equivalent to Waiter.Waitf. It begins accumulating events for the RPC client to check. // Clients need to call WaiterPoll to get these new events. -func (s *RPCServer) WaiterStart(input RPCWait, void *int) error { +func (s *Server) WaiterStart(input RPCWait, void *int) error { defer s.keepAlive() s.waitersMu.Lock() w := s.waiters[input.WaiterID] @@ -232,7 +232,7 @@ func (s *RPCServer) WaiterStart(input RPCWait, void *int) error { return nil } -func (s *RPCServer) WaiterPoll(waiterID int, eventsToCheck *[]api.Event) error { +func (s *Server) WaiterPoll(waiterID int, eventsToCheck *[]api.Event) error { defer s.keepAlive() fmt.Println("Acquiring lock") s.waitersMu.Lock() @@ -261,7 +261,7 @@ type RPCBackpaginate struct { Count int } -func (s *RPCServer) MustBackpaginate(input RPCBackpaginate, void *int) error { +func (s *Server) MustBackpaginate(input RPCBackpaginate, void *int) error { defer s.keepAlive() s.activeClient.MustBackpaginate(&api.MockT{TestName: input.TestName}, input.RoomID, input.Count) return nil @@ -274,14 +274,14 @@ type RPCGetEvent struct { } // MustGetEvent will return the client's view of this event, or fail the test if the event cannot be found. -func (s *RPCServer) MustGetEvent(input RPCGetEvent, output *api.Event) error { +func (s *Server) MustGetEvent(input RPCGetEvent, output *api.Event) error { defer s.keepAlive() *output = s.activeClient.MustGetEvent(&api.MockT{TestName: input.TestName}, input.RoomID, input.EventID) return nil } // MustBackupKeys will backup E2EE keys, else fail the test. -func (s *RPCServer) MustBackupKeys(testName string, recoveryKey *string) error { +func (s *Server) MustBackupKeys(testName string, recoveryKey *string) error { defer s.keepAlive() *recoveryKey = s.activeClient.MustBackupKeys(&api.MockT{TestName: testName}) return nil @@ -292,7 +292,7 @@ type RPCGetNotification struct { EventID string } -func (s *RPCServer) GetNotification(input RPCGetNotification, output *api.Notification) (err error) { +func (s *Server) GetNotification(input RPCGetNotification, output *api.Notification) (err error) { defer s.keepAlive() var n *api.Notification n, err = s.activeClient.GetNotification(&api.MockT{}, input.RoomID, input.EventID) @@ -303,35 +303,35 @@ func (s *RPCServer) GetNotification(input RPCGetNotification, output *api.Notifi } // MustLoadBackup will recover E2EE keys from the latest backup, else fail the test. -func (s *RPCServer) MustLoadBackup(recoveryKey string, void *int) error { +func (s *Server) MustLoadBackup(recoveryKey string, void *int) error { defer s.keepAlive() s.activeClient.MustLoadBackup(&api.MockT{}, recoveryKey) return nil } -func (s *RPCServer) LoadBackup(recoveryKey string, void *int) error { +func (s *Server) LoadBackup(recoveryKey string, void *int) error { defer s.keepAlive() return s.activeClient.LoadBackup(&api.MockT{}, recoveryKey) } -func (s *RPCServer) Logf(input string, void *int) error { +func (s *Server) Logf(input string, void *int) error { defer s.keepAlive() log.Println(input) s.activeClient.Logf(&api.MockT{}, input) return nil } -func (s *RPCServer) UserID(void int, userID *string) error { +func (s *Server) UserID(void int, userID *string) error { defer s.keepAlive() *userID = s.activeClient.UserID() return nil } -func (s *RPCServer) Type(void int, clientType *api.ClientTypeLang) error { +func (s *Server) Type(void int, clientType *api.ClientTypeLang) error { defer s.keepAlive() *clientType = s.activeClient.Type() return nil } -func (s *RPCServer) Opts(void int, opts *api.ClientCreationOpts) error { +func (s *Server) Opts(void int, opts *api.ClientCreationOpts) error { defer s.keepAlive() *opts = s.activeClient.Opts() return nil diff --git a/internal/tests/client_test.go b/internal/tests/client_test.go index 5535886..b60f332 100644 --- a/internal/tests/client_test.go +++ b/internal/tests/client_test.go @@ -16,6 +16,7 @@ import ( "github.com/matrix-org/complement-crypto/internal/api/js" "github.com/matrix-org/complement-crypto/internal/api/rust" "github.com/matrix-org/complement-crypto/internal/deploy" + "github.com/matrix-org/complement-crypto/internal/deploy/rpc" "github.com/matrix-org/complement/b" "github.com/matrix-org/complement/client" "github.com/matrix-org/complement/helpers" @@ -60,7 +61,7 @@ func TestMain(m *testing.M) { rpcBinary := os.Getenv("COMPLEMENT_CRYPTO_RPC_BINARY") if rpcBinary != "" { clientFactories = append(clientFactories, func(t *testing.T, cfg api.ClientCreationOpts) api.Client { - remoteBindings, err := deploy.NewRPCLanguageBindings(rpcBinary, api.ClientTypeRust, "") + remoteBindings, err := rpc.NewLanguageBindings(rpcBinary, api.ClientTypeRust, "") if err != nil { log.Fatal(err) }