SeaweedFS is a distributed storage system for object storage (S3), file systems, Iceberg table buckets, and Lance vector buckets, designed to handle billions of files with O(1) disk access and effortless horizontal scaling.
Go blob-storagecloud-drivedistributed-file-systemdistributed-storageerasure-codingfusehadoop-hdfshdfskuberneteslancelancedbobject-storageposixs3s3-storageseaweedfstiered-file-systemvector-search
//go:build foundationdb
package foundationdb
import (
"context"
"fmt"
"os"
"testing"
"time"
"github.com/seaweedfs/seaweedfs/weed/filer"
"github.com/seaweedfs/seaweedfs/weed/filer/foundationdb"
"github.com/seaweedfs/seaweedfs/weed/pb/filer_pb"
"github.com/seaweedfs/seaweedfs/weed/util"
)
func TestFoundationDBStore_BasicOperations(t *testing.T) {
store := createTestStore(t)
defer store.Shutdown()
ctx := context.Background()
// Test InsertEntry
entry := &filer.Entry{
FullPath: "/test/file1.txt",
Attr: filer.Attr{
Mode: 0644,
Uid: 1000,
Gid: 1000,
Mtime: time.Now(),
},
}
err := store.InsertEntry(ctx, entry)
if err != nil {
t.Fatalf("InsertEntry failed: %v", err)
}
// Test FindEntry
foundEntry, err := store.FindEntry(ctx, "/test/file1.txt")
if err != nil {
t.Fatalf("FindEntry failed: %v", err)
}
if foundEntry.FullPath != entry.FullPath {
t.Errorf("Expected path %s, got %s", entry.FullPath, foundEntry.FullPath)
}
if foundEntry.Attr.Mode != entry.Attr.Mode {
t.Errorf("Expected mode %o, got %o", entry.Attr.Mode, foundEntry.Attr.Mode)
}
// Test UpdateEntry
foundEntry.Attr.Mode = 0755
err = store.UpdateEntry(ctx, foundEntry)
if err != nil {
t.Fatalf("UpdateEntry failed: %v", err)
}
updatedEntry, err := store.FindEntry(ctx, "/test/file1.txt")
if err != nil {
t.Fatalf("FindEntry after update failed: %v", err)
}
if updatedEntry.Attr.Mode != 0755 {
t.Errorf("Expected updated mode 0755, got %o", updatedEntry.Attr.Mode)
}
// Test DeleteEntry
err = store.DeleteEntry(ctx, "/test/file1.txt")
if err != nil {
t.Fatalf("DeleteEntry failed: %v", err)
}
_, err = store.FindEntry(ctx, "/test/file1.txt")
if err == nil {
t.Error("Expected entry to be deleted, but it was found")
}
if err != filer_pb.ErrNotFound {
t.Errorf("Expected ErrNotFound, got %v", err)
}
}
func TestFoundationDBStore_DirectoryOperations(t *testing.T) {
store := createTestStore(t)
defer store.Shutdown()
ctx := context.Background()
// Create multiple entries in a directory
testDir := "/test/dir"
files := []string{"file1.txt", "file2.txt", "file3.txt", "subdir/"}
for _, fileName := range files {
entry := &filer.Entry{
FullPath: util.NewFullPath(testDir, fileName),
Attr: filer.Attr{
Mode: 0644,
Uid: 1000,
Gid: 1000,
Mtime: time.Now(),
},
}
if fileName == "subdir/" {
entry.Attr.Mode = 0755 | os.ModeDir
}
err := store.InsertEntry(ctx, entry)
if err != nil {
t.Fatalf("InsertEntry failed for %s: %v", fileName, err)
}
}
// Test ListDirectoryEntries
var listedFiles []string
lastFileName, err := store.ListDirectoryEntries(ctx, testDir, "", true, 100, func(entry *filer.Entry) (bool, error) {
listedFiles = append(listedFiles, entry.Name())
return true, nil
})
if err != nil {
t.Fatalf("ListDirectoryEntries failed: %v", err)
}
t.Logf("Last file name: %s", lastFileName)
t.Logf("Listed files: %v", listedFiles)
if len(listedFiles) != len(files) {
t.Errorf("Expected %d files, got %d", len(files), len(listedFiles))
}
// Test ListDirectoryPrefixedEntries
var prefixedFiles []string
_, err = store.ListDirectoryPrefixedEntries(ctx, testDir, "", true, 100, "file", func(entry *filer.Entry) (bool, error) {
prefixedFiles = append(prefixedFiles, entry.Name())
return true, nil
})
if err != nil {
t.Fatalf("ListDirectoryPrefixedEntries failed: %v", err)
}
expectedPrefixedCount := 3 // file1.txt, file2.txt, file3.txt
if len(prefixedFiles) != expectedPrefixedCount {
t.Errorf("Expected %d prefixed files, got %d: %v", expectedPrefixedCount, len(prefixedFiles), prefixedFiles)
}
// Test DeleteFolderChildren
err = store.DeleteFolderChildren(ctx, testDir)
if err != nil {
t.Fatalf("DeleteFolderChildren failed: %v", err)
}
// Verify children are deleted
var remainingFiles []string
_, err = store.ListDirectoryEntries(ctx, testDir, "", true, 100, func(entry *filer.Entry) (bool, error) {
remainingFiles = append(remainingFiles, entry.Name())
return true, nil
})
if err != nil {
t.Fatalf("ListDirectoryEntries after delete failed: %v", err)
}
if len(remainingFiles) != 0 {
t.Errorf("Expected no files after DeleteFolderChildren, got %d: %v", len(remainingFiles), remainingFiles)
}
}
func TestFoundationDBStore_TransactionOperations(t *testing.T) {
store := createTestStore(t)
defer store.Shutdown()
ctx := context.Background()
// Begin transaction
txCtx, err := store.BeginTransaction(ctx)
if err != nil {
t.Fatalf("BeginTransaction failed: %v", err)
}
// Insert entry in transaction
entry := &filer.Entry{
FullPath: "/test/tx_file.txt",
Attr: filer.Attr{
Mode: 0644,
Uid: 1000,
Gid: 1000,
Mtime: time.Now(),
},
}
err = store.InsertEntry(txCtx, entry)
if err != nil {
t.Fatalf("InsertEntry in transaction failed: %v", err)
}
// Entry should not be visible outside transaction yet
_, err = store.FindEntry(ctx, "/test/tx_file.txt")
if err == nil {
t.Error("Entry should not be visible before transaction commit")
}
// Commit transaction
err = store.CommitTransaction(txCtx)
if err != nil {
t.Fatalf("CommitTransaction failed: %v", err)
}
// Entry should now be visible
foundEntry, err := store.FindEntry(ctx, "/test/tx_file.txt")
if err != nil {
t.Fatalf("FindEntry after commit failed: %v", err)
}
if foundEntry.FullPath != entry.FullPath {
t.Errorf("Expected path %s, got %s", entry.FullPath, foundEntry.FullPath)
}
// Test rollback
txCtx2, err := store.BeginTransaction(ctx)
if err != nil {
t.Fatalf("BeginTransaction for rollback test failed: %v", err)
}
entry2 := &filer.Entry{
FullPath: "/test/rollback_file.txt",
Attr: filer.Attr{
Mode: 0644,
Uid: 1000,
Gid: 1000,
Mtime: time.Now(),
},
}
err = store.InsertEntry(txCtx2, entry2)
if err != nil {
t.Fatalf("InsertEntry for rollback test failed: %v", err)
}
// Rollback transaction
err = store.RollbackTransaction(txCtx2)
if err != nil {
t.Fatalf("RollbackTransaction failed: %v", err)
}
// Entry should not exist after rollback
_, err = store.FindEntry(ctx, "/test/rollback_file.txt")
if err == nil {
t.Error("Entry should not exist after rollback")
}
if err != filer_pb.ErrNotFound {
t.Errorf("Expected ErrNotFound after rollback, got %v", err)
}
}
func TestFoundationDBStore_KVOperations(t *testing.T) {
store := createTestStore(t)
defer store.Shutdown()
ctx := context.Background()
// Test KvPut
key := []byte("test_key")
value := []byte("test_value")
err := store.KvPut(ctx, key, value)
if err != nil {
t.Fatalf("KvPut failed: %v", err)
}
// Test KvGet
retrievedValue, err := store.KvGet(ctx, key)
if err != nil {
t.Fatalf("KvGet failed: %v", err)
}
if string(retrievedValue) != string(value) {
t.Errorf("Expected value %s, got %s", value, retrievedValue)
}
// Test KvDelete
err = store.KvDelete(ctx, key)
if err != nil {
t.Fatalf("KvDelete failed: %v", err)
}
// Verify key is deleted
_, err = store.KvGet(ctx, key)
if err == nil {
t.Error("Expected key to be deleted")
}
if err != filer.ErrKvNotFound {
t.Errorf("Expected ErrKvNotFound, got %v", err)
}
}
func TestFoundationDBStore_LargeEntry(t *testing.T) {
store := createTestStore(t)
defer store.Shutdown()
ctx := context.Background()
// Create entry with many chunks (to test compression)
entry := &filer.Entry{
FullPath: "/test/large_file.txt",
Attr: filer.Attr{
Mode: 0644,
Uid: 1000,
Gid: 1000,
Mtime: time.Now(),
},
}
// Add many chunks to trigger compression
for i := 0; i < filer.CountEntryChunksForGzip+10; i++ {
chunk := &filer_pb.FileChunk{
FileId: util.Uint64toHex(uint64(i)),
Offset: int64(i * 1024),
Size: 1024,
}
entry.Chunks = append(entry.Chunks, chunk)
}
err := store.InsertEntry(ctx, entry)
if err != nil {
t.Fatalf("InsertEntry with large chunks failed: %v", err)
}
// Retrieve and verify
foundEntry, err := store.FindEntry(ctx, "/test/large_file.txt")
if err != nil {
t.Fatalf("FindEntry for large file failed: %v", err)
}
if len(foundEntry.Chunks) != len(entry.Chunks) {
t.Errorf("Expected %d chunks, got %d", len(entry.Chunks), len(foundEntry.Chunks))
}
// Verify some chunk data
if foundEntry.Chunks[0].FileId != entry.Chunks[0].FileId {
t.Errorf("Expected first chunk FileId %s, got %s", entry.Chunks[0].FileId, foundEntry.Chunks[0].FileId)
}
}
func createTestStore(t *testing.T) *foundationdb.FoundationDBStore {
// Skip test if FoundationDB cluster file doesn't exist
clusterFile := os.Getenv("FDB_CLUSTER_FILE")
if clusterFile == "" {
clusterFile = "/var/fdb/config/fdb.cluster"
}
if _, err := os.Stat(clusterFile); os.IsNotExist(err) {
t.Skip("FoundationDB cluster file not found, skipping test")
}
config := util.GetViper()
config.Set("foundationdb.cluster_file", clusterFile)
config.Set("foundationdb.api_version", 740)
config.Set("foundationdb.timeout", "10s")
config.Set("foundationdb.max_retry_delay", "2s")
config.Set("foundationdb.directory_prefix", fmt.Sprintf("seaweedfs_test_%d", time.Now().UnixNano()))
store := &foundationdb.FoundationDBStore{}
err := store.Initialize(config, "foundationdb.")
if err != nil {
t.Fatalf("Failed to initialize FoundationDB store: %v", err)
}
return store
}