percona/percona-toolkit
1
0
Fork 0
mirror of https://github.com/percona/percona-toolkit.git synced 2026-04-26 01:02:25 +08:00
Code Issues Packages Projects Releases Wiki Activity

Update KeySize in pt-duplicate-key-checker to fix bug. Update all other modules too.

Browse Source
This commit is contained in:
Daniel Nichter
2013-12-11 18:17:16 -08:00
parent d48d77269d
commit 8ed6c956ac
2 changed files with 495 additions and 421 deletions
Download Patch File Download Diff File Expand all files Collapse all files
bin/pt-duplicate-key-checker
+238 -169
View File
@@ -23,7 +23,7 @@ BEGIN {
Daemon Daemon
Schema Schema
SchemaIterator SchemaIterator
HTTPMicro HTTP::Micro
VersionCheck VersionCheck
)); ));
} }
@@ -133,6 +133,8 @@ sub quote_val {
return $val if $val =~ m/^0x[0-9a-fA-F]+$/ # quote hex data return $val if $val =~ m/^0x[0-9a-fA-F]+$/ # quote hex data
&& !$args{is_char}; # unless is_char is true && !$args{is_char}; # unless is_char is true
return $val if $args{is_float};
$val =~ s/(['\\])/\\$1/g; $val =~ s/(['\\])/\\$1/g;
return "'$val'"; return "'$val'";
} }
@@ -2203,7 +2205,7 @@ sub get_key_size {
foreach my $col ( @cols ) { foreach my $col ( @cols ) {
push @where_cols, "$col=1"; push @where_cols, "$col=1";
} }
if ( scalar @cols == 1 ) { if ( scalar(@cols) == 1 && !$args{only_eq} ) {
push @where_cols, "$cols[0]<>1"; push @where_cols, "$cols[0]<>1";
} }
$sql .= join(' OR ', @where_cols); $sql .= join(' OR ', @where_cols);
@@ -2227,6 +2229,21 @@ sub get_key_size {
PTDEBUG && _d('MySQL chose key:', $chosen_key, 'len:', $key_len, PTDEBUG && _d('MySQL chose key:', $chosen_key, 'len:', $key_len,
'rows:', $rows); 'rows:', $rows);
if ( $chosen_key && $key_len eq '0' ) {
if ( $args{recurse} ) {
$self->{error} = "key_len = 0 in EXPLAIN:\n"
. _explain_to_text($explain);
return;
}
else {
return $self->get_key_size(
%args,
only_eq => 1,
recurse => 1,
);
}
}
my $key_size = 0; my $key_size = 0;
if ( $key_len && $rows ) { if ( $key_len && $rows ) {
if ( $chosen_key =~ m/,/ && $key_len =~ m/,/ ) { if ( $chosen_key =~ m/,/ && $key_len =~ m/,/ ) {
@@ -2687,59 +2704,79 @@ package Daemon;
use strict; use strict;
use warnings FATAL => 'all'; use warnings FATAL => 'all';
use English qw(-no_match_vars); use English qw(-no_match_vars);
use constant PTDEBUG => $ENV{PTDEBUG} || 0; use constant PTDEBUG => $ENV{PTDEBUG} || 0;
use POSIX qw(setsid); use POSIX qw(setsid);
use Fcntl qw(:DEFAULT);
sub new { sub new {
my ( $class, %args ) = @_; my ($class, %args) = @_;
foreach my $arg ( qw(o) ) {
die "I need a $arg argument" unless $args{$arg};
}
my $o = $args{o};
my $self = { my $self = {
o => $o, log_file => $args{log_file},
log_file => $o->has('log') ? $o->get('log') : undef, pid_file => $args{pid_file},
PID_file => $o->has('pid') ? $o->get('pid') : undef, daemonize => $args{daemonize},
force_log_file => $args{force_log_file},
parent_exit => $args{parent_exit},
pid_file_owner => 0,
}; };
check_PID_file(undef, $self->{PID_file});
PTDEBUG && _d('Daemonized child will log to', $self->{log_file});
return bless $self, $class; return bless $self, $class;
} }
sub daemonize { sub run {
my ( $self ) = @_; my ($self) = @_;
PTDEBUG && _d('About to fork and daemonize'); my $daemonize = $self->{daemonize};
defined (my $pid = fork()) or die "Cannot fork: $OS_ERROR"; my $pid_file = $self->{pid_file};
if ( $pid ) { my $log_file = $self->{log_file};
PTDEBUG && _d('Parent PID', $PID, 'exiting after forking child PID',$pid); my $force_log_file = $self->{force_log_file};
exit; my $parent_exit = $self->{parent_exit};
PTDEBUG && _d('Starting daemon');
if ( $pid_file ) {
eval {
$self->_make_pid_file(
pid => $PID, # parent's pid
pid_file => $pid_file,
);
};
die "$EVAL_ERROR\n" if $EVAL_ERROR;
if ( !$daemonize ) {
$self->{pid_file_owner} = $PID; # parent's pid
}
} }
PTDEBUG && _d('Daemonizing child PID', $PID); if ( $daemonize ) {
$self->{PID_owner} = $PID; defined (my $child_pid = fork()) or die "Cannot fork: $OS_ERROR";
$self->{child} = 1; if ( $child_pid ) {
PTDEBUG && _d('Forked child', $child_pid);
$parent_exit->($child_pid) if $parent_exit;
exit 0;
}
POSIX::setsid() or die "Cannot start a new session: $OS_ERROR"; POSIX::setsid() or die "Cannot start a new session: $OS_ERROR";
chdir '/' or die "Cannot chdir to /: $OS_ERROR"; chdir '/' or die "Cannot chdir to /: $OS_ERROR";
$self->_make_PID_file(); if ( $pid_file ) {
$self->_update_pid_file(
$OUTPUT_AUTOFLUSH = 1; pid => $PID, # child's pid
pid_file => $pid_file,
);
$self->{pid_file_owner} = $PID;
}
}
if ( $daemonize || $force_log_file ) {
PTDEBUG && _d('Redirecting STDIN to /dev/null'); PTDEBUG && _d('Redirecting STDIN to /dev/null');
close STDIN; close STDIN;
open STDIN, '/dev/null' open STDIN, '/dev/null'
or die "Cannot reopen STDIN to /dev/null: $OS_ERROR"; or die "Cannot reopen STDIN to /dev/null: $OS_ERROR";
if ( $log_file ) {
if ( $self->{log_file} ) { PTDEBUG && _d('Redirecting STDOUT and STDERR to', $log_file);
PTDEBUG && _d('Redirecting STDOUT and STDERR to', $self->{log_file});
close STDOUT; close STDOUT;
open STDOUT, '>>', $self->{log_file} open STDOUT, '>>', $log_file
or die "Cannot open log file $self->{log_file}: $OS_ERROR"; or die "Cannot open log file $log_file: $OS_ERROR";
close STDERR; close STDERR;
open STDERR, ">&STDOUT" open STDERR, ">&STDOUT"
@@ -2762,82 +2799,119 @@ sub daemonize {
} }
} }
$OUTPUT_AUTOFLUSH = 1;
}
PTDEBUG && _d('Daemon running');
return; return;
} }
sub check_PID_file { sub _make_pid_file {
my ( $self, $file ) = @_; my ($self, %args) = @_;
my $PID_file = $self ? $self->{PID_file} : $file; my @required_args = qw(pid pid_file);
PTDEBUG && _d('Checking PID file', $PID_file); foreach my $arg ( @required_args ) {
if ( $PID_file && -f $PID_file ) { die "I need a $arg argument" unless $args{$arg};
my $pid;
eval {
chomp($pid = (slurp_file($PID_file) || ''));
}; };
if ( $EVAL_ERROR ) { my $pid = $args{pid};
die "The PID file $PID_file already exists but it cannot be read: " my $pid_file = $args{pid_file};
. $EVAL_ERROR;
eval {
sysopen(PID_FH, $pid_file, O_RDWR|O_CREAT|O_EXCL) or die $OS_ERROR;
print PID_FH $PID, "\n";
close PID_FH;
};
if ( my $e = $EVAL_ERROR ) {
if ( $e =~ m/file exists/i ) {
my $old_pid = $self->_check_pid_file(
pid_file => $pid_file,
pid => $PID,
);
if ( $old_pid ) {
warn "Overwriting PID file $pid_file because PID $old_pid "
. "is not running.\n";
} }
PTDEBUG && _d('PID file exists; it contains PID', $pid); $self->_update_pid_file(
if ( $pid ) { pid => $PID,
my $pid_is_alive = kill 0, $pid; pid_file => $pid_file
);
}
else {
die "Error creating PID file $pid_file: $e\n";
}
}
return;
}
sub _check_pid_file {
my ($self, %args) = @_;
my @required_args = qw(pid_file pid);
foreach my $arg ( @required_args ) {
die "I need a $arg argument" unless $args{$arg};
};
my $pid_file = $args{pid_file};
my $pid = $args{pid};
PTDEBUG && _d('Checking if PID in', $pid_file, 'is running');
if ( ! -f $pid_file ) {
PTDEBUG && _d('PID file', $pid_file, 'does not exist');
return;
}
open my $fh, '<', $pid_file
or die "Error opening $pid_file: $OS_ERROR";
my $existing_pid = do { local $/; <$fh> };
chomp($existing_pid) if $existing_pid;
close $fh
or die "Error closing $pid_file: $OS_ERROR";
if ( $existing_pid ) {
if ( $existing_pid == $pid ) {
warn "The current PID $pid already holds the PID file $pid_file\n";
return;
}
else {
PTDEBUG && _d('Checking if PID', $existing_pid, 'is running');
my $pid_is_alive = kill 0, $existing_pid;
if ( $pid_is_alive ) { if ( $pid_is_alive ) {
die "The PID file $PID_file already exists " die "PID file $pid_file exists and PID $existing_pid is running\n";
. " and the PID that it contains, $pid, is running";
} }
else {
warn "Overwriting PID file $PID_file because the PID that it "
. "contains, $pid, is not running";
} }
} }
else { else {
die "The PID file $PID_file already exists but it does not " die "PID file $pid_file exists but it is empty. Remove the file "
. "contain a PID"; . "if the process is no longer running.\n";
}
}
else {
PTDEBUG && _d('No PID file');
} }
return $existing_pid;
}
sub _update_pid_file {
my ($self, %args) = @_;
my @required_args = qw(pid pid_file);
foreach my $arg ( @required_args ) {
die "I need a $arg argument" unless $args{$arg};
};
my $pid = $args{pid};
my $pid_file = $args{pid_file};
open my $fh, '>', $pid_file
or die "Cannot open $pid_file: $OS_ERROR";
print { $fh } $pid, "\n"
or die "Cannot print to $pid_file: $OS_ERROR";
close $fh
or warn "Cannot close $pid_file: $OS_ERROR";
return; return;
} }
sub make_PID_file { sub remove_pid_file {
my ( $self ) = @_; my ($self, $pid_file) = @_;
if ( exists $self->{child} ) { $pid_file ||= $self->{pid_file};
die "Do not call Daemon::make_PID_file() for daemonized scripts"; if ( $pid_file && -f $pid_file ) {
} unlink $self->{pid_file}
$self->_make_PID_file(); or warn "Cannot remove PID file $pid_file: $OS_ERROR";
$self->{PID_owner} = $PID;
return;
}
sub _make_PID_file {
my ( $self ) = @_;
my $PID_file = $self->{PID_file};
if ( !$PID_file ) {
PTDEBUG && _d('No PID file to create');
return;
}
$self->check_PID_file();
open my $PID_FH, '>', $PID_file
or die "Cannot open PID file $PID_file: $OS_ERROR";
print $PID_FH $PID
or die "Cannot print to PID file $PID_file: $OS_ERROR";
close $PID_FH
or die "Cannot close PID file $PID_file: $OS_ERROR";
PTDEBUG && _d('Created PID file:', $self->{PID_file});
return;
}
sub _remove_PID_file {
my ( $self ) = @_;
if ( $self->{PID_file} && -f $self->{PID_file} ) {
unlink $self->{PID_file}
or warn "Cannot remove PID file $self->{PID_file}: $OS_ERROR";
PTDEBUG && _d('Removed PID file'); PTDEBUG && _d('Removed PID file');
} }
else { else {
@@ -2847,20 +2921,15 @@ sub _remove_PID_file {
} }
sub DESTROY { sub DESTROY {
my ( $self ) = @_; my ($self) = @_;
$self->_remove_PID_file() if ($self->{PID_owner} || 0) == $PID; if ( $self->{pid_file_owner} == $PID ) {
$self->remove_pid_file();
}
return; return;
} }
sub slurp_file {
my ($file) = @_;
return unless $file;
open my $fh, "<", $file or die "Cannot open $file: $OS_ERROR";
return do { local $/; <$fh> };
}
sub _d { sub _d {
my ($package, undef, $line) = caller 0; my ($package, undef, $line) = caller 0;
@_ = map { (my $temp = $_) =~ s/\n/\n# /g; $temp; } @_ = map { (my $temp = $_) =~ s/\n/\n# /g; $temp; }
@@ -3543,25 +3612,23 @@ sub _d {
# ########################################################################### # ###########################################################################
# ########################################################################### # ###########################################################################
# HTTPMicro package # HTTP::Micro package
# This package is a copy without comments from the original. The original # This package is a copy without comments from the original. The original
# with comments and its test file can be found in the Bazaar repository at, # with comments and its test file can be found in the Bazaar repository at,
# lib/HTTPMicro.pm # lib/HTTP/Micro.pm
# t/lib/HTTPMicro.t # t/lib/HTTP/Micro.t
# See https://launchpad.net/percona-toolkit for more information. # See https://launchpad.net/percona-toolkit for more information.
# ########################################################################### # ###########################################################################
{ {
package HTTP::Micro;
our $VERSION = '0.01';
package HTTPMicro;
BEGIN {
$HTTPMicro::VERSION = '0.001';
}
use strict; use strict;
use warnings; use warnings FATAL => 'all';
use English qw(-no_match_vars);
use Carp (); use Carp ();
my @attributes; my @attributes;
BEGIN { BEGIN {
@attributes = qw(agent timeout); @attributes = qw(agent timeout);
@@ -3632,7 +3699,7 @@ sub _request {
headers => {}, headers => {},
}; };
my $handle = HTTPMicro::Handle->new(timeout => $self->{timeout}); my $handle = HTTP::Micro::Handle->new(timeout => $self->{timeout});
$handle->connect($scheme, $host, $port); $handle->connect($scheme, $host, $port);
@@ -3697,27 +3764,31 @@ sub _split_url {
return ($scheme, $host, $port, $path_query); return ($scheme, $host, $port, $path_query);
} }
package } # HTTP::Micro
HTTPMicro::Handle; # hide from PAUSE/indexers
use strict;
use warnings;
use Carp qw[croak]; {
use Errno qw[EINTR EPIPE]; package HTTP::Micro::Handle;
use IO::Socket qw[SOCK_STREAM];
sub BUFSIZE () { 32768 } use strict;
use warnings FATAL => 'all';
use English qw(-no_match_vars);
my $Printable = sub { use Carp qw(croak);
use Errno qw(EINTR EPIPE);
use IO::Socket qw(SOCK_STREAM);
sub BUFSIZE () { 32768 }
my $Printable = sub {
local $_ = shift; local $_ = shift;
s/\r/\\r/g; s/\r/\\r/g;
s/\n/\\n/g; s/\n/\\n/g;
s/\t/\\t/g; s/\t/\\t/g;
s/([^\x20-\x7E])/sprintf('\\x%.2X', ord($1))/ge; s/([^\x20-\x7E])/sprintf('\\x%.2X', ord($1))/ge;
$_; $_;
}; };
sub new { sub new {
my ($class, %args) = @_; my ($class, %args) = @_;
return bless { return bless {
rbuf => '', rbuf => '',
@@ -3725,15 +3796,15 @@ sub new {
max_line_size => 16384, max_line_size => 16384,
%args %args
}, $class; }, $class;
} }
my $ssl_verify_args = { my $ssl_verify_args = {
check_cn => "when_only", check_cn => "when_only",
wildcards_in_alt => "anywhere", wildcards_in_alt => "anywhere",
wildcards_in_cn => "anywhere" wildcards_in_cn => "anywhere"
}; };
sub connect { sub connect {
@_ == 4 || croak(q/Usage: $handle->connect(scheme, host, port)/); @_ == 4 || croak(q/Usage: $handle->connect(scheme, host, port)/);
my ($self, $scheme, $host, $port) = @_; my ($self, $scheme, $host, $port) = @_;
@@ -3747,7 +3818,7 @@ sub connect {
croak(qq/Unsupported URL scheme '$scheme'\n/); croak(qq/Unsupported URL scheme '$scheme'\n/);
} }
$self->{fh} = 'IO::Socket::INET'->new( $self->{fh} = IO::Socket::INET->new(
PeerHost => $host, PeerHost => $host,
PeerPort => $port, PeerPort => $port,
Proto => 'tcp', Proto => 'tcp',
@@ -3776,16 +3847,16 @@ sub connect {
$self->{port} = $port; $self->{port} = $port;
return $self; return $self;
} }
sub close { sub close {
@_ == 1 || croak(q/Usage: $handle->close()/); @_ == 1 || croak(q/Usage: $handle->close()/);
my ($self) = @_; my ($self) = @_;
CORE::close($self->{fh}) CORE::close($self->{fh})
or croak(qq/Could not close socket: '$!'/); or croak(qq/Could not close socket: '$!'/);
} }
sub write { sub write {
@_ == 2 || croak(q/Usage: $handle->write(buf)/); @_ == 2 || croak(q/Usage: $handle->write(buf)/);
my ($self, $buf) = @_; my ($self, $buf) = @_;
@@ -3811,9 +3882,9 @@ sub write {
} }
} }
return $off; return $off;
} }
sub read { sub read {
@_ == 2 || @_ == 3 || croak(q/Usage: $handle->read(len)/); @_ == 2 || @_ == 3 || croak(q/Usage: $handle->read(len)/);
my ($self, $len) = @_; my ($self, $len) = @_;
@@ -3842,9 +3913,9 @@ sub read {
croak(q/Unexpected end of stream/); croak(q/Unexpected end of stream/);
} }
return $buf; return $buf;
} }
sub readline { sub readline {
@_ == 1 || croak(q/Usage: $handle->readline()/); @_ == 1 || croak(q/Usage: $handle->readline()/);
my ($self) = @_; my ($self) = @_;
@@ -3863,9 +3934,9 @@ sub readline {
} }
} }
croak(q/Unexpected end of stream while looking for line/); croak(q/Unexpected end of stream while looking for line/);
} }
sub read_header_lines { sub read_header_lines {
@_ == 1 || @_ == 2 || croak(q/Usage: $handle->read_header_lines([headers])/); @_ == 1 || @_ == 2 || croak(q/Usage: $handle->read_header_lines([headers])/);
my ($self, $headers) = @_; my ($self, $headers) = @_;
$headers ||= {}; $headers ||= {};
@@ -3894,9 +3965,9 @@ sub read_header_lines {
} }
} }
return $headers; return $headers;
} }
sub write_header_lines { sub write_header_lines {
(@_ == 2 && ref $_[1] eq 'HASH') || croak(q/Usage: $handle->write_header_lines(headers)/); (@_ == 2 && ref $_[1] eq 'HASH') || croak(q/Usage: $handle->write_header_lines(headers)/);
my($self, $headers) = @_; my($self, $headers) = @_;
@@ -3910,9 +3981,9 @@ sub write_header_lines {
} }
$buf .= "\x0D\x0A"; $buf .= "\x0D\x0A";
return $self->write($buf); return $self->write($buf);
} }
sub read_content_body { sub read_content_body {
@_ == 3 || @_ == 4 || croak(q/Usage: $handle->read_content_body(callback, response, [read_length])/); @_ == 3 || @_ == 4 || croak(q/Usage: $handle->read_content_body(callback, response, [read_length])/);
my ($self, $cb, $response, $len) = @_; my ($self, $cb, $response, $len) = @_;
$len ||= $response->{headers}{'content-length'}; $len ||= $response->{headers}{'content-length'};
@@ -3927,9 +3998,9 @@ sub read_content_body {
} }
return; return;
} }
sub write_content_body { sub write_content_body {
@_ == 2 || croak(q/Usage: $handle->write_content_body(request)/); @_ == 2 || croak(q/Usage: $handle->write_content_body(request)/);
my ($self, $request) = @_; my ($self, $request) = @_;
my ($len, $content_length) = (0, $request->{headers}{'content-length'}); my ($len, $content_length) = (0, $request->{headers}{'content-length'});
@@ -3940,9 +4011,9 @@ sub write_content_body {
or croak(qq/Content-Length missmatch (got: $len expected: $content_length)/); or croak(qq/Content-Length missmatch (got: $len expected: $content_length)/);
return $len; return $len;
} }
sub read_response_header { sub read_response_header {
@_ == 1 || croak(q/Usage: $handle->read_response_header()/); @_ == 1 || croak(q/Usage: $handle->read_response_header()/);
my ($self) = @_; my ($self) = @_;
@@ -3959,17 +4030,17 @@ sub read_response_header {
headers => $self->read_header_lines, headers => $self->read_header_lines,
protocol => $protocol, protocol => $protocol,
}; };
} }
sub write_request_header { sub write_request_header {
@_ == 4 || croak(q/Usage: $handle->write_request_header(method, request_uri, headers)/); @_ == 4 || croak(q/Usage: $handle->write_request_header(method, request_uri, headers)/);
my ($self, $method, $request_uri, $headers) = @_; my ($self, $method, $request_uri, $headers) = @_;
return $self->write("$method $request_uri HTTP/1.1\x0D\x0A") return $self->write("$method $request_uri HTTP/1.1\x0D\x0A")
+ $self->write_header_lines($headers); + $self->write_header_lines($headers);
} }
sub _do_timeout { sub _do_timeout {
my ($self, $type, $timeout) = @_; my ($self, $type, $timeout) = @_;
$timeout = $self->{timeout} $timeout = $self->{timeout}
unless defined $timeout && $timeout >= 0; unless defined $timeout && $timeout >= 0;
@@ -3998,19 +4069,20 @@ sub _do_timeout {
} }
$! = 0; $! = 0;
return $nfound; return $nfound;
} }
sub can_read { sub can_read {
@_ == 1 || @_ == 2 || croak(q/Usage: $handle->can_read([timeout])/); @_ == 1 || @_ == 2 || croak(q/Usage: $handle->can_read([timeout])/);
my $self = shift; my $self = shift;
return $self->_do_timeout('read', @_) return $self->_do_timeout('read', @_)
} }
sub can_write { sub can_write {
@_ == 1 || @_ == 2 || croak(q/Usage: $handle->can_write([timeout])/); @_ == 1 || @_ == 2 || croak(q/Usage: $handle->can_write([timeout])/);
my $self = shift; my $self = shift;
return $self->_do_timeout('write', @_) return $self->_do_timeout('write', @_)
} }
} # HTTP::Micro::Handle
my $prog = <<'EOP'; my $prog = <<'EOP';
BEGIN { BEGIN {
@@ -4031,6 +4103,7 @@ BEGIN {
} }
} }
{ {
use Carp qw(croak);
my %dispatcher = ( my %dispatcher = (
issuer => sub { Net::SSLeay::X509_NAME_oneline( Net::SSLeay::X509_get_issuer_name( shift )) }, issuer => sub { Net::SSLeay::X509_NAME_oneline( Net::SSLeay::X509_get_issuer_name( shift )) },
subject => sub { Net::SSLeay::X509_NAME_oneline( Net::SSLeay::X509_get_subject_name( shift )) }, subject => sub { Net::SSLeay::X509_NAME_oneline( Net::SSLeay::X509_get_subject_name( shift )) },
@@ -4186,9 +4259,8 @@ if ( $INC{"IO/Socket/SSL.pm"} ) {
} }
1; 1;
}
# ########################################################################### # ###########################################################################
# End HTTPMicro package # End HTTP::Micro package
# ########################################################################### # ###########################################################################
# ########################################################################### # ###########################################################################
@@ -4222,7 +4294,7 @@ use FindBin qw();
eval { eval {
require Percona::Toolkit; require Percona::Toolkit;
require HTTPMicro; require HTTP::Micro;
}; };
{ {
@@ -4453,7 +4525,7 @@ sub pingback {
my $url = $args{url}; my $url = $args{url};
my $instances = $args{instances}; my $instances = $args{instances};
my $ua = $args{ua} || HTTPMicro->new( timeout => 3 ); my $ua = $args{ua} || HTTP::Micro->new( timeout => 3 );
my $response = $ua->request('GET', $url); my $response = $ua->request('GET', $url);
PTDEBUG && _d('Server response:', Dumper($response)); PTDEBUG && _d('Server response:', Dumper($response));
@@ -4832,14 +4904,11 @@ sub main {
# ######################################################################## # ########################################################################
# If --pid, check it first since we'll die if it already exits. # If --pid, check it first since we'll die if it already exits.
# ######################################################################## # ########################################################################
my $daemon; my $daemon = Daemon->new(
if ( $o->get('pid') ) { daemonize => 0,
# We're not daemoninzing, it just handles PID stuff. Keep $daemon pid_file => $o->get('pid'),
# in the the scope of main() because when it's destroyed it automatically );
# removes the PID file. $daemon->run();
$daemon = new Daemon(o=>$o);
$daemon->make_PID_file();
}
# ####################################################################### # #######################################################################
# Connect to MySQL. # Connect to MySQL.
t/pt-duplicate-key-checker/standard_options.t
+9 -4
View File
@@ -18,20 +18,25 @@ require "$trunk/bin/pt-duplicate-key-checker";
my $output; my $output;
my $cnf = "/tmp/12345/my.sandbox.cnf"; my $cnf = "/tmp/12345/my.sandbox.cnf";
my $cmd = "$trunk/bin/pt-duplicate-key-checker -F $cnf -h 127.1"; my $cmd = "$trunk/bin/pt-duplicate-key-checker -F $cnf -h 127.1";
my $pid_file = "/tmp/pt-dupe-key-test.pid";
diag(`rm -f $pid_file >/dev/null`);
# ######################################################################### # #########################################################################
# Issue 391: Add --pid option to all scripts # Issue 391: Add --pid option to all scripts
# ######################################################################### # #########################################################################
`touch /tmp/mk-script.pid`;
$output = `$cmd -d issue_295 --pid /tmp/mk-script.pid 2>&1`; diag(`touch $pid_file`);
$output = `$cmd -d issue_295 --pid $pid_file 2>&1`;
like( like(
$output, $output,
qr{PID file /tmp/mk-script.pid already exists}, qr{PID file $pid_file exists},
'Dies if PID file already exists (issue 391)' 'Dies if PID file already exists (issue 391)'
); );
`rm -rf /tmp/mk-script.pid`;
# ############################################################################# # #############################################################################
# Done. # Done.
# ############################################################################# # #############################################################################
diag(`rm -f $pid_file >/dev/null`);
exit; exit;