Merge pull request #53 from ellemouton/serverConnStatus

multi: server connection status

Author: guggero

cmd/wasm-client/lnd_conn.go

@@ -16,7 +16,7 @@ import (
 func mailboxRPCConnection(mailboxServer, pairingPhrase string,
 	localStatic keychain.SingleKeyECDH, remoteStatic *btcec.PublicKey,
 	onRemoteStatic func(key *btcec.PublicKey) error,
-	onAuthData func(data []byte) error) (func() mailbox.ConnStatus,
+	onAuthData func(data []byte) error) (func() mailbox.ClientStatus,
 	func() (*grpc.ClientConn, error), error) {
 
 	words := strings.Split(pairingPhrase, " ")

cmd/wasm-client/main.go

@@ -140,7 +140,7 @@ type wasmClient struct {
 
 	lndConn *grpc.ClientConn
 
-	statusChecker func() mailbox.ConnStatus
+	statusChecker func() mailbox.ClientStatus
 
 	mac *macaroon.Macaroon
 

itest/client_harness.go

@@ -19,6 +19,7 @@ type clientHarness struct {
 
 	grpcConn   *grpc.ClientConn
 	clientConn mockrpc.MockServiceClient
+	client     *mailbox.Client
 
 	passphraseEntropy []byte
 	localStatic       keychain.SingleKeyECDH
@@ -65,6 +66,7 @@ func (c *clientHarness) start() error {
 	if err != nil {
 		return err
 	}
+	c.client = transportConn
 
 	noiseConn := mailbox.NewNoiseGrpcConn(connData)
 

itest/connection_test.go

@@ -3,15 +3,20 @@ package itest
 import (
 	"context"
 	"crypto/rand"
+	"time"
 
 	"github.com/lightninglabs/lightning-node-connect/itest/mockrpc"
+	"github.com/lightninglabs/lightning-node-connect/mailbox"
+	"github.com/lightningnetwork/lnd/lntest/wait"
 	"github.com/stretchr/testify/require"
 )
 
 var (
 	defaultMessage = []byte("some default message")
 )
 
+const defaultTimeout = 30 * time.Second
+
 // testHappyPath ensures that client and server are able to communicate
 // as expected in the case where no connections are dropped.
 func testHappyPath(t *harnessTest) {
@@ -28,8 +33,11 @@ func testHappyPath(t *harnessTest) {
 // testHashmailServerReconnect tests that client and server are able to
 // continue with their communication after the hashmail server restarts.
 func testHashmailServerReconnect(t *harnessTest) {
-	ctx := context.Background()
+	// Assert that the server and client are connected.
+	assertServerStatus(t, mailbox.ServerStatusInUse)
+	assertClientStatus(t, mailbox.ClientStatusConnected)
 
+	ctx := context.Background()
 	resp, err := t.client.clientConn.MockServiceMethod(
 		ctx, &mockrpc.Request{Req: defaultMessage},
 	)
@@ -40,19 +48,31 @@ func testHashmailServerReconnect(t *harnessTest) {
 	require.NoError(t.t, t.hmserver.stop())
 	t.t.Logf("")
 
+	// Check that the client and server status are updated appropriately.
+	assertServerStatus(t, mailbox.ServerStatusNotConnected)
+	assertClientStatus(t, mailbox.ClientStatusNotConnected)
+
 	// Restart hashmail server
 	require.NoError(t.t, t.hmserver.start())
 
+	// Check that the client and server successfully reconnect.
+	assertServerStatus(t, mailbox.ServerStatusInUse)
+	assertClientStatus(t, mailbox.ClientStatusConnected)
+
 	resp, err = t.client.clientConn.MockServiceMethod(
 		ctx, &mockrpc.Request{Req: defaultMessage},
 	)
 	require.NoError(t.t, err)
 	require.Equal(t.t, len(defaultMessage)*10, len(resp.Resp))
 }
 
+// testClientReconnect tests that the client and server are able to reestablish
+// their connection if the client disconnects and reconnects.
 func testClientReconnect(t *harnessTest) {
-	ctx := context.Background()
+	// Assert that the server and client are connected.
+	assertServerStatus(t, mailbox.ServerStatusInUse)
 
+	ctx := context.Background()
 	resp, err := t.client.clientConn.MockServiceMethod(
 		ctx, &mockrpc.Request{Req: defaultMessage},
 	)
@@ -62,34 +82,50 @@ func testClientReconnect(t *harnessTest) {
 	// Stop the client.
 	require.NoError(t.t, t.client.cleanup())
 
+	// Check that the server status is updated appropriately.
+	assertServerStatus(t, mailbox.ServerStatusIdle)
+
 	// Restart the client.
 	require.NoError(t.t, t.client.start())
 
+	// Check that the client and server successfully reconnect.
+	assertServerStatus(t, mailbox.ServerStatusInUse)
+
 	resp, err = t.client.clientConn.MockServiceMethod(
 		ctx, &mockrpc.Request{Req: defaultMessage},
 	)
 	require.NoError(t.t, err)
 	require.Equal(t.t, len(defaultMessage)*10, len(resp.Resp))
 }
 
+// testServerReconnect tests that the client and server are able to reestablish
+// their connection if the server disconnects and reconnects.
 func testServerReconnect(t *harnessTest) {
-	ctx := context.Background()
+	// Assert that the server and client are connected.
+	assertClientStatus(t, mailbox.ClientStatusConnected)
 
+	ctx := context.Background()
 	resp, err := t.client.clientConn.MockServiceMethod(
 		ctx, &mockrpc.Request{Req: defaultMessage},
 	)
 	require.NoError(t.t, err)
 	require.Equal(t.t, len(defaultMessage)*10, len(resp.Resp))
 
 	t.server.stop()
+
+	// Assert that the client status is updated appropriately.
+	assertClientStatus(t, mailbox.ClientStatusSessionNotFound)
+
 	require.NoError(t.t, t.server.start())
 
 	select {
 	case err := <-t.server.errChan:
 		if err != nil {
 			t.Fatalf("could not start server: %v", err)
 		}
-	default:
+
+	case <-time.After(defaultTimeout):
+		t.Fatalf("could not start server in time")
 	}
 
 	// To replicate how the browser's behaviour, we retry this call a few
@@ -102,10 +138,16 @@ func testServerReconnect(t *harnessTest) {
 			break
 		}
 	}
+
 	require.NoError(t.t, err)
 	require.Equal(t.t, len(defaultMessage)*10, len(resp.Resp))
+
+	// Assert that the client's status has been correctly updated.
+	assertClientStatus(t, mailbox.ClientStatusConnected)
 }
 
+// testLargeResponse tests that the client and server can successfully send
+// a large amount of data back and forth reliably.
 func testLargeResponse(t *harnessTest) {
 	ctx := context.Background()
 
@@ -119,3 +161,20 @@ func testLargeResponse(t *harnessTest) {
 	require.NoError(t.t, err)
 	require.Equal(t.t, len(req)*10, len(resp.Resp))
 }
+
+func assertServerStatus(t *harnessTest, status mailbox.ServerStatus) {
+	err := wait.Predicate(func() bool {
+		t.server.statusMu.Lock()
+		defer t.server.statusMu.Unlock()
+
+		return t.server.status == status
+	}, defaultTimeout)
+	require.NoError(t.t, err)
+}
+
+func assertClientStatus(t *harnessTest, status mailbox.ClientStatus) {
+	err := wait.Predicate(func() bool {
+		return t.client.client.ConnStatus() == status
+	}, defaultTimeout)
+	require.NoError(t.t, err)
+}

itest/server_harness.go

@@ -25,6 +25,9 @@ type serverHarness struct {
 
 	tlsConfig *tls.Config
 
+	status   mailbox.ServerStatus
+	statusMu sync.Mutex
+
 	errChan chan error
 	wg      sync.WaitGroup
 }
@@ -74,7 +77,11 @@ func (s *serverHarness) start() error {
 	)
 
 	mailboxServer, err := mailbox.NewServer(
-		s.serverHost, connData, grpc.WithTransportCredentials(
+		s.serverHost, connData, func(status mailbox.ServerStatus) {
+			s.statusMu.Lock()
+			s.status = status
+			s.statusMu.Unlock()
+		}, grpc.WithTransportCredentials(
 			credentials.NewTLS(s.tlsConfig),
 		),
 	)

mailbox/client.go

@@ -14,7 +14,7 @@ type Client struct {
 
 	connData *ConnData
 
-	status   ConnStatus
+	status   ClientStatus
 	statusMu sync.Mutex
 
 	sid [64]byte
@@ -33,7 +33,7 @@ func NewClient(ctx context.Context, connData *ConnData) (*Client, error) {
 	return &Client{
 		ctx:      ctx,
 		connData: connData,
-		status:   ConnStatusNotConnected,
+		status:   ClientStatusNotConnected,
 		sid:      sid,
 	}, nil
 }
@@ -73,7 +73,7 @@ func (c *Client) Dial(_ context.Context, serverHost string) (net.Conn, error) {
 
 	if c.mailboxConn == nil {
 		mailboxConn, err := NewClientConn(
-			c.ctx, c.sid, serverHost, func(status ConnStatus) {
+			c.ctx, c.sid, serverHost, func(status ClientStatus) {
 				c.statusMu.Lock()
 				c.status = status
 				c.statusMu.Unlock()
@@ -95,7 +95,7 @@ func (c *Client) Dial(_ context.Context, serverHost string) (net.Conn, error) {
 }
 
 // ConnStatus returns last determined client connection status.
-func (c *Client) ConnStatus() ConnStatus {
+func (c *Client) ConnStatus() ClientStatus {
 	c.statusMu.Lock()
 	defer c.statusMu.Unlock()