package redis3 import ( "context" "fmt" "os" "testing" "time" "github.com/go-redsync/redsync/v4" goredis "github.com/go-redsync/redsync/v4/redis/goredis/v9" "github.com/redis/go-redis/v9" "github.com/seaweedfs/seaweedfs/weed/filer" "github.com/seaweedfs/seaweedfs/weed/util" ) func newTestStore(t *testing.T) (*UniversalRedis3Store, util.FullPath) { t.Helper() if os.Getenv("RUN_REDIS_TESTS") != "1" { t.Skip("redis3 tests are disabled. Start a redis-server and set RUN_REDIS_TESTS=1 to enable, REDIS_ADDR defaults to 127.0.0.1:6379.") } addr := os.Getenv("REDIS_ADDR") if addr == "" { addr = "127.0.0.1:6379" } ctx := context.Background() client := redis.NewClient(&redis.Options{Addr: addr}) t.Cleanup(func() { if err := client.Close(); err != nil { t.Errorf("close redis client: %v", err) } }) if err := client.Ping(ctx).Err(); err != nil { t.Fatalf("connect to redis at %s: %v", addr, err) } store := &UniversalRedis3Store{Client: client, redsync: redsync.New(goredis.NewPool(client))} dir := util.FullPath(fmt.Sprintf("/redis3_test_%d", time.Now().UnixNano())) t.Cleanup(func() { if err := store.DeleteFolderChildren(ctx, dir); err != nil { t.Errorf("cleanup %s children: %v", dir, err) } if err := store.DeleteEntry(ctx, dir); err != nil { t.Errorf("cleanup %s: %v", dir, err) } }) return store, dir } func listNames(t *testing.T, store *UniversalRedis3Store, dir util.FullPath) []string { t.Helper() names := []string{} if _, err := store.ListDirectoryEntries(context.Background(), dir, "", true, 100, func(entry *filer.Entry) (bool, error) { names = append(names, entry.Name()) return true, nil }); err != nil { t.Fatalf("list %s: %v", dir, err) } return names } func TestDeleteEntryKeepsChildListing(t *testing.T) { store, dir := newTestStore(t) ctx := context.Background() now := time.Now() child := dir.Child("obj") if err := store.InsertEntry(ctx, &filer.Entry{ FullPath: child, Attr: filer.Attr{Crtime: now, Mtime: now, Mode: 0644}, }); err != nil { t.Fatalf("InsertEntry %s: %v", child, err) } // The listing is the only record that the child sits under this directory, so // removing the directory entry must leave it alone. An entry that arrived after // the caller judged the directory empty would otherwise become unreachable. if err := store.DeleteEntry(ctx, dir); err != nil { t.Fatalf("DeleteEntry %s: %v", dir, err) } if names := listNames(t, store, dir); len(names) != 1 || names[0] != "obj" { t.Errorf("child should still be listed after the directory entry is deleted, got %v", names) } // DeleteFolderChildren owns that cleanup, and takes the listing with it if err := store.DeleteFolderChildren(ctx, dir); err != nil { t.Fatalf("DeleteFolderChildren %s: %v", dir, err) } if names := listNames(t, store, dir); len(names) != 0 { t.Errorf("listing should be empty once the children are deleted, got %v", names) } if n, err := store.Client.Exists(ctx, genDirectoryListKey(string(dir))).Result(); err != nil { t.Fatalf("exists %s: %v", dir, err) } else if n != 0 { t.Errorf("listing key should be removed with the children, still present") } } func TestRemovingTheLastChildDropsTheListing(t *testing.T) { store, dir := newTestStore(t) ctx := context.Background() now := time.Now() child := dir.Child("obj") if err := store.InsertEntry(ctx, &filer.Entry{ FullPath: child, Attr: filer.Attr{Crtime: now, Mtime: now, Mode: 0644}, }); err != nil { t.Fatalf("InsertEntry %s: %v", child, err) } // An emptied listing must not leave its header behind: cleanup deletes such a // folder without touching the listing, so the key would never be collected. if err := store.DeleteEntry(ctx, child); err != nil { t.Fatalf("DeleteEntry %s: %v", child, err) } if n, err := store.Client.Exists(ctx, genDirectoryListKey(string(dir))).Result(); err != nil { t.Fatalf("exists %s: %v", dir, err) } else if n != 0 { t.Errorf("listing key should be gone once the last child is removed, still present") } } // A configured keyPrefix must scope every key the store writes: entry values, // directory listings (and their skiplist nodes and locks), and Kv keys. The // raw-key assertions below would still pass a round-trip check if reads and // writes both dropped the prefix, so they check the actual key space. func TestKeyPrefixScopesAllKeys(t *testing.T) { store, dir := newTestStore(t) store.keyPrefix = string(dir) + "_" kvKey := string(dir) + "_k" ctx := context.Background() now := time.Now() child := dir.Child("obj") if err := store.InsertEntry(ctx, &filer.Entry{ FullPath: child, Attr: filer.Attr{Crtime: now, Mtime: now, Mode: 0644}, }); err != nil { t.Fatalf("InsertEntry %s: %v", child, err) } if _, err := store.FindEntry(ctx, child); err != nil { t.Fatalf("FindEntry %s: %v", child, err) } if names := listNames(t, store, dir); len(names) != 1 || names[0] != "obj" { t.Fatalf("list %s: got %v", dir, names) } for _, raw := range []string{string(child), genDirectoryListKey(string(dir))} { if n, err := store.Client.Exists(ctx, raw).Result(); err != nil || n != 0 { t.Fatalf("key %q should not exist unprefixed: n=%d err=%v", raw, n, err) } if n, err := store.Client.Exists(ctx, store.keyPrefix+raw).Result(); err != nil || n != 1 { t.Fatalf("key %q should exist under the prefix: n=%d err=%v", raw, n, err) } } if err := store.KvPut(ctx, []byte(kvKey), []byte("v")); err != nil { t.Fatalf("KvPut: %v", err) } if v, err := store.KvGet(ctx, []byte(kvKey)); err != nil || string(v) != "v" { t.Fatalf("KvGet: v=%q err=%v", v, err) } if _, err := store.Client.Get(ctx, kvKey).Result(); err != redis.Nil { t.Fatalf("kv key should not exist unprefixed: err=%v", err) } if v, err := store.Client.Get(ctx, store.keyPrefix+kvKey).Result(); err != nil || v != "v" { t.Fatalf("kv key should exist under the prefix: v=%q err=%v", v, err) } if err := store.KvDelete(ctx, []byte(kvKey)); err != nil { t.Fatalf("KvDelete: %v", err) } if _, err := store.KvGet(ctx, []byte(kvKey)); err != filer.ErrKvNotFound { t.Fatalf("KvGet after delete: err=%v", err) } if err := store.DeleteFolderChildren(ctx, dir); err != nil { t.Fatalf("DeleteFolderChildren %s: %v", dir, err) } if names := listNames(t, store, dir); len(names) != 0 { t.Fatalf("listing should be empty once the children are deleted, got %v", names) } if err := store.DeleteEntry(ctx, dir); err != nil { t.Fatalf("DeleteEntry %s: %v", dir, err) } if keys, err := store.Client.Keys(ctx, store.keyPrefix+"*").Result(); err != nil || len(keys) != 0 { t.Fatalf("no prefixed keys should remain after cleanup: keys=%v err=%v", keys, err) } }