Peer backup

peer/brontide.go

@@ -514,6 +514,10 @@ type Brontide struct {
 
 	// log is a peer-specific logging instance.
 	log btclog.Logger
+
+	// backupData is an in-memory store for data that we store for our
+	// peers.
+	backupData lnwire.PeerStorageBlob
 }
 
 // A compile-time check to ensure that Brontide satisfies the lnpeer.Peer interface.
@@ -1824,6 +1828,12 @@ out:
 			discStream.AddMsg(msg)
 
 		case *lnwire.PeerStorage:
+			err = p.handlePeerStorageMessage(msg)
+			if err != nil {
+				p.storeError(err)
+				p.log.Errorf("%v", err)
+			}
+
 		case *lnwire.PeerStorageRetrieval:
 			err = p.handlePeerStorageRetrieval()
 			if err != nil {
@@ -4169,6 +4179,42 @@ func (p *Brontide) handleRemovePendingChannel(req *newChannelMsg) {
 	p.addedChannels.Delete(chanID)
 }
 
+// handlePeerStorageMessage handles `PeerStorage` message, it stores the message
+// and sends it back to the peer as an ack.
+func (p *Brontide) handlePeerStorageMessage(msg *lnwire.PeerStorage) error {
+	// Check if we have the feature to store peer backup enabled.
+	if !p.LocalFeatures().HasFeature(lnwire.ProvideStorageOptional) {
+		warning := "received peer storage message but not " +
+			"advertising required feature bit"
+
+		if err := p.SendMessage(false, &lnwire.Warning{
+			ChanID: lnwire.ConnectionWideID,
+			Data:   []byte(warning),
+		}); err != nil {
+			return err
+		}
+
+		p.Disconnect(errors.New(warning))
+
+		return nil
+	}
+
+	// If we have no active channels with this peer, we return quickly.
+	if !p.hasActiveChannels() {
+		p.log.Tracef("Received peerStorage message from "+
+			"peer(%v) with no active channels -- ignoring",
+			p.String())
+
+		return nil
+	}
+
+	p.log.Debugf("handling peerbackup for peer(%s)", p)
+
+	p.backupData = msg.Blob
+
+	return nil
+}
+
 // sendLinkUpdateMsg sends a message that updates the channel to the
 // channel's message stream.
 func (p *Brontide) sendLinkUpdateMsg(cid lnwire.ChannelID, msg lnwire.Message) {

peer/brontide_test.go

@@ -16,6 +16,7 @@ import (
 	"github.com/lightningnetwork/lnd/fn"
 	"github.com/lightningnetwork/lnd/htlcswitch"
 	"github.com/lightningnetwork/lnd/lntest/wait"
+	"github.com/lightningnetwork/lnd/lnutils"
 	"github.com/lightningnetwork/lnd/lnwallet"
 	"github.com/lightningnetwork/lnd/lnwallet/chancloser"
 	"github.com/lightningnetwork/lnd/lnwire"
@@ -1442,3 +1443,129 @@ func TestHandlePeerStorageRetrieval(t *testing.T) {
 	// Test that we disconnect.
 	require.True(t, peer.IsDisconnected())
 }
+
+// TestHandlePeerStorage tests handling peer storage message.
+func TestHandlePeerStorage(t *testing.T) {
+	t.Parallel()
+	rt := require.New(t)
+
+	// Create test data.
+	blob := []byte{0x9c, 0x40, 0x1, 0x2, 0x3}
+
+	testCases := []struct {
+		name        string
+		msgTestFunc func(msg lnwire.Message)
+		setUpFunc   func(peer *Brontide)
+		noSendMsg   bool
+		disconnect  bool
+		backupData  lnwire.PeerStorageBlob
+	}{
+		{
+			name: "option peer storage disabled",
+			msgTestFunc: func(msg lnwire.Message) {
+				// In this case, we expect to send a warning to
+				// this peer.
+				rt.IsType(msg, &lnwire.Warning{})
+			},
+			disconnect: true,
+		},
+		{
+			name: "option peer storage enabled, active channels " +
+				"present",
+			setUpFunc: func(peer *Brontide) {
+				// Enable option_peer_storage.
+				peer.cfg.Features = lnwire.NewFeatureVector(
+					lnwire.NewRawFeatureVector(
+						lnwire.ProvideStorageOptional,
+					),
+					lnwire.Features,
+				)
+
+				// Add a  dummy active channel.
+				chanID := lnwire.NewChanIDFromOutPoint(
+					wire.OutPoint{Index: 1},
+				)
+				peer.activeChannels.Store(
+					chanID, &lnwallet.LightningChannel{},
+				)
+			},
+			noSendMsg:  true,
+			backupData: blob,
+		},
+		{
+			name: "option peer storage enabled, active channels " +
+				"absent",
+			setUpFunc: func(peer *Brontide) {
+				// Enable option_peer_storage.
+				peer.cfg.Features = lnwire.NewFeatureVector(
+					lnwire.NewRawFeatureVector(
+						lnwire.ProvideStorageOptional,
+					),
+					lnwire.Features,
+				)
+
+				peer.activeChannels = &lnutils.SyncMap[
+					lnwire.ChannelID,
+					*lnwallet.LightningChannel,
+				]{}
+			},
+			noSendMsg: true,
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			params := createTestPeer(t)
+			peer := params.peer
+
+			// The backupData should be nil on initialization.
+			rt.Nil(peer.backupData)
+
+			// Send a signal to this channel to indicate readiness
+			// for potential peer disconnection.
+			close(peer.startReady)
+
+			if tc.setUpFunc != nil {
+				tc.setUpFunc(peer)
+			}
+
+			// Buffer outgoingQueue to prevent blocking.
+			peer.outgoingQueue = make(chan outgoingMsg, 1)
+
+			peerStorageMsg, err := lnwire.NewPeerStorageMsg(
+				blob,
+			)
+			rt.NoError(err)
+
+			// Call the method.
+			err = peer.handlePeerStorageMessage(peerStorageMsg)
+			rt.NoError(err)
+
+			// Test for the backup data stored in memory.
+			rt.Equal(tc.backupData, peer.backupData)
+
+			// Test for expected outgoing messages, if any.
+			select {
+			case receivedMsg := <-peer.outgoingQueue:
+				if !tc.noSendMsg {
+					tc.msgTestFunc(receivedMsg.msg)
+
+					return
+				}
+
+				t.Fatalf("received unexpected "+
+					"message %v",
+					receivedMsg.msg.MsgType())
+
+			case <-time.After(2 * time.Second):
+				if !tc.noSendMsg {
+					t.Fatalf("did not receive message " +
+						"as expected.")
+				}
+			}
+
+			// Check if the peer should be disconnected.
+			rt.Equal(tc.disconnect, peer.IsDisconnected())
+		})
+	}
+}