// ReadAgents returns a list of all known agents
func ReadAgents() ([]Agent, error) {
res := []Agent{}
query := `
select
hostname,
port,
token,
last_submitted,
mysql_port
from
host_agent
order by
hostname
`
err := db.QueryOrchestratorRowsMap(query, func(m sqlutils.RowMap) error {
agent := Agent{}
agent.Hostname = m.GetString("hostname")
agent.Port = m.GetInt("port")
agent.MySQLPort = m.GetInt64("mysql_port")
agent.Token = ""
agent.LastSubmitted = m.GetString("last_submitted")
res = append(res, agent)
return nil
})
if err != nil {
log.Errore(err)
}
return res, err
}
// ReadReplicationAnalysisChangelog
func ReadReplicationAnalysisChangelog() ([]ReplicationAnalysisChangelog, error) {
res := []ReplicationAnalysisChangelog{}
query := `
select
hostname,
port,
group_concat(analysis_timestamp,';',analysis order by changelog_id) as changelog
from
database_instance_analysis_changelog
group by
hostname, port
`
err := db.QueryOrchestratorRowsMap(query, func(m sqlutils.RowMap) error {
analysisChangelog := ReplicationAnalysisChangelog{}
analysisChangelog.AnalyzedInstanceKey.Hostname = m.GetString("hostname")
analysisChangelog.AnalyzedInstanceKey.Port = m.GetInt("port")
analysisChangelog.Changelog = m.GetString("changelog")
res = append(res, analysisChangelog)
return nil
})
if err != nil {
log.Errore(err)
}
return res, err
}
// DeleteInvalidHostnameResolves removes invalid resolves. At this time these are:
// - infinite loop resolves (A->B and B->A), remove earlier mapping
func DeleteInvalidHostnameResolves() error {
var invalidHostnames []string
query := `
select
early.hostname
from
hostname_resolve as latest
join hostname_resolve early on (latest.resolved_hostname = early.hostname and latest.hostname = early.resolved_hostname)
where
latest.hostname != latest.resolved_hostname
and latest.resolved_timestamp > early.resolved_timestamp
`
err := db.QueryOrchestratorRowsMap(query, func(m sqlutils.RowMap) error {
invalidHostnames = append(invalidHostnames, m.GetString("hostname"))
return nil
})
if err != nil {
return err
}
for _, invalidHostname := range invalidHostnames {
_, err = db.ExecOrchestrator(`
delete
from hostname_resolve
where
hostname = ?`,
invalidHostname,
)
log.Errore(err)
}
return err
}
// ReadAllHostnameUnresolves returns the content of the hostname_unresolve table
func ReadAllHostnameUnresolves() ([]HostnameUnresolve, error) {
unres := []HostnameUnresolve{}
query := `
select
hostname,
unresolved_hostname
from
hostname_unresolve
`
err := db.QueryOrchestratorRowsMap(query, func(m sqlutils.RowMap) error {
hostnameUnresolve := HostnameUnresolve{hostname: m.GetString("hostname"), unresolvedHostname: m.GetString("unresolved_hostname")}
unres = append(unres, hostnameUnresolve)
return nil
})
return unres, log.Errore(err)
}
// ElectedNode returns the details of the elected node, as well as answering the question "is this process the elected one"?
func ElectedNode() (hostname string, token string, isElected bool, err error) {
query := `
select
hostname,
token
from
active_node
where
anchor = 1
`
err = db.QueryOrchestratorRowsMap(query, func(m sqlutils.RowMap) error {
hostname = m.GetString("hostname")
token = m.GetString("token")
return nil
})
if err != nil {
log.Errore(err)
}
isElected = (hostname == ThisHostname && token == ProcessToken.Hash)
return hostname, token, isElected, err
}
func ReadAllHostnameResolves() ([]HostnameResolve, error) {
res := []HostnameResolve{}
query := `
select
hostname,
resolved_hostname
from
hostname_resolve
`
err := db.QueryOrchestratorRowsMap(query, func(m sqlutils.RowMap) error {
hostnameResolve := HostnameResolve{hostname: m.GetString("hostname"), resolvedHostname: m.GetString("resolved_hostname")}
res = append(res, hostnameResolve)
return nil
})
readAllResolvedHostnamesCounter.Inc(1)
if err != nil {
log.Errore(err)
}
return res, err
}
// readMissingHostnamesToResolve gets those (unresolved, e.g. VIP) hostnames that *should* be present in
// the hostname_resolve table, but aren't.
func readMissingKeysToResolve() (result InstanceKeyMap, err error) {
query := `
select
hostname_unresolve.unresolved_hostname,
database_instance.port
from
database_instance
join hostname_unresolve on (database_instance.hostname = hostname_unresolve.hostname)
left join hostname_resolve on (database_instance.hostname = hostname_resolve.resolved_hostname)
where
hostname_resolve.hostname is null
`
err = db.QueryOrchestratorRowsMap(query, func(m sqlutils.RowMap) error {
instanceKey := InstanceKey{Hostname: m.GetString("unresolved_hostname"), Port: m.GetInt("port")}
result.AddKey(instanceKey)
return nil
})
if err != nil {
log.Errore(err)
}
return result, err
}