// TestInterface performs all interfaces tests for this database driver. func TestInterface(t *testing.T) { t.Parallel() // Create a new database to run tests against. dbPath := filepath.Join(os.TempDir(), "ffldb-interfacetest") _ = os.RemoveAll(dbPath) db, err := database.Create(dbType, dbPath, blockDataNet) if err != nil { t.Errorf("Failed to create test database (%s) %v", dbType, err) return } defer os.RemoveAll(dbPath) defer db.Close() // Ensure the driver type is the expected value. gotDbType := db.Type() if gotDbType != dbType { t.Errorf("Type: unepxected driver type - got %v, want %v", gotDbType, dbType) return } // Run all of the interface tests against the database. runtime.GOMAXPROCS(runtime.NumCPU()) // Change the maximum file size to a small value to force multiple flat // files with the test data set. ffldb.TstRunWithMaxBlockFileSize(db, 2048, func() { testInterface(t, db) }) }
// loadBlockDB opens the block database and returns a handle to it. func loadBlockDB() (database.DB, error) { // The database name is based on the database type. dbName := blockDbNamePrefix + "_" + cfg.DbType dbPath := filepath.Join(cfg.DataDir, dbName) log.Infof("Loading block database from '%s'", dbPath) db, err := database.Open(cfg.DbType, dbPath, activeNetParams.Net) if err != nil { // Return the error if it's not because the database doesn't // exist. if dbErr, ok := err.(database.Error); !ok || dbErr.ErrorCode != database.ErrDbDoesNotExist { return nil, err } // Create the db if it does not exist. err = os.MkdirAll(cfg.DataDir, 0700) if err != nil { return nil, err } db, err = database.Create(cfg.DbType, dbPath, activeNetParams.Net) if err != nil { return nil, err } } log.Info("Block database loaded") return db, nil }
// TestCreateOpenUnsupported ensures that attempting to create or open an // unsupported database type is handled properly. func TestCreateOpenUnsupported(t *testing.T) { // Ensure creating a database with an unsupported type fails with the // expected error. testName := "create with unsupported database type" dbType := "unsupported" _, err := database.Create(dbType) if !checkDbError(t, testName, err, database.ErrDbUnknownType) { return } // Ensure opening a database with the an unsupported type fails with the // expected error. testName = "open with unsupported database type" _, err = database.Open(dbType) if !checkDbError(t, testName, err, database.ErrDbUnknownType) { return } }
// BenchmarkBlockHeader benchmarks how long it takes to load the mainnet genesis // block. func BenchmarkBlock(b *testing.B) { // Start by creating a new database and populating it with the mainnet // genesis block. dbPath := filepath.Join(os.TempDir(), "ffldb-benchblk") _ = os.RemoveAll(dbPath) db, err := database.Create("ffldb", dbPath, blockDataNet) if err != nil { b.Fatal(err) } defer os.RemoveAll(dbPath) defer db.Close() err = db.Update(func(tx database.Tx) error { block := btcutil.NewBlock(chaincfg.MainNetParams.GenesisBlock) if err := tx.StoreBlock(block); err != nil { return err } return nil }) if err != nil { b.Fatal(err) } b.ReportAllocs() b.ResetTimer() err = db.View(func(tx database.Tx) error { blockHash := chaincfg.MainNetParams.GenesisHash for i := 0; i < b.N; i++ { _, err := tx.FetchBlock(blockHash) if err != nil { return err } } return nil }) if err != nil { b.Fatal(err) } // Don't benchmark teardown. b.StopTimer() }
// TestCreateOpenFail ensures that errors which occur while opening or closing // a database are handled properly. func TestCreateOpenFail(t *testing.T) { // bogusCreateDB is a function which acts as a bogus create and open // driver function that intentionally returns a failure which can be // detected. dbType := "createopenfail" openError := fmt.Errorf("failed to create or open database for "+ "database type [%v]", dbType) bogusCreateDB := func(args ...interface{}) (database.DB, error) { return nil, openError } // Create and add driver that intentionally fails when created or opened // to ensure errors on database open and create are handled properly. driver := database.Driver{ DbType: dbType, Create: bogusCreateDB, Open: bogusCreateDB, } database.RegisterDriver(driver) // Ensure creating a database with the new type fails with the expected // error. _, err := database.Create(dbType) if err != openError { t.Errorf("expected error not received - got: %v, want %v", err, openError) return } // Ensure opening a database with the new type fails with the expected // error. _, err = database.Open(dbType) if err != openError { t.Errorf("expected error not received - got: %v, want %v", err, openError) return } }
// This example demonstrates creating a new database. func ExampleCreate() { // This example assumes the ffldb driver is imported. // // import ( // "github.com/chrjen/btcd/database" // _ "github.com/chrjen/btcd/database/ffldb" // ) // Create a database and schedule it to be closed and removed on exit. // Typically you wouldn't want to remove the database right away like // this, nor put it in the temp directory, but it's done here to ensure // the example cleans up after itself. dbPath := filepath.Join(os.TempDir(), "examplecreate") db, err := database.Create("ffldb", dbPath, wire.MainNet) if err != nil { fmt.Println(err) return } defer os.RemoveAll(dbPath) defer db.Close() // Output: }
// TestFailureScenarios ensures several failure scenarios such as database // corruption, block file write failures, and rollback failures are handled // correctly. func TestFailureScenarios(t *testing.T) { // Create a new database to run tests against. dbPath := filepath.Join(os.TempDir(), "ffldb-failurescenarios") _ = os.RemoveAll(dbPath) idb, err := database.Create(dbType, dbPath, blockDataNet) if err != nil { t.Errorf("Failed to create test database (%s) %v", dbType, err) return } defer os.RemoveAll(dbPath) defer idb.Close() // Create a test context to pass around. tc := &testContext{ t: t, db: idb, files: make(map[uint32]*lockableFile), maxFileSizes: make(map[uint32]int64), } // Change the maximum file size to a small value to force multiple flat // files with the test data set and replace the file-related functions // to make use of mock files in memory. This allows injection of // various file-related errors. store := idb.(*db).store store.maxBlockFileSize = 1024 // 1KiB store.openWriteFileFunc = func(fileNum uint32) (filer, error) { if file, ok := tc.files[fileNum]; ok { // "Reopen" the file. file.Lock() mock := file.file.(*mockFile) mock.Lock() mock.closed = false mock.Unlock() file.Unlock() return mock, nil } // Limit the max size of the mock file as specified in the test // context. maxSize := int64(-1) if maxFileSize, ok := tc.maxFileSizes[fileNum]; ok { maxSize = int64(maxFileSize) } file := &mockFile{maxSize: int64(maxSize)} tc.files[fileNum] = &lockableFile{file: file} return file, nil } store.openFileFunc = func(fileNum uint32) (*lockableFile, error) { // Force error when trying to open max file num. if fileNum == ^uint32(0) { return nil, makeDbErr(database.ErrDriverSpecific, "test", nil) } if file, ok := tc.files[fileNum]; ok { // "Reopen" the file. file.Lock() mock := file.file.(*mockFile) mock.Lock() mock.closed = false mock.Unlock() file.Unlock() return file, nil } file := &lockableFile{file: &mockFile{}} tc.files[fileNum] = file return file, nil } store.deleteFileFunc = func(fileNum uint32) error { if file, ok := tc.files[fileNum]; ok { file.Lock() file.file.Close() file.Unlock() delete(tc.files, fileNum) return nil } str := fmt.Sprintf("file %d does not exist", fileNum) return makeDbErr(database.ErrDriverSpecific, str, nil) } // Load the test blocks and save in the test context for use throughout // the tests. blocks, err := loadBlocks(t, blockDataFile, blockDataNet) if err != nil { t.Errorf("loadBlocks: Unexpected error: %v", err) return } tc.blocks = blocks // Test various failures paths when writing to the block files. if !testWriteFailures(tc) { return } // Test various file-related issues such as closed and missing files. if !testBlockFileErrors(tc) { return } // Test various corruption scenarios. testCorruption(tc) }
// TestCreateOpenFail ensures that errors related to creating and opening a // database are handled properly. func TestCreateOpenFail(t *testing.T) { t.Parallel() // Ensure that attempting to open a database that doesn't exist returns // the expected error. wantErrCode := database.ErrDbDoesNotExist _, err := database.Open(dbType, "noexist", blockDataNet) if !checkDbError(t, "Open", err, wantErrCode) { return } // Ensure that attempting to open a database with the wrong number of // parameters returns the expected error. wantErr := fmt.Errorf("invalid arguments to %s.Open -- expected "+ "database path and block network", dbType) _, err = database.Open(dbType, 1, 2, 3) if err.Error() != wantErr.Error() { t.Errorf("Open: did not receive expected error - got %v, "+ "want %v", err, wantErr) return } // Ensure that attempting to open a database with an invalid type for // the first parameter returns the expected error. wantErr = fmt.Errorf("first argument to %s.Open is invalid -- "+ "expected database path string", dbType) _, err = database.Open(dbType, 1, blockDataNet) if err.Error() != wantErr.Error() { t.Errorf("Open: did not receive expected error - got %v, "+ "want %v", err, wantErr) return } // Ensure that attempting to open a database with an invalid type for // the second parameter returns the expected error. wantErr = fmt.Errorf("second argument to %s.Open is invalid -- "+ "expected block network", dbType) _, err = database.Open(dbType, "noexist", "invalid") if err.Error() != wantErr.Error() { t.Errorf("Open: did not receive expected error - got %v, "+ "want %v", err, wantErr) return } // Ensure that attempting to create a database with the wrong number of // parameters returns the expected error. wantErr = fmt.Errorf("invalid arguments to %s.Create -- expected "+ "database path and block network", dbType) _, err = database.Create(dbType, 1, 2, 3) if err.Error() != wantErr.Error() { t.Errorf("Create: did not receive expected error - got %v, "+ "want %v", err, wantErr) return } // Ensure that attempting to create a database with an invalid type for // the first parameter returns the expected error. wantErr = fmt.Errorf("first argument to %s.Create is invalid -- "+ "expected database path string", dbType) _, err = database.Create(dbType, 1, blockDataNet) if err.Error() != wantErr.Error() { t.Errorf("Create: did not receive expected error - got %v, "+ "want %v", err, wantErr) return } // Ensure that attempting to create a database with an invalid type for // the second parameter returns the expected error. wantErr = fmt.Errorf("second argument to %s.Create is invalid -- "+ "expected block network", dbType) _, err = database.Create(dbType, "noexist", "invalid") if err.Error() != wantErr.Error() { t.Errorf("Create: did not receive expected error - got %v, "+ "want %v", err, wantErr) return } // Ensure operations against a closed database return the expected // error. dbPath := filepath.Join(os.TempDir(), "ffldb-createfail") _ = os.RemoveAll(dbPath) db, err := database.Create(dbType, dbPath, blockDataNet) if err != nil { t.Errorf("Create: unexpected error: %v", err) return } defer os.RemoveAll(dbPath) db.Close() wantErrCode = database.ErrDbNotOpen err = db.View(func(tx database.Tx) error { return nil }) if !checkDbError(t, "View", err, wantErrCode) { return } wantErrCode = database.ErrDbNotOpen err = db.Update(func(tx database.Tx) error { return nil }) if !checkDbError(t, "Update", err, wantErrCode) { return } wantErrCode = database.ErrDbNotOpen _, err = db.Begin(false) if !checkDbError(t, "Begin(false)", err, wantErrCode) { return } wantErrCode = database.ErrDbNotOpen _, err = db.Begin(true) if !checkDbError(t, "Begin(true)", err, wantErrCode) { return } wantErrCode = database.ErrDbNotOpen err = db.Close() if !checkDbError(t, "Close", err, wantErrCode) { return } }
// TestPersistence ensures that values stored are still valid after closing and // reopening the database. func TestPersistence(t *testing.T) { t.Parallel() // Create a new database to run tests against. dbPath := filepath.Join(os.TempDir(), "ffldb-persistencetest") _ = os.RemoveAll(dbPath) db, err := database.Create(dbType, dbPath, blockDataNet) if err != nil { t.Errorf("Failed to create test database (%s) %v", dbType, err) return } defer os.RemoveAll(dbPath) defer db.Close() // Create a bucket, put some values into it, and store a block so they // can be tested for existence on re-open. bucket1Key := []byte("bucket1") storeValues := map[string]string{ "b1key1": "foo1", "b1key2": "foo2", "b1key3": "foo3", } genesisBlock := btcutil.NewBlock(chaincfg.MainNetParams.GenesisBlock) genesisHash := chaincfg.MainNetParams.GenesisHash err = db.Update(func(tx database.Tx) error { metadataBucket := tx.Metadata() if metadataBucket == nil { return fmt.Errorf("Metadata: unexpected nil bucket") } bucket1, err := metadataBucket.CreateBucket(bucket1Key) if err != nil { return fmt.Errorf("CreateBucket: unexpected error: %v", err) } for k, v := range storeValues { err := bucket1.Put([]byte(k), []byte(v)) if err != nil { return fmt.Errorf("Put: unexpected error: %v", err) } } if err := tx.StoreBlock(genesisBlock); err != nil { return fmt.Errorf("StoreBlock: unexpected error: %v", err) } return nil }) if err != nil { t.Errorf("Update: unexpected error: %v", err) return } // Close and reopen the database to ensure the values persist. db.Close() db, err = database.Open(dbType, dbPath, blockDataNet) if err != nil { t.Errorf("Failed to open test database (%s) %v", dbType, err) return } defer db.Close() // Ensure the values previously stored in the 3rd namespace still exist // and are correct. err = db.View(func(tx database.Tx) error { metadataBucket := tx.Metadata() if metadataBucket == nil { return fmt.Errorf("Metadata: unexpected nil bucket") } bucket1 := metadataBucket.Bucket(bucket1Key) if bucket1 == nil { return fmt.Errorf("Bucket1: unexpected nil bucket") } for k, v := range storeValues { gotVal := bucket1.Get([]byte(k)) if !reflect.DeepEqual(gotVal, []byte(v)) { return fmt.Errorf("Get: key '%s' does not "+ "match expected value - got %s, want %s", k, gotVal, v) } } genesisBlockBytes, _ := genesisBlock.Bytes() gotBytes, err := tx.FetchBlock(genesisHash) if err != nil { return fmt.Errorf("FetchBlock: unexpected error: %v", err) } if !reflect.DeepEqual(gotBytes, genesisBlockBytes) { return fmt.Errorf("FetchBlock: stored block mismatch") } return nil }) if err != nil { t.Errorf("View: unexpected error: %v", err) return } }
// This example demonstrates creating a new database and using a managed // read-write transaction to store and retrieve metadata. func Example_basicUsage() { // This example assumes the ffldb driver is imported. // // import ( // "github.com/chrjen/btcd/database" // _ "github.com/chrjen/btcd/database/ffldb" // ) // Create a database and schedule it to be closed and removed on exit. // Typically you wouldn't want to remove the database right away like // this, nor put it in the temp directory, but it's done here to ensure // the example cleans up after itself. dbPath := filepath.Join(os.TempDir(), "exampleusage") db, err := database.Create("ffldb", dbPath, wire.MainNet) if err != nil { fmt.Println(err) return } defer os.RemoveAll(dbPath) defer db.Close() // Use the Update function of the database to perform a managed // read-write transaction. The transaction will automatically be rolled // back if the supplied inner function returns a non-nil error. err = db.Update(func(tx database.Tx) error { // Store a key/value pair directly in the metadata bucket. // Typically a nested bucket would be used for a given feature, // but this example is using the metadata bucket directly for // simplicity. key := []byte("mykey") value := []byte("myvalue") if err := tx.Metadata().Put(key, value); err != nil { return err } // Read the key back and ensure it matches. if !bytes.Equal(tx.Metadata().Get(key), value) { return fmt.Errorf("unexpected value for key '%s'", key) } // Create a new nested bucket under the metadata bucket. nestedBucketKey := []byte("mybucket") nestedBucket, err := tx.Metadata().CreateBucket(nestedBucketKey) if err != nil { return err } // The key from above that was set in the metadata bucket does // not exist in this new nested bucket. if nestedBucket.Get(key) != nil { return fmt.Errorf("key '%s' is not expected nil", key) } return nil }) if err != nil { fmt.Println(err) return } // Output: }
// This example demonstrates creating a new database, using a managed read-write // transaction to store a block, and using a managed read-only transaction to // fetch the block. func Example_blockStorageAndRetrieval() { // This example assumes the ffldb driver is imported. // // import ( // "github.com/chrjen/btcd/database" // _ "github.com/chrjen/btcd/database/ffldb" // ) // Create a database and schedule it to be closed and removed on exit. // Typically you wouldn't want to remove the database right away like // this, nor put it in the temp directory, but it's done here to ensure // the example cleans up after itself. dbPath := filepath.Join(os.TempDir(), "exampleblkstorage") db, err := database.Create("ffldb", dbPath, wire.MainNet) if err != nil { fmt.Println(err) return } defer os.RemoveAll(dbPath) defer db.Close() // Use the Update function of the database to perform a managed // read-write transaction and store a genesis block in the database as // and example. err = db.Update(func(tx database.Tx) error { genesisBlock := chaincfg.MainNetParams.GenesisBlock return tx.StoreBlock(btcutil.NewBlock(genesisBlock)) }) if err != nil { fmt.Println(err) return } // Use the View function of the database to perform a managed read-only // transaction and fetch the block stored above. var loadedBlockBytes []byte err = db.Update(func(tx database.Tx) error { genesisHash := chaincfg.MainNetParams.GenesisHash blockBytes, err := tx.FetchBlock(genesisHash) if err != nil { return err } // As documented, all data fetched from the database is only // valid during a database transaction in order to support // zero-copy backends. Thus, make a copy of the data so it // can be used outside of the transaction. loadedBlockBytes = make([]byte, len(blockBytes)) copy(loadedBlockBytes, blockBytes) return nil }) if err != nil { fmt.Println(err) return } // Typically at this point, the block could be deserialized via the // wire.MsgBlock.Deserialize function or used in its serialized form // depending on need. However, for this example, just display the // number of serialized bytes to show it was loaded as expected. fmt.Printf("Serialized block size: %d bytes\n", len(loadedBlockBytes)) // Output: // Serialized block size: 285 bytes }