def get_server(name, values, quiet):
"""Connect to a server and return Server instance
If the name is 'master' or 'slave', the connection will be made via the
Master or Slave class else a normal Server class shall be used.
name[in] name of the server
values[in] dictionary of connection values
quiet[in] if True, do not print messages
Returns Server class instance
"""
from mysql.utilities.common.replication import Master
from mysql.utilities.common.replication import Slave
server_conn = None
# Try to connect to the MySQL database server.
if not quiet:
_print_connection(name, values)
server_options = {
'conn_info' : values,
'role' : name,
}
if name.lower() == 'master':
server_conn = Master(server_options)
elif name.lower() == 'slave':
server_conn = Slave(server_options)
else:
server_conn = Server(server_options)
server_conn.connect()
return server_conn
def _format_health_data(self):
"""Return health data from topology.
Returns tuple - (columns, rows).
"""
if self.topology:
try:
health_data = self.topology.get_health()
current_master = self._get_master()
# Get data for the remaining masters
for master_vals in self.masters_vals:
# Discard the current master
if master_vals["host"] == current_master.host and \
master_vals["port"] == current_master.port:
continue
# Connect to the master
conn_dict = {
"conn_info": master_vals,
"quiet": True,
"verbose": self.verbosity > 0,
}
master = Master(conn_dict)
master.connect()
# Get master health
rpl_health = master.check_rpl_health()
master_data = [
master.host,
master.port,
"MASTER",
get_server_state(master, master.host, 3,
self.verbosity > 0),
master.supports_gtid(),
"OK" if rpl_health[0] else ", ".join(rpl_health[1]),
]
# Get master status
master_status = master.get_status()
if len(master_status):
master_log, master_log_pos = master_status[0][0:2]
else:
master_log = None
master_log_pos = 0
# Show additional details if verbosity is turned on
if self.verbosity > 0:
master_data.extend([
master.get_version(), master_log, master_log_pos,
"", "", "", "", "", "", "", "", ""
])
health_data[1].append(master_data)
return health_data
except UtilError as err:
msg = "Cannot get health data: {0}".format(err)
self._report(msg, logging.ERROR, False)
raise UtilRplError(msg)
return ([], [])
def _check_server_versions(self):
"""Checks the server versions.
"""
if self.verbosity > 0:
print("# Checking server versions.\n#")
# Connection dictionary
conn_dict = {
"conn_info": None,
"quiet": True,
"verbose": self.verbosity > 0,
}
# Check masters version
for master_vals in self.masters_vals:
conn_dict["conn_info"] = master_vals
master = Master(conn_dict)
master.connect()
if not master.check_version_compat(*_MIN_SERVER_VERSION):
raise UtilRplError(
ERROR_MIN_SERVER_VERSIONS.format(
utility="mysqlrplms",
min_version=".".join([str(val) for val in
_MIN_SERVER_VERSION]),
host=master.host,
port=master.port
)
)
master.disconnect()
# Check slave version
conn_dict["conn_info"] = self.slave_vals
slave = Slave(conn_dict)
slave.connect()
if not slave.check_version_compat(*_MIN_SERVER_VERSION):
raise UtilRplError(
ERROR_MIN_SERVER_VERSIONS.format(
utility="mysqlrplms",
min_version=".".join([str(val) for val in
_MIN_SERVER_VERSION]),
host=slave.host,
port=slave.port
)
)
slave.disconnect()
def _check_privileges(self):
"""Check required privileges to perform the multi-source replication.
This method check if the used users for the slave and masters have
the required privileges to perform the multi-source replication.
The following privileges are required:
- on slave: SUPER, SELECT, INSERT, UPDATE, REPLICATION
SLAVE AND GRANT OPTION;
- on the master: SUPER, SELECT, INSERT, UPDATE, REPLICATION SLAVE
AND GRANT OPTION.
An exception is thrown if users doesn't have enough privileges.
"""
if self.verbosity > 0:
print("# Checking users privileges for replication.\n#")
# Connection dictionary
conn_dict = {
"conn_info": None,
"quiet": True,
"verbose": self.verbosity > 0,
}
# Check privileges for master.
master_priv = [('SUPER',), ('SELECT',), ('INSERT',), ('UPDATE',),
('REPLICATION SLAVE',), ('GRANT OPTION',)]
master_priv_str = ("SUPER, SELECT, INSERT, UPDATE, REPLICATION SLAVE "
"AND GRANT OPTION")
for master_vals in self.masters_vals:
conn_dict["conn_info"] = master_vals
master = Master(conn_dict)
master.connect()
user_obj = User(master, "{0}@{1}".format(master.user, master.host))
for any_priv_tuple in master_priv:
has_privilege = any(
[user_obj.has_privilege('*', '*', priv)
for priv in any_priv_tuple]
)
if not has_privilege:
msg = ERROR_USER_WITHOUT_PRIVILEGES.format(
user=master.user, host=master.host, port=master.port,
operation='perform replication',
req_privileges=master_priv_str
)
self._report(msg, logging.CRITICAL, False)
raise UtilRplError(msg)
master.disconnect()
# Check privileges for slave
slave_priv = [('SUPER',), ('SELECT',), ('INSERT',), ('UPDATE',),
('REPLICATION SLAVE',), ('GRANT OPTION',)]
slave_priv_str = ("SUPER, SELECT, INSERT, UPDATE, REPLICATION SLAVE "
"AND GRANT OPTION")
conn_dict["conn_info"] = self.slave_vals
slave = Slave(conn_dict)
slave.connect()
user_obj = User(slave, "{0}@{1}".format(slave.user, slave.host))
for any_priv_tuple in slave_priv:
has_privilege = any(
[user_obj.has_privilege('*', '*', priv)
for priv in any_priv_tuple]
)
if not has_privilege:
msg = ("User '{0}' on '{1}@{2}' does not have sufficient "
"privileges to perform replication (required: {3})."
"".format(slave.user, slave.host, slave.port,
slave_priv_str))
self._report(msg, logging.CRITICAL, False)
raise UtilRplError(msg)
slave.disconnect()
