mirror of https://github.com/bitcoin/bitcoin
scripted-diff: replace wallet DatabaseStatus with DatabaseError
-BEGIN VERIFY SCRIPT- git grep -l DatabaseStatus src | xargs sed -i s/DatabaseStatus/DatabaseError/g sed -i '/^ SUCCESS,$/d' src/wallet/db.h -END VERIFY SCRIPT-
This commit is contained in:
Ryan Ofsky
parent
965c31baa9
commit
2385cb37db
|
|
@ -929,7 +929,7 @@ std::unique_ptr<DatabaseBatch> BerkeleyDatabase::MakeBatch(bool flush_on_close)
|
|||
return std::make_unique<BerkeleyBatch>(*this, false, flush_on_close);
|
||||
}
|
||||
|
||||
util::ResultPtr<std::unique_ptr<BerkeleyDatabase>, DatabaseStatus> MakeBerkeleyDatabase(const fs::path& path, const DatabaseOptions& options)
|
||||
util::ResultPtr<std::unique_ptr<BerkeleyDatabase>, DatabaseError> MakeBerkeleyDatabase(const fs::path& path, const DatabaseOptions& options)
|
||||
{
|
||||
fs::path data_file = BDBDataFile(path);
|
||||
std::unique_ptr<BerkeleyDatabase> db;
|
||||
|
|
@ -939,14 +939,14 @@ util::ResultPtr<std::unique_ptr<BerkeleyDatabase>, DatabaseStatus> MakeBerkeleyD
|
|||
std::shared_ptr<BerkeleyEnvironment> env = GetBerkeleyEnv(data_file.parent_path(), options.use_shared_memory);
|
||||
if (env->m_databases.count(data_filename)) {
|
||||
return {util::Error{Untranslated(strprintf("Refusing to load database. Data file '%s' is already loaded.", fs::PathToString(env->Directory() / data_filename)))},
|
||||
DatabaseStatus::FAILED_ALREADY_LOADED};
|
||||
DatabaseError::FAILED_ALREADY_LOADED};
|
||||
}
|
||||
db = std::make_unique<BerkeleyDatabase>(std::move(env), std::move(data_filename), options);
|
||||
}
|
||||
|
||||
util::Result<void> verified;
|
||||
if (options.verify && !(verified = db->Verify())) {
|
||||
return {util::Error{}, util::MoveMessages(verified), DatabaseStatus::FAILED_VERIFY};
|
||||
return {util::Error{}, util::MoveMessages(verified), DatabaseError::FAILED_VERIFY};
|
||||
}
|
||||
|
||||
return {std::move(db)};
|
||||
|
|
|
|||
|
|
@ -216,7 +216,7 @@ std::string BerkeleyDatabaseVersion();
|
|||
bool BerkeleyDatabaseSanityCheck();
|
||||
|
||||
//! Return object giving access to Berkeley database at specified path.
|
||||
util::ResultPtr<std::unique_ptr<BerkeleyDatabase>, DatabaseStatus> MakeBerkeleyDatabase(const fs::path& path, const DatabaseOptions& options);
|
||||
util::ResultPtr<std::unique_ptr<BerkeleyDatabase>, DatabaseError> MakeBerkeleyDatabase(const fs::path& path, const DatabaseOptions& options);
|
||||
} // namespace wallet
|
||||
|
||||
#endif // BITCOIN_WALLET_BDB_H
|
||||
|
|
|
|||
|
|
@ -194,8 +194,7 @@ struct DatabaseOptions {
|
|||
int64_t max_log_mb = 100; //!< Max log size to allow before consolidating.
|
||||
};
|
||||
|
||||
enum class DatabaseStatus {
|
||||
SUCCESS,
|
||||
enum class DatabaseError {
|
||||
FAILED_BAD_PATH,
|
||||
FAILED_BAD_FORMAT,
|
||||
FAILED_ALREADY_LOADED,
|
||||
|
|
@ -212,7 +211,7 @@ enum class DatabaseStatus {
|
|||
std::vector<fs::path> ListDatabases(const fs::path& path);
|
||||
|
||||
void ReadDatabaseArgs(const ArgsManager& args, DatabaseOptions& options);
|
||||
util::ResultPtr<std::unique_ptr<WalletDatabase>, DatabaseStatus> MakeDatabase(const fs::path& path, const DatabaseOptions& options);
|
||||
util::ResultPtr<std::unique_ptr<WalletDatabase>, DatabaseError> MakeDatabase(const fs::path& path, const DatabaseOptions& options);
|
||||
|
||||
fs::path BDBDataFile(const fs::path& path);
|
||||
fs::path SQLiteDataFile(const fs::path& path);
|
||||
|
|
|
|||
|
|
@ -87,7 +87,7 @@ bool VerifyWallets(WalletContext& context)
|
|||
options.verify = true;
|
||||
auto result = MakeWalletDatabase(wallet_file, options);
|
||||
if (!result) {
|
||||
if (result.GetFailure() == DatabaseStatus::FAILED_NOT_FOUND) {
|
||||
if (result.GetFailure() == DatabaseError::FAILED_NOT_FOUND) {
|
||||
chain.initWarning(Untranslated(strprintf("Skipping -wallet path that doesn't exist. %s", util::ErrorString(result).original)));
|
||||
} else {
|
||||
chain.initError(util::ErrorString(result));
|
||||
|
|
@ -115,7 +115,7 @@ bool LoadWallets(WalletContext& context)
|
|||
options.verify = false; // No need to verify, assuming verified earlier in VerifyWallets()
|
||||
util::Result<void> result;
|
||||
auto database = MakeWalletDatabase(name, options) >> result;
|
||||
if (!database && database.GetFailure() == DatabaseStatus::FAILED_NOT_FOUND) {
|
||||
if (!database && database.GetFailure() == DatabaseError::FAILED_NOT_FOUND) {
|
||||
continue;
|
||||
}
|
||||
chain.initMessage(_("Loading wallet…").translated);
|
||||
|
|
|
|||
|
|
@ -151,24 +151,24 @@ void PushParentDescriptors(const CWallet& wallet, const CScript& script_pubkey,
|
|||
entry.pushKV("parent_descs", parent_descs);
|
||||
}
|
||||
|
||||
void HandleWalletError(const util::ResultPtr<std::shared_ptr<CWallet>, DatabaseStatus>& wallet)
|
||||
void HandleWalletError(const util::ResultPtr<std::shared_ptr<CWallet>, DatabaseError>& wallet)
|
||||
{
|
||||
if (!wallet) {
|
||||
// Map bad format to not found, since bad format is returned when the
|
||||
// wallet directory exists, but doesn't contain a data file.
|
||||
RPCErrorCode code = RPC_WALLET_ERROR;
|
||||
switch (wallet.GetFailure()) {
|
||||
case DatabaseStatus::FAILED_NOT_FOUND:
|
||||
case DatabaseStatus::FAILED_BAD_FORMAT:
|
||||
case DatabaseError::FAILED_NOT_FOUND:
|
||||
case DatabaseError::FAILED_BAD_FORMAT:
|
||||
code = RPC_WALLET_NOT_FOUND;
|
||||
break;
|
||||
case DatabaseStatus::FAILED_ALREADY_LOADED:
|
||||
case DatabaseError::FAILED_ALREADY_LOADED:
|
||||
code = RPC_WALLET_ALREADY_LOADED;
|
||||
break;
|
||||
case DatabaseStatus::FAILED_ALREADY_EXISTS:
|
||||
case DatabaseError::FAILED_ALREADY_EXISTS:
|
||||
code = RPC_WALLET_ALREADY_EXISTS;
|
||||
break;
|
||||
case DatabaseStatus::FAILED_INVALID_BACKUP_FILE:
|
||||
case DatabaseError::FAILED_INVALID_BACKUP_FILE:
|
||||
code = RPC_INVALID_PARAMETER;
|
||||
break;
|
||||
default: // RPC_WALLET_ERROR is returned for all other cases.
|
||||
|
|
|
|||
|
|
@ -21,7 +21,7 @@ struct bilingual_str;
|
|||
|
||||
namespace wallet {
|
||||
class LegacyScriptPubKeyMan;
|
||||
enum class DatabaseStatus;
|
||||
enum class DatabaseError;
|
||||
struct WalletContext;
|
||||
|
||||
extern const std::string HELP_REQUIRING_PASSPHRASE;
|
||||
|
|
@ -51,7 +51,7 @@ std::string LabelFromValue(const UniValue& value);
|
|||
//! Fetch parent descriptors of this scriptPubKey.
|
||||
void PushParentDescriptors(const CWallet& wallet, const CScript& script_pubkey, UniValue& entry);
|
||||
|
||||
void HandleWalletError(const util::ResultPtr<std::shared_ptr<CWallet>, DatabaseStatus>& wallet);
|
||||
void HandleWalletError(const util::ResultPtr<std::shared_ptr<CWallet>, DatabaseError>& wallet);
|
||||
int64_t ParseISO8601DateTime(const std::string& str);
|
||||
void AppendLastProcessedBlock(UniValue& entry, const CWallet& wallet) EXCLUSIVE_LOCKS_REQUIRED(wallet.cs_wallet);
|
||||
} // namespace wallet
|
||||
|
|
|
|||
|
|
@ -427,7 +427,7 @@ static RPCHelpMan createwallet()
|
|||
std::optional<bool> load_on_start = request.params[6].isNull() ? std::nullopt : std::optional<bool>(request.params[6].get_bool());
|
||||
auto wallet = CreateWallet(context, request.params[0].get_str(), load_on_start, options) >> result;
|
||||
if (!wallet) {
|
||||
RPCErrorCode code = wallet.GetFailure() == DatabaseStatus::FAILED_ENCRYPT ? RPC_WALLET_ENCRYPTION_FAILED : RPC_WALLET_ERROR;
|
||||
RPCErrorCode code = wallet.GetFailure() == DatabaseError::FAILED_ENCRYPT ? RPC_WALLET_ENCRYPTION_FAILED : RPC_WALLET_ERROR;
|
||||
throw JSONRPCError(code, Join(result.GetErrors(), Untranslated(" ")).original);
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -689,18 +689,18 @@ bool SQLiteBatch::TxnAbort()
|
|||
return res == SQLITE_OK;
|
||||
}
|
||||
|
||||
util::ResultPtr<std::unique_ptr<SQLiteDatabase>, DatabaseStatus> MakeSQLiteDatabase(const fs::path& path, const DatabaseOptions& options)
|
||||
util::ResultPtr<std::unique_ptr<SQLiteDatabase>, DatabaseError> MakeSQLiteDatabase(const fs::path& path, const DatabaseOptions& options)
|
||||
{
|
||||
try {
|
||||
fs::path data_file = SQLiteDataFile(path);
|
||||
auto db = std::make_unique<SQLiteDatabase>(data_file.parent_path(), data_file, options);
|
||||
util::Result<void> verified;
|
||||
if (options.verify && !(verified = db->Verify())) {
|
||||
return {util::Error{}, util::MoveMessages(verified), DatabaseStatus::FAILED_VERIFY};
|
||||
return {util::Error{}, util::MoveMessages(verified), DatabaseError::FAILED_VERIFY};
|
||||
}
|
||||
return db;
|
||||
} catch (const std::runtime_error& e) {
|
||||
return {util::Error{Untranslated(e.what())}, DatabaseStatus::FAILED_LOAD};
|
||||
return {util::Error{Untranslated(e.what())}, DatabaseError::FAILED_LOAD};
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -178,7 +178,7 @@ public:
|
|||
bool m_use_unsafe_sync;
|
||||
};
|
||||
|
||||
util::ResultPtr<std::unique_ptr<SQLiteDatabase>, DatabaseStatus> MakeSQLiteDatabase(const fs::path& path, const DatabaseOptions& options);
|
||||
util::ResultPtr<std::unique_ptr<SQLiteDatabase>, DatabaseError> MakeSQLiteDatabase(const fs::path& path, const DatabaseOptions& options);
|
||||
|
||||
std::string SQLiteDatabaseVersion();
|
||||
} // namespace wallet
|
||||
|
|
|
|||
|
|
@ -254,7 +254,7 @@ void UnloadWallet(std::shared_ptr<CWallet>&& wallet)
|
|||
}
|
||||
|
||||
namespace {
|
||||
util::ResultPtr<std::shared_ptr<CWallet>, DatabaseStatus> LoadWalletInternal(WalletContext& context, const std::string& name, std::optional<bool> load_on_start, const DatabaseOptions& options)
|
||||
util::ResultPtr<std::shared_ptr<CWallet>, DatabaseError> LoadWalletInternal(WalletContext& context, const std::string& name, std::optional<bool> load_on_start, const DatabaseOptions& options)
|
||||
{
|
||||
util::Result<void> result;
|
||||
try {
|
||||
|
|
@ -266,7 +266,7 @@ util::ResultPtr<std::shared_ptr<CWallet>, DatabaseStatus> LoadWalletInternal(Wal
|
|||
context.chain->initMessage(_("Loading wallet…").translated);
|
||||
auto wallet = CWallet::Create(context, name, std::move(database.value()), options.create_flags) >> result;
|
||||
if (!wallet) {
|
||||
return {util::Error{Untranslated("Wallet loading failed.")}, util::MoveMessages(result), DatabaseStatus::FAILED_LOAD};
|
||||
return {util::Error{Untranslated("Wallet loading failed.")}, util::MoveMessages(result), DatabaseError::FAILED_LOAD};
|
||||
}
|
||||
|
||||
// Legacy wallets are being deprecated, warn if the loaded wallet is legacy
|
||||
|
|
@ -283,7 +283,7 @@ util::ResultPtr<std::shared_ptr<CWallet>, DatabaseStatus> LoadWalletInternal(Wal
|
|||
|
||||
return {util::MoveMessages(result), std::move(wallet.value())};
|
||||
} catch (const std::runtime_error& e) {
|
||||
return {util::Error{Untranslated(e.what())}, util::MoveMessages(result), DatabaseStatus::FAILED_LOAD};
|
||||
return {util::Error{Untranslated(e.what())}, util::MoveMessages(result), DatabaseError::FAILED_LOAD};
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -346,20 +346,20 @@ private:
|
|||
};
|
||||
} // namespace
|
||||
|
||||
util::ResultPtr<std::shared_ptr<CWallet>, DatabaseStatus> LoadWallet(WalletContext& context, const std::string& name, std::optional<bool> load_on_start, const DatabaseOptions& options)
|
||||
util::ResultPtr<std::shared_ptr<CWallet>, DatabaseError> LoadWallet(WalletContext& context, const std::string& name, std::optional<bool> load_on_start, const DatabaseOptions& options)
|
||||
{
|
||||
auto result = WITH_LOCK(g_loading_wallet_mutex, return g_loading_wallet_set.insert(name));
|
||||
if (!result.second) {
|
||||
return {util::Error{Untranslated("Wallet already loading.")}, DatabaseStatus::FAILED_LOAD};
|
||||
return {util::Error{Untranslated("Wallet already loading.")}, DatabaseError::FAILED_LOAD};
|
||||
}
|
||||
auto wallet = LoadWalletInternal(context, name, load_on_start, options);
|
||||
WITH_LOCK(g_loading_wallet_mutex, g_loading_wallet_set.erase(result.first));
|
||||
return wallet;
|
||||
}
|
||||
|
||||
util::ResultPtr<std::shared_ptr<CWallet>, DatabaseStatus> CreateWallet(WalletContext& context, const std::string& name, std::optional<bool> load_on_start, DatabaseOptions& options)
|
||||
util::ResultPtr<std::shared_ptr<CWallet>, DatabaseError> CreateWallet(WalletContext& context, const std::string& name, std::optional<bool> load_on_start, DatabaseOptions& options)
|
||||
{
|
||||
util::Result<DatabaseStatus> result;
|
||||
util::Result<DatabaseError> result;
|
||||
|
||||
uint64_t wallet_creation_flags = options.create_flags;
|
||||
const SecureString& passphrase = options.create_passphrase;
|
||||
|
|
@ -376,42 +376,42 @@ util::ResultPtr<std::shared_ptr<CWallet>, DatabaseStatus> CreateWallet(WalletCon
|
|||
|
||||
// Private keys must be disabled for an external signer wallet
|
||||
if ((wallet_creation_flags & WALLET_FLAG_EXTERNAL_SIGNER) && !(wallet_creation_flags & WALLET_FLAG_DISABLE_PRIVATE_KEYS)) {
|
||||
return {util::Error{Untranslated("Private keys must be disabled when using an external signer")}, util::MoveMessages(result), DatabaseStatus::FAILED_CREATE};
|
||||
return {util::Error{Untranslated("Private keys must be disabled when using an external signer")}, util::MoveMessages(result), DatabaseError::FAILED_CREATE};
|
||||
}
|
||||
|
||||
// Descriptor support must be enabled for an external signer wallet
|
||||
if ((wallet_creation_flags & WALLET_FLAG_EXTERNAL_SIGNER) && !(wallet_creation_flags & WALLET_FLAG_DESCRIPTORS)) {
|
||||
return {util::Error{Untranslated("Descriptor support must be enabled when using an external signer")}, util::MoveMessages(result), DatabaseStatus::FAILED_CREATE};
|
||||
return {util::Error{Untranslated("Descriptor support must be enabled when using an external signer")}, util::MoveMessages(result), DatabaseError::FAILED_CREATE};
|
||||
}
|
||||
|
||||
// Do not allow a passphrase when private keys are disabled
|
||||
if (!passphrase.empty() && (wallet_creation_flags & WALLET_FLAG_DISABLE_PRIVATE_KEYS)) {
|
||||
return {util::Error{Untranslated("Passphrase provided but private keys are disabled. A passphrase is only used to encrypt private keys, so cannot be used for wallets with private keys disabled.")}, util::MoveMessages(result), DatabaseStatus::FAILED_CREATE};
|
||||
return {util::Error{Untranslated("Passphrase provided but private keys are disabled. A passphrase is only used to encrypt private keys, so cannot be used for wallets with private keys disabled.")}, util::MoveMessages(result), DatabaseError::FAILED_CREATE};
|
||||
}
|
||||
|
||||
// Wallet::Verify will check if we're trying to create a wallet with a duplicate name.
|
||||
auto database = MakeWalletDatabase(name, options) >> result;
|
||||
if (!database) {
|
||||
return {util::Error{Untranslated("Wallet file verification failed.")}, util::MoveMessages(result), DatabaseStatus::FAILED_VERIFY};
|
||||
return {util::Error{Untranslated("Wallet file verification failed.")}, util::MoveMessages(result), DatabaseError::FAILED_VERIFY};
|
||||
}
|
||||
|
||||
// Make the wallet
|
||||
context.chain->initMessage(_("Loading wallet…").translated);
|
||||
auto create = CWallet::Create(context, name, std::move(database.value()), wallet_creation_flags) >> result;
|
||||
if (!create) {
|
||||
return {util::Error{Untranslated("Wallet creation failed.")}, util::MoveMessages(result), DatabaseStatus::FAILED_CREATE};
|
||||
return {util::Error{Untranslated("Wallet creation failed.")}, util::MoveMessages(result), DatabaseError::FAILED_CREATE};
|
||||
}
|
||||
std::shared_ptr<CWallet> wallet = create.value();
|
||||
|
||||
// Encrypt the wallet
|
||||
if (!passphrase.empty() && !(wallet_creation_flags & WALLET_FLAG_DISABLE_PRIVATE_KEYS)) {
|
||||
if (!wallet->EncryptWallet(passphrase)) {
|
||||
return {util::Error{Untranslated("Error: Wallet created but failed to encrypt.")}, util::MoveMessages(result), DatabaseStatus::FAILED_ENCRYPT};
|
||||
return {util::Error{Untranslated("Error: Wallet created but failed to encrypt.")}, util::MoveMessages(result), DatabaseError::FAILED_ENCRYPT};
|
||||
}
|
||||
if (!create_blank) {
|
||||
// Unlock the wallet
|
||||
if (!wallet->Unlock(passphrase)) {
|
||||
return {util::Error{Untranslated("Error: Wallet was encrypted but could not be unlocked")}, util::MoveMessages(result), DatabaseStatus::FAILED_ENCRYPT};
|
||||
return {util::Error{Untranslated("Error: Wallet was encrypted but could not be unlocked")}, util::MoveMessages(result), DatabaseError::FAILED_ENCRYPT};
|
||||
}
|
||||
|
||||
// Set a seed for the wallet
|
||||
|
|
@ -422,7 +422,7 @@ util::ResultPtr<std::shared_ptr<CWallet>, DatabaseStatus> CreateWallet(WalletCon
|
|||
} else {
|
||||
for (auto spk_man : wallet->GetActiveScriptPubKeyMans()) {
|
||||
if (!spk_man->SetupGeneration()) {
|
||||
return {util::Error{Untranslated("Unable to generate initial keys")}, util::MoveMessages(result), DatabaseStatus::FAILED_CREATE};
|
||||
return {util::Error{Untranslated("Unable to generate initial keys")}, util::MoveMessages(result), DatabaseError::FAILED_CREATE};
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -448,7 +448,7 @@ util::ResultPtr<std::shared_ptr<CWallet>, DatabaseStatus> CreateWallet(WalletCon
|
|||
return {util::MoveMessages(result), wallet};
|
||||
}
|
||||
|
||||
util::ResultPtr<std::shared_ptr<CWallet>, DatabaseStatus> RestoreWallet(WalletContext& context, const fs::path& backup_file, const std::string& wallet_name, std::optional<bool> load_on_start)
|
||||
util::ResultPtr<std::shared_ptr<CWallet>, DatabaseError> RestoreWallet(WalletContext& context, const fs::path& backup_file, const std::string& wallet_name, std::optional<bool> load_on_start)
|
||||
{
|
||||
DatabaseOptions options;
|
||||
ReadDatabaseArgs(*context.args, options);
|
||||
|
|
@ -456,15 +456,15 @@ util::ResultPtr<std::shared_ptr<CWallet>, DatabaseStatus> RestoreWallet(WalletCo
|
|||
|
||||
const fs::path wallet_path = fsbridge::AbsPathJoin(GetWalletDir(), fs::u8path(wallet_name));
|
||||
auto wallet_file = wallet_path / "wallet.dat";
|
||||
util::ResultPtr<std::shared_ptr<CWallet>, DatabaseStatus> wallet;
|
||||
util::ResultPtr<std::shared_ptr<CWallet>, DatabaseError> wallet;
|
||||
|
||||
try {
|
||||
if (!fs::exists(backup_file)) {
|
||||
return {util::Error{Untranslated("Backup file does not exist")}, DatabaseStatus::FAILED_INVALID_BACKUP_FILE};
|
||||
return {util::Error{Untranslated("Backup file does not exist")}, DatabaseError::FAILED_INVALID_BACKUP_FILE};
|
||||
}
|
||||
|
||||
if (fs::exists(wallet_path) || !TryCreateDirectories(wallet_path)) {
|
||||
return {util::Error{Untranslated(strprintf("Failed to create database path '%s'. Database already exists.", fs::PathToString(wallet_path)))}, DatabaseStatus::FAILED_ALREADY_EXISTS};
|
||||
return {util::Error{Untranslated(strprintf("Failed to create database path '%s'. Database already exists.", fs::PathToString(wallet_path)))}, DatabaseError::FAILED_ALREADY_EXISTS};
|
||||
}
|
||||
|
||||
fs::copy_file(backup_file, wallet_file, fs::copy_options::none);
|
||||
|
|
@ -2854,7 +2854,7 @@ bool CWallet::EraseAddressReceiveRequest(WalletBatch& batch, const CTxDestinatio
|
|||
return true;
|
||||
}
|
||||
|
||||
util::ResultPtr<std::unique_ptr<WalletDatabase>, DatabaseStatus> MakeWalletDatabase(const std::string& name, const DatabaseOptions& options)
|
||||
util::ResultPtr<std::unique_ptr<WalletDatabase>, DatabaseError> MakeWalletDatabase(const std::string& name, const DatabaseOptions& options)
|
||||
{
|
||||
// Do some checking on wallet path. It should be either a:
|
||||
//
|
||||
|
|
@ -2872,7 +2872,7 @@ util::ResultPtr<std::unique_ptr<WalletDatabase>, DatabaseStatus> MakeWalletDatab
|
|||
"database/log.?????????? files can be stored, a location where such a directory could be created, "
|
||||
"or (for backwards compatibility) the name of an existing data file in -walletdir (%s)",
|
||||
name, fs::quoted(fs::PathToString(GetWalletDir()))))},
|
||||
DatabaseStatus::FAILED_BAD_PATH};
|
||||
DatabaseError::FAILED_BAD_PATH};
|
||||
}
|
||||
return MakeDatabase(wallet_path, options);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -93,12 +93,12 @@ util::Result<bool> RemoveWallet(WalletContext& context, const std::shared_ptr<CW
|
|||
std::vector<std::shared_ptr<CWallet>> GetWallets(WalletContext& context);
|
||||
std::shared_ptr<CWallet> GetDefaultWallet(WalletContext& context, size_t& count);
|
||||
std::shared_ptr<CWallet> GetWallet(WalletContext& context, const std::string& name);
|
||||
util::ResultPtr<std::shared_ptr<CWallet>, DatabaseStatus> LoadWallet(WalletContext& context, const std::string& name, std::optional<bool> load_on_start, const DatabaseOptions& options);
|
||||
util::ResultPtr<std::shared_ptr<CWallet>, DatabaseStatus> CreateWallet(WalletContext& context, const std::string& name, std::optional<bool> load_on_start, DatabaseOptions& options);
|
||||
util::ResultPtr<std::shared_ptr<CWallet>, DatabaseStatus> RestoreWallet(WalletContext& context, const fs::path& backup_file, const std::string& wallet_name, std::optional<bool> load_on_start);
|
||||
util::ResultPtr<std::shared_ptr<CWallet>, DatabaseError> LoadWallet(WalletContext& context, const std::string& name, std::optional<bool> load_on_start, const DatabaseOptions& options);
|
||||
util::ResultPtr<std::shared_ptr<CWallet>, DatabaseError> CreateWallet(WalletContext& context, const std::string& name, std::optional<bool> load_on_start, DatabaseOptions& options);
|
||||
util::ResultPtr<std::shared_ptr<CWallet>, DatabaseError> RestoreWallet(WalletContext& context, const fs::path& backup_file, const std::string& wallet_name, std::optional<bool> load_on_start);
|
||||
std::unique_ptr<interfaces::Handler> HandleLoadWallet(WalletContext& context, LoadWalletFn load_wallet);
|
||||
void NotifyWalletLoaded(WalletContext& context, const std::shared_ptr<CWallet>& wallet);
|
||||
util::ResultPtr<std::unique_ptr<WalletDatabase>, DatabaseStatus> MakeWalletDatabase(const std::string& name, const DatabaseOptions& options);
|
||||
util::ResultPtr<std::unique_ptr<WalletDatabase>, DatabaseError> MakeWalletDatabase(const std::string& name, const DatabaseOptions& options);
|
||||
|
||||
//! -paytxfee default
|
||||
constexpr CAmount DEFAULT_PAY_TX_FEE = 0;
|
||||
|
|
|
|||
|
|
@ -1347,13 +1347,13 @@ bool WalletBatch::TxnAbort()
|
|||
return m_batch->TxnAbort();
|
||||
}
|
||||
|
||||
util::ResultPtr<std::unique_ptr<WalletDatabase>, DatabaseStatus> MakeDatabase(const fs::path& path, const DatabaseOptions& options)
|
||||
util::ResultPtr<std::unique_ptr<WalletDatabase>, DatabaseError> MakeDatabase(const fs::path& path, const DatabaseOptions& options)
|
||||
{
|
||||
bool exists;
|
||||
try {
|
||||
exists = fs::symlink_status(path).type() != fs::file_type::not_found;
|
||||
} catch (const fs::filesystem_error& e) {
|
||||
return {util::Error{Untranslated(strprintf("Failed to access database path '%s': %s", fs::PathToString(path), fsbridge::get_filesystem_error_message(e)))}, DatabaseStatus::FAILED_BAD_PATH};
|
||||
return {util::Error{Untranslated(strprintf("Failed to access database path '%s': %s", fs::PathToString(path), fsbridge::get_filesystem_error_message(e)))}, DatabaseError::FAILED_BAD_PATH};
|
||||
}
|
||||
|
||||
std::optional<DatabaseFormat> format;
|
||||
|
|
@ -1363,25 +1363,25 @@ util::ResultPtr<std::unique_ptr<WalletDatabase>, DatabaseStatus> MakeDatabase(co
|
|||
}
|
||||
if (IsSQLiteFile(SQLiteDataFile(path))) {
|
||||
if (format) {
|
||||
return {util::Error{Untranslated(strprintf("Failed to load database path '%s'. Data is in ambiguous format.", fs::PathToString(path)))}, DatabaseStatus::FAILED_BAD_FORMAT};
|
||||
return {util::Error{Untranslated(strprintf("Failed to load database path '%s'. Data is in ambiguous format.", fs::PathToString(path)))}, DatabaseError::FAILED_BAD_FORMAT};
|
||||
}
|
||||
format = DatabaseFormat::SQLITE;
|
||||
}
|
||||
} else if (options.require_existing) {
|
||||
return {util::Error{Untranslated(strprintf("Failed to load database path '%s'. Path does not exist.", fs::PathToString(path)))}, DatabaseStatus::FAILED_NOT_FOUND};
|
||||
return {util::Error{Untranslated(strprintf("Failed to load database path '%s'. Path does not exist.", fs::PathToString(path)))}, DatabaseError::FAILED_NOT_FOUND};
|
||||
}
|
||||
|
||||
if (!format && options.require_existing) {
|
||||
return {util::Error{Untranslated(strprintf("Failed to load database path '%s'. Data is not in recognized format.", fs::PathToString(path)))}, DatabaseStatus::FAILED_BAD_FORMAT};
|
||||
return {util::Error{Untranslated(strprintf("Failed to load database path '%s'. Data is not in recognized format.", fs::PathToString(path)))}, DatabaseError::FAILED_BAD_FORMAT};
|
||||
}
|
||||
|
||||
if (format && options.require_create) {
|
||||
return {util::Error{Untranslated(strprintf("Failed to create database path '%s'. Database already exists.", fs::PathToString(path)))}, DatabaseStatus::FAILED_ALREADY_EXISTS};
|
||||
return {util::Error{Untranslated(strprintf("Failed to create database path '%s'. Database already exists.", fs::PathToString(path)))}, DatabaseError::FAILED_ALREADY_EXISTS};
|
||||
}
|
||||
|
||||
// A db already exists so format is set, but options also specifies the format, so make sure they agree
|
||||
if (format && options.require_format && format != options.require_format) {
|
||||
return {util::Error{Untranslated(strprintf("Failed to load database path '%s'. Data is not in required format.", fs::PathToString(path)))}, DatabaseStatus::FAILED_BAD_FORMAT};
|
||||
return {util::Error{Untranslated(strprintf("Failed to load database path '%s'. Data is not in required format.", fs::PathToString(path)))}, DatabaseError::FAILED_BAD_FORMAT};
|
||||
}
|
||||
|
||||
// Format is not set when a db doesn't already exist, so use the format specified by the options if it is set.
|
||||
|
|
@ -1405,7 +1405,7 @@ util::ResultPtr<std::unique_ptr<WalletDatabase>, DatabaseStatus> MakeDatabase(co
|
|||
#endif
|
||||
{
|
||||
return {util::Error{Untranslated(strprintf("Failed to open database path '%s'. Build does not support SQLite database format.", fs::PathToString(path)))},
|
||||
DatabaseStatus::FAILED_BAD_FORMAT};
|
||||
DatabaseError::FAILED_BAD_FORMAT};
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -1416,7 +1416,7 @@ util::ResultPtr<std::unique_ptr<WalletDatabase>, DatabaseStatus> MakeDatabase(co
|
|||
#endif
|
||||
{
|
||||
return {util::Error{Untranslated(strprintf("Failed to open database path '%s'. Build does not support Berkeley DB database format.", fs::PathToString(path)))},
|
||||
DatabaseStatus::FAILED_BAD_FORMAT};
|
||||
DatabaseError::FAILED_BAD_FORMAT};
|
||||
}
|
||||
}
|
||||
} // namespace wallet
|
||||
|
|
|
|||
Loading…
Reference in New Issue