percona/percona-toolkit
1
0
Fork 0
mirror of https://github.com/percona/percona-toolkit.git synced 2025-10-19 00:43:58 +00:00
Code Issues Packages Projects Releases Wiki Activity

Removed optional_value, made --version-check have default: off, updated the tools and documentation with the changes, and added the auto value to Pingback.pm

Browse Source
This commit is contained in:
Brian Fraser fraserb@gmail.com
2012-10-30 12:42:42 -03:00
parent d616a7e5e6
commit 6e3d3e6c96
30 changed files with 568 additions and 498 deletions
Download Patch File Download Diff File Expand all files Collapse all files

47
bin/pt-archiver
View File

@@ -86,7 +86,6 @@ sub new {
'default' => 1,
'cumulative' => 1,
'negatable' => 1,
'value_is_optional' => 1,
);
my $self = {
@@ -328,10 +327,9 @@ sub _parse_specs {
$opt->{short} = undef;
}
$opt->{is_negatable} = $opt->{spec} =~ m/!/ ? 1 : 0;
$opt->{is_cumulative} = $opt->{spec} =~ m/\+/ ? 1 : 0;
$opt->{optional_value} = $opt->{spec} =~ m/:/ ? 1 : 0;
$opt->{is_required} = $opt->{desc} =~ m/required/ ? 1 : 0;
$opt->{is_negatable} = $opt->{spec} =~ m/!/ ? 1 : 0;
$opt->{is_cumulative} = $opt->{spec} =~ m/\+/ ? 1 : 0;
$opt->{is_required} = $opt->{desc} =~ m/required/ ? 1 : 0;
$opt->{group} ||= 'default';
$self->{groups}->{ $opt->{group} }->{$long} = 1;
@@ -467,7 +465,7 @@ sub _set_option {
if ( $opt->{is_cumulative} ) {
$opt->{value}++;
}
elsif ( !($opt->{optional_value} && !$val) ) {
else {
$opt->{value} = $val;
}
$opt->{got} = 1;
@@ -1008,12 +1006,11 @@ sub _parse_size {
sub _parse_attribs {
my ( $self, $option, $attribs ) = @_;
my $types = $self->{types};
my $eq = $attribs->{'value_is_optional'} ? ':' : '=';
return $option
. ($attribs->{'short form'} ? '|' . $attribs->{'short form'} : '' )
. ($attribs->{'negatable'} ? '!' : '' )
. ($attribs->{'cumulative'} ? '+' : '' )
. ($attribs->{'type'} ? $eq . $types->{$attribs->{type}} : '' );
. ($attribs->{'type'} ? '=' . $types->{$attribs->{type}} : '' );
}
sub _parse_synopsis {
@@ -4820,17 +4817,27 @@ sub version_check {
return;
}
my $protocol = $args->{protocol} || 'https';
my $advice = pingback(
url => $ENV{PERCONA_VERSION_CHECK_URL} || "$protocol://v.percona.com",
instances => $instances_to_check,
protocol => $args->{protocol},
);
$args->{protocol} ||= 'https';
my @protocols = $args->{protocol} ne 'https' && $args->{protocol} ne 'http'
? qw(https http)
: $args->{protocol};
my $advice;
my $e;
for my $protocol ( @protocols ) {
$advice = eval { pingback(
url => $ENV{PERCONA_VERSION_CHECK_URL} || "$protocol://v.percona.com",
instances => $instances_to_check,
protocol => $protocol,
) };
last if !$advice && !$EVAL_ERROR;
$e ||= $EVAL_ERROR;
}
if ( $advice ) {
print "# Percona suggests these upgrades:\n";
print join("\n", map { "# * $_" } @$advice), "\n\n";
}
else {
die $e if $e;
print "# No suggestions at this time.\n\n";
($ENV{PTVCDEBUG} || PTDEBUG )
&& _d('--version-check worked, but there were no suggestions');
@@ -5613,7 +5620,7 @@ sub main {
# ########################################################################
# Do the version-check
# ########################################################################
if ( $o->got('version-check') && (!$o->has('quiet') || !$o->get('quiet')) ) {
if ( $o->get('version-check') ne 'off' && (!$o->has('quiet') || !$o->get('quiet')) ) {
Pingback::version_check(
{ dbh => $src->{dbh}, dsn => $src->{dsn} },
( $dst ? { dbh => $dst->{dbh}, dsn => $dst->{dsn} } : () ),
@@ -7050,14 +7057,14 @@ Show version and exit.
=item --version-check
type: string; value_is_optional: yes; default: https
type: string; default: off
Send program versions to Percona and print suggested upgrades and problems.
If specified without a value, it will use https by default; However, this
might fail if C<IO::Socket::SSL> is not installed on your system; for the
latter case, you may choose to use C<--version-check http>, which will forgo
encryption but should work out of the box.
Accepted values are https, http, off, and auto -- The latter tries both https
and http, in that order. Keep in mind that 'https' might fail if
C<IO::Socket::SSL> is not installed on your system, although
C<--version-check http> should work everywhere.
The version check feature causes the tool to send and receive data from
Percona over the web. The data contains program versions from the local

47
bin/pt-config-diff
View File

@@ -85,7 +85,6 @@ sub new {
'default' => 1,
'cumulative' => 1,
'negatable' => 1,
'value_is_optional' => 1,
);
my $self = {
@@ -327,10 +326,9 @@ sub _parse_specs {
$opt->{short} = undef;
}
$opt->{is_negatable} = $opt->{spec} =~ m/!/ ? 1 : 0;
$opt->{is_cumulative} = $opt->{spec} =~ m/\+/ ? 1 : 0;
$opt->{optional_value} = $opt->{spec} =~ m/:/ ? 1 : 0;
$opt->{is_required} = $opt->{desc} =~ m/required/ ? 1 : 0;
$opt->{is_negatable} = $opt->{spec} =~ m/!/ ? 1 : 0;
$opt->{is_cumulative} = $opt->{spec} =~ m/\+/ ? 1 : 0;
$opt->{is_required} = $opt->{desc} =~ m/required/ ? 1 : 0;
$opt->{group} ||= 'default';
$self->{groups}->{ $opt->{group} }->{$long} = 1;
@@ -466,7 +464,7 @@ sub _set_option {
if ( $opt->{is_cumulative} ) {
$opt->{value}++;
}
elsif ( !($opt->{optional_value} && !$val) ) {
else {
$opt->{value} = $val;
}
$opt->{got} = 1;
@@ -1007,12 +1005,11 @@ sub _parse_size {
sub _parse_attribs {
my ( $self, $option, $attribs ) = @_;
my $types = $self->{types};
my $eq = $attribs->{'value_is_optional'} ? ':' : '=';
return $option
. ($attribs->{'short form'} ? '|' . $attribs->{'short form'} : '' )
. ($attribs->{'negatable'} ? '!' : '' )
. ($attribs->{'cumulative'} ? '+' : '' )
. ($attribs->{'type'} ? $eq . $types->{$attribs->{type}} : '' );
. ($attribs->{'type'} ? '=' . $types->{$attribs->{type}} : '' );
}
sub _parse_synopsis {
@@ -3968,17 +3965,27 @@ sub version_check {
return;
}
my $protocol = $args->{protocol} || 'https';
my $advice = pingback(
url => $ENV{PERCONA_VERSION_CHECK_URL} || "$protocol://v.percona.com",
instances => $instances_to_check,
protocol => $args->{protocol},
);
$args->{protocol} ||= 'https';
my @protocols = $args->{protocol} ne 'https' && $args->{protocol} ne 'http'
? qw(https http)
: $args->{protocol};
my $advice;
my $e;
for my $protocol ( @protocols ) {
$advice = eval { pingback(
url => $ENV{PERCONA_VERSION_CHECK_URL} || "$protocol://v.percona.com",
instances => $instances_to_check,
protocol => $protocol,
) };
last if !$advice && !$EVAL_ERROR;
$e ||= $EVAL_ERROR;
}
if ( $advice ) {
print "# Percona suggests these upgrades:\n";
print join("\n", map { "# * $_" } @$advice), "\n\n";
}
else {
die $e if $e;
print "# No suggestions at this time.\n\n";
($ENV{PTVCDEBUG} || PTDEBUG )
&& _d('--version-check worked, but there were no suggestions');
@@ -4346,7 +4353,7 @@ sub main {
# ########################################################################
# Do the version-check
# ########################################################################
if ( $o->got('version-check') && (!$o->has('quiet') || !$o->get('quiet')) ) {
if ( $o->get('version-check') ne 'off' && (!$o->has('quiet') || !$o->get('quiet')) ) {
Pingback::version_check(
map({ +{ dbh => $_->dbh, dsn => $_->dsn } } @cxn),
{ protocol => $o->get('version-check') },
@@ -4633,14 +4640,14 @@ Show version and exit.
=item --version-check
type: string; value_is_optional: yes; default: https
type: string; default: off
Send program versions to Percona and print suggested upgrades and problems.
If specified without a value, it will use https by default; However, this
might fail if C<IO::Socket::SSL> is not installed on your system, in which
case you may choose to use C<--version-check http>, which will forgo
encryption but should work out of the box.
Accepted values are https, http, off, and auto -- The latter tries both https
and http, in that order. Keep in mind that 'https' might fail if
C<IO::Socket::SSL> is not installed on your system, although
C<--version-check http> should work everywhere.
The version check feature causes the tool to send and receive data from
Percona over the web. The data contains program versions from the local

47
bin/pt-deadlock-logger
View File

@@ -83,7 +83,6 @@ sub new {
'default' => 1,
'cumulative' => 1,
'negatable' => 1,
'value_is_optional' => 1,
);
my $self = {
@@ -325,10 +324,9 @@ sub _parse_specs {
$opt->{short} = undef;
}
$opt->{is_negatable} = $opt->{spec} =~ m/!/ ? 1 : 0;
$opt->{is_cumulative} = $opt->{spec} =~ m/\+/ ? 1 : 0;
$opt->{optional_value} = $opt->{spec} =~ m/:/ ? 1 : 0;
$opt->{is_required} = $opt->{desc} =~ m/required/ ? 1 : 0;
$opt->{is_negatable} = $opt->{spec} =~ m/!/ ? 1 : 0;
$opt->{is_cumulative} = $opt->{spec} =~ m/\+/ ? 1 : 0;
$opt->{is_required} = $opt->{desc} =~ m/required/ ? 1 : 0;
$opt->{group} ||= 'default';
$self->{groups}->{ $opt->{group} }->{$long} = 1;
@@ -464,7 +462,7 @@ sub _set_option {
if ( $opt->{is_cumulative} ) {
$opt->{value}++;
}
elsif ( !($opt->{optional_value} && !$val) ) {
else {
$opt->{value} = $val;
}
$opt->{got} = 1;
@@ -1005,12 +1003,11 @@ sub _parse_size {
sub _parse_attribs {
my ( $self, $option, $attribs ) = @_;
my $types = $self->{types};
my $eq = $attribs->{'value_is_optional'} ? ':' : '=';
return $option
. ($attribs->{'short form'} ? '|' . $attribs->{'short form'} : '' )
. ($attribs->{'negatable'} ? '!' : '' )
. ($attribs->{'cumulative'} ? '+' : '' )
. ($attribs->{'type'} ? $eq . $types->{$attribs->{type}} : '' );
. ($attribs->{'type'} ? '=' . $types->{$attribs->{type}} : '' );
}
sub _parse_synopsis {
@@ -3412,17 +3409,27 @@ sub version_check {
return;
}
my $protocol = $args->{protocol} || 'https';
my $advice = pingback(
url => $ENV{PERCONA_VERSION_CHECK_URL} || "$protocol://v.percona.com",
instances => $instances_to_check,
protocol => $args->{protocol},
);
$args->{protocol} ||= 'https';
my @protocols = $args->{protocol} ne 'https' && $args->{protocol} ne 'http'
? qw(https http)
: $args->{protocol};
my $advice;
my $e;
for my $protocol ( @protocols ) {
$advice = eval { pingback(
url => $ENV{PERCONA_VERSION_CHECK_URL} || "$protocol://v.percona.com",
instances => $instances_to_check,
protocol => $protocol,
) };
last if !$advice && !$EVAL_ERROR;
$e ||= $EVAL_ERROR;
}
if ( $advice ) {
print "# Percona suggests these upgrades:\n";
print join("\n", map { "# * $_" } @$advice), "\n\n";
}
else {
die $e if $e;
print "# No suggestions at this time.\n\n";
($ENV{PTVCDEBUG} || PTDEBUG )
&& _d('--version-check worked, but there were no suggestions');
@@ -3855,7 +3862,7 @@ sub main {
# ########################################################################
# Do the version-check
# ########################################################################
if ( $o->got('version-check') && (!$o->has('quiet') || !$o->get('quiet')) ) {
if ( $o->get('version-check') ne 'off' && (!$o->has('quiet') || !$o->get('quiet')) ) {
Pingback::version_check(
{ dbh => $dbh, dsn => $source_dsn },
($dest_dsn ? { dbh => $dest_dsn, dsn => $dest_dsn } : ()),
@@ -4547,14 +4554,14 @@ Show version and exit.
=item --version-check
type: string; value_is_optional: yes; default: https
type: string; default: off
Send program versions to Percona and print suggested upgrades and problems.
If specified without a value, it will use https by default; However, this
might fail if C<IO::Socket::SSL> is not installed on your system, in which
case you may choose to use C<--version-check http>, which will forgo
encryption but should work out of the box.
Accepted values are https, http, off, and auto -- The latter tries both https
and http, in that order. Keep in mind that 'https' might fail if
C<IO::Socket::SSL> is not installed on your system, although
C<--version-check http> should work everywhere.
The version check feature causes the tool to send and receive data from
Percona over the web. The data contains program versions from the local

47
bin/pt-diskstats
View File

@@ -85,7 +85,6 @@ sub new {
'default' => 1,
'cumulative' => 1,
'negatable' => 1,
'value_is_optional' => 1,
);
my $self = {
@@ -327,10 +326,9 @@ sub _parse_specs {
$opt->{short} = undef;
}
$opt->{is_negatable} = $opt->{spec} =~ m/!/ ? 1 : 0;
$opt->{is_cumulative} = $opt->{spec} =~ m/\+/ ? 1 : 0;
$opt->{optional_value} = $opt->{spec} =~ m/:/ ? 1 : 0;
$opt->{is_required} = $opt->{desc} =~ m/required/ ? 1 : 0;
$opt->{is_negatable} = $opt->{spec} =~ m/!/ ? 1 : 0;
$opt->{is_cumulative} = $opt->{spec} =~ m/\+/ ? 1 : 0;
$opt->{is_required} = $opt->{desc} =~ m/required/ ? 1 : 0;
$opt->{group} ||= 'default';
$self->{groups}->{ $opt->{group} }->{$long} = 1;
@@ -466,7 +464,7 @@ sub _set_option {
if ( $opt->{is_cumulative} ) {
$opt->{value}++;
}
elsif ( !($opt->{optional_value} && !$val) ) {
else {
$opt->{value} = $val;
}
$opt->{got} = 1;
@@ -1007,12 +1005,11 @@ sub _parse_size {
sub _parse_attribs {
my ( $self, $option, $attribs ) = @_;
my $types = $self->{types};
my $eq = $attribs->{'value_is_optional'} ? ':' : '=';
return $option
. ($attribs->{'short form'} ? '|' . $attribs->{'short form'} : '' )
. ($attribs->{'negatable'} ? '!' : '' )
. ($attribs->{'cumulative'} ? '+' : '' )
. ($attribs->{'type'} ? $eq . $types->{$attribs->{type}} : '' );
. ($attribs->{'type'} ? '=' . $types->{$attribs->{type}} : '' );
}
sub _parse_synopsis {
@@ -4523,17 +4520,27 @@ sub version_check {
return;
}
my $protocol = $args->{protocol} || 'https';
my $advice = pingback(
url => $ENV{PERCONA_VERSION_CHECK_URL} || "$protocol://v.percona.com",
instances => $instances_to_check,
protocol => $args->{protocol},
);
$args->{protocol} ||= 'https';
my @protocols = $args->{protocol} ne 'https' && $args->{protocol} ne 'http'
? qw(https http)
: $args->{protocol};
my $advice;
my $e;
for my $protocol ( @protocols ) {
$advice = eval { pingback(
url => $ENV{PERCONA_VERSION_CHECK_URL} || "$protocol://v.percona.com",
instances => $instances_to_check,
protocol => $protocol,
) };
last if !$advice && !$EVAL_ERROR;
$e ||= $EVAL_ERROR;
}
if ( $advice ) {
print "# Percona suggests these upgrades:\n";
print join("\n", map { "# * $_" } @$advice), "\n\n";
}
else {
die $e if $e;
print "# No suggestions at this time.\n\n";
($ENV{PTVCDEBUG} || PTDEBUG )
&& _d('--version-check worked, but there were no suggestions');
@@ -4835,7 +4842,7 @@ sub main {
# ########################################################################
# Do the version-check
# ########################################################################
if ( $o->got('version-check') && (!$o->has('quiet') || !$o->get('quiet')) ) {
if ( $o->get('version-check') ne 'off' && (!$o->has('quiet') || !$o->get('quiet')) ) {
Pingback::version_check({ protocol => $o->get('version-check') });
}
@@ -5427,14 +5434,14 @@ Show version and exit.
=item --version-check
type: string; value_is_optional: yes; default: https
type: string; default: off
Send program versions to Percona and print suggested upgrades and problems.
If specified without a value, it will use https by default; However, this
might fail if C<IO::Socket::SSL> is not installed on your system, in which
case you may choose to use C<--version-check http>, which will forgo
encryption but should work out of the box.
Accepted values are https, http, off, and auto -- The latter tries both https
and http, in that order. Keep in mind that 'https' might fail if
C<IO::Socket::SSL> is not installed on your system, although
C<--version-check http> should work everywhere.
The version check feature causes the tool to send and receive data from
Percona over the web. The data contains program versions from the local

47
bin/pt-duplicate-key-checker
View File

@@ -987,7 +987,6 @@ sub new {
'default' => 1,
'cumulative' => 1,
'negatable' => 1,
'value_is_optional' => 1,
);
my $self = {
@@ -1229,10 +1228,9 @@ sub _parse_specs {
$opt->{short} = undef;
}
$opt->{is_negatable} = $opt->{spec} =~ m/!/ ? 1 : 0;
$opt->{is_cumulative} = $opt->{spec} =~ m/\+/ ? 1 : 0;
$opt->{optional_value} = $opt->{spec} =~ m/:/ ? 1 : 0;
$opt->{is_required} = $opt->{desc} =~ m/required/ ? 1 : 0;
$opt->{is_negatable} = $opt->{spec} =~ m/!/ ? 1 : 0;
$opt->{is_cumulative} = $opt->{spec} =~ m/\+/ ? 1 : 0;
$opt->{is_required} = $opt->{desc} =~ m/required/ ? 1 : 0;
$opt->{group} ||= 'default';
$self->{groups}->{ $opt->{group} }->{$long} = 1;
@@ -1368,7 +1366,7 @@ sub _set_option {
if ( $opt->{is_cumulative} ) {
$opt->{value}++;
}
elsif ( !($opt->{optional_value} && !$val) ) {
else {
$opt->{value} = $val;
}
$opt->{got} = 1;
@@ -1909,12 +1907,11 @@ sub _parse_size {
sub _parse_attribs {
my ( $self, $option, $attribs ) = @_;
my $types = $self->{types};
my $eq = $attribs->{'value_is_optional'} ? ':' : '=';
return $option
. ($attribs->{'short form'} ? '|' . $attribs->{'short form'} : '' )
. ($attribs->{'negatable'} ? '!' : '' )
. ($attribs->{'cumulative'} ? '+' : '' )
. ($attribs->{'type'} ? $eq . $types->{$attribs->{type}} : '' );
. ($attribs->{'type'} ? '=' . $types->{$attribs->{type}} : '' );
}
sub _parse_synopsis {
@@ -4336,17 +4333,27 @@ sub version_check {
return;
}
my $protocol = $args->{protocol} || 'https';
my $advice = pingback(
url => $ENV{PERCONA_VERSION_CHECK_URL} || "$protocol://v.percona.com",
instances => $instances_to_check,
protocol => $args->{protocol},
);
$args->{protocol} ||= 'https';
my @protocols = $args->{protocol} ne 'https' && $args->{protocol} ne 'http'
? qw(https http)
: $args->{protocol};
my $advice;
my $e;
for my $protocol ( @protocols ) {
$advice = eval { pingback(
url => $ENV{PERCONA_VERSION_CHECK_URL} || "$protocol://v.percona.com",
instances => $instances_to_check,
protocol => $protocol,
) };
last if !$advice && !$EVAL_ERROR;
$e ||= $EVAL_ERROR;
}
if ( $advice ) {
print "# Percona suggests these upgrades:\n";
print join("\n", map { "# * $_" } @$advice), "\n\n";
}
else {
die $e if $e;
print "# No suggestions at this time.\n\n";
($ENV{PTVCDEBUG} || PTDEBUG )
&& _d('--version-check worked, but there were no suggestions');
@@ -4675,7 +4682,7 @@ sub main {
# ########################################################################
# Do the version-check
# ########################################################################
if ( $o->got('version-check') && (!$o->has('quiet') || !$o->get('quiet')) ) {
if ( $o->get('version-check') ne 'off' && (!$o->has('quiet') || !$o->get('quiet')) ) {
Pingback::version_check(
{dbh => $dbh, dsn => $dsn},
{ protocol => $o->get('version-check') },
@@ -5182,14 +5189,14 @@ Show version and exit.
=item --version-check
type: string; value_is_optional: yes; default: https
type: string; default: off
Send program versions to Percona and print suggested upgrades and problems.
If specified without a value, it will use https by default; However, this
might fail if C<IO::Socket::SSL> is not installed on your system, in which
case you may choose to use C<--version-check http>, which will forgo
encryption but should work out of the box.
Accepted values are https, http, off, and auto -- The latter tries both https
and http, in that order. Keep in mind that 'https' might fail if
C<IO::Socket::SSL> is not installed on your system, although
C<--version-check http> should work everywhere.
The version check feature causes the tool to send and receive data from
Percona over the web. The data contains program versions from the local

13
bin/pt-fifo-split
View File

@@ -57,7 +57,6 @@ sub new {
'default' => 1,
'cumulative' => 1,
'negatable' => 1,
'value_is_optional' => 1,
);
my $self = {
@@ -299,10 +298,9 @@ sub _parse_specs {
$opt->{short} = undef;
}
$opt->{is_negatable} = $opt->{spec} =~ m/!/ ? 1 : 0;
$opt->{is_cumulative} = $opt->{spec} =~ m/\+/ ? 1 : 0;
$opt->{optional_value} = $opt->{spec} =~ m/:/ ? 1 : 0;
$opt->{is_required} = $opt->{desc} =~ m/required/ ? 1 : 0;
$opt->{is_negatable} = $opt->{spec} =~ m/!/ ? 1 : 0;
$opt->{is_cumulative} = $opt->{spec} =~ m/\+/ ? 1 : 0;
$opt->{is_required} = $opt->{desc} =~ m/required/ ? 1 : 0;
$opt->{group} ||= 'default';
$self->{groups}->{ $opt->{group} }->{$long} = 1;
@@ -438,7 +436,7 @@ sub _set_option {
if ( $opt->{is_cumulative} ) {
$opt->{value}++;
}
elsif ( !($opt->{optional_value} && !$val) ) {
else {
$opt->{value} = $val;
}
$opt->{got} = 1;
@@ -979,12 +977,11 @@ sub _parse_size {
sub _parse_attribs {
my ( $self, $option, $attribs ) = @_;
my $types = $self->{types};
my $eq = $attribs->{'value_is_optional'} ? ':' : '=';
return $option
. ($attribs->{'short form'} ? '|' . $attribs->{'short form'} : '' )
. ($attribs->{'negatable'} ? '!' : '' )
. ($attribs->{'cumulative'} ? '+' : '' )
. ($attribs->{'type'} ? $eq . $types->{$attribs->{type}} : '' );
. ($attribs->{'type'} ? '=' . $types->{$attribs->{type}} : '' );
}
sub _parse_synopsis {

47
bin/pt-find
View File

@@ -455,7 +455,6 @@ sub new {
'default' => 1,
'cumulative' => 1,
'negatable' => 1,
'value_is_optional' => 1,
);
my $self = {
@@ -697,10 +696,9 @@ sub _parse_specs {
$opt->{short} = undef;
}
$opt->{is_negatable} = $opt->{spec} =~ m/!/ ? 1 : 0;
$opt->{is_cumulative} = $opt->{spec} =~ m/\+/ ? 1 : 0;
$opt->{optional_value} = $opt->{spec} =~ m/:/ ? 1 : 0;
$opt->{is_required} = $opt->{desc} =~ m/required/ ? 1 : 0;
$opt->{is_negatable} = $opt->{spec} =~ m/!/ ? 1 : 0;
$opt->{is_cumulative} = $opt->{spec} =~ m/\+/ ? 1 : 0;
$opt->{is_required} = $opt->{desc} =~ m/required/ ? 1 : 0;
$opt->{group} ||= 'default';
$self->{groups}->{ $opt->{group} }->{$long} = 1;
@@ -836,7 +834,7 @@ sub _set_option {
if ( $opt->{is_cumulative} ) {
$opt->{value}++;
}
elsif ( !($opt->{optional_value} && !$val) ) {
else {
$opt->{value} = $val;
}
$opt->{got} = 1;
@@ -1377,12 +1375,11 @@ sub _parse_size {
sub _parse_attribs {
my ( $self, $option, $attribs ) = @_;
my $types = $self->{types};
my $eq = $attribs->{'value_is_optional'} ? ':' : '=';
return $option
. ($attribs->{'short form'} ? '|' . $attribs->{'short form'} : '' )
. ($attribs->{'negatable'} ? '!' : '' )
. ($attribs->{'cumulative'} ? '+' : '' )
. ($attribs->{'type'} ? $eq . $types->{$attribs->{type}} : '' );
. ($attribs->{'type'} ? '=' . $types->{$attribs->{type}} : '' );
}
sub _parse_synopsis {
@@ -3176,17 +3173,27 @@ sub version_check {
return;
}
my $protocol = $args->{protocol} || 'https';
my $advice = pingback(
url => $ENV{PERCONA_VERSION_CHECK_URL} || "$protocol://v.percona.com",
instances => $instances_to_check,
protocol => $args->{protocol},
);
$args->{protocol} ||= 'https';
my @protocols = $args->{protocol} ne 'https' && $args->{protocol} ne 'http'
? qw(https http)
: $args->{protocol};
my $advice;
my $e;
for my $protocol ( @protocols ) {
$advice = eval { pingback(
url => $ENV{PERCONA_VERSION_CHECK_URL} || "$protocol://v.percona.com",
instances => $instances_to_check,
protocol => $protocol,
) };
last if !$advice && !$EVAL_ERROR;
$e ||= $EVAL_ERROR;
}
if ( $advice ) {
print "# Percona suggests these upgrades:\n";
print join("\n", map { "# * $_" } @$advice), "\n\n";
}
else {
die $e if $e;
print "# No suggestions at this time.\n\n";
($ENV{PTVCDEBUG} || PTDEBUG )
&& _d('--version-check worked, but there were no suggestions');
@@ -3843,7 +3850,7 @@ sub main {
# ########################################################################
# Do the version-check
# ########################################################################
if ( $o->got('version-check') && (!$o->has('quiet') || !$o->get('quiet')) ) {
if ( $o->get('version-check') ne 'off' && (!$o->has('quiet') || !$o->get('quiet')) ) {
Pingback::version_check(
{dbh => $dbh, dsn => $dsn},
{protocol => $o->get('version-check')},
@@ -4300,14 +4307,14 @@ Show version and exit.
=item --version-check
type: string; value_is_optional: yes; default: https
type: string; default: off
Send program versions to Percona and print suggested upgrades and problems.
If specified without a value, it will use https by default; However, this
might fail if C<IO::Socket::SSL> is not installed on your system, in which
case you may choose to use C<--version-check http>, which will forgo
encryption but should work out of the box.
Accepted values are https, http, off, and auto -- The latter tries both https
and http, in that order. Keep in mind that 'https' might fail if
C<IO::Socket::SSL> is not installed on your system, although
C<--version-check http> should work everywhere.
The version check feature causes the tool to send and receive data from
Percona over the web. The data contains program versions from the local

13
bin/pt-fingerprint
View File

@@ -58,7 +58,6 @@ sub new {
'default' => 1,
'cumulative' => 1,
'negatable' => 1,
'value_is_optional' => 1,
);
my $self = {
@@ -300,10 +299,9 @@ sub _parse_specs {
$opt->{short} = undef;
}
$opt->{is_negatable} = $opt->{spec} =~ m/!/ ? 1 : 0;
$opt->{is_cumulative} = $opt->{spec} =~ m/\+/ ? 1 : 0;
$opt->{optional_value} = $opt->{spec} =~ m/:/ ? 1 : 0;
$opt->{is_required} = $opt->{desc} =~ m/required/ ? 1 : 0;
$opt->{is_negatable} = $opt->{spec} =~ m/!/ ? 1 : 0;
$opt->{is_cumulative} = $opt->{spec} =~ m/\+/ ? 1 : 0;
$opt->{is_required} = $opt->{desc} =~ m/required/ ? 1 : 0;
$opt->{group} ||= 'default';
$self->{groups}->{ $opt->{group} }->{$long} = 1;
@@ -439,7 +437,7 @@ sub _set_option {
if ( $opt->{is_cumulative} ) {
$opt->{value}++;
}
elsif ( !($opt->{optional_value} && !$val) ) {
else {
$opt->{value} = $val;
}
$opt->{got} = 1;
@@ -980,12 +978,11 @@ sub _parse_size {
sub _parse_attribs {
my ( $self, $option, $attribs ) = @_;
my $types = $self->{types};
my $eq = $attribs->{'value_is_optional'} ? ':' : '=';
return $option
. ($attribs->{'short form'} ? '|' . $attribs->{'short form'} : '' )
. ($attribs->{'negatable'} ? '!' : '' )
. ($attribs->{'cumulative'} ? '+' : '' )
. ($attribs->{'type'} ? $eq . $types->{$attribs->{type}} : '' );
. ($attribs->{'type'} ? '=' . $types->{$attribs->{type}} : '' );
}
sub _parse_synopsis {

47
bin/pt-fk-error-logger
View File

@@ -82,7 +82,6 @@ sub new {
'default' => 1,
'cumulative' => 1,
'negatable' => 1,
'value_is_optional' => 1,
);
my $self = {
@@ -324,10 +323,9 @@ sub _parse_specs {
$opt->{short} = undef;
}
$opt->{is_negatable} = $opt->{spec} =~ m/!/ ? 1 : 0;
$opt->{is_cumulative} = $opt->{spec} =~ m/\+/ ? 1 : 0;
$opt->{optional_value} = $opt->{spec} =~ m/:/ ? 1 : 0;
$opt->{is_required} = $opt->{desc} =~ m/required/ ? 1 : 0;
$opt->{is_negatable} = $opt->{spec} =~ m/!/ ? 1 : 0;
$opt->{is_cumulative} = $opt->{spec} =~ m/\+/ ? 1 : 0;
$opt->{is_required} = $opt->{desc} =~ m/required/ ? 1 : 0;
$opt->{group} ||= 'default';
$self->{groups}->{ $opt->{group} }->{$long} = 1;
@@ -463,7 +461,7 @@ sub _set_option {
if ( $opt->{is_cumulative} ) {
$opt->{value}++;
}
elsif ( !($opt->{optional_value} && !$val) ) {
else {
$opt->{value} = $val;
}
$opt->{got} = 1;
@@ -1004,12 +1002,11 @@ sub _parse_size {
sub _parse_attribs {
my ( $self, $option, $attribs ) = @_;
my $types = $self->{types};
my $eq = $attribs->{'value_is_optional'} ? ':' : '=';
return $option
. ($attribs->{'short form'} ? '|' . $attribs->{'short form'} : '' )
. ($attribs->{'negatable'} ? '!' : '' )
. ($attribs->{'cumulative'} ? '+' : '' )
. ($attribs->{'type'} ? $eq . $types->{$attribs->{type}} : '' );
. ($attribs->{'type'} ? '=' . $types->{$attribs->{type}} : '' );
}
sub _parse_synopsis {
@@ -3116,17 +3113,27 @@ sub version_check {
return;
}
my $protocol = $args->{protocol} || 'https';
my $advice = pingback(
url => $ENV{PERCONA_VERSION_CHECK_URL} || "$protocol://v.percona.com",
instances => $instances_to_check,
protocol => $args->{protocol},
);
$args->{protocol} ||= 'https';
my @protocols = $args->{protocol} ne 'https' && $args->{protocol} ne 'http'
? qw(https http)
: $args->{protocol};
my $advice;
my $e;
for my $protocol ( @protocols ) {
$advice = eval { pingback(
url => $ENV{PERCONA_VERSION_CHECK_URL} || "$protocol://v.percona.com",
instances => $instances_to_check,
protocol => $protocol,
) };
last if !$advice && !$EVAL_ERROR;
$e ||= $EVAL_ERROR;
}
if ( $advice ) {
print "# Percona suggests these upgrades:\n";
print join("\n", map { "# * $_" } @$advice), "\n\n";
}
else {
die $e if $e;
print "# No suggestions at this time.\n\n";
($ENV{PTVCDEBUG} || PTDEBUG )
&& _d('--version-check worked, but there were no suggestions');
@@ -3500,7 +3507,7 @@ sub main {
# ########################################################################
# Do the version-check
# ########################################################################
if ( $o->got('version-check') && (!$o->has('quiet') || !$o->get('quiet')) ) {
if ( $o->get('version-check') ne 'off' && (!$o->has('quiet') || !$o->get('quiet')) ) {
Pingback::version_check(
{ dbh => $dbh, dsn => $src_dsn },
($dst_dbh ? { dbh => $dst_dbh, dsn => $dst_dsn } : ()),
@@ -3794,14 +3801,14 @@ Show version and exit.
=item --version-check
type: string; value_is_optional: yes; default: https
type: string; default: off
Send program versions to Percona and print suggested upgrades and problems.
If specified without a value, it will use https by default; However, this
might fail if C<IO::Socket::SSL> is not installed on your system, in which
case you may choose to use C<--version-check http>, which will forgo
encryption but should work out of the box.
Accepted values are https, http, off, and auto -- The latter tries both https
and http, in that order. Keep in mind that 'https' might fail if
C<IO::Socket::SSL> is not installed on your system, although
C<--version-check http> should work everywhere.
The version check feature causes the tool to send and receive data from
Percona over the web. The data contains program versions from the local

47
bin/pt-heartbeat
View File

@@ -818,7 +818,6 @@ sub new {
'default' => 1,
'cumulative' => 1,
'negatable' => 1,
'value_is_optional' => 1,
);
my $self = {
@@ -1060,10 +1059,9 @@ sub _parse_specs {
$opt->{short} = undef;
}
$opt->{is_negatable} = $opt->{spec} =~ m/!/ ? 1 : 0;
$opt->{is_cumulative} = $opt->{spec} =~ m/\+/ ? 1 : 0;
$opt->{optional_value} = $opt->{spec} =~ m/:/ ? 1 : 0;
$opt->{is_required} = $opt->{desc} =~ m/required/ ? 1 : 0;
$opt->{is_negatable} = $opt->{spec} =~ m/!/ ? 1 : 0;
$opt->{is_cumulative} = $opt->{spec} =~ m/\+/ ? 1 : 0;
$opt->{is_required} = $opt->{desc} =~ m/required/ ? 1 : 0;
$opt->{group} ||= 'default';
$self->{groups}->{ $opt->{group} }->{$long} = 1;
@@ -1199,7 +1197,7 @@ sub _set_option {
if ( $opt->{is_cumulative} ) {
$opt->{value}++;
}
elsif ( !($opt->{optional_value} && !$val) ) {
else {
$opt->{value} = $val;
}
$opt->{got} = 1;
@@ -1740,12 +1738,11 @@ sub _parse_size {
sub _parse_attribs {
my ( $self, $option, $attribs ) = @_;
my $types = $self->{types};
my $eq = $attribs->{'value_is_optional'} ? ':' : '=';
return $option
. ($attribs->{'short form'} ? '|' . $attribs->{'short form'} : '' )
. ($attribs->{'negatable'} ? '!' : '' )
. ($attribs->{'cumulative'} ? '+' : '' )
. ($attribs->{'type'} ? $eq . $types->{$attribs->{type}} : '' );
. ($attribs->{'type'} ? '=' . $types->{$attribs->{type}} : '' );
}
sub _parse_synopsis {
@@ -4260,17 +4257,27 @@ sub version_check {
return;
}
my $protocol = $args->{protocol} || 'https';
my $advice = pingback(
url => $ENV{PERCONA_VERSION_CHECK_URL} || "$protocol://v.percona.com",
instances => $instances_to_check,
protocol => $args->{protocol},
);
$args->{protocol} ||= 'https';
my @protocols = $args->{protocol} ne 'https' && $args->{protocol} ne 'http'
? qw(https http)
: $args->{protocol};
my $advice;
my $e;
for my $protocol ( @protocols ) {
$advice = eval { pingback(
url => $ENV{PERCONA_VERSION_CHECK_URL} || "$protocol://v.percona.com",
instances => $instances_to_check,
protocol => $protocol,
) };
last if !$advice && !$EVAL_ERROR;
$e ||= $EVAL_ERROR;
}
if ( $advice ) {
print "# Percona suggests these upgrades:\n";
print join("\n", map { "# * $_" } @$advice), "\n\n";
}
else {
die $e if $e;
print "# No suggestions at this time.\n\n";
($ENV{PTVCDEBUG} || PTDEBUG )
&& _d('--version-check worked, but there were no suggestions');
@@ -4963,7 +4970,7 @@ sub main {
# ########################################################################
# Do the version-check
# ########################################################################
if ( $o->got('version-check') && (!$o->has('quiet') || !$o->get('quiet')) ) {
if ( $o->get('version-check') ne 'off' && (!$o->has('quiet') || !$o->get('quiet')) ) {
Pingback::version_check({dbh => $dbh, dsn => $dsn}, { protocol => $o->get('version-check') });
}
@@ -5696,14 +5703,14 @@ Show version and exit.
=item --version-check
type: string; value_is_optional: yes; default: https
type: string; default: off
Send program versions to Percona and print suggested upgrades and problems.
If specified without a value, it will use https by default; However, this
might fail if C<IO::Socket::SSL> is not installed on your system, in which
case you may choose to use C<--version-check http>, which will forgo
encryption but should work out of the box.
Accepted values are https, http, off, and auto -- The latter tries both https
and http, in that order. Keep in mind that 'https' might fail if
C<IO::Socket::SSL> is not installed on your system, although
C<--version-check http> should work everywhere.
The version check feature causes the tool to send and receive data from
Percona over the web. The data contains program versions from the local

47
bin/pt-index-usage
View File

@@ -585,7 +585,6 @@ sub new {
'default' => 1,
'cumulative' => 1,
'negatable' => 1,
'value_is_optional' => 1,
);
my $self = {
@@ -827,10 +826,9 @@ sub _parse_specs {
$opt->{short} = undef;
}
$opt->{is_negatable} = $opt->{spec} =~ m/!/ ? 1 : 0;
$opt->{is_cumulative} = $opt->{spec} =~ m/\+/ ? 1 : 0;
$opt->{optional_value} = $opt->{spec} =~ m/:/ ? 1 : 0;
$opt->{is_required} = $opt->{desc} =~ m/required/ ? 1 : 0;
$opt->{is_negatable} = $opt->{spec} =~ m/!/ ? 1 : 0;
$opt->{is_cumulative} = $opt->{spec} =~ m/\+/ ? 1 : 0;
$opt->{is_required} = $opt->{desc} =~ m/required/ ? 1 : 0;
$opt->{group} ||= 'default';
$self->{groups}->{ $opt->{group} }->{$long} = 1;
@@ -966,7 +964,7 @@ sub _set_option {
if ( $opt->{is_cumulative} ) {
$opt->{value}++;
}
elsif ( !($opt->{optional_value} && !$val) ) {
else {
$opt->{value} = $val;
}
$opt->{got} = 1;
@@ -1507,12 +1505,11 @@ sub _parse_size {
sub _parse_attribs {
my ( $self, $option, $attribs ) = @_;
my $types = $self->{types};
my $eq = $attribs->{'value_is_optional'} ? ':' : '=';
return $option
. ($attribs->{'short form'} ? '|' . $attribs->{'short form'} : '' )
. ($attribs->{'negatable'} ? '!' : '' )
. ($attribs->{'cumulative'} ? '+' : '' )
. ($attribs->{'type'} ? $eq . $types->{$attribs->{type}} : '' );
. ($attribs->{'type'} ? '=' . $types->{$attribs->{type}} : '' );
}
sub _parse_synopsis {
@@ -5842,17 +5839,27 @@ sub version_check {
return;
}
my $protocol = $args->{protocol} || 'https';
my $advice = pingback(
url => $ENV{PERCONA_VERSION_CHECK_URL} || "$protocol://v.percona.com",
instances => $instances_to_check,
protocol => $args->{protocol},
);
$args->{protocol} ||= 'https';
my @protocols = $args->{protocol} ne 'https' && $args->{protocol} ne 'http'
? qw(https http)
: $args->{protocol};
my $advice;
my $e;
for my $protocol ( @protocols ) {
$advice = eval { pingback(
url => $ENV{PERCONA_VERSION_CHECK_URL} || "$protocol://v.percona.com",
instances => $instances_to_check,
protocol => $protocol,
) };
last if !$advice && !$EVAL_ERROR;
$e ||= $EVAL_ERROR;
}
if ( $advice ) {
print "# Percona suggests these upgrades:\n";
print join("\n", map { "# * $_" } @$advice), "\n\n";
}
else {
die $e if $e;
print "# No suggestions at this time.\n\n";
($ENV{PTVCDEBUG} || PTDEBUG )
&& _d('--version-check worked, but there were no suggestions');
@@ -6306,7 +6313,7 @@ sub main {
# ########################################################################
# Do the version-check
# ########################################################################
if ( $o->got('version-check') && (!$o->has('quiet') || !$o->get('quiet')) ) {
if ( $o->get('version-check') ne 'off' && (!$o->has('quiet') || !$o->get('quiet')) ) {
Pingback::version_check(
{ dbh => $dbh, dsn => $dsn },
($res_dbh ? { dbh => $res_dbh, dsn => $res_dsn } : ()),
@@ -7225,14 +7232,14 @@ Show version and exit.
=item --version-check
type: string; value_is_optional: yes; default: https
type: string; default: off
Send program versions to Percona and print suggested upgrades and problems.
If specified without a value, it will use https by default; However, this
might fail if C<IO::Socket::SSL> is not installed on your system, in which
case you may choose to use C<--version-check http>, which will forgo
encryption but should work out of the box.
Accepted values are https, http, off, and auto -- The latter tries both https
and http, in that order. Keep in mind that 'https' might fail if
C<IO::Socket::SSL> is not installed on your system, although
C<--version-check http> should work everywhere.
The version check feature causes the tool to send and receive data from
Percona over the web. The data contains program versions from the local

47
bin/pt-kill
View File

@@ -90,7 +90,6 @@ sub new {
'default' => 1,
'cumulative' => 1,
'negatable' => 1,
'value_is_optional' => 1,
);
my $self = {
@@ -332,10 +331,9 @@ sub _parse_specs {
$opt->{short} = undef;
}
$opt->{is_negatable} = $opt->{spec} =~ m/!/ ? 1 : 0;
$opt->{is_cumulative} = $opt->{spec} =~ m/\+/ ? 1 : 0;
$opt->{optional_value} = $opt->{spec} =~ m/:/ ? 1 : 0;
$opt->{is_required} = $opt->{desc} =~ m/required/ ? 1 : 0;
$opt->{is_negatable} = $opt->{spec} =~ m/!/ ? 1 : 0;
$opt->{is_cumulative} = $opt->{spec} =~ m/\+/ ? 1 : 0;
$opt->{is_required} = $opt->{desc} =~ m/required/ ? 1 : 0;
$opt->{group} ||= 'default';
$self->{groups}->{ $opt->{group} }->{$long} = 1;
@@ -471,7 +469,7 @@ sub _set_option {
if ( $opt->{is_cumulative} ) {
$opt->{value}++;
}
elsif ( !($opt->{optional_value} && !$val) ) {
else {
$opt->{value} = $val;
}
$opt->{got} = 1;
@@ -1012,12 +1010,11 @@ sub _parse_size {
sub _parse_attribs {
my ( $self, $option, $attribs ) = @_;
my $types = $self->{types};
my $eq = $attribs->{'value_is_optional'} ? ':' : '=';
return $option
. ($attribs->{'short form'} ? '|' . $attribs->{'short form'} : '' )
. ($attribs->{'negatable'} ? '!' : '' )
. ($attribs->{'cumulative'} ? '+' : '' )
. ($attribs->{'type'} ? $eq . $types->{$attribs->{type}} : '' );
. ($attribs->{'type'} ? '=' . $types->{$attribs->{type}} : '' );
}
sub _parse_synopsis {
@@ -5851,17 +5848,27 @@ sub version_check {
return;
}
my $protocol = $args->{protocol} || 'https';
my $advice = pingback(
url => $ENV{PERCONA_VERSION_CHECK_URL} || "$protocol://v.percona.com",
instances => $instances_to_check,
protocol => $args->{protocol},
);
$args->{protocol} ||= 'https';
my @protocols = $args->{protocol} ne 'https' && $args->{protocol} ne 'http'
? qw(https http)
: $args->{protocol};
my $advice;
my $e;
for my $protocol ( @protocols ) {
$advice = eval { pingback(
url => $ENV{PERCONA_VERSION_CHECK_URL} || "$protocol://v.percona.com",
instances => $instances_to_check,
protocol => $protocol,
) };
last if !$advice && !$EVAL_ERROR;
$e ||= $EVAL_ERROR;
}
if ( $advice ) {
print "# Percona suggests these upgrades:\n";
print join("\n", map { "# * $_" } @$advice), "\n\n";
}
else {
die $e if $e;
print "# No suggestions at this time.\n\n";
($ENV{PTVCDEBUG} || PTDEBUG )
&& _d('--version-check worked, but there were no suggestions');
@@ -6466,7 +6473,7 @@ sub main {
# ########################################################################
# Do the version-check
# ########################################################################
if ( $o->got('version-check') && (!$o->has('quiet') || !$o->get('quiet')) ) {
if ( $o->get('version-check') ne 'off' && (!$o->has('quiet') || !$o->get('quiet')) ) {
Pingback::version_check(
($dbh ? { dbh => $dbh, dsn => $cxn->dsn() } : ()),
{ protocol => $o->get('version-check') },
@@ -7200,14 +7207,14 @@ Show version and exit.
=item --version-check
type: string; value_is_optional: yes; default: https
type: string; default: off
Send program versions to Percona and print suggested upgrades and problems.
If specified without a value, it will use https by default; However, this
might fail if C<IO::Socket::SSL> is not installed on your system, in which
case you may choose to use C<--version-check http>, which will forgo
encryption but should work out of the box.
Accepted values are https, http, off, and auto -- The latter tries both https
and http, in that order. Keep in mind that 'https' might fail if
C<IO::Socket::SSL> is not installed on your system, although
C<--version-check http> should work everywhere.
The version check feature causes the tool to send and receive data from
Percona over the web. The data contains program versions from the local

13
bin/pt-log-player
View File

@@ -62,7 +62,6 @@ sub new {
'default' => 1,
'cumulative' => 1,
'negatable' => 1,
'value_is_optional' => 1,
);
my $self = {
@@ -304,10 +303,9 @@ sub _parse_specs {
$opt->{short} = undef;
}
$opt->{is_negatable} = $opt->{spec} =~ m/!/ ? 1 : 0;
$opt->{is_cumulative} = $opt->{spec} =~ m/\+/ ? 1 : 0;
$opt->{optional_value} = $opt->{spec} =~ m/:/ ? 1 : 0;
$opt->{is_required} = $opt->{desc} =~ m/required/ ? 1 : 0;
$opt->{is_negatable} = $opt->{spec} =~ m/!/ ? 1 : 0;
$opt->{is_cumulative} = $opt->{spec} =~ m/\+/ ? 1 : 0;
$opt->{is_required} = $opt->{desc} =~ m/required/ ? 1 : 0;
$opt->{group} ||= 'default';
$self->{groups}->{ $opt->{group} }->{$long} = 1;
@@ -443,7 +441,7 @@ sub _set_option {
if ( $opt->{is_cumulative} ) {
$opt->{value}++;
}
elsif ( !($opt->{optional_value} && !$val) ) {
else {
$opt->{value} = $val;
}
$opt->{got} = 1;
@@ -984,12 +982,11 @@ sub _parse_size {
sub _parse_attribs {
my ( $self, $option, $attribs ) = @_;
my $types = $self->{types};
my $eq = $attribs->{'value_is_optional'} ? ':' : '=';
return $option
. ($attribs->{'short form'} ? '|' . $attribs->{'short form'} : '' )
. ($attribs->{'negatable'} ? '!' : '' )
. ($attribs->{'cumulative'} ? '+' : '' )
. ($attribs->{'type'} ? $eq . $types->{$attribs->{type}} : '' );
. ($attribs->{'type'} ? '=' . $types->{$attribs->{type}} : '' );
}
sub _parse_synopsis {

47
bin/pt-online-schema-change
View File

@@ -96,7 +96,6 @@ sub new {
'default' => 1,
'cumulative' => 1,
'negatable' => 1,
'value_is_optional' => 1,
);
my $self = {
@@ -338,10 +337,9 @@ sub _parse_specs {
$opt->{short} = undef;
}
$opt->{is_negatable} = $opt->{spec} =~ m/!/ ? 1 : 0;
$opt->{is_cumulative} = $opt->{spec} =~ m/\+/ ? 1 : 0;
$opt->{optional_value} = $opt->{spec} =~ m/:/ ? 1 : 0;
$opt->{is_required} = $opt->{desc} =~ m/required/ ? 1 : 0;
$opt->{is_negatable} = $opt->{spec} =~ m/!/ ? 1 : 0;
$opt->{is_cumulative} = $opt->{spec} =~ m/\+/ ? 1 : 0;
$opt->{is_required} = $opt->{desc} =~ m/required/ ? 1 : 0;
$opt->{group} ||= 'default';
$self->{groups}->{ $opt->{group} }->{$long} = 1;
@@ -477,7 +475,7 @@ sub _set_option {
if ( $opt->{is_cumulative} ) {
$opt->{value}++;
}
elsif ( !($opt->{optional_value} && !$val) ) {
else {
$opt->{value} = $val;
}
$opt->{got} = 1;
@@ -1018,12 +1016,11 @@ sub _parse_size {
sub _parse_attribs {
my ( $self, $option, $attribs ) = @_;
my $types = $self->{types};
my $eq = $attribs->{'value_is_optional'} ? ':' : '=';
return $option
. ($attribs->{'short form'} ? '|' . $attribs->{'short form'} : '' )
. ($attribs->{'negatable'} ? '!' : '' )
. ($attribs->{'cumulative'} ? '+' : '' )
. ($attribs->{'type'} ? $eq . $types->{$attribs->{type}} : '' );
. ($attribs->{'type'} ? '=' . $types->{$attribs->{type}} : '' );
}
sub _parse_synopsis {
@@ -6873,17 +6870,27 @@ sub version_check {
return;
}
my $protocol = $args->{protocol} || 'https';
my $advice = pingback(
url => $ENV{PERCONA_VERSION_CHECK_URL} || "$protocol://v.percona.com",
instances => $instances_to_check,
protocol => $args->{protocol},
);
$args->{protocol} ||= 'https';
my @protocols = $args->{protocol} ne 'https' && $args->{protocol} ne 'http'
? qw(https http)
: $args->{protocol};
my $advice;
my $e;
for my $protocol ( @protocols ) {
$advice = eval { pingback(
url => $ENV{PERCONA_VERSION_CHECK_URL} || "$protocol://v.percona.com",
instances => $instances_to_check,
protocol => $protocol,
) };
last if !$advice && !$EVAL_ERROR;
$e ||= $EVAL_ERROR;
}
if ( $advice ) {
print "# Percona suggests these upgrades:\n";
print join("\n", map { "# * $_" } @$advice), "\n\n";
}
else {
die $e if $e;
print "# No suggestions at this time.\n\n";
($ENV{PTVCDEBUG} || PTDEBUG )
&& _d('--version-check worked, but there were no suggestions');
@@ -7527,7 +7534,7 @@ sub main {
# ########################################################################
# Do the version-check
# ########################################################################
if ( $o->got('version-check') && (!$o->has('quiet') || !$o->get('quiet')) ) {
if ( $o->get('version-check') ne 'off' && (!$o->has('quiet') || !$o->get('quiet')) ) {
Pingback::version_check(
map({ +{ dbh => $_->dbh(), dsn => $_->dsn() } }
$cxn, ($slaves ? @$slaves : ())),
@@ -9863,14 +9870,14 @@ Show version and exit.
=item --version-check
type: string; value_is_optional: yes; default: https
type: string; default: off
Send program versions to Percona and print suggested upgrades and problems.
If specified without a value, it will use https by default; However, this
might fail if C<IO::Socket::SSL> is not installed on your system, in which
case you may choose to use C<--version-check http>, which will forgo
encryption but should work out of the box.
Accepted values are https, http, off, and auto -- The latter tries both https
and http, in that order. Keep in mind that 'https' might fail if
C<IO::Socket::SSL> is not installed on your system, although
C<--version-check http> should work everywhere.
The version check feature causes the tool to send and receive data from
Percona over the web. The data contains program versions from the local

47
bin/pt-query-advisor
View File

@@ -466,7 +466,6 @@ sub new {
'default' => 1,
'cumulative' => 1,
'negatable' => 1,
'value_is_optional' => 1,
);
my $self = {
@@ -708,10 +707,9 @@ sub _parse_specs {
$opt->{short} = undef;
}
$opt->{is_negatable} = $opt->{spec} =~ m/!/ ? 1 : 0;
$opt->{is_cumulative} = $opt->{spec} =~ m/\+/ ? 1 : 0;
$opt->{optional_value} = $opt->{spec} =~ m/:/ ? 1 : 0;
$opt->{is_required} = $opt->{desc} =~ m/required/ ? 1 : 0;
$opt->{is_negatable} = $opt->{spec} =~ m/!/ ? 1 : 0;
$opt->{is_cumulative} = $opt->{spec} =~ m/\+/ ? 1 : 0;
$opt->{is_required} = $opt->{desc} =~ m/required/ ? 1 : 0;
$opt->{group} ||= 'default';
$self->{groups}->{ $opt->{group} }->{$long} = 1;
@@ -847,7 +845,7 @@ sub _set_option {
if ( $opt->{is_cumulative} ) {
$opt->{value}++;
}
elsif ( !($opt->{optional_value} && !$val) ) {
else {
$opt->{value} = $val;
}
$opt->{got} = 1;
@@ -1388,12 +1386,11 @@ sub _parse_size {
sub _parse_attribs {
my ( $self, $option, $attribs ) = @_;
my $types = $self->{types};
my $eq = $attribs->{'value_is_optional'} ? ':' : '=';
return $option
. ($attribs->{'short form'} ? '|' . $attribs->{'short form'} : '' )
. ($attribs->{'negatable'} ? '!' : '' )
. ($attribs->{'cumulative'} ? '+' : '' )
. ($attribs->{'type'} ? $eq . $types->{$attribs->{type}} : '' );
. ($attribs->{'type'} ? '=' . $types->{$attribs->{type}} : '' );
}
sub _parse_synopsis {
@@ -7027,17 +7024,27 @@ sub version_check {
return;
}
my $protocol = $args->{protocol} || 'https';
my $advice = pingback(
url => $ENV{PERCONA_VERSION_CHECK_URL} || "$protocol://v.percona.com",
instances => $instances_to_check,
protocol => $args->{protocol},
);
$args->{protocol} ||= 'https';
my @protocols = $args->{protocol} ne 'https' && $args->{protocol} ne 'http'
? qw(https http)
: $args->{protocol};
my $advice;
my $e;
for my $protocol ( @protocols ) {
$advice = eval { pingback(
url => $ENV{PERCONA_VERSION_CHECK_URL} || "$protocol://v.percona.com",
instances => $instances_to_check,
protocol => $protocol,
) };
last if !$advice && !$EVAL_ERROR;
$e ||= $EVAL_ERROR;
}
if ( $advice ) {
print "# Percona suggests these upgrades:\n";
print join("\n", map { "# * $_" } @$advice), "\n\n";
}
else {
die $e if $e;
print "# No suggestions at this time.\n\n";
($ENV{PTVCDEBUG} || PTDEBUG )
&& _d('--version-check worked, but there were no suggestions');
@@ -7685,7 +7692,7 @@ sub main {
# ########################################################################
# Do the version-check
# ########################################################################
if ( $o->got('version-check') && (!$o->has('quiet') || !$o->get('quiet')) ) {
if ( $o->get('version-check') ne 'off' && (!$o->has('quiet') || !$o->get('quiet')) ) {
Pingback::version_check(
($review_dbh ? { dbh => $review_dbh, dsn => $review_dsn } : ()),
($dbh ? { dbh => $dbh, dsn => $dsn } : ()),
@@ -8462,14 +8469,14 @@ Show version and exit.
=item --version-check
type: string; value_is_optional: yes; default: https
type: string; default: off
Send program versions to Percona and print suggested upgrades and problems.
If specified without a value, it will use https by default; However, this
might fail if C<IO::Socket::SSL> is not installed on your system, in which
case you may choose to use C<--version-check http>, which will forgo
encryption but should work out of the box.
Accepted values are https, http, off, and auto -- The latter tries both https
and http, in that order. Keep in mind that 'https' might fail if
C<IO::Socket::SSL> is not installed on your system, although
C<--version-check http> should work everywhere.
The version check feature causes the tool to send and receive data from
Percona over the web. The data contains program versions from the local

47
bin/pt-query-digest
View File

@@ -604,7 +604,6 @@ sub new {
'default' => 1,
'cumulative' => 1,
'negatable' => 1,
'value_is_optional' => 1,
);
my $self = {
@@ -846,10 +845,9 @@ sub _parse_specs {
$opt->{short} = undef;
}
$opt->{is_negatable} = $opt->{spec} =~ m/!/ ? 1 : 0;
$opt->{is_cumulative} = $opt->{spec} =~ m/\+/ ? 1 : 0;
$opt->{optional_value} = $opt->{spec} =~ m/:/ ? 1 : 0;
$opt->{is_required} = $opt->{desc} =~ m/required/ ? 1 : 0;
$opt->{is_negatable} = $opt->{spec} =~ m/!/ ? 1 : 0;
$opt->{is_cumulative} = $opt->{spec} =~ m/\+/ ? 1 : 0;
$opt->{is_required} = $opt->{desc} =~ m/required/ ? 1 : 0;
$opt->{group} ||= 'default';
$self->{groups}->{ $opt->{group} }->{$long} = 1;
@@ -985,7 +983,7 @@ sub _set_option {
if ( $opt->{is_cumulative} ) {
$opt->{value}++;
}
elsif ( !($opt->{optional_value} && !$val) ) {
else {
$opt->{value} = $val;
}
$opt->{got} = 1;
@@ -1526,12 +1524,11 @@ sub _parse_size {
sub _parse_attribs {
my ( $self, $option, $attribs ) = @_;
my $types = $self->{types};
my $eq = $attribs->{'value_is_optional'} ? ':' : '=';
return $option
. ($attribs->{'short form'} ? '|' . $attribs->{'short form'} : '' )
. ($attribs->{'negatable'} ? '!' : '' )
. ($attribs->{'cumulative'} ? '+' : '' )
. ($attribs->{'type'} ? $eq . $types->{$attribs->{type}} : '' );
. ($attribs->{'type'} ? '=' . $types->{$attribs->{type}} : '' );
}
sub _parse_synopsis {
@@ -12957,17 +12954,27 @@ sub version_check {
return;
}
my $protocol = $args->{protocol} || 'https';
my $advice = pingback(
url => $ENV{PERCONA_VERSION_CHECK_URL} || "$protocol://v.percona.com",
instances => $instances_to_check,
protocol => $args->{protocol},
);
$args->{protocol} ||= 'https';
my @protocols = $args->{protocol} ne 'https' && $args->{protocol} ne 'http'
? qw(https http)
: $args->{protocol};
my $advice;
my $e;
for my $protocol ( @protocols ) {
$advice = eval { pingback(
url => $ENV{PERCONA_VERSION_CHECK_URL} || "$protocol://v.percona.com",
instances => $instances_to_check,
protocol => $protocol,
) };
last if !$advice && !$EVAL_ERROR;
$e ||= $EVAL_ERROR;
}
if ( $advice ) {
print "# Percona suggests these upgrades:\n";
print join("\n", map { "# * $_" } @$advice), "\n\n";
}
else {
die $e if $e;
print "# No suggestions at this time.\n\n";
($ENV{PTVCDEBUG} || PTDEBUG )
&& _d('--version-check worked, but there were no suggestions');
@@ -14566,7 +14573,7 @@ sub main {
# ########################################################################
# Do the version-check
# ########################################################################
if ( $o->got('version-check') && (!$o->has('quiet') || !$o->get('quiet')) ) {
if ( $o->get('version-check') ne 'off' && (!$o->has('quiet') || !$o->get('quiet')) ) {
Pingback::version_check(
($qv_dbh ? { dbh => $qv_dbh, dsn => $review_dsn } : ()),
($ps_dbh ? { dbh => $ps_dbh, dsn => $ps_dsn } : ()),
@@ -16957,14 +16964,14 @@ Show version and exit.
=item --version-check
type: string; value_is_optional: yes; default: https
type: string; default: off
Send program versions to Percona and print suggested upgrades and problems.
If specified without a value, it will use https by default; However, this
might fail if C<IO::Socket::SSL> is not installed on your system, in which
case you may choose to use C<--version-check http>, which will forgo
encryption but should work out of the box.
Accepted values are https, http, off, and auto -- The latter tries both https
and http, in that order. Keep in mind that 'https' might fail if
C<IO::Socket::SSL> is not installed on your system, although
C<--version-check http> should work everywhere.
The version check feature causes the tool to send and receive data from
Percona over the web. The data contains program versions from the local

13
bin/pt-show-grants
View File

@@ -58,7 +58,6 @@ sub new {
'default' => 1,
'cumulative' => 1,
'negatable' => 1,
'value_is_optional' => 1,
);
my $self = {
@@ -300,10 +299,9 @@ sub _parse_specs {
$opt->{short} = undef;
}
$opt->{is_negatable} = $opt->{spec} =~ m/!/ ? 1 : 0;
$opt->{is_cumulative} = $opt->{spec} =~ m/\+/ ? 1 : 0;
$opt->{optional_value} = $opt->{spec} =~ m/:/ ? 1 : 0;
$opt->{is_required} = $opt->{desc} =~ m/required/ ? 1 : 0;
$opt->{is_negatable} = $opt->{spec} =~ m/!/ ? 1 : 0;
$opt->{is_cumulative} = $opt->{spec} =~ m/\+/ ? 1 : 0;
$opt->{is_required} = $opt->{desc} =~ m/required/ ? 1 : 0;
$opt->{group} ||= 'default';
$self->{groups}->{ $opt->{group} }->{$long} = 1;
@@ -439,7 +437,7 @@ sub _set_option {
if ( $opt->{is_cumulative} ) {
$opt->{value}++;
}
elsif ( !($opt->{optional_value} && !$val) ) {
else {
$opt->{value} = $val;
}
$opt->{got} = 1;
@@ -980,12 +978,11 @@ sub _parse_size {
sub _parse_attribs {
my ( $self, $option, $attribs ) = @_;
my $types = $self->{types};
my $eq = $attribs->{'value_is_optional'} ? ':' : '=';
return $option
. ($attribs->{'short form'} ? '|' . $attribs->{'short form'} : '' )
. ($attribs->{'negatable'} ? '!' : '' )
. ($attribs->{'cumulative'} ? '+' : '' )
. ($attribs->{'type'} ? $eq . $types->{$attribs->{type}} : '' );
. ($attribs->{'type'} ? '=' . $types->{$attribs->{type}} : '' );
}
sub _parse_synopsis {

47
bin/pt-slave-delay
View File

@@ -83,7 +83,6 @@ sub new {
'default' => 1,
'cumulative' => 1,
'negatable' => 1,
'value_is_optional' => 1,
);
my $self = {
@@ -325,10 +324,9 @@ sub _parse_specs {
$opt->{short} = undef;
}
$opt->{is_negatable} = $opt->{spec} =~ m/!/ ? 1 : 0;
$opt->{is_cumulative} = $opt->{spec} =~ m/\+/ ? 1 : 0;
$opt->{optional_value} = $opt->{spec} =~ m/:/ ? 1 : 0;
$opt->{is_required} = $opt->{desc} =~ m/required/ ? 1 : 0;
$opt->{is_negatable} = $opt->{spec} =~ m/!/ ? 1 : 0;
$opt->{is_cumulative} = $opt->{spec} =~ m/\+/ ? 1 : 0;
$opt->{is_required} = $opt->{desc} =~ m/required/ ? 1 : 0;
$opt->{group} ||= 'default';
$self->{groups}->{ $opt->{group} }->{$long} = 1;
@@ -464,7 +462,7 @@ sub _set_option {
if ( $opt->{is_cumulative} ) {
$opt->{value}++;
}
elsif ( !($opt->{optional_value} && !$val) ) {
else {
$opt->{value} = $val;
}
$opt->{got} = 1;
@@ -1005,12 +1003,11 @@ sub _parse_size {
sub _parse_attribs {
my ( $self, $option, $attribs ) = @_;
my $types = $self->{types};
my $eq = $attribs->{'value_is_optional'} ? ':' : '=';
return $option
. ($attribs->{'short form'} ? '|' . $attribs->{'short form'} : '' )
. ($attribs->{'negatable'} ? '!' : '' )
. ($attribs->{'cumulative'} ? '+' : '' )
. ($attribs->{'type'} ? $eq . $types->{$attribs->{type}} : '' );
. ($attribs->{'type'} ? '=' . $types->{$attribs->{type}} : '' );
}
sub _parse_synopsis {
@@ -3525,17 +3522,27 @@ sub version_check {
return;
}
my $protocol = $args->{protocol} || 'https';
my $advice = pingback(
url => $ENV{PERCONA_VERSION_CHECK_URL} || "$protocol://v.percona.com",
instances => $instances_to_check,
protocol => $args->{protocol},
);
$args->{protocol} ||= 'https';
my @protocols = $args->{protocol} ne 'https' && $args->{protocol} ne 'http'
? qw(https http)
: $args->{protocol};
my $advice;
my $e;
for my $protocol ( @protocols ) {
$advice = eval { pingback(
url => $ENV{PERCONA_VERSION_CHECK_URL} || "$protocol://v.percona.com",
instances => $instances_to_check,
protocol => $protocol,
) };
last if !$advice && !$EVAL_ERROR;
$e ||= $EVAL_ERROR;
}
if ( $advice ) {
print "# Percona suggests these upgrades:\n";
print join("\n", map { "# * $_" } @$advice), "\n\n";
}
else {
die $e if $e;
print "# No suggestions at this time.\n\n";
($ENV{PTVCDEBUG} || PTDEBUG )
&& _d('--version-check worked, but there were no suggestions');
@@ -3893,7 +3900,7 @@ sub main {
# ########################################################################
# Do the version-check
# ########################################################################
if ( $o->got('version-check') && (!$o->has('quiet') || !$o->get('quiet')) ) {
if ( $o->get('version-check') ne 'off' && (!$o->has('quiet') || !$o->get('quiet')) ) {
my $tmp_master_dsn = $master_dsn
? $master_dsn
: { h => $status->{master_host}, P => $status->{master_port} };
@@ -4377,14 +4384,14 @@ Show version and exit.
=item --version-check
type: string; value_is_optional: yes; default: https
type: string; default: off
Send program versions to Percona and print suggested upgrades and problems.
If specified without a value, it will use https by default; However, this
might fail if C<IO::Socket::SSL> is not installed on your system, in which
case you may choose to use C<--version-check http>, which will forgo
encryption but should work out of the box.
Accepted values are https, http, off, and auto -- The latter tries both https
and http, in that order. Keep in mind that 'https' might fail if
C<IO::Socket::SSL> is not installed on your system, although
C<--version-check http> should work everywhere.
The version check feature causes the tool to send and receive data from
Percona over the web. The data contains program versions from the local

13
bin/pt-slave-find
View File

@@ -62,7 +62,6 @@ sub new {
'default' => 1,
'cumulative' => 1,
'negatable' => 1,
'value_is_optional' => 1,
);
my $self = {
@@ -304,10 +303,9 @@ sub _parse_specs {
$opt->{short} = undef;
}
$opt->{is_negatable} = $opt->{spec} =~ m/!/ ? 1 : 0;
$opt->{is_cumulative} = $opt->{spec} =~ m/\+/ ? 1 : 0;
$opt->{optional_value} = $opt->{spec} =~ m/:/ ? 1 : 0;
$opt->{is_required} = $opt->{desc} =~ m/required/ ? 1 : 0;
$opt->{is_negatable} = $opt->{spec} =~ m/!/ ? 1 : 0;
$opt->{is_cumulative} = $opt->{spec} =~ m/\+/ ? 1 : 0;
$opt->{is_required} = $opt->{desc} =~ m/required/ ? 1 : 0;
$opt->{group} ||= 'default';
$self->{groups}->{ $opt->{group} }->{$long} = 1;
@@ -443,7 +441,7 @@ sub _set_option {
if ( $opt->{is_cumulative} ) {
$opt->{value}++;
}
elsif ( !($opt->{optional_value} && !$val) ) {
else {
$opt->{value} = $val;
}
$opt->{got} = 1;
@@ -984,12 +982,11 @@ sub _parse_size {
sub _parse_attribs {
my ( $self, $option, $attribs ) = @_;
my $types = $self->{types};
my $eq = $attribs->{'value_is_optional'} ? ':' : '=';
return $option
. ($attribs->{'short form'} ? '|' . $attribs->{'short form'} : '' )
. ($attribs->{'negatable'} ? '!' : '' )
. ($attribs->{'cumulative'} ? '+' : '' )
. ($attribs->{'type'} ? $eq . $types->{$attribs->{type}} : '' );
. ($attribs->{'type'} ? '=' . $types->{$attribs->{type}} : '' );
}
sub _parse_synopsis {

47
bin/pt-slave-restart
View File

@@ -204,7 +204,6 @@ sub new {
'default' => 1,
'cumulative' => 1,
'negatable' => 1,
'value_is_optional' => 1,
);
my $self = {
@@ -446,10 +445,9 @@ sub _parse_specs {
$opt->{short} = undef;
}
$opt->{is_negatable} = $opt->{spec} =~ m/!/ ? 1 : 0;
$opt->{is_cumulative} = $opt->{spec} =~ m/\+/ ? 1 : 0;
$opt->{optional_value} = $opt->{spec} =~ m/:/ ? 1 : 0;
$opt->{is_required} = $opt->{desc} =~ m/required/ ? 1 : 0;
$opt->{is_negatable} = $opt->{spec} =~ m/!/ ? 1 : 0;
$opt->{is_cumulative} = $opt->{spec} =~ m/\+/ ? 1 : 0;
$opt->{is_required} = $opt->{desc} =~ m/required/ ? 1 : 0;
$opt->{group} ||= 'default';
$self->{groups}->{ $opt->{group} }->{$long} = 1;
@@ -585,7 +583,7 @@ sub _set_option {
if ( $opt->{is_cumulative} ) {
$opt->{value}++;
}
elsif ( !($opt->{optional_value} && !$val) ) {
else {
$opt->{value} = $val;
}
$opt->{got} = 1;
@@ -1126,12 +1124,11 @@ sub _parse_size {
sub _parse_attribs {
my ( $self, $option, $attribs ) = @_;
my $types = $self->{types};
my $eq = $attribs->{'value_is_optional'} ? ':' : '=';
return $option
. ($attribs->{'short form'} ? '|' . $attribs->{'short form'} : '' )
. ($attribs->{'negatable'} ? '!' : '' )
. ($attribs->{'cumulative'} ? '+' : '' )
. ($attribs->{'type'} ? $eq . $types->{$attribs->{type}} : '' );
. ($attribs->{'type'} ? '=' . $types->{$attribs->{type}} : '' );
}
sub _parse_synopsis {
@@ -4148,17 +4145,27 @@ sub version_check {
return;
}
my $protocol = $args->{protocol} || 'https';
my $advice = pingback(
url => $ENV{PERCONA_VERSION_CHECK_URL} || "$protocol://v.percona.com",
instances => $instances_to_check,
protocol => $args->{protocol},
);
$args->{protocol} ||= 'https';
my @protocols = $args->{protocol} ne 'https' && $args->{protocol} ne 'http'
? qw(https http)
: $args->{protocol};
my $advice;
my $e;
for my $protocol ( @protocols ) {
$advice = eval { pingback(
url => $ENV{PERCONA_VERSION_CHECK_URL} || "$protocol://v.percona.com",
instances => $instances_to_check,
protocol => $protocol,
) };
last if !$advice && !$EVAL_ERROR;
$e ||= $EVAL_ERROR;
}
if ( $advice ) {
print "# Percona suggests these upgrades:\n";
print join("\n", map { "# * $_" } @$advice), "\n\n";
}
else {
die $e if $e;
print "# No suggestions at this time.\n\n";
($ENV{PTVCDEBUG} || PTDEBUG )
&& _d('--version-check worked, but there were no suggestions');
@@ -4579,7 +4586,7 @@ sub main {
# ########################################################################
# Do the version-check
# ########################################################################
if ( $o->got('version-check') && (!$o->has('quiet') || !$o->get('quiet')) ) {
if ( $o->get('version-check') ne 'off' && (!$o->has('quiet') || !$o->get('quiet')) ) {
Pingback::version_check(
{ dbh => $dbh, dsn => $dsn }, @servers_to_watch,
{ protocol => $o->get('version-check') },
@@ -5296,14 +5303,14 @@ Show version and exit.
=item --version-check
type: string; value_is_optional: yes; default: https
type: string; default: off
Send program versions to Percona and print suggested upgrades and problems.
If specified without a value, it will use https by default; However, this
might fail if C<IO::Socket::SSL> is not installed on your system, in which
case you may choose to use C<--version-check http>, which will forgo
encryption but should work out of the box.
Accepted values are https, http, off, and auto -- The latter tries both https
and http, in that order. Keep in mind that 'https' might fail if
C<IO::Socket::SSL> is not installed on your system, although
C<--version-check http> should work everywhere.
The version check feature causes the tool to send and receive data from
Percona over the web. The data contains program versions from the local

47
bin/pt-table-checksum
View File

@@ -1074,17 +1074,27 @@ sub version_check {
return;
}
my $protocol = $args->{protocol} || 'https';
my $advice = pingback(
url => $ENV{PERCONA_VERSION_CHECK_URL} || "$protocol://v.percona.com",
instances => $instances_to_check,
protocol => $args->{protocol},
);
$args->{protocol} ||= 'https';
my @protocols = $args->{protocol} ne 'https' && $args->{protocol} ne 'http'
? qw(https http)
: $args->{protocol};
my $advice;
my $e;
for my $protocol ( @protocols ) {
$advice = eval { pingback(
url => $ENV{PERCONA_VERSION_CHECK_URL} || "$protocol://v.percona.com",
instances => $instances_to_check,
protocol => $protocol,
) };
last if !$advice && !$EVAL_ERROR;
$e ||= $EVAL_ERROR;
}
if ( $advice ) {
print "# Percona suggests these upgrades:\n";
print join("\n", map { "# * $_" } @$advice), "\n\n";
}
else {
die $e if $e;
print "# No suggestions at this time.\n\n";
($ENV{PTVCDEBUG} || PTDEBUG )
&& _d('--version-check worked, but there were no suggestions');
@@ -1752,7 +1762,6 @@ sub new {
'default' => 1,
'cumulative' => 1,
'negatable' => 1,
'value_is_optional' => 1,
);
my $self = {
@@ -1994,10 +2003,9 @@ sub _parse_specs {
$opt->{short} = undef;
}
$opt->{is_negatable} = $opt->{spec} =~ m/!/ ? 1 : 0;
$opt->{is_cumulative} = $opt->{spec} =~ m/\+/ ? 1 : 0;
$opt->{optional_value} = $opt->{spec} =~ m/:/ ? 1 : 0;
$opt->{is_required} = $opt->{desc} =~ m/required/ ? 1 : 0;
$opt->{is_negatable} = $opt->{spec} =~ m/!/ ? 1 : 0;
$opt->{is_cumulative} = $opt->{spec} =~ m/\+/ ? 1 : 0;
$opt->{is_required} = $opt->{desc} =~ m/required/ ? 1 : 0;
$opt->{group} ||= 'default';
$self->{groups}->{ $opt->{group} }->{$long} = 1;
@@ -2133,7 +2141,7 @@ sub _set_option {
if ( $opt->{is_cumulative} ) {
$opt->{value}++;
}
elsif ( !($opt->{optional_value} && !$val) ) {
else {
$opt->{value} = $val;
}
$opt->{got} = 1;
@@ -2674,12 +2682,11 @@ sub _parse_size {
sub _parse_attribs {
my ( $self, $option, $attribs ) = @_;
my $types = $self->{types};
my $eq = $attribs->{'value_is_optional'} ? ':' : '=';
return $option
. ($attribs->{'short form'} ? '|' . $attribs->{'short form'} : '' )
. ($attribs->{'negatable'} ? '!' : '' )
. ($attribs->{'cumulative'} ? '+' : '' )
. ($attribs->{'type'} ? $eq . $types->{$attribs->{type}} : '' );
. ($attribs->{'type'} ? '=' . $types->{$attribs->{type}} : '' );
}
sub _parse_synopsis {
@@ -8805,7 +8812,7 @@ sub main {
# ########################################################################
# Do the version-check
# ########################################################################
if ( $o->got('version-check') && (!$o->has('quiet') || !$o->get('quiet')) ) {
if ( $o->get('version-check') ne 'off' && (!$o->has('quiet') || !$o->get('quiet')) ) {
Pingback::version_check(
{ dbh => $master_dbh, dsn => $master_dsn },
map({ +{ dbh => $_->dbh(), dsn => $_->dsn() } } @$slaves),
@@ -11147,14 +11154,14 @@ Show version and exit.
=item --version-check
type: string; value_is_optional: yes; default: https
type: string; default: off
Send program versions to Percona and print suggested upgrades and problems.
If specified without a value, it will use https by default; However, this
might fail if C<IO::Socket::SSL> is not installed on your system, in which
case you may choose to use C<--version-check http>, which will forgo
encryption but should work out of the box.
Accepted values are https, http, off, and auto -- The latter tries both https
and http, in that order. Keep in mind that 'https' might fail if
C<IO::Socket::SSL> is not installed on your system, although
C<--version-check http> should work everywhere.
The version check feature causes the tool to send and receive data from
Percona over the web. The data contains program versions from the local

12
bin/pt-table-sync
View File

@@ -9765,7 +9765,7 @@ sub main {
+{ dbh => $dbh, dsn => $dsn }
} @dsns;
if ( $o->got('version-check') && (!$o->has('quiet') || !$o->get('quiet')) ) {
if ( $o->get('version-check') ne 'off' && (!$o->has('quiet') || !$o->get('quiet')) ) {
Pingback::version_check(@instances, { protocol => $o->get('version-check') });
}
@@ -12278,14 +12278,14 @@ Show version and exit.
=item --version-check
type: string; value_is_optional: yes; default: https
type: string; default: off
Send program versions to Percona and print suggested upgrades and problems.
If specified without a value, it will use https by default; However, this
might fail if C<IO::Socket::SSL> is not installed on your system, in which
case you may choose to use C<--version-check http>, which will forgo
encryption but should work out of the box.
Accepted values are https, http, off, and auto -- The latter tries both https
and http, in that order. Keep in mind that 'https' might fail if
C<IO::Socket::SSL> is not installed on your system, although
C<--version-check http> should work everywhere.
The version check feature causes the tool to send and receive data from
Percona over the web. The data contains program versions from the local

13
bin/pt-tcp-model
View File

@@ -61,7 +61,6 @@ sub new {
'default' => 1,
'cumulative' => 1,
'negatable' => 1,
'value_is_optional' => 1,
);
my $self = {
@@ -303,10 +302,9 @@ sub _parse_specs {
$opt->{short} = undef;
}
$opt->{is_negatable} = $opt->{spec} =~ m/!/ ? 1 : 0;
$opt->{is_cumulative} = $opt->{spec} =~ m/\+/ ? 1 : 0;
$opt->{optional_value} = $opt->{spec} =~ m/:/ ? 1 : 0;
$opt->{is_required} = $opt->{desc} =~ m/required/ ? 1 : 0;
$opt->{is_negatable} = $opt->{spec} =~ m/!/ ? 1 : 0;
$opt->{is_cumulative} = $opt->{spec} =~ m/\+/ ? 1 : 0;
$opt->{is_required} = $opt->{desc} =~ m/required/ ? 1 : 0;
$opt->{group} ||= 'default';
$self->{groups}->{ $opt->{group} }->{$long} = 1;
@@ -442,7 +440,7 @@ sub _set_option {
if ( $opt->{is_cumulative} ) {
$opt->{value}++;
}
elsif ( !($opt->{optional_value} && !$val) ) {
else {
$opt->{value} = $val;
}
$opt->{got} = 1;
@@ -983,12 +981,11 @@ sub _parse_size {
sub _parse_attribs {
my ( $self, $option, $attribs ) = @_;
my $types = $self->{types};
my $eq = $attribs->{'value_is_optional'} ? ':' : '=';
return $option
. ($attribs->{'short form'} ? '|' . $attribs->{'short form'} : '' )
. ($attribs->{'negatable'} ? '!' : '' )
. ($attribs->{'cumulative'} ? '+' : '' )
. ($attribs->{'type'} ? $eq . $types->{$attribs->{type}} : '' );
. ($attribs->{'type'} ? '=' . $types->{$attribs->{type}} : '' );
}
sub _parse_synopsis {

13
bin/pt-trend
View File

@@ -61,7 +61,6 @@ sub new {
'default' => 1,
'cumulative' => 1,
'negatable' => 1,
'value_is_optional' => 1,
);
my $self = {
@@ -303,10 +302,9 @@ sub _parse_specs {
$opt->{short} = undef;
}
$opt->{is_negatable} = $opt->{spec} =~ m/!/ ? 1 : 0;
$opt->{is_cumulative} = $opt->{spec} =~ m/\+/ ? 1 : 0;
$opt->{optional_value} = $opt->{spec} =~ m/:/ ? 1 : 0;
$opt->{is_required} = $opt->{desc} =~ m/required/ ? 1 : 0;
$opt->{is_negatable} = $opt->{spec} =~ m/!/ ? 1 : 0;
$opt->{is_cumulative} = $opt->{spec} =~ m/\+/ ? 1 : 0;
$opt->{is_required} = $opt->{desc} =~ m/required/ ? 1 : 0;
$opt->{group} ||= 'default';
$self->{groups}->{ $opt->{group} }->{$long} = 1;
@@ -442,7 +440,7 @@ sub _set_option {
if ( $opt->{is_cumulative} ) {
$opt->{value}++;
}
elsif ( !($opt->{optional_value} && !$val) ) {
else {
$opt->{value} = $val;
}
$opt->{got} = 1;
@@ -983,12 +981,11 @@ sub _parse_size {
sub _parse_attribs {
my ( $self, $option, $attribs ) = @_;
my $types = $self->{types};
my $eq = $attribs->{'value_is_optional'} ? ':' : '=';
return $option
. ($attribs->{'short form'} ? '|' . $attribs->{'short form'} : '' )
. ($attribs->{'negatable'} ? '!' : '' )
. ($attribs->{'cumulative'} ? '+' : '' )
. ($attribs->{'type'} ? $eq . $types->{$attribs->{type}} : '' );
. ($attribs->{'type'} ? '=' . $types->{$attribs->{type}} : '' );
}
sub _parse_synopsis {

47
bin/pt-upgrade
View File

@@ -1006,7 +1006,6 @@ sub new {
'default' => 1,
'cumulative' => 1,
'negatable' => 1,
'value_is_optional' => 1,
);
my $self = {
@@ -1248,10 +1247,9 @@ sub _parse_specs {
$opt->{short} = undef;
}
$opt->{is_negatable} = $opt->{spec} =~ m/!/ ? 1 : 0;
$opt->{is_cumulative} = $opt->{spec} =~ m/\+/ ? 1 : 0;
$opt->{optional_value} = $opt->{spec} =~ m/:/ ? 1 : 0;
$opt->{is_required} = $opt->{desc} =~ m/required/ ? 1 : 0;
$opt->{is_negatable} = $opt->{spec} =~ m/!/ ? 1 : 0;
$opt->{is_cumulative} = $opt->{spec} =~ m/\+/ ? 1 : 0;
$opt->{is_required} = $opt->{desc} =~ m/required/ ? 1 : 0;
$opt->{group} ||= 'default';
$self->{groups}->{ $opt->{group} }->{$long} = 1;
@@ -1387,7 +1385,7 @@ sub _set_option {
if ( $opt->{is_cumulative} ) {
$opt->{value}++;
}
elsif ( !($opt->{optional_value} && !$val) ) {
else {
$opt->{value} = $val;
}
$opt->{got} = 1;
@@ -1928,12 +1926,11 @@ sub _parse_size {
sub _parse_attribs {
my ( $self, $option, $attribs ) = @_;
my $types = $self->{types};
my $eq = $attribs->{'value_is_optional'} ? ':' : '=';
return $option
. ($attribs->{'short form'} ? '|' . $attribs->{'short form'} : '' )
. ($attribs->{'negatable'} ? '!' : '' )
. ($attribs->{'cumulative'} ? '+' : '' )
. ($attribs->{'type'} ? $eq . $types->{$attribs->{type}} : '' );
. ($attribs->{'type'} ? '=' . $types->{$attribs->{type}} : '' );
}
sub _parse_synopsis {
@@ -11324,17 +11321,27 @@ sub version_check {
return;
}
my $protocol = $args->{protocol} || 'https';
my $advice = pingback(
url => $ENV{PERCONA_VERSION_CHECK_URL} || "$protocol://v.percona.com",
instances => $instances_to_check,
protocol => $args->{protocol},
);
$args->{protocol} ||= 'https';
my @protocols = $args->{protocol} ne 'https' && $args->{protocol} ne 'http'
? qw(https http)
: $args->{protocol};
my $advice;
my $e;
for my $protocol ( @protocols ) {
$advice = eval { pingback(
url => $ENV{PERCONA_VERSION_CHECK_URL} || "$protocol://v.percona.com",
instances => $instances_to_check,
protocol => $protocol,
) };
last if !$advice && !$EVAL_ERROR;
$e ||= $EVAL_ERROR;
}
if ( $advice ) {
print "# Percona suggests these upgrades:\n";
print join("\n", map { "# * $_" } @$advice), "\n\n";
}
else {
die $e if $e;
print "# No suggestions at this time.\n\n";
($ENV{PTVCDEBUG} || PTDEBUG )
&& _d('--version-check worked, but there were no suggestions');
@@ -11930,7 +11937,7 @@ sub main {
# ########################################################################
# Do the version-check
# ########################################################################
if ( $o->got('version-check') && (!$o->has('quiet') || !$o->get('quiet')) ) {
if ( $o->get('version-check') ne 'off' && (!$o->has('quiet') || !$o->get('quiet')) ) {
Pingback::version_check(
map({ +{ dbh => $_->{dbh}, dsn => $_->{dsn} } } @$hosts),
{ protocol => $o->get('version-check') },
@@ -12867,14 +12874,14 @@ Show version and exit.
=item --version-check
type: string; value_is_optional: yes; default: https
type: string; default: off
Send program versions to Percona and print suggested upgrades and problems.
If specified without a value, it will use https by default; However, this
might fail if C<IO::Socket::SSL> is not installed on your system, in which
case you may choose to use C<--version-check http>, which will forgo
encryption but should work out of the box.
Accepted values are https, http, off, and auto -- The latter tries both https
and http, in that order. Keep in mind that 'https' might fail if
C<IO::Socket::SSL> is not installed on your system, although
C<--version-check http> should work everywhere.
The version check feature causes the tool to send and receive data from
Percona over the web. The data contains program versions from the local

47
bin/pt-variable-advisor
View File

@@ -87,7 +87,6 @@ sub new {
'default' => 1,
'cumulative' => 1,
'negatable' => 1,
'value_is_optional' => 1,
);
my $self = {
@@ -329,10 +328,9 @@ sub _parse_specs {
$opt->{short} = undef;
}
$opt->{is_negatable} = $opt->{spec} =~ m/!/ ? 1 : 0;
$opt->{is_cumulative} = $opt->{spec} =~ m/\+/ ? 1 : 0;
$opt->{optional_value} = $opt->{spec} =~ m/:/ ? 1 : 0;
$opt->{is_required} = $opt->{desc} =~ m/required/ ? 1 : 0;
$opt->{is_negatable} = $opt->{spec} =~ m/!/ ? 1 : 0;
$opt->{is_cumulative} = $opt->{spec} =~ m/\+/ ? 1 : 0;
$opt->{is_required} = $opt->{desc} =~ m/required/ ? 1 : 0;
$opt->{group} ||= 'default';
$self->{groups}->{ $opt->{group} }->{$long} = 1;
@@ -468,7 +466,7 @@ sub _set_option {
if ( $opt->{is_cumulative} ) {
$opt->{value}++;
}
elsif ( !($opt->{optional_value} && !$val) ) {
else {
$opt->{value} = $val;
}
$opt->{got} = 1;
@@ -1009,12 +1007,11 @@ sub _parse_size {
sub _parse_attribs {
my ( $self, $option, $attribs ) = @_;
my $types = $self->{types};
my $eq = $attribs->{'value_is_optional'} ? ':' : '=';
return $option
. ($attribs->{'short form'} ? '|' . $attribs->{'short form'} : '' )
. ($attribs->{'negatable'} ? '!' : '' )
. ($attribs->{'cumulative'} ? '+' : '' )
. ($attribs->{'type'} ? $eq . $types->{$attribs->{type}} : '' );
. ($attribs->{'type'} ? '=' . $types->{$attribs->{type}} : '' );
}
sub _parse_synopsis {
@@ -4437,17 +4434,27 @@ sub version_check {
return;
}
my $protocol = $args->{protocol} || 'https';
my $advice = pingback(
url => $ENV{PERCONA_VERSION_CHECK_URL} || "$protocol://v.percona.com",
instances => $instances_to_check,
protocol => $args->{protocol},
);
$args->{protocol} ||= 'https';
my @protocols = $args->{protocol} ne 'https' && $args->{protocol} ne 'http'
? qw(https http)
: $args->{protocol};
my $advice;
my $e;
for my $protocol ( @protocols ) {
$advice = eval { pingback(
url => $ENV{PERCONA_VERSION_CHECK_URL} || "$protocol://v.percona.com",
instances => $instances_to_check,
protocol => $protocol,
) };
last if !$advice && !$EVAL_ERROR;
$e ||= $EVAL_ERROR;
}
if ( $advice ) {
print "# Percona suggests these upgrades:\n";
print join("\n", map { "# * $_" } @$advice), "\n\n";
}
else {
die $e if $e;
print "# No suggestions at this time.\n\n";
($ENV{PTVCDEBUG} || PTDEBUG )
&& _d('--version-check worked, but there were no suggestions');
@@ -4819,7 +4826,7 @@ sub main {
# ########################################################################
# Do the version-check
# ########################################################################
if ( $o->got('version-check') && (!$o->has('quiet') || !$o->get('quiet')) ) {
if ( $o->get('version-check') ne 'off' && (!$o->has('quiet') || !$o->get('quiet')) ) {
Pingback::version_check(
($dbh ? { dbh => $dbh, dsn => $dsn } : ()),
{ protocol => $o->get('version-check') },
@@ -5651,14 +5658,14 @@ Show version and exit.
=item --version-check
type: string; value_is_optional: yes; default: https
type: string; default: off
Send program versions to Percona and print suggested upgrades and problems.
If specified without a value, it will use https by default; However, this
might fail if C<IO::Socket::SSL> is not installed on your system, in which
case you may choose to use C<--version-check http>, which will forgo
encryption but should work out of the box.
Accepted values are https, http, off, and auto -- The latter tries both https
and http, in that order. Keep in mind that 'https' might fail if
C<IO::Socket::SSL> is not installed on your system, although
C<--version-check http> should work everywhere.
The version check feature causes the tool to send and receive data from
Percona over the web. The data contains program versions from the local

13
lib/OptionParser.pm
View File

@@ -107,7 +107,6 @@ sub new {
'default' => 1,
'cumulative' => 1,
'negatable' => 1,
'value_is_optional' => 1,
);
my $self = {
@@ -414,10 +413,9 @@ sub _parse_specs {
$opt->{short} = undef;
}
$opt->{is_negatable} = $opt->{spec} =~ m/!/ ? 1 : 0;
$opt->{is_cumulative} = $opt->{spec} =~ m/\+/ ? 1 : 0;
$opt->{optional_value} = $opt->{spec} =~ m/:/ ? 1 : 0;
$opt->{is_required} = $opt->{desc} =~ m/required/ ? 1 : 0;
$opt->{is_negatable} = $opt->{spec} =~ m/!/ ? 1 : 0;
$opt->{is_cumulative} = $opt->{spec} =~ m/\+/ ? 1 : 0;
$opt->{is_required} = $opt->{desc} =~ m/required/ ? 1 : 0;
$opt->{group} ||= 'default';
$self->{groups}->{ $opt->{group} }->{$long} = 1;
@@ -600,7 +598,7 @@ sub _set_option {
if ( $opt->{is_cumulative} ) {
$opt->{value}++;
}
elsif ( !($opt->{optional_value} && !$val) ) {
else {
$opt->{value} = $val;
}
$opt->{got} = 1;
@@ -1275,12 +1273,11 @@ sub _parse_size {
sub _parse_attribs {
my ( $self, $option, $attribs ) = @_;
my $types = $self->{types};
my $eq = $attribs->{'value_is_optional'} ? ':' : '=';
return $option
. ($attribs->{'short form'} ? '|' . $attribs->{'short form'} : '' )
. ($attribs->{'negatable'} ? '!' : '' )
. ($attribs->{'cumulative'} ? '+' : '' )
. ($attribs->{'type'} ? $eq . $types->{$attribs->{type}} : '' );
. ($attribs->{'type'} ? '=' . $types->{$attribs->{type}} : '' );
}
sub _parse_synopsis {

26
lib/Pingback.pm
View File

@@ -87,17 +87,31 @@ sub version_check {
return;
}
my $protocol = $args->{protocol} || 'https';
my $advice = pingback(
url => $ENV{PERCONA_VERSION_CHECK_URL} || "$protocol://v.percona.com",
instances => $instances_to_check,
protocol => $args->{protocol},
);
# We got here if the protocol wasn't "off", but we haven't validated
# other possible values. I don't want it to die here, so if it isn't
# https or http, assume that it's 'auto'.
$args->{protocol} ||= 'https';
my @protocols = $args->{protocol} ne 'https' && $args->{protocol} ne 'http'
? qw(https http)
: $args->{protocol};
my $advice;
my $e;
for my $protocol ( @protocols ) {
$advice = eval { pingback(
url => $ENV{PERCONA_VERSION_CHECK_URL} || "$protocol://v.percona.com",
instances => $instances_to_check,
protocol => $protocol,
) };
# No advice, and no error, so no reason to keep trying.
last if !$advice && !$EVAL_ERROR;
$e ||= $EVAL_ERROR;
}
if ( $advice ) {
print "# Percona suggests these upgrades:\n";
print join("\n", map { "# * $_" } @$advice), "\n\n";
}
else {
die $e if $e;
print "# No suggestions at this time.\n\n";
($ENV{PTVCDEBUG} || PTDEBUG )
&& _d('--version-check worked, but there were no suggestions');

65
t/lib/OptionParser.t
View File

@@ -145,7 +145,6 @@ is_deeply(
type => 's',
got => 0,
value => undef,
optional_value => 0,
},
'port' => {
spec => 'port|p=i',
@@ -159,7 +158,6 @@ is_deeply(
type => 'i',
got => 0,
value => undef,
optional_value => 0,
},
'price' => {
spec => 'price=f',
@@ -173,7 +171,6 @@ is_deeply(
type => 'f',
got => 0,
value => undef,
optional_value => 0,
},
'hash-req' => {
spec => 'hash-req=s',
@@ -187,7 +184,6 @@ is_deeply(
type => 'H',
got => 0,
value => undef,
optional_value => 0,
},
'hash-opt' => {
spec => 'hash-opt=s',
@@ -201,7 +197,6 @@ is_deeply(
type => 'h',
got => 0,
value => undef,
optional_value => 0,
},
'array-req' => {
spec => 'array-req=s',
@@ -215,7 +210,6 @@ is_deeply(
type => 'A',
got => 0,
value => undef,
optional_value => 0,
},
'array-opt' => {
spec => 'array-opt=s',
@@ -229,7 +223,6 @@ is_deeply(
type => 'a',
got => 0,
value => undef,
optional_value => 0,
},
'host' => {
spec => 'host=s',
@@ -243,7 +236,6 @@ is_deeply(
type => 'd',
got => 0,
value => undef,
optional_value => 0,
},
'chunk-size' => {
spec => 'chunk-size=s',
@@ -257,7 +249,6 @@ is_deeply(
type => 'z',
got => 0,
value => undef,
optional_value => 0,
},
'time' => {
spec => 'time=s',
@@ -271,7 +262,6 @@ is_deeply(
type => 'm',
got => 0,
value => undef,
optional_value => 0,
},
'help' => {
spec => 'help+',
@@ -285,7 +275,6 @@ is_deeply(
type => undef,
got => 0,
value => undef,
optional_value => 0,
},
'other' => {
spec => 'other!',
@@ -299,7 +288,6 @@ is_deeply(
type => undef,
got => 0,
value => undef,
optional_value => 0,
}
},
'Parse opt specs'
@@ -520,7 +508,6 @@ is_deeply(
type => undef,
got => 0,
value => undef,
optional_value => 0,
},
'defaultset' => {
spec => 'defaultset!',
@@ -536,7 +523,6 @@ is_deeply(
type => undef,
got => 0,
value => undef,
optional_value => 0,
},
'defaults-file' => {
spec => 'defaults-file|F=s',
@@ -550,7 +536,6 @@ is_deeply(
type => 's',
got => 0,
value => undef,
optional_value => 0,
},
'dog' => {
spec => 'dog|D=s',
@@ -564,7 +549,6 @@ is_deeply(
type => 's',
got => 0,
value => undef,
optional_value => 0,
},
'love' => {
spec => 'love|l+',
@@ -578,7 +562,6 @@ is_deeply(
type => undef,
got => 0,
value => undef,
optional_value => 0,
},
},
'Parse dog specs'
@@ -978,7 +961,6 @@ is_deeply(
long => 'bar',
type => undef,
parsed => 1,
optional_value=> 0,
},
'Disabled opt is not destroyed'
);
@@ -2008,55 +1990,13 @@ $o->get_opts();
$output = output(
sub { $o->usage_or_errors(undef, 1); },
);
$synop{usage} =~ s/([\[\]])/\\$1/g;
like(
$output,
qr/^$synop{description} For more details.+\nUsage: \Q$synop{usage}\E\n?$/m,
qr/^$synop{description} For more details.+\nUsage: $synop{usage}$/m,
"Uses desc and usage from SYNOPSIS for help"
);
# Add a value_is_optional option
@ARGV = qw();
$o->get_opts();
ok(
!$o->got('version-check'),
"version-check is not true by default"
);
is(
$o->get('version-check'),
"https",
"..but it still has a value",
);
@ARGV = qw(--version-check);
$o->get_opts();
ok(
$o->got('version-check'),
"version-check is true if specified without arguments"
);
is(
$o->get('version-check'),
"https",
"..and has the default value",
);
@ARGV = qw(--version-check http);
$o->get_opts();
ok(
$o->got('version-check'),
"version-check is true if specified with arguments"
);
is(
$o->get('version-check'),
"http",
"..and has the specified value",
);
# #############################################################################
# Bug 1039074: Tools exit 0 on error parsing options, should exit non-zero
# #############################################################################
@@ -2094,3 +2034,4 @@ like(
);
done_testing;
exit;

13
t/pt-query-digest/version_check.t
View File

@@ -109,6 +109,19 @@ ok(
"percona-toolkit-version-check file not created with --no-version-check"
);
$output = `PTVCDEBUG=1 $cmd --version-check off @args 2>&1`;
unlike(
$output,
qr/(?:VersionCheck|Pingback|Percona suggests)/,
"Looks like --version-check off disabled the version-check"
) or diag($output);
ok(
!-f $check_time_file,
"percona-toolkit-version-check file not created with --version-check off"
);
# PERCONA_VERSION_CHECK=0 is handled in Pingback, so it will print a line
# for PTVCDEBUG saying why it didn't run. So we just check that it doesn't
# create the file which also signifies that it didn't run.