inst

package
v0.12.0 Latest Latest
Warning

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

Go to latest
Published: Oct 26, 2021 License: Apache-2.0 Imports: 42 Imported by: 0

Documentation

Index

Constants

View Source
const (
	ForcePrimaryFailoverCommandHint    string = "force-primary-failover"
	ForcePrimaryTakeoverCommandHint    string = "force-primary-takeover"
	GracefulPrimaryTakeoverCommandHint string = "graceful-primary-takeover"
)
View Source
const (
	// Group member roles
	GroupReplicationMemberRolePrimary   = "PRIMARY"
	GroupReplicationMemberRoleSecondary = "SECONDARY"
	// Group member states
	GroupReplicationMemberStateOnline      = "ONLINE"
	GroupReplicationMemberStateRecovering  = "RECOVERING"
	GroupReplicationMemberStateUnreachable = "UNREACHABLE"
	GroupReplicationMemberStateOffline     = "OFFLINE"
	GroupReplicationMemberStateError       = "ERROR"
)

Constant strings for Group Replication information See https://dev.mysql.com/doc/refman/8.0/en/replication-group-members-table.html for additional information.

View Source
const (
	Error1201CouldnotInitializePrimaryInfoStructure = "Error 1201:"
)
View Source
const ReasonableDiscoveryLatency = 500 * time.Millisecond

Variables

View Source
var (
	DowntimeLostInRecoveryMessage = "lost-in-recovery"
)
View Source
var ErrTabletAliasNil = errors.New("tablet alias is nil")

ErrTabletAliasNil is a fixed error message.

View Source
var GroupReplicationNotSupportedErrors = map[uint16]bool{

	1193: true,
	1146: true,
}

We use this map to identify whether the query failed because the server does not support group replication or due to a different reason.

View Source
var ReplicationNotRunningError = fmt.Errorf("Replication not running")
View Source
var (
	TagEqualsRegexp = regexp.MustCompile("^([^=]+)=(.*)$")
)
View Source
var TopoServ *topo.Server

TopoServ is the connection to the topo server.

Functions

func ASCIITopology

func ASCIITopology(clusterName string, historyTimestampPattern string, tabulated bool, printTags bool) (result string, err error)

ASCIITopology returns a string representation of the topology of given cluster.

func ApplyPoolInstances

func ApplyPoolInstances(submission *PoolInstancesSubmission) error

func AuditOperation

func AuditOperation(auditType string, instanceKey *InstanceKey, message string) error

AuditOperation creates and writes a new audit entry by given params

func BeginBoundedMaintenance

func BeginBoundedMaintenance(instanceKey *InstanceKey, owner string, reason string, durationSeconds uint, explicitlyBounded bool) (int64, error)

BeginBoundedMaintenance will make new maintenance entry for given instanceKey.

func BeginDowntime

func BeginDowntime(downtime *Downtime) (err error)

BeginDowntime will make mark an instance as downtimed (or override existing downtime period)

func BeginMaintenance

func BeginMaintenance(instanceKey *InstanceKey, owner string, reason string) (int64, error)

BeginMaintenance will make new maintenance entry for given instanceKey. Maintenance time is unbounded

func ChangeTabletType

func ChangeTabletType(instanceKey InstanceKey, tabletType topodatapb.TabletType) (*topodatapb.Tablet, error)

ChangeTabletType designates the tablet that owns an instance as the primary.

func CheckMoveViaGTID

func CheckMoveViaGTID(instance, otherInstance *Instance) (err error)

func DeduceClusterName

func DeduceClusterName(nameOrAlias string) (clusterName string, err error)

DeduceClusterName attempts to resolve a cluster name given a name or alias. If unsuccessful to match by alias, the function returns the same given string

func DeleteHostnameUnresolve

func DeleteHostnameUnresolve(instanceKey *InstanceKey) error

DeleteHostnameUnresolve removes an unresolve entry

func DeleteInvalidHostnameResolves

func DeleteInvalidHostnameResolves() error

DeleteInvalidHostnameResolves removes invalid resolves. At this time these are: - infinite loop resolves (A->B and B->A), remove earlier mapping

func EmptyCommitInstance

func EmptyCommitInstance(instanceKey *InstanceKey) error

EmptyCommitInstance issues an empty COMMIT on a given instance

func EnableAuditSyslog

func EnableAuditSyslog() (err error)

EnableSyslogWriter enables, if possible, writes to syslog. These will execute _in addition_ to normal logging

func EndDowntime

func EndDowntime(instanceKey *InstanceKey) (wasDowntimed bool, err error)

EndDowntime will remove downtime flag from an instance

func EndMaintenance

func EndMaintenance(maintenanceToken int64) (wasMaintenance bool, err error)

EndMaintenance will terminate an active maintenance via maintenanceToken

func EndMaintenanceByInstanceKey

func EndMaintenanceByInstanceKey(instanceKey *InstanceKey) (wasMaintenance bool, err error)

EndMaintenanceByInstanceKey will terminate an active maintenance using given instanceKey as hint

func ErrantGTIDInjectEmpty

func ErrantGTIDInjectEmpty(instanceKey *InstanceKey) (instance *Instance, clusterPrimary *Instance, countInjectedTransactions int64, err error)

ErrantGTIDInjectEmpty will inject an empty transaction on the primary of an instance's cluster in order to get rid of an errant transaction observed on the instance.

func ExecDBWriteFunc

func ExecDBWriteFunc(f func() error) error

ExecDBWriteFunc chooses how to execute a write onto the database: whether synchronuously or not

func ExecInstance

func ExecInstance(instanceKey *InstanceKey, query string, args ...interface{}) (sql.Result, error)

ExecInstance executes a given query on the given MySQL topology instance

func ExecuteOnTopology

func ExecuteOnTopology(f func())

ExecuteOnTopology will execute given function while maintaining concurrency limit on topology servers. It is safe in the sense that we will not leak tokens.

func ExpireAudit

func ExpireAudit() error

ExpireAudit removes old rows from the audit table

func ExpireCandidateInstances

func ExpireCandidateInstances() error

ExpireCandidateInstances removes stale primary candidate suggestions.

func ExpireClusterDomainName

func ExpireClusterDomainName() error

ExpireClusterDomainName expires cluster_domain_name entries that haven't been updated recently.

func ExpireDowntime

func ExpireDowntime() error

ExpireDowntime will remove the maintenance flag on old downtimes

func ExpireHostnameUnresolve

func ExpireHostnameUnresolve() error

ExpireHostnameUnresolve expires hostname_unresolve entries that haven't been updated recently.

func ExpireInstanceAnalysisChangelog

func ExpireInstanceAnalysisChangelog() error

ExpireInstanceAnalysisChangelog removes old-enough analysis entries from the changelog

func ExpireMaintenance

func ExpireMaintenance() error

ExpireMaintenance will remove the maintenance flag on old maintenances and on bounded maintenances

func ExpirePoolInstances

func ExpirePoolInstances() error

ExpirePoolInstances cleans up the database_instance_pool table from expired items

func ExpireStaleInstanceBinlogCoordinates

func ExpireStaleInstanceBinlogCoordinates() error

func ExpireTableData

func ExpireTableData(tableName string, timestampColumn string) error

func FigureClusterName

func FigureClusterName(clusterHint string, instanceKey *InstanceKey, thisInstanceKey *InstanceKey) (clusterName string, err error)

FigureClusterName will make a best effort to deduce a cluster name using either a given alias or an instanceKey. First attempt is at alias, and if that doesn't work, we try instanceKey. - clusterHint may be an empty string

func FlushNontrivialResolveCacheToDatabase

func FlushNontrivialResolveCacheToDatabase() error

func ForgetCluster

func ForgetCluster(clusterName string) error

ForgetInstance removes an instance entry from the orchestrator backed database. It may be auto-rediscovered through topology or requested for discovery by multiple means.

func ForgetExpiredHostnameResolves

func ForgetExpiredHostnameResolves() error

ForgetExpiredHostnameResolves

func ForgetInstance

func ForgetInstance(instanceKey *InstanceKey) error

ForgetInstance removes an instance entry from the orchestrator backed database. It may be auto-rediscovered through topology or requested for discovery by multiple means.

func ForgetLongUnseenInstances

func ForgetLongUnseenInstances() error

ForgetLongUnseenInstances will remove entries of all instacnes that have long since been last seen.

func ForgetUnseenInstancesDifferentlyResolved

func ForgetUnseenInstancesDifferentlyResolved() error

ForgetUnseenInstancesDifferentlyResolved will purge instances which are invalid, and whose hostname appears on the hostname_resolved table; this means some time in the past their hostname was unresovled, and now resovled to a different value; the old hostname is never accessed anymore and the old entry should be removed.

func GTIDSubtract

func GTIDSubtract(instanceKey *InstanceKey, gtidSet string, gtidSubset string) (gtidSubtract string, err error)

func GetCNAME

func GetCNAME(hostname string) (string, error)

GetCNAME resolves an IP or hostname into a normalized valid CNAME

func GetCandidateReplica

func GetCandidateReplica(primaryKey *InstanceKey, forRematchPurposes bool) (*Instance, [](*Instance), [](*Instance), [](*Instance), [](*Instance), error)

GetCandidateReplica chooses the best replica to promote given a (possibly dead) primary

func GetClusterByAlias

func GetClusterByAlias(alias string) (string, error)

GetClusterByAlias returns the cluster name associated with given alias. The function returns with error when: - No cluster is associated with the alias - More than one cluster is associated with the alias

func GetClusterHeuristicLag

func GetClusterHeuristicLag(clusterName string) (int64, error)

GetClusterHeuristicLag returns a heuristic lag for a cluster, based on its OSC replicas

func GetClusterName

func GetClusterName(instanceKey *InstanceKey) (clusterName string, err error)

func GetClusterPrimaryKVKey added in v0.12.0

func GetClusterPrimaryKVKey(clusterAlias string) string

func GetClusterPrimaryKVPairs added in v0.12.0

func GetClusterPrimaryKVPairs(clusterAlias string, primaryKey *InstanceKey) (kvPairs [](*kv.KVPair))

GetClusterPrimaryKVPairs returns all KV pairs associated with a primary. This includes the full identity of the primary as well as a breakdown by hostname, port, ipv4, ipv6

func GetHeuristicClusterPoolInstancesLag

func GetHeuristicClusterPoolInstancesLag(clusterName string, pool string) (int64, error)

GetHeuristicClusterPoolInstancesLag returns a heuristic lag for the instances participating in a cluster pool (or all the cluster's pools)

func GetInstancesMaxLag

func GetInstancesMaxLag(instances [](*Instance)) (maxLag int64, err error)

GetInstancesMaxLag returns the maximum lag in a set of instances

func GetMaintenanceOwner

func GetMaintenanceOwner() string

func GetPrimariesKVPairs added in v0.12.0

func GetPrimariesKVPairs(clusterName string) (kvPairs [](*kv.KVPair), err error)

Get a listing of KVPair for clusters primaries, for all clusters or for a specific cluster.

func GetReplicationRestartPreserveStatements

func GetReplicationRestartPreserveStatements(instanceKey *InstanceKey, injectedStatement string) (statements []string, err error)

GetReplicationRestartPreserveStatements returns a sequence of statements that make sure a replica is stopped and then returned to the same state. For example, if the replica was fully running, this will issue a STOP on both io_thread and sql_thread, followed by START on both. If one of them is not running at the time this function is called, said thread will be neither stopped nor started. The caller may provide an injected statememt, to be executed while the replica is stopped. This is useful for CHANGE MASTER TO commands, that unfortunately must take place while the replica is completely stopped.

func HostnameResolveCache

func HostnameResolveCache() (map[string]cache.Item, error)

func HostnameResolveMethodIsNone

func HostnameResolveMethodIsNone() bool

func InMaintenance

func InMaintenance(instanceKey *InstanceKey) (inMaintenance bool, err error)

InMaintenance checks whether a given instance is under maintenacne

func InjectSeed

func InjectSeed(instanceKey *InstanceKey) error

InjectSeed: intented to be used to inject an instance upon startup, assuming it's not already known to orchestrator.

func InjectUnseenPrimaries added in v0.12.0

func InjectUnseenPrimaries() error

InjectUnseenPrimaries will review primaries of instances that are known to be replicating, yet which are not listed in database_instance. Since their replicas are listed as replicating, we can assume that such primaries actually do exist: we shall therefore inject them with minimal details into the database_instance table.

func InstanceIsForgotten

func InstanceIsForgotten(instanceKey *InstanceKey) bool

func InstanceIsPrimaryOf added in v0.12.0

func InstanceIsPrimaryOf(allegedPrimary, allegedReplica *Instance) bool

InstanceIsPrimaryOf checks whether an instance is the primary of another

func InstanceTagExists

func InstanceTagExists(instanceKey *InstanceKey, tag *Tag) (tagExists bool, err error)

func InstancesAreSiblings

func InstancesAreSiblings(instance0, instance1 *Instance) bool

InstancesAreSiblings checks whether both instances are replicating from same primary

func IsBannedFromBeingCandidateReplica

func IsBannedFromBeingCandidateReplica(replica *Instance) bool

func IsSmallerBinlogFormat

func IsSmallerBinlogFormat(binlogFormat string, otherBinlogFormat string) bool

IsSmallerBinlogFormat tests two binlog formats and sees if one is "smaller" than the other. "smaller" binlog format means you can replicate from the smaller to the larger.

func IsSmallerMajorVersion

func IsSmallerMajorVersion(version string, otherVersion string) bool

IsSmallerMajorVersion tests two versions against another and returns true if the former is a smaller "major" varsion than the latter. e.g. 5.5.36 is NOT a smaller major version as comapred to 5.5.40, but IS as compared to 5.6.9

func LoadHostnameResolveCache

func LoadHostnameResolveCache() error

func LocateErrantGTID

func LocateErrantGTID(instanceKey *InstanceKey) (errantBinlogs []string, err error)

func MajorVersion

func MajorVersion(version string) []string

MajorVersion returns a MySQL major version number (e.g. given "5.5.36" it returns "5.5")

func MoveReplicasGTID

func MoveReplicasGTID(primaryKey *InstanceKey, belowKey *InstanceKey, pattern string) (movedReplicas [](*Instance), unmovedReplicas [](*Instance), err error, errs []error)

MoveReplicasGTID will (attempt to) move all replicas of given primary below given instance.

func MoveUpReplicas

func MoveUpReplicas(instanceKey *InstanceKey, pattern string) ([](*Instance), *Instance, error, []error)

MoveUpReplicas will attempt moving up all replicas of a given instance, at the same time. Clock-time, this is fater than moving one at a time. However this means all replicas of the given instance, and the instance itself, will all stop replicating together.

func NewBinlogFormatSortedByCount

func NewBinlogFormatSortedByCount(formatsCount map[string]int) *binlogFormatSortedByCount

func NewMajorVersionsSortedByCount

func NewMajorVersionsSortedByCount(versionsCount map[string]int) *majorVersionsSortedByCount

func PopulateGroupReplicationInformation

func PopulateGroupReplicationInformation(instance *Instance, db *sql.DB) error

PopulateGroupReplicationInformation obtains information about Group Replication for this host as well as other hosts who are members of the same group (if any).

func PopulateInstancesAgents

func PopulateInstancesAgents(instances [](*Instance)) error

PopulateInstancesAgents will fill in extra data acquired from agents for given instances At current this is the number of snapshots. This isn't too pretty; it's a push-into-instance-data-that-belongs-to-agent thing. Originally the need was to visually present the number of snapshots per host on the web/cluster page, which indeed proves to be useful in our experience.

func PrimarySemiSync added in v0.12.0

func PrimarySemiSync(instanceKey InstanceKey) int

PrimarySemiSync returns the primary semi-sync setting for the instance. 0 means none. Non-zero specifies the number of required ackers.

func PutInstanceTag

func PutInstanceTag(instanceKey *InstanceKey, tag *Tag) (err error)

func ReadAliasByClusterName

func ReadAliasByClusterName(clusterName string) (alias string, err error)

ReadAliasByClusterName returns the cluster alias for the given cluster name, or the cluster name itself if not explicit alias found

func ReadClusterNameByAlias

func ReadClusterNameByAlias(alias string) (clusterName string, err error)

ReadClusterNameByAlias

func ReadClusters

func ReadClusters() (clusterNames []string, err error)

ReadClusters reads names of all known clusters

func ReadCountMySQLSnapshots

func ReadCountMySQLSnapshots(hostnames []string) (map[string]int, error)

ReadCountMySQLSnapshots is a utility method to return registered number of snapshots for a given list of hosts

func ReadInstanceClusterAttributes

func ReadInstanceClusterAttributes(instance *Instance) (err error)

ReadInstanceClusterAttributes will return the cluster name for a given instance by looking at its primary and getting it from there. It is a non-recursive function and so-called-recursion is performed upon periodic reading of instances.

func ReadInstancePromotionRule

func ReadInstancePromotionRule(instance *Instance) (err error)

func ReadInstanceTag

func ReadInstanceTag(instanceKey *InstanceKey, tag *Tag) (tagExists bool, err error)

func ReadReplicationGroupPrimary

func ReadReplicationGroupPrimary(instance *Instance) (err error)

func ReadResolvedHostname

func ReadResolvedHostname(hostname string) (string, error)

ReadResolvedHostname returns the resolved hostname given a hostname, or empty if not exists

func ReadTablet

func ReadTablet(instanceKey InstanceKey) (*topodatapb.Tablet, error)

ReadTablet reads the vitess tablet record.

func ReadUnambiguousSuggestedClusterAliases

func ReadUnambiguousSuggestedClusterAliases() (result map[string]InstanceKey, err error)

ReadUnambiguousSuggestedClusterAliases reads potential primary hostname:port who have suggested cluster aliases, where no one else shares said suggested cluster alias. Such hostname:port are likely true owners of the alias.

func RecordStaleInstanceBinlogCoordinates

func RecordStaleInstanceBinlogCoordinates(instanceKey *InstanceKey, binlogCoordinates *BinlogCoordinates) error

RecordInstanceCoordinatesHistory snapshots the binlog coordinates of instances

func RefreshTopologyInstances

func RefreshTopologyInstances(instances [](*Instance))

RefreshTopologyInstances will do a blocking (though concurrent) refresh of all given instances

func RegexpMatchPatterns

func RegexpMatchPatterns(s string, regexpPatterns []string) bool

RegexpMatchPatterns returns true if s matches any of the provided regexpPatterns

func RegisterCandidateInstance

func RegisterCandidateInstance(candidate *CandidateDatabaseInstance) error

RegisterCandidateInstance markes a given instance as suggested for succeeding a primary in the event of failover.

func RegisterHostnameUnresolve

func RegisterHostnameUnresolve(registration *HostnameRegistration) (err error)

func RegroupReplicas

func RegroupReplicas(primaryKey *InstanceKey, returnReplicaEvenOnFailureToRegroup bool,
	onCandidateReplicaChosen func(*Instance),
	postponedFunctionsContainer *PostponedFunctionsContainer) (

	aheadReplicas [](*Instance),
	equalReplicas [](*Instance),
	laterReplicas [](*Instance),
	cannotReplicateReplicas [](*Instance),
	instance *Instance,
	err error,
)

RegroupReplicas is a "smart" method of promoting one replica over the others ("promoting" it on top of its siblings) This method decides which strategy to use: GTID, Binlog Servers.

func RegroupReplicasBinlogServers

func RegroupReplicasBinlogServers(primaryKey *InstanceKey, returnReplicaEvenOnFailureToRegroup bool) (repointedBinlogServers [](*Instance), promotedBinlogServer *Instance, err error)

RegroupReplicasBinlogServers works on a binlog-servers topology. It picks the most up-to-date BLS and repoints all other BLS below it

func RegroupReplicasGTID

func RegroupReplicasGTID(
	primaryKey *InstanceKey,
	returnReplicaEvenOnFailureToRegroup bool,
	onCandidateReplicaChosen func(*Instance),
	postponedFunctionsContainer *PostponedFunctionsContainer,
	postponeAllMatchOperations func(*Instance, bool) bool,
) (
	lostReplicas [](*Instance),
	movedReplicas [](*Instance),
	cannotReplicateReplicas [](*Instance),
	candidateReplica *Instance,
	err error,
)

RegroupReplicasGTID will choose a candidate replica of a given instance, and take its siblings using GTID

func RelocateReplicas

func RelocateReplicas(instanceKey, otherKey *InstanceKey, pattern string) (replicas [](*Instance), other *Instance, err error, errs []error)

RelocateReplicas will attempt moving replicas of an instance indicated by instanceKey below another instance. Orchestrator will try and figure out the best way to relocate the servers. This could span normal binlog-position, repointing, binlog servers...

func ReplaceAliasClusterName

func ReplaceAliasClusterName(oldClusterName string, newClusterName string) (err error)

ReplaceAliasClusterName replaces alis mapping of one cluster name onto a new cluster name. Used in topology failover/recovery

func ReplaceClusterName

func ReplaceClusterName(oldClusterName string, newClusterName string) error

ReplaceClusterName replaces all occurrences of oldClusterName with newClusterName It is called after a primary failover

func ReplicaSemiSync

func ReplicaSemiSync(primaryKey, replicaKey InstanceKey) bool

ReplicaSemiSync returns the replica semi-sync setting for the instance.

func ReplicaSemiSyncFromTablet

func ReplicaSemiSyncFromTablet(primary, replica *topodatapb.Tablet) bool

ReplicaSemiSyncFromTablet returns the replica semi-sync setting from the tablet record. Prefer using this function if tablet record is available.

func ResetHostnameResolveCache

func ResetHostnameResolveCache() error

func ResetInstanceRelaylogCoordinatesHistory

func ResetInstanceRelaylogCoordinatesHistory(instanceKey *InstanceKey) error

ResetInstanceRelaylogCoordinatesHistory forgets about the history of an instance. This action is desirable when relay logs become obsolete or irrelevant. Such is the case on `CHANGE MASTER TO`: servers gets compeltely new relay logs.

func ResolveHostname

func ResolveHostname(hostname string) (string, error)

Attempt to resolve a hostname. This may return a database cached hostname or otherwise it may resolve the hostname via CNAME

func ResolveHostnameIPs

func ResolveHostnameIPs(hostname string) error

func ResolveUnknownPrimaryHostnameResolves added in v0.12.0

func ResolveUnknownPrimaryHostnameResolves() error

ResolveUnknownPrimaryHostnameResolves fixes missing hostname resolves based on hostname_resolve_history The use case is replicas replicating from some unknown-hostname which cannot be otherwise found. This could happen due to an expire unresolve together with clearing up of hostname cache.

func RestartReplicationQuick

func RestartReplicationQuick(instanceKey *InstanceKey) error

func ReviewUnseenInstances

func ReviewUnseenInstances() error

ReviewUnseenInstances reviews instances that have not been seen (suposedly dead) and updates some of their data

func SaveTablet

func SaveTablet(tablet *topodatapb.Tablet) error

SaveTablet saves the tablet record against the instanceKey.

func ScanInstanceRow

func ScanInstanceRow(instanceKey *InstanceKey, query string, dest ...interface{}) error

ScanInstanceRow executes a read-a-single-row query on a given MySQL topology instance

func SemicolonTerminated

func SemicolonTerminated(statement string) string

SemicolonTerminated is a utility function that makes sure a statement is terminated with a semicolon, if it isn't already

func SetClusterAlias

func SetClusterAlias(clusterName string, alias string) error

SetClusterAlias will write (and override) a single cluster name mapping

func SetClusterAliasManualOverride

func SetClusterAliasManualOverride(clusterName string, alias string) error

SetClusterAliasManualOverride will write (and override) a single cluster name mapping

func SetDurabilityPolicy

func SetDurabilityPolicy(name string, durabilityParams map[string]string) error

SetDurabilityPolicy is used to set the durability policy from the registered policies

func SetMaintenanceOwner

func SetMaintenanceOwner(owner string)

func SetSemiSyncPrimary added in v0.12.0

func SetSemiSyncPrimary(instanceKey *InstanceKey, enablePrimary bool) error

TODO(sougou): implement count

func SetSemiSyncReplica

func SetSemiSyncReplica(instanceKey *InstanceKey, enableReplica bool) error

TODO(sougou): This function may be used later for fixing semi-sync

func ShowBinaryLogs

func ShowBinaryLogs(instanceKey *InstanceKey) (binlogs []string, err error)

func ShowPrimaryStatus added in v0.12.0

func ShowPrimaryStatus(instanceKey *InstanceKey) (primaryStatusFound bool, executedGtidSet string, err error)

func SnapshotTopologies

func SnapshotTopologies() error

SnapshotTopologies records topology graph for all existing topologies

func StartReplicas

func StartReplicas(replicas [](*Instance))

StartReplicas will do concurrent start-replica

func SwitchPrimary added in v0.12.0

func SwitchPrimary(newPrimaryKey, oldPrimaryKey InstanceKey) error

SwitchPrimary makes the new tablet the primary and proactively performs the necessary propagation to the old primary. The propagation is best effort. If it fails, the tablet's shard sync will eventually converge. The proactive propagation allows a competing Orchestrator from discovering the successful action of a previous one, which reduces churn.

func TakePrimaryHook added in v0.12.0

func TakePrimaryHook(successor *Instance, demoted *Instance)

Created this function to allow a hook to be called after a successful TakePrimary event

func UpdateClusterAliases

func UpdateClusterAliases() error

UpdateClusterAliases writes down the cluster_alias table based on information gained from database_instance

func UpdateInstanceLastAttemptedCheck

func UpdateInstanceLastAttemptedCheck(instanceKey *InstanceKey) error

UpdateInstanceLastAttemptedCheck updates the last_attempted_check timestamp in the orchestrator backed database for a given instance. This is used as a failsafe mechanism in case access to the instance gets hung (it happens), in which case the entire ReadTopology gets stuck (and no, connection timeout nor driver timeouts don't help. Don't look at me, the world is a harsh place to live in). And so we make sure to note down *before* we even attempt to access the instance; and this raises a red flag when we wish to access the instance again: if last_attempted_check is *newer* than last_checked, that's bad news and means we have a "hanging" issue.

func UpdateInstanceLastChecked

func UpdateInstanceLastChecked(instanceKey *InstanceKey, partialSuccess bool) error

UpdateInstanceLastChecked updates the last_check timestamp in the orchestrator backed database for a given instance

func UpdateResolvedHostname

func UpdateResolvedHostname(hostname string, resolvedHostname string) bool

UpdateResolvedHostname will store the given resolved hostname in cache Returns false when the key already existed with same resolved value (similar to AFFECTED_ROWS() in mysql)

func ValidSecondsFromSeenToLastAttemptedCheck

func ValidSecondsFromSeenToLastAttemptedCheck() uint

ValidSecondsFromSeenToLastAttemptedCheck returns the maximum allowed elapsed time between last_attempted_check to last_checked before we consider the instance as invalid.

func WriteClusterDomainName

func WriteClusterDomainName(clusterName string, domainName string) error

WriteClusterDomainName will write (and override) the domain name of a cluster

func WriteHostnameUnresolve

func WriteHostnameUnresolve(instanceKey *InstanceKey, unresolvedHostname string) error

WriteHostnameUnresolve upserts an entry in hostname_unresolve

func WriteInstance

func WriteInstance(instance *Instance, instanceWasActuallyFound bool, lastError error) error

WriteInstance stores an instance in the orchestrator backend

func WriteResolvedHostname

func WriteResolvedHostname(hostname string, resolvedHostname string) error

WriteResolvedHostname stores a hostname and the resolved hostname to backend database

Types

type AggregatedWriteBufferMetric

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
}

func AggregatedSince

AggregatedSince returns the aggregated query metrics for the period given from the values provided.

type AnalysisCode

type AnalysisCode string
const (
	NoProblem                                                AnalysisCode = "NoProblem"
	ClusterHasNoPrimary                                      AnalysisCode = "ClusterHasNoPrimary"
	DeadPrimaryWithoutReplicas                               AnalysisCode = "DeadPrimaryWithoutReplicas"
	DeadPrimary                                              AnalysisCode = "DeadPrimary"
	DeadPrimaryAndReplicas                                   AnalysisCode = "DeadPrimaryAndReplicas"
	DeadPrimaryAndSomeReplicas                               AnalysisCode = "DeadPrimaryAndSomeReplicas"
	PrimaryHasPrimary                                        AnalysisCode = "PrimaryHasPrimary"
	PrimaryIsReadOnly                                        AnalysisCode = "PrimaryIsReadOnly"
	PrimarySemiSyncMustBeSet                                 AnalysisCode = "PrimarySemiSyncMustBeSet"
	PrimarySemiSyncMustNotBeSet                              AnalysisCode = "PrimarySemiSyncMustNotBeSet"
	ReplicaIsWritable                                        AnalysisCode = "ReplicaIsWritable"
	NotConnectedToPrimary                                    AnalysisCode = "NotConnectedToPrimary"
	ConnectedToWrongPrimary                                  AnalysisCode = "ConnectedToWrongPrimary"
	ReplicationStopped                                       AnalysisCode = "ReplicationStopped"
	ReplicaSemiSyncMustBeSet                                 AnalysisCode = "ReplicaSemiSyncMustBeSet"
	ReplicaSemiSyncMustNotBeSet                              AnalysisCode = "ReplicaSemiSyncMustNotBeSet"
	UnreachablePrimaryWithLaggingReplicas                    AnalysisCode = "UnreachablePrimaryWithLaggingReplicas"
	UnreachablePrimary                                       AnalysisCode = "UnreachablePrimary"
	PrimarySingleReplicaNotReplicating                       AnalysisCode = "PrimarySingleReplicaNotReplicating"
	PrimarySingleReplicaDead                                 AnalysisCode = "PrimarySingleReplicaDead"
	AllPrimaryReplicasNotReplicating                         AnalysisCode = "AllPrimaryReplicasNotReplicating"
	AllPrimaryReplicasNotReplicatingOrDead                   AnalysisCode = "AllPrimaryReplicasNotReplicatingOrDead"
	LockedSemiSyncPrimaryHypothesis                          AnalysisCode = "LockedSemiSyncPrimaryHypothesis"
	LockedSemiSyncPrimary                                    AnalysisCode = "LockedSemiSyncPrimary"
	PrimaryWithoutReplicas                                   AnalysisCode = "PrimaryWithoutReplicas"
	DeadCoPrimary                                            AnalysisCode = "DeadCoPrimary"
	DeadCoPrimaryAndSomeReplicas                             AnalysisCode = "DeadCoPrimaryAndSomeReplicas"
	UnreachableCoPrimary                                     AnalysisCode = "UnreachableCoPrimary"
	AllCoPrimaryReplicasNotReplicating                       AnalysisCode = "AllCoPrimaryReplicasNotReplicating"
	DeadIntermediatePrimary                                  AnalysisCode = "DeadIntermediatePrimary"
	DeadIntermediatePrimaryWithSingleReplica                 AnalysisCode = "DeadIntermediatePrimaryWithSingleReplica"
	DeadIntermediatePrimaryWithSingleReplicaFailingToConnect AnalysisCode = "DeadIntermediatePrimaryWithSingleReplicaFailingToConnect"
	DeadIntermediatePrimaryAndSomeReplicas                   AnalysisCode = "DeadIntermediatePrimaryAndSomeReplicas"
	DeadIntermediatePrimaryAndReplicas                       AnalysisCode = "DeadIntermediatePrimaryAndReplicas"
	UnreachableIntermediatePrimaryWithLaggingReplicas        AnalysisCode = "UnreachableIntermediatePrimaryWithLaggingReplicas"
	UnreachableIntermediatePrimary                           AnalysisCode = "UnreachableIntermediatePrimary"
	AllIntermediatePrimaryReplicasFailingToConnectOrDead     AnalysisCode = "AllIntermediatePrimaryReplicasFailingToConnectOrDead"
	AllIntermediatePrimaryReplicasNotReplicating             AnalysisCode = "AllIntermediatePrimaryReplicasNotReplicating"
	FirstTierReplicaFailingToConnectToPrimary                AnalysisCode = "FirstTierReplicaFailingToConnectToPrimary"
	BinlogServerFailingToConnectToPrimary                    AnalysisCode = "BinlogServerFailingToConnectToPrimary"
)

type AnalysisInstanceType

type AnalysisInstanceType string
const (
	AnalysisInstanceTypePrimary             AnalysisInstanceType = "primary"
	AnalysisInstanceTypeCoPrimary           AnalysisInstanceType = "co-primary"
	AnalysisInstanceTypeIntermediatePrimary AnalysisInstanceType = "intermediate-primary"
)

type AnalysisMap

type AnalysisMap map[string](*ReplicationAnalysis)

type Audit

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

Audit presents a single audit entry (namely in the database)

func ReadRecentAudit

func ReadRecentAudit(instanceKey *InstanceKey, page int) ([]Audit, error)

ReadRecentAudit returns a list of audit entries order chronologically descending, using page number.

type BinlogCoordinates

type BinlogCoordinates struct {
	LogFile string
	LogPos  int64
	Type    BinlogType
}

BinlogCoordinates described binary log coordinates in the form of log file & log position.

func GetPreviousKnownRelayLogCoordinatesForInstance

func GetPreviousKnownRelayLogCoordinatesForInstance(instance *Instance) (relayLogCoordinates *BinlogCoordinates, err error)

GetPreviousKnownRelayLogCoordinatesForInstance returns known relay log coordinates, that are not the exact current coordinates

func ParseBinlogCoordinates

func ParseBinlogCoordinates(logFileLogPos string) (*BinlogCoordinates, error)

ParseInstanceKey will parse an InstanceKey from a string representation such as 127.0.0.1:3306

func (*BinlogCoordinates) Detach

func (this *BinlogCoordinates) Detach() (detachedCoordinates BinlogCoordinates)

Detach returns a detahced form of coordinates

func (*BinlogCoordinates) DisplayString

func (this *BinlogCoordinates) DisplayString() string

DisplayString returns a user-friendly string representation of these coordinates

func (*BinlogCoordinates) Equals

func (this *BinlogCoordinates) Equals(other *BinlogCoordinates) bool

Equals tests equality of this corrdinate and another one.

func (*BinlogCoordinates) ExtractDetachedCoordinates

func (this *BinlogCoordinates) ExtractDetachedCoordinates() (isDetached bool, detachedCoordinates BinlogCoordinates)

FileSmallerThan returns true if this coordinate's file is strictly smaller than the other's.

func (*BinlogCoordinates) FileNumber

func (this *BinlogCoordinates) FileNumber() (int, int)

FileNumber returns the numeric value of the file, and the length in characters representing the number in the filename. Example: FileNumber() of mysqld.log.000789 is (789, 6)

func (*BinlogCoordinates) FileNumberDistance

func (this *BinlogCoordinates) FileNumberDistance(other *BinlogCoordinates) int

FileNumberDistance returns the numeric distance between this corrdinate's file number and the other's. Effectively it means "how many roatets/FLUSHes would make these coordinates's file reach the other's"

func (*BinlogCoordinates) FileSmallerThan

func (this *BinlogCoordinates) FileSmallerThan(other *BinlogCoordinates) bool

FileSmallerThan returns true if this coordinate's file is strictly smaller than the other's.

func (*BinlogCoordinates) IsEmpty

func (this *BinlogCoordinates) IsEmpty() bool

IsEmpty returns true if the log file is empty, unnamed

func (*BinlogCoordinates) NextFileCoordinates

func (this *BinlogCoordinates) NextFileCoordinates() (BinlogCoordinates, error)

PreviousFileCoordinates guesses the filename of the previous binlog/relaylog

func (*BinlogCoordinates) PreviousFileCoordinates

func (this *BinlogCoordinates) PreviousFileCoordinates() (BinlogCoordinates, error)

PreviousFileCoordinates guesses the filename of the previous binlog/relaylog

func (*BinlogCoordinates) PreviousFileCoordinatesBy

func (this *BinlogCoordinates) PreviousFileCoordinatesBy(offset int) (BinlogCoordinates, error)

PreviousFileCoordinatesBy guesses the filename of the previous binlog/relaylog, by given offset (number of files back)

func (*BinlogCoordinates) SmallerThan

func (this *BinlogCoordinates) SmallerThan(other *BinlogCoordinates) bool

SmallerThan returns true if this coordinate is strictly smaller than the other.

func (*BinlogCoordinates) SmallerThanOrEquals

func (this *BinlogCoordinates) SmallerThanOrEquals(other *BinlogCoordinates) bool

SmallerThanOrEquals returns true if this coordinate is the same or equal to the other one. We do NOT compare the type so we can not use this.Equals()

func (BinlogCoordinates) String

func (this BinlogCoordinates) String() string

String returns a user-friendly string representation of these coordinates

type BinlogEvent

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

func (*BinlogEvent) Equals

func (this *BinlogEvent) Equals(other *BinlogEvent) bool

func (*BinlogEvent) EqualsIgnoreCoordinates

func (this *BinlogEvent) EqualsIgnoreCoordinates(other *BinlogEvent) bool

func (*BinlogEvent) NextBinlogCoordinates

func (this *BinlogEvent) NextBinlogCoordinates() BinlogCoordinates

func (*BinlogEvent) NormalizeInfo

func (this *BinlogEvent) NormalizeInfo()

type BinlogEventCursor

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

func NewBinlogEventCursor

func NewBinlogEventCursor(startCoordinates BinlogCoordinates, fetchNextEventsFunc func(BinlogCoordinates) ([]BinlogEvent, error)) BinlogEventCursor

fetchNextEventsFunc expected to return events starting at a given position, and automatically fetch those from next binary log when no more rows are found in current log. It is expected to return empty array with no error upon end of binlogs It is expected to return error upon error...

type BinlogType

type BinlogType int
const (
	BinaryLog BinlogType = iota
	RelayLog
)

type CandidateDatabaseInstance

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

CandidateDatabaseInstance contains information about explicit promotion rules for an instance

func BulkReadCandidateDatabaseInstance

func BulkReadCandidateDatabaseInstance() ([]CandidateDatabaseInstance, error)

BulkReadCandidateDatabaseInstance returns a slice of CandidateDatabaseInstance converted to JSON.

root@myorchestrator [orchestrator]> select * from candidate_database_instance; +-------------------+------+---------------------+----------+----------------+ | hostname | port | last_suggested | priority | promotion_rule | +-------------------+------+---------------------+----------+----------------+ | host1.example.com | 3306 | 2016-11-22 17:41:06 | 1 | prefer | | host2.example.com | 3306 | 2016-11-22 17:40:24 | 1 | prefer | +-------------------+------+---------------------+----------+----------------+ 2 rows in set (0.00 sec)

func NewCandidateDatabaseInstance

func NewCandidateDatabaseInstance(instanceKey *InstanceKey, promotionRule CandidatePromotionRule) *CandidateDatabaseInstance

func (*CandidateDatabaseInstance) Key

Key returns an instance key representing this candidate

func (*CandidateDatabaseInstance) String

func (cdi *CandidateDatabaseInstance) String() string

String returns a string representation of the CandidateDatabaseInstance struct

func (*CandidateDatabaseInstance) WithCurrentTime

func (cdi *CandidateDatabaseInstance) WithCurrentTime() *CandidateDatabaseInstance

type CandidatePromotionRule

type CandidatePromotionRule string

CandidatePromotionRule describe the promotion preference/rule for an instance. It maps to promotion_rule column in candidate_database_instance

const (
	MustPromoteRule      CandidatePromotionRule = "must"
	PreferPromoteRule    CandidatePromotionRule = "prefer"
	NeutralPromoteRule   CandidatePromotionRule = "neutral"
	PreferNotPromoteRule CandidatePromotionRule = "prefer_not"
	MustNotPromoteRule   CandidatePromotionRule = "must_not"
)

func ParseCandidatePromotionRule

func ParseCandidatePromotionRule(ruleName string) (CandidatePromotionRule, error)

ParseCandidatePromotionRule returns a CandidatePromotionRule by name. It returns an error if there is no known rule by the given name.

func PromotionRule

func PromotionRule(tablet *topodatapb.Tablet) CandidatePromotionRule

PromotionRule returns the promotion rule for the instance.

func (*CandidatePromotionRule) BetterThan

func (this *CandidatePromotionRule) BetterThan(other CandidatePromotionRule) bool

type ClusterInfo

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

ClusterInfo makes for a cluster status/info summary

func ReadClusterInfo

func ReadClusterInfo(clusterName string) (*ClusterInfo, error)

ReadClusterInfo reads some info about a given cluster

func ReadClustersInfo

func ReadClustersInfo(clusterName string) ([]ClusterInfo, error)

ReadClustersInfo reads names of all known clusters and some aggregated info

func (*ClusterInfo) ApplyClusterAlias

func (this *ClusterInfo) ApplyClusterAlias()

ApplyClusterAlias updates the given clusterInfo's ClusterAlias property

func (*ClusterInfo) ReadRecoveryInfo

func (this *ClusterInfo) ReadRecoveryInfo()

ReadRecoveryInfo

type ClusterPoolInstance

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

ClusterPoolInstance is an instance mapping a cluster, pool & instance

func ReadAllClusterPoolInstances

func ReadAllClusterPoolInstances() ([](*ClusterPoolInstance), error)

ReadAllClusterPoolInstances returns all clusters-pools-insatnces associations

func ReadClusterPoolInstances

func ReadClusterPoolInstances(clusterName string, pool string) (result [](*ClusterPoolInstance), err error)

ReadClusterPoolInstances reads cluster-pool-instance associationsfor given cluster and pool

type Downtime

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

func NewDowntime

func NewDowntime(instanceKey *InstanceKey, owner string, reason string, duration time.Duration) *Downtime

func ReadDowntime

func ReadDowntime() (result []Downtime, err error)

func (*Downtime) Ended

func (downtime *Downtime) Ended() bool

func (*Downtime) EndsIn

func (downtime *Downtime) EndsIn() time.Duration

type HostnameRegistration

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

func NewHostnameDeregistration

func NewHostnameDeregistration(instanceKey *InstanceKey) *HostnameRegistration

func NewHostnameRegistration

func NewHostnameRegistration(instanceKey *InstanceKey, hostname string) *HostnameRegistration

func ReadAllHostnameUnresolvesRegistrations

func ReadAllHostnameUnresolvesRegistrations() (registrations []HostnameRegistration, err error)

ReadAllHostnameUnresolves returns the content of the hostname_unresolve table

type HostnameResolve

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

func ReadAllHostnameResolves

func ReadAllHostnameResolves() ([]HostnameResolve, error)

func (HostnameResolve) String

func (this HostnameResolve) String() string

type HostnameUnresolve

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

func ReadAllHostnameUnresolves

func ReadAllHostnameUnresolves() ([]HostnameUnresolve, error)

ReadAllHostnameUnresolves returns the content of the hostname_unresolve table

func (HostnameUnresolve) String

func (this HostnameUnresolve) String() string

type Instance

type Instance struct {
	Key                          InstanceKey
	InstanceAlias                string
	Uptime                       uint
	ServerID                     uint
	ServerUUID                   string
	Version                      string
	VersionComment               string
	FlavorName                   string
	ReadOnly                     bool
	Binlog_format                string
	BinlogRowImage               string
	LogBinEnabled                bool
	LogReplicationUpdatesEnabled bool
	SelfBinlogCoordinates        BinlogCoordinates
	SourceKey                    InstanceKey
	SourceUUID                   string
	AncestryUUID                 string
	IsDetachedPrimary            bool

	ReplicationSQLThreadRuning bool
	ReplicationIOThreadRuning  bool
	ReplicationSQLThreadState  ReplicationThreadState
	ReplicationIOThreadState   ReplicationThreadState

	HasReplicationFilters bool
	GTIDMode              string
	SupportsOracleGTID    bool
	UsingOracleGTID       bool
	UsingMariaDBGTID      bool
	UsingPseudoGTID       bool // Legacy. Always 'false'
	ReadBinlogCoordinates BinlogCoordinates
	ExecBinlogCoordinates BinlogCoordinates
	IsDetached            bool
	RelaylogCoordinates   BinlogCoordinates
	LastSQLError          string
	LastIOError           string
	SecondsBehindPrimary  sql.NullInt64
	SQLDelay              uint
	ExecutedGtidSet       string
	GtidPurged            string
	GtidErrant            string

	ReplicationLagSeconds              sql.NullInt64
	Replicas                           InstanceKeyMap
	ClusterName                        string
	SuggestedClusterAlias              string
	DataCenter                         string
	Region                             string
	PhysicalEnvironment                string
	ReplicationDepth                   uint
	IsCoPrimary                        bool
	HasReplicationCredentials          bool
	ReplicationCredentialsAvailable    bool
	SemiSyncAvailable                  bool // when both semi sync plugins (primary & replica) are loaded
	SemiSyncEnforced                   bool
	SemiSyncPrimaryEnabled             bool
	SemiSyncReplicaEnabled             bool
	SemiSyncPrimaryTimeout             uint64
	SemiSyncPrimaryWaitForReplicaCount uint
	SemiSyncPrimaryStatus              bool
	SemiSyncPrimaryClients             uint
	SemiSyncReplicaStatus              bool

	LastSeenTimestamp    string
	IsLastCheckValid     bool
	IsUpToDate           bool
	IsRecentlyChecked    bool
	SecondsSinceLastSeen sql.NullInt64
	CountMySQLSnapshots  int

	// 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
	AllowTLS             bool

	Problems []string

	LastDiscoveryLatency time.Duration

	// Group replication global variables
	ReplicationGroupName            string
	ReplicationGroupIsSinglePrimary bool

	// Replication group members information. See
	// https://dev.mysql.com/doc/refman/8.0/en/replication-group-members-table.html for details.
	ReplicationGroupMemberState string
	ReplicationGroupMemberRole  string

	// List of all known members of the same group
	ReplicationGroupMembers InstanceKeyMap

	// Primary of the replication group
	ReplicationGroupPrimaryInstanceKey InstanceKey
	// contains filtered or unexported fields
}

Instance represents a database instance, including its current configuration & status. It presents important replication configuration and detailed replication status.

func ChangePrimaryTo added in v0.12.0

func ChangePrimaryTo(instanceKey *InstanceKey, primaryKey *InstanceKey, primaryBinlogCoordinates *BinlogCoordinates, skipUnresolve bool, gtidHint OperationGTIDHint) (*Instance, error)

ChangePrimaryTo changes the given instance's primary according to given input. TODO(sougou): deprecate ReplicationCredentialsQuery, and all other credential discovery.

func DetachReplicaPrimaryHost added in v0.12.0

func DetachReplicaPrimaryHost(instanceKey *InstanceKey) (*Instance, error)

DetachReplicaPrimaryHost detaches a replica from its primary by corrupting the Master_Host (in such way that is reversible)

func DisableGTID

func DisableGTID(instanceKey *InstanceKey) (*Instance, error)

DisableGTID will attempt to disable GTID-mode (either Oracle or MariaDB) and revert to binlog file:pos replication

func EnableGTID

func EnableGTID(instanceKey *InstanceKey) (*Instance, error)

EnableGTID will attempt to enable GTID-mode (either Oracle or MariaDB)

func EnablePrimarySSL added in v0.12.0

func EnablePrimarySSL(instanceKey *InstanceKey) (*Instance, error)

EnablePrimarySSL issues CHANGE MASTER TO MASTER_SSL=1

func ErrantGTIDResetPrimary added in v0.12.0

func ErrantGTIDResetPrimary(instanceKey *InstanceKey) (instance *Instance, err error)

ErrantGTIDResetPrimary will issue a safe RESET MASTER on a replica that replicates via GTID: It will make sure the gtid_purged set matches the executed set value as read just before the RESET. this will enable new replicas to be attached to given instance without complaints about missing/purged entries. This function requires that the instance does not have replicas.

func FindInstances

func FindInstances(regexpPattern string) (result [](*Instance), err error)

FindInstances reads all instances whose name matches given pattern

func FlushBinaryLogs

func FlushBinaryLogs(instanceKey *InstanceKey, count int) (*Instance, error)

FlushBinaryLogs attempts a 'FLUSH BINARY LOGS' statement on the given instance.

func FlushBinaryLogsTo

func FlushBinaryLogsTo(instanceKey *InstanceKey, logFile string) (*Instance, error)

FlushBinaryLogsTo attempts to 'FLUSH BINARY LOGS' until given binary log is reached

func GetCandidateReplicaOfBinlogServerTopology

func GetCandidateReplicaOfBinlogServerTopology(primaryKey *InstanceKey) (candidateReplica *Instance, err error)

GetCandidateReplicaOfBinlogServerTopology chooses the best replica to promote given a (possibly dead) primary

func GetClusterGhostReplicas

func GetClusterGhostReplicas(clusterName string) (result [](*Instance), err error)

GetClusterGhostReplicas returns a list of replicas that can serve as the connected servers for a [gh-ost](https://github.com/github/gh-ost) operation. A gh-ost operation prefers to talk to a RBR replica that has no children.

func GetClusterOSCReplicas

func GetClusterOSCReplicas(clusterName string) ([](*Instance), error)

GetClusterOSCReplicas returns a heuristic list of replicas which are fit as controll replicas for an OSC operation. These would be intermediate primaries

func GetHeuristicClusterPoolInstances

func GetHeuristicClusterPoolInstances(clusterName string, pool string) (result [](*Instance), err error)

GetHeuristicClusterPoolInstances returns instances of a cluster which are also pooled. If `pool` argument is empty, all pools are considered, otherwise, only instances of given pool are considered.

func GetInstancePrimary added in v0.12.0

func GetInstancePrimary(instance *Instance) (*Instance, error)

GetInstancePrimary synchronously reaches into the replication topology and retrieves primary's data

func GetSortedReplicas

func GetSortedReplicas(primaryKey *InstanceKey, stopReplicationMethod StopReplicationMethod) (replicas [](*Instance), err error)

GetSortedReplicas reads list of replicas of a given primary, and returns them sorted by exec coordinates (most up-to-date replica first).

func KillQuery

func KillQuery(instanceKey *InstanceKey, process int64) (*Instance, error)

KillQuery stops replication on a given instance

func MakeCoPrimary added in v0.12.0

func MakeCoPrimary(instanceKey *InstanceKey) (*Instance, error)

MakeCoPrimary will attempt to make an instance co-primary with its primary, by making its primary a replica of its own. This only works out if the primary is not replicating; the primary does not have a known primary (it may have an unknown primary).

func MoveBelow

func MoveBelow(instanceKey, siblingKey *InstanceKey) (*Instance, error)

MoveBelow will attempt moving instance indicated by instanceKey below its supposed sibling indicated by sinblingKey. It will perform all safety and sanity checks and will tamper with this instance's replication as well as its sibling.

func MoveBelowGTID

func MoveBelowGTID(instanceKey, otherKey *InstanceKey) (*Instance, error)

MoveBelowGTID will attempt moving instance indicated by instanceKey below another instance using either Oracle GTID or MariaDB GTID.

func MoveUp

func MoveUp(instanceKey *InstanceKey) (*Instance, error)

MoveUp will attempt moving instance indicated by instanceKey up the topology hierarchy. It will perform all safety and sanity checks and will tamper with this instance's replication as well as its primary.

func NewInstance

func NewInstance() *Instance

func PrimaryPosWait added in v0.12.0

func PrimaryPosWait(instanceKey *InstanceKey, binlogCoordinates *BinlogCoordinates) (*Instance, error)

PrimaryPosWait issues a MASTER_POS_WAIT() an given instance according to given coordinates.

func PurgeBinaryLogsTo

func PurgeBinaryLogsTo(instanceKey *InstanceKey, logFile string, force bool) (*Instance, error)

PurgeBinaryLogsTo attempts to 'PURGE BINARY LOGS' until given binary log is reached

func PurgeBinaryLogsToLatest

func PurgeBinaryLogsToLatest(instanceKey *InstanceKey, force bool) (*Instance, error)

PurgeBinaryLogsToLatest attempts to 'PURGE BINARY LOGS' until latest binary log

func ReadBinlogServerReplicaInstances

func ReadBinlogServerReplicaInstances(primaryKey *InstanceKey) ([](*Instance), error)

ReadBinlogServerReplicaInstances reads direct replicas of a given primary that are binlog servers

func ReadClusterAliasInstances

func ReadClusterAliasInstances(clusterAlias string) ([](*Instance), error)

ReadClusterAliasInstances reads all instances of a cluster alias

func ReadClusterCandidateInstances

func ReadClusterCandidateInstances(clusterName string) ([](*Instance), error)

ReadClusterCandidateInstances reads cluster instances which are also marked as candidates

func ReadClusterInstances

func ReadClusterInstances(clusterName string) ([](*Instance), error)

ReadClusterInstances reads all instances of a given cluster

func ReadClusterNeutralPromotionRuleInstances

func ReadClusterNeutralPromotionRuleInstances(clusterName string) (neutralInstances [](*Instance), err error)

ReadClusterNeutralPromotionRuleInstances reads cluster instances whose promotion-rule is marked as 'neutral'

func ReadClusterPrimary added in v0.12.0

func ReadClusterPrimary(clusterName string) ([](*Instance), error)

ReadClusterPrimary returns the primary of this cluster. - if the cluster has co-primaries, the/a writable one is returned - if the cluster has a single primary, that primary is returned whether it is read-only or writable.

func ReadClusterWriteablePrimary added in v0.12.0

func ReadClusterWriteablePrimary(clusterName string) ([](*Instance), error)

ReadClusterWriteablePrimary returns the/a writeable primary of this cluster Typically, the cluster name indicates the primary of the cluster. However, in circular primary-primary replication one primary can assume the name of the cluster, and it is not guaranteed that it is the writeable one.

func ReadDowntimedInstances

func ReadDowntimedInstances(clusterName string) ([](*Instance), error)

ReadDowntimedInstances returns all instances currently downtimed, potentially filtered by cluster

func ReadFuzzyInstance

func ReadFuzzyInstance(fuzzyInstanceKey *InstanceKey) (*Instance, error)

ReadFuzzyInstance accepts a fuzzy instance key and expects to return a single instance. Multiple instances matching the fuzzy keys are not allowed.

func ReadHistoryClusterInstances

func ReadHistoryClusterInstances(clusterName string, historyTimestampPattern string) ([](*Instance), error)

ReadHistoryClusterInstances reads (thin) instances from history

func ReadInstance

func ReadInstance(instanceKey *InstanceKey) (*Instance, bool, error)

ReadInstance reads an instance from the orchestrator backend database

func ReadLostInRecoveryInstances

func ReadLostInRecoveryInstances(clusterName string) ([](*Instance), error)

ReadLostInRecoveryInstances returns all instances (potentially filtered by cluster) which are currently indicated as downtimed due to being lost during a topology recovery.

func ReadProblemInstances

func ReadProblemInstances(clusterName string) ([](*Instance), error)

ReadProblemInstances reads all instances with problems

func ReadReplicaInstances

func ReadReplicaInstances(primaryKey *InstanceKey) ([](*Instance), error)

ReadReplicaInstances reads replicas of a given primary

func ReadReplicaInstancesIncludingBinlogServerSubReplicas

func ReadReplicaInstancesIncludingBinlogServerSubReplicas(primaryKey *InstanceKey) ([](*Instance), error)

ReadReplicaInstancesIncludingBinlogServerSubReplicas returns a list of direct slves including any replicas of a binlog server replica

func ReadTopologyInstance

func ReadTopologyInstance(instanceKey *InstanceKey) (*Instance, error)

ReadTopologyInstance collects information on the state of a MySQL server and writes the result synchronously to the orchestrator backend.

func ReadTopologyInstanceBufferable

func ReadTopologyInstanceBufferable(instanceKey *InstanceKey, bufferWrites bool, latency *stopwatch.NamedStopwatch) (inst *Instance, err error)

ReadTopologyInstanceBufferable connects to a topology MySQL instance and collects information on the server and its replication state. It writes the information retrieved into orchestrator's backend. - writes are optionally buffered. - timing information can be collected for the stages performed.

func ReadUnseenInstances

func ReadUnseenInstances() ([](*Instance), error)

ReadUnseenInstances reads all instances which were not recently seen

func ReadWriteableClustersPrimaries added in v0.12.0

func ReadWriteableClustersPrimaries() (instances [](*Instance), err error)

ReadWriteableClustersPrimaries returns writeable primaries of all clusters, but only one per cluster, in similar logic to ReadClusterWriteablePrimary

func ReattachReplicaPrimaryHost added in v0.12.0

func ReattachReplicaPrimaryHost(instanceKey *InstanceKey) (*Instance, error)

ReattachReplicaPrimaryHost reattaches a replica back onto its primary by undoing a DetachReplicaPrimaryHost operation

func RefreshTopologyInstance

func RefreshTopologyInstance(instanceKey *InstanceKey) (*Instance, error)

RefreshTopologyInstance will synchronuously re-read topology instance

func RelocateBelow

func RelocateBelow(instanceKey, otherKey *InstanceKey) (*Instance, error)

RelocateBelow will attempt moving instance indicated by instanceKey below another instance. Orchestrator will try and figure out the best way to relocate the server. This could span normal binlog-position, repointing, binlog servers...

func RemoveBinlogServerInstances

func RemoveBinlogServerInstances(instances [](*Instance)) [](*Instance)

removeBinlogServerInstances will remove all binlog servers from given lsit

func RemoveInstance

func RemoveInstance(instances [](*Instance), instanceKey *InstanceKey) [](*Instance)

removeInstance will remove an instance from a list of instances

func RemoveNilInstances

func RemoveNilInstances(instances [](*Instance)) [](*Instance)

removeNilInstances

func Repoint

func Repoint(instanceKey *InstanceKey, primaryKey *InstanceKey, gtidHint OperationGTIDHint) (*Instance, error)

Repoint connects a replica to a primary using its exact same executing coordinates. The given primaryKey can be null, in which case the existing primary is used. Two use cases: - primaryKey is nil: use case is corrupted relay logs on replica - primaryKey is not nil: using Binlog servers (coordinates remain the same)

func RepointReplicas

func RepointReplicas(instanceKey *InstanceKey, pattern string) ([](*Instance), error, []error)

RepointReplicas repoints all replicas of a given instance onto its existing primary.

func RepointReplicasTo

func RepointReplicasTo(instanceKey *InstanceKey, pattern string, belowKey *InstanceKey) ([](*Instance), error, []error)

RepointReplicasTo repoints replicas of a given instance (possibly filtered) onto another primary. Binlog Server is the major use case

func RepointTo

func RepointTo(replicas [](*Instance), belowKey *InstanceKey) ([](*Instance), error, []error)

RepointTo repoints list of replicas onto another primary. Binlog Server is the major use case

func ResetPrimary added in v0.12.0

func ResetPrimary(instanceKey *InstanceKey) (*Instance, error)

ResetPrimary issues a RESET MASTER statement on given instance. Use with extreme care!

func ResetReplication

func ResetReplication(instanceKey *InstanceKey) (*Instance, error)

ResetReplication resets a replica, breaking the replication

func ResetReplicationOperation

func ResetReplicationOperation(instanceKey *InstanceKey) (*Instance, error)

ResetReplicationOperation will reset a replica

func RestartReplication

func RestartReplication(instanceKey *InstanceKey) (instance *Instance, err error)

RestartReplication stops & starts replication on a given instance

func RetryInstanceFunction

func RetryInstanceFunction(f func() (*Instance, error)) (instance *Instance, err error)

func SearchInstances

func SearchInstances(searchString string) ([](*Instance), error)

SearchInstances reads all instances qualifying for some searchString

func SetReadOnly

func SetReadOnly(instanceKey *InstanceKey, readOnly bool) (*Instance, error)

SetReadOnly sets or clears the instance's global read_only variable

func SkipQuery

func SkipQuery(instanceKey *InstanceKey) (*Instance, error)

SkipQuery skip a single query in a failed replication instance

func SkipToNextBinaryLog

func SkipToNextBinaryLog(instanceKey *InstanceKey) (*Instance, error)

SkipToNextBinaryLog changes primary position to beginning of next binlog USE WITH CARE! Use case is binlog servers where the primary was gone & replaced by another.

func StartReplication

func StartReplication(instanceKey *InstanceKey) (*Instance, error)

StartReplication starts replication on a given instance.

func StartReplicationUntilPrimaryCoordinates added in v0.12.0

func StartReplicationUntilPrimaryCoordinates(instanceKey *InstanceKey, primaryCoordinates *BinlogCoordinates) (*Instance, error)

StartReplicationUntilPrimaryCoordinates issuesa START SLAVE UNTIL... statement on given instance

func StopReplicas

func StopReplicas(replicas [](*Instance), stopReplicationMethod StopReplicationMethod, timeout time.Duration) [](*Instance)

StopReplicas will stop replication concurrently on given set of replicas. It will potentially do nothing, or attempt to stop _nicely_ or just stop normally, all according to stopReplicationMethod

func StopReplicasNicely

func StopReplicasNicely(replicas [](*Instance), timeout time.Duration) [](*Instance)

StopReplicasNicely will attemt to stop all given replicas nicely, up to timeout

func StopReplication

func StopReplication(instanceKey *InstanceKey) (*Instance, error)

StopReplication stops replication on a given instance

func StopReplicationNicely

func StopReplicationNicely(instanceKey *InstanceKey, timeout time.Duration) (*Instance, error)

StopReplicationNicely stops a replica such that SQL_thread and IO_thread are aligned (i.e. SQL_thread consumes all relay log entries) It will actually START the sql_thread even if the replica is completely stopped.

func TakePrimary added in v0.12.0

func TakePrimary(instanceKey *InstanceKey, allowTakingCoPrimary bool) (*Instance, error)

TakePrimary will move an instance up the chain and cause its primary to become its replica. It's almost a role change, just that other replicas of either 'instance' or its primary are currently unaffected (they continue replicate without change) Note that the primary must itself be a replica; however the grandparent does not necessarily have to be reachable and can in fact be dead.

func TakeSiblings

func TakeSiblings(instanceKey *InstanceKey) (instance *Instance, takenSiblings int, err error)

TakeSiblings is a convenience method for turning siblings of a replica to be its subordinates. This operation is a syntatctic sugar on top relocate-replicas, which uses any available means to the objective: GTID, binlog servers, standard replication...

func WaitForExecBinlogCoordinatesToReach

func WaitForExecBinlogCoordinatesToReach(instanceKey *InstanceKey, coordinates *BinlogCoordinates, maxWait time.Duration) (instance *Instance, exactMatch bool, err error)

func WaitForSQLThreadUpToDate

func WaitForSQLThreadUpToDate(instanceKey *InstanceKey, overallTimeout time.Duration, staleCoordinatesTimeout time.Duration) (instance *Instance, err error)

func (*Instance) AddGroupMemberKey

func (this *Instance) AddGroupMemberKey(groupMemberKey *InstanceKey)

AddGroupMemberKey adds a group member to the list of this instance's group members.

func (*Instance) AddReplicaKey

func (this *Instance) AddReplicaKey(replicaKey *InstanceKey)

AddReplicaKey adds a replica to the list of this instance's replicas.

func (*Instance) CanMove

func (this *Instance) CanMove() (bool, error)

CanMove returns true if this instance's state allows it to be repositioned. For example, if this instance lags too much, it will not be moveable.

func (*Instance) CanMoveAsCoPrimary added in v0.12.0

func (this *Instance) CanMoveAsCoPrimary() (bool, error)

CanMoveAsCoPrimary returns true if this instance's state allows it to be repositioned.

func (*Instance) CanReplicateFrom

func (this *Instance) CanReplicateFrom(other *Instance) (bool, error)

CanReplicateFrom uses heursitics to decide whether this instacne can practically replicate from other instance. Checks are made to binlog format, version number, binary logs etc.

func (*Instance) Equals

func (this *Instance) Equals(other *Instance) bool

Equals tests that this instance is the same instance as other. The function does not test configuration or status.

func (*Instance) FlavorNameAndMajorVersion

func (this *Instance) FlavorNameAndMajorVersion() string

FlavorNameAndMajorVersion returns a string of the combined flavor and major version which is useful in some checks.

func (*Instance) GetNextBinaryLog

func (this *Instance) GetNextBinaryLog(binlogCoordinates BinlogCoordinates) (BinlogCoordinates, error)

GetNextBinaryLog returns the successive, if any, binary log file to the one given

func (*Instance) HasReasonableMaintenanceReplicationLag

func (this *Instance) HasReasonableMaintenanceReplicationLag() bool

HasReasonableMaintenanceReplicationLag returns true when the replica lag is reasonable, and maintenance operations should have a green light to go.

func (*Instance) HumanReadableDescription

func (this *Instance) HumanReadableDescription() string

HumanReadableDescription returns a simple readable string describing the status, version, etc. properties of this instance

func (*Instance) IsBinlogServer

func (this *Instance) IsBinlogServer() bool

IsBinlogServer checks whether this is any type of a binlog server

func (*Instance) IsDescendantOf

func (this *Instance) IsDescendantOf(other *Instance) bool

IsDescendantOf returns true if this is replication directly or indirectly from other

func (*Instance) IsMariaDB

func (this *Instance) IsMariaDB() bool

IsMariaDB checks whether this is any version of MariaDB

func (*Instance) IsMySQL51

func (this *Instance) IsMySQL51() bool

func (*Instance) IsMySQL55

func (this *Instance) IsMySQL55() bool

func (*Instance) IsMySQL56

func (this *Instance) IsMySQL56() bool

func (*Instance) IsMySQL57

func (this *Instance) IsMySQL57() bool

func (*Instance) IsMySQL80

func (this *Instance) IsMySQL80() bool

func (*Instance) IsNDB

func (this *Instance) IsNDB() bool

isNDB check whether this is NDB Cluster (aka MySQL Cluster)

func (*Instance) IsOracleMySQL

func (this *Instance) IsOracleMySQL() bool

IsOracleMySQL checks whether this is an Oracle MySQL distribution

func (*Instance) IsPercona

func (this *Instance) IsPercona() bool

IsPercona checks whether this is any version of Percona Server

func (*Instance) IsPrimary added in v0.12.0

func (this *Instance) IsPrimary() bool

IsPrimary makes simple heuristics to decide whether this instance is a primary (not replicating from any other server), either via traditional async/semisync replication or group replication

func (*Instance) IsPrimaryOf added in v0.12.0

func (this *Instance) IsPrimaryOf(replica *Instance) bool

IsReplicaOf returns true if this i supposed primary of given replica

func (*Instance) IsReplica

func (this *Instance) IsReplica() bool

IsReplica makes simple heuristics to decide whether this instance is a replica of another instance

func (*Instance) IsReplicaOf

func (this *Instance) IsReplicaOf(primary *Instance) bool

IsReplicaOf returns true if this instance claims to replicate from given primary

func (*Instance) IsReplicationGroupMember

func (this *Instance) IsReplicationGroupMember() bool

IsReplicationGroup checks whether the host thinks it is part of a known replication group. Notice that this might return True even if the group has decided to expel the member represented by this instance, as the instance might not know that under certain circumstances

func (*Instance) IsReplicationGroupPrimary

func (this *Instance) IsReplicationGroupPrimary() bool

func (*Instance) IsReplicationGroupSecondary

func (this *Instance) IsReplicationGroupSecondary() bool

func (*Instance) IsSeed

func (this *Instance) IsSeed() bool

func (*Instance) IsSmallerBinlogFormat

func (this *Instance) IsSmallerBinlogFormat(other *Instance) bool

IsSmallerBinlogFormat returns true when this instance's binlgo format is "smaller" than the other's, i.e. binary logs cannot flow from the other instance to this one

func (*Instance) IsSmallerMajorVersion

func (this *Instance) IsSmallerMajorVersion(other *Instance) bool

IsSmallerMajorVersion tests this instance against another and returns true if this instance is of a smaller "major" varsion. e.g. 5.5.36 is NOT a smaller major version as comapred to 5.5.36, but IS as compared to 5.6.9

func (*Instance) IsSmallerMajorVersionByString

func (this *Instance) IsSmallerMajorVersionByString(otherVersion string) bool

IsSmallerMajorVersionByString checks if this instance has a smaller major version number than given one

func (*Instance) LagStatusString

func (this *Instance) LagStatusString() string

LagStatusString returns a human readable representation of current lag

func (*Instance) MajorVersion

func (this *Instance) MajorVersion() []string

MajorVersion returns this instance's major version number (e.g. for 5.5.36 it returns "5.5")

func (*Instance) MajorVersionString

func (this *Instance) MajorVersionString() string

MajorVersion returns this instance's major version number (e.g. for 5.5.36 it returns "5.5")

func (*Instance) MarshalJSON

func (this *Instance) MarshalJSON() ([]byte, error)

func (*Instance) NextGTID

func (this *Instance) NextGTID() (string, error)

NextGTID returns the next (Oracle) GTID to be executed. Useful for skipping queries

func (*Instance) ReplicaRunning

func (this *Instance) ReplicaRunning() bool

ReplicaRunning returns true when this instance's status is of a replicating replica.

func (*Instance) ReplicationThreadsExist

func (this *Instance) ReplicationThreadsExist() bool

NoReplicationThreadRunning returns true when neither SQL nor IO threads are running (including the case where isn't even a replica)

func (*Instance) ReplicationThreadsStopped

func (this *Instance) ReplicationThreadsStopped() bool

NoReplicationThreadRunning returns true when neither SQL nor IO threads are running (including the case where isn't even a replica)

func (*Instance) SQLThreadUpToDate

func (this *Instance) SQLThreadUpToDate() bool

SQLThreadUpToDate returns true when the instance had consumed all relay logs.

func (*Instance) SetSeed

func (this *Instance) SetSeed()

func (*Instance) StatusString

func (this *Instance) StatusString() string

StatusString returns a human readable description of this instance's status

func (*Instance) TabulatedDescription

func (this *Instance) TabulatedDescription(separator string) string

TabulatedDescription returns a simple tabulated string of various properties

func (*Instance) UsingGTID

func (this *Instance) UsingGTID() bool

UsingGTID returns true when this replica is currently replicating via GTID (either Oracle or MariaDB)

type InstanceAnalysis

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

func NewInstanceAnalysis

func NewInstanceAnalysis(instanceKey *InstanceKey, analysis AnalysisCode) *InstanceAnalysis

func (*InstanceAnalysis) String

func (instanceAnalysis *InstanceAnalysis) String() string

type InstanceKey

type InstanceKey struct {
	Hostname string
	Port     int
}

InstanceKey is an instance indicator, identifued by hostname and port

func BulkReadInstance

func BulkReadInstance() ([](*InstanceKey), error)

BulkReadInstance returns a list of all instances from the database

  • I only need the Hostname and Port fields.
  • I must use readInstancesByCondition to ensure all column settings are correct.

func FigureInstanceKey

func FigureInstanceKey(instanceKey *InstanceKey, thisInstanceKey *InstanceKey) (*InstanceKey, error)

FigureInstanceKey tries to figure out a key

func GetHeuristicClusterDomainInstanceAttribute

func GetHeuristicClusterDomainInstanceAttribute(clusterName string) (instanceKey *InstanceKey, err error)

GetHeuristicClusterDomainInstanceAttribute attempts detecting the cluster domain for the given cluster, and return the instance key associated as writer with that domain

func HeuristicallyApplyClusterDomainInstanceAttribute

func HeuristicallyApplyClusterDomainInstanceAttribute(clusterName string) (instanceKey *InstanceKey, err error)

HeuristicallyApplyClusterDomainInstanceAttribute writes down the cluster-domain to primary-hostname as a general attribute, by reading current topology and **trusting** it to be correct

func NewRawInstanceKeyStrings

func NewRawInstanceKeyStrings(hostname string, port string) (*InstanceKey, error)

NewResolveInstanceKeyStrings creates and resolves a new instance key based on string params

func NewResolveInstanceKey

func NewResolveInstanceKey(hostname string, port int) (instanceKey *InstanceKey, err error)

func NewResolveInstanceKeyStrings

func NewResolveInstanceKeyStrings(hostname string, port string) (*InstanceKey, error)

NewResolveInstanceKeyStrings creates and resolves a new instance key based on string params

func ParseRawInstanceKey

func ParseRawInstanceKey(hostPort string) (instanceKey *InstanceKey, err error)

func ParseResolveInstanceKey

func ParseResolveInstanceKey(hostPort string) (instanceKey *InstanceKey, err error)

func ReadAllInstanceKeys

func ReadAllInstanceKeys() ([]InstanceKey, error)

ReadAllInstanceKeys

func ReadFuzzyInstanceKey

func ReadFuzzyInstanceKey(fuzzyInstanceKey *InstanceKey) *InstanceKey

ReadFuzzyInstanceKey accepts a fuzzy instance key and expects to return a single, fully qualified, known instance key.

func ReadFuzzyInstanceKeyIfPossible

func ReadFuzzyInstanceKeyIfPossible(fuzzyInstanceKey *InstanceKey) *InstanceKey

ReadFuzzyInstanceKeyIfPossible accepts a fuzzy instance key and hopes to return a single, fully qualified, known instance key, or else the original given key

func ReadMaintenanceInstanceKey

func ReadMaintenanceInstanceKey(maintenanceToken int64) (*InstanceKey, error)

ReadMaintenanceInstanceKey will return the instanceKey for active maintenance by maintenanceToken

func ReadOutdatedInstanceKeys

func ReadOutdatedInstanceKeys() ([]InstanceKey, error)

ReadOutdatedInstanceKeys reads and returns keys for all instances that are not up to date (i.e. pre-configured time has passed since they were last checked) But we also check for the case where an attempt at instance checking has been made, that hasn't resulted in an actual check! This can happen when TCP/IP connections are hung, in which case the "check" never returns. In such case we multiply interval by a factor, so as not to open too many connections on the instance.

func UnresolveHostname

func UnresolveHostname(instanceKey *InstanceKey) (InstanceKey, bool, error)

func (*InstanceKey) DetachedKey

func (this *InstanceKey) DetachedKey() *InstanceKey

DetachedKey returns an instance key whose hostname is detahced: invalid, but recoverable

func (*InstanceKey) DisplayString

func (this *InstanceKey) DisplayString() string

DisplayString returns a user-friendly string representation of this key

func (*InstanceKey) Equals

func (this *InstanceKey) Equals(other *InstanceKey) bool

Equals tests equality between this key and another key

func (*InstanceKey) IsDetached

func (this *InstanceKey) IsDetached() bool

IsDetached returns 'true' when this hostname is logically "detached"

func (*InstanceKey) IsIPv4

func (this *InstanceKey) IsIPv4() bool

IsValid uses simple heuristics to see whether this key represents an actual instance

func (*InstanceKey) IsValid

func (this *InstanceKey) IsValid() bool

IsValid uses simple heuristics to see whether this key represents an actual instance

func (*InstanceKey) ReattachedKey

func (this *InstanceKey) ReattachedKey() *InstanceKey

ReattachedKey returns an instance key whose hostname is detahced: invalid, but recoverable

func (*InstanceKey) ResolveHostname

func (this *InstanceKey) ResolveHostname() (*InstanceKey, error)

func (*InstanceKey) SmallerThan

func (this *InstanceKey) SmallerThan(other *InstanceKey) bool

SmallerThan returns true if this key is dictionary-smaller than another. This is used for consistent sorting/ordering; there's nothing magical about it.

func (InstanceKey) String

func (this InstanceKey) String() string

String returns a user-friendly string representation of this key

func (*InstanceKey) StringCode

func (this *InstanceKey) StringCode() string

StringCode returns an official string representation of this key

type InstanceKeyMap

type InstanceKeyMap map[InstanceKey]bool

InstanceKeyMap is a convenience struct for listing InstanceKey-s

func GetInstanceKeysByTag

func GetInstanceKeysByTag(tag *Tag) (tagged *InstanceKeyMap, err error)

func GetInstanceKeysByTags

func GetInstanceKeysByTags(tagsString string) (tagged *InstanceKeyMap, err error)

func NewInstanceKeyMap

func NewInstanceKeyMap() *InstanceKeyMap

func Untag

func Untag(instanceKey *InstanceKey, tag *Tag) (tagged *InstanceKeyMap, err error)

func (*InstanceKeyMap) AddInstances

func (this *InstanceKeyMap) AddInstances(instances [](*Instance))

AddInstances adds keys of all given instances to this map

func (*InstanceKeyMap) AddKey

func (this *InstanceKeyMap) AddKey(key InstanceKey)

AddKey adds a single key to this map

func (*InstanceKeyMap) AddKeys

func (this *InstanceKeyMap) AddKeys(keys []InstanceKey)

AddKeys adds all given keys to this map

func (*InstanceKeyMap) GetInstanceKeys

func (this *InstanceKeyMap) GetInstanceKeys() []InstanceKey

GetInstanceKeys returns keys in this map in the form of an array

func (*InstanceKeyMap) HasKey

func (this *InstanceKeyMap) HasKey(key InstanceKey) bool

HasKey checks if given key is within the map

func (*InstanceKeyMap) Intersect

func (this *InstanceKeyMap) Intersect(other *InstanceKeyMap) *InstanceKeyMap

Intersect returns a keymap which is the intersection of this and another map

func (InstanceKeyMap) MarshalJSON

func (this InstanceKeyMap) MarshalJSON() ([]byte, error)

MarshalJSON will marshal this map as JSON

func (*InstanceKeyMap) ReadCommaDelimitedList

func (this *InstanceKeyMap) ReadCommaDelimitedList(list string) error

ReadJson unmarshalls a json into this map

func (*InstanceKeyMap) ReadJson

func (this *InstanceKeyMap) ReadJson(jsonString string) error

ReadJson unmarshalls a json into this map

func (*InstanceKeyMap) ToCommaDelimitedList

func (this *InstanceKeyMap) ToCommaDelimitedList() string

ToCommaDelimitedList will export this map in comma delimited format

func (*InstanceKeyMap) ToJSON

func (this *InstanceKeyMap) ToJSON() (string, error)

ToJSON will marshal this map as JSON

func (*InstanceKeyMap) ToJSONString

func (this *InstanceKeyMap) ToJSONString() string

ToJSONString will marshal this map as JSON

func (*InstanceKeyMap) UnmarshalJSON

func (this *InstanceKeyMap) UnmarshalJSON(b []byte) error

UnmarshalJSON reds this object from JSON

type InstanceTag

type InstanceTag struct {
	Key InstanceKey
	T   Tag
}

type InstancesByCountReplicas

type InstancesByCountReplicas [](*Instance)

InstancesByCountReplicas is a sortable type for Instance

func (InstancesByCountReplicas) Len

func (this InstancesByCountReplicas) Len() int

func (InstancesByCountReplicas) Less

func (this InstancesByCountReplicas) Less(i, j int) bool

func (InstancesByCountReplicas) Swap

func (this InstancesByCountReplicas) Swap(i, j int)

type InstancesSorterByExec

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

InstancesSorterByExec sorts instances by executed binlog coordinates

func NewInstancesSorterByExec

func NewInstancesSorterByExec(instances [](*Instance), dataCenter string) *InstancesSorterByExec

func (*InstancesSorterByExec) Len

func (this *InstancesSorterByExec) Len() int

func (*InstancesSorterByExec) Less

func (this *InstancesSorterByExec) Less(i, j int) bool

func (*InstancesSorterByExec) Swap

func (this *InstancesSorterByExec) Swap(i, j int)

type Maintenance

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

Maintenance indicates a maintenance entry (also in the database)

func ReadActiveMaintenance

func ReadActiveMaintenance() ([]Maintenance, error)

ReadActiveMaintenance returns the list of currently active maintenance entries

type MinimalInstance

type MinimalInstance struct {
	Key         InstanceKey
	PrimaryKey  InstanceKey
	ClusterName string
}

func ReadAllMinimalInstances

func ReadAllMinimalInstances() ([]MinimalInstance, error)

ReadAllInstanceKeysSourceKeys

func (*MinimalInstance) ToInstance

func (this *MinimalInstance) ToInstance() *Instance

type OperationGTIDHint

type OperationGTIDHint string
const (
	GTIDHintDeny    OperationGTIDHint = "NoGTID"
	GTIDHintNeutral OperationGTIDHint = "GTIDHintNeutral"
	GTIDHintForce   OperationGTIDHint = "GTIDHintForce"
)

type OracleGtidSet

type OracleGtidSet struct {
	GtidEntries [](*OracleGtidSetEntry)
}

OracleGtidSet represents a set of GTID ranges as depicted by Retrieved_Gtid_Set, Executed_Gtid_Set or @@gtid_purged.

func GetPreviousGTIDs

func GetPreviousGTIDs(instanceKey *InstanceKey, binlog string) (previousGTIDs *OracleGtidSet, err error)

func NewOracleGtidSet

func NewOracleGtidSet(gtidSet string) (res *OracleGtidSet, err error)

Example input: `230ea8ea-81e3-11e4-972a-e25ec4bd140a:1-10539, 316d193c-70e5-11e5-adb2-ecf4bb2262ff:1-8935:8984-6124596, 321f5c0d-70e5-11e5-adb2-ecf4bb2262ff:1-56`

func (*OracleGtidSet) Explode

func (this *OracleGtidSet) Explode() (result [](*OracleGtidSetEntry))

String returns a user-friendly string representation of this entry

func (*OracleGtidSet) IsEmpty

func (this *OracleGtidSet) IsEmpty() bool

func (*OracleGtidSet) RemoveUUID

func (this *OracleGtidSet) RemoveUUID(uuid string) (removed bool)

RemoveUUID removes entries that belong to given UUID. By way of how this works there can only be one entry matching our UUID, but we generalize. We keep order of entries.

func (*OracleGtidSet) RetainUUID

func (this *OracleGtidSet) RetainUUID(uuid string) (anythingRemoved bool)

RetainUUID retains only entries that belong to given UUID.

func (*OracleGtidSet) RetainUUIDs

func (this *OracleGtidSet) RetainUUIDs(uuids []string) (anythingRemoved bool)

RetainUUIDs retains only entries that belong to given UUIDs.

func (*OracleGtidSet) SharedUUIDs

func (this *OracleGtidSet) SharedUUIDs(other *OracleGtidSet) (shared []string)

SharedUUIDs returns UUIDs (range-less) that are shared between the two sets

func (*OracleGtidSet) String

func (this *OracleGtidSet) String() string

type OracleGtidSetEntry

type OracleGtidSetEntry struct {
	UUID   string
	Ranges string
}

OracleGtidSetEntry represents an entry in a set of GTID ranges, for example, the entry: "316d193c-70e5-11e5-adb2-ecf4bb2262ff:1-8935:8984-6124596" (may include gaps)

func NewOracleGtidSetEntry

func NewOracleGtidSetEntry(gtidRangeString string) (*OracleGtidSetEntry, error)

NewOracleGtidSetEntry parses a single entry text

func (*OracleGtidSetEntry) Explode

func (this *OracleGtidSetEntry) Explode() (result [](*OracleGtidSetEntry))

String returns a user-friendly string representation of this entry

func (*OracleGtidSetEntry) String

func (this *OracleGtidSetEntry) String() string

String returns a user-friendly string representation of this entry

type PeerAnalysisMap

type PeerAnalysisMap map[string]int

PeerAnalysisMap indicates the number of peers agreeing on an analysis. Key of this map is a InstanceAnalysis.String()

func ReadPeerAnalysisMap

func ReadPeerAnalysisMap() (peerAnalysisMap PeerAnalysisMap, err error)

ReadPeerAnalysisMap reads raft-peer failure analysis, and returns a PeerAnalysisMap, indicating how many peers see which analysis

type PoolInstancesMap

type PoolInstancesMap map[string]([]*InstanceKey)

PoolInstancesMap lists instance keys per pool name

func ReadClusterPoolInstancesMap

func ReadClusterPoolInstancesMap(clusterName string, pool string) (*PoolInstancesMap, error)

ReadClusterPoolInstancesMap returns association of pools-to-instances for a given cluster and potentially for a given pool.

type PoolInstancesSubmission

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

func NewPoolInstancesSubmission

func NewPoolInstancesSubmission(pool string, instances string) *PoolInstancesSubmission

func ReadAllPoolInstancesSubmissions

func ReadAllPoolInstancesSubmissions() ([]PoolInstancesSubmission, error)

type PostponedFunctionsContainer

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

func NewPostponedFunctionsContainer

func NewPostponedFunctionsContainer() *PostponedFunctionsContainer

func (*PostponedFunctionsContainer) AddPostponedFunction

func (this *PostponedFunctionsContainer) AddPostponedFunction(postponedFunction func() error, description string)

func (*PostponedFunctionsContainer) Descriptions

func (this *PostponedFunctionsContainer) Descriptions() []string

func (*PostponedFunctionsContainer) Len

func (this *PostponedFunctionsContainer) Len() int

func (*PostponedFunctionsContainer) Wait

func (this *PostponedFunctionsContainer) Wait()

type Process

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
}

Process presents a MySQL executing thread (as observed by PROCESSLIST)

type ReplicationAnalysis

type ReplicationAnalysis struct {
	AnalyzedInstanceKey                       InstanceKey
	AnalyzedInstancePrimaryKey                InstanceKey
	TabletType                                topodatapb.TabletType
	PrimaryTimeStamp                          time.Time
	SuggestedClusterAlias                     string
	ClusterDetails                            ClusterInfo
	AnalyzedInstanceDataCenter                string
	AnalyzedInstanceRegion                    string
	AnalyzedInstancePhysicalEnvironment       string
	AnalyzedInstanceBinlogCoordinates         BinlogCoordinates
	IsPrimary                                 bool
	IsClusterPrimary                          bool
	IsCoPrimary                               bool
	LastCheckValid                            bool
	LastCheckPartialSuccess                   bool
	CountReplicas                             uint
	CountValidReplicas                        uint
	CountValidReplicatingReplicas             uint
	CountReplicasFailingToConnectToPrimary    uint
	CountDowntimedReplicas                    uint
	ReplicationDepth                          uint
	Replicas                                  InstanceKeyMap
	IsFailingToConnectToPrimary               bool
	ReplicationStopped                        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. AllPrimaryReplicasNotReplicating)
	DowntimeEndTimestamp                      string
	DowntimeRemainingSeconds                  int
	IsBinlogServer                            bool
	OracleGTIDImmediateTopology               bool
	MariaDBGTIDImmediateTopology              bool
	BinlogServerImmediateTopology             bool
	SemiSyncPrimaryEnabled                    bool
	SemiSyncPrimaryStatus                     bool
	SemiSyncPrimaryWaitForReplicaCount        uint
	SemiSyncPrimaryClients                    uint
	SemiSyncReplicaEnabled                    bool
	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
}

ReplicationAnalysis notes analysis on replication chain status, per instance

func GetReplicationAnalysis

func GetReplicationAnalysis(clusterName string, hints *ReplicationAnalysisHints) ([]ReplicationAnalysis, error)

GetReplicationAnalysis will check for replication problems (dead primary; unreachable primary; etc)

func (*ReplicationAnalysis) AnalysisString

func (this *ReplicationAnalysis) AnalysisString() string

AnalysisString returns a human friendly description of all analysis issues

func (*ReplicationAnalysis) GetAnalysisInstanceType

func (this *ReplicationAnalysis) GetAnalysisInstanceType() AnalysisInstanceType

Get a string description of the analyzed instance type (primary? co-primary? intermediate-primary?)

func (*ReplicationAnalysis) MarshalJSON

func (this *ReplicationAnalysis) MarshalJSON() ([]byte, error)

func (*ReplicationAnalysis) ReadReplicaHostsFromString

func (this *ReplicationAnalysis) ReadReplicaHostsFromString(replicaHostsString string) error

ReadReplicaHostsFromString parses and reads replica keys from comma delimited string

type ReplicationAnalysisChangelog

type ReplicationAnalysisChangelog struct {
	AnalyzedInstanceKey InstanceKey
	Changelog           []string
}

func ReadReplicationAnalysisChangelog

func ReadReplicationAnalysisChangelog() (res [](*ReplicationAnalysisChangelog), err error)

ReadReplicationAnalysisChangelog

type ReplicationAnalysisHints

type ReplicationAnalysisHints struct {
	IncludeDowntimed bool
	IncludeNoProblem bool
	AuditAnalysis    bool
}

type ReplicationThreadState

type ReplicationThreadState int
const (
	ReplicationThreadStateNoThread ReplicationThreadState = -1
	ReplicationThreadStateStopped  ReplicationThreadState = 0
	ReplicationThreadStateRunning  ReplicationThreadState = 1
	ReplicationThreadStateOther    ReplicationThreadState = 2
)

func ReplicationThreadStateFromStatus

func ReplicationThreadStateFromStatus(status string) ReplicationThreadState

func (*ReplicationThreadState) Exists

func (this *ReplicationThreadState) Exists() bool

func (*ReplicationThreadState) IsRunning

func (this *ReplicationThreadState) IsRunning() bool

func (*ReplicationThreadState) IsStopped

func (this *ReplicationThreadState) IsStopped() bool

type StopReplicationMethod

type StopReplicationMethod string
const (
	NoStopReplication     StopReplicationMethod = "NoStopReplication"
	StopReplicationNormal StopReplicationMethod = "StopReplicationNormal"
	StopReplicationNice   StopReplicationMethod = "StopReplicationNice"
)

type StructureAnalysisCode

type StructureAnalysisCode string
const (
	StatementAndMixedLoggingReplicasStructureWarning     StructureAnalysisCode = "StatementAndMixedLoggingReplicasStructureWarning"
	StatementAndRowLoggingReplicasStructureWarning       StructureAnalysisCode = "StatementAndRowLoggingReplicasStructureWarning"
	MixedAndRowLoggingReplicasStructureWarning           StructureAnalysisCode = "MixedAndRowLoggingReplicasStructureWarning"
	MultipleMajorVersionsLoggingReplicasStructureWarning StructureAnalysisCode = "MultipleMajorVersionsLoggingReplicasStructureWarning"
	NoLoggingReplicasStructureWarning                    StructureAnalysisCode = "NoLoggingReplicasStructureWarning"
	DifferentGTIDModesStructureWarning                   StructureAnalysisCode = "DifferentGTIDModesStructureWarning"
	ErrantGTIDStructureWarning                           StructureAnalysisCode = "ErrantGTIDStructureWarning"
	NoFailoverSupportStructureWarning                    StructureAnalysisCode = "NoFailoverSupportStructureWarning"
	NoWriteablePrimaryStructureWarning                   StructureAnalysisCode = "NoWriteablePrimaryStructureWarning"
	NotEnoughValidSemiSyncReplicasStructureWarning       StructureAnalysisCode = "NotEnoughValidSemiSyncReplicasStructureWarning"
)

type Tag

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

func NewTag

func NewTag(tagName string, tagValue string) (*Tag, error)

func ParseIntersectTags

func ParseIntersectTags(tagsString string) (tags [](*Tag), err error)

func ParseTag

func ParseTag(tagString string) (*Tag, error)

func ReadInstanceTags

func ReadInstanceTags(instanceKey *InstanceKey) (tags [](*Tag), err error)

func (*Tag) Display

func (tag *Tag) Display() string

func (*Tag) String

func (tag *Tag) String() string

type WriteBufferMetric

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
}

Metric records query metrics of backend writes that go through a sized channel. It allows us to compare the time waiting to execute the query against the time needed to run it and in a "sized channel" the wait time may be significant and is good to measure.

func (WriteBufferMetric) When

func (m WriteBufferMetric) When() time.Time

When records the timestamp of the start of the recording

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL