From 6d823b6f8a88476ca7e7e8a4588b19ca12decc91 Mon Sep 17 00:00:00 2001 From: Calvin Zachman Date: Wed, 7 Jul 2021 00:04:10 -0500 Subject: [PATCH 1/3] embed kvdb.Backend interface in TowerDB/ClientDB/VersionedDB struct to match ChannelDB --- watchtower/wtdb/client_db.go | 46 +++++++++++++----------------------- watchtower/wtdb/tower_db.go | 36 ++++++++++------------------ watchtower/wtdb/version.go | 7 +++--- 3 files changed, 32 insertions(+), 57 deletions(-) diff --git a/watchtower/wtdb/client_db.go b/watchtower/wtdb/client_db.go index 7f98a69850..220ddbc557 100644 --- a/watchtower/wtdb/client_db.go +++ b/watchtower/wtdb/client_db.go @@ -119,7 +119,7 @@ var ( // ClientDB is single database providing a persistent storage engine for the // wtclient. type ClientDB struct { - db kvdb.Backend + kvdb.Backend dbPath string } @@ -139,8 +139,8 @@ func OpenClientDB(dbPath string, dbTimeout time.Duration) (*ClientDB, error) { } clientDB := &ClientDB{ - db: bdb, - dbPath: dbPath, + Backend: bdb, + dbPath: dbPath, } err = initOrSyncVersions(clientDB, firstInit, clientDBVersions) @@ -154,7 +154,7 @@ func OpenClientDB(dbPath string, dbTimeout time.Duration) (*ClientDB, error) { // initialized. This allows us to assume their presence throughout all // operations. If an known top-level bucket is expected to exist but is // missing, this will trigger a ErrUninitializedDB error. - err = kvdb.Update(clientDB.db, initClientDBBuckets, func() {}) + err = kvdb.Update(clientDB, initClientDBBuckets, func() {}) if err != nil { bdb.Close() return nil, err @@ -184,19 +184,12 @@ func initClientDBBuckets(tx kvdb.RwTx) error { return nil } -// bdb returns the backing bbolt.DB instance. -// -// NOTE: Part of the versionedDB interface. -func (c *ClientDB) bdb() kvdb.Backend { - return c.db -} - // Version returns the database's current version number. // // NOTE: Part of the versionedDB interface. func (c *ClientDB) Version() (uint32, error) { var version uint32 - err := kvdb.View(c.db, func(tx kvdb.RTx) error { + err := kvdb.View(c, func(tx kvdb.RTx) error { var err error version, err = getDBVersion(tx) return err @@ -210,11 +203,6 @@ func (c *ClientDB) Version() (uint32, error) { return version, nil } -// Close closes the underlying database. -func (c *ClientDB) Close() error { - return c.db.Close() -} - // CreateTower initialize an address record used to communicate with a // watchtower. Each Tower is assigned a unique ID, that is used to amortize // storage costs of the public key when used by multiple sessions. If the tower @@ -225,7 +213,7 @@ func (c *ClientDB) CreateTower(lnAddr *lnwire.NetAddress) (*Tower, error) { copy(towerPubKey[:], lnAddr.IdentityKey.SerializeCompressed()) var tower *Tower - err := kvdb.Update(c.db, func(tx kvdb.RwTx) error { + err := kvdb.Update(c, func(tx kvdb.RwTx) error { towerIndex := tx.ReadWriteBucket(cTowerIndexBkt) if towerIndex == nil { return ErrUninitializedDB @@ -320,7 +308,7 @@ func (c *ClientDB) CreateTower(lnAddr *lnwire.NetAddress) (*Tower, error) { // // NOTE: An error is not returned if the tower doesn't exist. func (c *ClientDB) RemoveTower(pubKey *btcec.PublicKey, addr net.Addr) error { - return kvdb.Update(c.db, func(tx kvdb.RwTx) error { + return kvdb.Update(c, func(tx kvdb.RwTx) error { towers := tx.ReadWriteBucket(cTowerBkt) if towers == nil { return ErrUninitializedDB @@ -401,7 +389,7 @@ func (c *ClientDB) RemoveTower(pubKey *btcec.PublicKey, addr net.Addr) error { // LoadTowerByID retrieves a tower by its tower ID. func (c *ClientDB) LoadTowerByID(towerID TowerID) (*Tower, error) { var tower *Tower - err := kvdb.View(c.db, func(tx kvdb.RTx) error { + err := kvdb.View(c, func(tx kvdb.RTx) error { towers := tx.ReadBucket(cTowerBkt) if towers == nil { return ErrUninitializedDB @@ -423,7 +411,7 @@ func (c *ClientDB) LoadTowerByID(towerID TowerID) (*Tower, error) { // LoadTower retrieves a tower by its public key. func (c *ClientDB) LoadTower(pubKey *btcec.PublicKey) (*Tower, error) { var tower *Tower - err := kvdb.View(c.db, func(tx kvdb.RTx) error { + err := kvdb.View(c, func(tx kvdb.RTx) error { towers := tx.ReadBucket(cTowerBkt) if towers == nil { return ErrUninitializedDB @@ -454,7 +442,7 @@ func (c *ClientDB) LoadTower(pubKey *btcec.PublicKey) (*Tower, error) { // ListTowers retrieves the list of towers available within the database. func (c *ClientDB) ListTowers() ([]*Tower, error) { var towers []*Tower - err := kvdb.View(c.db, func(tx kvdb.RTx) error { + err := kvdb.View(c, func(tx kvdb.RTx) error { towerBucket := tx.ReadBucket(cTowerBkt) if towerBucket == nil { return ErrUninitializedDB @@ -487,7 +475,7 @@ func (c *ClientDB) NextSessionKeyIndex(towerID TowerID, blobType blob.Type) (uint32, error) { var index uint32 - err := kvdb.Update(c.db, func(tx kvdb.RwTx) error { + err := kvdb.Update(c, func(tx kvdb.RwTx) error { keyIndex := tx.ReadWriteBucket(cSessionKeyIndexBkt) if keyIndex == nil { return ErrUninitializedDB @@ -539,7 +527,7 @@ func (c *ClientDB) NextSessionKeyIndex(towerID TowerID, // CreateClientSession records a newly negotiated client session in the set of // active sessions. The session can be identified by its SessionID. func (c *ClientDB) CreateClientSession(session *ClientSession) error { - return kvdb.Update(c.db, func(tx kvdb.RwTx) error { + return kvdb.Update(c, func(tx kvdb.RwTx) error { keyIndexes := tx.ReadWriteBucket(cSessionKeyIndexBkt) if keyIndexes == nil { return ErrUninitializedDB @@ -641,7 +629,7 @@ func getSessionKeyIndex(keyIndexes kvdb.RwBucket, towerID TowerID, // response that do not correspond to this tower. func (c *ClientDB) ListClientSessions(id *TowerID) (map[SessionID]*ClientSession, error) { var clientSessions map[SessionID]*ClientSession - err := kvdb.View(c.db, func(tx kvdb.RTx) error { + err := kvdb.View(c, func(tx kvdb.RTx) error { sessions := tx.ReadBucket(cSessionBkt) if sessions == nil { return ErrUninitializedDB @@ -697,7 +685,7 @@ func listClientSessions(sessions kvdb.RBucket, // channel summaries. func (c *ClientDB) FetchChanSummaries() (ChannelSummaries, error) { var summaries map[lnwire.ChannelID]ClientChanSummary - err := kvdb.View(c.db, func(tx kvdb.RTx) error { + err := kvdb.View(c, func(tx kvdb.RTx) error { chanSummaries := tx.ReadBucket(cChanSummaryBkt) if chanSummaries == nil { return ErrUninitializedDB @@ -735,7 +723,7 @@ func (c *ClientDB) FetchChanSummaries() (ChannelSummaries, error) { func (c *ClientDB) RegisterChannel(chanID lnwire.ChannelID, sweepPkScript []byte) error { - return kvdb.Update(c.db, func(tx kvdb.RwTx) error { + return kvdb.Update(c, func(tx kvdb.RwTx) error { chanSummaries := tx.ReadWriteBucket(cChanSummaryBkt) if chanSummaries == nil { return ErrUninitializedDB @@ -779,7 +767,7 @@ func (c *ClientDB) CommitUpdate(id *SessionID, update *CommittedUpdate) (uint16, error) { var lastApplied uint16 - err := kvdb.Update(c.db, func(tx kvdb.RwTx) error { + err := kvdb.Update(c, func(tx kvdb.RwTx) error { sessions := tx.ReadWriteBucket(cSessionBkt) if sessions == nil { return ErrUninitializedDB @@ -885,7 +873,7 @@ func (c *ClientDB) CommitUpdate(id *SessionID, func (c *ClientDB) AckUpdate(id *SessionID, seqNum uint16, lastApplied uint16) error { - return kvdb.Update(c.db, func(tx kvdb.RwTx) error { + return kvdb.Update(c, func(tx kvdb.RwTx) error { sessions := tx.ReadWriteBucket(cSessionBkt) if sessions == nil { return ErrUninitializedDB diff --git a/watchtower/wtdb/tower_db.go b/watchtower/wtdb/tower_db.go index 6f67298f80..632f969e01 100644 --- a/watchtower/wtdb/tower_db.go +++ b/watchtower/wtdb/tower_db.go @@ -56,7 +56,7 @@ var ( // TowerDB is single database providing a persistent storage engine for the // wtserver and lookout subsystems. type TowerDB struct { - db kvdb.Backend + kvdb.Backend dbPath string } @@ -76,8 +76,8 @@ func OpenTowerDB(dbPath string, dbTimeout time.Duration) (*TowerDB, error) { } towerDB := &TowerDB{ - db: bdb, - dbPath: dbPath, + Backend: bdb, + dbPath: dbPath, } err = initOrSyncVersions(towerDB, firstInit, towerDBVersions) @@ -91,7 +91,7 @@ func OpenTowerDB(dbPath string, dbTimeout time.Duration) (*TowerDB, error) { // initialized. This allows us to assume their presence throughout all // operations. If an known top-level bucket is expected to exist but is // missing, this will trigger a ErrUninitializedDB error. - err = kvdb.Update(towerDB.db, initTowerDBBuckets, func() {}) + err = kvdb.Update(towerDB, initTowerDBBuckets, func() {}) if err != nil { bdb.Close() return nil, err @@ -120,19 +120,12 @@ func initTowerDBBuckets(tx kvdb.RwTx) error { return nil } -// bdb returns the backing bbolt.DB instance. -// -// NOTE: Part of the versionedDB interface. -func (t *TowerDB) bdb() kvdb.Backend { - return t.db -} - // Version returns the database's current version number. // // NOTE: Part of the versionedDB interface. func (t *TowerDB) Version() (uint32, error) { var version uint32 - err := kvdb.View(t.db, func(tx kvdb.RTx) error { + err := kvdb.View(t, func(tx kvdb.RTx) error { var err error version, err = getDBVersion(tx) return err @@ -146,16 +139,11 @@ func (t *TowerDB) Version() (uint32, error) { return version, nil } -// Close closes the underlying database. -func (t *TowerDB) Close() error { - return t.db.Close() -} - // GetSessionInfo retrieves the session for the passed session id. An error is // returned if the session could not be found. func (t *TowerDB) GetSessionInfo(id *SessionID) (*SessionInfo, error) { var session *SessionInfo - err := kvdb.View(t.db, func(tx kvdb.RTx) error { + err := kvdb.View(t, func(tx kvdb.RTx) error { sessions := tx.ReadBucket(sessionsBkt) if sessions == nil { return ErrUninitializedDB @@ -177,7 +165,7 @@ func (t *TowerDB) GetSessionInfo(id *SessionID) (*SessionInfo, error) { // InsertSessionInfo records a negotiated session in the tower database. An // error is returned if the session already exists. func (t *TowerDB) InsertSessionInfo(session *SessionInfo) error { - return kvdb.Update(t.db, func(tx kvdb.RwTx) error { + return kvdb.Update(t, func(tx kvdb.RwTx) error { sessions := tx.ReadWriteBucket(sessionsBkt) if sessions == nil { return ErrUninitializedDB @@ -226,7 +214,7 @@ func (t *TowerDB) InsertSessionInfo(session *SessionInfo) error { // properly and the last applied values echoed by the client are sane. func (t *TowerDB) InsertStateUpdate(update *SessionStateUpdate) (uint16, error) { var lastApplied uint16 - err := kvdb.Update(t.db, func(tx kvdb.RwTx) error { + err := kvdb.Update(t, func(tx kvdb.RwTx) error { sessions := tx.ReadWriteBucket(sessionsBkt) if sessions == nil { return ErrUninitializedDB @@ -312,7 +300,7 @@ func (t *TowerDB) InsertStateUpdate(update *SessionStateUpdate) (uint16, error) // DeleteSession removes all data associated with a particular session id from // the tower's database. func (t *TowerDB) DeleteSession(target SessionID) error { - return kvdb.Update(t.db, func(tx kvdb.RwTx) error { + return kvdb.Update(t, func(tx kvdb.RwTx) error { sessions := tx.ReadWriteBucket(sessionsBkt) if sessions == nil { return ErrUninitializedDB @@ -398,7 +386,7 @@ func (t *TowerDB) DeleteSession(target SessionID) error { // they exist in the database. func (t *TowerDB) QueryMatches(breachHints []blob.BreachHint) ([]Match, error) { var matches []Match - err := kvdb.View(t.db, func(tx kvdb.RTx) error { + err := kvdb.View(t, func(tx kvdb.RTx) error { sessions := tx.ReadBucket(sessionsBkt) if sessions == nil { return ErrUninitializedDB @@ -482,7 +470,7 @@ func (t *TowerDB) QueryMatches(breachHints []blob.BreachHint) ([]Match, error) { // SetLookoutTip stores the provided epoch as the latest lookout tip epoch in // the tower database. func (t *TowerDB) SetLookoutTip(epoch *chainntnfs.BlockEpoch) error { - return kvdb.Update(t.db, func(tx kvdb.RwTx) error { + return kvdb.Update(t, func(tx kvdb.RwTx) error { lookoutTip := tx.ReadWriteBucket(lookoutTipBkt) if lookoutTip == nil { return ErrUninitializedDB @@ -496,7 +484,7 @@ func (t *TowerDB) SetLookoutTip(epoch *chainntnfs.BlockEpoch) error { // database. func (t *TowerDB) GetLookoutTip() (*chainntnfs.BlockEpoch, error) { var epoch *chainntnfs.BlockEpoch - err := kvdb.View(t.db, func(tx kvdb.RTx) error { + err := kvdb.View(t, func(tx kvdb.RTx) error { lookoutTip := tx.ReadBucket(lookoutTipBkt) if lookoutTip == nil { return ErrUninitializedDB diff --git a/watchtower/wtdb/version.go b/watchtower/wtdb/version.go index 229b8a9dd8..166934f953 100644 --- a/watchtower/wtdb/version.go +++ b/watchtower/wtdb/version.go @@ -88,8 +88,7 @@ func putDBVersion(tx kvdb.RwTx, version uint32) error { // databases, permitting all versioning operations to be performed generically // on either. type versionedDB interface { - // bdb returns the underlying bbolt database. - bdb() kvdb.Backend + kvdb.Backend // Version returns the current version stored in the database. Version() (uint32, error) @@ -105,7 +104,7 @@ func initOrSyncVersions(db versionedDB, init bool, versions []version) error { // If the database has not yet been created, we'll initialize the // database version with the latest known version. if init { - return kvdb.Update(db.bdb(), func(tx kvdb.RwTx) error { + return kvdb.Update(db, func(tx kvdb.RwTx) error { return initDBVersion(tx, getLatestDBVersion(versions)) }, func() {}) } @@ -141,7 +140,7 @@ func syncVersions(db versionedDB, versions []version) error { // Otherwise, apply any migrations in order to bring the database // version up to the highest known version. updates := getMigrations(versions, curVersion) - return kvdb.Update(db.bdb(), func(tx kvdb.RwTx) error { + return kvdb.Update(db, func(tx kvdb.RwTx) error { for i, update := range updates { if update.migration == nil { continue From bfeca313a888a1ea3b2dd19bd3c3bb1410f2797d Mon Sep 17 00:00:00 2001 From: Calvin Zachman Date: Wed, 7 Jul 2021 00:15:00 -0500 Subject: [PATCH 2/3] allow watchtower to store data in remote (etcd) backend --- lnd.go | 90 ++++++++++++++++++++++++++++++++----- watchtower/wtdb/tower_db.go | 80 ++++++++++++++++++++++----------- 2 files changed, 131 insertions(+), 39 deletions(-) diff --git a/lnd.go b/lnd.go index bd0f2839d1..32295451f5 100644 --- a/lnd.go +++ b/lnd.go @@ -42,6 +42,7 @@ import ( "github.com/lightningnetwork/lnd/chanacceptor" "github.com/lightningnetwork/lnd/channeldb" "github.com/lightningnetwork/lnd/keychain" + "github.com/lightningnetwork/lnd/kvdb" "github.com/lightningnetwork/lnd/lncfg" "github.com/lightningnetwork/lnd/lnrpc" "github.com/lightningnetwork/lnd/lnwallet" @@ -799,19 +800,11 @@ func Main(cfg *Config, lisCfg ListenerCfg, interceptor signal.Interceptor) error var tower *watchtower.Standalone if cfg.Watchtower.Active { - // Segment the watchtower directory by chain and network. - towerDBDir := filepath.Join( - cfg.Watchtower.TowerDir, - cfg.registeredChains.PrimaryChain().String(), - lncfg.NormalizeNetwork(cfg.ActiveNetParams.Name), - ) - - towerDB, err := wtdb.OpenTowerDB( - towerDBDir, cfg.DB.Bolt.DBTimeout, - ) + // Grab pointer to either local or remote tower database. + towerDB, err := initializeTowerDatabase(ctx, cfg) if err != nil { - err := fmt.Errorf("unable to open watchtower "+ - "database: %v", err) + err := fmt.Errorf("unable to open watchtower (%s) database: %v", + cfg.DB.Backend, err) ltndLog.Error(err) return err } @@ -1724,6 +1717,79 @@ func initializeDatabases(ctx context.Context, return localChanDB, remoteChanDB, cleanUp, nil } +// initializeTowerDatabase configures either a local (boltdb) or remote (etcd) +// database for the watchtower server. +func initializeTowerDatabase(ctx context.Context, + cfg *Config) (*wtdb.TowerDB, error) { + + ltndLog.Infof("Opening the watchtower database, this might take a few " + + "minutes...") + + if cfg.DB.Backend == lncfg.BoltBackend { + ltndLog.Infof("Opening bbolt database for watchtower, sync_freelist=%v, "+ + "auto_compact=%v", cfg.DB.Bolt.SyncFreelist, + cfg.DB.Bolt.AutoCompact) + } + + startOpenTime := time.Now() + + var ( + towerDB *wtdb.TowerDB + err error + ) + + if cfg.DB.Backend == lncfg.BoltBackend { + // Segment the watchtower directory by chain and network. + towerDBDir := filepath.Join( + cfg.Watchtower.TowerDir, + cfg.registeredChains.PrimaryChain().String(), + lncfg.NormalizeNetwork(cfg.ActiveNetParams.Name), + ) + + // Open the towerdb, which is dedicated to storing watchtower + // server data. + towerDB, err = wtdb.OpenTowerDB( + towerDBDir, cfg.DB.Bolt.DBTimeout, + ) + if err != nil { + err := fmt.Errorf("unable to open local watchtower "+ + "database: %v", err) + ltndLog.Error(err) + return nil, err + } + + } else if cfg.DB.Backend == lncfg.EtcdBackend { + ltndLog.Infof("Database replication is available! Creating " + + "remote towerdb instance") + + // Open connection to remote etcd backend. + remoteDB, err := kvdb.Open( + kvdb.EtcdBackendName, ctx, cfg.DB.Etcd, + ) + if err != nil { + return nil, err + } + + // Initialize the remote watchtower db. + towerDB, err = wtdb.CreateWithBackend( + remoteDB, + ) + if err != nil { + towerDB.Close() + + err := fmt.Errorf("unable to open remote watchtower "+ + "database: %v", err) + ltndLog.Error(err) + return nil, err + } + } + + openTime := time.Since(startOpenTime) + ltndLog.Infof("Tower database now open (time_to_open=%v)!", openTime) + + return towerDB, nil +} + // initNeutrinoBackend inits a new instance of the neutrino light client // backend given a target chain directory to store the chain state. func initNeutrinoBackend(cfg *Config, chainDir string, diff --git a/watchtower/wtdb/tower_db.go b/watchtower/wtdb/tower_db.go index 632f969e01..72a61c6b1d 100644 --- a/watchtower/wtdb/tower_db.go +++ b/watchtower/wtdb/tower_db.go @@ -3,6 +3,7 @@ package wtdb import ( "bytes" "errors" + "fmt" "time" "github.com/btcsuite/btcd/chaincfg/chainhash" @@ -67,54 +68,79 @@ type TowerDB struct { // migrations will be applied before returning. Any attempt to open a database // with a version number higher that the latest version will fail to prevent // accidental reversion. +// NOTE: We can match the channelDB by deprecating this function in favor +// of CreateWithBackend(). func OpenTowerDB(dbPath string, dbTimeout time.Duration) (*TowerDB, error) { - bdb, firstInit, err := createDBIfNotExist( - dbPath, towerDBName, dbTimeout, - ) + + boltBackend, err := kvdb.GetBoltBackend(&kvdb.BoltBackendConfig{ + DBPath: dbPath, + DBFileName: towerDBName, + DBTimeout: dbTimeout, + }) if err != nil { return nil, err } - towerDB := &TowerDB{ - Backend: bdb, - dbPath: dbPath, + towerDB, err := CreateWithBackend(boltBackend) + if err == nil { + towerDB.dbPath = dbPath } + return towerDB, err +} - err = initOrSyncVersions(towerDB, firstInit, towerDBVersions) - if err != nil { - bdb.Close() +// CreateWithBackend creates towerdb instance using the passed kvdb.Backend. +// Any necessary schemas migrations due to updates will take place as necessary. +func CreateWithBackend(backend kvdb.Backend) (*TowerDB, error) { + if err := initTowerDBBuckets(backend); err != nil { return nil, err } - // Now that the database version fully consistent with our latest known - // version, ensure that all top-level buckets known to this version are - // initialized. This allows us to assume their presence throughout all - // operations. If an known top-level bucket is expected to exist but is - // missing, this will trigger a ErrUninitializedDB error. - err = kvdb.Update(towerDB, initTowerDBBuckets, func() {}) + towerDB := &TowerDB{ + Backend: backend, + } + + // TODO(czachman): apply options? (see ChannelDB). + + // Synchronize the version of database and apply migrations if needed. + err := syncVersions(towerDB, towerDBVersions) if err != nil { - bdb.Close() + backend.Close() return nil, err } return towerDB, nil } +var topLevelBuckets = [][]byte{ + sessionsBkt, + updateIndexBkt, + updatesBkt, + lookoutTipBkt, +} + // initTowerDBBuckets creates all top-level buckets required to handle database // operations required by the latest version. -func initTowerDBBuckets(tx kvdb.RwTx) error { - buckets := [][]byte{ - sessionsBkt, - updateIndexBkt, - updatesBkt, - lookoutTipBkt, - } +func initTowerDBBuckets(db kvdb.Backend) error { + err := kvdb.Update(db, func(tx kvdb.RwTx) error { - for _, bucket := range buckets { - _, err := tx.CreateTopLevelBucket(bucket) - if err != nil { - return err + // Check if DB is already initialized. + _, err := getDBVersion(tx) + if err == nil { + return nil } + + for _, tlb := range topLevelBuckets { + _, err := tx.CreateTopLevelBucket(tlb) + if err != nil { + return err + } + } + + // Set the DB version + return initDBVersion(tx, getLatestDBVersion(towerDBVersions)) + }, func() {}) + if err != nil { + return fmt.Errorf("unable to initialize new towerdb: %v", err) } return nil From aee451d20f73c4622fe006cbd8eab377b6cf8f00 Mon Sep 17 00:00:00 2001 From: Calvin Zachman Date: Wed, 7 Jul 2021 00:00:27 -0500 Subject: [PATCH 3/3] explicit database initialization function name - rename function 'initializeDatabases' to make explicit that we are setting up the channelDB --- lnd.go | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/lnd.go b/lnd.go index 32295451f5..3ef833c789 100644 --- a/lnd.go +++ b/lnd.go @@ -433,7 +433,7 @@ func Main(cfg *Config, lisCfg ListenerCfg, interceptor signal.Interceptor) error ltndLog.Infof("Elected as leader (%v)", cfg.Cluster.ID) } - localChanDB, remoteChanDB, cleanUp, err := initializeDatabases(ctx, cfg) + localChanDB, remoteChanDB, cleanUp, err := initializeChannelDatabases(ctx, cfg) switch { case err == channeldb.ErrDryRunMigrationOK: ltndLog.Infof("%v, exiting", err) @@ -1593,13 +1593,13 @@ func waitForWalletPassword(cfg *Config, } } -// initializeDatabases extracts the current databases that we'll use for normal -// operation in the daemon. Two databases are returned: one remote and one -// local. However, only if the replicated database is active will the remote -// database point to a unique database. Otherwise, the local and remote DB will -// both point to the same local database. A function closure that closes all -// opened databases is also returned. -func initializeDatabases(ctx context.Context, +// initializeChannelDatabases extracts the current databases that we'll use for +// normal operation in the daemon. Two databases are returned: one remote and +// one local. However, only if the replicated database is active will the +// remote database point to a unique database. Otherwise, the local and remote +// DB will both point to the same local database. A function closure that +// closes all opened databases is also returned. +func initializeChannelDatabases(ctx context.Context, cfg *Config) (*channeldb.DB, *channeldb.DB, func(), error) { ltndLog.Infof("Opening the main database, this might take a few " +