14495430837

Committed 16 Apr 2025 02:36PM UTC coverage: 58.591% (-10.5%) from 69.084%

Build # 14495430837

Build Type

Pull #9723

github

Committed by

web-flow

Commit Message

Merge fee68593a into 06f1ef47f

Pull Request Pull Request #9723: Add the global lock for the wallet db back for postgres

Run Details

0 of 11 new or added lines in 1 file covered. (0.0%)

28188 existing lines in 450 files now uncovered.

97163 of 165833 relevant lines covered (58.59%)

1.82 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

25.0

/lncfg/db.go

package lncfg

import (
        "context"
        "fmt"
        "path"
        "path/filepath"
        "time"

        "github.com/btcsuite/btclog/v2"
        "github.com/lightningnetwork/lnd/kvdb"
        "github.com/lightningnetwork/lnd/kvdb/etcd"
        "github.com/lightningnetwork/lnd/kvdb/postgres"
        "github.com/lightningnetwork/lnd/kvdb/sqlbase"
        "github.com/lightningnetwork/lnd/kvdb/sqlite"
        "github.com/lightningnetwork/lnd/lnrpc"
        "github.com/lightningnetwork/lnd/lnwallet/btcwallet"
        "github.com/lightningnetwork/lnd/sqldb"
)

const (
        ChannelDBName     = "channel.db"
        MacaroonDBName    = "macaroons.db"
        DecayedLogDbName  = "sphinxreplay.db"
        TowerClientDBName = "wtclient.db"
        TowerServerDBName = "watchtower.db"
        WalletDBName      = "wallet.db"
        NeutrinoDBName    = "neutrino.db"

        SqliteChannelDBName  = "channel.sqlite"
        SqliteChainDBName    = "chain.sqlite"
        SqliteNeutrinoDBName = "neutrino.sqlite"
        SqliteTowerDBName    = "watchtower.sqlite"
        SqliteNativeDBName   = "lnd.sqlite"

        BoltBackend                = "bolt"
        EtcdBackend                = "etcd"
        PostgresBackend            = "postgres"
        SqliteBackend              = "sqlite"
        DefaultBatchCommitInterval = 500 * time.Millisecond

        defaultPostgresMaxConnections = 50
        defaultSqliteMaxConnections   = 2

        defaultSqliteBusyTimeout = 5 * time.Second

        // NSChannelDB is the namespace name that we use for the combined graph
        // and channel state DB.
        NSChannelDB = "channeldb"

        // NSMacaroonDB is the namespace name that we use for the macaroon DB.
        NSMacaroonDB = "macaroondb"

        // NSDecayedLogDB is the namespace name that we use for the sphinx
        // replay a.k.a. decayed log DB.
        NSDecayedLogDB = "decayedlogdb"

        // NSTowerClientDB is the namespace name that we use for the watchtower
        // client DB.
        NSTowerClientDB = "towerclientdb"

        // NSTowerServerDB is the namespace name that we use for the watchtower
        // server DB.
        NSTowerServerDB = "towerserverdb"

        // NSWalletDB is the namespace name that we use for the wallet DB.
        NSWalletDB = "walletdb"

        // NSNeutrinoDB is the namespace name that we use for the neutrino DB.
        NSNeutrinoDB = "neutrinodb"
)

// DB holds database configuration for LND.
//
//nolint:ll
type DB struct {
        Backend string `long:"backend" description:"The selected database backend."`

        BatchCommitInterval time.Duration `long:"batch-commit-interval" description:"The maximum duration the channel graph batch schedulers will wait before attempting to commit a batch of pending updates. This can be tradeoff database contenion for commit latency."`

        Etcd *etcd.Config `group:"etcd" namespace:"etcd" description:"Etcd settings."`

        Bolt *kvdb.BoltConfig `group:"bolt" namespace:"bolt" description:"Bolt settings."`

        Postgres *sqldb.PostgresConfig `group:"postgres" namespace:"postgres" description:"Postgres settings."`

        Sqlite *sqldb.SqliteConfig `group:"sqlite" namespace:"sqlite" description:"Sqlite settings."`

        UseNativeSQL bool `long:"use-native-sql" description:"Use native SQL for tables that already support it."`

        SkipNativeSQLMigration bool `long:"skip-native-sql-migration" description:"Do not run the KV to native SQL migration. It should only be used if errors are encountered normally."`

        NoGraphCache bool `long:"no-graph-cache" description:"Don't use the in-memory graph cache for path finding. Much slower but uses less RAM. Can only be used with a bolt database backend."`

        PruneRevocation bool `long:"prune-revocation" description:"Run the optional migration that prunes the revocation logs to save disk space."`

        NoRevLogAmtData bool `long:"no-rev-log-amt-data" description:"If set, the to-local and to-remote output amounts of revoked commitment transactions will not be stored in the revocation log. Note that once this data is lost, a watchtower client will not be able to back up the revoked state."`
}

// DefaultDB creates and returns a new default DB config.
func DefaultDB() *DB {
        return &DB{
                Backend:             BoltBackend,
                BatchCommitInterval: DefaultBatchCommitInterval,
                Bolt: &kvdb.BoltConfig{
                        NoFreelistSync:    true,
                        AutoCompactMinAge: kvdb.DefaultBoltAutoCompactMinAge,
                        DBTimeout:         kvdb.DefaultDBTimeout,
                },
                Etcd: &etcd.Config{
                        // Allow at most 32 MiB messages by default.
                        MaxMsgSize: 32768 * 1024,
                },
                Postgres: &sqldb.PostgresConfig{
                        MaxConnections: defaultPostgresMaxConnections,
                },
                Sqlite: &sqldb.SqliteConfig{
                        MaxConnections: defaultSqliteMaxConnections,
                        BusyTimeout:    defaultSqliteBusyTimeout,
                },
                UseNativeSQL:           false,
                SkipNativeSQLMigration: false,
        }
}

// Validate validates the DB config.
func (db *DB) Validate() error {
        switch db.Backend {
        case BoltBackend:
                if db.UseNativeSQL {
                        return fmt.Errorf("cannot use native SQL with bolt " +
                                "backend")
                }

        case SqliteBackend:
        case PostgresBackend:
                if err := db.Postgres.Validate(); err != nil {
                        return err
                }

        case EtcdBackend:
                if db.UseNativeSQL {
                        return fmt.Errorf("cannot use native SQL with etcd " +
                                "backend")
                }

                if !db.Etcd.Embedded && db.Etcd.Host == "" {
                        return fmt.Errorf("etcd host must be set")
                }

        default:
                return fmt.Errorf("unknown backend, must be either '%v', "+
                        "'%v', '%v' or '%v'", BoltBackend, EtcdBackend,
                        PostgresBackend, SqliteBackend)
        }

        // The path finding uses a manual read transaction that's open for a
        // potentially long time. That works fine with the locking model of
        // bbolt but can lead to locks or rolled back transactions with etcd or
        // postgres. And since we already have a smaller memory footprint for
        // remote database setups (due to not needing to memory-map the bbolt DB
        // files), we can keep the graph in memory instead. But for mobile
        // devices the tradeoff between a smaller memory footprint and the
        // longer time needed for path finding might be a desirable one.
        if db.NoGraphCache && db.Backend != BoltBackend {
                return fmt.Errorf("cannot use no-graph-cache with database "+
                        "backend '%v'", db.Backend)
        }

        return nil
}

// Init should be called upon start to pre-initialize database access dependent
// on configuration.
func (db *DB) Init(ctx context.Context, dbPath string) error {
        // Start embedded etcd server if requested.
        switch {
        case db.Backend == EtcdBackend && db.Etcd.Embedded:
                cfg, _, err := kvdb.StartEtcdTestBackend(
                        dbPath, db.Etcd.EmbeddedClientPort,
                        db.Etcd.EmbeddedPeerPort, db.Etcd.EmbeddedLogFile,
                )
                if err != nil {
                        return err
                }

                // Override the original config with the config for
                // the embedded instance.
                db.Etcd = cfg

        case db.Backend == PostgresBackend:
                sqlbase.Init(db.Postgres.MaxConnections)

        case db.Backend == SqliteBackend:
                sqlbase.Init(db.Sqlite.MaxConnections)
        }

        return nil
}

// DatabaseBackends is a two-tuple that holds the set of active database
// backends for the daemon. The two backends we expose are the graph database
// backend, and the channel state backend.
type DatabaseBackends struct {
        // GraphDB points to the database backend that contains the less
        // critical data that is accessed often, such as the channel graph and
        // chain height hints.
        GraphDB kvdb.Backend

        // ChanStateDB points to a possibly networked replicated backend that
        // contains the critical channel state related data.
        ChanStateDB kvdb.Backend

        // HeightHintDB points to a possibly networked replicated backend that
        // contains the chain height hint related data.
        HeightHintDB kvdb.Backend

        // MacaroonDB points to a database backend that stores the macaroon root
        // keys.
        MacaroonDB kvdb.Backend

        // DecayedLogDB points to a database backend that stores the decayed log
        // data.
        DecayedLogDB kvdb.Backend

        // TowerClientDB points to a database backend that stores the watchtower
        // client data. This might be nil if the watchtower client is disabled.
        TowerClientDB kvdb.Backend

        // TowerServerDB points to a database backend that stores the watchtower
        // server data. This might be nil if the watchtower server is disabled.
        TowerServerDB kvdb.Backend

        // WalletDB is an option that instructs the wallet loader where to load
        // the underlying wallet database from.
        WalletDB btcwallet.LoaderOption

        // NativeSQLStore holds a reference to the native SQL store that can
        // be used for native SQL queries for tables that already support it.
        // This may be nil if the use-native-sql flag was not set.
        NativeSQLStore sqldb.DB

        // Remote indicates whether the database backends are remote, possibly
        // replicated instances or local bbolt or sqlite backed databases.
        Remote bool

        // CloseFuncs is a map of close functions for each of the initialized
        // DB backends keyed by their namespace name.
        CloseFuncs map[string]func() error
}

// GetPostgresConfigKVDB converts a sqldb.PostgresConfig to a kvdb
// postgres.Config.
func GetPostgresConfigKVDB(cfg *sqldb.PostgresConfig) *postgres.Config {
        return &postgres.Config{
                Dsn:            cfg.Dsn,
                Timeout:        cfg.Timeout,
                MaxConnections: cfg.MaxConnections,
        }
}

// GetSqliteConfigKVDB converts a sqldb.SqliteConfig to a kvdb sqlite.Config.
func GetSqliteConfigKVDB(cfg *sqldb.SqliteConfig) *sqlite.Config {
        return &sqlite.Config{
                Timeout:        cfg.Timeout,
                BusyTimeout:    cfg.BusyTimeout,
                MaxConnections: cfg.MaxConnections,
                PragmaOptions:  cfg.PragmaOptions,
        }
}

// GetBackends returns a set of kvdb.Backends as set in the DB config.
func (db *DB) GetBackends(ctx context.Context, chanDBPath,
        walletDBPath, towerServerDBPath string, towerClientEnabled,
        towerServerEnabled bool, logger btclog.Logger) (*DatabaseBackends,
        error) {

        // We keep track of all the kvdb backends we actually open and return a
        // reference to their close function so they can be cleaned up properly
        // on error or shutdown.
        closeFuncs := make(map[string]func() error)

        // If we need to return early because of an error, we invoke any close
        // function that has been initialized so far.
        returnEarly := true
        defer func() {
                if !returnEarly {
                        return
                }

                for _, closeFunc := range closeFuncs {
                        _ = closeFunc()
                }
        }()

        switch db.Backend {
        case EtcdBackend:
                // As long as the graph data, channel state and height hint
                // cache are all still in the channel.db file in bolt, we
                // replicate the same behavior here and use the same etcd
                // backend for those three sub DBs. But we namespace it properly
                // to make such a split even easier in the future. This will
                // break lnd for users that ran on etcd with 0.13.x since that
                // code used the root namespace. We assume that nobody used etcd
                // for mainnet just yet since that feature was clearly marked as
                // experimental in 0.13.x.
                etcdBackend, err := kvdb.Open(
                        kvdb.EtcdBackendName, ctx,
                        db.Etcd.CloneWithSubNamespace(NSChannelDB),
                )
                if err != nil {
                        return nil, fmt.Errorf("error opening etcd DB: %w", err)
                }
                closeFuncs[NSChannelDB] = etcdBackend.Close

                etcdMacaroonBackend, err := kvdb.Open(
                        kvdb.EtcdBackendName, ctx,
                        db.Etcd.CloneWithSubNamespace(NSMacaroonDB),
                )
                if err != nil {
                        return nil, fmt.Errorf("error opening etcd macaroon "+
                                "DB: %v", err)
                }
                closeFuncs[NSMacaroonDB] = etcdMacaroonBackend.Close

                etcdDecayedLogBackend, err := kvdb.Open(
                        kvdb.EtcdBackendName, ctx,
                        db.Etcd.CloneWithSubNamespace(NSDecayedLogDB),
                )
                if err != nil {
                        return nil, fmt.Errorf("error opening etcd decayed "+
                                "log DB: %v", err)
                }
                closeFuncs[NSDecayedLogDB] = etcdDecayedLogBackend.Close

                etcdTowerClientBackend, err := kvdb.Open(
                        kvdb.EtcdBackendName, ctx,
                        db.Etcd.CloneWithSubNamespace(NSTowerClientDB),
                )
                if err != nil {
                        return nil, fmt.Errorf("error opening etcd tower "+
                                "client DB: %v", err)
                }
                closeFuncs[NSTowerClientDB] = etcdTowerClientBackend.Close

                etcdTowerServerBackend, err := kvdb.Open(
                        kvdb.EtcdBackendName, ctx,
                        db.Etcd.CloneWithSubNamespace(NSTowerServerDB),
                )
                if err != nil {
                        return nil, fmt.Errorf("error opening etcd tower "+
                                "server DB: %v", err)
                }
                closeFuncs[NSTowerServerDB] = etcdTowerServerBackend.Close

                etcdWalletBackend, err := kvdb.Open(
                        kvdb.EtcdBackendName, ctx,
                        db.Etcd.
                                CloneWithSubNamespace(NSWalletDB).
                                CloneWithSingleWriter(),
                )
                if err != nil {
                        return nil, fmt.Errorf("error opening etcd macaroon "+
                                "DB: %v", err)
                }
                closeFuncs[NSWalletDB] = etcdWalletBackend.Close

                returnEarly = false

                return &DatabaseBackends{
                        GraphDB:       etcdBackend,
                        ChanStateDB:   etcdBackend,
                        HeightHintDB:  etcdBackend,
                        MacaroonDB:    etcdMacaroonBackend,
                        DecayedLogDB:  etcdDecayedLogBackend,
                        TowerClientDB: etcdTowerClientBackend,
                        TowerServerDB: etcdTowerServerBackend,
                        // The wallet loader will attempt to use/create the
                        // wallet in the replicated remote DB if we're running
                        // in a clustered environment. This will ensure that all
                        // members of the cluster have access to the same wallet
                        // state.
                        WalletDB: btcwallet.LoaderWithExternalWalletDB(
                                etcdWalletBackend,
                        ),
                        Remote:     true,
                        CloseFuncs: closeFuncs,
                }, nil

        case PostgresBackend:
                // Convert the sqldb PostgresConfig to a kvdb postgres.Config.
                // This is a temporary measure until we migrate all kvdb SQL
                // users to native SQL.
                postgresConfig := GetPostgresConfigKVDB(db.Postgres)

                postgresBackend, err := kvdb.Open(
                        kvdb.PostgresBackendName, ctx,
                        postgresConfig, NSChannelDB,
                )
                if err != nil {
                        return nil, fmt.Errorf("error opening postgres graph "+
                                "DB: %v", err)
                }
                closeFuncs[NSChannelDB] = postgresBackend.Close

                postgresMacaroonBackend, err := kvdb.Open(
                        kvdb.PostgresBackendName, ctx,
                        postgresConfig, NSMacaroonDB,
                )
                if err != nil {
                        return nil, fmt.Errorf("error opening postgres "+
                                "macaroon DB: %v", err)
                }
                closeFuncs[NSMacaroonDB] = postgresMacaroonBackend.Close

                postgresDecayedLogBackend, err := kvdb.Open(
                        kvdb.PostgresBackendName, ctx,
                        postgresConfig, NSDecayedLogDB,
                )
                if err != nil {
                        return nil, fmt.Errorf("error opening postgres "+
                                "decayed log DB: %v", err)
                }
                closeFuncs[NSDecayedLogDB] = postgresDecayedLogBackend.Close

                postgresTowerClientBackend, err := kvdb.Open(
                        kvdb.PostgresBackendName, ctx,
                        postgresConfig, NSTowerClientDB,
                )
                if err != nil {
                        return nil, fmt.Errorf("error opening postgres tower "+
                                "client DB: %v", err)
                }
                closeFuncs[NSTowerClientDB] = postgresTowerClientBackend.Close

                postgresTowerServerBackend, err := kvdb.Open(
                        kvdb.PostgresBackendName, ctx,
                        postgresConfig, NSTowerServerDB,
                )
                if err != nil {
                        return nil, fmt.Errorf("error opening postgres tower "+
                                "server DB: %v", err)
                }
                closeFuncs[NSTowerServerDB] = postgresTowerServerBackend.Close

                // The wallet subsystem is still not robust enough to run it
                // without a single writer in postgres therefore we create a
                // new config with the global lock enabled.
                //
                // NOTE: This is a temporary measure and should be removed as
                // soon as the wallet code is more robust.
                postgresConfigWalletDB := GetPostgresConfigKVDB(db.Postgres)
                postgresConfigWalletDB.WithGlobalLock = true

                postgresWalletBackend, err := kvdb.Open(
                        kvdb.PostgresBackendName, ctx,
                        postgresConfigWalletDB, NSWalletDB,
                )
                if err != nil {
                        return nil, fmt.Errorf("error opening postgres wallet "+
                                "DB: %v", err)
                }
                closeFuncs[NSWalletDB] = postgresWalletBackend.Close

                var nativeSQLStore sqldb.DB
                if db.UseNativeSQL {
                        nativePostgresStore, err := sqldb.NewPostgresStore(
                                db.Postgres,
                        )
                        if err != nil {
                                return nil, fmt.Errorf("error opening "+
                                        "native postgres store: %v", err)
                        }

                        nativeSQLStore = nativePostgresStore
                        closeFuncs[PostgresBackend] = nativePostgresStore.Close
                }

                // Warn if the user is trying to switch over to a Postgres DB
                // while there is a wallet or channel bbolt DB still present.
                warnExistingBoltDBs(
                        logger, "postgres", walletDBPath, WalletDBName,
                )
                warnExistingBoltDBs(
                        logger, "postgres", chanDBPath, ChannelDBName,
                )

                returnEarly = false

                return &DatabaseBackends{
                        GraphDB:       postgresBackend,
                        ChanStateDB:   postgresBackend,
                        HeightHintDB:  postgresBackend,
                        MacaroonDB:    postgresMacaroonBackend,
                        DecayedLogDB:  postgresDecayedLogBackend,
                        TowerClientDB: postgresTowerClientBackend,
                        TowerServerDB: postgresTowerServerBackend,
                        // The wallet loader will attempt to use/create the
                        // wallet in the replicated remote DB if we're running
                        // in a clustered environment. This will ensure that all
                        // members of the cluster have access to the same wallet
                        // state.
                        WalletDB: btcwallet.LoaderWithExternalWalletDB(
                                postgresWalletBackend,
                        ),
                        NativeSQLStore: nativeSQLStore,
                        Remote:         true,
                        CloseFuncs:     closeFuncs,
                }, nil

        case SqliteBackend:
                // Convert the sqldb SqliteConfig to a kvdb sqlite.Config.
                // This is a temporary measure until we migrate all kvdb SQL
                // users to native SQL.
                sqliteConfig := GetSqliteConfigKVDB(db.Sqlite)

                // Note that for sqlite, we put kv tables for the channel.db,
                // wtclient.db and sphinxreplay.db all in the channel.sqlite db.
                // The tables for wallet.db and macaroon.db are in the
                // chain.sqlite db and watchtower.db tables are in the
                // watchtower.sqlite db. The reason for the multiple sqlite dbs
                // is twofold. The first reason is that it maintains the file
                // structure that users are used to. The second reason is the
                // fact that sqlite only supports one writer at a time which
                // would cause deadlocks in the code due to the wallet db often
                // being accessed during a write to another db.
                sqliteBackend, err := kvdb.Open(
                        kvdb.SqliteBackendName, ctx, sqliteConfig, chanDBPath,
                        SqliteChannelDBName, NSChannelDB,
                )
                if err != nil {
                        return nil, fmt.Errorf("error opening sqlite graph "+
                                "DB: %v", err)
                }
                closeFuncs[NSChannelDB] = sqliteBackend.Close

                sqliteMacaroonBackend, err := kvdb.Open(
                        kvdb.SqliteBackendName, ctx, sqliteConfig, walletDBPath,
                        SqliteChainDBName, NSMacaroonDB,
                )
                if err != nil {
                        return nil, fmt.Errorf("error opening sqlite "+
                                "macaroon DB: %v", err)
                }
                closeFuncs[NSMacaroonDB] = sqliteMacaroonBackend.Close

                sqliteDecayedLogBackend, err := kvdb.Open(
                        kvdb.SqliteBackendName, ctx, sqliteConfig, chanDBPath,
                        SqliteChannelDBName, NSDecayedLogDB,
                )
                if err != nil {
                        return nil, fmt.Errorf("error opening sqlite decayed "+
                                "log DB: %v", err)
                }
                closeFuncs[NSDecayedLogDB] = sqliteDecayedLogBackend.Close

                sqliteTowerClientBackend, err := kvdb.Open(
                        kvdb.SqliteBackendName, ctx, sqliteConfig, chanDBPath,
                        SqliteChannelDBName, NSTowerClientDB,
                )
                if err != nil {
                        return nil, fmt.Errorf("error opening sqlite tower "+
                                "client DB: %v", err)
                }
                closeFuncs[NSTowerClientDB] = sqliteTowerClientBackend.Close

                sqliteTowerServerBackend, err := kvdb.Open(
                        kvdb.SqliteBackendName, ctx, sqliteConfig,
                        towerServerDBPath, SqliteTowerDBName, NSTowerServerDB,
                )
                if err != nil {
                        return nil, fmt.Errorf("error opening sqlite tower "+
                                "server DB: %v", err)
                }
                closeFuncs[NSTowerServerDB] = sqliteTowerServerBackend.Close

                sqliteWalletBackend, err := kvdb.Open(
                        kvdb.SqliteBackendName, ctx, sqliteConfig, walletDBPath,
                        SqliteChainDBName, NSWalletDB,
                )
                if err != nil {
                        return nil, fmt.Errorf("error opening sqlite macaroon "+
                                "DB: %v", err)
                }
                closeFuncs[NSWalletDB] = sqliteWalletBackend.Close

                var nativeSQLStore sqldb.DB
                if db.UseNativeSQL {
                        nativeSQLiteStore, err := sqldb.NewSqliteStore(
                                db.Sqlite,
                                path.Join(chanDBPath, SqliteNativeDBName),
                        )
                        if err != nil {
                                return nil, fmt.Errorf("error opening "+
                                        "native SQLite store: %v", err)
                        }

                        nativeSQLStore = nativeSQLiteStore
                        closeFuncs[SqliteBackend] = nativeSQLiteStore.Close
                }

                // Warn if the user is trying to switch over to a sqlite DB
                // while there is a wallet or channel bbolt DB still present.
                warnExistingBoltDBs(
                        logger, "sqlite", walletDBPath, WalletDBName,
                )
                warnExistingBoltDBs(
                        logger, "sqlite", chanDBPath, ChannelDBName,
                )

                returnEarly = false

                return &DatabaseBackends{
                        GraphDB:       sqliteBackend,
                        ChanStateDB:   sqliteBackend,
                        HeightHintDB:  sqliteBackend,
                        MacaroonDB:    sqliteMacaroonBackend,
                        DecayedLogDB:  sqliteDecayedLogBackend,
                        TowerClientDB: sqliteTowerClientBackend,
                        TowerServerDB: sqliteTowerServerBackend,
                        // The wallet loader will attempt to use/create the
                        // wallet in the replicated remote DB if we're running
                        // in a clustered environment. This will ensure that all
                        // members of the cluster have access to the same wallet
                        // state.
                        WalletDB: btcwallet.LoaderWithExternalWalletDB(
                                sqliteWalletBackend,
                        ),
                        NativeSQLStore: nativeSQLStore,
                        CloseFuncs:     closeFuncs,
                }, nil
        }

        // We're using all bbolt based databases by default.
        boltBackend, err := kvdb.GetBoltBackend(&kvdb.BoltBackendConfig{
                DBPath:            chanDBPath,
                DBFileName:        ChannelDBName,
                DBTimeout:         db.Bolt.DBTimeout,
                NoFreelistSync:    db.Bolt.NoFreelistSync,
                AutoCompact:       db.Bolt.AutoCompact,
                AutoCompactMinAge: db.Bolt.AutoCompactMinAge,
        })
        if err != nil {
                return nil, fmt.Errorf("error opening bolt DB: %w", err)
        }
        closeFuncs[NSChannelDB] = boltBackend.Close

        macaroonBackend, err := kvdb.GetBoltBackend(&kvdb.BoltBackendConfig{
                DBPath:            walletDBPath,
                DBFileName:        MacaroonDBName,
                DBTimeout:         db.Bolt.DBTimeout,
                NoFreelistSync:    db.Bolt.NoFreelistSync,
                AutoCompact:       db.Bolt.AutoCompact,
                AutoCompactMinAge: db.Bolt.AutoCompactMinAge,
        })
        if err != nil {
                return nil, fmt.Errorf("error opening macaroon DB: %w", err)
        }
        closeFuncs[NSMacaroonDB] = macaroonBackend.Close

        decayedLogBackend, err := kvdb.GetBoltBackend(&kvdb.BoltBackendConfig{
                DBPath:            chanDBPath,
                DBFileName:        DecayedLogDbName,
                DBTimeout:         db.Bolt.DBTimeout,
                NoFreelistSync:    db.Bolt.NoFreelistSync,
                AutoCompact:       db.Bolt.AutoCompact,
                AutoCompactMinAge: db.Bolt.AutoCompactMinAge,
        })
        if err != nil {
                return nil, fmt.Errorf("error opening decayed log DB: %w", err)
        }
        closeFuncs[NSDecayedLogDB] = decayedLogBackend.Close

        // The tower client is optional and might not be enabled by the user. We
        // handle it being nil properly in the main server.
        var towerClientBackend kvdb.Backend
        if towerClientEnabled {
                towerClientBackend, err = kvdb.GetBoltBackend(
                        &kvdb.BoltBackendConfig{
                                DBPath:            chanDBPath,
                                DBFileName:        TowerClientDBName,
                                DBTimeout:         db.Bolt.DBTimeout,
                                NoFreelistSync:    db.Bolt.NoFreelistSync,
                                AutoCompact:       db.Bolt.AutoCompact,
                                AutoCompactMinAge: db.Bolt.AutoCompactMinAge,
                        },
                )
                if err != nil {
                        return nil, fmt.Errorf("error opening tower client "+
                                "DB: %v", err)
                }
                closeFuncs[NSTowerClientDB] = towerClientBackend.Close
        }

        // The tower server is optional and might not be enabled by the user. We
        // handle it being nil properly in the main server.
        var towerServerBackend kvdb.Backend
        if towerServerEnabled {
                towerServerBackend, err = kvdb.GetBoltBackend(
                        &kvdb.BoltBackendConfig{
                                DBPath:            towerServerDBPath,
                                DBFileName:        TowerServerDBName,
                                DBTimeout:         db.Bolt.DBTimeout,
                                NoFreelistSync:    db.Bolt.NoFreelistSync,
                                AutoCompact:       db.Bolt.AutoCompact,
                                AutoCompactMinAge: db.Bolt.AutoCompactMinAge,
                        },
                )
                if err != nil {
                        return nil, fmt.Errorf("error opening tower server "+
                                "DB: %v", err)
                }
                closeFuncs[NSTowerServerDB] = towerServerBackend.Close
        }

        returnEarly = false

        return &DatabaseBackends{
                GraphDB:       boltBackend,
                ChanStateDB:   boltBackend,
                HeightHintDB:  boltBackend,
                MacaroonDB:    macaroonBackend,
                DecayedLogDB:  decayedLogBackend,
                TowerClientDB: towerClientBackend,
                TowerServerDB: towerServerBackend,
                // When "running locally", LND will use the bbolt wallet.db to
                // store the wallet located in the chain data dir, parametrized
                // by the active network. The wallet loader has its own cleanup
                // method so we don't need to add anything to our map (in fact
                // nothing is opened just yet).
                WalletDB: btcwallet.LoaderWithLocalWalletDB(
                        walletDBPath, db.Bolt.NoFreelistSync, db.Bolt.DBTimeout,
                ),
                CloseFuncs: closeFuncs,
        }, nil
}

// warnExistingBoltDBs checks if there is an existing bbolt database in the
// given location and logs a warning if so.
func warnExistingBoltDBs(log btclog.Logger, dbType, dir, fileName string) {
        if lnrpc.FileExists(filepath.Join(dir, fileName)) {
                log.Warnf("Found existing bbolt database file in %s/%s while "+
                        "using database type %s. Existing data will NOT be "+
                        "migrated to %s automatically!", dir, fileName, dbType,
                        dbType)
        }
}

// Compile-time constraint to ensure Workers implements the Validator interface.
var _ Validator = (*DB)(nil)

lightningnetwork / lnd / 14495430837

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous