dynamicconfig

package
v1.13.4 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Feb 10, 2022 License: MIT Imports: 16 Imported by: 13

Documentation

Overview

Package dynamicconfig is a generated GoMock package.

Index

Constants

View Source 
const DefaultNumTaskQueuePartitions = 4

Variables

View Source 
var Keys = map[Key]string{
	// contains filtered or unexported fields

}/* 246 elements not displayed */

Keys represents a mapping from Key to keyName, where keyName are used dynamic config source.

Functions

func GetBoolPropertyFn 

func GetBoolPropertyFn(value bool) func(opts ...FilterOption) bool

GetBoolPropertyFn returns value as BoolPropertyFn

func GetBoolPropertyFnFilteredByNamespace 

func GetBoolPropertyFnFilteredByNamespace(value bool) func(namespace string) bool

GetBoolPropertyFnFilteredByNamespace returns value as BoolPropertyFnWithNamespaceFilters

func GetDurationPropertyFn 

func GetDurationPropertyFn(value time.Duration) func(opts ...FilterOption) time.Duration

GetDurationPropertyFn returns value as DurationPropertyFn

func GetDurationPropertyFnFilteredByNamespace 

func GetDurationPropertyFnFilteredByNamespace(value time.Duration) func(namespace string) time.Duration

GetDurationPropertyFnFilteredByNamespace returns value as DurationPropertyFnFilteredByNamespace

func GetDurationPropertyFnFilteredByTaskQueueInfo 

func GetDurationPropertyFnFilteredByTaskQueueInfo(value time.Duration) func(namespace string, taskQueue string, taskType enumspb.TaskQueueType) time.Duration

GetDurationPropertyFnFilteredByTaskQueueInfo returns value as DurationPropertyFnWithTaskQueueInfoFilters

func GetFloatPropertyFn 

func GetFloatPropertyFn(value float64) func(opts ...FilterOption) float64

GetFloatPropertyFn returns value as FloatPropertyFn

func GetIntPropertyFilteredByNamespace 

func GetIntPropertyFilteredByNamespace(value int) func(namespace string) int

GetIntPropertyFilteredByNamespace returns values as IntPropertyFnWithNamespaceFilters

func GetIntPropertyFilteredByTaskQueueInfo 

func GetIntPropertyFilteredByTaskQueueInfo(value int) func(namespace string, taskQueue string, taskType enumspb.TaskQueueType) int

GetIntPropertyFilteredByTaskQueueInfo returns value as IntPropertyFnWithTaskQueueInfoFilters

func GetIntPropertyFn 

func GetIntPropertyFn(value int) func(opts ...FilterOption) int

GetIntPropertyFn returns value as IntPropertyFn

func GetMapPropertyFn 

func GetMapPropertyFn(value map[string]interface{}) func(opts ...FilterOption) map[string]interface{}

GetMapPropertyFn returns value as MapPropertyFn

func GetMapPropertyFnWithNamespaceFilter 

func GetMapPropertyFnWithNamespaceFilter(value map[string]interface{}) func(namespace string) map[string]interface{}

GetMapPropertyFnWithNamespaceFilter returns value as MapPropertyFn

func GetStringPropertyFn 

func GetStringPropertyFn(value string) func(opts ...FilterOption) string

GetStringPropertyFn returns value as StringPropertyFn

func NewNoopClient 

func NewNoopClient() *noopClient

NewNoopClient creates a nop client

Types

type BoolPropertyFn 

type BoolPropertyFn func(opts ...FilterOption) bool

BoolPropertyFn is a wrapper to get bool property from dynamic config

type BoolPropertyFnWithNamespaceFilter 

type BoolPropertyFnWithNamespaceFilter func(namespace string) bool

BoolPropertyFnWithNamespaceFilter is a wrapper to get bool property from dynamic config

type BoolPropertyFnWithNamespaceIDFilter 

type BoolPropertyFnWithNamespaceIDFilter func(id string) bool

BoolPropertyFnWithNamespaceIDFilter is a wrapper to get bool property from dynamic config

type BoolPropertyFnWithTaskQueueInfoFilters 

type BoolPropertyFnWithTaskQueueInfoFilters func(namespace string, taskQueue string, taskType enumspb.TaskQueueType) bool

BoolPropertyFnWithTaskQueueInfoFilters is a wrapper to get bool property from dynamic config with three filters: namespace, taskQueue, taskType

type Client 

type Client interface {
	GetValue(name Key, defaultValue interface{}) (interface{}, error)
	GetValueWithFilters(name Key, filters map[Filter]interface{}, defaultValue interface{}) (interface{}, error)

	GetIntValue(name Key, filters map[Filter]interface{}, defaultValue int) (int, error)
	GetFloatValue(name Key, filters map[Filter]interface{}, defaultValue float64) (float64, error)
	GetBoolValue(name Key, filters map[Filter]interface{}, defaultValue bool) (bool, error)
	GetStringValue(name Key, filters map[Filter]interface{}, defaultValue string) (string, error)
	GetMapValue(
		name Key, filters map[Filter]interface{}, defaultValue map[string]interface{},
	) (map[string]interface{}, error)
	GetDurationValue(
		name Key, filters map[Filter]interface{}, defaultValue time.Duration,
	) (time.Duration, error)
}

Client allows fetching values from a dynamic configuration system NOTE: This does not have async options right now. In the interest of keeping it minimal, we can add when requirement arises.

func NewFileBasedClient 

func NewFileBasedClient(config *FileBasedClientConfig, logger log.Logger, doneCh <-chan interface{}) (Client, error)

NewFileBasedClient creates a file based client.

type Collection 

type Collection struct {
	// contains filtered or unexported fields
}

Collection wraps dynamic config client with a closure so that across the code, the config values can be directly accessed by calling the function without propagating the client everywhere in code

func NewCollection 

func NewCollection(client Client, logger log.Logger) *Collection

NewCollection creates a new collection

func NewNoopCollection 

func NewNoopCollection() *Collection

NewNoopCollection creates a new nop collection

func (*Collection) GetBoolProperty 

func (c *Collection) GetBoolProperty(key Key, defaultValue bool) BoolPropertyFn

GetBoolProperty gets property and asserts that it's an bool

func (*Collection) GetBoolPropertyFilteredByTaskQueueInfo 

func (c *Collection) GetBoolPropertyFilteredByTaskQueueInfo(key Key, defaultValue bool) BoolPropertyFnWithTaskQueueInfoFilters

GetBoolPropertyFilteredByTaskQueueInfo gets property with taskQueueInfo as filters and asserts that it's an bool

func (*Collection) GetBoolPropertyFnWithNamespaceFilter 

func (c *Collection) GetBoolPropertyFnWithNamespaceFilter(key Key, defaultValue bool) BoolPropertyFnWithNamespaceFilter

GetBoolPropertyFnWithNamespaceFilter gets property with namespace filter and asserts that its namespace

func (*Collection) GetBoolPropertyFnWithNamespaceIDFilter 

func (c *Collection) GetBoolPropertyFnWithNamespaceIDFilter(key Key, defaultValue bool) BoolPropertyFnWithNamespaceIDFilter

GetBoolPropertyFnWithNamespaceIDFilter gets property with namespaceID filter and asserts that it's a bool

func (*Collection) GetDurationProperty 

func (c *Collection) GetDurationProperty(key Key, defaultValue time.Duration) DurationPropertyFn

GetDurationProperty gets property and asserts that it's a duration

func (*Collection) GetDurationPropertyFilteredByNamespace 

func (c *Collection) GetDurationPropertyFilteredByNamespace(key Key, defaultValue time.Duration) DurationPropertyFnWithNamespaceFilter

GetDurationPropertyFilteredByNamespace gets property with namespace filter and asserts that it's a duration

func (*Collection) GetDurationPropertyFilteredByNamespaceID 

func (c *Collection) GetDurationPropertyFilteredByNamespaceID(key Key, defaultValue time.Duration) DurationPropertyFnWithNamespaceIDFilter

GetDurationPropertyFilteredByNamespaceID gets property with namespaceID filter and asserts that it's a duration

func (*Collection) GetDurationPropertyFilteredByShardID 

func (c *Collection) GetDurationPropertyFilteredByShardID(key Key, defaultValue time.Duration) DurationPropertyFnWithShardIDFilter

GetDurationPropertyFilteredByShardID gets property with shardID id as filter and asserts that it's a duration

func (*Collection) GetDurationPropertyFilteredByTaskQueueInfo 

func (c *Collection) GetDurationPropertyFilteredByTaskQueueInfo(key Key, defaultValue time.Duration) DurationPropertyFnWithTaskQueueInfoFilters

GetDurationPropertyFilteredByTaskQueueInfo gets property with taskQueueInfo as filters and asserts that it's a duration

func (*Collection) GetFloat64Property 

func (c *Collection) GetFloat64Property(key Key, defaultValue float64) FloatPropertyFn

GetFloat64Property gets property and asserts that it's a float64

func (*Collection) GetFloat64PropertyFilteredByShardID 

func (c *Collection) GetFloat64PropertyFilteredByShardID(key Key, defaultValue float64) FloatPropertyFnWithShardIDFilter

GetFloat64PropertyFilteredByShardID gets property with shardID filter and asserts that it's a float64

func (*Collection) GetFloatPropertyFilteredByNamespace 

func (c *Collection) GetFloatPropertyFilteredByNamespace(key Key, defaultValue float64) FloatPropertyFnWithNamespaceFilter

GetFloatPropertyFilteredByNamespace gets property with namespace filter and asserts that it's a float

func (*Collection) GetFloatPropertyFilteredByTaskQueueInfo 

func (c *Collection) GetFloatPropertyFilteredByTaskQueueInfo(key Key, defaultValue float64) FloatPropertyFnWithTaskQueueInfoFilters

GetFloatPropertyFilteredByTaskQueueInfo gets property with taskQueueInfo as filters and asserts that it's an integer

func (*Collection) GetIntProperty 

func (c *Collection) GetIntProperty(key Key, defaultValue int) IntPropertyFn

GetIntProperty gets property and asserts that it's an integer

func (*Collection) GetIntPropertyFilteredByNamespace 

func (c *Collection) GetIntPropertyFilteredByNamespace(key Key, defaultValue int) IntPropertyFnWithNamespaceFilter

GetIntPropertyFilteredByNamespace gets property with namespace filter and asserts that it's an integer

func (*Collection) GetIntPropertyFilteredByShardID 

func (c *Collection) GetIntPropertyFilteredByShardID(key Key, defaultValue int) IntPropertyFnWithShardIDFilter

GetIntPropertyFilteredByShardID gets property with shardID as filter and asserts that it's an integer

func (*Collection) GetIntPropertyFilteredByTaskQueueInfo 

func (c *Collection) GetIntPropertyFilteredByTaskQueueInfo(key Key, defaultValue int) IntPropertyFnWithTaskQueueInfoFilters

GetIntPropertyFilteredByTaskQueueInfo gets property with taskQueueInfo as filters and asserts that it's an integer

func (*Collection) GetMapProperty 

func (c *Collection) GetMapProperty(key Key, defaultValue map[string]interface{}) MapPropertyFn

GetMapProperty gets property and asserts that it's a map

func (*Collection) GetMapPropertyFnWithNamespaceFilter 

func (c *Collection) GetMapPropertyFnWithNamespaceFilter(key Key, defaultValue map[string]interface{}) MapPropertyFnWithNamespaceFilter

GetMapPropertyFnWithNamespaceFilter gets property and asserts that it's a map

func (*Collection) GetProperty 

func (c *Collection) GetProperty(key Key, defaultValue interface{}) PropertyFn

GetProperty gets a interface property and returns defaultValue if property is not found

func (*Collection) GetStringProperty 

func (c *Collection) GetStringProperty(key Key, defaultValue string) StringPropertyFn

GetStringProperty gets property and asserts that it's an string

func (*Collection) GetStringPropertyFnWithNamespaceFilter 

func (c *Collection) GetStringPropertyFnWithNamespaceFilter(key Key, defaultValue string) StringPropertyFnWithNamespaceFilter

GetStringPropertyFnWithNamespaceFilter gets property with namespace filter and asserts that its namespace

type DurationPropertyFn 

type DurationPropertyFn func(opts ...FilterOption) time.Duration

DurationPropertyFn is a wrapper to get duration property from dynamic config

type DurationPropertyFnWithNamespaceFilter 

type DurationPropertyFnWithNamespaceFilter func(namespace string) time.Duration

DurationPropertyFnWithNamespaceFilter is a wrapper to get duration property from dynamic config with namespace as filter

type DurationPropertyFnWithNamespaceIDFilter 

type DurationPropertyFnWithNamespaceIDFilter func(namespaceID string) time.Duration

DurationPropertyFnWithNamespaceIDFilter is a wrapper to get duration property from dynamic config with namespaceID as filter

type DurationPropertyFnWithShardIDFilter 

type DurationPropertyFnWithShardIDFilter func(shardID int32) time.Duration

DurationPropertyFnWithShardIDFilter is a wrapper to get duration property from dynamic config with shardID as filter

type DurationPropertyFnWithTaskQueueInfoFilters 

type DurationPropertyFnWithTaskQueueInfoFilters func(namespace string, taskQueue string, taskType enumspb.TaskQueueType) time.Duration

DurationPropertyFnWithTaskQueueInfoFilters is a wrapper to get duration property from dynamic config with three filters: namespace, taskQueue, taskType

type FileBasedClientConfig 

type FileBasedClientConfig struct {
	Filepath     string        `yaml:"filepath"`
	PollInterval time.Duration `yaml:"pollInterval"`
}

FileBasedClientConfig is the config for the file based dynamic config client. It specifies where the config file is stored and how often the config should be updated by checking the config file again.

type Filter 

type Filter int

Filter represents a filter on the dynamic config key 

const (

	// Namespace is the namespace name
	Namespace Filter
	// NamespaceID is the namespace Id
	NamespaceID
	// TaskQueueName is the taskqueue name
	TaskQueueName
	// TaskType is the task type (0:Workflow, 1:Activity)
	TaskType
	// ShardID is the shard id
	ShardID
)

func (Filter) String 

func (f Filter) String() string

type FilterOption 

type FilterOption func(filterMap map[Filter]interface{})

FilterOption is used to provide filters for dynamic config keys

func NamespaceFilter 

func NamespaceFilter(name string) FilterOption

NamespaceFilter filters by namespace name

func NamespaceIDFilter 

func NamespaceIDFilter(namespaceID string) FilterOption

NamespaceIDFilter filters by namespace id

func ShardIDFilter 

func ShardIDFilter(shardID int32) FilterOption

ShardIDFilter filters by shard id

func TaskQueueFilter 

func TaskQueueFilter(name string) FilterOption

TaskQueueFilter filters by task queue name

func TaskTypeFilter 

func TaskTypeFilter(taskType enumspb.TaskQueueType) FilterOption

TaskTypeFilter filters by task type

type FloatPropertyFn 

type FloatPropertyFn func(opts ...FilterOption) float64

FloatPropertyFn is a wrapper to get float property from dynamic config

type FloatPropertyFnWithNamespaceFilter 

type FloatPropertyFnWithNamespaceFilter func(namespace string) float64

FloatPropertyFnWithNamespaceFilter is a wrapper to get float property from dynamic config with namespace as filter

type FloatPropertyFnWithShardIDFilter 

type FloatPropertyFnWithShardIDFilter func(shardID int32) float64

FloatPropertyFnWithShardIDFilter is a wrapper to get float property from dynamic config with shardID as filter

type FloatPropertyFnWithTaskQueueInfoFilters 

type FloatPropertyFnWithTaskQueueInfoFilters func(namespace string, taskQueue string, taskType enumspb.TaskQueueType) float64

FloatPropertyFnWithTaskQueueInfoFilters is a wrapper to get float property from dynamic config with three filters: namespace, taskQueue, taskType

type IntPropertyFn 

type IntPropertyFn func(opts ...FilterOption) int

IntPropertyFn is a wrapper to get int property from dynamic config

type IntPropertyFnWithNamespaceFilter 

type IntPropertyFnWithNamespaceFilter func(namespace string) int

IntPropertyFnWithNamespaceFilter is a wrapper to get int property from dynamic config with namespace as filter

type IntPropertyFnWithShardIDFilter 

type IntPropertyFnWithShardIDFilter func(shardID int32) int

IntPropertyFnWithShardIDFilter is a wrapper to get int property from dynamic config with shardID as filter

type IntPropertyFnWithTaskQueueInfoFilters 

type IntPropertyFnWithTaskQueueInfoFilters func(namespace string, taskQueue string, taskType enumspb.TaskQueueType) int

IntPropertyFnWithTaskQueueInfoFilters is a wrapper to get int property from dynamic config with three filters: namespace, taskQueue, taskType

type Key 

type Key int

Key represents a key/property stored in dynamic config 

const (

	// AdminMatchingNamespaceToPartitionDispatchRate is the max qps of any task queue partition for a given namespace
	AdminMatchingNamespaceToPartitionDispatchRate Key
	// AdminMatchingNamespaceTaskqueueToPartitionDispatchRate is the max qps of a task queue partition for a given namespace & task queue
	AdminMatchingNamespaceTaskqueueToPartitionDispatchRate

	// EnableDBRecordVersion is key for enable db version
	EnableDBRecordVersion

	// StandardVisibilityPersistenceMaxReadQPS is the max QPC system host can query standard visibility DB (SQL or Cassandra) for read.
	StandardVisibilityPersistenceMaxReadQPS
	// StandardVisibilityPersistenceMaxWriteQPS is the max QPC system host can query standard visibility DB (SQL or Cassandra) for write.
	StandardVisibilityPersistenceMaxWriteQPS
	// AdvancedVisibilityPersistenceMaxReadQPS is the max QPC system host can query advanced visibility DB (Elasticsearch) for read.
	AdvancedVisibilityPersistenceMaxReadQPS
	// AdvancedVisibilityPersistenceMaxWriteQPS is the max QPC system host can query advanced visibility DB (Elasticsearch) for write.
	AdvancedVisibilityPersistenceMaxWriteQPS
	// AdvancedVisibilityWritingMode is key for how to write to advanced visibility
	AdvancedVisibilityWritingMode
	// EnableReadVisibilityFromES is key for enable read from elastic search
	EnableReadVisibilityFromES
	// DisableListVisibilityByFilter is config to disable list open/close workflow using filter
	DisableListVisibilityByFilter

	// EmitShardDiffLog whether emit the shard diff log
	EmitShardDiffLog
	// HistoryArchivalState is key for the state of history archival
	HistoryArchivalState
	// EnableReadFromHistoryArchival is key for enabling reading history from archival store
	EnableReadFromHistoryArchival
	// VisibilityArchivalState is key for the state of visibility archival
	VisibilityArchivalState
	// EnableReadFromVisibilityArchival is key for enabling reading visibility from archival store
	EnableReadFromVisibilityArchival
	// EnableNamespaceNotActiveAutoForwarding whether enabling DC auto forwarding to active cluster
	// for signal / start / signal with start API if namespace is not active
	EnableNamespaceNotActiveAutoForwarding
	// TransactionSizeLimit is the largest allowed transaction size to persistence
	TransactionSizeLimit
	// DisallowQuery is the key to disallow query for a namespace
	DisallowQuery
	// EnablePriorityTaskProcessor is the key for enabling priority task processor
	EnablePriorityTaskProcessor
	// EnableAuthorization is the key to enable authorization for a namespace
	EnableAuthorization
	// EnableCrossNamespaceCommands is the key to enable commands for external namespaces
	EnableCrossNamespaceCommands
	// BlobSizeLimitError is the per event blob size limit
	BlobSizeLimitError
	// BlobSizeLimitWarn is the per event blob size limit for warning
	BlobSizeLimitWarn
	// MemoSizeLimitError is the per event memo size limit
	MemoSizeLimitError
	// MemoSizeLimitWarn is the per event memo size limit for warning
	MemoSizeLimitWarn
	// HistorySizeLimitError is the per workflow execution history size limit
	HistorySizeLimitError
	// HistorySizeLimitWarn is the per workflow execution history size limit for warning
	HistorySizeLimitWarn
	// HistoryCountLimitError is the per workflow execution history event count limit
	HistoryCountLimitError
	// HistoryCountLimitWarn is the per workflow execution history event count limit for warning
	HistoryCountLimitWarn

	// MaxIDLengthLimit is the length limit for various IDs, including: Namespace, TaskQueue, WorkflowID, ActivityID, TimerID,
	// WorkflowType, ActivityType, SignalName, MarkerName, ErrorReason/FailureReason/CancelCause, Identity, RequestID
	MaxIDLengthLimit

	// FrontendPersistenceMaxQPS is the max qps frontend host can query DB
	FrontendPersistenceMaxQPS
	// FrontendPersistenceGlobalMaxQPS is the max qps frontend cluster can query DB
	FrontendPersistenceGlobalMaxQPS

	// FrontendVisibilityMaxPageSize is default max size for ListWorkflowExecutions in one page
	FrontendVisibilityMaxPageSize
	// FrontendESIndexMaxResultWindow is ElasticSearch index setting max_result_window
	FrontendESIndexMaxResultWindow

	// FrontendHistoryMaxPageSize is default max size for GetWorkflowExecutionHistory in one page
	FrontendHistoryMaxPageSize
	// FrontendRPS is workflow rate limit per second
	FrontendRPS
	// FrontendMaxNamespaceRPSPerInstance is workflow namespace rate limit per second
	FrontendMaxNamespaceRPSPerInstance
	// FrontendMaxNamespaceCountPerInstance is workflow namespace count limit per second
	FrontendMaxNamespaceCountPerInstance
	// FrontendGlobalNamespaceRPS is workflow namespace rate limit per second for the whole cluster
	FrontendGlobalNamespaceRPS
	// FrontendThrottledLogRPS is the rate limit on number of log messages emitted per second for throttled logger
	FrontendThrottledLogRPS
	// FrontendShutdownDrainDuration is the duration of traffic drain during shutdown
	FrontendShutdownDrainDuration
	// EnableClientVersionCheck enables client version check for frontend
	EnableClientVersionCheck

	// FrontendMaxBadBinaries is the max number of bad binaries in namespace config
	FrontendMaxBadBinaries
	// SendRawWorkflowHistory is whether to enable raw history retrieving
	SendRawWorkflowHistory
	// SearchAttributesNumberOfKeysLimit is the limit of number of keys
	SearchAttributesNumberOfKeysLimit
	// SearchAttributesSizeOfValueLimit is the size limit of each value
	SearchAttributesSizeOfValueLimit
	// SearchAttributesTotalSizeLimit is the size limit of the whole map
	SearchAttributesTotalSizeLimit
	// VisibilityArchivalQueryMaxPageSize is the maximum page size for a visibility archival query
	VisibilityArchivalQueryMaxPageSize
	// VisibilityArchivalQueryMaxRangeInDays is the maximum number of days for a visibility archival query
	VisibilityArchivalQueryMaxRangeInDays
	// VisibilityArchivalQueryMaxQPS is the timeout for a visibility archival query
	VisibilityArchivalQueryMaxQPS
	// EnableServerVersionCheck is a flag that controls whether or not periodic version checking is enabled
	EnableServerVersionCheck
	// EnableTokenNamespaceEnforcement enables enforcement that namespace in completion token matches namespace of the request
	EnableTokenNamespaceEnforcement
	// KeepAliveMinTime is the minimum amount of time a client should wait before sending a keepalive ping.
	KeepAliveMinTime
	// KeepAlivePermitWithoutStream If true, server allows keepalive pings even when there are no active
	// streams(RPCs). If false, and client sends ping when there are no active
	// streams, server will send GOAWAY and close the connection.
	KeepAlivePermitWithoutStream
	// KeepAliveMaxConnectionIdle is a duration for the amount of time after which an
	// idle connection would be closed by sending a GoAway. Idleness duration is
	// defined since the most recent time the number of outstanding RPCs became
	// zero or the connection establishment.
	KeepAliveMaxConnectionIdle
	// KeepAliveMaxConnectionAge is a duration for the maximum amount of time a
	// connection may exist before it will be closed by sending a GoAway. A
	// random jitter of +/-10% will be added to MaxConnectionAge to spread out
	// connection storms.
	KeepAliveMaxConnectionAge
	// KeepAliveMaxConnectionAgeGrace is an additive period after MaxConnectionAge after
	// which the connection will be forcibly closed.
	KeepAliveMaxConnectionAgeGrace
	// KeepAliveTime After a duration of this time if the server doesn't see any activity it
	// pings the client to see if the transport is still alive.
	// If set below 1s, a minimum value of 1s will be used instead.
	KeepAliveTime
	// KeepAliveTimeout After having pinged for keepalive check, the server waits for a duration
	// of Timeout and if no activity is seen even after that the connection is closed.
	KeepAliveTimeout

	// MatchingRPS is request rate per second for each matching host
	MatchingRPS
	// MatchingPersistenceMaxQPS is the max qps matching host can query DB
	MatchingPersistenceMaxQPS
	// MatchingPersistenceGlobalMaxQPS is the max qps matching cluster can query DB
	MatchingPersistenceGlobalMaxQPS
	// MatchingMinTaskThrottlingBurstSize is the minimum burst size for task queue throttling
	MatchingMinTaskThrottlingBurstSize
	// MatchingGetTasksBatchSize is the maximum batch size to fetch from the task buffer
	MatchingGetTasksBatchSize
	// MatchingLongPollExpirationInterval is the long poll expiration interval in the matching service
	MatchingLongPollExpirationInterval
	// MatchingSyncMatchWaitDuration is to wait time for sync match
	MatchingSyncMatchWaitDuration
	// MatchingUpdateAckInterval is the interval for update ack
	MatchingUpdateAckInterval
	// MatchingIdleTaskqueueCheckInterval is the IdleTaskqueueCheckInterval
	MatchingIdleTaskqueueCheckInterval
	// MaxTaskqueueIdleTime is the max time taskqueue being idle
	MaxTaskqueueIdleTime
	// MatchingOutstandingTaskAppendsThreshold is the threshold for outstanding task appends
	MatchingOutstandingTaskAppendsThreshold
	// MatchingMaxTaskBatchSize is max batch size for task writer
	MatchingMaxTaskBatchSize
	// MatchingMaxTaskDeleteBatchSize is the max batch size for range deletion of tasks
	MatchingMaxTaskDeleteBatchSize
	// MatchingThrottledLogRPS is the rate limit on number of log messages emitted per second for throttled logger
	MatchingThrottledLogRPS
	// MatchingNumTaskqueueWritePartitions is the number of write partitions for a task queue
	MatchingNumTaskqueueWritePartitions
	// MatchingNumTaskqueueReadPartitions is the number of read partitions for a task queue
	MatchingNumTaskqueueReadPartitions
	// MatchingForwarderMaxOutstandingPolls is the max number of inflight polls from the forwarder
	MatchingForwarderMaxOutstandingPolls
	// MatchingForwarderMaxOutstandingTasks is the max number of inflight addTask/queryTask from the forwarder
	MatchingForwarderMaxOutstandingTasks
	// MatchingForwarderMaxRatePerSecond is the max rate at which add/query can be forwarded
	MatchingForwarderMaxRatePerSecond
	// MatchingForwarderMaxChildrenPerNode is the max number of children per node in the task queue partition tree
	MatchingForwarderMaxChildrenPerNode
	// MatchingShutdownDrainDuration is the duration of traffic drain during shutdown
	MatchingShutdownDrainDuration

	// HistoryRPS is request rate per second for each history host
	HistoryRPS
	// HistoryPersistenceMaxQPS is the max qps history host can query DB
	HistoryPersistenceMaxQPS
	// HistoryPersistenceGlobalMaxQPS is the max qps history cluster can query DB
	HistoryPersistenceGlobalMaxQPS
	// HistoryLongPollExpirationInterval is the long poll expiration interval in the history service
	HistoryLongPollExpirationInterval
	// HistoryCacheInitialSize is initial size of history cache
	HistoryCacheInitialSize
	// HistoryCacheMaxSize is max size of history cache
	HistoryCacheMaxSize
	// HistoryCacheTTL is TTL of history cache
	HistoryCacheTTL
	// HistoryShutdownDrainDuration is the duration of traffic drain during shutdown
	HistoryShutdownDrainDuration
	// EventsCacheInitialSize is initial size of events cache
	EventsCacheInitialSize
	// EventsCacheMaxSize is max size of events cache
	EventsCacheMaxSize
	// EventsCacheTTL is TTL of events cache
	EventsCacheTTL
	// AcquireShardInterval is interval that timer used to acquire shard
	AcquireShardInterval
	// AcquireShardConcurrency is number of goroutines that can be used to acquire shards in the shard controller.
	AcquireShardConcurrency
	// StandbyClusterDelay is the artificial delay added to standby cluster's view of active cluster's time
	StandbyClusterDelay
	// StandbyTaskMissingEventsResendDelay is the amount of time standby cluster's will wait (if events are missing)
	// before calling remote for missing events
	StandbyTaskMissingEventsResendDelay
	// StandbyTaskMissingEventsDiscardDelay is the amount of time standby cluster's will wait (if events are missing)
	// before discarding the task
	StandbyTaskMissingEventsDiscardDelay
	// TaskProcessRPS is the task processing rate per second for each namespace
	TaskProcessRPS
	// TaskSchedulerType is the task scheduler type for priority task processor
	TaskSchedulerType
	// TaskSchedulerWorkerCount is the number of workers per shard in task scheduler
	TaskSchedulerWorkerCount
	// TaskSchedulerQueueSize is the size of task channel size in task scheduler
	TaskSchedulerQueueSize
	// TaskSchedulerRoundRobinWeights is the priority weight for weighted round robin task scheduler
	TaskSchedulerRoundRobinWeights
	// TimerTaskBatchSize is batch size for timer processor to process tasks
	TimerTaskBatchSize
	// TimerTaskWorkerCount is number of task workers for timer processor
	TimerTaskWorkerCount
	// TimerTaskMaxRetryCount is max retry count for timer processor
	TimerTaskMaxRetryCount
	// TimerProcessorGetFailureRetryCount is retry count for timer processor get failure operation
	TimerProcessorGetFailureRetryCount
	// TimerProcessorCompleteTimerFailureRetryCount is retry count for timer processor complete timer operation
	TimerProcessorCompleteTimerFailureRetryCount
	// TimerProcessorUpdateShardTaskCount is update shard count for timer processor
	TimerProcessorUpdateShardTaskCount
	// TimerProcessorUpdateAckInterval is update interval for timer processor
	TimerProcessorUpdateAckInterval
	// TimerProcessorUpdateAckIntervalJitterCoefficient is the update interval jitter coefficient
	TimerProcessorUpdateAckIntervalJitterCoefficient
	// TimerProcessorCompleteTimerInterval is complete timer interval for timer processor
	TimerProcessorCompleteTimerInterval
	// TimerProcessorFailoverMaxPollRPS is max poll rate per second for timer processor
	TimerProcessorFailoverMaxPollRPS
	// TimerProcessorMaxPollRPS is max poll rate per second for timer processor
	TimerProcessorMaxPollRPS
	// TimerProcessorMaxPollInterval is max poll interval for timer processor
	TimerProcessorMaxPollInterval
	// TimerProcessorMaxPollIntervalJitterCoefficient is the max poll interval jitter coefficient
	TimerProcessorMaxPollIntervalJitterCoefficient
	// TimerProcessorRedispatchInterval is the redispatch interval for timer processor
	TimerProcessorRedispatchInterval
	// TimerProcessorRedispatchIntervalJitterCoefficient is the redispatch interval jitter coefficient
	TimerProcessorRedispatchIntervalJitterCoefficient
	// TimerProcessorMaxRedispatchQueueSize is the threshold of the number of tasks in the redispatch queue for timer processor
	TimerProcessorMaxRedispatchQueueSize
	// TimerProcessorEnablePriorityTaskProcessor indicates whether priority task processor should be used for timer processor
	TimerProcessorEnablePriorityTaskProcessor
	// TimerProcessorMaxTimeShift is the max shift timer processor can have
	TimerProcessorMaxTimeShift
	// TimerProcessorHistoryArchivalSizeLimit is the max history size for inline archival
	TimerProcessorHistoryArchivalSizeLimit
	// TimerProcessorArchivalTimeLimit is the upper time limit for inline history archival
	TimerProcessorArchivalTimeLimit
	// TransferTaskBatchSize is batch size for transferQueueProcessor
	TransferTaskBatchSize
	// TransferProcessorFailoverMaxPollRPS is max poll rate per second for transferQueueProcessor
	TransferProcessorFailoverMaxPollRPS
	// TransferProcessorMaxPollRPS is max poll rate per second for transferQueueProcessor
	TransferProcessorMaxPollRPS
	// TransferTaskWorkerCount is number of worker for transferQueueProcessor
	TransferTaskWorkerCount
	// TransferTaskMaxRetryCount is max times of retry for transferQueueProcessor
	TransferTaskMaxRetryCount
	// TransferProcessorCompleteTransferFailureRetryCount is times of retry for failure
	TransferProcessorCompleteTransferFailureRetryCount
	// TransferProcessorUpdateShardTaskCount is update shard count for transferQueueProcessor
	TransferProcessorUpdateShardTaskCount
	// TransferProcessorMaxPollInterval max poll interval for transferQueueProcessor
	TransferProcessorMaxPollInterval
	// TransferProcessorMaxPollIntervalJitterCoefficient is the max poll interval jitter coefficient
	TransferProcessorMaxPollIntervalJitterCoefficient
	// TransferProcessorUpdateAckInterval is update interval for transferQueueProcessor
	TransferProcessorUpdateAckInterval
	// TransferProcessorUpdateAckIntervalJitterCoefficient is the update interval jitter coefficient
	TransferProcessorUpdateAckIntervalJitterCoefficient
	// TransferProcessorCompleteTransferInterval is complete timer interval for transferQueueProcessor
	TransferProcessorCompleteTransferInterval
	// TransferProcessorRedispatchInterval is the redispatch interval for transferQueueProcessor
	TransferProcessorRedispatchInterval
	// TransferProcessorRedispatchIntervalJitterCoefficient is the redispatch interval jitter coefficient
	TransferProcessorRedispatchIntervalJitterCoefficient
	// TransferProcessorMaxRedispatchQueueSize is the threshold of the number of tasks in the redispatch queue for transferQueueProcessor
	TransferProcessorMaxRedispatchQueueSize
	// TransferProcessorEnablePriorityTaskProcessor indicates whether priority task processor should be used for transferQueueProcessor
	TransferProcessorEnablePriorityTaskProcessor
	// TransferProcessorVisibilityArchivalTimeLimit is the upper time limit for archiving visibility records
	TransferProcessorVisibilityArchivalTimeLimit

	// VisibilityTaskBatchSize is batch size for visibilityQueueProcessor
	VisibilityTaskBatchSize
	// VisibilityProcessorFailoverMaxPollRPS is max poll rate per second for visibilityQueueProcessor
	VisibilityProcessorFailoverMaxPollRPS
	// VisibilityProcessorMaxPollRPS is max poll rate per second for visibilityQueueProcessor
	VisibilityProcessorMaxPollRPS
	// VisibilityTaskWorkerCount is number of worker for visibilityQueueProcessor
	VisibilityTaskWorkerCount
	// VisibilityTaskMaxRetryCount is max times of retry for visibilityQueueProcessor
	VisibilityTaskMaxRetryCount
	// VisibilityProcessorCompleteTaskFailureRetryCount is times of retry for failure
	VisibilityProcessorCompleteTaskFailureRetryCount
	// VisibilityProcessorUpdateShardTaskCount is update shard count for visibilityQueueProcessor
	VisibilityProcessorUpdateShardTaskCount
	// VisibilityProcessorMaxPollInterval max poll interval for visibilityQueueProcessor
	VisibilityProcessorMaxPollInterval
	// VisibilityProcessorMaxPollIntervalJitterCoefficient is the max poll interval jitter coefficient
	VisibilityProcessorMaxPollIntervalJitterCoefficient
	// VisibilityProcessorUpdateAckInterval is update interval for visibilityQueueProcessor
	VisibilityProcessorUpdateAckInterval
	// VisibilityProcessorUpdateAckIntervalJitterCoefficient is the update interval jitter coefficient
	VisibilityProcessorUpdateAckIntervalJitterCoefficient
	// VisibilityProcessorCompleteTaskInterval is complete timer interval for visibilityQueueProcessor
	VisibilityProcessorCompleteTaskInterval
	// VisibilityProcessorRedispatchInterval is the redispatch interval for visibilityQueueProcessor
	VisibilityProcessorRedispatchInterval
	// VisibilityProcessorRedispatchIntervalJitterCoefficient is the redispatch interval jitter coefficient
	VisibilityProcessorRedispatchIntervalJitterCoefficient
	// VisibilityProcessorMaxRedispatchQueueSize is the threshold of the number of tasks in the redispatch queue for visibilityQueueProcessor
	VisibilityProcessorMaxRedispatchQueueSize
	// VisibilityProcessorEnablePriorityTaskProcessor indicates whether priority task processor should be used for visibilityQueueProcessor
	VisibilityProcessorEnablePriorityTaskProcessor
	// VisibilityProcessorVisibilityArchivalTimeLimit is the upper time limit for archiving visibility records
	VisibilityProcessorVisibilityArchivalTimeLimit

	// ReplicatorTaskBatchSize is batch size for ReplicatorProcessor
	ReplicatorTaskBatchSize
	// ReplicatorTaskWorkerCount is number of worker for ReplicatorProcessor
	ReplicatorTaskWorkerCount
	// ReplicatorTaskMaxRetryCount is max times of retry for ReplicatorProcessor
	ReplicatorTaskMaxRetryCount
	// ReplicatorProcessorMaxPollRPS is max poll rate per second for ReplicatorProcessor
	ReplicatorProcessorMaxPollRPS
	// ReplicatorProcessorUpdateShardTaskCount is update shard count for ReplicatorProcessor
	ReplicatorProcessorUpdateShardTaskCount
	// ReplicatorProcessorMaxPollInterval is max poll interval for ReplicatorProcessor
	ReplicatorProcessorMaxPollInterval
	// ReplicatorProcessorMaxPollIntervalJitterCoefficient is the max poll interval jitter coefficient
	ReplicatorProcessorMaxPollIntervalJitterCoefficient
	// ReplicatorProcessorUpdateAckInterval is update interval for ReplicatorProcessor
	ReplicatorProcessorUpdateAckInterval
	// ReplicatorProcessorUpdateAckIntervalJitterCoefficient is the update interval jitter coefficient
	ReplicatorProcessorUpdateAckIntervalJitterCoefficient
	// ReplicatorProcessorRedispatchInterval is the redispatch interval for ReplicatorProcessor
	ReplicatorProcessorRedispatchInterval
	// ReplicatorProcessorRedispatchIntervalJitterCoefficient is the redispatch interval jitter coefficient
	ReplicatorProcessorRedispatchIntervalJitterCoefficient
	// ReplicatorProcessorMaxRedispatchQueueSize is the threshold of the number of tasks in the redispatch queue for ReplicatorProcessor
	ReplicatorProcessorMaxRedispatchQueueSize
	// ReplicatorProcessorEnablePriorityTaskProcessor indicates whether priority task processor should be used for ReplicatorProcessor
	ReplicatorProcessorEnablePriorityTaskProcessor
	// MaximumBufferedEventsBatch is max number of buffer event in mutable state
	MaximumBufferedEventsBatch
	// MaximumSignalsPerExecution is max number of signals supported by single execution
	MaximumSignalsPerExecution
	// ShardUpdateMinInterval is the minimal time interval which the shard info can be updated
	ShardUpdateMinInterval
	// ShardSyncMinInterval is the minimal time interval which the shard info should be sync to remote
	ShardSyncMinInterval
	// ShardSyncTimerJitterCoefficient is the sync shard jitter coefficient
	ShardSyncTimerJitterCoefficient
	// DefaultEventEncoding is the encoding type for history events
	DefaultEventEncoding
	// NumArchiveSystemWorkflows is key for number of archive system workflows running in total
	NumArchiveSystemWorkflows
	// ArchiveRequestRPS is the rate limit on the number of archive request per second
	ArchiveRequestRPS
	// DefaultActivityRetryPolicy represents the out-of-box retry policy for activities where
	// the user has not specified an explicit RetryPolicy
	DefaultActivityRetryPolicy
	// DefaultWorkflowRetryPolicy represents the out-of-box retry policy for unset fields
	// where the user has set an explicit RetryPolicy, but not specified all the fields
	DefaultWorkflowRetryPolicy

	// HistoryMaxAutoResetPoints is the key for max number of auto reset points stored in mutableState
	HistoryMaxAutoResetPoints

	// EnableParentClosePolicy whether to  ParentClosePolicy
	EnableParentClosePolicy
	// ParentClosePolicyThreshold decides that parent close policy will be processed by sys workers(if enabled) if
	// the number of children greater than or equal to this threshold
	ParentClosePolicyThreshold
	// NumParentClosePolicySystemWorkflows is key for number of parentClosePolicy system workflows running in total
	NumParentClosePolicySystemWorkflows

	// HistoryThrottledLogRPS is the rate limit on number of log messages emitted per second for throttled logger
	HistoryThrottledLogRPS
	// StickyTTL is to expire a sticky taskqueue if no update more than this duration
	StickyTTL
	// WorkflowTaskHeartbeatTimeout for workflow task heartbeat
	WorkflowTaskHeartbeatTimeout
	// DefaultWorkflowTaskTimeout for a workflow task
	DefaultWorkflowTaskTimeout

	// EnableDropStuckTaskByNamespaceID is whether stuck timer/transfer task should be dropped for a namespace
	EnableDropStuckTaskByNamespaceID
	// SkipReapplicationByNamespaceID is whether skipping a event re-application for a namespace
	SkipReapplicationByNamespaceID

	// WorkerPersistenceMaxQPS is the max qps worker host can query DB
	WorkerPersistenceMaxQPS
	// WorkerPersistenceGlobalMaxQPS is the max qps worker cluster can query DB
	WorkerPersistenceGlobalMaxQPS
	// WorkerIndexerConcurrency is the max concurrent messages to be processed at any given time
	WorkerIndexerConcurrency
	// WorkerESProcessorNumOfWorkers is num of workers for esProcessor
	WorkerESProcessorNumOfWorkers
	// WorkerESProcessorBulkActions is max number of requests in bulk for esProcessor
	WorkerESProcessorBulkActions
	// WorkerESProcessorBulkSize is max total size of bulk in bytes for esProcessor
	WorkerESProcessorBulkSize
	// WorkerESProcessorFlushInterval is flush interval for esProcessor
	WorkerESProcessorFlushInterval
	// WorkerESProcessorAckTimeout is the timeout that store will wait to get ack signal from ES processor.
	// Should be at least WorkerESProcessorFlushInterval+<time to process request>.
	WorkerESProcessorAckTimeout
	// WorkerArchiverMaxConcurrentActivityExecutionSize indicates worker archiver max concurrent activity execution size
	WorkerArchiverMaxConcurrentActivityExecutionSize
	// WorkerArchiverMaxConcurrentWorkflowTaskExecutionSize indicates worker archiver max concurrent workflow execution size
	WorkerArchiverMaxConcurrentWorkflowTaskExecutionSize
	// WorkerArchiverMaxConcurrentActivityTaskPollers indicates worker archiver max concurrent activity pollers
	WorkerArchiverMaxConcurrentActivityTaskPollers
	// WorkerArchiverMaxConcurrentWorkflowTaskPollers indicates worker archiver max concurrent workflow pollers
	WorkerArchiverMaxConcurrentWorkflowTaskPollers
	// WorkerArchiverConcurrency controls the number of coroutines handling archival work per archival workflow
	WorkerArchiverConcurrency
	// WorkerArchivalsPerIteration controls the number of archivals handled in each iteration of archival workflow
	WorkerArchivalsPerIteration
	// WorkerTimeLimitPerArchivalIteration controls the time limit of each iteration of archival workflow
	WorkerTimeLimitPerArchivalIteration
	// WorkerThrottledLogRPS is the rate limit on number of log messages emitted per second for throttled logger
	WorkerThrottledLogRPS
	// WorkerScannerMaxConcurrentActivityExecutionSize indicates worker scanner max concurrent activity execution size
	WorkerScannerMaxConcurrentActivityExecutionSize
	// WorkerScannerMaxConcurrentWorkflowTaskExecutionSize indicates worker scanner max concurrent workflow execution size
	WorkerScannerMaxConcurrentWorkflowTaskExecutionSize
	// WorkerScannerMaxConcurrentActivityTaskPollers indicates worker scanner max concurrent activity pollers
	WorkerScannerMaxConcurrentActivityTaskPollers
	// WorkerScannerMaxConcurrentWorkflowTaskPollers indicates worker scanner max concurrent workflow pollers
	WorkerScannerMaxConcurrentWorkflowTaskPollers
	// ScannerPersistenceMaxQPS is the maximum rate of persistence calls from worker.Scanner
	ScannerPersistenceMaxQPS
	// TaskQueueScannerEnabled indicates if task queue scanner should be started as part of worker.Scanner
	TaskQueueScannerEnabled
	// HistoryScannerEnabled indicates if history scanner should be started as part of worker.Scanner
	HistoryScannerEnabled
	// ExecutionsScannerEnabled indicates if executions scanner should be started as part of worker.Scanner
	ExecutionsScannerEnabled
	// WorkerBatcherMaxConcurrentActivityExecutionSize indicates worker batcher max concurrent activity execution size
	WorkerBatcherMaxConcurrentActivityExecutionSize
	// WorkerBatcherMaxConcurrentWorkflowTaskExecutionSize indicates worker batcher max concurrent workflow execution size
	WorkerBatcherMaxConcurrentWorkflowTaskExecutionSize
	// WorkerBatcherMaxConcurrentActivityTaskPollers indicates worker batcher max concurrent activity pollers
	WorkerBatcherMaxConcurrentActivityTaskPollers
	// WorkerBatcherMaxConcurrentWorkflowTaskPollers indicates worker batcher max concurrent workflow pollers
	WorkerBatcherMaxConcurrentWorkflowTaskPollers
	// EnableBatcher decides whether start batcher in our worker
	EnableBatcher
	// WorkerParentCloseMaxConcurrentActivityExecutionSize indicates worker parent close worker max concurrent activity execution size
	WorkerParentCloseMaxConcurrentActivityExecutionSize
	// WorkerParentCloseMaxConcurrentWorkflowTaskExecutionSize indicates worker parent close worker max concurrent workflow execution size
	WorkerParentCloseMaxConcurrentWorkflowTaskExecutionSize
	// WorkerParentCloseMaxConcurrentActivityTaskPollers indicates worker parent close worker max concurrent activity pollers
	WorkerParentCloseMaxConcurrentActivityTaskPollers
	// WorkerParentCloseMaxConcurrentWorkflowTaskPollers indicates worker parent close worker max concurrent workflow pollers
	WorkerParentCloseMaxConcurrentWorkflowTaskPollers
	// EnableParentClosePolicyWorker decides whether or not enable system workers for processing parent close policy task
	EnableParentClosePolicyWorker
	// EnableStickyQuery indicates if sticky query should be enabled per namespace
	EnableStickyQuery

	// ReplicationTaskFetcherParallelism determines how many go routines we spin up for fetching tasks
	ReplicationTaskFetcherParallelism
	// ReplicationTaskFetcherAggregationInterval determines how frequently the fetch requests are sent
	ReplicationTaskFetcherAggregationInterval
	// ReplicationTaskFetcherTimerJitterCoefficient is the jitter for fetcher timer
	ReplicationTaskFetcherTimerJitterCoefficient
	// ReplicationTaskFetcherErrorRetryWait is the wait time when fetcher encounters error
	ReplicationTaskFetcherErrorRetryWait
	// ReplicationTaskProcessorErrorRetryWait is the initial retry wait when we see errors in applying replication tasks
	ReplicationTaskProcessorErrorRetryWait
	// ReplicationTaskProcessorErrorRetryBackoffCoefficient is the retry wait backoff time coefficient
	ReplicationTaskProcessorErrorRetryBackoffCoefficient
	// ReplicationTaskProcessorErrorRetryMaxInterval is the retry wait backoff max duration
	ReplicationTaskProcessorErrorRetryMaxInterval
	// ReplicationTaskProcessorErrorRetryMaxAttempts is the max retry attempts for applying replication tasks
	ReplicationTaskProcessorErrorRetryMaxAttempts
	// ReplicationTaskProcessorErrorRetryExpiration is the max retry duration for applying replication tasks
	ReplicationTaskProcessorErrorRetryExpiration
	// ReplicationTaskProcessorNoTaskInitialWait is the wait time when not ask is returned
	ReplicationTaskProcessorNoTaskInitialWait
	// ReplicationTaskProcessorCleanupInterval determines how frequently the cleanup replication queue
	ReplicationTaskProcessorCleanupInterval
	// ReplicationTaskProcessorCleanupJitterCoefficient is the jitter for cleanup timer
	ReplicationTaskProcessorCleanupJitterCoefficient
	// ReplicationTaskProcessorStartWait is the wait time before each task processing batch
	ReplicationTaskProcessorStartWait
	// ReplicationTaskProcessorStartWaitJitterCoefficient is the jitter for batch start wait timer
	ReplicationTaskProcessorStartWaitJitterCoefficient
	// ReplicationTaskProcessorHostQPS is the qps of task processing rate limiter on host level
	ReplicationTaskProcessorHostQPS
	// ReplicationTaskProcessorShardQPS is the qps of task processing rate limiter on shard level
	ReplicationTaskProcessorShardQPS
	// MaxBufferedQueryCount indicates max buffer query count
	MaxBufferedQueryCount
	// MutableStateChecksumGenProbability is the probability [0-100] that checksum will be generated for mutable state
	MutableStateChecksumGenProbability
	// MutableStateChecksumVerifyProbability is the probability [0-100] that checksum will be verified for mutable state
	MutableStateChecksumVerifyProbability
	// MutableStateChecksumInvalidateBefore is the epoch timestamp before which all checksums are to be discarded
	MutableStateChecksumInvalidateBefore

	// ReplicationEventsFromCurrentCluster is a feature flag to allow cross DC replicate events that generated from the current cluster
	ReplicationEventsFromCurrentCluster

	// StandbyTaskReReplicationContextTimeout is the context timeout for standby task re-replication
	StandbyTaskReReplicationContextTimeout

	EnableRingpopTLS
)

func (Key) String 

func (k Key) String() string

type MapPropertyFn 

type MapPropertyFn func(opts ...FilterOption) map[string]interface{}

MapPropertyFn is a wrapper to get map property from dynamic config

type MapPropertyFnWithNamespaceFilter 

type MapPropertyFnWithNamespaceFilter func(namespace string) map[string]interface{}

MapPropertyFnWithNamespaceFilter is a wrapper to get map property from dynamic config

type MockClient 

type MockClient struct {
	// contains filtered or unexported fields
}

MockClient is a mock of Client interface.

func NewMockClient 

func NewMockClient(ctrl *gomock.Controller) *MockClient

NewMockClient creates a new mock instance.

func (*MockClient) EXPECT 

func (m *MockClient) EXPECT() *MockClientMockRecorder

EXPECT returns an object that allows the caller to indicate expected use.

func (*MockClient) GetBoolValue 

func (m *MockClient) GetBoolValue(name Key, filters map[Filter]interface{}, defaultValue bool) (bool, error)

GetBoolValue mocks base method.

func (*MockClient) GetDurationValue 

func (m *MockClient) GetDurationValue(name Key, filters map[Filter]interface{}, defaultValue time.Duration) (time.Duration, error)

GetDurationValue mocks base method.

func (*MockClient) GetFloatValue 

func (m *MockClient) GetFloatValue(name Key, filters map[Filter]interface{}, defaultValue float64) (float64, error)

GetFloatValue mocks base method.

func (*MockClient) GetIntValue 

func (m *MockClient) GetIntValue(name Key, filters map[Filter]interface{}, defaultValue int) (int, error)

GetIntValue mocks base method.

func (*MockClient) GetMapValue 

func (m *MockClient) GetMapValue(name Key, filters map[Filter]interface{}, defaultValue map[string]interface{}) (map[string]interface{}, error)

GetMapValue mocks base method.

func (*MockClient) GetStringValue 

func (m *MockClient) GetStringValue(name Key, filters map[Filter]interface{}, defaultValue string) (string, error)

GetStringValue mocks base method.

func (*MockClient) GetValue 

func (m *MockClient) GetValue(name Key, defaultValue interface{}) (interface{}, error)

GetValue mocks base method.

func (*MockClient) GetValueWithFilters 

func (m *MockClient) GetValueWithFilters(name Key, filters map[Filter]interface{}, defaultValue interface{}) (interface{}, error)

GetValueWithFilters mocks base method.

type MockClientMockRecorder 

type MockClientMockRecorder struct {
	// contains filtered or unexported fields
}

MockClientMockRecorder is the mock recorder for MockClient.

func (*MockClientMockRecorder) GetBoolValue 

func (mr *MockClientMockRecorder) GetBoolValue(name, filters, defaultValue interface{}) *gomock.Call

GetBoolValue indicates an expected call of GetBoolValue.

func (*MockClientMockRecorder) GetDurationValue 

func (mr *MockClientMockRecorder) GetDurationValue(name, filters, defaultValue interface{}) *gomock.Call

GetDurationValue indicates an expected call of GetDurationValue.

func (*MockClientMockRecorder) GetFloatValue 

func (mr *MockClientMockRecorder) GetFloatValue(name, filters, defaultValue interface{}) *gomock.Call

GetFloatValue indicates an expected call of GetFloatValue.

func (*MockClientMockRecorder) GetIntValue 

func (mr *MockClientMockRecorder) GetIntValue(name, filters, defaultValue interface{}) *gomock.Call

GetIntValue indicates an expected call of GetIntValue.

func (*MockClientMockRecorder) GetMapValue 

func (mr *MockClientMockRecorder) GetMapValue(name, filters, defaultValue interface{}) *gomock.Call

GetMapValue indicates an expected call of GetMapValue.

func (*MockClientMockRecorder) GetStringValue 

func (mr *MockClientMockRecorder) GetStringValue(name, filters, defaultValue interface{}) *gomock.Call

GetStringValue indicates an expected call of GetStringValue.

func (*MockClientMockRecorder) GetValue 

func (mr *MockClientMockRecorder) GetValue(name, defaultValue interface{}) *gomock.Call

GetValue indicates an expected call of GetValue.

func (*MockClientMockRecorder) GetValueWithFilters 

func (mr *MockClientMockRecorder) GetValueWithFilters(name, filters, defaultValue interface{}) *gomock.Call

GetValueWithFilters indicates an expected call of GetValueWithFilters.

type MutableEphemeralClient added in v1.12.0 

type MutableEphemeralClient struct {
	// contains filtered or unexported fields
}

MutableEphemeralClient is a dynamicconfig.Client implementation that is safely mutable in the presence of an unbounded number of reads and writes. Writers block other writers but not readers. Readers don't block anything. Mutations are batched to the Update function. Data written to objects of this type is not made durable.

func NewMutableEphemeralClient added in v1.12.0 

func NewMutableEphemeralClient(mutations ...Mutation) *MutableEphemeralClient

NewMutableEphemeralClient constructs a new MutableEphemeralClient with an empty internal store.

func (*MutableEphemeralClient) Add added in v1.12.0 

func (c *MutableEphemeralClient) Add(
	k Key,
	v interface{},
	mcs ...MutationConstraint,
)

Set adds a value to the set of configured values for a given key.

func (MutableEphemeralClient) GetBoolValue added in v1.12.0 

func (bc MutableEphemeralClient) GetBoolValue(
	name Key,
	filters map[Filter]interface{},
	defaultValue bool,
) (bool, error)

func (MutableEphemeralClient) GetDurationValue added in v1.12.0 

func (bc MutableEphemeralClient) GetDurationValue(
	name Key, filters map[Filter]interface{}, defaultValue time.Duration,
) (time.Duration, error)

func (MutableEphemeralClient) GetFloatValue added in v1.12.0 

func (bc MutableEphemeralClient) GetFloatValue(
	name Key,
	filters map[Filter]interface{},
	defaultValue float64,
) (float64, error)

func (MutableEphemeralClient) GetIntValue added in v1.12.0 

func (bc MutableEphemeralClient) GetIntValue(
	name Key,
	filters map[Filter]interface{},
	defaultValue int,
) (int, error)

func (MutableEphemeralClient) GetMapValue added in v1.12.0 

func (bc MutableEphemeralClient) GetMapValue(
	name Key,
	filters map[Filter]interface{},
	defaultValue map[string]interface{},
) (map[string]interface{}, error)

func (MutableEphemeralClient) GetStringValue added in v1.12.0 

func (bc MutableEphemeralClient) GetStringValue(
	name Key,
	filters map[Filter]interface{},
	defaultValue string,
) (string, error)

func (MutableEphemeralClient) GetValue added in v1.12.0 

func (bc MutableEphemeralClient) GetValue(
	name Key,
	defaultValue interface{},
) (interface{}, error)

func (MutableEphemeralClient) GetValueWithFilters added in v1.12.0 

func (bc MutableEphemeralClient) GetValueWithFilters(
	name Key,
	filters map[Filter]interface{},
	defaultValue interface{},
) (interface{}, error)

func (*MutableEphemeralClient) MAdd added in v1.12.0 

func (c *MutableEphemeralClient) MAdd(
	kvs map[Key]interface{},
	mcs ...MutationConstraint,
)

MSet appends to multiple keys atomically. The supplied MutationConstraints are applied to each of the resulting configuration values.

func (*MutableEphemeralClient) MSet added in v1.12.0 

func (c *MutableEphemeralClient) MSet(
	kvs map[Key]interface{},
	mcs ...MutationConstraint,
)

MSet assigns to multiple keys atomically. The supplied MutationConstraints are applied to each of the resulting configuration values.

func (*MutableEphemeralClient) Set added in v1.12.0 

func (c *MutableEphemeralClient) Set(
	k Key,
	v interface{},
	mcs ...MutationConstraint,
)

Set assigns a single configuration value, overwriting any existing values.

func (*MutableEphemeralClient) Update added in v1.12.0 

func (c *MutableEphemeralClient) Update(mutations ...Mutation)

Updated applies the provided Mutations to this MutableEphemeralClients underlying non-durable value store.

type Mutation added in v1.12.0 

type Mutation func(configValueMap)

Mutation expresses a modification to a MutableEphemeralClient's internal value store. Mutation functions are applied with MutableEphemeralClient.Update.

func Add added in v1.12.0 

func Add(k Key, v interface{}, constrainers ...MutationConstraint) Mutation

Add appends the supplied value and optional constraints to those already present under the indicated key. If there are no values present for the key this is equivalent to Set.

func Set added in v1.12.0 

func Set(k Key, v interface{}, constrainers ...MutationConstraint) Mutation

Set assigns the supplied value along with optional constraints to the indicated key. Any other additional value (possibly with other constraints) is overwritten.

type MutationConstraint added in v1.12.0 

type MutationConstraint func(map[string]interface{})

MutationConstraint expresses a configuration constraint (namespace, queue name, or queue type) that is an optional part of a Mutation.

func ForNamespace added in v1.12.0 

func ForNamespace(ns string) MutationConstraint

ForNamespaces builds an exact-match namespace MutationConstraint.

func ForTaskQueueName added in v1.12.0 

func ForTaskQueueName(n string) MutationConstraint

ForTaskQueueName builds an exact-match task queue name MutationConstraint.

func ForTaskType added in v1.12.0 

func ForTaskType(t int) MutationConstraint

ForTaskType builds an exact-match task type MutationConstraint.

type PropertyFn 

type PropertyFn func() interface{}

PropertyFn is a wrapper to get property from dynamic config

type StringPropertyFn 

type StringPropertyFn func(opts ...FilterOption) string

StringPropertyFn is a wrapper to get string property from dynamic config

type StringPropertyFnWithNamespaceFilter 

type StringPropertyFnWithNamespaceFilter func(namespace string) string

StringPropertyFnWithNamespaceFilter is a wrapper to get string property from dynamic config

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.