dtstruct

type APIResponse struct {
	HttpStatus int
	Code       APIResponseCode
	Message    string
	Detail     interface{}
}

type APIResponseCode int

type Agent struct {
	IP         string
	Port       int
	Hostname   string
	Interval   int
	LastUpdate time.Time
}

type AggregatedWriteBufferMetric struct {
	InstanceWriteBufferSize           int // config setting
	InstanceFlushIntervalMilliseconds int // config setting
	CountInstances                    int
	MaxInstances                      float64
	MeanInstances                     float64
	MedianInstances                   float64
	P95Instances                      float64
	MaxWaitSeconds                    float64
	MeanWaitSeconds                   float64
	MedianWaitSeconds                 float64
	P95WaitSeconds                    float64
	MaxWriteSeconds                   float64
	MeanWriteSeconds                  float64
	MedianWriteSeconds                float64
	P95WriteSeconds                   float64
}

type AnalysisCode string

type AnalysisInstanceType string

type AnalysisMap map[string](*ReplicationAnalysis)

type Audit struct {
	AuditId          int64
	AuditTimestamp   string
	AuditType        string
	AuditInstanceKey InstanceKey
	Message          string
}

type BinlogEvent struct {
	Coordinates  LogCoordinates
	NextEventPos int64
	EventType    string
	Info         string
}

type BinlogEventCursor struct {
	CachedEvents      []BinlogEvent
	CurrentEventIndex int
	// contains filtered or unexported fields
}

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

type BlockedTopologyRecovery struct {
	FailedInstanceKey    InstanceKey
	ClusterName          string
	Analysis             AnalysisCode
	LastBlockedTimestamp string
	BlockingRecoveryId   int64
}

type ByNamePort []*InstanceKey

type CLIFlag struct {
	Noop                       *bool
	SkipUnresolved             *bool
	SkipUnresolvedCheck        *bool
	BinlogFile                 *string
	GrabElection               *bool
	Version                    *bool
	Statement                  *string
	PromotionRule              *string
	ConfiguredVersion          string
	SkipBinlogSearch           *bool
	SkipContinuousRegistration *bool
	EnableDatabaseUpdate       *bool
	IgnoreRaftSetup            *bool
	Tag                        *string
}

type Cache struct {
	sync.Mutex
	Name string
	*cache.Cache
	// contains filtered or unexported fields
}

type CandidateDatabaseInstance struct {
	InstanceKey
	PromotionRule       CandidatePromotionRule
	LastSuggestedString string
	PromotionRuleExpiry string // generated when retrieved from database for consistency reasons
}

type CandidatePromotionRule string

type CliParam struct {
	Command                     string
	Strict                      bool
	DatabaseType                string
	ClusterId                   string
	Instance                    string
	Destination                 string
	Owner                       string
	Reason                      string
	Duration                    string
	Pattern                     string
	ClusterAlias                string
	Pool                        string
	HostnameFlag                string
	RawInstanceKey              *InstanceKey
	InstanceKey                 *InstanceKey
	DestinationKey              *InstanceKey
	PostponedFunctionsContainer *PostponedFunctionsContainer
}

type ClusterInfo struct {
	DatabaseType                           string
	ClusterName                            string
	ClusterAlias                           string // Human friendly alias
	ClusterDomain                          string // CNAME/VIP/A-record/whatever of the master of this cluster
	CountInstances                         uint
	HeuristicLag                           int64
	HasAutomatedMasterRecovery             bool
	HasAutomatedIntermediateMasterRecovery bool
}

type ClusterPoolInstance struct {
	ClusterName  string
	ClusterAlias string
	Pool         string
	Hostname     string
	Port         int
}

type Collection struct {
	sync.Mutex                     // for locking the structure
	MetricList   []MetricInterface // metrics of this collection
	Done         chan struct{}     // to indicate that we are finishing expiry processing
	ExpirePeriod time.Duration     // time to keep the MetricList information for
	// contains filtered or unexported fields
}

type CommandDesc struct {
	Command     string
	Category    string
	Section     string
	Description string
	Func        func(cliPrm *CliParam)
}

type CommandList []CommandDesc

type CommandSlice []string

type Downtime struct {
	Key            *InstanceKey
	Owner          string
	Reason         string
	Duration       time.Duration
	BeginsAt       time.Time
	EndsAt         time.Time
	BeginsAtString string
	EndsAtString   string
}

type DummySqlResult struct {
}

type HamHandler interface {
	SchemaBase() []string
	SchemaPatch() []string

	DriveName() string
	GetDBURI(host string, port int, args ...interface{}) string
	TLSCheck(string) bool
	TLSConfig(*tls.Config) error
	GetDBConnPool(uri string) (*sql.DB, error)

	// register cli command
	CliCmd(commandMap map[string]CommandDesc, cliParam *CliParam)

	// http api
	RegisterAPIRequest() map[string][]interface{}
	RegisterWebRequest() map[string][]interface{}

	// interface for sql in different case
	SQLProblemQuery() string
	SQLProblemCondition() string
	SQLProblemArgs(args ...interface{}) []interface{}

	// exec sql
	OpenTopology(host string, port int, args ...interface{}) (*sql.DB, error)
	ExecSQLOnInstance(instanceKey *InstanceKey, query string, args ...interface{}) (sql.Result, error)
	ScanInstanceRow(instanceKey *InstanceKey, query string, dest ...interface{}) error
	EmptyCommitInstance(instanceKey *InstanceKey) error

	// instance
	ReadFromBackendDB(instanceKey *InstanceKey) (InstanceAdaptor, bool, error)
	ReadInstanceByCondition(query string, condition string, args []interface{}, sort string) ([]InstanceAdaptor, error)
	ReadClusterInstances(clusterName string) ([]InstanceAdaptor, error)
	ReadReplicaInstances(masterKey *InstanceKey) ([]InstanceAdaptor, error)
	GetInfoFromInstance(ctx context.Context, instanceKey *InstanceKey, checkOnly, bufferWrites bool, latency *stopwatch.NamedStopwatch, agent string) (inst InstanceAdaptor, err error)
	GetSyncInfo(instanceKey *InstanceKey, bufferWrites bool, agent string) (interface{}, error)
	RowToInstance(rowMap sqlutil.RowMap) InstanceAdaptor
	WriteToBackendDB(context.Context, []InstanceAdaptor, bool, bool) error
	ForgetInstance(instanceKey *InstanceKey) error

	// replication
	StartReplication(ctx context.Context, instanceKey *InstanceKey) (interface{}, error)
	RestartReplication(instanceKey *InstanceKey) (interface{}, error)
	ResetReplication(instanceKey *InstanceKey) (InstanceAdaptor, error)
	CanReplicateFrom(first InstanceAdaptor, other InstanceAdaptor) (bool, error)
	StopReplication(*InstanceKey) (interface{}, error)
	StopReplicationNicely(instanceKey *InstanceKey, timeout time.Duration) (InstanceAdaptor, error)
	DelayReplication(instanceKey *InstanceKey, seconds int) error
	SetReadOnly(instanceKey *InstanceKey, readOnly bool) (InstanceAdaptor, error)
	SetSemiSyncOnDownstream(instanceKey *InstanceKey, enable bool) (InstanceAdaptor, error)
	SetSemiSyncOnUpstream(instanceKey *InstanceKey, enable bool) (InstanceAdaptor, error)
	SkipQuery(instanceKey *InstanceKey) (InstanceAdaptor, error)
	KillQuery(instanceKey *InstanceKey, process int64) (InstanceAdaptor, error)

	// master
	ChangeMasterTo(*InstanceKey, *InstanceKey, *LogCoordinates, bool, string) (InstanceAdaptor, error)
	DetachMaster(*InstanceKey) (InstanceAdaptor, error)
	ReattachMaster(*InstanceKey) (InstanceAdaptor, error)
	MakeCoMaster(instanceKey *InstanceKey) (InstanceAdaptor, error)
	MakeMaster(instanceKey *InstanceKey) (InstanceAdaptor, error)
	TakeMaster(instanceKey *InstanceKey, allowTakingCoMaster bool) (InstanceAdaptor, error)
	MakeLocalMaster(instanceKey *InstanceKey) (InstanceAdaptor, error)

	// topology
	MoveUp(instanceKey *InstanceKey) (InstanceAdaptor, error)
	MoveEquivalent(instanceKey, otherKey *InstanceKey) (InstanceAdaptor, error)
	MoveBelow(instanceKey, siblingKey *InstanceKey) (InstanceAdaptor, error)
	MoveUpReplicas(instanceKey *InstanceKey, pattern string) ([]InstanceAdaptor, InstanceAdaptor, error, []error)

	MatchUp(instanceKey *InstanceKey, requireInstanceMaintenance bool) (InstanceAdaptor, *LogCoordinates, error)
	MatchBelow(instanceKey, otherKey *InstanceKey, requireInstanceMaintenance bool) (InstanceAdaptor, *LogCoordinates, error)
	RelocateBelow(downstreamInstKey, upstreamInstKey *InstanceKey) (interface{}, error)
	RelocateReplicas(instanceKey, otherKey *InstanceKey, pattern string) (replicas []InstanceAdaptor, other InstanceAdaptor, err error, errs []error)

	MultiMatchReplicas(masterKey *InstanceKey, belowKey *InstanceKey, pattern string) ([]InstanceAdaptor, InstanceAdaptor, error, []error)
	MatchUpReplicas(masterKey *InstanceKey, pattern string) ([]InstanceAdaptor, InstanceAdaptor, error, []error)
	MultiMatchBelow(replicas []InstanceAdaptor, belowKey *InstanceKey, postponedFunctionsContainer *PostponedFunctionsContainer) (matchedReplicas []InstanceAdaptor, belowInstance InstanceAdaptor, err error, errs []error)

	RematchReplica(instanceKey *InstanceKey, requireInstanceMaintenance bool) (InstanceAdaptor, *LogCoordinates, error)
	TakeSiblings(instanceKey *InstanceKey) (instance InstanceAdaptor, takenSiblings int, err error)

	Repoint(*InstanceKey, *InstanceKey, string) (InstanceAdaptor, error)
	RegroupReplicas(masterKey *InstanceKey, returnReplicaEvenOnFailureToRegroup bool, onCandidateReplicaChosen func(InstanceAdaptor), postponedFunctionsContainer *PostponedFunctionsContainer) (aheadReplicas []InstanceAdaptor, equalReplicas []InstanceAdaptor, laterReplicas []InstanceAdaptor, cannotReplicateReplicas []InstanceAdaptor, instance InstanceAdaptor, err error)
	RepointReplicasTo(instanceKey *InstanceKey, pattern string, belowKey *InstanceKey) ([]InstanceAdaptor, error, []error)

	Topology(request *Request, historyTimestampPattern string, tabulated bool, printTags bool) (result interface{}, err error)

	ReplicationConfirm(failedKey *InstanceKey, streamKey *InstanceKey, upstream bool) bool

	// recovery
	GetReplicationAnalysis(clusterName, clusterId string, hints *ReplicationAnalysisHints) ([]ReplicationAnalysis, error)
	GetCheckAndRecoverFunction(analysisCode AnalysisCode, analyzedInstanceKey *InstanceKey) (
		checkAndRecoverFunction func(analysisEntry ReplicationAnalysis, candidateInstanceKey *InstanceKey, forceInstanceRecovery bool, skipProcesses bool) (recoveryAttempted bool, topologyRecovery *TopologyRecovery, err error),
		isActionableRecovery bool,
	)
	GetMasterRecoveryType(*ReplicationAnalysis) RecoveryType
	GetCandidateReplica(*InstanceKey, bool) (InstanceAdaptor, []InstanceAdaptor, []InstanceAdaptor, []InstanceAdaptor, []InstanceAdaptor, error)
	CategorizeReplication(*TopologyRecovery, *InstanceKey, func(InstanceAdaptor, bool) bool) (aheadReplicas, equalReplicas, laterReplicas, cannotReplicateReplicas []InstanceAdaptor, promotedReplica InstanceAdaptor, err error)
	RunEmergentOperations(analysisEntry *ReplicationAnalysis)
	CheckIfWouldBeMaster(InstanceAdaptor) bool
	//CheckAndRecoverDeadMaster(analysisEntry dtstruct.ReplicationAnalysis, candidateInstanceKey *dtstruct.InstanceKey, forceInstanceRecovery bool, skipProcesses bool) (recoveryAttempted bool, topologyRecovery *dtstruct.TopologyRecovery, err error)
	GracefulMasterTakeover(clusterName string, designatedKey *InstanceKey, auto bool) (topologyRecovery *TopologyRecovery, promotedMasterCoordinates *LogCoordinates, err error)

	// interface for agent
	BaseInfo() string
	MasterInfo() string
	SlaveInfo() string
	CascadeInfo() string
}

type HostAttributes struct {
	Hostname        string
	AttributeName   string
	AttributeValue  string
	SubmitTimestamp string
	ExpireTimestamp string
}

type HostnameRegistration struct {
	CreatedAt time.Time
	Key       InstanceKey
	Hostname  string
}

type HostnameResolve struct {
	Hostname         string
	ResolvedHostname string
}

type HostnameUnresolve struct {
	Hostname           string
	UnresolvedHostname string
}

type HttpAPI struct {
	URLPrefix string
}

type Instance struct {
	Uptime                    uint
	Key                       InstanceKey
	InstanceId                string
	InstanceAlias             string
	ClusterId                 string
	Version                   string
	VersionComment            string
	UpstreamKey               InstanceKey
	DownstreamKeyMap          InstanceKeyMap
	Role                      string
	DBState                   string
	IsCoUpstream              bool
	ReadOnly                  bool
	LastSeenTimestamp         string
	IsLastCheckValid          bool
	IsUpToDate                bool
	IsRecentlyChecked         bool
	ClusterName               string
	FlavorName                string
	DataCenter                string
	Region                    string
	Environment               string
	SuggestedClusterAlias     string
	ReplicationState          string
	ReplicationDepth          uint
	HasReplicationFilters     bool
	AllowTLS                  bool
	HasReplicationCredentials bool

	IsDetachedMaster bool

	SlaveLagSeconds       sql.NullInt64 // for API backwards compatibility. Equals `ReplicationLagSeconds`
	ReplicationLagSeconds sql.NullInt64

	ReplicationCredentialsAvailable bool

	SecondsSinceLastSeen sql.NullInt64

	// Careful. IsCandidate and PromotionRule are used together
	// and probably need to be merged. IsCandidate's value may
	// be picked up from daabase_candidate_instance's value when
	// reading an instance from the db.
	IsCandidate          bool
	PromotionRule        CandidatePromotionRule
	IsDowntimed          bool
	DowntimeReason       string
	DowntimeOwner        string
	DowntimeEndTimestamp string
	ElapsedDowntime      time.Duration
	UnresolvedHostname   string

	Problems []string

	LastDiscoveryLatency time.Duration

	Seed bool // Means we force this instance to be written to backend, even if it's invalid, empty or forgotten

}

type InstanceAdaptor interface {

	// get instance database type
	GetDatabaseType() string

	// get instance hostname
	GetHostname() string

	// get instance port
	GetPort() int

	// get handler for this instance
	GetHandler() InstanceAdaptor

	// get instance all replicas
	GetReplicas() InstanceKeyMap

	// get upstream and downstream instance
	GetAssociateInstance() []InstanceKey

	// get instance info
	GetInstance() *Instance

	// get instance description
	HumanReadableDescription() string

	// set promotion rule for candidate instance
	SetPromotionRule(CandidatePromotionRule)

	// set hostname/port/cluster name
	SetHstPrtAndClusterName(hostname string, port int, upstreamHostname string, upstreamPort int, clusterName string)

	// set instance
	SetInstance(*Instance)

	// set instance favor name
	SetFlavorName()

	// check if instance's replication is running
	ReplicaRunning() bool

	// check if instance is a binlog serve
	IsReplicaServer() bool

	// check if instance is replica
	IsReplica() bool

	// for instance sort
	Less(handler InstanceAdaptor, dataCenter string) bool
}

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

type InstanceBinlogCoordinates struct {
	Key         InstanceKey
	Coordinates LogCoordinates
}

type InstanceKey struct {
	DBType    string
	Hostname  string
	Port      int
	ClusterId string
}

type InstanceKeyMap map[InstanceKey]bool

type InstanceTag struct {
	Key InstanceKey
	T   Tag
}

type InstancesByCountReplicas []InstanceAdaptor

type KVPair struct {
	Key   string
	Value string
}

type KVStore interface {
	PutKeyValue(key string, value string) (err error)
	PutKVPairs(kvPairs []*KVPair) (err error)
	GetKeyValue(key string) (value string, found bool, err error)
	DistributePairs(kvPairs [](*KVPair)) (err error)
}

type LogCoordinates struct {
	LogFile string
	LogPos  int64
	Type    constant.LogType
}

type Maintenance struct {
	MaintenanceId  uint
	Key            InstanceKey
	BeginTimestamp string
	SecondsElapsed uint
	IsActive       bool
	Owner          string
	Reason         string
}

type Metric struct {
	Timestamp      time.Time     // time the metric was started
	WaitLatency    time.Duration // time that we had to wait before starting query execution
	ExecuteLatency time.Duration // time the query took to execute
	Err            error         // any error resulting from the query execution
}

type MetricAggregate struct {
	stats.Float64Data
}

type MetricAggregatedDiscovery struct {
	FirstSeen                       time.Time // timestamp of the first data seen
	LastSeen                        time.Time // timestamp of the last data seen
	CountDistinctInstanceKeys       int       // number of distinct Instances seen (note: this may not be true: distinct = succeeded + failed)
	CountDistinctOkInstanceKeys     int       // number of distinct Instances which succeeded
	CountDistinctFailedInstanceKeys int       // number of distinct Instances which failed
	FailedDiscoveries               uint64    // number of failed discoveries
	SuccessfulDiscoveries           uint64    // number of successful discoveries
	MeanTotalSeconds                float64
	MeanBackendSeconds              float64
	MeanInstanceSeconds             float64
	FailedMeanTotalSeconds          float64
	FailedMeanBackendSeconds        float64
	FailedMeanInstanceSeconds       float64
	MaxTotalSeconds                 float64
	MaxBackendSeconds               float64
	MaxInstanceSeconds              float64
	FailedMaxTotalSeconds           float64
	FailedMaxBackendSeconds         float64
	FailedMaxInstanceSeconds        float64
	MedianTotalSeconds              float64
	MedianBackendSeconds            float64
	MedianInstanceSeconds           float64
	FailedMedianTotalSeconds        float64
	FailedMedianBackendSeconds      float64
	FailedMedianInstanceSeconds     float64
	P95TotalSeconds                 float64
	P95BackendSeconds               float64
	P95InstanceSeconds              float64
	FailedP95TotalSeconds           float64
	FailedP95BackendSeconds         float64
	FailedP95InstanceSeconds        float64
}

type MetricAggregatedQuery struct {
	Count             int
	MaxExecSeconds    float64
	MeanExecSeconds   float64
	MedianExecSeconds float64
	P95ExecSeconds    float64
	MaxWaitSeconds    float64
	MeanWaitSeconds   float64
	MedianWaitSeconds float64
	P95WaitSeconds    float64
}

type MetricAggregatedQueue struct {
	ActiveMinEntries    float64
	ActiveMeanEntries   float64
	ActiveMedianEntries float64
	ActiveP95Entries    float64
	ActiveMaxEntries    float64
	QueuedMinEntries    float64
	QueuedMeanEntries   float64
	QueuedMedianEntries float64
	QueuedP95Entries    float64
	QueuedMaxEntries    float64
}

type MetricDiscover struct {
	Timestamp       time.Time     // time the collection was taken
	InstanceKey     InstanceKey   // instance being monitored
	BackendLatency  time.Duration // time taken talking to the backend
	InstanceLatency time.Duration // time taken talking to the instance
	TotalLatency    time.Duration // total time taken doing the discovery
	Err             error         // error (if applicable) doing the discovery process
}

type MetricInterface interface {
	When() time.Time // when the metric was taken
}

type MetricQueue struct {
	Active int
	Queued int
}

type MinimalInstance struct {
	Key         InstanceKey
	MasterKey   InstanceKey
	ClusterName string
}

type Monitor interface {
	Init() error
}

type MultiSQL struct {
	Query []string
	Args  [][]interface{}
}

type PeerAnalysisMap map[string]int

type PoolInstancesMap map[string][]*InstanceKey

type PoolInstancesSubmission struct {
	CreatedAt          time.Time
	DatabaseType       string
	Pool               string
	DelimitedInstances string
	RegisteredAt       string
}

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

type Process struct {
	InstanceHostname string
	InstancePort     int
	Id               int64
	User             string
	Host             string
	Db               string
	Command          string
	Time             int64
	State            string
	Info             string
	StartedAt        string
}

type Queue struct {
	sync.Mutex
	// contains filtered or unexported fields
}

type RecoveryAcknowledgement struct {
	CreatedAt time.Time
	Owner     string
	Comment   string

	Key           InstanceKey
	ClusterName   string
	Id            int64
	UID           string
	AllRecoveries bool
}

type RecoveryType string

type ReplicationAnalysis struct {
	AnalyzedInstanceKey                       InstanceKey
	AnalyzedInstanceUpstreamKey               InstanceKey
	ClusterDetails                            ClusterInfo
	AnalyzedInstanceDataCenter                string
	AnalyzedInstanceRegion                    string
	AnalyzedInstanceBinlogCoordinates         LogCoordinates
	IsMaster                                  bool
	IsReplicationGroupMember                  bool
	IsCoMaster                                bool
	LastCheckValid                            bool
	LastCheckPartialSuccess                   bool
	CountReplicas                             uint
	CountValidReplicas                        uint
	CountValidReplicatingReplicas             uint
	CountReplicasFailingToConnectToMaster     uint
	CountDowntimedReplicas                    uint
	ReplicationDepth                          uint
	Downstreams                               InstanceKeyMap
	SlaveHosts                                InstanceKeyMap // for backwards compatibility. Equals `DownstreamKeyMap`
	IsFailingToConnectToMaster                bool
	Analysis                                  AnalysisCode
	Description                               string
	StructureAnalysis                         []StructureAnalysisCode
	IsDowntimed                               bool
	IsReplicasDowntimed                       bool // as good as downtimed because all replicas are downtimed AND analysis is all about the replicas (e.e. AllMasterReplicasNotReplicating)
	DowntimeEndTimestamp                      string
	DowntimeRemainingSeconds                  int
	IsReplicaServer                           bool
	PseudoGTIDImmediateTopology               bool
	OracleGTIDImmediateTopology               bool
	MariaDBGTIDImmediateTopology              bool
	BinlogServerImmediateTopology             bool
	SemiSyncMasterEnabled                     bool
	SemiSyncMasterStatus                      bool
	SemiSyncMasterWaitForReplicaCount         uint
	SemiSyncMasterClients                     uint
	CountSemiSyncReplicasEnabled              uint
	CountLoggingReplicas                      uint
	CountStatementBasedLoggingReplicas        uint
	CountMixedBasedLoggingReplicas            uint
	CountRowBasedLoggingReplicas              uint
	CountDistinctMajorVersionsLoggingReplicas uint
	CountDelayedReplicas                      uint
	CountLaggingReplicas                      uint
	IsActionableRecovery                      bool
	ProcessingNodeHostname                    string
	ProcessingNodeToken                       string
	CountAdditionalAgreeingNodes              int
	StartActivePeriod                         string
	SkippableDueToDowntime                    bool
	GTIDMode                                  string
	MinReplicaGTIDMode                        string
	MaxReplicaGTIDMode                        string
	MaxReplicaGTIDErrant                      string
	CommandHint                               string
	IsReadOnly                                bool

	//for opengauss
	CountPrimary int
}

type ReplicationAnalysisChangelog struct {
	AnalyzedInstanceKey InstanceKey
	Changelog           []string
}

type ReplicationAnalysisHints struct {
	IncludeDowntimed bool
	IncludeNoProblem bool
	AuditAnalysis    bool
}

type ReplicationCredentials struct {
	User      string
	Password  string
	SSLCert   string
	SSLKey    string
	SSLCaCert string
}

type Request struct {
	*InstanceKey
	Hint string
}

type SnapshotData struct {
	Keys             []InstanceKey // Kept for backwards comapatibility
	MinimalInstances []MinimalInstance
	RecoveryDisabled bool

	ClusterAlias,
	ClusterAliasOverride,
	ClusterDomainName,
	HostAttributes,
	InstanceTags,
	AccessToken,
	PoolInstances,
	InjectedPseudoGTIDClusters,
	HostnameResolves,
	HostnameUnresolves,
	DowntimedInstances,
	Candidates,
	Detections,
	KVStore,
	Recovery,
	RecoverySteps sqlutil.NamedResultData

	LeaderURI string
}

type SnapshotHandler interface {
	Snapshot() (data []byte, err error)
	Restore(rc io.ReadCloser) error
}

type StructureAnalysisCode string

type Tag struct {
	TagName  string
	TagValue string
	HasValue bool
	Negate   bool
}

type Token struct {
	Hash string
}

type TopologyRecovery struct {
	PostponedFunctionsContainer

	Id                        int64
	UID                       string
	AnalysisEntry             ReplicationAnalysis
	SuccessorKey              *InstanceKey
	SuccessorAlias            string
	IsActive                  bool
	IsSuccessful              bool
	LostReplicas              InstanceKeyMap
	ParticipatingInstanceKeys InstanceKeyMap
	AllErrors                 []string
	RecoveryStartTimestamp    string
	RecoveryEndTimestamp      string
	ProcessingNodeHostname    string
	ProcessingNodeToken       string
	Acknowledged              bool
	AcknowledgedAt            string
	AcknowledgedBy            string
	AcknowledgedComment       string
	LastDetectionId           int64
	RelatedRecoveryId         int64
	Type                      RecoveryType
	RecoveryType              RecoveryType
}

type TopologyRecoveryStep struct {
	Id          int64
	RecoveryUID string
	AuditAt     string
	Message     string
}

type Worker struct {
	Name string // worker name, better to define in constant with "WorkerName" prefix
	// contains filtered or unexported fields
}

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

type WriteBufferMetric struct {
	Timestamp    time.Time     // time the metric was started
	Instances    int           // number of flushed instances
	WaitLatency  time.Duration // waiting before flush
	WriteLatency time.Duration // time writing to backend
}