TestScheduledUpdates

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 {

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 {

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 {

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 {

84 joinTime time.Time,

85 replicaPoints int,

86 > ) *monitor { monitor.go

87 > lifecycleCtx, lifecycleCancel := context.WithCancel(context.Background())

88 > lifecycleCtx = headers.SetCallerInfo(

89 > lifecycleCtx,

90 > headers.SystemBackgroundHighCallerInfo,

91 > )

92 > hostID, _ := uuid.New().MarshalBinary()

93 > // MarshalBinary should never error.

94 >

95 > rpo := &monitor{

96 > status: common.DaemonStatusInitialized,

97 >

98 > lifecycleCtx: lifecycleCtx,

99 > lifecycleCancel: lifecycleCancel,

100 >

101 > serviceName: serviceName,

102 > services: services,

103 > rp: rp,

104 > rings: make(map[primitives.ServiceName]*serviceResolver),

105 > replicaPoints: replicaPoints,

106 > logger: logger,

107 > metadataManager: metadataManager,

108 > broadcastHostPortResolver: broadcastHostPortResolver,

109 > hostID: hostID,

110 > initialized: future.NewFuture[struct{}](),

111 > maxJoinDuration: maxJoinDuration,

112 > propagationTime: propagationTime,

113 > joinTime: joinTime,

114 > }

115 > for service, port := range services {

116 > rpo.rings[service] = newServiceResolver(service, port, rp, replicaPoints, logger)

117 > }

118 > return rpo

119 }

120

122 // it's safe for Stop() to run, which is at any point when we are neither updating the status field nor

123 // starting rings

124 > func (rpo *monitor) Start() { monitor.go

125 > rpo.stateLock.Lock()

126 > if rpo.status != common.DaemonStatusInitialized {

127 rpo.stateLock.Unlock()

128 return

129 }

130 > rpo.status = common.DaemonStatusStarted monitor.go

131 > rpo.stateLock.Unlock()

132 >

133 > broadcastAddress, err := rpo.broadcastHostPortResolver()

134 > if err != nil {

135 rpo.logger.Fatal("unable to resolve broadcast address", tag.Error(err))

136 }

140 // we must know our seed nodes before bootstrapping

141

142 > if err = rpo.startHeartbeat(broadcastAddress); err != nil { monitor.go

143 rpo.logger.Fatal("unable to initialize membership heartbeats", tag.Error(err))

144 }

145

146 > if err = rpo.bootstrapRingPop(); err != nil { monitor.go

147 // Stop() called during Start()'s execution. This is ok

148 if strings.Contains(err.Error(), "destroyed while attempting to join") {

152 }

153

154 > labels, err := rpo.rp.Labels() monitor.go

155 > if err != nil {

156 rpo.logger.Fatal("unable to get ringpop labels", tag.Error(err))

157 }

158

159 > if until := time.Until(rpo.joinTime); until > 0 && until.Seconds() < maxScheduledEventTimeSeconds { monitor.go

160 > if err = labels.Set(startAtKey, strconv.FormatInt(rpo.joinTime.Unix(), 10)); err != nil { monitor.go

161 rpo.logger.Fatal("unable to set ringpop label", tag.Error(err), tag.Key(startAtKey))

162 }

164 // The jitter doesn't really matter, but if two nodes join/leave at the same aligned

165 // time, it just spreads out the membership gossip traffic a little bit.

166 > clearAfter := until + backoff.Jitter(2*rpo.propagationTime, 0.2) monitor.go

167 > time.AfterFunc(clearAfter, rpo.clearStartAt)

168 }

169

170 > if err = labels.Set(portKey, strconv.Itoa(rpo.services[rpo.serviceName])); err != nil { monitor.go

171 rpo.logger.Fatal("unable to set ringpop label", tag.Error(err), tag.Key(portKey))

172 }

173

174 // This label should be set last, it's used as the prediciate for finding members for rings.

175 > if err = labels.Set(roleKey, string(rpo.serviceName)); err != nil { monitor.go

176 rpo.logger.Fatal("unable to set ringpop label", tag.Error(err), tag.Key(roleKey))

177 }

178

179 // Our individual rings may not support concurrent start/stop calls so we reacquire the state lock while acting upon them

180 > rpo.stateLock.Lock() monitor.go

181 > for _, ring := range rpo.rings {

182 > ring.Start()

183 > }

184 > rpo.stateLock.Unlock()

185 >

186 > rpo.initialized.Set(struct{}{}, nil)

187 }

188

189 // bootstrap ring pop service by discovering the bootstrap hosts and joining the ring pop cluster

190 > func (rpo *monitor) bootstrapRingPop() error { monitor.go

191 > policy := backoff.NewExponentialRetryPolicy(healthyHostLastHeartbeatCutoff / 2).

192 > WithBackoffCoefficient(1).

193 > WithMaximumAttempts(maxBootstrapRetries)

194 > op := func() error {

195 > hostPorts, err := rpo.fetchCurrentBootstrapHostports()

196 > if err != nil {

197 return err

198 }

199

200 > bootParams := &swim.BootstrapOptions{ monitor.go

201 > ParallelismFactor: 10,

202 > JoinSize: 1,

203 > MaxJoinDuration: rpo.maxJoinDuration,

204 > DiscoverProvider: statichosts.New(hostPorts...),

205 > }

206 >

207 > _, err = rpo.rp.Bootstrap(bootParams)

208 > if err != nil {

209 rpo.logger.Warn("unable to bootstrap ringpop. retrying", tag.Error(err))

210 }

211 > return err monitor.go

212 }

213

214 > if err := backoff.ThrottleRetry(op, policy, nil); err != nil { monitor.go

215 return fmt.Errorf("exhausted all retries: %w", err)

216 }

217 > return nil monitor.go

218 }

219

234 ctx context.Context,

235 request *persistence.UpsertClusterMembershipRequest,

236 > ) error { monitor.go

237 > err := rpo.metadataManager.UpsertClusterMembership(ctx, request)

238 >

239 > if err == nil {

240 > hostID, err := uuid.FromBytes(request.HostID)

241 > if err != nil {

242 return err

243 }

244 > rpo.logger.Debug("Membership heartbeat upserted successfully", monitor.go

245 > tag.Address(request.RPCAddress.String()),

246 > tag.Port(int(request.RPCPort)),

247 > tag.HostID(hostID.String()))

248 }

249

250 > return err monitor.go

251 }

252

253 // splitHostPortTyped expands upon net.SplitHostPort by providing type parsing.

254 > func splitHostPortTyped(hostPort string) (net.IP, uint16, error) { monitor.go

255 > ipstr, portstr, err := net.SplitHostPort(hostPort)

256 > if err != nil {

257 return nil, 0, err

258 }

259

260 > broadcastAddress := net.ParseIP(ipstr) monitor.go

261 > broadcastPort, err := strconv.ParseUint(portstr, 10, 16)

262 > if err != nil {

263 return nil, 0, err

264 }

265

266 > return broadcastAddress, uint16(broadcastPort), nil monitor.go

267 }

268

269 > func (rpo *monitor) startHeartbeat(broadcastHostport string) error { monitor.go

270 > // Start by cleaning up expired records to avoid growth

271 > err := rpo.metadataManager.PruneClusterMembership(rpo.lifecycleCtx, &persistence.PruneClusterMembershipRequest{MaxRecordsPruned: 10})

272 > if err != nil {

273 return err

274 }

275

276 > sessionStarted := time.Now().UTC() monitor.go

277 >

278 > // Parse and validate broadcast hostport

279 > broadcastAddress, broadcastPort, err := splitHostPortTyped(broadcastHostport)

280 > if err != nil {

281 return err

282 }

283

284 // Parse and validate existing service name

285 > role, err := serviceNameToServiceTypeEnum(rpo.serviceName) monitor.go

286 > if err != nil {

287 return err

288 }

289

290 > req := &persistence.UpsertClusterMembershipRequest{ monitor.go

291 > Role: role,

292 > RPCAddress: broadcastAddress,

293 > RPCPort: broadcastPort,

294 > SessionStart: sessionStarted,

295 > RecordExpiry: upsertMembershipRecordExpiryDefault,

296 > HostID: rpo.hostID,

297 > }

298 >

299 > // Upsert before fetching bootstrap hosts.

300 > // This makes us discoverable by other Temporal cluster members

301 > // Expire in 48 hours to allow for inspection of table by humans for debug scenarios.

302 > // For bootstrapping, we filter to a much shorter duration on the

303 > // read side by filtering on the last time a heartbeat was seen.

304 > err = rpo.upsertMyMembership(rpo.lifecycleCtx, req)

305 > if err == nil {

306 > hostID, err := uuid.FromBytes(rpo.hostID)

307 > if err != nil {

308 return err

309 }

310 > rpo.logger.Info("Membership heartbeat upserted successfully", monitor.go

311 > tag.Address(broadcastAddress.String()),

312 > tag.Port(int(broadcastPort)),

313 > tag.HostID(hostID.String()))

314 >

315 > rpo.startHeartbeatUpsertLoop(req)

316 }

317

318 > return err monitor.go

319 }

320

321 > func (rpo *monitor) fetchCurrentBootstrapHostports() ([]string, error) { monitor.go

322 > pageSize := 1000

323 > set := make(map[string]struct{})

324 >

325 > var nextPageToken []byte

326 >

327 > for {

328 > resp, err := rpo.metadataManager.GetClusterMembers(

329 > rpo.lifecycleCtx,

330 > &persistence.GetClusterMembersRequest{

331 > LastHeartbeatWithin: healthyHostLastHeartbeatCutoff,

332 > PageSize: pageSize,

333 > NextPageToken: nextPageToken,

334 > })

335 > if err != nil {

336 return nil, err

337 }

338

339 // Dedupe on hostport

340 > for _, host := range resp.ActiveMembers { monitor.go

341 > set[net.JoinHostPort(host.RPCAddress.String(), convert.Uint16ToString(host.RPCPort))] = struct{}{}

342 > }

343 > nextPageToken = resp.NextPageToken

344 >

345 > // Stop iterating once we have either 500 unique ip:port combos or there is no more results.

346 > if len(nextPageToken) == 0 || len(set) >= 500 {

347 > bootstrapHostPorts := make([]string, 0, len(set))

348 > for k := range set {

349 > bootstrapHostPorts = append(bootstrapHostPorts, k)

350 > }

351

352 > rpo.logger.Info("bootstrap hosts fetched", tag.BootstrapHostPorts(strings.Join(bootstrapHostPorts, ","))) monitor.go

353 > return bootstrapHostPorts, nil

354 }

355 }

356 }

357

358 > func (rpo *monitor) startHeartbeatUpsertLoop(request *persistence.UpsertClusterMembershipRequest) { monitor.go

359 > loopUpsertMembership := func() {

360 > for {

361 > select {

362 case <-rpo.lifecycleCtx.Done():

363 return

364 > default: monitor.go

365 }

366 > err := rpo.upsertMyMembership(rpo.lifecycleCtx, request) monitor.go

367 > if err != nil {

368 rpo.logger.Error("Membership upsert failed.", tag.Error(err))

369 }

370

371 > jitter := math.Round(rand.Float64() * 5) monitor.go

372 > time.Sleep(time.Second * time.Duration(10+jitter))

373 }

374 }

375

376 > go loopUpsertMembership() monitor.go

377 }

378

380 // for the entire call as the individual ring Start/Stop functions may not be safe to

381 // call concurrently

382 > func (rpo *monitor) Stop() { monitor.go

383 > rpo.stateLock.Lock()

384 > defer rpo.stateLock.Unlock()

385 > if rpo.status != common.DaemonStatusStarted {

386 return

387 }

388 > rpo.status = common.DaemonStatusStopped monitor.go

389 >

390 > rpo.lifecycleCancel()

391 >

392 > for _, ring := range rpo.rings {

393 > ring.Stop()

394 > }

395

396 > rpo.rp.Destroy() monitor.go

397 }

398

401 }

402

403 > func (rpo *monitor) EvictSelfAt(asOf time.Time) (time.Duration, error) { monitor.go

404 > until := time.Until(asOf)

405 > if until <= 0 || until.Seconds() >= maxScheduledEventTimeSeconds {

406 return 0, rpo.rp.SelfEvict()

407 }

408 // set label for eviction time in the future

409 > labels, err := rpo.rp.Labels() monitor.go

410 > if err != nil {

411 rpo.logger.Error("unable to set ringpop label", tag.Error(err), tag.Key(stopAtKey))

412 return 0, err

413 }

414 > err = labels.Set(stopAtKey, strconv.FormatInt(asOf.Unix(), 10)) monitor.go

415 > if err != nil {

416 rpo.logger.Error("unable to set ringpop label", tag.Error(err), tag.Key(stopAtKey))

417 return 0, err

420 // The jitter doesn't really matter, but if two nodes join/leave at the same aligned time,

421 // it just spreads out the membership gossip traffic a little bit.

422 > leaveAfter := until + backoff.Jitter(rpo.propagationTime, 0.2) monitor.go

423 > time.AfterFunc(leaveAfter, func() { _ = rpo.rp.SelfEvict() })

424 > return leaveAfter + rpo.propagationTime, nil

425 }

426

427 > func (rpo *monitor) GetResolver(service primitives.ServiceName) (membership.ServiceResolver, error) { monitor.go

428 > ring, found := rpo.rings[service]

429 > if !found {

430 return nil, membership.ErrUnknownService

431 }

432 > return ring, nil monitor.go

433 }

434

450 }

451

452 > func replaceServicePort(address string, servicePort int) (string, error) { monitor.go

453 > host, _, err := net.SplitHostPort(address)

454 > if err != nil {

455 return "", membership.ErrIncorrectAddressFormat

456 }

457 > return net.JoinHostPort(host, convert.IntToString(servicePort)), nil monitor.go

458 }

459

463

464 // RegisterServiceNameToServiceTypeEnum must be called from a static init().

465 > func RegisterServiceNameToServiceTypeEnum(serviceName primitives.ServiceName, serviceType persistence.ServiceType) { monitor.go

466 > serviceNameToServiceTypeEnumMap[serviceName] = serviceType

467 > }

468

469 > func init() { monitor.go

470 > RegisterServiceNameToServiceTypeEnum(primitives.AllServices, persistence.All)

471 > RegisterServiceNameToServiceTypeEnum(primitives.FrontendService, persistence.Frontend)

472 > RegisterServiceNameToServiceTypeEnum(primitives.InternalFrontendService, persistence.InternalFrontend)

473 > RegisterServiceNameToServiceTypeEnum(primitives.HistoryService, persistence.History)

474 > RegisterServiceNameToServiceTypeEnum(primitives.MatchingService, persistence.Matching)

475 > RegisterServiceNameToServiceTypeEnum(primitives.WorkerService, persistence.Worker)

476 > }

477

478 > func serviceNameToServiceTypeEnum(name primitives.ServiceName) (persistence.ServiceType, error) { monitor.go

479 > if serviceType, ok := serviceNameToServiceTypeEnumMap[name]; ok {

480 > return serviceType, nil

481 > }

482

483 return persistence.All, fmt.Errorf("unable to parse servicename '%s'", name)