percona/percona-toolkit
1
0
Fork 0
mirror of https://github.com/percona/percona-toolkit.git synced 2025-09-16 08:17:20 +00:00
Code Issues Packages Projects Releases Wiki Activity

PT-2340 - Support MySQL 8.4

Browse Source 
- Removed lib/Percona/Test.pm, lib/Safeguards.pm, t/lib/Safeguards.t, because they are not used anymore
- Removed word "slave" from lib
This commit is contained in:
Sveta Smirnova
2024-07-25 23:37:22 +03:00
parent b9a5231c9b
commit 8cbb5a0c8f
24 changed files with 576 additions and 1443 deletions
Download Patch File Download Diff File Expand all files Collapse all files

102
lib/ReplicaLagWaiter.pm
View File

@@ -19,7 +19,7 @@
# ###########################################################################
{
# Package: ReplicaLagWaiter
# ReplicaLagWaiter helps limit slave lag when working on the source.
# ReplicaLagWaiter helps limit replica lag when working on the source.
package ReplicaLagWaiter;
use strict;
@@ -34,16 +34,16 @@ use Data::Dumper;
#
# Required Arguments:
# oktorun - Callback that returns true if it's ok to continue running
# get_lag - Callback passed slave dbh and returns slave's lag
# get_lag - Callback passed replica dbh and returns replica's lag
# sleep - Callback to sleep between checking lag.
# max_lag - Max lag
# slaves - Arrayref of <Cxn> objects
# replicas - Arrayref of <Cxn> objects
#
# Returns:
# ReplicaLagWaiter object
sub new {
my ( $class, %args ) = @_;
my @required_args = qw(oktorun get_lag sleep max_lag slaves);
my @required_args = qw(oktorun get_lag sleep max_lag replicas);
foreach my $arg ( @required_args ) {
die "I need a $arg argument" unless defined $args{$arg};
}
@@ -56,13 +56,13 @@ sub new {
}
# Sub: wait
# Wait for Seconds_Behind_Source on all slaves to become < max.
# Wait for Seconds_Behind_Source on all replicas to become < max.
#
# Optional Arguments:
# Progress - <Progress> object to report waiting
#
# Returns:
# 1 if all slaves catch up before timeout, else 0 if continue=yes, else die.
# 1 if all replicas catch up before timeout, else 0 if continue=yes, else die.
sub wait {
my ( $self, %args ) = @_;
my @required_args = qw();
@@ -71,34 +71,34 @@ sub wait {
}
my $pr = $args{Progress};
my $oktorun = $self->{oktorun};
my $get_lag = $self->{get_lag};
my $sleep = $self->{sleep};
my $slaves = $self->{slaves};
my $max_lag = $self->{max_lag};
my $oktorun = $self->{oktorun};
my $get_lag = $self->{get_lag};
my $sleep = $self->{sleep};
my $replicas = $self->{replicas};
my $max_lag = $self->{max_lag};
my $worst; # most lagging slave
my $worst; # most lagging replica
my $pr_callback;
my $pr_first_report;
### refresh list of slaves. In: self passed to wait()
### Returns: new slave list
my $pr_refresh_slave_list = sub {
### refresh list of replicas. In: self passed to wait()
### Returns: new replica list
my $pr_refresh_replica_list = sub {
my ($self) = @_;
my ($slaves, $refresher) = ($self->{slaves}, $self->{get_slaves_cb});
return $slaves if ( not defined $refresher );
my $before = join ' ', sort map {$_->description()} @$slaves;
$slaves = $refresher->();
my $after = join ' ', sort map {$_->description()} @$slaves;
my ($replicas, $refresher) = ($self->{replicas}, $self->{get_replicas_cb});
return $replicas if ( not defined $refresher );
my $before = join ' ', sort map {$_->description()} @$replicas;
$replicas = $refresher->();
my $after = join ' ', sort map {$_->description()} @$replicas;
if ($before ne $after) {
$self->{slaves} = $slaves;
printf STDERR "Slave set to watch has changed\n Was: %s\n Now: %s\n",
$self->{replicas} = $replicas;
printf STDERR "Replica set to watch has changed\n Was: %s\n Now: %s\n",
$before, $after;
}
return($self->{slaves});
return($self->{replicas});
};
$slaves = $pr_refresh_slave_list->($self);
$replicas = $pr_refresh_replica_list->($self);
if ( $pr ) {
# If you use the default Progress report callback, you'll need to
@@ -136,54 +136,54 @@ sub wait {
};
}
# First check all slaves.
my @lagged_slaves = map { {cxn=>$_, lag=>undef} } @$slaves;
while ( $oktorun->() && @lagged_slaves ) {
PTDEBUG && _d('Checking slave lag');
# First check all replicas.
my @lagged_replicas = map { {cxn=>$_, lag=>undef} } @$replicas;
while ( $oktorun->() && @lagged_replicas ) {
PTDEBUG && _d('Checking replica lag');
### while we were waiting our list of slaves may have changed
$slaves = $pr_refresh_slave_list->($self);
### while we were waiting our list of replicas may have changed
$replicas = $pr_refresh_replica_list->($self);
my $watched = 0;
@lagged_slaves = grep {
my $slave_name = $_->{cxn}->name();
grep {$slave_name eq $_->name()} @{$slaves // []}
} @lagged_slaves;
@lagged_replicas = grep {
my $replica_name = $_->{cxn}->name();
grep {$replica_name eq $_->name()} @{$replicas // []}
} @lagged_replicas;
for my $i ( 0..$#lagged_slaves ) {
for my $i ( 0..$#lagged_replicas ) {
my $lag;
eval {
$lag = $get_lag->($lagged_slaves[$i]->{cxn});
$lag = $get_lag->($lagged_replicas[$i]->{cxn});
};
if ($EVAL_ERROR) {
die $EVAL_ERROR;
}
PTDEBUG && _d($lagged_slaves[$i]->{cxn}->name(),
'slave lag:', $lag);
PTDEBUG && _d($lagged_replicas[$i]->{cxn}->name(),
'replica lag:', $lag);
if ( !defined $lag || $lag > $max_lag ) {
$lagged_slaves[$i]->{lag} = $lag;
$lagged_replicas[$i]->{lag} = $lag;
}
else {
delete $lagged_slaves[$i];
delete $lagged_replicas[$i];
}
}
# Remove slaves that aren't lagging.
@lagged_slaves = grep { defined $_ } @lagged_slaves;
if ( @lagged_slaves ) {
# Sort lag, undef is highest because it means the slave is stopped.
@lagged_slaves = reverse sort {
# Remove replicas that aren't lagging.
@lagged_replicas = grep { defined $_ } @lagged_replicas;
if ( @lagged_replicas ) {
# Sort lag, undef is highest because it means the replica is stopped.
@lagged_replicas = reverse sort {
defined $a->{lag} && defined $b->{lag} ? $a->{lag} <=> $b->{lag}
: defined $a->{lag} ? -1
: 1;
} @lagged_slaves;
$worst = $lagged_slaves[0];
PTDEBUG && _d(scalar @lagged_slaves, 'slaves are lagging, worst:',
} @lagged_replicas;
$worst = $lagged_replicas[0];
PTDEBUG && _d(scalar @lagged_replicas, 'replicas are lagging, worst:',
$worst->{lag}, 'on', Dumper($worst->{cxn}->dsn()));
if ( $pr ) {
# There's no real progress because we can't estimate how long
# it will take all slaves to catch up. The progress reports
# are just to inform the user every 30s which slave is still
# it will take all replicas to catch up. The progress reports
# are just to inform the user every 30s which replica is still
# lagging this most.
$pr->update(
sub { return 0; },
@@ -196,7 +196,7 @@ sub wait {
}
}
PTDEBUG && _d('All slaves caught up');
PTDEBUG && _d('All replicas caught up');
return;
}