host

type AdminClient interface {
	admin.Client
}

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

type AsyncWFIntegrationSuite struct {
	*require.Assertions
	*IntegrationBase
}

type Cadence interface {
	Start() error
	Stop()
	GetAdminClient() adminClient.Client
	GetFrontendClient() frontendClient.Client
	FrontendHost() membership.HostInfo
	GetHistoryClient() historyClient.Client
	GetMatchingClient() matchingClient.Client
	GetMatchingClients() []matchingClient.Client
	GetExecutionManagerFactory() persistence.ExecutionManagerFactory
}

type CadenceParams struct {
	ClusterMetadata               cluster.Metadata
	PersistenceConfig             config.Persistence
	MessagingClient               messaging.Client
	DomainManager                 persistence.DomainManager
	HistoryV2Mgr                  persistence.HistoryManager
	ExecutionMgrFactory           persistence.ExecutionManagerFactory
	DomainReplicationQueue        domain.ReplicationQueue
	Logger                        log.Logger
	ClusterNo                     int
	ArchiverMetadata              carchiver.ArchivalMetadata
	ArchiverProvider              provider.ArchiverProvider
	EnableReadHistoryFromArchival bool
	HistoryConfig                 *HistoryConfig
	MatchingConfig                *MatchingConfig
	ESConfig                      *config.ElasticSearchConfig
	ESClient                      elasticsearch.GenericClient
	WorkerConfig                  *WorkerConfig
	MockAdminClient               map[string]adminClient.Client
	DomainReplicationTaskExecutor domain.ReplicationTaskExecutor
	AuthorizationConfig           config.Authorization
	PinotConfig                   *config.PinotVisibilityConfig
	PinotClient                   pinot.GenericClient
	AsyncWFQueues                 map[string]config.AsyncWorkflowQueueProvider
	TimeSource                    clock.TimeSource

	FrontendDynCfgOverrides map[dynamicproperties.Key]interface{}
	HistoryDynCfgOverrides  map[dynamicproperties.Key]interface{}
	MatchingDynCfgOverrides map[dynamicproperties.Key]interface{}
	WorkerDynCfgOverrides   map[dynamicproperties.Key]interface{}
}

type ClientIntegrationSuite struct {
	// override suite.Suite.Assertions with require.Assertions; this means that s.NotNil(nil) will stop the test,
	// not merely log an error
	*require.Assertions
	*IntegrationBase
	// contains filtered or unexported fields
}

type FrontendClient interface {
	frontend.Client
}

type HistoryClient interface {
	history.Client
}

type HistoryConfig struct {
	// When MockClient is set, rest of the configs are ignored, history service is not started
	// and mock history client is passed to other services
	MockClient HistoryClient

	NumHistoryShards       int
	NumHistoryHosts        int
	HistoryCountLimitError int
	HistoryCountLimitWarn  int
	SimulationConfig       HistorySimulationConfig
}

type HistorySimulationConfig struct {
	NumWorkflows int
	// WorkflowDeletionJitterRange defines the duration in minutes for workflow close tasks jittering
	// defaults to 0 to remove jittering
	WorkflowDeletionJitterRange int
	// EnableTransferQueueV2 enables queue v2 framework for transfer queue
	EnableTransferQueueV2 bool
	// EnableTimerQueueV2 enables queue v2 framework for timer queue
	EnableTimerQueueV2 bool
}

type IntegrationBase struct {
	suite.Suite

	TestCluster              *TestCluster
	TestClusterConfig        *TestClusterConfig
	Engine                   FrontendClient
	AdminClient              AdminClient
	Logger                   log.Logger
	DomainName               string
	SecondaryDomainName      string
	TestRawHistoryDomainName string
	ForeignDomainName        string
	ArchivalDomainName       string
	DefaultTestCluster       testcluster.PersistenceTestCluster
	VisibilityTestCluster    testcluster.PersistenceTestCluster
}

type IntegrationBaseParams struct {
	T                     *testing.T
	DefaultTestCluster    testcluster.PersistenceTestCluster
	VisibilityTestCluster testcluster.PersistenceTestCluster
	TestClusterConfig     *TestClusterConfig
}

type IntegrationQueueV2Suite struct {
	*IntegrationSuite
}

type IntegrationSuite struct {
	// override suite.Suite.Assertions with require.Assertions; this means that s.NotNil(nil) will stop the test,
	// not merely log an error
	*require.Assertions
	*IntegrationBase
}

type MatchingClient interface {
	matching.Client
}

type MatchingConfig struct {
	// number of matching host can be at most 4 due to existing static port assignments in onebox.go.
	// can be changed easily.
	NumMatchingHosts int
	SimulationConfig MatchingSimulationConfig
}

type MatchingSimulationConfig struct {
	// Number of task list write partitions defaults to 1
	TaskListWritePartitions int

	// Number of task list read partitions defaults to 1
	TaskListReadPartitions int

	// At most N polls will be forwarded at a time. defaults to 20
	ForwarderMaxOutstandingPolls int

	// At most N tasks will be forwarded at a time. defaults to 1
	ForwarderMaxOutstandingTasks int

	// Forwarder rps limit defaults to 10
	ForwarderMaxRatePerSecond int

	// Children per node. defaults to 20
	ForwarderMaxChildrenPerNode int

	// LocalPollWaitTime. defaults to 0ms.
	LocalPollWaitTime time.Duration

	// LocalTaskWaitTime. defaults to 0ms.
	LocalTaskWaitTime time.Duration

	// RecordDecisionTaskStartedTime. The amount of time spent by History to complete RecordDecisionTaskStarted
	RecordDecisionTaskStartedTime time.Duration

	// TasklistLoadBalancerStrategy the strategy of load balancer. defaults to "random".
	TasklistLoadBalancerStrategy string

	// The pollers that will be created to process
	Pollers []SimulationPollerConfiguration

	Tasks []SimulationTaskConfiguration

	Backlogs []SimulationBacklogConfiguration

	// GetPartitionConfigFromDB indicates whether to get the partition config from DB or not.
	// This is a prerequisite for adaptive scaler.
	GetPartitionConfigFromDB bool

	// Adaptive scaler configurations
	EnableAdaptiveScaler                bool
	PartitionDownscaleFactor            float64
	PartitionUpscaleRPS                 int
	PartitionUpscaleSustainedDuration   time.Duration
	PartitionDownscaleSustainedDuration time.Duration
	AdaptiveScalerUpdateInterval        time.Duration
	QPSTrackerInterval                  time.Duration
	TaskIsolationDuration               time.Duration
}

type MessagingClientConfig struct {
	UseMock     bool
	KafkaConfig *config.KafkaConfig
}

type Service interface {
	Start()
	Stop()
	GetLogger() log.Logger
	GetThrottledLogger() log.Logger
	GetMetricsClient() metrics.Client
	GetClientBean() client.Bean
	GetTimeSource() clock.TimeSource
	GetDispatcher() *yarpc.Dispatcher
	GetMembershipResolver() membership.Resolver
	GetHostInfo() membership.HostInfo
	GetClusterMetadata() cluster.Metadata
	GetMessagingClient() messaging.Client
	GetBlobstoreClient() blobstore.Client
	GetArchivalMetadata() archiver.ArchivalMetadata
	GetArchiverProvider() provider.ArchiverProvider
	GetPayloadSerializer() persistence.PayloadSerializer
}

type SimulationBacklogConfiguration struct {
	// The partition number
	Partition int // Do not set it to 0, because it's not guaranteed to add backlog to partition 0
	// The backlog count
	BacklogCount int
	// The weight of each isolation group, can be empty
	IsolationGroups map[string]int
}

type SimulationPollerConfiguration struct {
	// The isolation group that pollers will be created with. Optional.
	IsolationGroup string
	// The number of pollers that will be created with this configuration. Defaults to 1
	NumPollers int
	// TaskProcessTime. The amount of time spent by the poller in-between requests. Defaults to 1ms
	TaskProcessTime time.Duration
	// Poll request timeout defaults to 15 seconds
	PollTimeout time.Duration
}

type SimulationTaskConfiguration struct {
	// The isolation groups that tasks will be evenly distributed between
	IsolationGroups []string

	// Number of task generators defaults to 1
	NumTaskGenerators int

	// Upper limit of tasks to generate. Task generators will stop if total number of tasks generated reaches MaxTaskToGenerate during simulation
	// Defaults to 2k
	MaxTaskToGenerate int

	// Task generation QPS. Defaults to 40.
	TasksPerSecond int

	// The burst value for the rate limiter for task generation. Controls the maximum number of AddTask requests
	// that can be sent concurrently. For example, if you have TasksPerSecond, TasksBurst, and NumTaskGenerators all
	// set to 10 then every second you'll get 10 tasks added right at the start of the second. If you instead set
	// TasksBurst to 1 then you'd get a steady stream of tasks, with one task every 100ms.
	TasksBurst int

	// OverTime is a list of TasksProduceSpec that will be used to change the qps over time.
	// Each item has a duration and they will be applied in the given order.
	// If this is set, TasksPerSecond and TasksBurst will be ignored.
	OverTime []TasksProduceSpec
}

type SizeLimitIntegrationSuite struct {
	// override suite.Suite.Assertions with require.Assertions; this means that s.NotNil(nil) will stop the test,
	// not merely log an error
	*require.Assertions
	*IntegrationBase
}

type TaskListIsolationIntegrationSuite struct {
	*require.Assertions
	*IntegrationBase
}

type TaskPoller struct {
	Engine                              FrontendClient
	Domain                              string
	TaskList                            *types.TaskList
	StickyTaskList                      *types.TaskList
	StickyScheduleToStartTimeoutSeconds *int32
	Identity                            string
	DecisionHandler                     decisionTaskHandler
	ActivityHandler                     activityTaskHandler
	QueryHandler                        queryHandler
	Logger                              log.Logger
	T                                   *testing.T
	CallOptions                         []yarpc.CallOption
}

type TasksProduceSpec struct {
	// Task generation qps
	TasksPerSecond int

	// The burst value for the rate limiter for task generation.
	TasksBurst int

	// The duration for which the settings will be applied.
	// If the duration is unset, the settings will be applied indefinitely.
	Duration *time.Duration
}

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

type TestClusterConfig struct {
	FrontendAddress       string
	EnableArchival        bool
	IsPrimaryCluster      bool
	ClusterNo             int
	ClusterGroupMetadata  config.ClusterGroupMetadata
	MessagingClientConfig *MessagingClientConfig
	Persistence           persistencetests.TestBaseOptions
	HistoryConfig         *HistoryConfig
	MatchingConfig        *MatchingConfig
	ESConfig              *config.ElasticSearchConfig
	WorkerConfig          *WorkerConfig
	MockAdminClient       map[string]adminClient.Client
	PinotConfig           *config.PinotVisibilityConfig
	AsyncWFQueues         map[string]config.AsyncWorkflowQueueProvider

	// TimeSource is used to override the time source of internal components.
	// Note that most components don't respect this, and it's only used in a few places.
	// e.g. async workflow test's consumer manager and domain manager
	TimeSource                     clock.MockedTimeSource
	FrontendDynamicConfigOverrides map[dynamicproperties.Key]interface{}
	HistoryDynamicConfigOverrides  map[dynamicproperties.Key]interface{}
	MatchingDynamicConfigOverrides map[dynamicproperties.Key]interface{}
	WorkerDynamicConfigOverrides   map[dynamicproperties.Key]interface{}
}

type WorkerConfig struct {
	EnableArchiver        bool
	EnableIndexer         bool
	EnableReplicator      bool
	EnableAsyncWFConsumer bool
}

type WorkflowIDInternalRateLimitIntegrationSuite struct {
	*require.Assertions
	*IntegrationBase
}

type WorkflowIDRateLimitIntegrationSuite struct {
	*require.Assertions
	*IntegrationBase
}