From ddea833d3109bced93f9ac366d25835aa42b7ab7 Mon Sep 17 00:00:00 2001 From: Oliver Gugger Date: Tue, 21 Sep 2021 19:18:16 +0200 Subject: [PATCH] multi: extract address source into interface As a preparation to have the method for querying the addresses of a node separate from the channel state, we extract that method out into its own interface. --- chanbackup/backup.go | 22 ++++++++++++++-------- chanbackup/backup_test.go | 10 ++++++---- rpcserver.go | 6 +++--- server.go | 7 ++++++- 4 files changed, 29 insertions(+), 16 deletions(-) diff --git a/chanbackup/backup.go b/chanbackup/backup.go index 076e2fcf6..dce1210b2 100644 --- a/chanbackup/backup.go +++ b/chanbackup/backup.go @@ -21,7 +21,11 @@ type LiveChannelSource interface { // passed chanPoint. Optionally an existing db tx can be supplied. FetchChannel(tx kvdb.RTx, chanPoint wire.OutPoint) ( *channeldb.OpenChannel, error) +} +// AddressSource is an interface that allows us to query for the set of +// addresses a node can be connected to. +type AddressSource interface { // AddrsForNode returns all known addresses for the target node public // key. AddrsForNode(nodePub *btcec.PublicKey) ([]net.Addr, error) @@ -31,15 +35,15 @@ type LiveChannelSource interface { // passed open channel. The backup includes all information required to restore // the channel, as well as addressing information so we can find the peer and // reconnect to them to initiate the protocol. -func assembleChanBackup(chanSource LiveChannelSource, +func assembleChanBackup(addrSource AddressSource, openChan *channeldb.OpenChannel) (*Single, error) { log.Debugf("Crafting backup for ChannelPoint(%v)", openChan.FundingOutpoint) // First, we'll query the channel source to obtain all the addresses - // that are are associated with the peer for this channel. - nodeAddrs, err := chanSource.AddrsForNode(openChan.IdentityPub) + // that are associated with the peer for this channel. + nodeAddrs, err := addrSource.AddrsForNode(openChan.IdentityPub) if err != nil { return nil, err } @@ -52,8 +56,8 @@ func assembleChanBackup(chanSource LiveChannelSource, // FetchBackupForChan attempts to create a plaintext static channel backup for // the target channel identified by its channel point. If we're unable to find // the target channel, then an error will be returned. -func FetchBackupForChan(chanPoint wire.OutPoint, - chanSource LiveChannelSource) (*Single, error) { +func FetchBackupForChan(chanPoint wire.OutPoint, chanSource LiveChannelSource, + addrSource AddressSource) (*Single, error) { // First, we'll query the channel source to see if the channel is known // and open within the database. @@ -66,7 +70,7 @@ func FetchBackupForChan(chanPoint wire.OutPoint, // Once we have the target channel, we can assemble the backup using // the source to obtain any extra information that we may need. - staticChanBackup, err := assembleChanBackup(chanSource, targetChan) + staticChanBackup, err := assembleChanBackup(addrSource, targetChan) if err != nil { return nil, fmt.Errorf("unable to create chan backup: %v", err) } @@ -76,7 +80,9 @@ func FetchBackupForChan(chanPoint wire.OutPoint, // FetchStaticChanBackups will return a plaintext static channel back up for // all known active/open channels within the passed channel source. -func FetchStaticChanBackups(chanSource LiveChannelSource) ([]Single, error) { +func FetchStaticChanBackups(chanSource LiveChannelSource, + addrSource AddressSource) ([]Single, error) { + // First, we'll query the backup source for information concerning all // currently open and available channels. openChans, err := chanSource.FetchAllChannels() @@ -89,7 +95,7 @@ func FetchStaticChanBackups(chanSource LiveChannelSource) ([]Single, error) { // channel. staticChanBackups := make([]Single, 0, len(openChans)) for _, openChan := range openChans { - chanBackup, err := assembleChanBackup(chanSource, openChan) + chanBackup, err := assembleChanBackup(addrSource, openChan) if err != nil { return nil, err } diff --git a/chanbackup/backup_test.go b/chanbackup/backup_test.go index e718dce3e..ff321c188 100644 --- a/chanbackup/backup_test.go +++ b/chanbackup/backup_test.go @@ -124,7 +124,9 @@ func TestFetchBackupForChan(t *testing.T) { }, } for i, testCase := range testCases { - _, err := FetchBackupForChan(testCase.chanPoint, chanSource) + _, err := FetchBackupForChan( + testCase.chanPoint, chanSource, chanSource, + ) switch { // If this is a valid test case, and we failed, then we'll // return an error. @@ -167,7 +169,7 @@ func TestFetchStaticChanBackups(t *testing.T) { // With the channel source populated, we'll now attempt to create a set // of backups for all the channels. This should succeed, as all items // are populated within the channel source. - backups, err := FetchStaticChanBackups(chanSource) + backups, err := FetchStaticChanBackups(chanSource, chanSource) if err != nil { t.Fatalf("unable to create chan back ups: %v", err) } @@ -184,7 +186,7 @@ func TestFetchStaticChanBackups(t *testing.T) { copy(n[:], randomChan2.IdentityPub.SerializeCompressed()) delete(chanSource.addrs, n) - _, err = FetchStaticChanBackups(chanSource) + _, err = FetchStaticChanBackups(chanSource, chanSource) if err == nil { t.Fatalf("query with incomplete information should fail") } @@ -193,7 +195,7 @@ func TestFetchStaticChanBackups(t *testing.T) { // source at all, then we'll fail as well. chanSource = newMockChannelSource() chanSource.failQuery = true - _, err = FetchStaticChanBackups(chanSource) + _, err = FetchStaticChanBackups(chanSource, chanSource) if err == nil { t.Fatalf("query should fail") } diff --git a/rpcserver.go b/rpcserver.go index 0e2770421..79f655375 100644 --- a/rpcserver.go +++ b/rpcserver.go @@ -6469,7 +6469,7 @@ func (r *rpcServer) ExportChannelBackup(ctx context.Context, // the database. If this channel has been closed, or the outpoint is // unknown, then we'll return an error unpackedBackup, err := chanbackup.FetchBackupForChan( - chanPoint, r.server.chanStateDB, + chanPoint, r.server.chanStateDB, r.server.addrSource, ) if err != nil { return nil, err @@ -6639,7 +6639,7 @@ func (r *rpcServer) ExportAllChannelBackups(ctx context.Context, // First, we'll attempt to read back ups for ALL currently opened // channels from disk. allUnpackedBackups, err := chanbackup.FetchStaticChanBackups( - r.server.chanStateDB, + r.server.chanStateDB, r.server.addrSource, ) if err != nil { return nil, fmt.Errorf("unable to fetch all static chan "+ @@ -6766,7 +6766,7 @@ func (r *rpcServer) SubscribeChannelBackups(req *lnrpc.ChannelBackupSubscription // we'll obtains the current set of single channel // backups from disk. chanBackups, err := chanbackup.FetchStaticChanBackups( - r.server.chanStateDB, + r.server.chanStateDB, r.server.addrSource, ) if err != nil { return fmt.Errorf("unable to fetch all "+ diff --git a/server.go b/server.go index 62a0aa62d..6b8830f03 100644 --- a/server.go +++ b/server.go @@ -224,6 +224,8 @@ type server struct { chanStateDB *channeldb.DB + addrSource chanbackup.AddressSource + htlcSwitch *htlcswitch.Switch interceptableSwitch *htlcswitch.InterceptableSwitch @@ -433,6 +435,7 @@ func newServer(cfg *Config, listenAddrs []net.Addr, cfg: cfg, graphDB: dbs.graphDB.ChannelGraph(), chanStateDB: dbs.chanStateDB, + addrSource: dbs.chanStateDB, cc: cc, sigPool: lnwallet.NewSigPool(cfg.Workers.Sig, cc.Signer), writePool: writePool, @@ -1246,7 +1249,9 @@ func newServer(cfg *Config, listenAddrs []net.Addr, addrs: s.chanStateDB, } backupFile := chanbackup.NewMultiFile(cfg.BackupFilePath) - startingChans, err := chanbackup.FetchStaticChanBackups(s.chanStateDB) + startingChans, err := chanbackup.FetchStaticChanBackups( + s.chanStateDB, s.addrSource, + ) if err != nil { return nil, err }