TestWatchInitialRefreshPaginationError

26 type GlobalBoolConstrainedDefaultSetting = GlobalTypedConstrainedDefaultSetting[bool]

27

28 > func NewGlobalBoolSetting(key string, def bool, description string) GlobalBoolSetting { setting_gen.go

29 > return NewGlobalTypedSettingWithConverter[bool](key, convertBool, def, description)

30 > }

31

32 func NewGlobalBoolSettingWithConstrainedDefault(key string, cdef []TypedConstrainedValue[bool], description string) GlobalBoolConstrainedDefaultSetting {

36 type BoolPropertyFn = TypedPropertyFn[bool]

37

38 > func GetBoolPropertyFn(value bool) BoolPropertyFn { setting_gen.go

39 > return GetTypedPropertyFn(value)

40 > }

41

42 type NamespaceBoolSetting = NamespaceTypedSetting[bool]

43 type NamespaceBoolConstrainedDefaultSetting = NamespaceTypedConstrainedDefaultSetting[bool]

44

45 > func NewNamespaceBoolSetting(key string, def bool, description string) NamespaceBoolSetting { setting_gen.go

46 > return NewNamespaceTypedSettingWithConverter[bool](key, convertBool, def, description)

47 > }

48

49 func NewNamespaceBoolSettingWithConstrainedDefault(key string, cdef []TypedConstrainedValue[bool], description string) NamespaceBoolConstrainedDefaultSetting {

60 type NamespaceIDBoolConstrainedDefaultSetting = NamespaceIDTypedConstrainedDefaultSetting[bool]

61

62 > func NewNamespaceIDBoolSetting(key string, def bool, description string) NamespaceIDBoolSetting { setting_gen.go

63 > return NewNamespaceIDTypedSettingWithConverter[bool](key, convertBool, def, description)

64 > }

65

66 func NewNamespaceIDBoolSettingWithConstrainedDefault(key string, cdef []TypedConstrainedValue[bool], description string) NamespaceIDBoolConstrainedDefaultSetting {

77 type TaskQueueBoolConstrainedDefaultSetting = TaskQueueTypedConstrainedDefaultSetting[bool]

78

79 > func NewTaskQueueBoolSetting(key string, def bool, description string) TaskQueueBoolSetting { setting_gen.go

80 > return NewTaskQueueTypedSettingWithConverter[bool](key, convertBool, def, description)

81 > }

82

83 func NewTaskQueueBoolSettingWithConstrainedDefault(key string, cdef []TypedConstrainedValue[bool], description string) TaskQueueBoolConstrainedDefaultSetting {

128 type DestinationBoolConstrainedDefaultSetting = DestinationTypedConstrainedDefaultSetting[bool]

129

130 > func NewDestinationBoolSetting(key string, def bool, description string) DestinationBoolSetting { setting_gen.go

131 > return NewDestinationTypedSettingWithConverter[bool](key, convertBool, def, description)

132 > }

133

134 func NewDestinationBoolSettingWithConstrainedDefault(key string, cdef []TypedConstrainedValue[bool], description string) DestinationBoolConstrainedDefaultSetting {

162 type GlobalIntConstrainedDefaultSetting = GlobalTypedConstrainedDefaultSetting[int]

163

164 > func NewGlobalIntSetting(key string, def int, description string) GlobalIntSetting { setting_gen.go

165 > return NewGlobalTypedSettingWithConverter[int](key, convertInt, def, description)

166 > }

167

168 func NewGlobalIntSettingWithConstrainedDefault(key string, cdef []TypedConstrainedValue[int], description string) GlobalIntConstrainedDefaultSetting {

179 type NamespaceIntConstrainedDefaultSetting = NamespaceTypedConstrainedDefaultSetting[int]

180

181 > func NewNamespaceIntSetting(key string, def int, description string) NamespaceIntSetting { setting_gen.go

182 > return NewNamespaceTypedSettingWithConverter[int](key, convertInt, def, description)

183 > }

184

185 func NewNamespaceIntSettingWithConstrainedDefault(key string, cdef []TypedConstrainedValue[int], description string) NamespaceIntConstrainedDefaultSetting {

189 type IntPropertyFnWithNamespaceFilter = TypedPropertyFnWithNamespaceFilter[int]

190

191 > func GetIntPropertyFnFilteredByNamespace(value int) IntPropertyFnWithNamespaceFilter { setting_gen.go

192 > return GetTypedPropertyFnFilteredByNamespace(value)

193 > }

194

195 type NamespaceIDIntSetting = NamespaceIDTypedSetting[int]

213 type TaskQueueIntConstrainedDefaultSetting = TaskQueueTypedConstrainedDefaultSetting[int]

214

215 > func NewTaskQueueIntSetting(key string, def int, description string) TaskQueueIntSetting { setting_gen.go

216 > return NewTaskQueueTypedSettingWithConverter[int](key, convertInt, def, description)

217 > }

218

219 > func NewTaskQueueIntSettingWithConstrainedDefault(key string, cdef []TypedConstrainedValue[int], description string) TaskQueueIntConstrainedDefaultSetting { setting_gen.go

220 > return NewTaskQueueTypedSettingWithConstrainedDefault[int](key, convertInt, cdef, description)

221 > }

222

223 type IntPropertyFnWithTaskQueueFilter = TypedPropertyFnWithTaskQueueFilter[int]

230 type ShardIDIntConstrainedDefaultSetting = ShardIDTypedConstrainedDefaultSetting[int]

231

232 > func NewShardIDIntSetting(key string, def int, description string) ShardIDIntSetting { setting_gen.go

233 > return NewShardIDTypedSettingWithConverter[int](key, convertInt, def, description)

234 > }

235

236 func NewShardIDIntSettingWithConstrainedDefault(key string, cdef []TypedConstrainedValue[int], description string) ShardIDIntConstrainedDefaultSetting {

264 type DestinationIntConstrainedDefaultSetting = DestinationTypedConstrainedDefaultSetting[int]

265

266 > func NewDestinationIntSetting(key string, def int, description string) DestinationIntSetting { setting_gen.go

267 > return NewDestinationTypedSettingWithConverter[int](key, convertInt, def, description)

268 > }

269

270 func NewDestinationIntSettingWithConstrainedDefault(key string, cdef []TypedConstrainedValue[int], description string) DestinationIntConstrainedDefaultSetting {

298 type GlobalFloatConstrainedDefaultSetting = GlobalTypedConstrainedDefaultSetting[float64]

299

300 > func NewGlobalFloatSetting(key string, def float64, description string) GlobalFloatSetting { setting_gen.go

301 > return NewGlobalTypedSettingWithConverter[float64](key, convertFloat, def, description)

302 > }

303

304 func NewGlobalFloatSettingWithConstrainedDefault(key string, cdef []TypedConstrainedValue[float64], description string) GlobalFloatConstrainedDefaultSetting {

315 type NamespaceFloatConstrainedDefaultSetting = NamespaceTypedConstrainedDefaultSetting[float64]

316

317 > func NewNamespaceFloatSetting(key string, def float64, description string) NamespaceFloatSetting { setting_gen.go

318 > return NewNamespaceTypedSettingWithConverter[float64](key, convertFloat, def, description)

319 > }

320

321 func NewNamespaceFloatSettingWithConstrainedDefault(key string, cdef []TypedConstrainedValue[float64], description string) NamespaceFloatConstrainedDefaultSetting {

349 type TaskQueueFloatConstrainedDefaultSetting = TaskQueueTypedConstrainedDefaultSetting[float64]

350

351 > func NewTaskQueueFloatSetting(key string, def float64, description string) TaskQueueFloatSetting { setting_gen.go

352 > return NewTaskQueueTypedSettingWithConverter[float64](key, convertFloat, def, description)

353 > }

354

355 func NewTaskQueueFloatSettingWithConstrainedDefault(key string, cdef []TypedConstrainedValue[float64], description string) TaskQueueFloatConstrainedDefaultSetting {

366 type ShardIDFloatConstrainedDefaultSetting = ShardIDTypedConstrainedDefaultSetting[float64]

367

368 > func NewShardIDFloatSetting(key string, def float64, description string) ShardIDFloatSetting { setting_gen.go

369 > return NewShardIDTypedSettingWithConverter[float64](key, convertFloat, def, description)

370 > }

371

372 func NewShardIDFloatSettingWithConstrainedDefault(key string, cdef []TypedConstrainedValue[float64], description string) ShardIDFloatConstrainedDefaultSetting {

400 type DestinationFloatConstrainedDefaultSetting = DestinationTypedConstrainedDefaultSetting[float64]

401

402 > func NewDestinationFloatSetting(key string, def float64, description string) DestinationFloatSetting { setting_gen.go

403 > return NewDestinationTypedSettingWithConverter[float64](key, convertFloat, def, description)

404 > }

405

406 func NewDestinationFloatSettingWithConstrainedDefault(key string, cdef []TypedConstrainedValue[float64], description string) DestinationFloatConstrainedDefaultSetting {

434 type GlobalStringConstrainedDefaultSetting = GlobalTypedConstrainedDefaultSetting[string]

435

436 > func NewGlobalStringSetting(key string, def string, description string) GlobalStringSetting { setting_gen.go

437 > return NewGlobalTypedSettingWithConverter[string](key, convertString, def, description)

438 > }

439

440 func NewGlobalStringSettingWithConstrainedDefault(key string, cdef []TypedConstrainedValue[string], description string) GlobalStringConstrainedDefaultSetting {

570 type GlobalDurationConstrainedDefaultSetting = GlobalTypedConstrainedDefaultSetting[time.Duration]

571

572 > func NewGlobalDurationSetting(key string, def time.Duration, description string) GlobalDurationSetting { setting_gen.go

573 > return NewGlobalTypedSettingWithConverter[time.Duration](key, convertDuration, def, description)

574 > }

575

576 func NewGlobalDurationSettingWithConstrainedDefault(key string, cdef []TypedConstrainedValue[time.Duration], description string) GlobalDurationConstrainedDefaultSetting {

580 type DurationPropertyFn = TypedPropertyFn[time.Duration]

581

582 > func GetDurationPropertyFn(value time.Duration) DurationPropertyFn { setting_gen.go

583 > return GetTypedPropertyFn(value)

584 > }

585

586 type NamespaceDurationSetting = NamespaceTypedSetting[time.Duration]

587 type NamespaceDurationConstrainedDefaultSetting = NamespaceTypedConstrainedDefaultSetting[time.Duration]

588

589 > func NewNamespaceDurationSetting(key string, def time.Duration, description string) NamespaceDurationSetting { setting_gen.go

590 > return NewNamespaceTypedSettingWithConverter[time.Duration](key, convertDuration, def, description)

591 > }

592

593 func NewNamespaceDurationSettingWithConstrainedDefault(key string, cdef []TypedConstrainedValue[time.Duration], description string) NamespaceDurationConstrainedDefaultSetting {

604 type NamespaceIDDurationConstrainedDefaultSetting = NamespaceIDTypedConstrainedDefaultSetting[time.Duration]

605

606 > func NewNamespaceIDDurationSetting(key string, def time.Duration, description string) NamespaceIDDurationSetting { setting_gen.go

607 > return NewNamespaceIDTypedSettingWithConverter[time.Duration](key, convertDuration, def, description)

608 > }

609

610 func NewNamespaceIDDurationSettingWithConstrainedDefault(key string, cdef []TypedConstrainedValue[time.Duration], description string) NamespaceIDDurationConstrainedDefaultSetting {

621 type TaskQueueDurationConstrainedDefaultSetting = TaskQueueTypedConstrainedDefaultSetting[time.Duration]

622

623 > func NewTaskQueueDurationSetting(key string, def time.Duration, description string) TaskQueueDurationSetting { setting_gen.go

624 > return NewTaskQueueTypedSettingWithConverter[time.Duration](key, convertDuration, def, description)

625 > }

626

627 > func NewTaskQueueDurationSettingWithConstrainedDefault(key string, cdef []TypedConstrainedValue[time.Duration], description string) TaskQueueDurationConstrainedDefaultSetting { setting_gen.go

628 > return NewTaskQueueTypedSettingWithConstrainedDefault[time.Duration](key, convertDuration, cdef, description)

629 > }

630

631 type DurationPropertyFnWithTaskQueueFilter = TypedPropertyFnWithTaskQueueFilter[time.Duration]

638 type ShardIDDurationConstrainedDefaultSetting = ShardIDTypedConstrainedDefaultSetting[time.Duration]

639

640 > func NewShardIDDurationSetting(key string, def time.Duration, description string) ShardIDDurationSetting { setting_gen.go

641 > return NewShardIDTypedSettingWithConverter[time.Duration](key, convertDuration, def, description)

642 > }

643

644 func NewShardIDDurationSettingWithConstrainedDefault(key string, cdef []TypedConstrainedValue[time.Duration], description string) ShardIDDurationConstrainedDefaultSetting {

655 type TaskTypeDurationConstrainedDefaultSetting = TaskTypeTypedConstrainedDefaultSetting[time.Duration]

656

657 > func NewTaskTypeDurationSetting(key string, def time.Duration, description string) TaskTypeDurationSetting { setting_gen.go

658 > return NewTaskTypeTypedSettingWithConverter[time.Duration](key, convertDuration, def, description)

659 > }

660

661 func NewTaskTypeDurationSettingWithConstrainedDefault(key string, cdef []TypedConstrainedValue[time.Duration], description string) TaskTypeDurationConstrainedDefaultSetting {

672 type DestinationDurationConstrainedDefaultSetting = DestinationTypedConstrainedDefaultSetting[time.Duration]

673

674 > func NewDestinationDurationSetting(key string, def time.Duration, description string) DestinationDurationSetting { setting_gen.go

675 > return NewDestinationTypedSettingWithConverter[time.Duration](key, convertDuration, def, description)

676 > }

677

678 func NewDestinationDurationSettingWithConstrainedDefault(key string, cdef []TypedConstrainedValue[time.Duration], description string) DestinationDurationConstrainedDefaultSetting {

689 type ChasmTaskTypeDurationConstrainedDefaultSetting = ChasmTaskTypeTypedConstrainedDefaultSetting[time.Duration]

690

691 > func NewChasmTaskTypeDurationSetting(key string, def time.Duration, description string) ChasmTaskTypeDurationSetting { setting_gen.go

692 > return NewChasmTaskTypeTypedSettingWithConverter[time.Duration](key, convertDuration, def, description)

693 > }

694

695 func NewChasmTaskTypeDurationSettingWithConstrainedDefault(key string, cdef []TypedConstrainedValue[time.Duration], description string) ChasmTaskTypeDurationConstrainedDefaultSetting {

723 type NamespaceMapConstrainedDefaultSetting = NamespaceTypedConstrainedDefaultSetting[map[string]any]

724

725 > func NewNamespaceMapSetting(key string, def map[string]any, description string) NamespaceMapSetting { setting_gen.go

726 > return NewNamespaceTypedSettingWithConverter[map[string]any](key, convertMap, def, description)

727 > }

728

729 func NewNamespaceMapSettingWithConstrainedDefault(key string, cdef []TypedConstrainedValue[map[string]any], description string) NamespaceMapConstrainedDefaultSetting {

845 // values. The value from dynamic config will be _merged_ over a deep copy of 'def'. Be very careful

846 // when using non-empty maps or slices as defaults, the result may not be what you want.

847 > func NewGlobalTypedSetting[T any](key string, def T, description string) GlobalTypedSetting[T] { setting_gen.go

848 > // Warn on any shared structure used with ConvertStructure, even though we handle it by deep copying.

849 > warnDefaultSharedStructure(key, def)

850 > // If even deep copy won't even work, we should panic early. Do that by calling deep copy once here.

851 > _ = deepCopyForMapstructure(def)

852 >

853 > s := GlobalTypedSetting[T]{

854 > key: MakeKey(key),

855 > def: def,

856 > convert: ConvertStructure[T](def),

857 > description: description,

858 > }

859 > register(s)

860 > return s

861 > }

862

863 // NewGlobalTypedSettingWithConverter creates a setting with a custom converter function.

864 > func NewGlobalTypedSettingWithConverter[T any](key string, convert func(any) (T, error), def T, description string) GlobalTypedSetting[T] { setting_gen.go

865 > s := GlobalTypedSetting[T]{

866 > key: MakeKey(key),

867 > def: def,

868 > convert: convert,

869 > description: description,

870 > }

871 > register(s)

872 > return s

873 > }

874

875 // NewGlobalTypedSettingWithConstrainedDefault creates a setting with a compound default value.

885 }

886

887 > func (s GlobalTypedSetting[T]) Key() Key { return s.key } setting_gen.go

888 func (s GlobalTypedSetting[T]) Precedence() Precedence { return PrecedenceGlobal }

889 func (s GlobalTypedSetting[T]) Validate(v any) error {

969 }

970

971 > func GetTypedPropertyFn[T any](value T) TypedPropertyFn[T] { setting_gen.go

972 > return func() T {

973 return value

974 }

981 // values. The value from dynamic config will be _merged_ over a deep copy of 'def'. Be very careful

982 // when using non-empty maps or slices as defaults, the result may not be what you want.

983 > func NewNamespaceTypedSetting[T any](key string, def T, description string) NamespaceTypedSetting[T] { setting_gen.go

984 > // Warn on any shared structure used with ConvertStructure, even though we handle it by deep copying.

985 > warnDefaultSharedStructure(key, def)

986 > // If even deep copy won't even work, we should panic early. Do that by calling deep copy once here.

987 > _ = deepCopyForMapstructure(def)

988 >

989 > s := NamespaceTypedSetting[T]{

990 > key: MakeKey(key),

991 > def: def,

992 > convert: ConvertStructure[T](def),

993 > description: description,

994 > }

995 > register(s)

996 > return s

997 > }

998

999 // NewNamespaceTypedSettingWithConverter creates a setting with a custom converter function.

1000 > func NewNamespaceTypedSettingWithConverter[T any](key string, convert func(any) (T, error), def T, description string) NamespaceTypedSetting[T] { setting_gen.go

1001 > s := NamespaceTypedSetting[T]{

1002 > key: MakeKey(key),

1003 > def: def,

1004 > convert: convert,

1005 > description: description,

1006 > }

1007 > register(s)

1008 > return s

1009 > }

1010

1011 // NewNamespaceTypedSettingWithConstrainedDefault creates a setting with a compound default value.

1021 }

1022

1023 > func (s NamespaceTypedSetting[T]) Key() Key { return s.key } setting_gen.go

1024 func (s NamespaceTypedSetting[T]) Precedence() Precedence { return PrecedenceNamespace }

1025 func (s NamespaceTypedSetting[T]) Validate(v any) error {

1105 }

1106

1107 > func GetTypedPropertyFnFilteredByNamespace[T any](value T) TypedPropertyFnWithNamespaceFilter[T] { setting_gen.go

1108 > return func(namespace string) T {

1109 return value

1110 }

1134

1135 // NewNamespaceIDTypedSettingWithConverter creates a setting with a custom converter function.

1136 > func NewNamespaceIDTypedSettingWithConverter[T any](key string, convert func(any) (T, error), def T, description string) NamespaceIDTypedSetting[T] { setting_gen.go

1137 > s := NamespaceIDTypedSetting[T]{

1138 > key: MakeKey(key),

1139 > def: def,

1140 > convert: convert,

1141 > description: description,

1142 > }

1143 > register(s)

1144 > return s

1145 > }

1146

1147 // NewNamespaceIDTypedSettingWithConstrainedDefault creates a setting with a compound default value.

1157 }

1158

1159 > func (s NamespaceIDTypedSetting[T]) Key() Key { return s.key } setting_gen.go

1160 func (s NamespaceIDTypedSetting[T]) Precedence() Precedence { return PrecedenceNamespaceID }

1161 func (s NamespaceIDTypedSetting[T]) Validate(v any) error {

1253 // values. The value from dynamic config will be _merged_ over a deep copy of 'def'. Be very careful

1254 // when using non-empty maps or slices as defaults, the result may not be what you want.

1255 > func NewTaskQueueTypedSetting[T any](key string, def T, description string) TaskQueueTypedSetting[T] { setting_gen.go

1256 > // Warn on any shared structure used with ConvertStructure, even though we handle it by deep copying.

1257 > warnDefaultSharedStructure(key, def)

1258 > // If even deep copy won't even work, we should panic early. Do that by calling deep copy once here.

1259 > _ = deepCopyForMapstructure(def)

1260 >

1261 > s := TaskQueueTypedSetting[T]{

1262 > key: MakeKey(key),

1263 > def: def,

1264 > convert: ConvertStructure[T](def),

1265 > description: description,

1266 > }

1267 > register(s)

1268 > return s

1269 > }

1270

1271 // NewTaskQueueTypedSettingWithConverter creates a setting with a custom converter function.

1272 > func NewTaskQueueTypedSettingWithConverter[T any](key string, convert func(any) (T, error), def T, description string) TaskQueueTypedSetting[T] { setting_gen.go

1273 > s := TaskQueueTypedSetting[T]{

1274 > key: MakeKey(key),

1275 > def: def,

1276 > convert: convert,

1277 > description: description,

1278 > }

1279 > register(s)

1280 > return s

1281 > }

1282

1283 // NewTaskQueueTypedSettingWithConstrainedDefault creates a setting with a compound default value.

1284 > func NewTaskQueueTypedSettingWithConstrainedDefault[T any](key string, convert func(any) (T, error), cdef []TypedConstrainedValue[T], description string) TaskQueueTypedConstrainedDefaultSetting[T] { setting_gen.go

1285 > s := TaskQueueTypedConstrainedDefaultSetting[T]{

1286 > key: MakeKey(key),

1287 > cdef: cdef,

1288 > convert: convert,

1289 > description: description,

1290 > }

1291 > register(s)

1292 > return s

1293 > }

1294

1295 > func (s TaskQueueTypedSetting[T]) Key() Key { return s.key } setting_gen.go

1296 func (s TaskQueueTypedSetting[T]) Precedence() Precedence { return PrecedenceTaskQueue }

1297 func (s TaskQueueTypedSetting[T]) Validate(v any) error {

1300 }

1301

1302 > func (s TaskQueueTypedConstrainedDefaultSetting[T]) Key() Key { return s.key } setting_gen.go

1303 func (s TaskQueueTypedConstrainedDefaultSetting[T]) Precedence() Precedence { return PrecedenceTaskQueue }

1304 func (s TaskQueueTypedConstrainedDefaultSetting[T]) Validate(v any) error {

1430

1431 // NewShardIDTypedSettingWithConverter creates a setting with a custom converter function.

1432 > func NewShardIDTypedSettingWithConverter[T any](key string, convert func(any) (T, error), def T, description string) ShardIDTypedSetting[T] { setting_gen.go

1433 > s := ShardIDTypedSetting[T]{

1434 > key: MakeKey(key),

1435 > def: def,

1436 > convert: convert,

1437 > description: description,

1438 > }

1439 > register(s)

1440 > return s

1441 > }

1442

1443 // NewShardIDTypedSettingWithConstrainedDefault creates a setting with a compound default value.

1453 }

1454

1455 > func (s ShardIDTypedSetting[T]) Key() Key { return s.key } setting_gen.go

1456 func (s ShardIDTypedSetting[T]) Precedence() Precedence { return PrecedenceShardID }

1457 func (s ShardIDTypedSetting[T]) Validate(v any) error {

1566

1567 // NewTaskTypeTypedSettingWithConverter creates a setting with a custom converter function.

1568 > func NewTaskTypeTypedSettingWithConverter[T any](key string, convert func(any) (T, error), def T, description string) TaskTypeTypedSetting[T] { setting_gen.go

1569 > s := TaskTypeTypedSetting[T]{

1570 > key: MakeKey(key),

1571 > def: def,

1572 > convert: convert,

1573 > description: description,

1574 > }

1575 > register(s)

1576 > return s

1577 > }

1578

1579 // NewTaskTypeTypedSettingWithConstrainedDefault creates a setting with a compound default value.

1589 }

1590

1591 > func (s TaskTypeTypedSetting[T]) Key() Key { return s.key } setting_gen.go

1592 func (s TaskTypeTypedSetting[T]) Precedence() Precedence { return PrecedenceTaskType }

1593 func (s TaskTypeTypedSetting[T]) Validate(v any) error {

1685 // values. The value from dynamic config will be _merged_ over a deep copy of 'def'. Be very careful

1686 // when using non-empty maps or slices as defaults, the result may not be what you want.

1687 > func NewDestinationTypedSetting[T any](key string, def T, description string) DestinationTypedSetting[T] { setting_gen.go

1688 > // Warn on any shared structure used with ConvertStructure, even though we handle it by deep copying.

1689 > warnDefaultSharedStructure(key, def)

1690 > // If even deep copy won't even work, we should panic early. Do that by calling deep copy once here.

1691 > _ = deepCopyForMapstructure(def)

1692 >

1693 > s := DestinationTypedSetting[T]{

1694 > key: MakeKey(key),

1695 > def: def,

1696 > convert: ConvertStructure[T](def),

1697 > description: description,

1698 > }

1699 > register(s)

1700 > return s

1701 > }

1702

1703 // NewDestinationTypedSettingWithConverter creates a setting with a custom converter function.

1704 > func NewDestinationTypedSettingWithConverter[T any](key string, convert func(any) (T, error), def T, description string) DestinationTypedSetting[T] { setting_gen.go

1705 > s := DestinationTypedSetting[T]{

1706 > key: MakeKey(key),

1707 > def: def,

1708 > convert: convert,

1709 > description: description,

1710 > }

1711 > register(s)

1712 > return s

1713 > }

1714

1715 // NewDestinationTypedSettingWithConstrainedDefault creates a setting with a compound default value.

1725 }

1726

1727 > func (s DestinationTypedSetting[T]) Key() Key { return s.key } setting_gen.go

1728 func (s DestinationTypedSetting[T]) Precedence() Precedence { return PrecedenceDestination }

1729 func (s DestinationTypedSetting[T]) Validate(v any) error {

1858

1859 // NewChasmTaskTypeTypedSettingWithConverter creates a setting with a custom converter function.

1860 > func NewChasmTaskTypeTypedSettingWithConverter[T any](key string, convert func(any) (T, error), def T, description string) ChasmTaskTypeTypedSetting[T] { setting_gen.go

1861 > s := ChasmTaskTypeTypedSetting[T]{

1862 > key: MakeKey(key),

1863 > def: def,

1864 > convert: convert,

1865 > description: description,

1866 > }

1867 > register(s)

1868 > return s

1869 > }

1870

1871 // NewChasmTaskTypeTypedSettingWithConstrainedDefault creates a setting with a compound default value.

1881 }

1882

1883 > func (s ChasmTaskTypeTypedSetting[T]) Key() Key { return s.key } setting_gen.go

1884 func (s ChasmTaskTypeTypedSetting[T]) Precedence() Precedence { return PrecedenceChasmTaskType }

1885 func (s ChasmTaskTypeTypedSetting[T]) Validate(v any) error {

160 replicationResolverFactory namespace.ReplicationResolverFactory,

161 namespaceStateChangedFn namespace.NamespaceStateChangedFn,

162 > ) *registry { registry.go

163 > return &registry{

164 > persistence: aPersistence,

165 > globalNamespacesEnabled: enableGlobalNamespaces,

166 > currentClusterName: currentClusterName,

167 > clock: clock.NewRealTimeSource(),

168 > metricsHandler: metricsHandler.WithTags(metrics.OperationTag(metrics.NamespaceCacheScope)),

169 > logger: logger,

170 > nameToID: make(map[namespace.Name]namespace.ID),

171 > idToNamespace: make(map[namespace.ID]*namespace.Namespace),

172 > refreshInterval: refreshInterval,

173 > readthroughNotFoundCache: cache.New(readthroughCacheSize, &readthroughNotFoundCacheOpts),

174 >

175 > forceSearchAttributesCacheRefreshOnRead: forceSearchAttributesCacheRefreshOnRead,

176 > replicationResolverFactory: replicationResolverFactory,

177 > namespaceStateChangedFn: namespaceStateChangedFn,

178 > }

179 > }

180

181 // DefaultNamespaceStateChanged is the default implementation that checks whether a namespace

182 // state change is significant enough to trigger callbacks.

183 > func DefaultNamespaceStateChanged(currentClusterName string, oldNS *namespace.Namespace, newNS *namespace.Namespace) bool { registry.go

184 > return oldNS == nil ||

185 > oldNS.State() != newNS.State() ||

186 > oldNS.Name() != newNS.Name() ||

187 > oldNS.IsGlobalNamespace() != newNS.IsGlobalNamespace() ||

188 > //nolint:forbidigo // ns-wide state diff for cache invalidation.

189 > oldNS.ActiveInCluster(currentClusterName) != newNS.ActiveInCluster(currentClusterName) ||

190 > oldNS.ReplicationState("") != newNS.ReplicationState("")

191 > }

192

193 // GetRegistrySize observes the size of the by-name and by-ID maps.

215 // arrive. If not supported, falls back to periodic polling. Start blocks until the initial namespace refresh completes.

216 // The initial refresh must succeed or the function will fatal.

217 > func (r *registry) Start() { registry.go

218 > ctx := headers.SetCallerInfo(

219 > context.Background(),

220 > headers.SystemBackgroundHighCallerInfo,

221 > )

222 >

223 > watchStarted := false

224 > r.refresher, watchStarted = r.runWatchLoop(ctx)

225 > if watchStarted {

226 > // Watch started successfully registry.go

227 > return

228 > }

229

230 if err := r.refresher.Err(); !errors.Is(err, persistence.ErrWatchNotSupported) {

245 // Stop ends background refresh. Should only be invoked by fx lifecycle hook.

246 // Should not be called multiple times or concurrently with Start().

247 > func (r *registry) Stop() { registry.go

248 > // refresher may be nil if watch failed to start and we're shutting down.

249 > if r.refresher != nil {

250 > r.refresher.Cancel()

251 > <-r.refresher.Done()

252 > }

253 }

254

271 }

272

273 > func (r *registry) GetAllNamespaces() []*namespace.Namespace { registry.go

274 > r.nsMapsLock.RLock()

275 > defer r.nsMapsLock.RUnlock()

276 > return expmaps.Values(r.idToNamespace)

277 > }

278

279 > func (r *registry) RegisterStateChangeCallback(key any, cb namespace.StateChangeCallbackFn) { registry.go

280 > // Store callback first to avoid race where watch events arrive between reading the namespace snapshot and storing the

281 > // callback. This ensures no events are missed, but introduces a different trade-off: The callback may receive duplicate

282 > // calls for the same namespace if a watch event arrives while we're iterating through the catch-up loop below. For

283 > // example:

284 > // 1. Callback is stored in stateChangeCallbacks

285 > // 2. Watch event arrives for namespace X, callback is invoked

286 > // 3. Catch-up loop reaches namespace X, callback is invoked again

287 > //

288 > // This is acceptable because callbacks are rarely added (so unlikely to trigger this) and callbacks should be idempotent anyway.

289 > callbackWithTiming := func(ns *namespace.Namespace, deletedFromDb bool) {

290 > // Track callback duration so we can identify slow callbacks

291 > start := time.Now()

292 > defer func() {

293 > duration := time.Since(start)

294 > if duration > slowCallbackDuration {

295 metrics.NamespaceRegistrySlowCallbacks.With(r.metricsHandler).Record(1)

296 r.logger.Warn(

302 }()

303

304 > cb(ns, deletedFromDb) registry.go

305 }

306

307 > r.stateChangeCallbacks.Store(key, namespace.StateChangeCallbackFn(callbackWithTiming)) registry.go

308 >

309 > r.nsMapsLock.RLock()

310 > allNamespaces := expmaps.Values(r.idToNamespace)

311 > r.nsMapsLock.RUnlock()

312 >

313 > // call once for each namespace already in the registry

314 > for _, ns := range allNamespaces {

315 callbackWithTiming(ns, false)

316 }

323 // GetNamespace retrieves the information from the internal maps if it exists, otherwise retrieves the information from metadata

324 // store and update internal entries with an expiry before returning back

325 > func (r *registry) GetNamespace(name namespace.Name) (*namespace.Namespace, error) { registry.go

326 > if name == "" {

327 return nil, serviceerror.NewInvalidArgument("Namespace is empty.")

328 }

329 > return r.getOrReadthroughNamespace(name) registry.go

330 }

331

405 // watchLoop processes namespace watch events and handles restarts on failure.

406 // It returns when the context is cancelled or the watch channel is closed.

407 > func (r *registry) watchLoop(ctx context.Context, watchCh <-chan *persistence.NamespaceWatchEvent) { registry.go

408 > r.logger.Info("Starting namespace registry loop")

409 > for {

410 > select {

411 > case <-ctx.Done():

412 > return

413 case event, ok := <-watchCh:

414 var err error

433 // On initial startup (initialWatch=true), retries are limited to avoid blocking server startup indefinitely.

434 // On reconnection after a previous success (initialWatch=false), retries continue indefinitely.

435 > func watchStartRetryPolicy(initialWatch bool) backoff.RetryPolicy { registry.go

436 > policy := backoff.NewExponentialRetryPolicy(CacheRefreshFailureRetryInterval)

437 > if initialWatch {

438 > return policy.WithMaximumAttempts(startWatchMaxAttempts)

439 > }

440 return policy.WithExpirationInterval(backoff.NoInterval)

441 }

447 // Uses ShutdownOnce to track whether the watch has ever started successfully, which affects retry behavior: limited

448 // retries on initial startup, unlimited on reconnection.

449 > func (r *registry) runWatchLoop(ctx context.Context) (*goro.Handle, bool) { registry.go

450 > // watchStartedOnce tracks whether the watch has ever started successfully.

451 > // Used to determine retry policy and signal to the caller when watch is ready.

452 > watchStartedOnce := channel.NewShutdownOnce()

453 >

454 > handle := goro.NewHandle(ctx).Go(

455 > func(ctx context.Context) error {

456 > // Outer loop handles watch restarts after connection failures.

457 > for {

458 > select {

459 > case <-ctx.Done(): registry.go

460 > return nil

461 > default: registry.go

462 }

463

464 > result, err := r.startWatch(ctx, !watchStartedOnce.IsShutdown()) registry.go

465 > if err != nil {

466 return err

467 }

468

469 > watchStartedOnce.Shutdown() registry.go

470 > r.watchLoop(result.watchCtx, result.eventCh)

471 > result.watchCancel()

472 }

473 },

476 // Wait for either the watch to start successfully, or the goroutine to exit (due to error

477 // or because watch is not supported). Return true only if watch started successfully.

478 > select { registry.go

479 > case <-watchStartedOnce.Channel(): registry.go

480 > return handle, true

481 case <-handle.Done():

482 return handle, false

486 // startWatch attempts to establish a namespace watch with retries.

487 // Returns the watch channel and context on success.

488 > func (r *registry) startWatch(ctx context.Context, initialWatch bool) (watchStartResult, error) { registry.go

489 > return backoff.ThrottleRetryContextWithReturn(

490 > ctx,

491 > func(ctx context.Context) (startResult watchStartResult, err error) {

492 > // Create fresh watch context for this attempt

493 > watchCtx, watchCancel := context.WithCancel(ctx)

494 > defer func() {

495 > if err != nil {

496 > // Cancel attempt's watch context to clean up any partial watch state registry.go

497 > watchCancel()

498 > }

499 }()

500

501 > startResult.watchCtx = watchCtx registry.go

502 > startResult.watchCancel = watchCancel

503 >

504 > if startResult.eventCh, err = r.persistence.WatchNamespaces(watchCtx); err != nil {

505 if !errors.Is(err, persistence.ErrWatchNotSupported) {

506 r.logger.Error("Error starting namespace watch", tag.Error(err))

511 // A full refresh must be done *after* (not before) the watch is established to ensure no updates are missed. If the

512 // refresh were done before establishing the watch, updates that occur between the two could be missed.

513 > r.logger.Info("Namespace watch started") registry.go

514 > if err = r.refreshNamespaces(ctx); err != nil {

515 > r.logger.Error("Error refreshing namespaces after watch start", tag.Error(err)) registry.go

516 > return

517 > }

518 > r.logger.Info("Initial refresh completed") registry.go

519 >

520 > return

521 },

522 watchStartRetryPolicy(initialWatch),

523 > func(err error) bool { registry.go

524 > return !errors.Is(err, persistence.ErrWatchNotSupported)

525 > },

526 )

527 }

554 }

555

556 > func (r *registry) refreshNamespaces(ctx context.Context) (err error) { registry.go

557 > start := time.Now()

558 > defer func() {

559 > if err != nil {

560 > metrics.NamespaceRegistryRefreshFailures.With(r.metricsHandler).Record(1) registry.go

561 > }

562 > metrics.NamespaceRegistryRefreshLatency.With(r.metricsHandler).Record(time.Since(start)) registry.go

563 }()

564

565 > request := &persistence.ListNamespacesRequest{ registry.go

566 > PageSize: CacheRefreshPageSize,

567 > IncludeDeleted: true,

568 > }

569 > var namespacesDb namespace.Namespaces

570 > namespaceIDsDb := make(map[namespace.ID]struct{})

571 >

572 > for {

573 > // TODO: consider adding a timeout and/or retries here - long ListNamespaces

574 > // calls could delay watch reconnection or block shutdown

575 > response, err := r.persistence.ListNamespaces(ctx, request)

576 > if err != nil {

577 > return err registry.go

578 > }

579 > for _, namespaceDb := range response.Namespaces { registry.go

580 > ns, err := namespace.FromPersistentState( registry.go

581 > namespaceDb.Namespace,

582 > r.replicationResolverFactory(namespaceDb.Namespace),

583 > namespace.WithGlobalFlag(namespaceDb.IsGlobalNamespace),

584 > namespace.WithNotificationVersion(namespaceDb.NotificationVersion),

585 > )

586 > if err != nil {

587 return err

588 }

589 > namespacesDb = append(namespacesDb, ns) registry.go

590 > namespaceIDsDb[namespace.ID(namespaceDb.Namespace.Info.Id)] = struct{}{}

591 }

592 > if len(response.NextPageToken) == 0 { registry.go

593 > break

594 }

595 > request.NextPageToken = response.NextPageToken registry.go

596 }

597

598 // Make a copy of the existing namespace maps (excluding deleted), so we can calculate diff and do atomic swap.

599 > newNameToID := make(map[namespace.Name]namespace.ID) registry.go

600 > newIDToNamespace := make(map[namespace.ID]*namespace.Namespace)

601 >

602 > var deletedEntries []*namespace.Namespace

603 > for _, ns := range r.GetAllNamespaces() {

604 if _, namespaceExistsDb := namespaceIDsDb[ns.ID()]; !namespaceExistsDb {

605 deletedEntries = append(deletedEntries, ns)

610 }

611

612 > var stateChanged []*namespace.Namespace registry.go

613 > for _, aNamespace := range namespacesDb {

614 > oldNS := r.updateIDToNamespace(newIDToNamespace, aNamespace.ID(), aNamespace) registry.go

615 > // If namespace was renamed, remove entry for the old name

616 > if oldNS != nil && oldNS.Name() != aNamespace.Name() {

617 delete(newNameToID, oldNS.Name())

618 }

619 > newNameToID[aNamespace.Name()] = aNamespace.ID() registry.go

620 >

621 > if r.namespaceStateChanged(oldNS, aNamespace) {

622 > stateChanged = append(stateChanged, aNamespace)

623 > }

624 }

625

626 > r.nsMapsLock.Lock() registry.go

627 > totalNamespaceCount := len(newIDToNamespace) // record metric value within lock boundary

628 > r.idToNamespace = newIDToNamespace

629 > r.nameToID = newNameToID

630 > stateChanged = append(stateChanged, r.stateChangedDuringReadthrough...)

631 > r.stateChangedDuringReadthrough = nil

632 > r.nsMapsLock.Unlock()

633 >

634 > metrics.TotalNamespaces.With(r.metricsHandler).Record(float64(totalNamespaceCount))

635 >

636 > r.stateChangeCallbacks.Range(

637 > func(_, value any) bool {

638 > //revive:disable-next-line:unchecked-type-assertion registry.go

639 > cb := value.(namespace.StateChangeCallbackFn)

640 >

641 > for _, ns := range deletedEntries {

642 cb(ns, true)

643 }

644 > for _, ns := range stateChanged { registry.go

645 > cb(ns, false) registry.go

646 > }

647

648 > return true registry.go

649 })

650

651 > return nil registry.go

652 }

653

714 id namespace.ID,

715 newNS *namespace.Namespace,

716 > ) *namespace.Namespace { registry.go

717 > oldNS := iDToNamespace[id]

718 > iDToNamespace[id] = newNS

719 > return oldNS

720 > }

721

722 // getNamespace retrieves the information from the cache if it exists

723 > func (r *registry) getNamespace(name namespace.Name) (*namespace.Namespace, error) { registry.go

724 > r.nsMapsLock.RLock()

725 > defer r.nsMapsLock.RUnlock()

726 > if id, ok := r.nameToID[name]; ok {

727 > return r.getNamespaceByIDLocked(id) registry.go

728 > }

729 return nil, serviceerror.NewNamespaceNotFound(name.String())

730 }

737 }

738

739 > func (r *registry) getNamespaceByIDLocked(id namespace.ID) (*namespace.Namespace, error) { registry.go

740 > if ns, ok := r.idToNamespace[id]; ok {

741 > return ns, nil registry.go

742 > }

743 return nil, serviceerror.NewNamespaceNotFound(id.String())

744 }

746 // getOrReadthroughNamespace returns namespace information if it exists or reads through

747 // to the persistence layer and updates internal entry if it doesn't

748 > func (r *registry) getOrReadthroughNamespace(name namespace.Name) (*namespace.Namespace, error) { registry.go

749 > // check main caches

750 > ns, err := r.getNamespace(name)

751 > if err == nil {

752 > return ns, nil registry.go

753 > }

754

755 r.readthroughLock.Lock()

894 }

895

896 > func (r *registry) namespaceStateChanged(oldNS *namespace.Namespace, newNS *namespace.Namespace) bool { registry.go

897 > return r.namespaceStateChangedFn(r.currentClusterName, oldNS, newNS)

898 > }