migrate metadata cache

cfg/config.go

@@ -541,7 +541,7 @@ func BindFlags(v *viper.Viper, flagSet *pflag.FlagSet) error {
 		return err
 	}
 
-	flagSet.IntP("metadata-cache-ttl", "", 60, "The ttl value in seconds to be used for expiring items in metadata-cache. It can be set to -1 for no-ttl, 0 for no cache and > 0 for ttl-controlled metadata-cache. Any value set below -1 will throw an error.\"")
+	flagSet.IntP("metadata-cache-ttl", "", TtlInSecsUnsetSentinel, "The ttl value in seconds to be used for expiring items in metadata-cache. It can be set to -1 for no-ttl, 0 for no cache and > 0 for ttl-controlled metadata-cache. Any value set below -1 will throw an error.\"")
 
 	if err := v.BindPFlag("metadata-cache.ttl-secs", flagSet.Lookup("metadata-cache-ttl")); err != nil {
 		return err
@@ -611,7 +611,7 @@ func BindFlags(v *viper.Viper, flagSet *pflag.FlagSet) error {
 		return err
 	}
 
-	flagSet.IntP("stat-cache-max-size-mb", "", 32, "The maximum size of stat-cache in MiBs. It can also be set to -1 for no-size-limit, 0 for no cache. Values below -1 are not supported.")
+	flagSet.IntP("stat-cache-max-size-mb", "", StatCacheMaxSizeMBUnsetSentinel, "The maximum size of stat-cache in MiBs. It can also be set to -1 for no-size-limit, 0 for no cache. Values below -1 are not supported.")
 
 	if err := v.BindPFlag("metadata-cache.stat-cache-max-size-mb", flagSet.Lookup("stat-cache-max-size-mb")); err != nil {
 		return err

cfg/config_util.go

@@ -59,15 +59,14 @@ func ResolveMetadataCacheTTL(statCacheTTL, typeCacheTTL time.Duration, ttlInSeco
 	} else {
 		metadataCacheTTL = time.Second * time.Duration(uint64(math.Ceil(math.Min(statCacheTTL.Seconds(), typeCacheTTL.Seconds()))))
 	}
-
 	return
 }
 
 // ResolveStatCacheMaxSizeMB returns the stat-cache size in MiBs based on the user old and new flags/configs.
 func ResolveStatCacheMaxSizeMB(mountConfigStatCacheMaxSizeMB int64, flagStatCacheCapacity int) (statCacheMaxSizeMB uint64, err error) {
 	if mountConfigStatCacheMaxSizeMB != StatCacheMaxSizeMBUnsetSentinel {
 		if mountConfigStatCacheMaxSizeMB == -1 {
-			statCacheMaxSizeMB = MaxSupportedStatCacheMaxSizeMB
+			statCacheMaxSizeMB = maxSupportedStatCacheMaxSizeMB
 		} else {
 			statCacheMaxSizeMB = uint64(mountConfigStatCacheMaxSizeMB)
 		}

cfg/config_util_test.go

@@ -157,9 +157,9 @@ func TestResolveMetadataCacheTTL(t *testing.T) {
 			name:         "metadata_cache_ttl_maximum",
 			statCacheTTL: DefaultStatOrTypeCacheTTL,
 			typeCacheTTL: DefaultStatOrTypeCacheTTL,
-			ttlInSeconds: MaxSupportedTTLInSeconds,
+			ttlInSeconds: maxSupportedTTLInSeconds,
 
-			expectedMetadataCacheTTL: time.Second * time.Duration(MaxSupportedTTLInSeconds),
+			expectedMetadataCacheTTL: time.Second * time.Duration(maxSupportedTTLInSeconds),
 		},
 		{
 			// Scenario where user sets both the old flags and the
@@ -249,7 +249,7 @@ func TestResolveStatCacheMaxSizeMB(t *testing.T) {
 			name:                          "stat_cache_size_mb_-1",
 			flagStatCacheCapacity:         DefaultStatCacheCapacity,
 			mountConfigStatCacheMaxSizeMB: -1,
-			expectedStatCacheMaxSizeMB:    MaxSupportedStatCacheMaxSizeMB,
+			expectedStatCacheMaxSizeMB:    maxSupportedStatCacheMaxSizeMB,
 		},
 		{
 			// Scenario where user sets only metadata-cache:stat-cache-max-size-mb and
@@ -272,8 +272,8 @@ func TestResolveStatCacheMaxSizeMB(t *testing.T) {
 			// sets it to its highest user-input value.
 			name:                          "stat_cache_size_mb_maximum",
 			flagStatCacheCapacity:         DefaultStatCacheCapacity,
-			mountConfigStatCacheMaxSizeMB: int64(MaxSupportedStatCacheMaxSizeMB),
-			expectedStatCacheMaxSizeMB:    MaxSupportedStatCacheMaxSizeMB,
+			mountConfigStatCacheMaxSizeMB: int64(maxSupportedStatCacheMaxSizeMB),
+			expectedStatCacheMaxSizeMB:    maxSupportedStatCacheMaxSizeMB,
 		},
 		{
 			// Scenario where user sets both stat-cache-capacity and the
@@ -291,7 +291,7 @@ func TestResolveStatCacheMaxSizeMB(t *testing.T) {
 			name:                          "both_stat_cache_size_mb_and_capacity_set_2",
 			flagStatCacheCapacity:         10000,
 			mountConfigStatCacheMaxSizeMB: -1,
-			expectedStatCacheMaxSizeMB:    MaxSupportedStatCacheMaxSizeMB,
+			expectedStatCacheMaxSizeMB:    maxSupportedStatCacheMaxSizeMB,
 		},
 		{
 			// Scenario where user sets both stat-cache-capacity and the

cfg/constants.go

@@ -47,9 +47,9 @@ const (
 )
 
 const (
-	// MaxSupportedTTLInSeconds represents maximum multiple of seconds representable by time.Duration.
-	MaxSupportedTTLInSeconds = math.MaxInt64 / int64(time.Second)
-	maxSupportedTTL          = time.Duration(MaxSupportedTTLInSeconds * int64(time.Second))
+	// maxSupportedTTLInSeconds represents maximum multiple of seconds representable by time.Duration.
+	maxSupportedTTLInSeconds = math.MaxInt64 / int64(time.Second)
+	maxSupportedTTL          = time.Duration(maxSupportedTTLInSeconds * int64(time.Second))
 )
 
 const (
@@ -69,7 +69,7 @@ const (
 	// metadata-cache:stat-cache-max-size-mb when it is not set in the gcsfuse
 	// mount config file.
 	StatCacheMaxSizeMBUnsetSentinel = math.MinInt64
-	MaxSupportedStatCacheMaxSizeMB  = util.MaxMiBsInUint64
+	maxSupportedStatCacheMaxSizeMB  = util.MaxMiBsInUint64
 	// DefaultStatCacheCapacity is the default value for stat-cache-capacity.
 	// This is equivalent of setting metadata-cache: stat-cache-max-size-mb.
 	DefaultStatCacheCapacity = 20460

cfg/validate.go

@@ -94,7 +94,7 @@ func isTTLInSecsValid(secs int64) error {
 	if secs < -1 {
 		return fmt.Errorf("the value of ttl-secs can't be less than -1")
 	}
-	if secs > MaxSupportedTTLInSeconds {
+	if secs > maxSupportedTTLInSeconds {
 		return fmt.Errorf("the value of ttl-secs is too high to be supported. Max is 9223372036")
 	}
 	return nil
@@ -107,6 +107,30 @@ func isValidKernelListCacheTTL(TTLSecs int64) error {
 	return nil
 }
 
+func isValidMetadataCache(c MetadataCacheConfig) error {
+	if c.TtlSecs != TtlInSecsUnsetSentinel {
+		if c.TtlSecs < -1 {
+			return fmt.Errorf("the value of ttl-secs for metadata-cache can't be less than -1")
+		}
+		if c.TtlSecs > maxSupportedTTLInSeconds {
+			return fmt.Errorf("the value of ttl-secs in metadata-cache is too high to be supported. Max is 9223372036")
+		}
+	}
+	if c.TypeCacheMaxSizeMb < -1 {
+		return fmt.Errorf("the value of type-cache-max-size-mb for metadata-cache can't be less than -1")
+	}
+
+	if c.StatCacheMaxSizeMb != StatCacheMaxSizeMBUnsetSentinel {
+		if c.StatCacheMaxSizeMb < -1 {
+			return fmt.Errorf("the value of stat-cache-max-size-mb for metadata-cache can't be less than -1")
+		}
+		if c.StatCacheMaxSizeMb > int64(maxSupportedStatCacheMaxSizeMB) {
+			return fmt.Errorf("the value of stat-cache-max-size-mb for metadata-cache is too high! Max supported: 17592186044415")
+		}
+	}
+	return nil
+}
+
 // ValidateConfig returns a non-nil error if the config is invalid.
 func ValidateConfig(config *Config) error {
 	var err error
@@ -139,5 +163,9 @@ func ValidateConfig(config *Config) error {
 		return fmt.Errorf("error parsing kernel-list-cache-ttl-secs config: %w", err)
 	}
 
+	if err = isValidMetadataCache(config.MetadataCache); err != nil {
+		return fmt.Errorf("error parsing metadata-cache config: %w", err)
+	}
+
 	return nil
 }

cmd/config_validation_test.go

@@ -262,6 +262,26 @@ func TestValidateConfigFile_InvalidConfigThrowsError(t *testing.T) {
 			name:       "unsupported_large_kernel_list_cache_TTL",
 			configFile: "testdata/file_system_config/unsupported_large_kernel_list_cache_ttl.yaml",
 		},
+		{
+			name:       "negative_stat_cache_size",
+			configFile: "testdata/metadata_cache/metadata_cache_config_invalid_stat-cache-max-size-mb.yaml",
+		},
+		{
+			name:       "negative_ttl_secs",
+			configFile: "testdata/metadata_cache/metadata_cache_config_invalid_ttl.yaml",
+		},
+		{
+			name:       "negative_type_cache_size",
+			configFile: "testdata/metadata_cache/metadata_cache_config_invalid_type-cache-max-size-mb.yaml",
+		},
+		{
+			name:       "stat_cache_size_too_high",
+			configFile: "testdata/metadata_cache/metadata_cache_config_stat-cache-max-size-mb_too_high.yaml",
+		},
+		{
+			name:       "metadata_cache_size_too_high",
+			configFile: "testdata/metadata_cache/metadata_cache_config_ttl_too_high.yaml",
+		},
 	}
 
 	for _, tc := range testCases {

cmd/mount.go

@@ -85,11 +85,11 @@ be interacting with the file system.`)
 		gid = uint32(newConfig.FileSystem.Gid)
 	}
 
-	metadataCacheTTL := cfg.ResolveMetadataCacheTTL(newConfig.MetadataCache.DeprecatedStatCacheTtl, newConfig.MetadataCache.DeprecatedTypeCacheTtl, mountConfig.MetadataCacheConfig.TtlInSeconds)
-	statCacheMaxSizeMB, err := cfg.ResolveStatCacheMaxSizeMB(mountConfig.StatCacheMaxSizeMB, int(newConfig.MetadataCache.DeprecatedStatCacheCapacity))
+	metadataCacheTTL := cfg.ResolveMetadataCacheTTL(newConfig.MetadataCache.DeprecatedStatCacheTtl, newConfig.MetadataCache.DeprecatedTypeCacheTtl, newConfig.MetadataCache.TtlSecs)
+	statCacheMaxSizeMB, err := cfg.ResolveStatCacheMaxSizeMB(newConfig.MetadataCache.StatCacheMaxSizeMb, int(newConfig.MetadataCache.DeprecatedStatCacheCapacity))
 	if err != nil {
-		return nil, fmt.Errorf("failed to calculate StatCacheMaxSizeMB from stat-cache-capacity=%v, metadata-cache:stat-cache-max-size-mb=%v: %w",
-			newConfig.MetadataCache.DeprecatedStatCacheCapacity, mountConfig.StatCacheMaxSizeMB, err)
+		return nil, fmt.Errorf("failed to calculate StatCacheMaxSizeMb from stat-cache-capacity=%v, metadata-cache:stat-cache-max-size-mb=%v: %w",
+			newConfig.MetadataCache.DeprecatedStatCacheCapacity, newConfig.MetadataCache.StatCacheMaxSizeMb, err)
 	}
 
 	bucketCfg := gcsx.BucketConfig{

internal/cache/metadata/stat_cache_test.go

@@ -117,15 +117,15 @@ type MultiBucketStatCacheTest struct {
 }
 
 func (t *StatCacheTest) SetupTest() {
-	cache := lru.NewCache((cfg.AverageSizeOfPositiveStatCacheEntry + cfg.AverageSizeOfNegativeStatCacheEntry) * capacity)
+	cache := lru.NewCache(uint64((cfg.AverageSizeOfPositiveStatCacheEntry + cfg.AverageSizeOfNegativeStatCacheEntry) * capacity))
 	t.cache.wrapped = metadata.NewStatCacheBucketView(cache, "") // this demonstrates
 	t.statCache = metadata.NewStatCacheBucketView(cache, "")     // this demonstrates
 	// that if you are using a cache for a single bucket, then
 	// its prepending bucketName can be left empty("") without any problem.
 }
 
 func (t *MultiBucketStatCacheTest) SetupTest() {
-	sharedCache := lru.NewCache((cfg.AverageSizeOfPositiveStatCacheEntry + cfg.AverageSizeOfNegativeStatCacheEntry) * capacity)
+	sharedCache := lru.NewCache(uint64((cfg.AverageSizeOfPositiveStatCacheEntry + cfg.AverageSizeOfNegativeStatCacheEntry) * capacity))
 	t.multiBucketCache.fruits = testHelperCache{wrapped: metadata.NewStatCacheBucketView(sharedCache, "fruits")}
 	t.multiBucketCache.spices = testHelperCache{wrapped: metadata.NewStatCacheBucketView(sharedCache, "spices")}
 }

internal/cache/metadata/type_cache.go

@@ -134,7 +134,7 @@ type typeCache struct {
 // When insertion of next entry would cause size of cache > maxSizeMB,
 // older entries are evicted according to the LRU-policy.
 // If either of TTL or maxSizeMB is zero, nothing is ever cached.
-func NewTypeCache(maxSizeMB int, ttl time.Duration) TypeCache {
+func NewTypeCache(maxSizeMB int64, ttl time.Duration) TypeCache {
 	if ttl > 0 && maxSizeMB != 0 {
 		var lruSizeInBytesToUse uint64 = math.MaxUint64 // default for when maxSizeMB = -1
 		if maxSizeMB > 0 {

internal/cache/metadata/type_cache_test.go

@@ -82,7 +82,7 @@ func (t *ZeroTtlTypeCacheTest) SetUp(ti *TestInfo) {
 // Helpers
 ////////////////////////////////////////////////////////////////////////
 
-func createNewTypeCache(maxSizeMB int, ttl time.Duration) *typeCache {
+func createNewTypeCache(maxSizeMB int64, ttl time.Duration) *typeCache {
 	tc := NewTypeCache(maxSizeMB, ttl)
 
 	AssertNe(nil, tc)
@@ -97,7 +97,7 @@ func createNewTypeCache(maxSizeMB int, ttl time.Duration) *typeCache {
 
 func (t *TypeCacheTest) TestNewTypeCache() {
 	input := []struct {
-		maxSizeMB          int
+		maxSizeMB          int64
 		ttl                time.Duration
 		entriesShouldBeNil bool
 	}{

internal/config/yaml_parser.go

@@ -27,12 +27,6 @@ import (
 
 const (
 	parseConfigFileErrMsgFormat = "error parsing config file: %v"
-
-	MetadataCacheTtlSecsInvalidValueError = "the value of ttl-secs for metadata-cache can't be less than -1"
-	MetadataCacheTtlSecsTooHighError      = "the value of ttl-secs in metadata-cache is too high to be supported. Max is 9223372036"
-	TypeCacheMaxSizeMBInvalidValueError   = "the value of type-cache-max-size-mb for metadata-cache can't be less than -1"
-	StatCacheMaxSizeMBInvalidValueError   = "the value of stat-cache-max-size-mb for metadata-cache can't be less than -1"
-	StatCacheMaxSizeMBTooHighError        = "the value of stat-cache-max-size-mb for metadata-cache is too high! Max supported: 17592186044415"
 )
 
 func IsValidLogSeverity(severity string) bool {
@@ -49,30 +43,6 @@ func IsValidLogSeverity(severity string) bool {
 	return false
 }
 
-func (metadataCacheConfig *MetadataCacheConfig) validate() error {
-	if metadataCacheConfig.TtlInSeconds != cfg.TtlInSecsUnsetSentinel {
-		if metadataCacheConfig.TtlInSeconds < -1 {
-			return fmt.Errorf(MetadataCacheTtlSecsInvalidValueError)
-		}
-		if metadataCacheConfig.TtlInSeconds > cfg.MaxSupportedTTLInSeconds {
-			return fmt.Errorf(MetadataCacheTtlSecsTooHighError)
-		}
-	}
-	if metadataCacheConfig.TypeCacheMaxSizeMB < -1 {
-		return fmt.Errorf(TypeCacheMaxSizeMBInvalidValueError)
-	}
-
-	if metadataCacheConfig.StatCacheMaxSizeMB != cfg.StatCacheMaxSizeMBUnsetSentinel {
-		if metadataCacheConfig.StatCacheMaxSizeMB < -1 {
-			return fmt.Errorf(StatCacheMaxSizeMBInvalidValueError)
-		}
-		if metadataCacheConfig.StatCacheMaxSizeMB > int64(cfg.MaxSupportedStatCacheMaxSizeMB) {
-			return fmt.Errorf(StatCacheMaxSizeMBTooHighError)
-		}
-	}
-	return nil
-}
-
 func (grpcClientConfig *GCSConnection) validate() error {
 	if grpcClientConfig.GRPCConnPoolSize < 1 {
 		return fmt.Errorf("the value of conn-pool-size can't be less than 1")
@@ -112,10 +82,6 @@ func ParseConfigFile(fileName string) (mountConfig *MountConfig, err error) {
 		return
 	}
 
-	if err = mountConfig.MetadataCacheConfig.validate(); err != nil {
-		return mountConfig, fmt.Errorf("error parsing metadata-cache configs: %w", err)
-	}
-
 	if err = mountConfig.GCSConnection.validate(); err != nil {
 		return mountConfig, fmt.Errorf("error parsing gcs-connection configs: %w", err)
 	}

internal/config/yaml_parser_test.go

@@ -147,12 +147,6 @@ func (t *YamlParserTest) TestReadConfigFile_InvalidLogConfig() {
 	assert.ErrorContains(t.T(), err, fmt.Sprintf(parseConfigFileErrMsgFormat, "log severity should be one of [trace, debug, info, warning, error, off]"))
 }
 
-func (t *YamlParserTest) TestReadConfigFile_MetatadaCacheConfig_InvalidTTL() {
-	_, err := ParseConfigFile("testdata/metadata_cache_config_invalid_ttl.yaml")
-
-	assert.ErrorContains(t.T(), err, MetadataCacheTtlSecsInvalidValueError)
-}
-
 func (t *YamlParserTest) TestReadConfigFile_MetatadaCacheConfig_TtlNotSet() {
 	mountConfig, err := ParseConfigFile("testdata/metadata_cache_config_ttl-unset.yaml")
 
@@ -161,18 +155,6 @@ func (t *YamlParserTest) TestReadConfigFile_MetatadaCacheConfig_TtlNotSet() {
 	assert.EqualValues(t.T(), cfg.TtlInSecsUnsetSentinel, mountConfig.MetadataCacheConfig.TtlInSeconds)
 }
 
-func (t *YamlParserTest) TestReadConfigFile_MetatadaCacheConfig_TtlTooHigh() {
-	_, err := ParseConfigFile("testdata/metadata_cache_config_ttl_too_high.yaml")
-
-	assert.ErrorContains(t.T(), err, MetadataCacheTtlSecsTooHighError)
-}
-
-func (t *YamlParserTest) TestReadConfigFile_MetatadaCacheConfig_InvalidTypeCacheMaxSize() {
-	_, err := ParseConfigFile("testdata/metadata_cache_config_invalid_type-cache-max-size-mb.yaml")
-
-	assert.ErrorContains(t.T(), err, TypeCacheMaxSizeMBInvalidValueError)
-}
-
 func (t *YamlParserTest) TestReadConfigFile_MetatadaCacheConfig_TypeCacheMaxSizeNotSet() {
 	mountConfig, err := ParseConfigFile("testdata/metadata_cache_config_type-cache-max-size-mb_unset.yaml")
 
@@ -181,12 +163,6 @@ func (t *YamlParserTest) TestReadConfigFile_MetatadaCacheConfig_TypeCacheMaxSize
 	assert.Equal(t.T(), cfg.DefaultTypeCacheMaxSizeMB, mountConfig.MetadataCacheConfig.TypeCacheMaxSizeMB)
 }
 
-func (t *YamlParserTest) TestReadConfigFile_MetatadaCacheConfig_InvalidStatCacheSize() {
-	_, err := ParseConfigFile("testdata/metadata_cache_config_invalid_stat-cache-max-size-mb.yaml")
-
-	assert.ErrorContains(t.T(), err, StatCacheMaxSizeMBInvalidValueError)
-}
-
 func (t *YamlParserTest) TestReadConfigFile_MetatadaCacheConfig_StatCacheSizeNotSet() {
 	mountConfig, err := ParseConfigFile("testdata/metadata_cache_config_stat-cache-max-size-mb_unset.yaml")
 
@@ -195,12 +171,6 @@ func (t *YamlParserTest) TestReadConfigFile_MetatadaCacheConfig_StatCacheSizeNot
 	assert.EqualValues(t.T(), cfg.StatCacheMaxSizeMBUnsetSentinel, mountConfig.MetadataCacheConfig.StatCacheMaxSizeMB)
 }
 
-func (t *YamlParserTest) TestReadConfigFile_MetatadaCacheConfig_StatCacheSizeTooHigh() {
-	_, err := ParseConfigFile("testdata/metadata_cache_config_stat-cache-max-size-mb_too_high.yaml")
-
-	assert.ErrorContains(t.T(), err, StatCacheMaxSizeMBTooHighError)
-}
-
 func (t *YamlParserTest) TestReadConfigFile_GrpcClientConfig_invalidConnPoolSize() {
 	_, err := ParseConfigFile("testdata/gcs_connection/invalid_conn_pool_size.yaml")
 

internal/fs/caching_test.go

@@ -57,7 +57,7 @@ func (t *cachingTestCommon) SetUpTestSuite() {
 	// Wrap the bucket in a stat caching layer for the purposes of the file
 	// system.
 	uncachedBucket = fake.NewFakeBucket(timeutil.RealClock(), "some_bucket", gcs.NonHierarchical)
-	lruCache := newLruCache(1000 * cfg.AverageSizeOfPositiveStatCacheEntry)
+	lruCache := newLruCache(uint64(1000 * cfg.AverageSizeOfPositiveStatCacheEntry))
 	statCache := metadata.NewStatCacheBucketView(lruCache, "")
 	bucket = caching.NewFastStatBucket(
 		ttl,
@@ -456,7 +456,7 @@ func getMultiMountBucketDir(bucketName string) string {
 }
 
 func (t *MultiBucketMountCachingTest) SetUpTestSuite() {
-	sharedCache := newLruCache(1000 * cfg.AverageSizeOfPositiveStatCacheEntry)
+	sharedCache := newLruCache(uint64(1000 * cfg.AverageSizeOfPositiveStatCacheEntry))
 	uncachedBuckets = make(map[string]gcs.Bucket)
 	buckets = make(map[string]gcs.Bucket)
 

internal/fs/fs.go

@@ -274,7 +274,7 @@ func makeRootForBucket(
 		&syncerBucket,
 		fs.mtimeClock,
 		fs.cacheClock,
-		fs.mountConfig.MetadataCacheConfig.TypeCacheMaxSizeMB,
+		fs.newConfig.MetadataCache.TypeCacheMaxSizeMb,
 		fs.newConfig.EnableHns,
 	)
 }
@@ -730,7 +730,7 @@ func (fs *fileSystem) createExplicitDirInode(inodeID fuseops.InodeID, ic inode.C
 		ic.Bucket,
 		fs.mtimeClock,
 		fs.cacheClock,
-		fs.mountConfig.MetadataCacheConfig.TypeCacheMaxSizeMB,
+		fs.newConfig.MetadataCache.TypeCacheMaxSizeMb,
 		fs.newConfig.EnableHns)
 
 	return in
@@ -773,7 +773,7 @@ func (fs *fileSystem) mintInode(ic inode.Core) (in inode.Inode) {
 			ic.Bucket,
 			fs.mtimeClock,
 			fs.cacheClock,
-			fs.mountConfig.MetadataCacheConfig.TypeCacheMaxSizeMB,
+			fs.newConfig.MetadataCache.TypeCacheMaxSizeMb,
 			fs.newConfig.EnableHns,
 		)