storage: add cluster version to env config

xinhaoz · xinhaoz · commit 8d099d45ac72 · 2025-08-19T13:17:18.000-04:00
diff --git a/pkg/ccl/storageccl/engineccl/encrypted_fs_test.go b/pkg/ccl/storageccl/engineccl/encrypted_fs_test.go
@@ -247,6 +247,7 @@ func TestPebbleEncryption(t *testing.T) {
 
 	func() {
 		// Initialize the filesystem env.
+		settings := cluster.MakeTestingClusterSettings()
 		env, err := fs.InitEnvFromStoreSpec(
 			ctx,
 			base.StoreSpec{
@@ -255,12 +256,15 @@ func TestPebbleEncryption(t *testing.T) {
 				EncryptionOptions: encOptions,
 				StickyVFSID:       stickyVFSID,
 			},
-			fs.ReadWrite,
+			fs.EnvConfig{
+				RW:      fs.ReadWrite,
+				Version: settings.Version,
+			},
 			stickyRegistry, /* sticky registry */
 			nil,            /* statsCollector */
 		)
 		require.NoError(t, err)
-		db, err := storage.Open(ctx, env, cluster.MakeTestingClusterSettings())
+		db, err := storage.Open(ctx, env, settings)
 		require.NoError(t, err)
 		defer db.Close()
 
@@ -295,6 +299,7 @@ func TestPebbleEncryption(t *testing.T) {
 
 	func() {
 		// Initialize the filesystem env again, replaying the file registries.
+		settings := cluster.MakeTestingClusterSettings()
 		env, err := fs.InitEnvFromStoreSpec(
 			ctx,
 			base.StoreSpec{
@@ -303,12 +308,15 @@ func TestPebbleEncryption(t *testing.T) {
 				EncryptionOptions: encOptions,
 				StickyVFSID:       stickyVFSID,
 			},
-			fs.ReadWrite,
+			fs.EnvConfig{
+				RW:      fs.ReadWrite,
+				Version: settings.Version,
+			},
 			stickyRegistry, /* sticky registry */
 			nil,            /* statsCollector */
 		)
 		require.NoError(t, err)
-		db, err := storage.Open(ctx, env, cluster.MakeTestingClusterSettings())
+		db, err := storage.Open(ctx, env, settings)
 		require.NoError(t, err)
 		defer db.Close()
 		require.Equal(t, []byte("a"), storageutils.MVCCGetRaw(t, db, storageutils.PointKey("a", 0)))
@@ -382,6 +390,7 @@ func TestPebbleEncryption2(t *testing.T) {
 
 		// Initialize the filesystem env.
 		ctx := context.Background()
+		settings := cluster.MakeTestingClusterSettings()
 		env, err := fs.InitEnvFromStoreSpec(
 			ctx,
 			base.StoreSpec{
@@ -390,12 +399,15 @@ func TestPebbleEncryption2(t *testing.T) {
 				EncryptionOptions: encOptions,
 				StickyVFSID:       stickyVFSID,
 			},
-			fs.ReadWrite,
+			fs.EnvConfig{
+				RW:      fs.ReadWrite,
+				Version: settings.Version,
+			},
 			stickyRegistry, /* sticky registry */
 			nil,            /* statsCollector */
 		)
 		require.NoError(t, err)
-		db, err := storage.Open(ctx, env, cluster.MakeTestingClusterSettings())
+		db, err := storage.Open(ctx, env, settings)
 		require.NoError(t, err)
 		defer db.Close()
 
diff --git a/pkg/cli/debug.go b/pkg/cli/debug.go
@@ -163,7 +163,7 @@ func (f *keyFormat) Type() string {
 // engine, they should manually open it using storage.Open. The returned Env has
 // 1 reference and the caller must ensure it's closed.
 func OpenFilesystemEnv(dir string, rw fs.RWMode) (*fs.Env, error) {
-	envConfig := fs.EnvConfig{RW: rw}
+	envConfig := fs.EnvConfig{RW: rw, Version: serverCfg.Settings.Version}
 	if err := fillEncryptionOptionsForStore(dir, &envConfig); err != nil {
 		return nil, err
 	}
@@ -1743,7 +1743,9 @@ func pebbleCryptoInitializer(ctx context.Context) {
 		encryptedPaths = append(encryptedPaths, spec.Path)
 	}
 	resolveFn := func(dir string) (*fs.Env, error) {
-		var envConfig fs.EnvConfig
+		envConfig := fs.EnvConfig{
+			Version: serverCfg.Settings.Version,
+		}
 		if err := fillEncryptionOptionsForStore(dir, &envConfig); err != nil {
 			return nil, err
 		}
diff --git a/pkg/cmd/roachtest/tests/BUILD.bazel b/pkg/cmd/roachtest/tests/BUILD.bazel
@@ -280,8 +280,8 @@ go_library(
         "//pkg/sql/pgwire/pgerror",
         "//pkg/sql/sem/tree",
         "//pkg/sql/ttl/ttlbase",
-        "//pkg/storage",
         "//pkg/storage/enginepb",
+        "//pkg/storage/minversion",
         "//pkg/testutils",
         "//pkg/testutils/fingerprintutils",
         "//pkg/testutils/floatcmp",
diff --git a/pkg/cmd/roachtest/tests/versionupgrade.go b/pkg/cmd/roachtest/tests/versionupgrade.go
@@ -23,7 +23,7 @@ import (
 	"github.com/cockroachdb/cockroach/pkg/cmd/roachtest/test"
 	"github.com/cockroachdb/cockroach/pkg/roachprod/install"
 	"github.com/cockroachdb/cockroach/pkg/roachprod/logger"
-	"github.com/cockroachdb/cockroach/pkg/storage"
+	"github.com/cockroachdb/cockroach/pkg/storage/minversion"
 	"github.com/cockroachdb/cockroach/pkg/testutils/release"
 	"github.com/cockroachdb/cockroach/pkg/ts/tspb"
 	"github.com/cockroachdb/cockroach/pkg/util/timeutil"
@@ -281,7 +281,7 @@ func makeVersionFixtureAndFatal(
 	// #54761.
 	c.Run(ctx, option.WithNodes(c.Node(1)), "cp", "{store-dir}/cluster-bootstrapped", "{store-dir}/"+name)
 	// Similar to the above - newer versions require the min version file to open a store.
-	c.Run(ctx, option.WithNodes(c.All()), "cp", fmt.Sprintf("{store-dir}/%s", storage.MinVersionFilename), "{store-dir}/"+name)
+	c.Run(ctx, option.WithNodes(c.All()), "cp", fmt.Sprintf("{store-dir}/%s", minversion.MinVersionFilename), "{store-dir}/"+name)
 	c.Run(ctx, option.WithNodes(c.All()), "tar", "-C", "{store-dir}/"+name, "-czf", "{log-dir}/"+name+".tgz", ".")
 	t.Fatalf(`successfully created checkpoints; failing test on purpose.
 
diff --git a/pkg/kv/kvserver/client_metrics_test.go b/pkg/kv/kvserver/client_metrics_test.go
@@ -100,7 +100,10 @@ func verifyStatsOnServers(
 		// To recompute the metrics, we need an open engine. Open the
 		// Engine again in read-only mode (leaving the rest of the
 		// Server stopped) to compute MVCC stats.
-		env, err := fs.InitEnvFromStoreSpec(ctx, specs[storeIdx], fs.ReadOnly, stickyRegistry, nil /* statsCollector */)
+		env, err := fs.InitEnvFromStoreSpec(ctx, specs[storeIdx], fs.EnvConfig{
+			RW:      fs.ReadOnly,
+			Version: s.GetStoreConfig().Settings.Version,
+		}, stickyRegistry, nil /* statsCollector */)
 		if err != nil {
 			t.Fatal(err)
 		}
diff --git a/pkg/kv/kvserver/consistency_queue_test.go b/pkg/kv/kvserver/consistency_queue_test.go
@@ -407,9 +407,10 @@ func TestCheckConsistencyInconsistent(t *testing.T) {
 		// VFS to verify its contents.
 		ctx := context.Background()
 		memFS := stickyVFSRegistry.Get(vfsIDs[i])
-		env, err := fs.InitEnv(ctx, memFS, cps[0], fs.EnvConfig{RW: fs.ReadOnly}, nil /* statsCollector */)
+		settings := cluster.MakeClusterSettings()
+		env, err := fs.InitEnv(ctx, memFS, cps[0], fs.EnvConfig{RW: fs.ReadOnly, Version: settings.Version}, nil /* statsCollector */)
 		require.NoError(t, err)
-		cpEng, err := storage.Open(ctx, env, cluster.MakeClusterSettings(),
+		cpEng, err := storage.Open(ctx, env, settings,
 			storage.ForTesting, storage.MustExist, storage.CacheSize(1<<20))
 		if err != nil {
 			require.NoError(t, err)
diff --git a/pkg/kv/kvserver/logstore/sideload_test.go b/pkg/kv/kvserver/logstore/sideload_test.go
@@ -575,9 +575,12 @@ func TestSideloadStorageSync(t *testing.T) {
 		// able to emulate crash restart by rolling it back to last synced state.
 		ctx := context.Background()
 		memFS := vfs.NewCrashableMem()
-		env, err := fs.InitEnv(ctx, memFS, "", fs.EnvConfig{}, nil /* statsCollector */)
+		settings := cluster.MakeTestingClusterSettings()
+		env, err := fs.InitEnv(ctx, memFS, "", fs.EnvConfig{
+			Version: settings.Version,
+		}, nil /* statsCollector */)
 		require.NoError(t, err)
-		eng, err := storage.Open(ctx, env, cluster.MakeTestingClusterSettings(), storage.ForTesting)
+		eng, err := storage.Open(ctx, env, settings, storage.ForTesting)
 		require.NoError(t, err)
 		ss := newTestingSideloadStorage(eng)
 
@@ -595,9 +598,11 @@ func TestSideloadStorageSync(t *testing.T) {
 		// Reset filesystem to the last synced state.
 
 		// Emulate process restart. Load from the last synced state.
-		env, err = fs.InitEnv(ctx, crashFS, "", fs.EnvConfig{}, nil /* statsCollector */)
+		env, err = fs.InitEnv(ctx, crashFS, "", fs.EnvConfig{
+			Version: settings.Version,
+		}, nil /* statsCollector */)
 		require.NoError(t, err)
-		eng, err = storage.Open(ctx, env, cluster.MakeTestingClusterSettings(), storage.ForTesting)
+		eng, err = storage.Open(ctx, env, settings, storage.ForTesting)
 		require.NoError(t, err)
 		defer eng.Close()
 		ss = newTestingSideloadStorage(eng)
diff --git a/pkg/server/config.go b/pkg/server/config.go
@@ -764,7 +764,10 @@ func (cfg *Config) CreateEngines(ctx context.Context) (Engines, error) {
 		stickyRegistry = serverKnobs.StickyVFSRegistry
 	}
 
-	storeEnvs, err := fs.InitEnvsFromStoreSpecs(ctx, cfg.Stores.Specs, fs.ReadWrite, stickyRegistry, cfg.DiskWriteStats)
+	storeEnvs, err := fs.InitEnvsFromStoreSpecs(ctx, cfg.Stores.Specs, fs.EnvConfig{
+		RW:      fs.ReadWrite,
+		Version: cfg.Settings.Version,
+	}, stickyRegistry, cfg.DiskWriteStats)
 	if err != nil {
 		return Engines{}, err
 	}
diff --git a/pkg/storage/bench_data_test.go b/pkg/storage/bench_data_test.go
@@ -142,10 +142,13 @@ func buildInitialState(
 		// or not, we build the conditions using an in-memory engine for
 		// performance.
 		buildFS = vfs.NewMem()
-		env, err := fs.InitEnv(ctx, buildFS, "", fs.EnvConfig{}, nil /* statsCollector */)
+		settings := cluster.MakeClusterSettings()
+		env, err := fs.InitEnv(ctx, buildFS, "", fs.EnvConfig{
+			Version: settings.Version,
+		}, nil /* statsCollector */)
 		require.NoError(b, err)
 
-		e, err := Open(ctx, env, cluster.MakeClusterSettings(), opts...)
+		e, err := Open(ctx, env, settings, opts...)
 		require.NoError(b, err)
 		require.NoError(b, initial.Build(ctx, b, e))
 		e.Close()
diff --git a/pkg/storage/engine_test.go b/pkg/storage/engine_test.go
@@ -1072,7 +1072,10 @@ func TestCreateCheckpoint(t *testing.T) {
 }
 
 func mustInitTestEnv(t testing.TB, baseFS vfs.FS, dir string) *fs.Env {
-	e, err := fs.InitEnv(context.Background(), baseFS, dir, fs.EnvConfig{}, nil /* statsCollector */)
+	settings := cluster.MakeTestingClusterSettings()
+	e, err := fs.InitEnv(context.Background(), baseFS, dir, fs.EnvConfig{
+		Version: settings.Version,
+	}, nil /* statsCollector */)
 	require.NoError(t, err)
 	return e
 }
diff --git a/pkg/storage/fs/BUILD.bazel b/pkg/storage/fs/BUILD.bazel
@@ -16,9 +16,13 @@ go_library(
     deps = [
         "//pkg/base",
         "//pkg/cli/exit",
+        "//pkg/clusterversion",
+        "//pkg/roachpb",
         "//pkg/settings",
+        "//pkg/settings/cluster",
         "//pkg/storage/disk",
         "//pkg/storage/enginepb",
+        "//pkg/storage/minversion",
         "//pkg/storage/storageconfig",
         "//pkg/util/buildutil",
         "//pkg/util/envutil",
diff --git a/pkg/storage/fs/fs.go b/pkg/storage/fs/fs.go
@@ -15,8 +15,12 @@ import (
 
 	"github.com/cockroachdb/cockroach/pkg/base"
 	"github.com/cockroachdb/cockroach/pkg/cli/exit"
+	"github.com/cockroachdb/cockroach/pkg/clusterversion"
+	"github.com/cockroachdb/cockroach/pkg/roachpb"
 	"github.com/cockroachdb/cockroach/pkg/settings"
+	"github.com/cockroachdb/cockroach/pkg/settings/cluster"
 	"github.com/cockroachdb/cockroach/pkg/storage/disk"
+	"github.com/cockroachdb/cockroach/pkg/storage/minversion"
 	"github.com/cockroachdb/cockroach/pkg/storage/storageconfig"
 	"github.com/cockroachdb/cockroach/pkg/util/buildutil"
 	"github.com/cockroachdb/cockroach/pkg/util/envutil"
@@ -62,14 +66,14 @@ var MaxSyncDurationFatalOnExceeded = settings.RegisterBoolSetting(
 func InitEnvsFromStoreSpecs(
 	ctx context.Context,
 	specs []base.StoreSpec,
-	rw RWMode,
+	cfg EnvConfig,
 	stickyRegistry StickyRegistry,
 	diskWriteStats disk.WriteStatsManager,
 ) (Envs, error) {
 	envs := make(Envs, len(specs))
 	for i := range specs {
 		var err error
-		envs[i], err = InitEnvFromStoreSpec(ctx, specs[i], rw, stickyRegistry, diskWriteStats)
+		envs[i], err = InitEnvFromStoreSpec(ctx, specs[i], cfg, stickyRegistry, diskWriteStats)
 		if err != nil {
 			envs.CloseAll()
 			return nil, err
@@ -97,7 +101,7 @@ func (e Envs) CloseAll() {
 func InitEnvFromStoreSpec(
 	ctx context.Context,
 	spec base.StoreSpec,
-	rw RWMode,
+	cfg EnvConfig,
 	stickyRegistry StickyRegistry,
 	diskWriteStats disk.WriteStatsManager,
 ) (*Env, error) {
@@ -113,16 +117,16 @@ func InitEnvFromStoreSpec(
 			fs = vfs.NewMem()
 		}
 	}
-	return InitEnv(ctx, fs, dir, EnvConfig{
-		RW:                rw,
-		EncryptionOptions: spec.EncryptionOptions,
-	}, diskWriteStats)
+	// Override encryption options from the store spec.
+	cfg.EncryptionOptions = spec.EncryptionOptions
+	return InitEnv(ctx, fs, dir, cfg, diskWriteStats)
 }
 
 // EnvConfig provides additional configuration settings for Envs.
 type EnvConfig struct {
 	RW                RWMode
 	EncryptionOptions *storageconfig.EncryptionOptions
+	Version           clusterversion.Handle
 }
 
 // InitEnv initializes a new virtual filesystem environment.
@@ -316,7 +320,12 @@ func (e *Env) onDiskSlow(info vfs.DiskSlowInfo) {
 
 // InMemory constructs a new in-memory environment.
 func InMemory() *Env {
-	e, err := InitEnv(context.Background(), vfs.NewMem(), "" /* dir */, EnvConfig{}, nil /* diskWriteStats */)
+	// For in-memory environments, we create a dummy cluster settings to provide
+	// a version handle, since these environments don't persist version information.
+	clusterSettings := cluster.MakeTestingClusterSettings()
+	e, err := InitEnv(context.Background(), vfs.NewMem(), "" /* dir */, EnvConfig{
+		Version: clusterSettings.Version,
+	}, nil /* diskWriteStats */)
 	// In practice InitEnv is infallible with this configuration.
 	if err != nil {
 		panic(err)
@@ -329,7 +338,10 @@ func InMemory() *Env {
 // encryption-at-rest. Since this function ignores the possibility of
 // encryption-at-rest, it should only be used as a testing convenience.
 func MustInitPhysicalTestingEnv(dir string) *Env {
-	e, err := InitEnv(context.Background(), vfs.Default, dir, EnvConfig{}, nil /* diskWriteStats */)
+	clusterSettings := cluster.MakeTestingClusterSettings()
+	e, err := InitEnv(context.Background(), vfs.Default, dir, EnvConfig{
+		Version: clusterSettings.Version,
+	}, nil /* diskWriteStats */)
 	if err != nil {
 		panic(err)
 	}
diff --git a/pkg/storage/fs/sticky_vfs_test.go b/pkg/storage/fs/sticky_vfs_test.go
@@ -36,7 +36,10 @@ func TestStickyVFS(t *testing.T) {
 		Size:        storageconfig.Size{Bytes: storeSize},
 	}
 	fs1 := registry.Get(spec1.StickyVFSID)
-	env, err := fs.InitEnvFromStoreSpec(ctx, spec1, fs.ReadWrite, registry, nil /* statsCollector */)
+	env, err := fs.InitEnvFromStoreSpec(ctx, spec1, fs.EnvConfig{
+		RW:      fs.ReadWrite,
+		Version: settings.Version,
+	}, registry, nil /* statsCollector */)
 	require.NoError(t, err)
 	engine1, err := storage.Open(ctx, env, settings)
 	require.NoError(t, err)
@@ -48,7 +51,10 @@ func TestStickyVFS(t *testing.T) {
 	// Refetching the engine should give back a different engine with the same
 	// underlying fs.
 	fs3 := registry.Get(spec1.StickyVFSID)
-	env, err = fs.InitEnvFromStoreSpec(ctx, spec1, fs.ReadWrite, registry, nil /* statsCollector */)
+	env, err = fs.InitEnvFromStoreSpec(ctx, spec1, fs.EnvConfig{
+		RW:      fs.ReadWrite,
+		Version: settings.Version,
+	}, registry, nil /* statsCollector */)
 	require.NoError(t, err)
 	engine2, err := storage.Open(ctx, env, settings)
 	require.NoError(t, err)
diff --git a/pkg/storage/metamorphic/generator.go b/pkg/storage/metamorphic/generator.go
@@ -36,7 +36,10 @@ type engineConfig struct {
 }
 
 func (e *engineConfig) create(path string, baseFS vfs.FS) (storage.Engine, error) {
-	env, err := fs.InitEnv(context.Background(), baseFS, path, fs.EnvConfig{}, nil /* diskWriteStats */)
+	settings := cluster.MakeTestingClusterSettings()
+	env, err := fs.InitEnv(context.Background(), baseFS, path, fs.EnvConfig{
+		Version: settings.Version,
+	}, nil /* diskWriteStats */)
 	if err != nil {
 		return nil, err
 	}
@@ -47,7 +50,7 @@ func (e *engineConfig) create(path string, baseFS vfs.FS) (storage.Engine, error
 	if e.opts != nil {
 		configOpts = append(configOpts, storage.PebbleOptions(e.opts.String(), parseHooks))
 	}
-	eng, err := storage.Open(context.Background(), env, cluster.MakeTestingClusterSettings(), configOpts...)
+	eng, err := storage.Open(context.Background(), env, settings, configOpts...)
 	if err != nil {
 		env.Close()
 		return nil, err
diff --git a/pkg/storage/min_version_test.go b/pkg/storage/min_version_test.go
@@ -93,7 +93,13 @@ func TestSetMinVersion(t *testing.T) {
 	defer leaktest.AfterTest(t)()
 	defer log.Scope(t).Close(t)
 
-	p, err := Open(context.Background(), InMemory(), cluster.MakeClusterSettings(), CacheSize(0))
+	settings := cluster.MakeClusterSettings()
+	e, err := fs.InitEnv(context.Background(), vfs.NewMem(), "" /* dir */, fs.EnvConfig{
+		Version: settings.Version,
+	}, nil /* diskWriteStats */)
+	// In practice InitEnv is infallible with this configuration.
+	require.NoError(t, err)
+	p, err := Open(context.Background(), e, settings, CacheSize(0))
 	require.NoError(t, err)
 	defer p.Close()
 	require.Equal(t, MinimumSupportedFormatVersion, p.db.FormatMajorVersion())
@@ -121,6 +127,7 @@ func TestMinVersion_IsNotEncrypted(t *testing.T) {
 	baseFS := vfs.NewMem()
 	env, err := fs.InitEnv(ctx, baseFS, "", fs.EnvConfig{
 		EncryptionOptions: &storageconfig.EncryptionOptions{},
+		Version:           st.Version,
 	}, nil /* statsCollector */)
 	require.NoError(t, err)
 
diff --git a/pkg/storage/open.go b/pkg/storage/open.go
@@ -286,6 +286,7 @@ func makeExternalWALDir(
 	env, err := fs.InitEnv(context.Background(), defaultFS, externalDir.Path, fs.EnvConfig{
 		RW:                engineCfg.env.RWMode(),
 		EncryptionOptions: externalDir.Encryption,
+		Version:           engineCfg.settings.Version,
 	}, diskWriteStats)
 	if err != nil {
 		return wal.Dir{}, err
diff --git a/pkg/storage/open_test.go b/pkg/storage/open_test.go
diff --git a/pkg/storage/pebble_test.go b/pkg/storage/pebble_test.go
diff --git a/pkg/storage/temp_engine.go b/pkg/storage/temp_engine.go

Original file line number	Diff line number	Diff line change
`@@ -163,7 +163,7 @@ func (f *keyFormat) Type() string {`
`163`	`163`	`// engine, they should manually open it using storage.Open. The returned Env has`
`164`	`164`	`// 1 reference and the caller must ensure it's closed.`
`165`	`165`	`func OpenFilesystemEnv(dir string, rw fs.RWMode) (*fs.Env, error) {`
`166`		`- envConfig := fs.EnvConfig{RW: rw}`
	`166`	`+ envConfig := fs.EnvConfig{RW: rw, Version: serverCfg.Settings.Version}`
`167`	`167`	`if err := fillEncryptionOptionsForStore(dir, &envConfig); err != nil {`
`168`	`168`	`return nil, err`
`169`	`169`	`}`
`@@ -1743,7 +1743,9 @@ func pebbleCryptoInitializer(ctx context.Context) {`
`1743`	`1743`	`encryptedPaths = append(encryptedPaths, spec.Path)`
`1744`	`1744`	`}`
`1745`	`1745`	`resolveFn := func(dir string) (*fs.Env, error) {`
`1746`		`- var envConfig fs.EnvConfig`
	`1746`	`+ envConfig := fs.EnvConfig{`
	`1747`	`+ Version: serverCfg.Settings.Version,`
	`1748`	`+ }`
`1747`	`1749`	`if err := fillEncryptionOptionsForStore(dir, &envConfig); err != nil {`
`1748`	`1750`	`return nil, err`
`1749`	`1751`	`}`
Original file line number	Diff line number	Diff line change
`@@ -764,7 +764,10 @@ func (cfg *Config) CreateEngines(ctx context.Context) (Engines, error) {`
`764`	`764`	`stickyRegistry = serverKnobs.StickyVFSRegistry`
`765`	`765`	`}`
`766`	`766`
`767`		`- storeEnvs, err := fs.InitEnvsFromStoreSpecs(ctx, cfg.Stores.Specs, fs.ReadWrite, stickyRegistry, cfg.DiskWriteStats)`
	`767`	`+ storeEnvs, err := fs.InitEnvsFromStoreSpecs(ctx, cfg.Stores.Specs, fs.EnvConfig{`
	`768`	`+ RW: fs.ReadWrite,`
	`769`	`+ Version: cfg.Settings.Version,`
	`770`	`+ }, stickyRegistry, cfg.DiskWriteStats)`
`768`	`771`	`if err != nil {`
`769`	`772`	`return Engines{}, err`
`770`	`773`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1072,7 +1072,10 @@ func TestCreateCheckpoint(t *testing.T) {`
`1072`	`1072`	`}`
`1073`	`1073`
`1074`	`1074`	`func mustInitTestEnv(t testing.TB, baseFS vfs.FS, dir string) *fs.Env {`
`1075`		`- e, err := fs.InitEnv(context.Background(), baseFS, dir, fs.EnvConfig{}, nil /* statsCollector */)`
	`1075`	`+ settings := cluster.MakeTestingClusterSettings()`
	`1076`	`+ e, err := fs.InitEnv(context.Background(), baseFS, dir, fs.EnvConfig{`
	`1077`	`+ Version: settings.Version,`
	`1078`	`+ }, nil /* statsCollector */)`
`1076`	`1079`	`require.NoError(t, err)`
`1077`	`1080`	`return e`
`1078`	`1081`	`}`