Merge lp:~percona-dev/percona-xtrabackup/bugfix510960-et-al-test-suite into lp:percona-xtrabackup/2.0

[Daniel Nichter]

[Daniel Nichter (daniel-nichter)]

I didn't want to make these kinds of extensive changes to innobackupex-1.5.1 so I made a new dir, innobackupex, in which innobackupex (the script) has been substantially altered. Changes include:

1) Debugging w/ IBEXDEBUG=1 (like MKDEBUG=1) to expose stuff that was hidden before.

2) All system() calls are now ran through system_call() so that every command can be seen when IBEXDEBUG=1.

3) Removed all $option_ vars, replaced with $o hashref.

4) Tweaked help/usage output a little, added to its end a list of the current option values after cmd line parsing.

5) Dogged it, which means I ran it through perltidy to format it according to the standards explained in the book Perl Best Practices.

6) innobackupex/t/ has the first incarnation of a test suite. It requires that the environment variable XTRABACKUP_TRUNK be set.

7) Made code a runable module so it can be tested and test coverage can be established. innobackupex/test-coverage.txt shows what we have so far, about 50% coverage.

It doesn't seem like this script was designed from the start to be testable. Testing it will be difficult and require a good amount of work. xtrabackup is also very talkative which means that innobackupex's tests will be noisy; xtrabackup should have a --quiet option. Since innobackupex forks children and runs shell commands capturing STDOUT and STDERR is difficult to impossible.

All in all, my branch should be as reliable, if not more, than the original code.

[Vadim Tkachenko (vadim-tk)]

Daniel,

Could you re-allocate bugfix510960 and test suite into two different branches ?

bugfix should be included in main trunk, while I agree script with test suite could be in different dir.

review: Needs Fixing

[Daniel Nichter (daniel-nichter)]

Vadim,

Vadim Tkachenko wrote:
> Review: Needs Fixing
> Daniel,
>
> Could you re-allocate bugfix510960 and test suite into two different branches ?
>
> bugfix should be included in main trunk, while I agree script with test suite could be in different dir.

So,

branch1 = apply fix(es) to original code in trunk
branch2 = separate innobackupex dir with my modified/fixed code and test suite

or,

branch1 = separate innodbackupex dir w/ my modified/fixed code
branch2 = add test suite in separate innobackupex dir

?

[Vadim Tkachenko (vadim-tk)]

Daniel,

branch1 = apply fix(es) to original code in trunk
branch2 = separate innobackupex dir with my modified/fixed code and test suite

On Thu, Jan 21, 2010 at 9:00 PM, Daniel Nichter <email address hidden> wrote:
> Vadim,
>
> Vadim Tkachenko wrote:
>> Review: Needs Fixing
>> Daniel,
>>
>> Could you re-allocate bugfix510960 and test suite into two different branches ?
>>
>> bugfix should be included in main trunk, while I agree script with test suite could be in different dir.
>
> So,
>
> branch1 = apply fix(es) to original code in trunk
> branch2 = separate innobackupex dir with my modified/fixed code and test suite
>
> or,
>
> branch1 = separate innodbackupex dir w/ my modified/fixed code
> branch2 = add test suite in separate innobackupex dir
>
> ?
> --
> https://code.launchpad.net/~percona-dev/percona-xtrabackup/bugfix510960-et-al-test-suite/+merge/17861
> You are reviewing the proposed merge of lp:~percona-dev/percona-xtrabackup/bugfix510960-et-al-test-suite into lp:percona-xtrabackup.
>

--
Vadim Tkachenko, CTO, Percona Inc.
Phone [phone], Skype: vadimtk153
Schedule meeting: http://tungle.me/VadimTkachenko

Unmerged revisions

115. By Daniel Nichter on 2010-01-22

Fix bugs 510960 510964 510965 510966 510969 510970. -- Add innobackupex/ with new, enhanced copy of innobackupex-1.5.1. First incarnation of a test suite.

=== added directory 'innobackupex'
=== added directory 'innobackupex/common'
=== added file 'innobackupex/common/DSNParser.pm'
--- innobackupex/common/DSNParser.pm	1970-01-01 00:00:00 +0000
+++ innobackupex/common/DSNParser.pm	2010-01-22 01:31:15 +0000
@@ -0,0 +1,417 @@
+# This program is copyright 2007-2009 Baron Schwartz.
+# Feedback and improvements are welcome.
+#
+# THIS PROGRAM IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR IMPLIED
+# WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
+# MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+#
+# This program is free software; you can redistribute it and/or modify it under
+# the terms of the GNU General Public License as published by the Free Software
+# Foundation, version 2; OR the Perl Artistic License.  On UNIX and similar
+# systems, you can issue `man perlgpl' or `man perlartistic' to read these
+# licenses.
+#
+# You should have received a copy of the GNU General Public License along with
+# this program; if not, write to the Free Software Foundation, Inc., 59 Temple
+# Place, Suite 330, Boston, MA  02111-1307  USA.
+# ###########################################################################
+# DSNParser package $Revision: 5266 $
+# ###########################################################################
+package DSNParser;
+
+use strict;
+use warnings FATAL => 'all';
+use English qw(-no_match_vars);
+use Data::Dumper;
+$Data::Dumper::Indent    = 0;
+$Data::Dumper::Quotekeys = 0;
+
+eval {
+   require DBI;
+};
+my $have_dbi = $EVAL_ERROR ? 0 : 1;
+
+use constant MKDEBUG => $ENV{MKDEBUG} || 0;
+
+# Defaults are built-in, but you can add/replace items by passing them as
+# hashrefs of {key, desc, copy, dsn}.  The desc and dsn items are optional.
+# You can set properties with the prop() sub.  Don't set the 'opts' property.
+sub new {
+   my ( $class, @opts ) = @_;
+   my $self = {
+      opts => {
+         A => {
+            desc => 'Default character set',
+            dsn  => 'charset',
+            copy => 1,
+         },
+         D => {
+            desc => 'Database to use',
+            dsn  => 'database',
+            copy => 1,
+         },
+         F => {
+            desc => 'Only read default options from the given file',
+            dsn  => 'mysql_read_default_file',
+            copy => 1,
+         },
+         h => {
+            desc => 'Connect to host',
+            dsn  => 'host',
+            copy => 1,
+         },
+         p => {
+            desc => 'Password to use when connecting',
+            dsn  => 'password',
+            copy => 1,
+         },
+         P => {
+            desc => 'Port number to use for connection',
+            dsn  => 'port',
+            copy => 1,
+         },
+         S => {
+            desc => 'Socket file to use for connection',
+            dsn  => 'mysql_socket',
+            copy => 1,
+         },
+         u => {
+            desc => 'User for login if not current user',
+            dsn  => 'user',
+            copy => 1,
+         },
+      },
+   };
+   foreach my $opt ( @opts ) {
+      MKDEBUG && _d('Adding extra property', $opt->{key});
+      $self->{opts}->{$opt->{key}} = { desc => $opt->{desc}, copy => $opt->{copy} };
+   }
+   return bless $self, $class;
+}
+
+# Recognized properties:
+# * dbidriver: which DBI driver to use; assumes mysql, supports Pg.
+# * required:  which parts are required (hashref).
+# * set-vars:  a list of variables to set after connecting
+sub prop {
+   my ( $self, $prop, $value ) = @_;
+   if ( @_ > 2 ) {
+      MKDEBUG && _d('Setting', $prop, 'property');
+      $self->{$prop} = $value;
+   }
+   return $self->{$prop};
+}
+
+# Parse DSN string, like "h=host,P=3306", and return hashref with
+# all DSN values, like:
+#    {
+#       D => undef,
+#       F => undef,
+#       h => 'host',
+#       p => undef,
+#       P => 3306,
+#       S => undef,
+#       t => undef,
+#       u => undef,
+#       A => undef,
+#    }
+sub parse {
+   my ( $self, $dsn, $prev, $defaults ) = @_;
+   if ( !$dsn ) {
+      MKDEBUG && _d('No DSN to parse');
+      return;
+   }
+   MKDEBUG && _d('Parsing', $dsn);
+   $prev     ||= {};
+   $defaults ||= {};
+   my %given_props;
+   my %final_props;
+   my %opts = %{$self->{opts}};
+
+   # Parse given props
+   foreach my $dsn_part ( split(/,/, $dsn) ) {
+      if ( my ($prop_key, $prop_val) = $dsn_part =~  m/^(.)=(.*)$/ ) {
+         # Handle the typical DSN parts like h=host, P=3306, etc.
+         $given_props{$prop_key} = $prop_val;
+      }
+      else {
+         # Handle barewords
+         MKDEBUG && _d('Interpreting', $dsn_part, 'as h=', $dsn_part);
+         $given_props{h} = $dsn_part;
+      }
+   }
+
+   # Fill in final props from given, previous, and/or default props
+   foreach my $key ( keys %opts ) {
+      MKDEBUG && _d('Finding value for', $key);
+      $final_props{$key} = $given_props{$key};
+      if (   !defined $final_props{$key}
+           && defined $prev->{$key} && $opts{$key}->{copy} )
+      {
+         $final_props{$key} = $prev->{$key};
+         MKDEBUG && _d('Copying value for', $key, 'from previous DSN');
+      }
+      if ( !defined $final_props{$key} ) {
+         $final_props{$key} = $defaults->{$key};
+         MKDEBUG && _d('Copying value for', $key, 'from defaults');
+      }
+   }
+
+   # Sanity check props
+   foreach my $key ( keys %given_props ) {
+      die "Unrecognized DSN part '$key' in '$dsn'\n"
+         unless exists $opts{$key};
+   }
+   if ( (my $required = $self->prop('required')) ) {
+      foreach my $key ( keys %$required ) {
+         die "Missing DSN part '$key' in '$dsn'\n" unless $final_props{$key};
+      }
+   }
+
+   return \%final_props;
+}
+
+# Like parse() above but takes an OptionParser object instead of
+# a DSN string.
+sub parse_options {
+   my ( $self, $o ) = @_;
+   die 'I need an OptionParser object' unless ref $o eq 'OptionParser';
+   my $dsn_string
+      = join(',',
+          map  { "$_=".$o->get($_); }
+          grep { $o->has($_) && $o->get($_) }
+          keys %{$self->{opts}}
+        );
+   MKDEBUG && _d('DSN string made from options:', $dsn_string);
+   return $self->parse($dsn_string);
+}
+
+sub as_string {
+   my ( $self, $dsn ) = @_;
+   return $dsn unless ref $dsn;
+   return join(',',
+      map  { "$_=" . ($_ eq 'p' ? '...' : $dsn->{$_}) }
+      grep { defined $dsn->{$_} && $self->{opts}->{$_} }
+      sort keys %$dsn );
+}
+
+sub usage {
+   my ( $self ) = @_;
+   my $usage
+      = "DSN syntax is key=value[,key=value...]  Allowable DSN keys:\n\n"
+      . "  KEY  COPY  MEANING\n"
+      . "  ===  ====  =============================================\n";
+   my %opts = %{$self->{opts}};
+   foreach my $key ( sort keys %opts ) {
+      $usage .= "  $key    "
+             .  ($opts{$key}->{copy} ? 'yes   ' : 'no    ')
+             .  ($opts{$key}->{desc} || '[No description]')
+             . "\n";
+   }
+   $usage .= "\n  If the DSN is a bareword, the word is treated as the 'h' key.\n";
+   return $usage;
+}
+
+# Supports PostgreSQL via the dbidriver element of $info, but assumes MySQL by
+# default.
+sub get_cxn_params {
+   my ( $self, $info ) = @_;
+   my $dsn;
+   my %opts = %{$self->{opts}};
+   my $driver = $self->prop('dbidriver') || '';
+   if ( $driver eq 'Pg' ) {
+      $dsn = 'DBI:Pg:dbname=' . ( $info->{D} || '' ) . ';'
+         . join(';', map  { "$opts{$_}->{dsn}=$info->{$_}" }
+                     grep { defined $info->{$_} }
+                     qw(h P));
+   }
+   else {
+      $dsn = 'DBI:mysql:' . ( $info->{D} || '' ) . ';'
+         . join(';', map  { "$opts{$_}->{dsn}=$info->{$_}" }
+                     grep { defined $info->{$_} }
+                     qw(F h P S A))
+         . ';mysql_read_default_group=client';
+   }
+   MKDEBUG && _d($dsn);
+   return ($dsn, $info->{u}, $info->{p});
+}
+
+# Fills in missing info from a DSN after successfully connecting to the server.
+sub fill_in_dsn {
+   my ( $self, $dbh, $dsn ) = @_;
+   my $vars = $dbh->selectall_hashref('SHOW VARIABLES', 'Variable_name');
+   my ($user, $db) = $dbh->selectrow_array('SELECT USER(), DATABASE()');
+   $user =~ s/@.*//;
+   $dsn->{h} ||= $vars->{hostname}->{Value};
+   $dsn->{S} ||= $vars->{'socket'}->{Value};
+   $dsn->{P} ||= $vars->{port}->{Value};
+   $dsn->{u} ||= $user;
+   $dsn->{D} ||= $db;
+}
+
+# Actually opens a connection, then sets some things on the connection so it is
+# the way the Maatkit tools will expect.  Tools should NEVER open their own
+# connection or use $dbh->reconnect, or these things will not take place!
+sub get_dbh {
+   my ( $self, $cxn_string, $user, $pass, $opts ) = @_;
+   $opts ||= {};
+   my $defaults = {
+      AutoCommit         => 0,
+      RaiseError         => 1,
+      PrintError         => 0,
+      ShowErrorStatement => 1,
+      mysql_enable_utf8 => ($cxn_string =~ m/charset=utf8/ ? 1 : 0),
+   };
+   @{$defaults}{ keys %$opts } = values %$opts;
+
+   if ( !$have_dbi ) {
+      die "Cannot connect to MySQL because the Perl DBI module is not "
+         . "installed or not found.  Run 'perl -MDBI' to see the directories "
+         . "that Perl searches for DBI.  If DBI is not installed, try:\n"
+         . "  Debian/Ubuntu  apt-get install libdbi-perl\n"
+         . "  RHEL/CentOS    yum install perl-DBI\n"
+         . "  OpenSolaris    pgk install pkg:/SUNWpmdbi\n";
+
+   }
+
+   # Try twice to open the $dbh and set it up as desired.
+   my $dbh;
+   my $tries = 2;
+   while ( !$dbh && $tries-- ) {
+      MKDEBUG && _d($cxn_string, ' ', $user, ' ', $pass, ' {',
+         join(', ', map { "$_=>$defaults->{$_}" } keys %$defaults ), '}');
+
+      eval {
+         $dbh = DBI->connect($cxn_string, $user, $pass, $defaults);
+
+         # If it's a MySQL connection, set some options.
+         if ( $cxn_string =~ m/mysql/i ) {
+            my $sql;
+
+            # Set SQL_MODE and options for SHOW CREATE TABLE.
+            $sql = q{SET @@SQL_QUOTE_SHOW_CREATE = 1}
+                 . q{/*!40101, @@SQL_MODE='NO_AUTO_VALUE_ON_ZERO'*/};
+            MKDEBUG && _d($dbh, ':', $sql);
+            $dbh->do($sql);
+
+            # Set character set and binmode on STDOUT.
+            if ( my ($charset) = $cxn_string =~ m/charset=(\w+)/ ) {
+               $sql = "/*!40101 SET NAMES $charset*/";
+               MKDEBUG && _d($dbh, ':', $sql);
+               $dbh->do($sql);
+               MKDEBUG && _d('Enabling charset for STDOUT');
+               if ( $charset eq 'utf8' ) {
+                  binmode(STDOUT, ':utf8')
+                     or die "Can't binmode(STDOUT, ':utf8'): $OS_ERROR";
+               }
+               else {
+                  binmode(STDOUT) or die "Can't binmode(STDOUT): $OS_ERROR";
+               }
+            }
+
+            if ( $self->prop('set-vars') ) {
+               $sql = "SET " . $self->prop('set-vars');
+               MKDEBUG && _d($dbh, ':', $sql);
+               $dbh->do($sql);
+            }
+         }
+      };
+      if ( !$dbh && $EVAL_ERROR ) {
+         MKDEBUG && _d($EVAL_ERROR);
+         if ( $EVAL_ERROR =~ m/not a compiled character set|character set utf8/ ) {
+            MKDEBUG && _d('Going to try again without utf8 support');
+            delete $defaults->{mysql_enable_utf8};
+         }
+         elsif ( $EVAL_ERROR =~ m/locate DBD\/mysql/i ) {
+            die "Cannot connect to MySQL because the Perl DBD::mysql module is "
+               . "not installed or not found.  Run 'perl -MDBD::mysql' to see "
+               . "the directories that Perl searches for DBD::mysql.  If "
+               . "DBD::mysql is not installed, try:\n"
+               . "  Debian/Ubuntu  apt-get install libdbd-mysql-perl\n"
+               . "  RHEL/CentOS    yum install perl-DBD-MySQL\n"
+               . "  OpenSolaris    pgk install pkg:/SUNWapu13dbd-mysql\n";
+         }
+         if ( !$tries ) {
+            die $EVAL_ERROR;
+         }
+      }
+   }
+
+   MKDEBUG && _d('DBH info: ',
+      $dbh,
+      Dumper($dbh->selectrow_hashref(
+         'SELECT DATABASE(), CONNECTION_ID(), VERSION()/*!50038 , @@hostname*/')),
+      'Connection info:',      $dbh->{mysql_hostinfo},
+      'Character set info:',   Dumper($dbh->selectall_arrayref(
+                     'SHOW VARIABLES LIKE "character_set%"', { Slice => {}})),
+      '$DBD::mysql::VERSION:', $DBD::mysql::VERSION,
+      '$DBI::VERSION:',        $DBI::VERSION,
+   );
+
+   return $dbh;
+}
+
+# Tries to figure out a hostname for the connection.
+sub get_hostname {
+   my ( $self, $dbh ) = @_;
+   if ( my ($host) = ($dbh->{mysql_hostinfo} || '') =~ m/^(\w+) via/ ) {
+      return $host;
+   }
+   my ( $hostname, $one ) = $dbh->selectrow_array(
+      'SELECT /*!50038 @@hostname, */ 1');
+   return $hostname;
+}
+
+# Disconnects a database handle, but complains verbosely if there are any active
+# children.  These are usually $sth handles that haven't been finish()ed.
+sub disconnect {
+   my ( $self, $dbh ) = @_;
+   MKDEBUG && $self->print_active_handles($dbh);
+   $dbh->disconnect;
+}
+
+sub print_active_handles {
+   my ( $self, $thing, $level ) = @_;
+   $level ||= 0;
+   printf("# Active %sh: %s %s %s\n", ($thing->{Type} || 'undef'), "\t" x $level,
+      $thing, (($thing->{Type} || '') eq 'st' ? $thing->{Statement} || '' : ''))
+      or die "Cannot print: $OS_ERROR";
+   foreach my $handle ( grep {defined} @{ $thing->{ChildHandles} } ) {
+      $self->print_active_handles( $handle, $level + 1 );
+   }
+}
+
+# Copy all set vals in dsn_1 to dsn_2.  Existing val in dsn_2 are not
+# overwritten unless overwrite=>1 is given, but undef never overwrites a
+# val.
+sub copy {
+   my ( $self, $dsn_1, $dsn_2, %args ) = @_;
+   die 'I need a dsn_1 argument' unless $dsn_1;
+   die 'I need a dsn_2 argument' unless $dsn_2;
+   my %new_dsn = map {
+      my $key = $_;
+      my $val;
+      if ( $args{overwrite} ) {
+         $val = defined $dsn_1->{$key} ? $dsn_1->{$key} : $dsn_2->{$key};
+      }
+      else {
+         $val = defined $dsn_2->{$key} ? $dsn_2->{$key} : $dsn_1->{$key};
+      }
+      $key => $val;
+   } keys %{$self->{opts}};
+   return \%new_dsn;
+}
+
+sub _d {
+   my ($package, undef, $line) = caller 0;
+   @_ = map { (my $temp = $_) =~ s/\n/\n# /g; $temp; }
+        map { defined $_ ? $_ : 'undef' }
+        @_;
+   print STDERR "# $package:$line $PID ", join(' ', @_), "\n";
+}
+
+1;
+
+# ###########################################################################
+# End DSNParser package
+# ###########################################################################

=== added file 'innobackupex/common/IbexTest.pm'
--- innobackupex/common/IbexTest.pm	1970-01-01 00:00:00 +0000
+++ innobackupex/common/IbexTest.pm	2010-01-22 01:31:15 +0000
@@ -0,0 +1,133 @@
+# This program is copyright 2010 Percona Inc.
+# Feedback and improvements are welcome.
+#
+# THIS PROGRAM IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR IMPLIED
+# WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
+# MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+#
+# This program is free software; you can redistribute it and/or modify it under
+# the terms of the GNU General Public License as published by the Free Software
+# Foundation, version 2; OR the Perl Artistic License.  On UNIX and similar
+# systems, you can issue `man perlgpl' or `man perlartistic' to read these
+# licenses.
+#
+# You should have received a copy of the GNU General Public License along with
+# this program; if not, write to the Free Software Foundation, Inc., 59 Temple
+# Place, Suite 330, Boston, MA  02111-1307  USA.
+package IbexTest;
+
+BEGIN {
+   die "The XTRABACKUP_TRUNK environment variable is not set."
+      unless $ENV{XTRABACKUP_TRUNK} && -d $ENV{XTRABACKUP_TRUNK};
+   unshift @INC, "$ENV{XTRABACKUP_TRUNK}/innobackupex/common";
+};
+our $trunk = $ENV{XTRABACKUP_TRUNK};
+
+use strict;
+use warnings FATAL => 'all';
+use English qw(-no_match_vars);
+use Test::More;
+use Data::Dumper;
+$Data::Dumper::Indent    = 1;
+$Data::Dumper::Sortkeys  = 1;
+$Data::Dumper::Quotekeys = 0;
+
+require Exporter;
+our @ISA         = qw(Exporter);
+our %EXPORT_TAGS = ();
+our @EXPORT      = qw(
+   output
+   load_file
+   wait_until
+   wait_for
+   no_diff
+   $trunk
+);
+our @EXPORT_OK   = qw();
+
+sub output {
+   my ( $code ) = @_;
+   die "I need a code argument" unless $code;
+   my $output = '';
+   open my $output_fh, '>', \$output
+      or die "Cannot capture output to variable: $OS_ERROR";
+   select $output_fh;
+   eval { $code->() };
+   close $output_fh;
+   select STDOUT;
+   die $EVAL_ERROR if $EVAL_ERROR;
+   return $output;
+}
+
+# Slurp file and return its entire contents.
+sub load_file {
+   my ( $file, %args ) = @_;
+   $file = "$trunk/$file";
+   open my $fh, "<", $file or die "Cannot open $file: $OS_ERROR";
+   my $contents = do { local $/ = undef; <$fh> };
+   close $fh;
+   chomp $contents if $args{chomp_contents};
+   return $contents;
+}
+
+# Wait until code returns true.
+sub wait_until {
+   my ( $code, $t, $max_t ) = @_;
+   my $slept     = 0;
+   my $sleep_int = $t || .5;
+   $t     ||= .5;
+   $max_t ||= 5;
+   $t *= 1_000_000;
+   while ( $slept <= $max_t ) {
+      return if $code->();
+      usleep($t);
+      $slept += $sleep_int;
+   }
+   return;
+}
+
+# Wait t seconds for code to return.
+sub wait_for {
+   my ( $code, $t ) = @_;
+   $t ||= 0;
+   my $mask   = POSIX::SigSet->new(&POSIX::SIGALRM);
+   my $action = POSIX::SigAction->new(
+      sub { die },
+      $mask,
+   );
+   my $oldaction = POSIX::SigAction->new();
+   sigaction(&POSIX::SIGALRM, $action, $oldaction);
+   eval {
+      alarm $t;
+      $code->();
+      alarm 0;
+   };
+   if ( $EVAL_ERROR ) {
+      # alarm was raised
+      return 1;
+   }
+   return 0;
+}
+
+# Returns true (1) if there's no difference between the
+# cmd's output and the expected output.  If $update_sample
+# or the env var UPDATE_SAMPLES is true then the $cmd
+# output is written to the $expected_output file.
+sub no_diff {
+   my ( $cmd, $expected_output, $update_sample ) = @_;
+   die "I need a cmd argument" unless $cmd;
+   die "I need an expected_output argument" unless $expected_output;
+   my $output_file = '/tmp/ibex-test-output.txt';
+   $expected_output = "$trunk/$expected_output";
+   `$cmd > $output_file`;
+   if ( $ENV{UPDATE_SAMPLES} || $update_sample ) {
+      `cat $output_file > $expected_output`;
+      print STDERR "Updated $expected_output\n";
+   }
+   my $retval = system("diff $expected_output $output_file");
+   `rm -rf $output_file`;
+   $retval = $retval >> 8; 
+   return !$retval;
+}
+
+1;

=== added file 'innobackupex/common/Sandbox.pm'
--- innobackupex/common/Sandbox.pm	1970-01-01 00:00:00 +0000
+++ innobackupex/common/Sandbox.pm	2010-01-22 01:31:15 +0000
@@ -0,0 +1,168 @@
+# This program is copyright 2010 Percona Inc.
+# Feedback and improvements are welcome.
+#
+# THIS PROGRAM IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR IMPLIED
+# WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
+# MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+#
+# This program is free software; you can redistribute it and/or modify it under
+# the terms of the GNU General Public License as published by the Free Software
+# Foundation, version 2; OR the Perl Artistic License.  On UNIX and similar
+# systems, you can issue `man perlgpl' or `man perlartistic' to read these
+# licenses.
+#
+# You should have received a copy of the GNU General Public License along with
+# this program; if not, write to the Free Software Foundation, Inc., 59 Temple
+# Place, Suite 330, Boston, MA  02111-1307  USA.
+package Sandbox;
+
+BEGIN {
+   die "The XTRABACKUP_TRUNK environment variable is not set."
+      unless $ENV{XTRABACKUP_TRUNK} && -d $ENV{XTRABACKUP_TRUNK};
+   unshift @INC, "$ENV{XTRABACKUP_TRUNK}/innobackupex/common";
+};
+
+use strict;
+use warnings FATAL => 'all';
+use English qw(-no_match_vars);
+
+my $trunk = $ENV{XTRABACKUP_TRUNK};
+
+use constant IBEXDEBUG => $ENV{IBEXDEBUG} || 0;
+
+my %port_for = (
+   master  => 12345,
+   slave1  => 12346,
+   slave2  => 12347,
+   master1 => 12348, # master-master
+   master2 => 12349, # master-master
+);
+
+sub new {
+   my ( $class, %args ) = @_;
+   foreach my $arg ( qw(basedir DSNParser) ) {
+      die "I need a $arg argument" unless defined $args{$arg};
+   }
+
+   if ( !-d $args{basedir} ) {
+      die "$args{basedir} is not a directory";
+   }
+
+   return bless { %args }, $class;
+}
+
+sub use {
+   my ( $self, $server, $cmd ) = @_;
+   _check_server($server);
+   return if !defined $cmd || !$cmd;
+   my $use = $self->_use_for($server) . " $cmd";
+   IBEXDEBUG && _d('"Executing', $use, 'on', $server);
+   eval {
+      `$use`;
+   };
+   if ( $EVAL_ERROR ) {
+      die "Failed to execute $cmd on $server: $EVAL_ERROR";
+   }
+   return;
+}
+
+sub create_dbs {
+   my ( $self, $dbh, $dbs, %args ) = @_;
+   die 'I need a dbh' if !$dbh;
+   return if ( !ref $dbs || scalar @$dbs == 0 );
+   my %default_args = (
+      repl => 1,
+      drop => 1,
+   );
+   %args = ( %default_args, %args );
+
+   $dbh->do('SET SQL_LOG_BIN=0') unless $args{repl};
+
+   foreach my $db ( @$dbs ) {
+      $dbh->do("DROP DATABASE IF EXISTS `$db`") if $args{drop};
+
+      my $sql = "CREATE DATABASE `$db`";
+      eval {
+         $dbh->do($sql);
+      };
+      die $EVAL_ERROR if $EVAL_ERROR;
+   }
+
+   $dbh->do('SET SQL_LOG_BIN=1');
+
+   return;
+}
+   
+sub get_dbh_for {
+   my ( $self, $server, $cxn_ops ) = @_;
+   _check_server($server);
+   $cxn_ops ||= { AutoCommit => 1 };
+   IBEXDEBUG && _d('dbh for', $server, 'on port', $port_for{$server});
+   my $dp = $self->{DSNParser};
+   my $dsn = $dp->parse('h=127.0.0.1,u=msandbox,p=msandbox,P=' . $port_for{$server});
+   my $dbh;
+   eval { $dbh = $dp->get_dbh($dp->get_cxn_params($dsn), $cxn_ops) };
+   if ( $EVAL_ERROR ) {
+      IBEXDEBUG && _d('Failed to get dbh for', $server, ':', $EVAL_ERROR);
+      return 0;
+   }
+   return $dbh;
+}
+
+sub load_file {
+   my ( $self, $server, $file, $use_db ) = @_;
+   _check_server($server);
+   $file = "$trunk/$file";
+   if ( !-f $file ) {
+      die "$file is not a file";
+   }
+
+   my $d = $use_db ? "-D $use_db" : '';
+
+   my $use = $self->_use_for($server) . " $d < $file";
+   IBEXDEBUG && _d('Loading', $file, 'on', $server, ':', $use);
+   eval { `$use` };
+   if ( $EVAL_ERROR ) {
+      die "Failed to execute $file on $server: $EVAL_ERROR";
+   }
+
+   return;
+}
+
+sub _use_for {
+   my ( $self, $server ) = @_;
+   return "$self->{basedir}/$port_for{$server}/use";
+}
+
+sub _check_server {
+   my ( $server ) = @_;
+   if ( !exists $port_for{$server} ) {
+      die "Unknown server $server";
+   }
+   return;
+}
+
+sub wipe_clean {
+   my ( $self, $dbh ) = @_;
+   foreach my $db ( @{$dbh->selectcol_arrayref('SHOW DATABASES')} ) {
+      next if $db eq 'mysql';
+      next if $db eq 'information_schema';
+      next if $db eq 'sakila';
+      $dbh->do("DROP DATABASE IF EXISTS `$db`");
+   }
+   return;
+}
+
+sub _d {
+   my ($package, undef, $line) = caller 0;
+   @_ = map { (my $temp = $_) =~ s/\n/\n# /g; $temp; }
+        map { defined $_ ? $_ : 'undef' }
+        @_;
+   print STDERR "# $package:$line $PID ", join(' ', @_), "\n";
+}
+
+1;
+
+# ###########################################################################
+# End Sandbox package
+# ###########################################################################

=== added file 'innobackupex/innobackupex'
--- innobackupex/innobackupex	1970-01-01 00:00:00 +0000
+++ innobackupex/innobackupex	2010-01-22 01:31:15 +0000
@@ -0,0 +1,2400 @@
+#!/usr/bin/env perl
+
+# A script for making backups of InnoDB and MyISAM tables, indexes and .frm
+# files.
+#
+# Orginal code copyright 2003, 2009 Innobase Oy.
+# http://www.innodb.com/download/
+#
+# Modified code copyright 2010 Percona Inc.
+# https://launchpad.net/percona-xtrabackup/trunk
+
+# ############################################################################
+# This is a a runnable module.  Check at the end of this package for the call
+# to main() which actually runs the program.
+# ############################################################################
+package innobackupex;
+
+use strict;
+use warnings FATAL => 'all';
+use English qw(-no_match_vars);
+use Getopt::Long qw(:config default);
+use File::Spec;
+use POSIX "strftime";
+use POSIX ":sys_wait_h";
+use POSIX "tmpnam";
+use FileHandle;
+use File::Basename;
+
+use constant IBEXDEBUG => $ENV{IBEXDEBUG} || 0;
+
+# version of this script
+my $innobackup_version = '1.5.1-xtrabackup';
+my $innobackup_script  = basename($0);
+
+# copyright notice
+my $copyright_notice = "InnoDB Backup Utility v${innobackup_version}; Copyright 2003, 2009 Innobase Oy.
+All Rights Reserved.
+
+This software is published under
+the GNU GENERAL PUBLIC LICENSE Version 2, June 1991.
+
+";
+
+# required Perl version (5.005)
+my @required_perl_version = ( 5, 0, 5 );
+my $required_perl_version_old_style = 5.005;
+
+# force flush after every write and print
+$OUTPUT_AUTOFLUSH = 1;
+
+######################################################################
+# modifiable parameters
+######################################################################
+
+# maximum number of files in a database directory which are
+# separately printed when a backup is made
+my $backup_file_print_limit = 9;
+
+# timeout in seconds for a reply from mysql
+my $mysql_response_timeout = 900;
+
+# default compression level (this is an argument to ibbackup)
+my $default_compression_level = 1;
+
+# time in seconds after which a dummy query is sent to mysql server
+# in order to keep the database connection alive
+my $mysql_keep_alive_timeout = 1800;
+
+######################################################################
+# end of modifiable parameters
+######################################################################
+
+# command line options
+my $o = {
+   'compress'  => 999,
+   'databases' => '',
+   'ibbackup'  => 'xtrabackup',
+   'scp-opt'   => '-Cp -c arcfour',
+   'stream'    => '',
+};
+
+# root of the backup directory
+my $backup_root = '';
+
+# backup directory pathname
+my $backup_dir = '';
+
+# name of the ibbackup suspend-at-end file
+my $suspend_file = '';
+
+# name of the temporary transaction log file during the backup
+my $tmp_logfile = '';
+
+# home directory of innoDB log files
+my $innodb_log_group_home_dir = '';
+
+# backup my.cnf file
+my $backup_config_file = '';
+
+# options from the options file
+my %config;
+
+# options from the backup options file
+#my %backup_config;
+
+# list of databases to be included in a backup
+my %databases_list;
+
+# prefix for output lines
+my $prefix = "$innobackup_script:";
+
+# process id of mysql client program (runs as a child process of this script)
+my $mysql_pid = '';
+
+# mysql server version string
+my $mysql_server_version = '';
+
+# name of the file where stderr of mysql process is directed
+my $mysql_stderr;
+
+# name of the file where stdout of mysql process is directed
+my $mysql_stdout;
+
+# name of the file where binlog position info is written
+my $binlog_info;
+
+# name of the file where slave info is written
+my $slave_info;
+
+# mysql binlog position as given by "SHOW MASTER STATUS" command
+my $mysql_binlog_position = '';
+
+# mysql master's binlog position as given by "SHOW SLAVE STATUS" command
+# run on a slave server
+my $mysql_slave_position = '';
+
+# time of the most recent mysql_check call. (value returned by time() function)
+my $mysql_last_access_time = 0;
+
+# process id of ibbackup program (runs as a child process of this script)
+my $ibbackup_pid = '';
+
+# a counter for numbering mysql connection checks
+my $hello_id = 0;
+
+# the request which has been sent to mysqld, but to which
+# mysqld has not yet replied. Empty string denotes that no
+# request has been sent to mysqld or that mysqld has replied
+# to all requests.
+my $current_mysql_request = '';
+
+# escape sequences for options files
+my %option_value_escapes = (
+   'b'  => "\b",
+   't'  => "\t",
+   'n'  => "\n",
+   'r'  => "\r",
+   "\\" => "\\",
+   's'  => ' '
+);
+
+# signal that is sent to child processes when they are killed
+my $kill_signal = 15;
+
+# current local time
+my $now;
+
+# incremental backup base directory
+my $incremental_basedir = '';
+
+my $src_name;
+my $dst_name;
+my $win    = ( $^O  eq 'MSWin32' ? 1         : 0 );
+my $CP_CMD = ( $win eq 1         ? "copy /Y" : "cp -p" );
+
+######################################################################
+# program execution begins here
+######################################################################
+sub main {
+   @ARGV = @_;    # set global ARGV for this package
+
+   # check command-line args
+   check_args();
+
+   # print program version and copyright
+   print_version();
+
+   # initialize global variables and perform some checks
+   init();
+
+   if ( $o->{'copy-back'} ) {
+      # copy files from backup directory back to their original locations
+      copy_back();
+   }
+   elsif ( $o->{'apply-log'} ) {
+      # expand data files in backup directory by applying log files to them
+      apply_log();
+   }
+   else {
+      # make a backup of InnoDB and MyISAM tables, indexes and .frm files.
+      backup();
+   }
+
+   # program has completed successfully
+   $now = current_time();
+   print STDERR "$now  $prefix completed OK!\n";
+
+   if ( $o->{'stream'} eq 'tar' ) {
+      print STDERR "$prefix You must use -i (--ignore-zeros) option for extraction of the tar stream.\n";
+   }
+
+   return 0;
+}
+
+##############################################################################
+# Subroutines
+##############################################################################
+
+#
+# print_version subroutine prints program version and copyright.
+#
+sub print_version {
+   printf( STDERR $copyright_notice );
+}
+
+#
+# usage subroutine prints instructions of how to use this program to stdout.
+#
+sub usage {
+   print STDOUT <<EOF;
+
+Usage:
+
+   $innobackup_script BACKUP-ROOT-DIR [OPTIONS]
+
+   $innobackup_script --apply-log BACKUP-DIR [OPTIONS]
+   
+   $innobackup_script --copy-back BACKUP-DIR [OPTIONS]
+
+The first command line above makes a hot backup of a MySQL database.
+By default it creates a backup directory (named by the current date
+and time) in the given BACKUP-ROOT-DIR directory.  With the --no-timestamp
+option it does not create a time-stamped backup directory, but it puts
+the backup in the given directory (which must not exist).  This
+command makes a complete backup of all MyISAM and InnoDB tables and
+indexes in all databases or in all of the databases specified with the
+--databases option.  The created backup contains .frm, .MRG, .MYD,
+.MYI, .TRG, .TRN, .ARM, .ARZ, .opt, .par, and InnoDB data and log files.
+The MY.CNF options file defines the location of the database.  This command
+connects to the MySQL server using mysql client program, and runs
+ibbackup (InnoDB Hot Backup program) as a child process.
+
+The command with --apply-log option prepares a backup for starting a MySQL
+server on the backup. This command expands InnoDB data files as specified
+in BACKUP-DIR/backup-my.cnf using BACKUP-DIR/ibbackup_logfile,
+and creates new InnoDB log files as specified in BACKUP-DIR/backup-my.cnf.
+The BACKUP-DIR should be a path name of a backup directory created by
+innobackup. This command runs ibbackup as a child process, but it does not 
+connect to the database server. 
+
+The command with --copy-back option copies data, index, and log files
+from backup directory back to their original locations.
+The MY.CNF options file defines the original location of the database.
+The BACKUP-DIR is a path name of a backup directory created by innobackup.
+
+On success the exit code of innobackup process is 0. A non-zero exit code 
+indicates an error.
+
+Options:
+
+    --help      Display this helpscreen and exit.
+
+    --version   Print version information and exit.
+
+    --defaults-file=[MY.CNF]
+                This option is passed to the xtrabackup child process
+                and the mysql child process.  It specifies which file
+                to read default options from.
+
+    --apply-log
+                Prepare a backup for starting mysql server on the backup. 
+                Expand InnoDB data files as specified in 
+                backup-dir/backup-my.cnf, using backup-dir/ibbackup_logfile, 
+                and create new log files as specified in 
+                backup-dir/backup-my.cnf.
+
+    --copy-back
+                Copy data and index files from backup directory back to 
+                their original locations.
+
+    --remote-host=[USER@]HOSTNAME
+                If this option is specified, backup files will be created
+                at the remote host by using ssh and scp.  BACKUP-ROOT-DIR
+                is relative to this host.
+
+    --stream=[tar|cpio(not implemented)]
+                If this option is specified, backup to STDOUT as specified
+                format.
+
+    --tmpdir=DIRECTORY
+                When --remote-host or --stream specified, transaction log
+                should be stored temporary. The default value is same to
+                mysqld setting.
+
+    --use-memory=MB
+                This option is passed to the ibbackup child process.
+                It tells ibbackup that it can use MB megabytes of 
+                memory in restoration.
+                Try 'ibbackup --help' for more details on this option.
+
+    --throttle=IOS
+                This option is passed to the xtrabackup child process.
+                It limits count of IO operations (pairs of read&write) per
+                second to IOS values (for '--backup')
+
+    --sleep=MS 
+                This option is passed to the ibbackup child process.
+                It instructs the ibbackup program to sleep 
+                MS milliseconds after each 1 MB of copied data.
+                You can use this parameter to tune the additional 
+                disk i/o load the ibbackup program causes on the computer.
+                Try 'ibbackup --help' for more details on this option.
+                ** it is not supported by xtrabackup **
+
+    --compress[=LEVEL]
+                This option is passed to the ibbackup child process.
+                It instructs ibbackup to compress the backup copies of 
+                InnoDB data files. Compression level can be
+                specified as an optional argument. Compression level is 
+                an integer between 0 and 9: 1 gives fastest compression, 
+                9 gives best compression, and 0 means no compression. 
+                If compression level is not given, the default level 1 is used.
+                Try 'ibbackup --help' for more details on this option.
+                ** it is not supported by xtrabackup yet **
+
+    --include=REGEXP 
+                This option is passed to the ibbackup child process.
+                It tells ibbackup to backup only those per-table data
+                files which match the given regular expression.  For
+                each table with a per-table data file a string of the
+                form db_name.table_name is checked against the regular
+                expression.  If the regular expression matches the
+                complete string db_name.table_name, the table is
+                included in the backup. The regular expression should
+                be of the POSIX 1003.2 "extended" form.  
+                Try 'ibbackup --help' for more details on this option.
+
+    --databases=LIST
+                This option is used to specify the list of databases that
+                innobackup should backup. The list is of the form
+                "db_name[.table_name] db_name1[.table_name1] ...".
+                If this option is not specified all databases containing 
+                MyISAM and InnoDB tables will be backed up. 
+                Please make sure that --databases contains all of the 
+                innodb databases & tables so that all of the innodb .frm 
+                files are also backed up. In case the list is very long, 
+                this can be specified in a file and the full path of the 
+                file can be specified instead of the list.
+
+    --uncompress
+                This option is passed to the ibbackup child process.
+                It tells ibbackup to uncompress compressed InnoDB data files.
+                Try 'ibbackup --help' for more details on this option.
+                ** it is not supported by xtrabackup yet **
+                
+    --export   
+                This option is passed to the xtrabackup child process.
+                It is effective with '--prepare' option.
+                It tells xtrabackup to output "clean" .ibd files and .exp
+                files for 'ALTER TABLE ... IMPORT TABLESPACE' command
+                at innodb_expand_import option enabled XtraDB.
+
+    --user=NAME 
+                This option is passed to the mysql child process.
+                It defines the user for database login if not current user.
+                Try 'mysql --help' for more details on this option.
+
+    --password=WORD
+                This option is passed to the mysql child process.
+                It defines the password to use when connecting to database.
+                Try 'mysql --help' for more details on this option.
+
+    --host=HOST
+                This option is passed to the mysql child process.
+                It defines the hostname or IP address to use when connecting
+                to the database server.
+                Try 'mysql --help' for more details on this option.
+
+    --port=PORT 
+                This option is passed to the mysql child process.
+                It defines the port to use when connecting to local database
+                server with TCP/IP.
+                Try 'mysql --help' for more details on this option.
+
+    --slave-info
+                This option is useful when backing up a replication
+                slave server. It prints the binary log position and
+                name of the binary log file of the master server.
+                It also writes this information to the 'ibbackup_slave_info'
+                file as a 'CHANGE MASTER' command. A new slave for this
+                master can be set up by starting a slave server on this 
+                backup and issuing a 'CHANGE MASTER' command with the binary 
+                log position saved in the 'ibbackup_slave_info' file.
+
+    --socket=SOCKET
+                This option is passed to the mysql child process.
+                It defines the socket to use when connecting to local database
+                server with UNIX domain socket.
+                Try 'mysql --help' for more details on this option.
+
+    --no-timestamp
+                This option prevents the creation of a new backup
+                directory (named by the current date and time) under
+                the backup root directory. Instead, the backup is put
+                in the directory given on the command-line (in the
+                place of BACKUP-ROOT-DIR argument). The directory must not 
+                exist, because innobackup creates it while making a backup.
+
+    --ibbackup=IBBACKUP-BINARY
+                Use this option to specify which ibbackup (InnoDB Hot
+                Backup) binary should be used.  IBBACKUP-BINARY
+                should be the command used to run ibbackup. This can
+                be useful if ibbackup is not in your search path or
+                working directory.  If this option is not given,
+                ibbackup is run with command "ibbackup".
+    --no-lock
+                Use this option to disable table lock with
+                FLUSH TABLES WITH READ LOCK. use it only while ALL your 
+                tables are InnoDB and you DO NOT CARE about binary log 
+                position of backup.
+
+    --scpopt=SCP-OPTIONS
+                Use this option to specify the command line options
+                to pass to scp.  The default options are '-Cp -c arcfour'.
+
+EOF
+
+   print STDOUT "Option values after processing arguments:\n\n";
+   print STDOUT
+      join( "\n", sort map { "    --$_=" . $o->{$_} || '' } keys %$o ),
+      "\n\n";
+
+   return;
+}
+
+#
+# return current local time as string in form "070816 12:23:15"
+#
+sub current_time {
+   return strftime( "%y%m%d %H:%M:%S", localtime() );
+}
+
+#
+# Die subroutine kills all child processes and exits this process.
+# This subroutine takes the same argument as the built-in die function.
+#    Parameters:
+#       message   string which is printed to stdout
+#
+sub Die {
+   my $message    = shift;
+   my $extra_info = '';
+
+   # kill all child processes of this process
+   kill_child_processes();
+
+   if ($current_mysql_request) {
+      $extra_info = " while waiting for reply to MySQL request:"
+         . " '$current_mysql_request'";
+   }
+
+   IBEXDEBUG && _d('Die', $prefix, $message, $extra_info);
+   die "$prefix Error: $message$extra_info";
+}
+
+#
+# backup subroutine makes a backup of InnoDB and MyISAM tables, indexes and
+# .frm files. It connects to the database server and runs ibbackup as a child
+# process.
+#
+sub backup {
+   my $orig_datadir = get_option( \%config, 'mysqld', 'datadir' );
+
+   # check that we can connect to the database. This done by
+   # connecting, issuing a query, and closing the connection.
+   mysql_open();
+   mysql_check();
+   mysql_close();
+
+   # start ibbackup as a child process
+   start_ibbackup();
+
+   # wait for ibbackup to suspend itself
+   if ( !$o->{'remote-host'} && !$o->{'stream'} ) {
+      wait_for_ibbackup_suspend();
+   }
+
+   if ( !$o->{'incremental'} ) {
+      mysql_open();
+      mysql_check();
+      mysql_lockall() unless $o->{'no-lock'};
+      backup_files();
+   }
+
+   # resume ibbackup and wait till it has finished
+   resume_ibbackup();
+
+   if ( !$o->{'incremental'} ) {
+      mysql_unlockall() unless $o->{'no-lock'};
+      mysql_close();
+   }
+
+   if ( $o->{'remote-host'} ) {
+      system_call("scp $o->{'scp-opt'} '$tmp_logfile' "
+         . "'$o->{'remote-host'}:$backup_dir/xtrabackup_logfile'");
+
+      system_call("rm -f '$tmp_logfile'");
+
+      system_call("scp $o->{'scp-opt'} '$orig_datadir/xtrabackup_checkpoints' "
+         . "'$o->{'remote-host'}:$backup_dir/xtrabackup_checkpoints'");
+
+      system_call("rm -f '$orig_datadir/xtrabackup_checkpoints'");
+   }
+   elsif ( $o->{'stream'} eq 'tar' ) {
+      system_call("cd $o->{'tmpdir'}; tar chf - xtrabackup_logfile");
+
+      system_call("rm -f '$tmp_logfile'");
+
+      system_call("cd $orig_datadir; tar chf - xtrabackup_checkpoints");
+
+      system_call("rm -f '$orig_datadir/xtrabackup_checkpoints'");
+   }
+
+   print STDERR "\n$prefix Backup created in directory "
+      . ($o->{'remote-host'} ? "$o->{'remote-host'}:" : '')
+      . "'$backup_dir'\n";
+
+   if ($mysql_binlog_position) {
+      print STDERR "$prefix MySQL binlog position: $mysql_binlog_position\n";
+   }
+   if ( $mysql_slave_position && $o->{'slave-info'} ) {
+      print STDERR "$prefix MySQL slave binlog position: "
+         . "$mysql_slave_position\n";
+   }
+
+   return;
+}
+
+#
+# are_equal_innodb_data_file_paths subroutine checks if the given
+# InnoDB data file option values are equal.
+#   Parameters:
+#     str1    InnoDB data file path option value
+#     str2    InnoDB data file path option value
+#   Return value:
+#     1  if values are equal
+#     0  otherwise
+#
+sub are_equal_innodb_data_file_paths {
+   my $str1   = shift;
+   my $str2   = shift;
+   my @array1 = split( /;/, $str1 );
+   my @array2 = split( /;/, $str2 );
+
+   if ( $#array1 != $#array2 ) { return 0; }
+
+   for ( my $i = 0; $i <= $#array1; $i++ ) {
+      my @def1 = split( /:/, $array1[$i] );
+      my @def2 = split( /:/, $array2[$i] );
+
+      if ( $#def1 != $#def2 ) { return 0; }
+
+      for ( my $j = 0; $j <= $#def1; $j++ ) {
+         if ( $def1[$j] ne $def2[$j] ) { return 0; }
+      }
+   }
+   return 1;
+}
+
+#
+# is_in_array subroutine checks if the given string is in the array.
+#   Parameters:
+#     str       a string
+#     array_ref a reference to an array of strings
+#   Return value:
+#     1  if string is in the array
+#     0  otherwise
+#
+sub is_in_array {
+   my $str       = shift;
+   my $array_ref = shift;
+
+   if ( grep { $str eq $_ } @{$array_ref} ) {
+      return 1;
+   }
+   return 0;
+}
+
+#
+# copy_back subroutine copies data and index files from backup directory
+# back to their original locations.
+#
+sub copy_back {
+   my $orig_datadir = get_option( \%config, 'mysqld', 'datadir' );
+   my $orig_ibdata_dir =
+      get_option( \%config, 'mysqld', 'innodb_data_home_dir' );
+   my $orig_innodb_data_file_path =
+      get_option( \%config, 'mysqld', 'innodb_data_file_path' );
+   my $orig_iblog_dir =
+      get_option( \%config, 'mysqld', 'innodb_log_group_home_dir' );
+   my $excluded_files =
+      '^(\.\.?|backup-my\.cnf|xtrabackup_logfile|mysql-std(err|out)|.*\.ibz)$';
+   my @ibdata_files;
+   my $iblog_files          = '^ib_logfile.*$';
+   my $compressed_data_file = '.*\.ibz$';
+   my $file;
+   my $backup_innodb_data_file_path;
+
+   # check that original data directory exists
+   if ( !-d $orig_datadir ) {
+      Die "Original data directory '$orig_datadir' does not exist!";
+   }
+
+   # check that original InnoDB data directory exists
+   if ( !-d $orig_ibdata_dir ) {
+      Die "Original InnoDB data directory '$orig_ibdata_dir' does not exist!";
+   }
+
+   # check that original InnoDB log directory exists
+   if ( !-d $orig_iblog_dir ) {
+      Die "Original InnoDB log directory '$orig_iblog_dir' does not exist!";
+   }
+
+   # check that the original options file and the backup options file have
+   # the same value for "innodb_data_file_path" option
+   #$backup_innodb_data_file_path =
+   #    get_option(\%backup_config, 'mysqld', 'innodb_data_file_path');
+   #if (!are_equal_innodb_data_file_paths($orig_innodb_data_file_path,
+   #                                      $backup_innodb_data_file_path)
+   #) {
+   #    Die "The value of 'innodb_data_file_path' option in the original "
+   #      . "my.cnf file '$config_file' is different from the value "
+   #      . "in the backup my.cnf file '$backup_config_file'.\n(original: "
+   #      . "'$orig_innodb_data_file_path')\n"
+   #      . "(backup:   '$backup_innodb_data_file_path')";
+   #}
+
+   # make a list of all ibdata files in the backup directory and all
+   # directories in the backup directory under which there are ibdata files
+   foreach my $a ( split( /;/, $orig_innodb_data_file_path ) ) {
+      my $path     = ( split( /:/,   $a ) )[0];
+      my $filename = ( split( /\/+/, $path ) )[-1];
+
+      # check that the backup data file exists
+      if ( !-e "$backup_dir/$filename" ) {
+         if ( -e "$backup_dir/${filename}.ibz" ) {
+            Die
+               "Backup data file '$backup_dir/$filename' does not exist, but "
+               . "its compressed copy '${path}.ibz' exists. Check that you "
+               . "have run '$innobackup_script --apply-log --uncompress "
+               . "...' before attempting '$innobackup_script --copy-back ...' !";
+         }
+         else {
+            Die "Backup data file '$backup_dir/$filename' does not exist.";
+         }
+      }
+
+      if ( !is_in_array( $filename, \@ibdata_files ) ) {
+         push( @ibdata_files, $filename );
+      }
+   }
+
+   # copy files from backup dir to their original locations
+
+   # copy files to original data directory
+   opendir( DIR, $backup_dir )
+      || Die "Can't open directory '$backup_dir': $OS_ERROR\n";
+   print STDERR "$prefix Starting to copy MyISAM tables, indexes,\n";
+   print STDERR
+      "$prefix .MRG, .TRG, .TRN, .ARM, .ARZ, .opt, and .frm files\n";
+   print STDERR "$prefix in '$backup_dir'\n";
+   print STDERR "$prefix back to original data directory '$orig_datadir'\n";
+   while ( defined( $file = readdir(DIR) ) ) {
+      if ( $file =~ /$excluded_files/ ) { next; }
+      if ( is_in_array( $file, \@ibdata_files ) ) { next; }
+      if ( $file =~ /$iblog_files/ ) { next; }
+      if ( -d "$backup_dir/$file" ) {
+         my $subdir = "$backup_dir/$file";
+         my $file2;
+
+         print STDERR "$prefix Copying directory '$subdir'\n";
+         if ( !-x "\"" . escape_path("$orig_datadir/$file") . "\"" ) {
+            system_call("mkdir \"" . escape_path("$orig_datadir/$file") . "\"");
+         }
+         opendir( SUBDIR, "$subdir" )
+            || Die "Can't open directory '$subdir': $OS_ERROR\n";
+         while ( defined( $file2 = readdir(SUBDIR) ) ) {
+            if ( -d "$subdir/$file2" ) { next; }
+            if ( $file2 =~ /$compressed_data_file/ ) { next; }
+            $src_name = escape_path("$subdir/$file2");
+            $dst_name = escape_path("$orig_datadir/$file");
+            system_call("$CP_CMD \"$src_name\" \"$dst_name\"");
+         }
+         closedir(SUBDIR);
+      }
+      else {
+         print STDERR "$prefix Copying file " . "'$backup_dir/$file'\n";
+         $src_name = escape_path("$backup_dir/$file");
+         $dst_name = escape_path("$orig_datadir");
+         system_call("$CP_CMD \"$src_name\" \"$dst_name\"");
+      }
+   }
+   closedir(DIR);
+
+   # copy InnoDB data files to original InnoDB data directory
+   print STDERR "\n$prefix Starting to copy InnoDB tables and indexes\n";
+   print STDERR "$prefix in '$backup_dir'\n";
+   print STDERR
+      "$prefix back to original InnoDB data directory '$orig_ibdata_dir'\n";
+   foreach my $a ( split( /;/, $orig_innodb_data_file_path ) ) {
+
+      # get the relative pathname of a data file
+      my $path     = ( split( /:/,   $a ) )[0];
+      my $filename = ( split( /\/+/, $path ) )[-1];
+      print STDERR "$prefix Copying file '$backup_dir/$filename'\n";
+      $src_name = escape_path("$backup_dir/$filename");
+      $dst_name = escape_path("$orig_ibdata_dir/$path");
+      system_call("$CP_CMD \"$src_name\" \"$dst_name\"");
+   }
+
+   # copy InnoDB log files to original InnoDB log directory
+   opendir( DIR, $backup_dir )
+      || Die "Can't open directory '$backup_dir': $OS_ERROR\n";
+   print STDERR "\n$prefix Starting to copy InnoDB log files\n";
+   print STDERR "$prefix in '$backup_dir'\n";
+   print STDERR
+      "$prefix back to original InnoDB log directory '$orig_iblog_dir'\n";
+   while ( defined( $file = readdir(DIR) ) ) {
+      if ( $file =~ /$iblog_files/ && -f "$backup_dir/$file" ) {
+         print STDERR "$prefix Copying file '$backup_dir/$file'\n";
+         $src_name = escape_path("$backup_dir/$file");
+         $dst_name = escape_path("$orig_iblog_dir");
+         system_call("$CP_CMD \"$src_name\" \"$dst_name\"");
+      }
+   }
+   closedir(DIR);
+
+   print STDERR "$prefix Finished copying back files.\n\n";
+
+   return;
+}
+
+#
+# apply_log subroutine prepares a backup for starting database server
+# on the backup. It applies InnoDB log files to the InnoDB data files.
+#
+sub apply_log {
+   my $rcode;
+   my $cmdline = '';
+   my $options = '';
+
+   if ( $o->{'defaults-file'} ) {
+      $options = $options . " --defaults-file=\"$o->{'defaults-file'}\" ";
+   }
+
+   $options = $options . "--prepare --target-dir=$backup_dir";
+
+   if ( $o->{'uncompress'} ) {
+      $options = $options . ' --uncompress';
+   }
+   if ( $o->{'export'} ) {
+      $options = $options . ' --export';
+   }
+   if ( $o->{'use-memory'} ) {
+      $options = $options . " --use-memory=$o->{'use-memory'}";
+   }
+
+   # run ibbackup as a child process
+   $cmdline = "$o->{'ibbackup'} $options";
+   $now     = current_time();
+   print STDERR "\n$now  $prefix Starting ibbackup with command: $cmdline\n\n";
+   $rcode = system_call($cmdline, 1);
+   Die "\n$prefix ibbackup failed" if $rcode;
+
+   $now = current_time();
+   print STDERR
+      "\n$now  $prefix Restarting xtrabackup with command: $cmdline\nfor creating ib_logfile*\n\n";
+   $rcode = system_call($cmdline, 1);
+   Die "\n$prefix xtrabackup (2nd execution) failed" if $rcode;
+
+   return;
+}
+
+#
+# wait_for_ibbackup_suspend subroutine waits until ibbackup has suspended
+# itself.
+#
+sub wait_for_ibbackup_suspend {
+   print STDERR
+      "$prefix Waiting for ibbackup (pid=$ibbackup_pid) to suspend\n";
+   print STDERR "$prefix Suspend file '$suspend_file'\n\n";
+   for ( ;; ) {
+      sleep 2;
+      last if -e $suspend_file;
+
+      # check that ibbackup child process is still alive
+      if ( $ibbackup_pid == waitpid( $ibbackup_pid, &WNOHANG ) ) {
+         $ibbackup_pid = '';
+         Die "ibbackup child process has died";
+      }
+   }
+   $now = current_time();
+   print STDERR "\n$now  $prefix Continuing after ibbackup has suspended\n";
+}
+
+#
+# resume_ibbackup subroutine signals ibbackup to complete its execution
+# by deleting the 'ibbackup_suspended' file.
+#
+sub resume_ibbackup {
+   print STDERR "$prefix Resuming ibbackup\n\n";
+   unlink $suspend_file || Die "Failed to delete '$suspend_file': $OS_ERROR";
+
+   # wait for ibbackup to finish
+   waitpid( $ibbackup_pid, 0 );
+   $ibbackup_pid = '';
+}
+
+#
+# start_ibbackup subroutine spawns a child process running ibbackup
+# program for backing up InnoDB tables and indexes.
+#
+sub start_ibbackup {
+   my $options = '';
+   my $cmdline = '';
+   my $pid     = undef;
+
+   if ( $o->{'defaults-file'} ) {
+      $options = $options . " --defaults-file=\"$o->{'defaults-file'}\" ";
+   }
+
+   $options = $options . "--backup --suspend-at-end";
+
+   if ( !$o->{'remote-host'} && !$o->{'stream'} ) {
+      $options = $options . " --target-dir=$backup_dir";
+   }
+   else {
+
+      #(datadir) for 'xtrabackup_suspended' and 'xtrabackup_checkpoints'
+      $options = $options . " --log-stream --target-dir=./";
+   }
+
+   # prepare command line for running ibbackup
+   if ( $o->{'throttle'} ) {
+      $options = $options . " --throttle=$o->{'throttle'}";
+   }
+   if ( $o->{'sleep'} ) {
+      $options = $options . " --sleep=$o->{'sleep'}";
+   }
+   if ( $o->{'compress'} ) {
+      $options = $options . " --compress=$o->{'compress'}";
+   }
+   if ( $o->{'use-memory'} ) {
+      $options = $options . " --use-memory=$o->{'use-memory'}";
+   }
+   if ( $o->{'include'} ) {
+      $options = $options . " --tables='$o->{'include'}'";
+   }
+   if ( $o->{'incremental'} ) {
+      $options = $options . " --incremental-basedir='$incremental_basedir'";
+   }
+   $cmdline = "$o->{'ibbackup'} $options";
+
+   # run ibbackup as a child process
+   $now = current_time();
+   print STDERR "\n$now  $prefix Starting ibbackup with command: $cmdline\n";
+   if ( defined($pid = fork) ) {
+      if ($pid) {
+         # parent process
+         $ibbackup_pid = $pid;
+
+         # direct copy to remote
+         if ( $o->{'remote-host'} || $o->{'stream'} ) {
+            my $orig_datadir
+               = get_option( \%config, 'mysqld', 'datadir' );
+            my $orig_ibdata_dir
+               = get_option( \%config, 'mysqld', 'innodb_data_home_dir' );
+            my $orig_innodb_data_file_path
+               = get_option( \%config, 'mysqld', 'innodb_data_file_path' );
+            my $subdir;
+            my @list;
+
+            if ( $o->{'remote-host'} ) {
+               if ( system_call("ssh $o->{'remote-host'} test -e "
+                        . "$backup_dir/ib_logfile0", 1) == 0 ) {
+                  print STDERR "$prefix Remove "
+                     . "$o->{'remote-host'}:$backup_dir/ib_logfile*\n";
+                  system_call( "ssh $o->{'remote-host'} "
+                     . "rm $backup_dir/ib_logfile\*"
+                  )
+               }
+            }
+
+            wait_for_ibbackup_suspend();
+
+            #InnoDB data files from original InnoDB data directory
+            print STDERR
+               "\n$prefix Starting to backup InnoDB tables and indexes\n";
+            if ( $o->{'remote-host'} ) {
+               print STDERR "$prefix to '$backup_dir'\n";
+            }
+            print STDERR
+               "$prefix from original InnoDB data directory '$orig_ibdata_dir'\n";
+            foreach my $a ( split( /;/, $orig_innodb_data_file_path ) ) {
+               my $path = ( split( /:/, $a ) )[0];
+               $path =~ s/([\$\\\" ])/\\$1/g;
+               if ( $o->{'remote-host'} ) {
+                  print STDERR
+                     "$prefix Backing up file '$orig_ibdata_dir/$path'\n";
+                  system_call("scp $o->{'scp-opt'} '$orig_ibdata_dir/$path' "
+                     . "'$o->{'remote-host'}:$backup_dir/$path'");
+               }
+               elsif ( $o->{'stream'} eq 'tar' ) {
+                  my $ret = 0;
+                  print STDERR "$prefix Backing up as tar stream '$path'\n";
+                  if ( !$o->{'tar4ibd'} ) {
+                     $ret = system_call(
+                        "cd $orig_ibdata_dir; tar chf - -b 32 $path", 1);
+                  }
+                  else {
+                     $ret = system_call(
+                        "cd $orig_ibdata_dir; tar4ibd -c $path", 1);
+                  }
+                  if ( $ret == 1 ) {
+                     print STDERR "$prefix If you use GNU tar, this warning "
+                        . "can be ignored.\n";
+                  }
+                  elsif ( $ret != 0 ) {
+                     print STDERR "$prefix tar returned with exit code $ret.\n";
+                     Die "Failed to stream '$path': $OS_ERROR";
+                  }
+               }
+            }
+
+            #copy *.ibd files
+            opendir( DIR, $orig_datadir )
+               || Die "Can't open directory '$orig_datadir': $OS_ERROR\n";
+            while ( defined( $subdir = readdir(DIR) ) ) {
+               my $print_each_file = 0;
+               my $file_c;
+               my $file;
+               if ( $subdir eq '.' || $subdir eq '..' ) { next; }
+               next unless -d "$orig_datadir/$subdir";
+               next unless check_if_required($subdir);
+
+               @list = glob( "$orig_datadir/$subdir/" . '*.ibd' );
+
+               $file_c = @list;
+               if ( $file_c <= $backup_file_print_limit ) {
+                  $print_each_file = 1;
+               }
+               else {
+                  print STDERR "$prefix Backing up files "
+                     . "'$orig_datadir/$subdir/*.ibd' ($file_c files)\n";
+               }
+
+               foreach $file ( @list ) {
+                  if ( $o->{'include'} ) {
+                     my $table_name;
+                     $table_name = substr($file, rindex( $file, '/' ));
+                     $table_name = substr( $table_name, 1,
+                        rindex( $table_name, '.' ) - 1);
+                     $table_name = $subdir . "." . $table_name;
+                     if ( $table_name !~ m/$o->{'include'}/o ) {
+                        print STDERR "'$file' is skipped.\n";
+                        next;
+                     }
+                  }
+
+                  if ($print_each_file) {
+                     print STDERR "$prefix Backing up file '$file'\n";
+                  }
+
+                  if ( $o->{'remote-host'} ) {
+                     system_call(
+                        "ssh $o->{'remote-host'} mkdir '$backup_dir/$subdir'",
+                        1  # don't die on failure
+                     );
+                     system_call("scp $o->{'scp-opt'} '$file' "
+                        . "'$o->{'remote-host'}:$backup_dir/$subdir/'");
+                  }
+                  elsif ( $o->{'stream'} eq 'tar' ) {
+                     my $ret       = 0;
+                     my $file_name = substr($file, rindex( $file, '/' ) + 1);
+                     $file_name    =~ s/([\$\\\" ])/\\$1/g;
+
+                     if ( !$o->{'tar4ibd'} ) {
+                        $ret = system_call("cd $orig_datadir; tar chf - -b 32 "
+                           . "$subdir/$file_name", 1);
+                     }
+                     else {
+                        $ret = system_call("cd $orig_datadir; tar4ibd -c "
+                           . "$subdir/$file_name", 1);
+                     }
+
+                     if ( $ret == 1 ) {
+                        print STDERR "$prefix If you use GNU tar, this warning "
+                           . "can be ignored.\n";
+                     }
+                     elsif ( $ret != 0 ) {
+                        print STDERR "$prefix tar returned with exit code "
+                           . "$ret.\n";
+                        Die "Failed to stream '$subdir/$file_name': $OS_ERROR";
+                     }
+                  }
+               }  # each file
+            }  # each subdir
+            closedir(DIR);
+         }
+      }  # parent process
+      else {  # child process
+         if ( $o->{'remote-host'} || $o->{'stream'} ) {
+            open STDOUT, "> $tmp_logfile"
+               or Die "Failed to open file '$tmp_logfile': $OS_ERROR";
+         }
+         IBEXDEBUG && _d($cmdline);
+         exec($cmdline) or Die "Failed to exec ibbackup: $OS_ERROR";
+      }
+   }
+   else {
+      Die "failed to fork ibbackup child process: $OS_ERROR";
+   }
+}
+
+#
+# get_mysql_options subroutine returns the options to mysql client program
+# as a string. The options are determined from the options given by the
+# user to innobackup.
+#
+sub get_mysql_options {
+   my @options;
+
+   # --defaults-file needs to be first.
+   if ( $o->{'defaults-file'} ) {
+      push @options, "--defaults-file=$o->{'defaults-file'}";
+   }
+
+   if ( $o->{'host'} ) {
+      push @options, "--host=$o->{'host'}";
+   }
+   if ( $o->{'port'} ) {
+      push @options, "--port=$o->{'port'}";
+   }
+   if ( $o->{'user'} ) {
+      push @options, "--user=$o->{'user'}";
+   }
+   if ( $o->{'password'} ) {
+      push @options, "--password=$o->{'password'}";
+   }
+   if ( $o->{'socket'} ) {
+      push @options, "--socket=$o->{'socket'}";
+   }
+
+   push @options, '--unbuffered --';
+
+   my $options = join( ' ', @options );
+   IBEXDEBUG && _d('mysql options:', $options);
+   return $options;
+}
+
+#
+# mysql_open subroutine starts mysql as a child process with
+# a pipe connection.
+#
+sub mysql_open {
+   my $options = get_mysql_options();
+
+   # run mysql as a child process with a pipe connection
+   $now = current_time();
+   print STDERR "$now  $prefix Starting mysql with options: $options\n";
+   $mysql_pid = open(*MYSQL_WRITER,
+      "| mysql $options >$mysql_stdout 2>$mysql_stderr ")
+      or Die "Failed to spawn mysql child process: $OS_ERROR";
+   MYSQL_WRITER->autoflush(1);
+   $now = current_time();
+   print STDERR "$now  $prefix Connected to database with mysql child process (pid=$mysql_pid)\n";
+
+   return;
+}
+
+#
+# mysql_check subroutine checks that the connection to mysql child process
+# is ok.
+#
+sub mysql_check {
+   my $mysql_pid_copy = $mysql_pid;
+
+   # send a dummy query to mysql child process
+   $hello_id++;
+   my $hello_message = "innobackup hello $hello_id";
+   IBEXDEBUG && _d('mysql check:', $hello_message);
+   print MYSQL_WRITER "select '$hello_message';\n"
+      or Die "Connection to mysql child process failed: $OS_ERROR";
+
+   # wait for reply
+   eval {
+      local $SIG{ALRM} = sub { die "alarm clock restart" };
+      my $stdout = '';
+      my $stderr = '';
+      alarm $mysql_response_timeout;
+      while ( index( $stdout, $hello_message ) < 0 ) {
+         sleep 2;
+         if ( $mysql_pid && $mysql_pid == waitpid( $mysql_pid, &WNOHANG ) ) {
+            my $reason = `cat $mysql_stderr`;
+            $mysql_pid = '';
+            die "mysql child process has died: $reason";
+         }
+         $stdout = `cat $mysql_stdout`;
+         $stderr = `cat $mysql_stderr`;
+         if ($stderr) {
+            # mysql has reported an error, do exit
+            die "mysql error: $stderr";
+         }
+      }
+      alarm 0;
+   };
+   if ( $EVAL_ERROR =~ /alarm clock restart/ ) {
+      Die "Connection to mysql child process (pid=$mysql_pid_copy) timedout."
+         . " (Time limit of $mysql_response_timeout seconds exceeded."
+         . " You may adjust time limit by editing the value of parameter"
+         . " \"\$mysql_response_timeout\" in this script.)";
+   }
+   elsif ( $EVAL_ERROR ) {
+      Die $EVAL_ERROR;
+   }
+
+   $mysql_last_access_time = time();
+
+   return;
+}
+
+#
+# mysql_keep_alive subroutine tries to keep connection to the mysqld database
+# server alive by sending a dummy query when the connection has been idle
+# for the specified time.
+#
+sub mysql_keep_alive {
+   if ( ( time() - $mysql_last_access_time ) > $mysql_keep_alive_timeout ) {
+      # too long idle, send a dummy query
+      mysql_check();
+   }
+   return;
+}
+
+#
+# mysql_send subroutine send a request string to mysql child process.
+# This subroutine appends a newline character to the request and checks
+# that mysqld receives the query.
+# Parameters:
+#    request  request string
+#
+sub mysql_send {
+   my $request = shift;
+   $current_mysql_request = $request;
+   print MYSQL_WRITER "$request\n";
+   mysql_check();
+   $current_mysql_request = '';
+   return;
+}
+
+#
+# mysql_close subroutine terminates mysql child process gracefully.
+#
+sub mysql_close {
+   print MYSQL_WRITER "quit\n";
+   $now = current_time();
+   print STDERR "$now  $prefix Connection to database server closed\n";
+   $mysql_pid = '';
+   return;
+}
+
+#
+# write_binlog_info subroutine retrieves MySQL binlog position and
+# saves it in a file. It also prints it to stdout.
+#
+sub write_binlog_info {
+   my @lines;
+   my @info_lines = ();
+   my $position   = '';
+   my $filename   = '';
+
+   # get binlog position
+   mysql_send "SHOW MASTER STATUS;";
+
+   # get "show master status" output lines (2) from mysql output
+   file_to_array( $mysql_stdout, \@lines );
+   foreach my $line (@lines) {
+      if ( $line =~ m/innobackup hello/ ) {
+
+         # this is a hello message, ignore it
+      }
+      else {
+
+         # this is output line from "show master status"
+         push( @info_lines, $line );
+      }
+   }
+
+   # write binlog info file
+   if ( !defined $info_lines[1] ) {
+      $info_lines[1] = "";
+   }
+   if ( !$o->{'remote-host'} ) {
+      open( FILE, ">$binlog_info" )
+         || Die "Failed to open file '$binlog_info': $OS_ERROR";
+   }
+   else {
+      open( FILE, "| ssh $o->{'remote-host'} 'cat > $binlog_info'" )
+         || Die
+         "Failed to open file '$o->{'remote-host'}:$binlog_info': $OS_ERROR";
+   }
+   print FILE "$info_lines[1]\n";
+   close(FILE);
+
+   if ( $o->{'stream'} eq 'tar' ) {
+      system_call("cd $o->{'tmpdir'}; tar chf - xtrabackup_binlog_info");
+      unlink $binlog_info or Die "Failed to delete '$binlog_info': $OS_ERROR";
+   }
+
+   # get the name of the last binlog file and position in it
+   ( $filename, $position ) = $info_lines[1] =~ /^\s*([^\s]+)\s+(.*)$/;
+
+   if ( defined $filename && defined $position ) {
+      $mysql_binlog_position = "filename '$filename', position $position";
+   }
+   else {
+      $mysql_binlog_position = "filename '', position ";
+   }
+
+   return;
+}
+
+#
+# write_slave_info subroutine retrieves MySQL binlog position of the
+# master server in a replication setup and saves it in a file. It
+# also saves it in $msql_slave_position variable.
+#
+sub write_slave_info {
+   my @lines;
+   my @info_lines;
+   my $position = '';
+   my $filename = '';
+   my $master   = '';
+
+   # get slave status. Use single quotes here, otherwise
+   # \G is evaluated as a control character.
+   mysql_send 'SHOW SLAVE STATUS\G;';
+
+   # get output of the "show slave status" command from mysql output
+   # and extract binlog position of the master server
+   file_to_array( $mysql_stdout, \@lines );
+   for (@lines) {
+      $master   = $1 if /Master_Host:\s*(\S*)\s*$/;
+      $filename = $1 if /Master_Log_File:\s*(\S*)\s*$/;
+      $position = $1 if /Master_Log_Pos:\s*(\S*)\s*$/;
+   }
+
+   # print slave status to a file
+   if ( !$o->{'remote-host'} ) {
+      open( FILE, ">$slave_info" )
+         || Die "Failed to open file '$slave_info': $OS_ERROR";
+   }
+   else {
+      open( FILE, "| ssh $o->{'remote-host'} 'cat > $slave_info'" )
+         || Die
+         "Failed to open file '$o->{'remote-host'}:$slave_info': $OS_ERROR";
+   }
+   print FILE
+      "CHANGE MASTER TO MASTER_LOG_FILE='$filename', MASTER_LOG_POS=$position\n";
+   close(FILE);
+
+   if ( $o->{'stream'} eq 'tar' ) {
+      system_call("cd $o->{'tmpdir'}; tar chf - xtrabackup_slave_info");
+      unlink $slave_info or Die "Failed to delete '$slave_info': $OS_ERROR";
+   }
+
+   $mysql_slave_position =
+      "master host '$master', filename '$filename', position $position";
+
+   return;
+}
+
+#
+# mysql_lockall subroutine puts a read lock on all tables in all databases.
+#
+sub mysql_lockall {
+   $now = current_time();
+   print STDERR "$now  $prefix Starting to lock all tables...\n";
+
+   mysql_send "USE mysql;";
+
+#    mysql_send "DROP TABLE IF EXISTS ibbackup_binlog_marker;";
+#    if (compare_versions($mysql_server_version, '4.1.0') == -1) {
+#        # MySQL server version is 4.0 or older, ENGINE keyword not supported
+#        mysql_send "CREATE TABLE ibbackup_binlog_marker(a INT) TYPE=INNODB;";
+#    } else {
+#        # MySQL server version is 4.1 or newer, use ENGINE keyword
+#        mysql_send "CREATE TABLE ibbackup_binlog_marker(a INT) ENGINE=INNODB;";
+#    }
+   mysql_send "SET AUTOCOMMIT=0;";
+
+   #    mysql_send "INSERT INTO ibbackup_binlog_marker VALUES (1);";
+   if (  compare_versions( $mysql_server_version, '4.0.22' ) == 0
+      || compare_versions( $mysql_server_version, '4.1.7' ) == 0 )
+   {
+
+      # MySQL server version is 4.0.22 or 4.1.7
+      mysql_send "COMMIT;";
+      mysql_send "FLUSH TABLES WITH READ LOCK;";
+   }
+   else {
+
+      # MySQL server version is other than 4.0.22 or 4.1.7
+      mysql_send "FLUSH TABLES WITH READ LOCK;";
+      mysql_send "COMMIT;";
+   }
+   write_binlog_info;
+   write_slave_info if $o->{'slave-info'};
+
+   $now = current_time();
+   print STDERR "$now  $prefix All tables locked and flushed to disk\n";
+
+   return;
+}
+
+#
+# mysql_unlockall subroutine releases read locks on all tables in all
+# databases.
+#
+sub mysql_unlockall {
+   mysql_send "UNLOCK TABLES;";
+
+   #    mysql_send "DROP TABLE IF EXISTS ibbackup_binlog_marker;";
+
+   $now = current_time();
+   print STDERR "$now  $prefix All tables unlocked\n";
+}
+
+#
+# catch_sigpipe subroutine is a signal handler for SIGPIPE.
+#
+sub catch_sigpipe {
+   my $rcode;
+
+   if (
+      $mysql_pid
+      && ( -1 == ( $rcode = waitpid( $mysql_pid, &WNOHANG ) )
+         || $rcode == $mysql_pid )
+      )
+   {
+      my $reason = `cat $mysql_stderr`;
+      print STDERR "Pipe to mysql child process broken: $reason at";
+      system("date +'%H:%M:%S'");
+      exit(1);
+   }
+   else {
+      Die "Broken pipe";
+   }
+}
+
+#
+# kill_child_processes subroutine kills all child processes of this process.
+#
+sub kill_child_processes {
+   if ($ibbackup_pid) {
+      kill( $kill_signal, $ibbackup_pid );
+      $ibbackup_pid = '';
+   }
+
+   if ($mysql_pid) {
+      kill( $kill_signal, $mysql_pid );
+      $mysql_pid = '';
+   }
+}
+
+#
+# require_external subroutine checks that an external program is runnable
+# via the shell. This is tested by calling the program with the
+# given arguments. It is checked that the program returns 0 and does
+# not print anything to stderr. If this check fails, this subroutine exits.
+#    Parameters:
+#       program      pathname of the program file
+#       args         arguments to the program
+#       pattern      a string containing a regular expression for finding
+#                    the program version.
+#                    this pattern should contain a subpattern enclosed
+#                    in parentheses which is matched with the version.
+#       version_ref  a reference to a variable where the program version
+#                    string is returned. Example "2.0-beta2".
+#
+sub require_external {
+   my $program     = shift;
+   my $args        = shift;
+   my $pattern     = shift;
+   my $version_ref = shift;
+   my @lines;
+   my $tmp_stdout = tmpnam();
+   my $tmp_stderr = tmpnam();
+   my $rcode;
+   my $error;
+
+   $rcode = system_call("$program $args >$tmp_stdout 2>$tmp_stderr", 1);
+   if ($rcode) {
+      $error = $OS_ERROR;
+   }
+   my $stderr = `cat $tmp_stderr`;
+   unlink $tmp_stderr;
+   if ( $stderr ne '' ) {
+
+      # failure
+      unlink $tmp_stdout;
+      Die "Couldn't run $program: $stderr";
+   }
+   elsif ($rcode) {
+
+      # failure
+      unlink $tmp_stdout;
+      Die "Couldn't run $program: $error";
+   }
+
+   # success
+   my $stdout = `cat $tmp_stdout`;
+   unlink $tmp_stdout;
+   @lines = split( /\n|;/, $stdout );
+   print STDERR "$prefix Using $lines[0]\n";
+
+   # get version string from the first output line of the program
+   ${$version_ref} = '';
+   if ( $lines[0] =~ /$pattern/ ) {
+      ${$version_ref} = $1;
+   }
+}
+
+# compare_versions subroutine compares two GNU-style version strings.
+# A GNU-style version string consists of three decimal numbers delimitted
+# by dots, and optionally followed by extra attributes.
+# Examples: "4.0.1", "4.1.1-alpha-debug".
+#    Parameters:
+#       str1   a GNU-style version string
+#       str2   a GNU-style version string
+#    Return value:
+#       -1   if str1 < str2
+#        0   if str1 == str2
+#        1   is str1 > str2
+sub compare_versions {
+   my $str1   = shift;
+   my $str2   = shift;
+   my $extra1 = '';
+   my $extra2 = '';
+   my @array1 = ();
+   my @array2 = ();
+   my $i;
+
+   # remove possible extra attributes
+   ( $str1, $extra1 ) = $str1 =~ /^([0-9.]*)(.*)/;
+   ( $str2, $extra2 ) = $str2 =~ /^([0-9.]*)(.*)/;
+
+   # split "dotted" decimal number string into an array
+   @array1 = split( '\.', $str1 );
+   @array2 = split( '\.', $str2 );
+
+   # compare in lexicographic order
+   for ( $i = 0; $i <= $#array1 && $i <= $#array2; $i++ ) {
+      if ( $array1[$i] < $array2[$i] ) {
+         return -1;
+      }
+      elsif ( $array1[$i] > $array2[$i] ) {
+         return 1;
+      }
+   }
+   if ( $#array1 < $#array2 ) {
+      return -1;
+   }
+   elsif ( $#array1 > $#array2 ) {
+      return 1;
+   }
+   else {
+      return 0;
+   }
+}
+
+#
+# init subroutine initializes global variables and performs some checks on the
+# system we are running on.
+#
+sub init {
+   my $mysql_version    = '';
+   my $ibbackup_version = '';
+   my $run              = '';
+
+   # print some instructions to the user
+   if ( !$o->{'apply-log'} && !$o->{'copy-back'} ) {
+      $run = 'backup';
+   }
+   elsif ( $o->{'copy-back'} ) {
+      $run = 'copy-back';
+   }
+   else {
+      $run = 'apply-log';
+   }
+   print STDERR
+      "IMPORTANT: Please check that the $run run completes successfully.\n";
+   print STDERR
+      "           At the end of a successful $run run $innobackup_script\n";
+   print STDERR "           prints \"completed OK!\".\n\n";
+
+   # check that MySQL client program and InnoDB Hot Backup program
+   # are runnable via shell
+   if ( !$o->{'copy-back'} ) {
+
+      # we are making a backup or applying log to backup
+      if ( !$o->{'apply-log'} ) {
+
+         # we are making a backup, we need mysql server
+         my $output = '';
+         my @lines  = ();
+
+         # check that we have mysql client program
+         require_external( 'mysql', '--version', 'Ver ([^,]+)',
+            \$mysql_version );
+
+         # get mysql server version
+         my $options = get_mysql_options();
+         @lines = split( '\n', `mysql $options -e "select \@\@version"` );
+         $mysql_server_version = $lines[1];
+         print STDERR
+            "$prefix Using mysql server version $mysql_server_version\n";
+      }
+
+      #require_external($o->{'ibbackup-binary'}, '--license',
+      #                 'version (\S+)', \$ibbackup_version);
+      print STDERR "\n";
+
+      if (  $o->{'include'}
+         && $ibbackup_version
+         && $ibbackup_version le "2.0" )
+      {
+
+         # --include option was given, but ibbackup is too
+         # old to support it
+         Die "--include option was given, but ibbackup is too old"
+            . " to support it. You must upgrade to InnoDB Hot Backup"
+            . " v2.0 in order to use --include option.\n";
+      }
+   }
+
+   # set signal handlers
+   $SIG{PIPE} = \&catch_sigpipe;
+
+   # read MySQL options file
+   #read_config_file($config_file, \%config);
+   read_config_file( \%config );
+
+   if ( !$o->{'tmpdir'} ) {
+      $o->{'tmpdir'} = get_option( \%config, 'mysqld', 'tmpdir' );
+   }
+
+   # get innodb log home directory from options file
+   #$innodb_log_group_home_dir =
+   #    get_option(\%config, 'mysqld', 'innodb_log_group_home_dir');
+
+   if ( !$o->{'apply-log'} && !$o->{'copy-back'} ) {
+
+      # we are making a backup, create a new backup directory
+      if ( !$o->{'remote-host'} ) {
+         $backup_dir = File::Spec->rel2abs( make_backup_dir() );
+      }
+      else {
+         $backup_dir = make_backup_dir();
+      }
+      print STDERR "$prefix Created backup directory $backup_dir\n";
+      if ( !$o->{'remote-host'} && !$o->{'stream'} ) {
+         $backup_config_file = $backup_dir . '/backup-my.cnf';
+         $suspend_file       = $backup_dir . '/xtrabackup_suspended';
+         $mysql_stdout       = $backup_dir . '/mysql-stdout';
+         $mysql_stderr       = $backup_dir . '/mysql-stderr';
+         $binlog_info        = $backup_dir . '/xtrabackup_binlog_info';
+         $slave_info         = $backup_dir . '/xtrabackup_slave_info';
+      }
+      else {
+         $suspend_file = get_option( \%config, 'mysqld', 'datadir' )
+            . '/xtrabackup_suspended';
+         $tmp_logfile  = $o->{'tmpdir'} . '/xtrabackup_logfile';
+         $mysql_stdout = $o->{'tmpdir'} . '/mysql-stdout';
+         $mysql_stderr = $o->{'tmpdir'} . '/mysql-stderr';
+         if ( $o->{'stream'} ) {
+            $backup_config_file = $o->{'tmpdir'} . '/backup-my.cnf';
+            $binlog_info        = $o->{'tmpdir'} . '/xtrabackup_binlog_info';
+            $slave_info         = $o->{'tmpdir'} . '/xtrabackup_slave_info';
+         }
+         else {
+            $backup_config_file = $backup_dir . '/backup-my.cnf';
+            $binlog_info        = $backup_dir . '/xtrabackup_binlog_info';
+            $slave_info         = $backup_dir . '/xtrabackup_slave_info';
+         }
+      }
+      write_backup_config_file($backup_config_file);
+   }
+   elsif ( $o->{'copy-back'} ) {
+      #$backup_config_file = $backup_dir . '/backup-my.cnf';
+      #read_config_file($backup_config_file, \%backup_config);
+   }
+
+   return;
+}
+
+#
+# write_backup_config_file subroutine creates a backup options file for
+# ibbackup program. It writes to the file only those options that
+# are required by ibbackup.
+#    Parameters:
+#       filename  name for the created options file
+#
+sub write_backup_config_file {
+   my $filename = shift;
+   my $innodb_data_file_path =
+      get_option( \%config, 'mysqld', 'innodb_data_file_path' );
+   my $innodb_log_files_in_group =
+      get_option( \%config, 'mysqld', 'innodb_log_files_in_group' );
+   my $innodb_log_file_size =
+      get_option( \%config, 'mysqld', 'innodb_log_file_size' );
+   my $root;
+
+   my @array = split( /;/, $innodb_data_file_path );
+   for ( my $i = 0; $i <= $#array; $i++ ) {
+      my @tmp = split( /\/+/, $array[$i] );
+      $array[$i] = $tmp[-1];
+   }
+   $innodb_data_file_path = join( ";", @array );
+
+   if ( !$o->{'remote-host'} ) {
+      $root = $backup_dir;
+      open( FILE, "> $filename" )
+         || Die "Failed to open file '$filename': $OS_ERROR";
+   }
+   else {
+      $root = `ssh $o->{'remote-host'} 'cd $backup_dir; pwd'`;
+      open( FILE, "| ssh $o->{'remote-host'} 'cat > $filename'" )
+         || Die
+         "Failed to open file '$o->{'remote-host'}:$filename': $OS_ERROR";
+   }
+
+   print FILE
+      "# This MySQL options file was generated by $innobackup_script.\n\n"
+      . "# The MySQL server\n"
+      . "[mysqld]\n"
+      . "datadir=$root\n"
+      . "innodb_data_home_dir=$root\n"
+      . "innodb_data_file_path=$innodb_data_file_path\n"
+      . "innodb_log_group_home_dir=$root\n"
+      . "innodb_log_files_in_group=$innodb_log_files_in_group\n"
+      . "innodb_log_file_size=$innodb_log_file_size\n";
+   close(FILE);
+
+   if ( $o->{'stream'} ) {
+      my $filename_dir  = dirname($filename);
+      my $filename_name = basename($filename);
+      if ( $o->{'stream'} eq 'tar' ) {
+         system_call("cd $filename_dir; tar chf - $filename_name");
+      }
+      unlink $filename or Die "Failed to delete '$filename': $OS_ERROR";
+   }
+}
+
+#
+# check_args subroutine checks command line arguments. If there is a problem,
+# this subroutine prints error message and exits.
+#
+sub check_args {
+   my $i;
+   my $rcode;
+   my $buf;
+   my $perl_version;
+
+   # check the version of the perl we are running
+   if ( !defined $PERL_VERSION ) {
+
+      # this perl is prior to 5.6.0 and uses old style version string
+      my $required_version = $required_perl_version_old_style;
+      if ( $] lt $required_version ) {
+         print STDERR "$prefix Warning: "
+            . "Your perl is too old! Innobackup requires\n";
+         print STDERR "$prefix Warning: perl $required_version or newer!\n";
+      }
+   }
+   else {
+      $perl_version = 'v' . join( '.', @required_perl_version );
+      if ( $PERL_VERSION lt $perl_version ) {
+         my $version =
+              chr( 48 + $required_perl_version[0] ) . "."
+            . chr( 48 + $required_perl_version[1] ) . "."
+            . chr( 48 + $required_perl_version[2] );
+         print STDERR "$prefix Warning: "
+            . "Your perl is too old! Innobackup requires\n";
+         print STDERR "$prefix Warning: perl $version or newer!\n";
+      }
+   }
+
+   if ( @ARGV == 0 ) {
+
+      # no command line arguments
+      usage();
+      exit(1);
+   }
+
+   # read command line options
+   $rcode = GetOptions(
+      $o,
+      'compress:i',
+      'help',        
+      'version',
+      'throttle=i',
+      'sleep=i',
+      'apply-log',
+      'copy-back',
+      'include=s',
+      'databases=s',
+      'use-memory=s',
+      'uncompress',
+      'export',
+      'password=s',
+      'host=s',
+      'user=s',
+      'port=s',
+      'slave-info',
+      'socket=s', 
+      'no-timestamp',
+      'defaults-file=s',
+      'incremental',
+      'remote-host=s',
+      'stream=s',
+      'tmpdir=s',
+      'no-lock',
+      'ibbackup=s',
+      'scpopt=s',
+   );
+
+   if ( !$rcode ) {
+      print STDERR "$prefix Bad command line arguments\n";
+      exit 1;
+   }
+
+   if ( $o->{'help'} ) {
+      # print help text and exit
+      usage();
+      exit 1;
+   }
+
+   if ( $o->{'version'} ) {
+      # print program version and copyright
+      print_version();
+      exit 0;
+   }
+
+   if ( $o->{'compress'} == 0 ) {
+      # compression level no specified, use default level
+      $o->{'compress'} = $default_compression_level;
+   }
+
+   if ( $o->{'compress'} == 999 ) {
+      # compress option not given in the command line
+      $o->{'compress'} = 0;
+   }
+
+   if ( @ARGV < 1 ) {
+      print STDERR "$prefix Missing command line argument\n";
+      usage();
+      exit(1);
+   }
+   elsif ( @ARGV > 1 ) {
+      print STDERR "$prefix Too many command line arguments\n";
+      usage();
+      exit(1);
+   }
+
+   if ( $o->{'stream'} ) {
+      if ( $o->{'stream'} eq 'tar' ) {
+      }
+      elsif ( $o->{'stream'} eq 'tar4ibd' ) {
+         $o->{'stream'}  = 'tar';
+         $o->{'tar4ibd'} = 'tar4ibd';
+      }
+      elsif ( $o->{'stream'} eq 'cpio' ) {
+         print STDERR "$prefix --stream=cpio is not supported yet\n";
+         exit 1;
+      }
+      else {
+         print STDERR "$prefix Unknown option --stream=$o->{'stream'}\n";
+         exit 1;
+      }
+   }
+
+   # get options file name
+   #$config_file = $ARGV[0];
+
+   if ( !$o->{'apply-log'} && !$o->{'copy-back'} ) {
+      # we are making a backup, get backup root directory
+      $backup_root = $ARGV[0];
+      if ( $o->{'incremental'} ) {
+         if ( $o->{'remote-host'} ) {
+            print STDERR "--incremental does not work with --remote-host.\n";
+            exit 1;
+         }
+         my @dirs    = `ls -1 -t $backup_root`;
+         my $inc_dir = $dirs[0];
+         chomp($inc_dir);
+         $incremental_basedir = File::Spec->catfile( $backup_root, $inc_dir );
+
+         #print STDERR "--incremental_basedir=$incremental_basedir\n";
+         #print STDERR "incremental backup is not supported for now.\n";
+         #exit(1);
+      }
+      if( $o->{'remote-host'} ) {
+         my ($host, $dir) =  split( ':', $o->{'remote-host'} );
+         if ( $dir ) {
+            print STDERR "--remote-host should not have a ':directory' part.\n"
+               . "Specify the remote host directory asBACK-ROOT-DIR.";
+            exit 1;
+         }
+      }
+   }
+   else {
+      # get backup directory
+      $backup_dir = File::Spec->rel2abs( $ARGV[0] );
+   }
+
+   parse_databases_option_value();
+
+   return;
+}
+
+#
+# make_backup_dir subroutine creates a new backup directory and returns
+# its name.
+#
+sub make_backup_dir {
+   my $dir;
+   my $innodb_data_file_path =
+      get_option( \%config, 'mysqld', 'innodb_data_file_path' );
+
+   # create backup directory
+   $dir = $backup_root;
+   if ( $o->{'stream'} ) {
+      return $dir;
+   }
+
+   $dir .= '/' . strftime( "%Y-%m-%d_%H-%M-%S", localtime() )
+      unless $o->{'no-timestamp'};
+   if ( !$o->{'remote-host'} ) {
+      mkdir( $dir, 0777 )
+         || Die "Failed to create backup directory $dir: $OS_ERROR";
+   }
+   else {
+      system_call("ssh $o->{'remote-host'} mkdir '$dir'");
+   }
+
+   # create subdirectories for ibdata files if needed
+   #    foreach my $a (split(/;/, $innodb_data_file_path)) {
+   #        my $path = (split(/:/,$a))[0];
+   #        my @relative_path = split(/\/+/, $path);
+   #        pop @relative_path;
+   #        if (@relative_path) {
+   #            # there is a non-trivial path from the backup directory
+   #            # to the directory of this backup ibdata file, check
+   #            # that all the directories in the path exist.
+   #            create_path_if_needed($dir, \@relative_path);
+   #        }
+   #    }
+
+   return $dir;
+}
+
+#
+# create_path_if_needed subroutine checks that all components
+# in the given relative path are directories. If the
+# directories do not exist, they are created.
+#    Parameters:
+#       root           a path to the root directory of the relative pathname
+#       relative_path  a relative pathname (a reference to an array of
+#                      pathname components)
+#
+sub create_path_if_needed {
+   my $root          = shift;
+   my $relative_path = shift;
+   my $path;
+
+   $path = $root;
+   foreach $a ( @{$relative_path} ) {
+      $path = $path . "/" . $a;
+      if ( !$o->{'remote-host'} ) {
+         if ( !-d $path ) {
+
+            # this directory does not exist, create it !
+            mkdir( $path, 0777 )
+               || Die "Failed to create backup directory: $OS_ERROR";
+         }
+      }
+      else {
+         if ( system_call("ssh $o->{'remote-host'} test -d '$path'", 1) != 0 ) {
+            system_call("ssh $o->{'remote-host'} mkdir $path");
+         }
+      }
+   }
+}
+
+#
+# remove_from_array subroutine removes excluded element from the array.
+#    Parameters:
+#       array_ref   a reference to an array of strings
+#       excluded   a string to be excluded from the copy
+#
+sub remove_from_array {
+   my $array_ref = shift;
+   my $excluded  = shift;
+   my @copy      = ();
+   my $size      = 0;
+
+   foreach my $str ( @{$array_ref} ) {
+      if ( $str ne $excluded ) {
+         $copy[$size] = $str;
+         $size = $size + 1;
+      }
+   }
+   @{$array_ref} = @copy;
+}
+
+#
+# backup_files subroutine copies .frm, .MRG, .MYD and .MYI files to
+# backup directory.
+#
+sub backup_files {
+   my $source_dir = get_option( \%config, 'mysqld', 'datadir' );
+   my @list;
+   my $file;
+   my $database;
+   my $wildcard = '*.{frm,MYD,MYI,MRG,TRG,TRN,ARM,ARZ,opt,par}';
+
+   opendir( DIR, $source_dir )
+      or Die "Cannot open directory '$source_dir': $OS_ERROR\n";
+   $now = current_time();
+   print STDERR
+      "\n$now  $prefix Starting to backup .frm, .MRG, .MYD, .MYI,\n";
+   print STDERR "$prefix .TRG, .TRN, .ARM, .ARZ and .opt files in\n";
+   print STDERR "$prefix subdirectories of '$source_dir'\n";
+
+   # loop through all database directories
+   while ( defined( $database = readdir(DIR) ) ) {
+      my $print_each_file = 0;
+      my $file_c;
+      my @scp_files;
+
+      # skip files that are not database directories
+      next if $database eq '.' || $database eq '..';
+      next unless -d "$source_dir/$database";
+      next unless check_if_required($database);
+      
+      IBEXDEBUG && _d('Working in database', "$source_dir/$database");
+
+      if ( !$o->{'remote-host'} && !$o->{'stream'} ) {
+         if ( !-e "$backup_dir/$database" ) {
+
+            # create database directory for the backup
+            mkdir( "$backup_dir/$database", 0777 )
+               or Die "Cannot create directory '$backup_dir/$database': "
+               . $OS_ERROR;
+         }
+      }
+      elsif ( $o->{'remote-host'} ) {
+         system_call("ssh $o->{'remote-host'} mkdir '$backup_dir/$database'");
+      }
+
+      # copy files of this database
+      opendir( DBDIR, "$source_dir/$database" );
+      @list = grep(
+         /\.(frm)|(MYD)|(MYI)|(MRG)|(TRG)|(TRN)|(ARM)|(ARZ)|(opt)|(par)$/,
+         readdir(DBDIR) );
+      closedir DBDIR;
+      $file_c = @list;
+      if ( $file_c <= $backup_file_print_limit ) {
+         $print_each_file = 1;
+      }
+      else {
+         print STDERR "$prefix Backing up files "
+            . "'$source_dir/$database/$wildcard' ($file_c files)\n";
+      }
+      foreach $file (@list) {
+
+         # copying may take a long time, so we have to prevent
+         # mysql connection from timing out
+         mysql_keep_alive();
+         next unless check_if_required( $database, $file );
+
+         if ( $print_each_file ) {
+            print STDERR "$prefix Backing up file "
+               . "'$source_dir/$database/$file'\n";
+         }
+
+         if ( !$o->{'remote-host'} && !$o->{'stream'} ) {
+            $src_name = escape_path("$source_dir/$database/$file");
+            $dst_name = escape_path("$backup_dir/$database");
+            system_call("$CP_CMD \"$src_name\" \"$dst_name\"");
+         }
+         elsif ( $o->{'remote-host'} ) {
+            # Queue up files for one single scp per database.
+            push @scp_files, "'$file'";
+         }
+         elsif ( $o->{'stream'} eq 'tar' ) {
+            my $ret = 0;
+            my $file_name = substr( $file, rindex( $file, '/' ) + 1 );
+            $file_name =~ s/([\$\\\" ])/\\$1/g;
+            $ret = system_call(
+               "cd $source_dir; tar cf - $database/$file_name", 1);
+            if ( $ret == 1 ) {
+               print STDERR "$prefix If you use GNU tar, "
+                  . "this warning can be ignored.\n";
+            }
+            elsif ( $ret != 0 ) {
+               print STDERR "$prefix tar returned with exit code $ret.\n";
+               Die "Failed to stream '$database/$file_name': $OS_ERROR";
+            }
+         }
+      }
+      if ( $o->{'remote-host'} ) {
+         my $scp_file_list =
+            join( " ", map {"$source_dir/$database/$_"} @scp_files );
+         system_call("scp $o->{'scp-opt'} $scp_file_list "
+            . "'$o->{'remote-host'}:$backup_dir/$database/'");
+      }
+   }
+   closedir(DIR);
+
+   $now = current_time();
+   print STDERR
+      "$now  $prefix Finished backing up .frm, .MRG, .MYD, .MYI, .TRG, .TRN, .ARM, .ARZ and .opt files\n\n";
+
+   return;
+}
+
+#
+# file_to_array subroutine reads the given text file into an array and
+# stores each line as an element of the array. The end-of-line
+# character(s) are removed from the lines stored in the array.
+#    Parameters:
+#       filename   name of a text file
+#       lines_ref  a reference to an array
+#
+sub file_to_array {
+   my $filename  = shift;
+   my $lines_ref = shift;
+
+   open( FILE, $filename ) || Die "can't open file '$filename': $OS_ERROR";
+   @{$lines_ref} = <FILE>;
+   close(FILE) || Die "can't close file '$filename': $OS_ERROR";
+
+   foreach my $a ( @{$lines_ref} ) {
+      chomp($a);
+   }
+}
+
+#
+# unescape_string subroutine expands escape sequences found in the string and
+# returns the expanded string. It also removes possible single or double quotes
+# around the value.
+#    Parameters:
+#       value   a string
+#    Return value:
+#       a string with expanded escape sequences
+#
+sub unescape_string {
+   my $value  = shift;
+   my $result = '';
+   my $offset = 0;
+
+   # remove quotes around the value if they exist
+   if ( length($value) >= 2 ) {
+      if ( ( substr( $value, 0, 1 ) eq "'" && substr( $value, -1, 1 ) eq "'" )
+         || (  substr( $value, 0, 1 ) eq '"'
+            && substr( $value, -1, 1 ) eq '"' ) )
+      {
+         $value = substr( $value, 1, -1 );
+      }
+   }
+
+   # expand escape sequences
+   while ( $offset < length($value) ) {
+      my $pos = index( $value, "\\", $offset );
+      if ( $pos < 0 ) {
+         $pos    = length($value);
+         $result = $result . substr( $value, $offset, $pos - $offset );
+         $offset = $pos;
+      }
+      else {
+         my $replacement = substr( $value, $pos,     2 );
+         my $escape_code = substr( $value, $pos + 1, 1 );
+         if ( exists $o->{'value-escapes'}{$escape_code} ) {
+            $replacement = $o->{'value-escapes'}{$escape_code};
+         }
+         $result =
+              $result
+            . substr( $value, $offset, $pos - $offset )
+            . $replacement;
+         $offset = $pos + 2;
+      }
+   }
+
+   return $result;
+}
+
+#
+# read_config_file subroutine reads MySQL options file and
+# returns the options in a hash containing one hash per group.
+#    Parameters:
+#       filename    name of a MySQL options file
+#       groups_ref  a reference to hash variable where the read
+#                   options are returned
+#
+sub read_config_file {
+
+   #my $filename = shift;
+   my $groups_ref = shift;
+   my @lines;
+   my $i;
+   my $group;
+   my $group_hash_ref;
+
+   my $cmdline = '';
+   my $options = '';
+
+   if ( $o->{'defaults-file'} ) {
+      $options = $options . " --defaults-file=\"$o->{'defaults-file'}\" ";
+   }
+
+   $options = $options . "--print-param";
+
+   # read file to an array, one line per element
+   #file_to_array($filename, \@lines);
+   $cmdline = "$o->{'ibbackup'} $options";
+   @lines   = `$cmdline`;
+
+   # classify lines and save option values
+   $group          = 'default';
+   $group_hash_ref = {};
+   ${$groups_ref}{$group} = $group_hash_ref;
+
+   # this pattern described an option value which may be
+   # quoted with single or double quotes. This pattern
+   # does not work by its own. It assumes that the first
+   # opening parenthesis in this string is the second opening
+   # parenthesis in the full pattern.
+   my $value_pattern = q/((["'])([^\\\4]|(\\[^\4]))*\4)|([^\s]+)/;
+   for ( $i = 0; $i < @lines; $i++ ) {
+   SWITCH: for ( $lines[$i] ) {
+
+         # comment
+         /^\s*(#|;)/
+            && do { last; };
+
+         # group
+         /^\s*\[(.*)\]/
+            && do {
+            $group = $1;
+            if ( !exists ${$groups_ref}{$group} ) {
+               $group_hash_ref = {};
+               ${$groups_ref}{$group} = $group_hash_ref;
+            }
+            else {
+               $group_hash_ref = ${$groups_ref}{$group};
+            }
+            last;
+            };
+
+         # option
+         /^\s*([^\s=]+)\s*(#.*)?$/
+            && do {
+            ${$group_hash_ref}{$1} = '';
+            last;
+            };
+
+         # set-variable = option = value
+         /^\s*set-variable\s*=\s*([^\s=]+)\s*=\s*($value_pattern)\s*(#.*)?$/
+            && do { ${$group_hash_ref}{$1} = unescape_string($2); last; };
+
+         # option = value
+         /^\s*([^\s=]+)\s*=\s*($value_pattern)\s*(#.*)?$/
+            && do { ${$group_hash_ref}{$1} = unescape_string($2); last; };
+
+         # empty line
+         /^\s*$/
+            && do { last; };
+
+         # unknown
+         print( "$prefix: Warning: Ignored unrecognized line ",
+            $i + 1, " in options : '${lines[$i]}'\n" );
+      }
+   }
+}
+
+#
+# get_option subroutine returns the value of given option in the config
+# structure. If option is missing, this subroutine calls exit.
+#    Parameters:
+#       config_ref   a reference to a config data
+#       group        option group name
+#       option_name  name of the option
+#    Return value:
+#       option value as a string
+#
+sub get_option {
+   my $config_ref  = shift;
+   my $group       = shift;
+   my $o->{'name'} = shift;
+   my $group_hash_ref;
+
+   if ( !exists $config{$group} ) {
+      # no group
+      print STDERR "$prefix fatal error: no '$group' group in MySQL options\n";
+      print STDERR "$prefix fatal error: OR no 'datadir' option in group "
+         . "'$group' in MySQL options\n";
+      exit(1);
+   }
+
+   $group_hash_ref = ${$config_ref}{$group};
+   if ( !exists ${$group_hash_ref}{ $o->{'name'} } ) {
+      # no option
+      print STDERR "$prefix fatal error: no '$o->{'name'}' option in group "
+         . "'$group' in MySQL options\n";
+      exit(1);
+   }
+
+   return ${$group_hash_ref}{ $o->{'name'} };
+}
+
+# check_if_required subroutine returns 1 if the specified database and
+# table needs to be backed up.
+#    Parameters:
+#       $_[0]        name of database to be checked
+#       $_[1]        full path of table file (This argument is optional)
+#    Return value:
+#       1 if backup should be done and 0 if not
+#
+sub check_if_required {
+   my $db       = $_[0];
+   my $db_count = keys %databases_list;
+   my $table_path;
+   if ( defined $_[1] ) {
+      $table_path = $_[1];
+   }
+   else {
+      undef $table_path;
+   }
+
+   if ( $db_count == 0 ) {
+      # no databases defined with --databases option, include all databases
+      return 1;
+   }
+   if ( defined $databases_list{$db} ) {
+      if ( defined $table_path ) {
+
+         # get the last component in the table pathname
+         my $filename = ( reverse( split( /\//, $table_path ) ) )[0];
+
+         # get name of the table by removing file suffix
+         my $table = ( split( /\./, $filename ) )[0];
+
+         my $db_hash = $databases_list{$db};
+         $db_count = keys %$db_hash;
+         if ( $db_count > 0 && !defined $databases_list{$db}->{$table} ) {
+
+            # --databases option specified, but table is not included
+            return 0;
+         }
+      }
+      # include this database and table
+      return 1;
+   }
+   else {
+      # --databases option given, but database is not included
+      return 0;
+   }
+}
+
+# parse_databases_option_value subroutine parses the value of
+# --databases option. If the option value begins with a slash
+# it is considered a pathname and the option value is read
+# from the file.
+#
+# This subroutine sets the global "databases_list" variable.
+#
+sub parse_databases_option_value {
+   my $item;
+
+   if ( $o->{'databases'} =~ /^\// ) {
+
+      # the value of the --databases option begins with a slash,
+      # the option value is pathname of the file containing
+      # list of databases
+      if ( !-f $o->{'databases'} ) {
+         Die "can't find file '$o->{'databases'}'";
+      }
+
+      # read from file the value of --databases option
+      my @lines;
+      file_to_array( $o->{'databases'}, \@lines );
+      $o->{'databases'} = join( " ", @lines );
+   }
+
+   # mark each database or database.table definition in the
+   # global databases_list.
+   foreach $item ( split( /\s/, $o->{'databases'} ) ) {
+      my $db    = "";
+      my $table = "";
+      my %hash;
+
+      if ( $item eq "" ) {
+
+         # ignore empty strings
+         next;
+      }
+
+      # get database and table names
+      if ( $item =~ /(\S*)\.(\S*)/ ) {
+
+         # item is of the form DATABASE.TABLE
+         $db    = $1;
+         $table = $2;
+      }
+      else {
+
+         # item is database name, table is undefined
+         $db = $item;
+      }
+
+      if ( !defined $databases_list{$db} ) {
+
+         # create empty hash for the database
+         $databases_list{$db} = \%hash;
+      }
+      if ( $table ne "" ) {
+
+         # add mapping table --> 1 to the database hash
+         my $h = $databases_list{$db};
+         $h->{$table} = 1;
+      }
+   }
+}
+
+sub escape_path {
+   my $str = shift;
+   if ( $win eq 1 ) {
+      $str =~ s/\//\\/g;
+      $str =~ s/\\\\/\\/g;
+   }
+   else {
+      $str =~ s/\/\//\//g;
+   }
+   return $str;
+
+}
+
+sub system_call {
+   my ( $cmd, $dont_check_retval ) = @_;
+   IBEXDEBUG && _d($cmd);
+   Die "I need a cmd argument" unless $cmd;
+
+   my $retval = system($cmd);
+   IBEXDEBUG && _d('Exit status:', $retval);
+
+   return $retval if $dont_check_retval;
+
+   # A non-zero retval (exit status) means that cmd caused an error.
+   if ( $retval ) {
+      Die "Failed system call: $cmd\n"
+         . "Exit status: $retval\n"
+   }
+
+   return $retval;
+}
+
+sub _d {
+   my ( $package, undef, $line ) = caller 0;
+   @_ = map { ( my $temp = $_ ) =~ s/\n/\n# /g; $temp; }
+      map { defined $_ ? $_ : 'undef' } @_;
+   print STDERR "# $package:$line $PID ", join( ' ', @_ ), "\n";
+}
+
+# ############################################################################
+# Run the program.
+# ############################################################################
+if ( !caller ) { exit main(@ARGV); }
+
+1;    # Because this is a module as well as a script.

=== added directory 'innobackupex/t'
=== added file 'innobackupex/t/001_get_mysql_options.t'
--- innobackupex/t/001_get_mysql_options.t	1970-01-01 00:00:00 +0000
+++ innobackupex/t/001_get_mysql_options.t	2010-01-22 01:31:15 +0000
@@ -0,0 +1,61 @@
+#!/usr/bin/perl
+
+BEGIN {
+   die "The XTRABACKUP_TRUNK environment variable is not set."
+      unless $ENV{XTRABACKUP_TRUNK} && -d $ENV{XTRABACKUP_TRUNK};
+   unshift @INC, "$ENV{XTRABACKUP_TRUNK}/innobackupex/common";
+};
+
+use strict;
+use warnings FATAL => 'all';
+use English qw(-no_match_vars);
+use Test::More tests => 5;
+
+use IbexTest;
+require "$trunk/innobackupex/innobackupex";
+
+is(
+   innobackupex::get_mysql_options(),
+   '--unbuffered --',
+   'No options'
+);
+
+@ARGV = qw(--password foo /tmp);
+innobackupex::check_args();
+is(
+   innobackupex::get_mysql_options(),
+   '--password=foo --unbuffered --',
+   '--password'
+);
+
+# check_args() doesn't clear opts from previous runs so this
+# test inherits --password=foo.
+@ARGV = qw(--defaults-file=/etc/my.cnf /tmp);
+innobackupex::check_args();
+is(
+   innobackupex::get_mysql_options(),
+   '--defaults-file=/etc/my.cnf --password=foo --unbuffered --',
+   '--defaults-file'
+);
+
+@ARGV = qw(--port=12345 --user=bob --password=bar /tmp);
+innobackupex::check_args();
+is(
+   innobackupex::get_mysql_options(),
+   '--defaults-file=/etc/my.cnf --port=12345 --user=bob --password=bar --unbuffered --',
+   '--port and --user'
+);
+
+# The whole enchilada.
+@ARGV = qw(--host=10.0.0.1 /tmp);
+innobackupex::check_args();
+is(
+   innobackupex::get_mysql_options(),
+   '--defaults-file=/etc/my.cnf --host=10.0.0.1 --port=12345 --user=bob --password=bar --unbuffered --',
+   '--host'
+);
+
+# #############################################################################
+# Done.
+# #############################################################################
+exit;

=== added file 'innobackupex/t/100_backup.t'
--- innobackupex/t/100_backup.t	1970-01-01 00:00:00 +0000
+++ innobackupex/t/100_backup.t	2010-01-22 01:31:15 +0000
@@ -0,0 +1,87 @@
+#!/usr/bin/perl
+
+BEGIN {
+   die "The XTRABACKUP_TRUNK environment variable is not set."
+      unless $ENV{XTRABACKUP_TRUNK} && -d $ENV{XTRABACKUP_TRUNK};
+   unshift @INC, "$ENV{XTRABACKUP_TRUNK}/innobackupex/common";
+};
+
+use strict;
+use warnings FATAL => 'all';
+use English qw(-no_match_vars);
+use Test::More;
+
+use IbexTest;
+use DSNParser;
+use Sandbox;
+require "$trunk/innobackupex/innobackupex";
+
+my $dp  = new DSNParser();
+my $sb  = new Sandbox(basedir => '/tmp', DSNParser => $dp);
+my $dbh = $sb->get_dbh_for('master');
+
+if ( !$dbh ) {
+   plan skip_all => 'Cannot connect to sandbox master';
+}
+else {
+   plan tests => 9;
+}
+
+my $cnf = '/tmp/12345/my.sandbox.cnf';
+my $backup_root_dir = '/tmp/ibex';
+
+diag(`rm -rf $backup_root_dir >/dev/null`);
+
+$sb->wipe_clean($dbh);
+$sb->load_file('master', "innobackupex/t/samples/basic-tables.sql");
+
+output(
+   sub { innobackupex::main('--defaults-file', $cnf, $backup_root_dir,
+      qw(--databases ibex --no-timestamp)) }
+);
+
+ok(
+   -d $backup_root_dir,
+   "Created backup root dir $backup_root_dir"
+);
+
+ok(
+   -d "$backup_root_dir/ibex",
+   "Created $backup_root_dir/ibex"
+);
+
+ok(
+   !-d "$backup_root_dir/mysql",
+   "Did not backup mysql database"
+);
+
+my @files = </tmp/12345/data/ibex/*>;
+
+is_deeply(
+   \@files,
+   [qw(
+      /tmp/12345/data/ibex/db.opt
+      /tmp/12345/data/ibex/t1.frm
+      /tmp/12345/data/ibex/t2.frm
+      /tmp/12345/data/ibex/t2.MYD
+      /tmp/12345/data/ibex/t2.MYI
+   )],
+   'Copied all files from ibex db'
+);
+
+foreach my $file ( @files ) {
+   my ($file2) = $file =~ m/([\w\.]+)$/;
+   my $output = `diff $file $backup_root_dir/ibex/$file2`;
+   is(
+      $output,
+      '',
+      "$file2 does not differ"
+   );
+}
+
+# #############################################################################
+# Done.
+# #############################################################################
+diag(`rm -rf $backup_root_dir >/dev/null`);
+$sb->wipe_clean($dbh);
+exit;

=== added directory 'innobackupex/t/samples'
=== added file 'innobackupex/t/samples/basic-tables.sql'
--- innobackupex/t/samples/basic-tables.sql	1970-01-01 00:00:00 +0000
+++ innobackupex/t/samples/basic-tables.sql	2010-01-22 01:31:15 +0000
@@ -0,0 +1,17 @@
+drop database if exists ibex;
+create database ibex;
+use ibex;
+
+create table t1 (
+   i int,
+   unique key (i)
+) engine=innodb;
+
+insert into ibex.t1 values (1),(2),(3);
+
+create table t2 (
+   i int,
+   unique key (i)
+) engine=myisam;
+
+insert into ibex.t2 values (4),(5),(6);

=== added file 'innobackupex/test-coverage.txt'
--- innobackupex/test-coverage.txt	1970-01-01 00:00:00 +0000
+++ innobackupex/test-coverage.txt	2010-01-22 01:31:15 +0000
@@ -0,0 +1,2854 @@
+Reading database from /home/daniel/dev/percona-xtrabackup/innobackupex/t/cover_db
+
+
+---------------------------- ------ ------ ------ ------ ------ ------ ------
+File                           stmt   bran   cond    sub    pod   time  total
+---------------------------- ------ ------ ------ ------ ------ ------ ------
+...innobackupex/innobackupex   51.7   32.6   33.7   76.4    n/a  100.0   46.0
+Total                          51.7   32.6   33.7   76.4    n/a  100.0   46.0
+---------------------------- ------ ------ ------ ------ ------ ------ ------
+
+
+Run:          100_backup.t
+Perl version: 118.53.46.49.48.46.48
+OS:           linux
+Start:        Thu Jan 21 23:50:53 2010
+Finish:       Thu Jan 21 23:50:55 2010
+
+Run:          100_backup.t
+Perl version: 118.53.46.49.48.46.48
+OS:           linux
+Start:        Thu Jan 21 23:50:53 2010
+Finish:       Thu Jan 21 23:51:12 2010
+
+Run:          001_get_mysql_options.t
+Perl version: 118.53.46.49.48.46.48
+OS:           linux
+Start:        Thu Jan 21 23:55:00 2010
+Finish:       Thu Jan 21 23:55:00 2010
+
+/home/daniel/dev/percona-xtrabackup/innobackupex/innobackupex
+
+line  err   stmt   bran   cond    sub    pod   time   code
+1                                                     #!/usr/bin/env perl
+2                                                     
+3                                                     # A script for making backups of InnoDB and MyISAM tables, indexes and .frm
+4                                                     # files.
+5                                                     #
+6                                                     # Orginal code copyright 2003, 2009 Innobase Oy.
+7                                                     # http://www.innodb.com/download/
+8                                                     #
+9                                                     # Modified code copyright 2010 Percona Inc.
+10                                                    # https://launchpad.net/percona-xtrabackup/trunk
+11                                                    
+12                                                    # ############################################################################
+13                                                    # This is a a runnable module.  Check at the end of this package for the call
+14                                                    # to main() which actually runs the program.
+15                                                    # ############################################################################
+16                                                    package innobackupex;
+17                                                    
+18             3                    3            23   use strict;
+               3                                  6   
+               3                                 19   
+19             3                    3            20   use warnings FATAL => 'all';
+               3                                  6   
+               3                                 29   
+20             3                    3            18   use English qw(-no_match_vars);
+               3                                  7   
+               3                                 17   
+21             3                    3            32   use Getopt::Long qw(:config default);
+               3                                 12   
+               3                                 23   
+22             3                    3            24   use File::Spec;
+               3                                  6   
+               3                                 35   
+23             3                    3            47   use POSIX "strftime";
+               3                                 10   
+               3                                 24   
+24             3                    3            55   use POSIX ":sys_wait_h";
+               3                                  8   
+               3                                 24   
+25             3                    3            22   use POSIX "tmpnam";
+               3                                 18   
+               3                                 21   
+26             3                    3            21   use FileHandle;
+               3                                  9   
+               3                                 32   
+27             3                    3            24   use File::Basename;
+               3                                  9   
+               3                                 41   
+28                                                    
+29    ***      3            50      3            22   use constant IBEXDEBUG => $ENV{IBEXDEBUG} || 0;
+               3                                  9   
+               3                                 57   
+30                                                    
+31                                                    # version of this script
+32                                                    my $innobackup_version = '1.5.1-xtrabackup';
+33                                                    my $innobackup_script  = basename($0);
+34                                                    
+35                                                    # copyright notice
+36                                                    my $copyright_notice = "InnoDB Backup Utility v${innobackup_version}; Copyright 2003, 2009 Innobase Oy.
+37                                                    All Rights Reserved.
+38                                                    
+39                                                    This software is published under
+40                                                    the GNU GENERAL PUBLIC LICENSE Version 2, June 1991.
+41                                                    
+42                                                    ";
+43                                                    
+44                                                    # required Perl version (5.005)
+45                                                    my @required_perl_version = ( 5, 0, 5 );
+46                                                    my $required_perl_version_old_style = 5.005;
+47                                                    
+48                                                    # force flush after every write and print
+49                                                    $OUTPUT_AUTOFLUSH = 1;
+50                                                    
+51                                                    ######################################################################
+52                                                    # modifiable parameters
+53                                                    ######################################################################
+54                                                    
+55                                                    # maximum number of files in a database directory which are
+56                                                    # separately printed when a backup is made
+57                                                    my $backup_file_print_limit = 9;
+58                                                    
+59                                                    # timeout in seconds for a reply from mysql
+60                                                    my $mysql_response_timeout = 900;
+61                                                    
+62                                                    # default compression level (this is an argument to ibbackup)
+63                                                    my $default_compression_level = 1;
+64                                                    
+65                                                    # time in seconds after which a dummy query is sent to mysql server
+66                                                    # in order to keep the database connection alive
+67                                                    my $mysql_keep_alive_timeout = 1800;
+68                                                    
+69                                                    ######################################################################
+70                                                    # end of modifiable parameters
+71                                                    ######################################################################
+72                                                    
+73                                                    # command line options
+74                                                    my $o = {
+75                                                       'compress'  => 999,
+76                                                       'databases' => '',
+77                                                       'ibbackup'  => 'xtrabackup',
+78                                                       'scp-opt'   => '-Cp -c arcfour',
+79                                                       'stream'    => '',
+80                                                    };
+81                                                    
+82                                                    # root of the backup directory
+83                                                    my $backup_root = '';
+84                                                    
+85                                                    # backup directory pathname
+86                                                    my $backup_dir = '';
+87                                                    
+88                                                    # name of the ibbackup suspend-at-end file
+89                                                    my $suspend_file = '';
+90                                                    
+91                                                    # name of the temporary transaction log file during the backup
+92                                                    my $tmp_logfile = '';
+93                                                    
+94                                                    # home directory of innoDB log files
+95                                                    my $innodb_log_group_home_dir = '';
+96                                                    
+97                                                    # backup my.cnf file
+98                                                    my $backup_config_file = '';
+99                                                    
+100                                                   # options from the options file
+101                                                   my %config;
+102                                                   
+103                                                   # options from the backup options file
+104                                                   #my %backup_config;
+105                                                   
+106                                                   # list of databases to be included in a backup
+107                                                   my %databases_list;
+108                                                   
+109                                                   # prefix for output lines
+110                                                   my $prefix = "$innobackup_script:";
+111                                                   
+112                                                   # process id of mysql client program (runs as a child process of this script)
+113                                                   my $mysql_pid = '';
+114                                                   
+115                                                   # mysql server version string
+116                                                   my $mysql_server_version = '';
+117                                                   
+118                                                   # name of the file where stderr of mysql process is directed
+119                                                   my $mysql_stderr;
+120                                                   
+121                                                   # name of the file where stdout of mysql process is directed
+122                                                   my $mysql_stdout;
+123                                                   
+124                                                   # name of the file where binlog position info is written
+125                                                   my $binlog_info;
+126                                                   
+127                                                   # name of the file where slave info is written
+128                                                   my $slave_info;
+129                                                   
+130                                                   # mysql binlog position as given by "SHOW MASTER STATUS" command
+131                                                   my $mysql_binlog_position = '';
+132                                                   
+133                                                   # mysql master's binlog position as given by "SHOW SLAVE STATUS" command
+134                                                   # run on a slave server
+135                                                   my $mysql_slave_position = '';
+136                                                   
+137                                                   # time of the most recent mysql_check call. (value returned by time() function)
+138                                                   my $mysql_last_access_time = 0;
+139                                                   
+140                                                   # process id of ibbackup program (runs as a child process of this script)
+141                                                   my $ibbackup_pid = '';
+142                                                   
+143                                                   # a counter for numbering mysql connection checks
+144                                                   my $hello_id = 0;
+145                                                   
+146                                                   # the request which has been sent to mysqld, but to which
+147                                                   # mysqld has not yet replied. Empty string denotes that no
+148                                                   # request has been sent to mysqld or that mysqld has replied
+149                                                   # to all requests.
+150                                                   my $current_mysql_request = '';
+151                                                   
+152                                                   # escape sequences for options files
+153                                                   my %option_value_escapes = (
+154                                                      'b'  => "\b",
+155                                                      't'  => "\t",
+156                                                      'n'  => "\n",
+157                                                      'r'  => "\r",
+158                                                      "\\" => "\\",
+159                                                      's'  => ' '
+160                                                   );
+161                                                   
+162                                                   # signal that is sent to child processes when they are killed
+163                                                   my $kill_signal = 15;
+164                                                   
+165                                                   # current local time
+166                                                   my $now;
+167                                                   
+168                                                   # incremental backup base directory
+169                                                   my $incremental_basedir = '';
+170                                                   
+171                                                   my $src_name;
+172                                                   my $dst_name;
+173                                                   my $win    = ( $^O  eq 'MSWin32' ? 1         : 0 );
+174                                                   my $CP_CMD = ( $win eq 1         ? "copy /Y" : "cp -p" );
+175                                                   
+176                                                   ######################################################################
+177                                                   # program execution begins here
+178                                                   ######################################################################
+179                                                   sub main {
+180            2                    2           162      @ARGV = @_;    # set global ARGV for this package
+181                                                   
+182                                                      # check command-line args
+183            2                                 34      check_args();
+184                                                   
+185                                                      # print program version and copyright
+186            2                                 14      print_version();
+187                                                   
+188                                                      # initialize global variables and perform some checks
+189            2                                 32      init();
+190                                                   
+191   ***      2     50                          26      if ( $o->{'copy-back'} ) {
+      ***            50                               
+192                                                         # copy files from backup directory back to their original locations
+193   ***      0                                  0         copy_back();
+194                                                      }
+195                                                      elsif ( $o->{'apply-log'} ) {
+196                                                         # expand data files in backup directory by applying log files to them
+197   ***      0                                  0         apply_log();
+198                                                      }
+199                                                      else {
+200                                                         # make a backup of InnoDB and MyISAM tables, indexes and .frm files.
+201            2                                 40         backup();
+202                                                      }
+203                                                   
+204                                                      # program has completed successfully
+205            1                                  7      $now = current_time();
+206            1                                 24      print STDERR "$now  $prefix completed OK!\n";
+207                                                   
+208   ***      1     50                          14      if ( $o->{'stream'} eq 'tar' ) {
+209   ***      0                                  0         print STDERR "$prefix You must use -i (--ignore-zeros) option for extraction of the tar stream.\n";
+210                                                      }
+211                                                   
+212            1                                 23      return 0;
+213                                                   }
+214                                                   
+215                                                   ##############################################################################
+216                                                   # Subroutines
+217                                                   ##############################################################################
+218                                                   
+219                                                   #
+220                                                   # print_version subroutine prints program version and copyright.
+221                                                   #
+222                                                   sub print_version {
+223            2                    2           140      printf( STDERR $copyright_notice );
+224                                                   }
+225                                                   
+226                                                   #
+227                                                   # usage subroutine prints instructions of how to use this program to stdout.
+228                                                   #
+229                                                   sub usage {
+230   ***      0                    0             0      print STDOUT <<EOF;
+231                                                   
+232                                                   Usage:
+233                                                   
+234                                                      $innobackup_script BACKUP-ROOT-DIR [OPTIONS]
+235                                                   
+236                                                      $innobackup_script --apply-log BACKUP-DIR [OPTIONS]
+237                                                      
+238                                                      $innobackup_script --copy-back BACKUP-DIR [OPTIONS]
+239                                                   
+240                                                   The first command line above makes a hot backup of a MySQL database.
+241                                                   By default it creates a backup directory (named by the current date
+242                                                   and time) in the given BACKUP-ROOT-DIR directory.  With the --no-timestamp
+243                                                   option it does not create a time-stamped backup directory, but it puts
+244                                                   the backup in the given directory (which must not exist).  This
+245                                                   command makes a complete backup of all MyISAM and InnoDB tables and
+246                                                   indexes in all databases or in all of the databases specified with the
+247                                                   --databases option.  The created backup contains .frm, .MRG, .MYD,
+248                                                   .MYI, .TRG, .TRN, .ARM, .ARZ, .opt, .par, and InnoDB data and log files.
+249                                                   The MY.CNF options file defines the location of the database.  This command
+250                                                   connects to the MySQL server using mysql client program, and runs
+251                                                   ibbackup (InnoDB Hot Backup program) as a child process.
+252                                                   
+253                                                   The command with --apply-log option prepares a backup for starting a MySQL
+254                                                   server on the backup. This command expands InnoDB data files as specified
+255                                                   in BACKUP-DIR/backup-my.cnf using BACKUP-DIR/ibbackup_logfile,
+256                                                   and creates new InnoDB log files as specified in BACKUP-DIR/backup-my.cnf.
+257                                                   The BACKUP-DIR should be a path name of a backup directory created by
+258                                                   innobackup. This command runs ibbackup as a child process, but it does not 
+259                                                   connect to the database server. 
+260                                                   
+261                                                   The command with --copy-back option copies data, index, and log files
+262                                                   from backup directory back to their original locations.
+263                                                   The MY.CNF options file defines the original location of the database.
+264                                                   The BACKUP-DIR is a path name of a backup directory created by innobackup.
+265                                                   
+266                                                   On success the exit code of innobackup process is 0. A non-zero exit code 
+267                                                   indicates an error.
+268                                                   
+269                                                   Options:
+270                                                   
+271                                                       --help      Display this helpscreen and exit.
+272                                                   
+273                                                       --version   Print version information and exit.
+274                                                   
+275                                                       --defaults-file=[MY.CNF]
+276                                                                   This option is passed to the xtrabackup child process
+277                                                                   and the mysql child process.  It specifies which file
+278                                                                   to read default options from.
+279                                                   
+280                                                       --apply-log
+281                                                                   Prepare a backup for starting mysql server on the backup. 
+282                                                                   Expand InnoDB data files as specified in 
+283                                                                   backup-dir/backup-my.cnf, using backup-dir/ibbackup_logfile, 
+284                                                                   and create new log files as specified in 
+285                                                                   backup-dir/backup-my.cnf.
+286                                                   
+287                                                       --copy-back
+288                                                                   Copy data and index files from backup directory back to 
+289                                                                   their original locations.
+290                                                   
+291                                                       --remote-host=[USER@]HOSTNAME
+292                                                                   If this option is specified, backup files will be created
+293                                                                   at the remote host by using ssh and scp.  BACKUP-ROOT-DIR
+294                                                                   is relative to this host.
+295                                                   
+296                                                       --stream=[tar|cpio(not implemented)]
+297                                                                   If this option is specified, backup to STDOUT as specified
+298                                                                   format.
+299                                                   
+300                                                       --tmpdir=DIRECTORY
+301                                                                   When --remote-host or --stream specified, transaction log
+302                                                                   should be stored temporary. The default value is same to
+303                                                                   mysqld setting.
+304                                                   
+305                                                       --use-memory=MB
+306                                                                   This option is passed to the ibbackup child process.
+307                                                                   It tells ibbackup that it can use MB megabytes of 
+308                                                                   memory in restoration.
+309                                                                   Try 'ibbackup --help' for more details on this option.
+310                                                   
+311                                                       --throttle=IOS
+312                                                                   This option is passed to the xtrabackup child process.
+313                                                                   It limits count of IO operations (pairs of read&write) per
+314                                                                   second to IOS values (for '--backup')
+315                                                   
+316                                                       --sleep=MS 
+317                                                                   This option is passed to the ibbackup child process.
+318                                                                   It instructs the ibbackup program to sleep 
+319                                                                   MS milliseconds after each 1 MB of copied data.
+320                                                                   You can use this parameter to tune the additional 
+321                                                                   disk i/o load the ibbackup program causes on the computer.
+322                                                                   Try 'ibbackup --help' for more details on this option.
+323                                                                   ** it is not supported by xtrabackup **
+324                                                   
+325                                                       --compress[=LEVEL]
+326                                                                   This option is passed to the ibbackup child process.
+327                                                                   It instructs ibbackup to compress the backup copies of 
+328                                                                   InnoDB data files. Compression level can be
+329                                                                   specified as an optional argument. Compression level is 
+330                                                                   an integer between 0 and 9: 1 gives fastest compression, 
+331                                                                   9 gives best compression, and 0 means no compression. 
+332                                                                   If compression level is not given, the default level 1 is used.
+333                                                                   Try 'ibbackup --help' for more details on this option.
+334                                                                   ** it is not supported by xtrabackup yet **
+335                                                   
+336                                                       --include=REGEXP 
+337                                                                   This option is passed to the ibbackup child process.
+338                                                                   It tells ibbackup to backup only those per-table data
+339                                                                   files which match the given regular expression.  For
+340                                                                   each table with a per-table data file a string of the
+341                                                                   form db_name.table_name is checked against the regular
+342                                                                   expression.  If the regular expression matches the
+343                                                                   complete string db_name.table_name, the table is
+344                                                                   included in the backup. The regular expression should
+345                                                                   be of the POSIX 1003.2 "extended" form.  
+346                                                                   Try 'ibbackup --help' for more details on this option.
+347                                                   
+348                                                       --databases=LIST
+349                                                                   This option is used to specify the list of databases that
+350                                                                   innobackup should backup. The list is of the form
+351                                                                   "db_name[.table_name] db_name1[.table_name1] ...".
+352                                                                   If this option is not specified all databases containing 
+353                                                                   MyISAM and InnoDB tables will be backed up. 
+354                                                                   Please make sure that --databases contains all of the 
+355                                                                   innodb databases & tables so that all of the innodb .frm 
+356                                                                   files are also backed up. In case the list is very long, 
+357                                                                   this can be specified in a file and the full path of the 
+358                                                                   file can be specified instead of the list.
+359                                                   
+360                                                       --uncompress
+361                                                                   This option is passed to the ibbackup child process.
+362                                                                   It tells ibbackup to uncompress compressed InnoDB data files.
+363                                                                   Try 'ibbackup --help' for more details on this option.
+364                                                                   ** it is not supported by xtrabackup yet **
+365                                                                   
+366                                                       --export   
+367                                                                   This option is passed to the xtrabackup child process.
+368                                                                   It is effective with '--prepare' option.
+369                                                                   It tells xtrabackup to output "clean" .ibd files and .exp
+370                                                                   files for 'ALTER TABLE ... IMPORT TABLESPACE' command
+371                                                                   at innodb_expand_import option enabled XtraDB.
+372                                                   
+373                                                       --user=NAME 
+374                                                                   This option is passed to the mysql child process.
+375                                                                   It defines the user for database login if not current user.
+376                                                                   Try 'mysql --help' for more details on this option.
+377                                                   
+378                                                       --password=WORD
+379                                                                   This option is passed to the mysql child process.
+380                                                                   It defines the password to use when connecting to database.
+381                                                                   Try 'mysql --help' for more details on this option.
+382                                                   
+383                                                       --host=HOST
+384                                                                   This option is passed to the mysql child process.
+385                                                                   It defines the hostname or IP address to use when connecting
+386                                                                   to the database server.
+387                                                                   Try 'mysql --help' for more details on this option.
+388                                                   
+389                                                       --port=PORT 
+390                                                                   This option is passed to the mysql child process.
+391                                                                   It defines the port to use when connecting to local database
+392                                                                   server with TCP/IP.
+393                                                                   Try 'mysql --help' for more details on this option.
+394                                                   
+395                                                       --slave-info
+396                                                                   This option is useful when backing up a replication
+397                                                                   slave server. It prints the binary log position and
+398                                                                   name of the binary log file of the master server.
+399                                                                   It also writes this information to the 'ibbackup_slave_info'
+400                                                                   file as a 'CHANGE MASTER' command. A new slave for this
+401                                                                   master can be set up by starting a slave server on this 
+402                                                                   backup and issuing a 'CHANGE MASTER' command with the binary 
+403                                                                   log position saved in the 'ibbackup_slave_info' file.
+404                                                   
+405                                                       --socket=SOCKET
+406                                                                   This option is passed to the mysql child process.
+407                                                                   It defines the socket to use when connecting to local database
+408                                                                   server with UNIX domain socket.
+409                                                                   Try 'mysql --help' for more details on this option.
+410                                                   
+411                                                       --no-timestamp
+412                                                                   This option prevents the creation of a new backup
+413                                                                   directory (named by the current date and time) under
+414                                                                   the backup root directory. Instead, the backup is put
+415                                                                   in the directory given on the command-line (in the
+416                                                                   place of BACKUP-ROOT-DIR argument). The directory must not 
+417                                                                   exist, because innobackup creates it while making a backup.
+418                                                   
+419                                                       --ibbackup=IBBACKUP-BINARY
+420                                                                   Use this option to specify which ibbackup (InnoDB Hot
+421                                                                   Backup) binary should be used.  IBBACKUP-BINARY
+422                                                                   should be the command used to run ibbackup. This can
+423                                                                   be useful if ibbackup is not in your search path or
+424                                                                   working directory.  If this option is not given,
+425                                                                   ibbackup is run with command "ibbackup".
+426                                                       --no-lock
+427                                                                   Use this option to disable table lock with
+428                                                                   FLUSH TABLES WITH READ LOCK. use it only while ALL your 
+429                                                                   tables are InnoDB and you DO NOT CARE about binary log 
+430                                                                   position of backup.
+431                                                   
+432                                                       --scpopt=SCP-OPTIONS
+433                                                                   Use this option to specify the command line options
+434                                                                   to pass to scp.  The default options are '-Cp -c arcfour'.
+435                                                   
+436                                                   EOF
+437                                                   
+438   ***      0                                  0      print STDOUT "Option values after processing arguments:\n\n";
+439   ***      0      0                           0      print STDOUT
+440   ***      0                                  0         join( "\n", sort map { "    --$_=" . $o->{$_} || '' } keys %$o ),
+441                                                         "\n\n";
+442                                                   
+443   ***      0                                  0      return;
+444                                                   }
+445                                                   
+446                                                   #
+447                                                   # return current local time as string in form "070816 12:23:15"
+448                                                   #
+449                                                   sub current_time {
+450           18                   18          1294      return strftime( "%y%m%d %H:%M:%S", localtime() );
+451                                                   }
+452                                                   
+453                                                   #
+454                                                   # Die subroutine kills all child processes and exits this process.
+455                                                   # This subroutine takes the same argument as the built-in die function.
+456                                                   #    Parameters:
+457                                                   #       message   string which is printed to stdout
+458                                                   #
+459                                                   sub Die {
+460   ***      0                    0             0      my $message    = shift;
+461   ***      0                                  0      my $extra_info = '';
+462                                                   
+463                                                      # kill all child processes of this process
+464   ***      0                                  0      kill_child_processes();
+465                                                   
+466   ***      0      0                           0      if ($current_mysql_request) {
+467   ***      0                                  0         $extra_info = " while waiting for reply to MySQL request:"
+468                                                            . " '$current_mysql_request'";
+469                                                      }
+470                                                   
+471   ***      0                                  0      IBEXDEBUG && _d('Die', $prefix, $message, $extra_info);
+472   ***      0                                  0      die "$prefix Error: $message$extra_info";
+473                                                   }
+474                                                   
+475                                                   #
+476                                                   # backup subroutine makes a backup of InnoDB and MyISAM tables, indexes and
+477                                                   # .frm files. It connects to the database server and runs ibbackup as a child
+478                                                   # process.
+479                                                   #
+480                                                   sub backup {
+481            2                    2            24      my $orig_datadir = get_option( \%config, 'mysqld', 'datadir' );
+482                                                   
+483                                                      # check that we can connect to the database. This done by
+484                                                      # connecting, issuing a query, and closing the connection.
+485            2                                 36      mysql_open();
+486            2                                 30      mysql_check();
+487            2                                452      mysql_close();
+488                                                   
+489                                                      # start ibbackup as a child process
+490            2                                 20      start_ibbackup();
+491                                                   
+492                                                      # wait for ibbackup to suspend itself
+493   ***      1     50     33                   39      if ( !$o->{'remote-host'} && !$o->{'stream'} ) {
+494            1                                 44         wait_for_ibbackup_suspend();
+495                                                      }
+496                                                   
+497   ***      1     50                          18      if ( !$o->{'incremental'} ) {
+498            1                                 15         mysql_open();
+499            1                                660         mysql_check();
+500   ***      1     50                          51         mysql_lockall() unless $o->{'no-lock'};
+501            1                                 11         backup_files();
+502                                                      }
+503                                                   
+504                                                      # resume ibbackup and wait till it has finished
+505            1                                 23      resume_ibbackup();
+506                                                   
+507   ***      1     50                          44      if ( !$o->{'incremental'} ) {
+508   ***      1     50                          18         mysql_unlockall() unless $o->{'no-lock'};
+509            1                                 20         mysql_close();
+510                                                      }
+511                                                   
+512   ***      1     50                          32      if ( $o->{'remote-host'} ) {
+      ***            50                               
+513   ***      0                                  0         system_call("scp $o->{'scp-opt'} '$tmp_logfile' "
+514                                                            . "'$o->{'remote-host'}:$backup_dir/xtrabackup_logfile'");
+515                                                   
+516   ***      0                                  0         system_call("rm -f '$tmp_logfile'");
+517                                                   
+518   ***      0                                  0         system_call("scp $o->{'scp-opt'} '$orig_datadir/xtrabackup_checkpoints' "
+519                                                            . "'$o->{'remote-host'}:$backup_dir/xtrabackup_checkpoints'");
+520                                                   
+521   ***      0                                  0         system_call("rm -f '$orig_datadir/xtrabackup_checkpoints'");
+522                                                      }
+523                                                      elsif ( $o->{'stream'} eq 'tar' ) {
+524   ***      0                                  0         system_call("cd $o->{'tmpdir'}; tar chf - xtrabackup_logfile");
+525                                                   
+526   ***      0                                  0         system_call("rm -f '$tmp_logfile'");
+527                                                   
+528   ***      0                                  0         system_call("cd $orig_datadir; tar chf - xtrabackup_checkpoints");
+529                                                   
+530   ***      0                                  0         system_call("rm -f '$orig_datadir/xtrabackup_checkpoints'");
+531                                                      }
+532                                                   
+533   ***      1     50                          35      print STDERR "\n$prefix Backup created in directory "
+534                                                         . ($o->{'remote-host'} ? "$o->{'remote-host'}:" : '')
+535                                                         . "'$backup_dir'\n";
+536                                                   
+537   ***      1     50                           9      if ($mysql_binlog_position) {
+538            1                                 40         print STDERR "$prefix MySQL binlog position: $mysql_binlog_position\n";
+539                                                      }
+540   ***      1     50     33                   13      if ( $mysql_slave_position && $o->{'slave-info'} ) {
+541   ***      0                                  0         print STDERR "$prefix MySQL slave binlog position: "
+542                                                            . "$mysql_slave_position\n";
+543                                                      }
+544                                                   
+545            1                                 16      return;
+546                                                   }
+547                                                   
+548                                                   #
+549                                                   # are_equal_innodb_data_file_paths subroutine checks if the given
+550                                                   # InnoDB data file option values are equal.
+551                                                   #   Parameters:
+552                                                   #     str1    InnoDB data file path option value
+553                                                   #     str2    InnoDB data file path option value
+554                                                   #   Return value:
+555                                                   #     1  if values are equal
+556                                                   #     0  otherwise
+557                                                   #
+558                                                   sub are_equal_innodb_data_file_paths {
+559   ***      0                    0             0      my $str1   = shift;
+560   ***      0                                  0      my $str2   = shift;
+561   ***      0                                  0      my @array1 = split( /;/, $str1 );
+562   ***      0                                  0      my @array2 = split( /;/, $str2 );
+563                                                   
+564   ***      0      0                           0      if ( $#array1 != $#array2 ) { return 0; }
+      ***      0                                  0   
+565                                                   
+566                                                      for ( my $i = 0; $i <= $#array1; $i++ ) {
+567   ***      0                                  0         my @def1 = split( /:/, $array1[$i] );
+568   ***      0                                  0         my @def2 = split( /:/, $array2[$i] );
+569                                                   
+570   ***      0      0                           0         if ( $#def1 != $#def2 ) { return 0; }
+      ***      0                                  0   
+571                                                   
+572                                                         for ( my $j = 0; $j <= $#def1; $j++ ) {
+573   ***      0      0                           0            if ( $def1[$j] ne $def2[$j] ) { return 0; }
+      ***      0                                  0   
+574   ***      0                                  0         }
+575   ***      0                                  0      }
+576   ***      0                                  0      return 1;
+577                                                   }
+578                                                   
+579                                                   #
+580                                                   # is_in_array subroutine checks if the given string is in the array.
+581                                                   #   Parameters:
+582                                                   #     str       a string
+583                                                   #     array_ref a reference to an array of strings
+584                                                   #   Return value:
+585                                                   #     1  if string is in the array
+586                                                   #     0  otherwise
+587                                                   #
+588                                                   sub is_in_array {
+589   ***      0                    0             0      my $str       = shift;
+590   ***      0                                  0      my $array_ref = shift;
+591                                                   
+592   ***      0      0                           0      if ( grep { $str eq $_ } @{$array_ref} ) {
+      ***      0                                  0   
+      ***      0                                  0   
+593   ***      0                                  0         return 1;
+594                                                      }
+595   ***      0                                  0      return 0;
+596                                                   }
+597                                                   
+598                                                   #
+599                                                   # copy_back subroutine copies data and index files from backup directory
+600                                                   # back to their original locations.
+601                                                   #
+602                                                   sub copy_back {
+603   ***      0                    0             0      my $orig_datadir = get_option( \%config, 'mysqld', 'datadir' );
+604   ***      0                                  0      my $orig_ibdata_dir =
+605                                                         get_option( \%config, 'mysqld', 'innodb_data_home_dir' );
+606   ***      0                                  0      my $orig_innodb_data_file_path =
+607                                                         get_option( \%config, 'mysqld', 'innodb_data_file_path' );
+608   ***      0                                  0      my $orig_iblog_dir =
+609                                                         get_option( \%config, 'mysqld', 'innodb_log_group_home_dir' );
+610   ***      0                                  0      my $excluded_files =
+611                                                         '^(\.\.?|backup-my\.cnf|xtrabackup_logfile|mysql-std(err|out)|.*\.ibz)$';
+612   ***      0                                  0      my @ibdata_files;
+613   ***      0                                  0      my $iblog_files          = '^ib_logfile.*$';
+614   ***      0                                  0      my $compressed_data_file = '.*\.ibz$';
+615   ***      0                                  0      my $file;
+616   ***      0                                  0      my $backup_innodb_data_file_path;
+617                                                   
+618                                                      # check that original data directory exists
+619   ***      0      0                           0      if ( !-d $orig_datadir ) {
+620   ***      0                                  0         Die "Original data directory '$orig_datadir' does not exist!";
+621                                                      }
+622                                                   
+623                                                      # check that original InnoDB data directory exists
+624   ***      0      0                           0      if ( !-d $orig_ibdata_dir ) {
+625   ***      0                                  0         Die "Original InnoDB data directory '$orig_ibdata_dir' does not exist!";
+626                                                      }
+627                                                   
+628                                                      # check that original InnoDB log directory exists
+629   ***      0      0                           0      if ( !-d $orig_iblog_dir ) {
+630   ***      0                                  0         Die "Original InnoDB log directory '$orig_iblog_dir' does not exist!";
+631                                                      }
+632                                                   
+633                                                      # check that the original options file and the backup options file have
+634                                                      # the same value for "innodb_data_file_path" option
+635                                                      #$backup_innodb_data_file_path =
+636                                                      #    get_option(\%backup_config, 'mysqld', 'innodb_data_file_path');
+637                                                      #if (!are_equal_innodb_data_file_paths($orig_innodb_data_file_path,
+638                                                      #                                      $backup_innodb_data_file_path)
+639                                                      #) {
+640                                                      #    Die "The value of 'innodb_data_file_path' option in the original "
+641                                                      #      . "my.cnf file '$config_file' is different from the value "
+642                                                      #      . "in the backup my.cnf file '$backup_config_file'.\n(original: "
+643                                                      #      . "'$orig_innodb_data_file_path')\n"
+644                                                      #      . "(backup:   '$backup_innodb_data_file_path')";
+645                                                      #}
+646                                                   
+647                                                      # make a list of all ibdata files in the backup directory and all
+648                                                      # directories in the backup directory under which there are ibdata files
+649   ***      0                                  0      foreach my $a ( split( /;/, $orig_innodb_data_file_path ) ) {
+650   ***      0                                  0         my $path     = ( split( /:/,   $a ) )[0];
+651   ***      0                                  0         my $filename = ( split( /\/+/, $path ) )[-1];
+652                                                   
+653                                                         # check that the backup data file exists
+654   ***      0      0                           0         if ( !-e "$backup_dir/$filename" ) {
+655   ***      0      0                           0            if ( -e "$backup_dir/${filename}.ibz" ) {
+656   ***      0                                  0               Die
+657                                                                  "Backup data file '$backup_dir/$filename' does not exist, but "
+658                                                                  . "its compressed copy '${path}.ibz' exists. Check that you "
+659                                                                  . "have run '$innobackup_script --apply-log --uncompress "
+660                                                                  . "...' before attempting '$innobackup_script --copy-back ...' !";
+661                                                            }
+662                                                            else {
+663   ***      0                                  0               Die "Backup data file '$backup_dir/$filename' does not exist.";
+664                                                            }
+665                                                         }
+666                                                   
+667   ***      0      0                           0         if ( !is_in_array( $filename, \@ibdata_files ) ) {
+668   ***      0                                  0            push( @ibdata_files, $filename );
+669                                                         }
+670                                                      }
+671                                                   
+672                                                      # copy files from backup dir to their original locations
+673                                                   
+674                                                      # copy files to original data directory
+675   ***      0      0                           0      opendir( DIR, $backup_dir )
+676                                                         || Die "Can't open directory '$backup_dir': $OS_ERROR\n";
+677   ***      0                                  0      print STDERR "$prefix Starting to copy MyISAM tables, indexes,\n";
+678   ***      0                                  0      print STDERR
+679                                                         "$prefix .MRG, .TRG, .TRN, .ARM, .ARZ, .opt, and .frm files\n";
+680   ***      0                                  0      print STDERR "$prefix in '$backup_dir'\n";
+681   ***      0                                  0      print STDERR "$prefix back to original data directory '$orig_datadir'\n";
+682   ***      0                                  0      while ( defined( $file = readdir(DIR) ) ) {
+683   ***      0      0                           0         if ( $file =~ /$excluded_files/ ) { next; }
+      ***      0                                  0   
+684   ***      0      0                           0         if ( is_in_array( $file, \@ibdata_files ) ) { next; }
+      ***      0                                  0   
+685   ***      0      0                           0         if ( $file =~ /$iblog_files/ ) { next; }
+      ***      0                                  0   
+686   ***      0      0                           0         if ( -d "$backup_dir/$file" ) {
+687   ***      0                                  0            my $subdir = "$backup_dir/$file";
+688   ***      0                                  0            my $file2;
+689                                                   
+690   ***      0                                  0            print STDERR "$prefix Copying directory '$subdir'\n";
+691   ***      0      0                           0            if ( !-x "\"" . escape_path("$orig_datadir/$file") . "\"" ) {
+692   ***      0                                  0               system_call("mkdir \"" . escape_path("$orig_datadir/$file") . "\"");
+693                                                            }
+694   ***      0      0                           0            opendir( SUBDIR, "$subdir" )
+695                                                               || Die "Can't open directory '$subdir': $OS_ERROR\n";
+696   ***      0                                  0            while ( defined( $file2 = readdir(SUBDIR) ) ) {
+697   ***      0      0                           0               if ( -d "$subdir/$file2" ) { next; }
+      ***      0                                  0   
+698   ***      0      0                           0               if ( $file2 =~ /$compressed_data_file/ ) { next; }
+      ***      0                                  0   
+699   ***      0                                  0               $src_name = escape_path("$subdir/$file2");
+700   ***      0                                  0               $dst_name = escape_path("$orig_datadir/$file");
+701   ***      0                                  0               system_call("$CP_CMD \"$src_name\" \"$dst_name\"");
+702                                                            }
+703   ***      0                                  0            closedir(SUBDIR);
+704                                                         }
+705                                                         else {
+706   ***      0                                  0            print STDERR "$prefix Copying file " . "'$backup_dir/$file'\n";
+707   ***      0                                  0            $src_name = escape_path("$backup_dir/$file");
+708   ***      0                                  0            $dst_name = escape_path("$orig_datadir");
+709   ***      0                                  0            system_call("$CP_CMD \"$src_name\" \"$dst_name\"");
+710                                                         }
+711                                                      }
+712   ***      0                                  0      closedir(DIR);
+713                                                   
+714                                                      # copy InnoDB data files to original InnoDB data directory
+715   ***      0                                  0      print STDERR "\n$prefix Starting to copy InnoDB tables and indexes\n";
+716   ***      0                                  0      print STDERR "$prefix in '$backup_dir'\n";
+717   ***      0                                  0      print STDERR
+718                                                         "$prefix back to original InnoDB data directory '$orig_ibdata_dir'\n";
+719   ***      0                                  0      foreach my $a ( split( /;/, $orig_innodb_data_file_path ) ) {
+720                                                   
+721                                                         # get the relative pathname of a data file
+722   ***      0                                  0         my $path     = ( split( /:/,   $a ) )[0];
+723   ***      0                                  0         my $filename = ( split( /\/+/, $path ) )[-1];
+724   ***      0                                  0         print STDERR "$prefix Copying file '$backup_dir/$filename'\n";
+725   ***      0                                  0         $src_name = escape_path("$backup_dir/$filename");
+726   ***      0                                  0         $dst_name = escape_path("$orig_ibdata_dir/$path");
+727   ***      0                                  0         system_call("$CP_CMD \"$src_name\" \"$dst_name\"");
+728                                                      }
+729                                                   
+730                                                      # copy InnoDB log files to original InnoDB log directory
+731   ***      0      0                           0      opendir( DIR, $backup_dir )
+732                                                         || Die "Can't open directory '$backup_dir': $OS_ERROR\n";
+733   ***      0                                  0      print STDERR "\n$prefix Starting to copy InnoDB log files\n";
+734   ***      0                                  0      print STDERR "$prefix in '$backup_dir'\n";
+735   ***      0                                  0      print STDERR
+736                                                         "$prefix back to original InnoDB log directory '$orig_iblog_dir'\n";
+737   ***      0                                  0      while ( defined( $file = readdir(DIR) ) ) {
+738   ***      0      0      0                    0         if ( $file =~ /$iblog_files/ && -f "$backup_dir/$file" ) {
+739   ***      0                                  0            print STDERR "$prefix Copying file '$backup_dir/$file'\n";
+740   ***      0                                  0            $src_name = escape_path("$backup_dir/$file");
+741   ***      0                                  0            $dst_name = escape_path("$orig_iblog_dir");
+742   ***      0                                  0            system_call("$CP_CMD \"$src_name\" \"$dst_name\"");
+743                                                         }
+744                                                      }
+745   ***      0                                  0      closedir(DIR);
+746                                                   
+747   ***      0                                  0      print STDERR "$prefix Finished copying back files.\n\n";
+748                                                   
+749   ***      0                                  0      return;
+750                                                   }
+751                                                   
+752                                                   #
+753                                                   # apply_log subroutine prepares a backup for starting database server
+754                                                   # on the backup. It applies InnoDB log files to the InnoDB data files.
+755                                                   #
+756                                                   sub apply_log {
+757   ***      0                    0             0      my $rcode;
+758   ***      0                                  0      my $cmdline = '';
+759   ***      0                                  0      my $options = '';
+760                                                   
+761   ***      0      0                           0      if ( $o->{'defaults-file'} ) {
+762   ***      0                                  0         $options = $options . " --defaults-file=\"$o->{'defaults-file'}\" ";
+763                                                      }
+764                                                   
+765   ***      0                                  0      $options = $options . "--prepare --target-dir=$backup_dir";
+766                                                   
+767   ***      0      0                           0      if ( $o->{'uncompress'} ) {
+768   ***      0                                  0         $options = $options . ' --uncompress';
+769                                                      }
+770   ***      0      0                           0      if ( $o->{'export'} ) {
+771   ***      0                                  0         $options = $options . ' --export';
+772                                                      }
+773   ***      0      0                           0      if ( $o->{'use-memory'} ) {
+774   ***      0                                  0         $options = $options . " --use-memory=$o->{'use-memory'}";
+775                                                      }
+776                                                   
+777                                                      # run ibbackup as a child process
+778   ***      0                                  0      $cmdline = "$o->{'ibbackup'} $options";
+779   ***      0                                  0      $now     = current_time();
+780   ***      0                                  0      print STDERR "\n$now  $prefix Starting ibbackup with command: $cmdline\n\n";
+781   ***      0                                  0      $rcode = system_call($cmdline, 1);
+782   ***      0      0                           0      Die "\n$prefix ibbackup failed" if $rcode;
+783                                                   
+784   ***      0                                  0      $now = current_time();
+785   ***      0                                  0      print STDERR
+786                                                         "\n$now  $prefix Restarting xtrabackup with command: $cmdline\nfor creating ib_logfile*\n\n";
+787   ***      0                                  0      $rcode = system_call($cmdline, 1);
+788   ***      0      0                           0      Die "\n$prefix xtrabackup (2nd execution) failed" if $rcode;
+789                                                   
+790   ***      0                                  0      return;
+791                                                   }
+792                                                   
+793                                                   #
+794                                                   # wait_for_ibbackup_suspend subroutine waits until ibbackup has suspended
+795                                                   # itself.
+796                                                   #
+797                                                   sub wait_for_ibbackup_suspend {
+798            1                    1           165      print STDERR
+799                                                         "$prefix Waiting for ibbackup (pid=$ibbackup_pid) to suspend\n";
+800            1                                 94      print STDERR "$prefix Suspend file '$suspend_file'\n\n";
+801            1                                 17      for ( ;; ) {
+802            1                             2000223         sleep 2;
+803   ***      1     50                          59         last if -e $suspend_file;
+804                                                   
+805                                                         # check that ibbackup child process is still alive
+806   ***      0      0                           0         if ( $ibbackup_pid == waitpid( $ibbackup_pid, &WNOHANG ) ) {
+807   ***      0                                  0            $ibbackup_pid = '';
+808   ***      0                                  0            Die "ibbackup child process has died";
+809                                                         }
+810                                                      }
+811            1                                 16      $now = current_time();
+812            1                                200      print STDERR "\n$now  $prefix Continuing after ibbackup has suspended\n";
+813                                                   }
+814                                                   
+815                                                   #
+816                                                   # resume_ibbackup subroutine signals ibbackup to complete its execution
+817                                                   # by deleting the 'ibbackup_suspended' file.
+818                                                   #
+819                                                   sub resume_ibbackup {
+820            1                    1           222      print STDERR "$prefix Resuming ibbackup\n\n";
+821   ***      1            33                   69      unlink $suspend_file || Die "Failed to delete '$suspend_file': $OS_ERROR";
+822                                                   
+823                                                      # wait for ibbackup to finish
+824            1                             302772      waitpid( $ibbackup_pid, 0 );
+825            1                                 22      $ibbackup_pid = '';
+826                                                   }
+827                                                   
+828                                                   #
+829                                                   # start_ibbackup subroutine spawns a child process running ibbackup
+830                                                   # program for backing up InnoDB tables and indexes.
+831                                                   #
+832                                                   sub start_ibbackup {
+833            2                    2            12      my $options = '';
+834            2                                 14      my $cmdline = '';
+835            2                                 36      my $pid     = undef;
+836                                                   
+837   ***      2     50                          30      if ( $o->{'defaults-file'} ) {
+838            2                                 22         $options = $options . " --defaults-file=\"$o->{'defaults-file'}\" ";
+839                                                      }
+840                                                   
+841            2                                 12      $options = $options . "--backup --suspend-at-end";
+842                                                   
+843   ***      2     50     33                   62      if ( !$o->{'remote-host'} && !$o->{'stream'} ) {
+844            2                                 26         $options = $options . " --target-dir=$backup_dir";
+845                                                      }
+846                                                      else {
+847                                                   
+848                                                         #(datadir) for 'xtrabackup_suspended' and 'xtrabackup_checkpoints'
+849   ***      0                                  0         $options = $options . " --log-stream --target-dir=./";
+850                                                      }
+851                                                   
+852                                                      # prepare command line for running ibbackup
+853   ***      2     50                          20      if ( $o->{'throttle'} ) {
+854   ***      0                                  0         $options = $options . " --throttle=$o->{'throttle'}";
+855                                                      }
+856   ***      2     50                          18      if ( $o->{'sleep'} ) {
+857   ***      0                                  0         $options = $options . " --sleep=$o->{'sleep'}";
+858                                                      }
+859   ***      2     50                          16      if ( $o->{'compress'} ) {
+860   ***      0                                  0         $options = $options . " --compress=$o->{'compress'}";
+861                                                      }
+862   ***      2     50                          26      if ( $o->{'use-memory'} ) {
+863   ***      0                                  0         $options = $options . " --use-memory=$o->{'use-memory'}";
+864                                                      }
+865   ***      2     50                          16      if ( $o->{'include'} ) {
+866   ***      0                                  0         $options = $options . " --tables='$o->{'include'}'";
+867                                                      }
+868   ***      2     50                          16      if ( $o->{'incremental'} ) {
+869   ***      0                                  0         $options = $options . " --incremental-basedir='$incremental_basedir'";
+870                                                      }
+871            2                                 24      $cmdline = "$o->{'ibbackup'} $options";
+872                                                   
+873                                                      # run ibbackup as a child process
+874            2                                 10      $now = current_time();
+875            2                                 64      print STDERR "\n$now  $prefix Starting ibbackup with command: $cmdline\n";
+876   ***      2     50                       23639      if ( defined($pid = fork) ) {
+877            2    100                          64         if ($pid) {
+878                                                            # parent process
+879            1                                 34            $ibbackup_pid = $pid;
+880                                                   
+881                                                            # direct copy to remote
+882   ***      1     50     33                   96            if ( $o->{'remote-host'} || $o->{'stream'} ) {
+883   ***      0                                  0               my $orig_datadir
+884                                                                  = get_option( \%config, 'mysqld', 'datadir' );
+885   ***      0                                  0               my $orig_ibdata_dir
+886                                                                  = get_option( \%config, 'mysqld', 'innodb_data_home_dir' );
+887   ***      0                                  0               my $orig_innodb_data_file_path
+888                                                                  = get_option( \%config, 'mysqld', 'innodb_data_file_path' );
+889   ***      0                                  0               my $subdir;
+890   ***      0                                  0               my @list;
+891                                                   
+892   ***      0      0                           0               if ( $o->{'remote-host'} ) {
+893   ***      0      0                           0                  if ( system_call("ssh $o->{'remote-host'} test -e "
+894                                                                           . "$backup_dir/ib_logfile0", 1) == 0 ) {
+895   ***      0                                  0                     print STDERR "$prefix Remove "
+896                                                                        . "$o->{'remote-host'}:$backup_dir/ib_logfile*\n";
+897   ***      0                                  0                     system_call( "ssh $o->{'remote-host'} "
+898                                                                        . "rm $backup_dir/ib_logfile\*"
+899                                                                     )
+900                                                                  }
+901                                                               }
+902                                                   
+903   ***      0                                  0               wait_for_ibbackup_suspend();
+904                                                   
+905                                                               #InnoDB data files from original InnoDB data directory
+906   ***      0                                  0               print STDERR
+907                                                                  "\n$prefix Starting to backup InnoDB tables and indexes\n";
+908   ***      0      0                           0               if ( $o->{'remote-host'} ) {
+909   ***      0                                  0                  print STDERR "$prefix to '$backup_dir'\n";
+910                                                               }
+911   ***      0                                  0               print STDERR
+912                                                                  "$prefix from original InnoDB data directory '$orig_ibdata_dir'\n";
+913   ***      0                                  0               foreach my $a ( split( /;/, $orig_innodb_data_file_path ) ) {
+914   ***      0                                  0                  my $path = ( split( /:/, $a ) )[0];
+915   ***      0                                  0                  $path =~ s/([\$\\\" ])/\\$1/g;
+916   ***      0      0                           0                  if ( $o->{'remote-host'} ) {
+      ***             0                               
+917   ***      0                                  0                     print STDERR
+918                                                                        "$prefix Backing up file '$orig_ibdata_dir/$path'\n";
+919   ***      0                                  0                     system_call("scp $o->{'scp-opt'} '$orig_ibdata_dir/$path' "
+920                                                                        . "'$o->{'remote-host'}:$backup_dir/$path'");
+921                                                                  }
+922                                                                  elsif ( $o->{'stream'} eq 'tar' ) {
+923   ***      0                                  0                     my $ret = 0;
+924   ***      0                                  0                     print STDERR "$prefix Backing up as tar stream '$path'\n";
+925   ***      0      0                           0                     if ( !$o->{'tar4ibd'} ) {
+926   ***      0                                  0                        $ret = system_call(
+927                                                                           "cd $orig_ibdata_dir; tar chf - -b 32 $path", 1);
+928                                                                     }
+929                                                                     else {
+930   ***      0                                  0                        $ret = system_call(
+931                                                                           "cd $orig_ibdata_dir; tar4ibd -c $path", 1);
+932                                                                     }
+933   ***      0      0                           0                     if ( $ret == 1 ) {
+      ***             0                               
+934   ***      0                                  0                        print STDERR "$prefix If you use GNU tar, this warning "
+935                                                                           . "can be ignored.\n";
+936                                                                     }
+937                                                                     elsif ( $ret != 0 ) {
+938   ***      0                                  0                        print STDERR "$prefix tar returned with exit code $ret.\n";
+939   ***      0                                  0                        Die "Failed to stream '$path': $OS_ERROR";
+940                                                                     }
+941                                                                  }
+942                                                               }
+943                                                   
+944                                                               #copy *.ibd files
+945   ***      0      0                           0               opendir( DIR, $orig_datadir )
+946                                                                  || Die "Can't open directory '$orig_datadir': $OS_ERROR\n";
+947   ***      0                                  0               while ( defined( $subdir = readdir(DIR) ) ) {
+948   ***      0                                  0                  my $print_each_file = 0;
+949   ***      0                                  0                  my $file_c;
+950   ***      0                                  0                  my $file;
+951   ***      0      0      0                    0                  if ( $subdir eq '.' || $subdir eq '..' ) { next; }
+      ***      0                                  0   
+952   ***      0      0                           0                  next unless -d "$orig_datadir/$subdir";
+953   ***      0      0                           0                  next unless check_if_required($subdir);
+954                                                   
+955   ***      0                                  0                  @list = glob( "$orig_datadir/$subdir/" . '*.ibd' );
+956                                                   
+957   ***      0                                  0                  $file_c = @list;
+958   ***      0      0                           0                  if ( $file_c <= $backup_file_print_limit ) {
+959   ***      0                                  0                     $print_each_file = 1;
+960                                                                  }
+961                                                                  else {
+962   ***      0                                  0                     print STDERR "$prefix Backing up files "
+963                                                                        . "'$orig_datadir/$subdir/*.ibd' ($file_c files)\n";
+964                                                                  }
+965                                                   
+966   ***      0                                  0                  foreach $file ( @list ) {
+967   ***      0      0                           0                     if ( $o->{'include'} ) {
+968   ***      0                                  0                        my $table_name;
+969   ***      0                                  0                        $table_name = substr($file, rindex( $file, '/' ));
+970   ***      0                                  0                        $table_name = substr( $table_name, 1,
+971                                                                           rindex( $table_name, '.' ) - 1);
+972   ***      0                                  0                        $table_name = $subdir . "." . $table_name;
+973   ***      0      0                           0                        if ( $table_name !~ m/$o->{'include'}/o ) {
+974   ***      0                                  0                           print STDERR "'$file' is skipped.\n";
+975   ***      0                                  0                           next;
+976                                                                        }
+977                                                                     }
+978                                                   
+979   ***      0      0                           0                     if ($print_each_file) {
+980   ***      0                                  0                        print STDERR "$prefix Backing up file '$file'\n";
+981                                                                     }
+982                                                   
+983   ***      0      0                           0                     if ( $o->{'remote-host'} ) {
+      ***             0                               
+984   ***      0                                  0                        system_call(
+985                                                                           "ssh $o->{'remote-host'} mkdir '$backup_dir/$subdir'",
+986                                                                           1  # don't die on failure
+987                                                                        );
+988   ***      0                                  0                        system_call("scp $o->{'scp-opt'} '$file' "
+989                                                                           . "'$o->{'remote-host'}:$backup_dir/$subdir/'");
+990                                                                     }
+991                                                                     elsif ( $o->{'stream'} eq 'tar' ) {
+992   ***      0                                  0                        my $ret       = 0;
+993   ***      0                                  0                        my $file_name = substr($file, rindex( $file, '/' ) + 1);
+994   ***      0                                  0                        $file_name    =~ s/([\$\\\" ])/\\$1/g;
+995                                                   
+996   ***      0      0                           0                        if ( !$o->{'tar4ibd'} ) {
+997   ***      0                                  0                           $ret = system_call("cd $orig_datadir; tar chf - -b 32 "
+998                                                                              . "$subdir/$file_name", 1);
+999                                                                        }
+1000                                                                       else {
+1001  ***      0                                  0                           $ret = system_call("cd $orig_datadir; tar4ibd -c "
+1002                                                                             . "$subdir/$file_name", 1);
+1003                                                                       }
+1004                                                  
+1005  ***      0      0                           0                        if ( $ret == 1 ) {
+      ***             0                               
+1006  ***      0                                  0                           print STDERR "$prefix If you use GNU tar, this warning "
+1007                                                                             . "can be ignored.\n";
+1008                                                                       }
+1009                                                                       elsif ( $ret != 0 ) {
+1010  ***      0                                  0                           print STDERR "$prefix tar returned with exit code "
+1011                                                                             . "$ret.\n";
+1012  ***      0                                  0                           Die "Failed to stream '$subdir/$file_name': $OS_ERROR";
+1013                                                                       }
+1014                                                                    }
+1015                                                                 }  # each file
+1016                                                              }  # each subdir
+1017  ***      0                                  0               closedir(DIR);
+1018                                                           }
+1019                                                        }  # parent process
+1020                                                        else {  # child process
+1021  ***      1     50     33                   90            if ( $o->{'remote-host'} || $o->{'stream'} ) {
+1022  ***      0      0                           0               open STDOUT, "> $tmp_logfile"
+1023                                                                 or Die "Failed to open file '$tmp_logfile': $OS_ERROR";
+1024                                                           }
+1025           1                                  4            IBEXDEBUG && _d($cmdline);
+1026  ***      1      0                          46            exec($cmdline) or Die "Failed to exec ibbackup: $OS_ERROR";
+1027                                                        }
+1028                                                     }
+1029                                                     else {
+1030  ***      0                                  0         Die "failed to fork ibbackup child process: $OS_ERROR";
+1031                                                     }
+1032                                                  }
+1033                                                  
+1034                                                  #
+1035                                                  # get_mysql_options subroutine returns the options to mysql client program
+1036                                                  # as a string. The options are determined from the options given by the
+1037                                                  # user to innobackup.
+1038                                                  #
+1039                                                  sub get_mysql_options {
+1040          10                   10            56      my @options;
+1041                                                  
+1042                                                     # --defaults-file needs to be first.
+1043          10    100                          82      if ( $o->{'defaults-file'} ) {
+1044           8                                106         push @options, "--defaults-file=$o->{'defaults-file'}";
+1045                                                     }
+1046                                                  
+1047          10    100                          72      if ( $o->{'host'} ) {
+1048           1                                  5         push @options, "--host=$o->{'host'}";
+1049                                                     }
+1050          10    100                          65      if ( $o->{'port'} ) {
+1051           2                                 11         push @options, "--port=$o->{'port'}";
+1052                                                     }
+1053          10    100                          62      if ( $o->{'user'} ) {
+1054           2                                 10         push @options, "--user=$o->{'user'}";
+1055                                                     }
+1056          10    100                          61      if ( $o->{'password'} ) {
+1057           4                                 19         push @options, "--password=$o->{'password'}";
+1058                                                     }
+1059  ***     10     50                          65      if ( $o->{'socket'} ) {
+1060  ***      0                                  0         push @options, "--socket=$o->{'socket'}";
+1061                                                     }
+1062                                                  
+1063          10                                 46      push @options, '--unbuffered --';
+1064                                                  
+1065          10                                 73      my $options = join( ' ', @options );
+1066          10                                 31      IBEXDEBUG && _d('mysql options:', $options);
+1067          10                                 83      return $options;
+1068                                                  }
+1069                                                  
+1070                                                  #
+1071                                                  # mysql_open subroutine starts mysql as a child process with
+1072                                                  # a pipe connection.
+1073                                                  #
+1074                                                  sub mysql_open {
+1075           3                    3            31      my $options = get_mysql_options();
+1076                                                  
+1077                                                     # run mysql as a child process with a pipe connection
+1078           3                                 30      $now = current_time();
+1079           3                                398      print STDERR "$now  $prefix Starting mysql with options: $options\n";
+1080  ***      3     50                       14260      $mysql_pid = open(*MYSQL_WRITER,
+1081                                                        "| mysql $options >$mysql_stdout 2>$mysql_stderr ")
+1082                                                        or Die "Failed to spawn mysql child process: $OS_ERROR";
+1083           3                                254      MYSQL_WRITER->autoflush(1);
+1084           3                                113      $now = current_time();
+1085           3                               5000      print STDERR "$now  $prefix Connected to database with mysql child process (pid=$mysql_pid)\n";
+1086                                                  
+1087           3                                 70      return;
+1088                                                  }
+1089                                                  
+1090                                                  #
+1091                                                  # mysql_check subroutine checks that the connection to mysql child process
+1092                                                  # is ok.
+1093                                                  #
+1094                                                  sub mysql_check {
+1095           9                    9            85      my $mysql_pid_copy = $mysql_pid;
+1096                                                  
+1097                                                     # send a dummy query to mysql child process
+1098           9                                 69      $hello_id++;
+1099           9                                 73      my $hello_message = "innobackup hello $hello_id";
+1100           9                                 36      IBEXDEBUG && _d('mysql check:', $hello_message);
+1101  ***      9     50                        5816      print MYSQL_WRITER "select '$hello_message';\n"
+1102                                                        or Die "Connection to mysql child process failed: $OS_ERROR";
+1103                                                  
+1104                                                     # wait for reply
+1105           9                                 82      eval {
+1106  ***      9                    0           432         local $SIG{ALRM} = sub { die "alarm clock restart" };
+      ***      0                                  0   
+1107           9                                 73         my $stdout = '';
+1108           9                                 55         my $stderr = '';
+1109           9                                125         alarm $mysql_response_timeout;
+1110           9                                 93         while ( index( $stdout, $hello_message ) < 0 ) {
+1111           9                             18001882            sleep 2;
+1112  ***      9     50     33                  718            if ( $mysql_pid && $mysql_pid == waitpid( $mysql_pid, &WNOHANG ) ) {
+1113  ***      0                                  0               my $reason = `cat $mysql_stderr`;
+1114  ***      0                                  0               $mysql_pid = '';
+1115  ***      0                                  0               die "mysql child process has died: $reason";
+1116                                                           }
+1117           9                              53378            $stdout = `cat $mysql_stdout`;
+1118           9                              47330            $stderr = `cat $mysql_stderr`;
+1119  ***      9     50                         360            if ($stderr) {
+1120                                                              # mysql has reported an error, do exit
+1121  ***      0                                  0               die "mysql error: $stderr";
+1122                                                           }
+1123                                                        }
+1124           9                                667         alarm 0;
+1125                                                     };
+1126  ***      9     50                         176      if ( $EVAL_ERROR =~ /alarm clock restart/ ) {
+      ***            50                               
+1127  ***      0                                  0         Die "Connection to mysql child process (pid=$mysql_pid_copy) timedout."
+1128                                                           . " (Time limit of $mysql_response_timeout seconds exceeded."
+1129                                                           . " You may adjust time limit by editing the value of parameter"
+1130                                                           . " \"\$mysql_response_timeout\" in this script.)";
+1131                                                     }
+1132                                                     elsif ( $EVAL_ERROR ) {
+1133  ***      0                                  0         Die $EVAL_ERROR;
+1134                                                     }
+1135                                                  
+1136           9                                 81      $mysql_last_access_time = time();
+1137                                                  
+1138           9                                171      return;
+1139                                                  }
+1140                                                  
+1141                                                  #
+1142                                                  # mysql_keep_alive subroutine tries to keep connection to the mysqld database
+1143                                                  # server alive by sending a dummy query when the connection has been idle
+1144                                                  # for the specified time.
+1145                                                  #
+1146                                                  sub mysql_keep_alive {
+1147  ***      5     50             5            63      if ( ( time() - $mysql_last_access_time ) > $mysql_keep_alive_timeout ) {
+1148                                                        # too long idle, send a dummy query
+1149  ***      0                                  0         mysql_check();
+1150                                                     }
+1151           5                                 23      return;
+1152                                                  }
+1153                                                  
+1154                                                  #
+1155                                                  # mysql_send subroutine send a request string to mysql child process.
+1156                                                  # This subroutine appends a newline character to the request and checks
+1157                                                  # that mysqld receives the query.
+1158                                                  # Parameters:
+1159                                                  #    request  request string
+1160                                                  #
+1161                                                  sub mysql_send {
+1162           6                    6            59      my $request = shift;
+1163           6                                 41      $current_mysql_request = $request;
+1164           6                                652      print MYSQL_WRITER "$request\n";
+1165           6                                 53      mysql_check();
+1166           6                                 99      $current_mysql_request = '';
+1167           6                                 57      return;
+1168                                                  }
+1169                                                  
+1170                                                  #
+1171                                                  # mysql_close subroutine terminates mysql child process gracefully.
+1172                                                  #
+1173                                                  sub mysql_close {
+1174           3                    3            95      print MYSQL_WRITER "quit\n";
+1175           3                                 50      $now = current_time();
+1176           3                                 94      print STDERR "$now  $prefix Connection to database server closed\n";
+1177           3                                 34      $mysql_pid = '';
+1178           3                                 20      return;
+1179                                                  }
+1180                                                  
+1181                                                  #
+1182                                                  # write_binlog_info subroutine retrieves MySQL binlog position and
+1183                                                  # saves it in a file. It also prints it to stdout.
+1184                                                  #
+1185                                                  sub write_binlog_info {
+1186           1                    1             9      my @lines;
+1187           1                                 22      my @info_lines = ();
+1188           1                                 12      my $position   = '';
+1189           1                                  7      my $filename   = '';
+1190                                                  
+1191                                                     # get binlog position
+1192           1                                 13      mysql_send "SHOW MASTER STATUS;";
+1193                                                  
+1194                                                     # get "show master status" output lines (2) from mysql output
+1195           1                                 69      file_to_array( $mysql_stdout, \@lines );
+1196           1                                 10      foreach my $line (@lines) {
+1197          14    100                         112         if ( $line =~ m/innobackup hello/ ) {
+1198                                                  
+1199                                                           # this is a hello message, ignore it
+1200                                                        }
+1201                                                        else {
+1202                                                  
+1203                                                           # this is output line from "show master status"
+1204           2                                 13            push( @info_lines, $line );
+1205                                                        }
+1206                                                     }
+1207                                                  
+1208                                                     # write binlog info file
+1209  ***      1     50                          11      if ( !defined $info_lines[1] ) {
+1210  ***      0                                  0         $info_lines[1] = "";
+1211                                                     }
+1212  ***      1     50                          10      if ( !$o->{'remote-host'} ) {
+1213  ***      1     50                          92         open( FILE, ">$binlog_info" )
+1214                                                           || Die "Failed to open file '$binlog_info': $OS_ERROR";
+1215                                                     }
+1216                                                     else {
+1217  ***      0      0                           0         open( FILE, "| ssh $o->{'remote-host'} 'cat > $binlog_info'" )
+1218                                                           || Die
+1219                                                           "Failed to open file '$o->{'remote-host'}:$binlog_info': $OS_ERROR";
+1220                                                     }
+1221           1                                 21      print FILE "$info_lines[1]\n";
+1222           1                                 43      close(FILE);
+1223                                                  
+1224  ***      1     50                          14      if ( $o->{'stream'} eq 'tar' ) {
+1225  ***      0                                  0         system_call("cd $o->{'tmpdir'}; tar chf - xtrabackup_binlog_info");
+1226  ***      0      0                           0         unlink $binlog_info or Die "Failed to delete '$binlog_info': $OS_ERROR";
+1227                                                     }
+1228                                                  
+1229                                                     # get the name of the last binlog file and position in it
+1230           1                                 37      ( $filename, $position ) = $info_lines[1] =~ /^\s*([^\s]+)\s+(.*)$/;
+1231                                                  
+1232  ***      1     50     33                   33      if ( defined $filename && defined $position ) {
+1233           1                                 11         $mysql_binlog_position = "filename '$filename', position $position";
+1234                                                     }
+1235                                                     else {
+1236  ***      0                                  0         $mysql_binlog_position = "filename '', position ";
+1237                                                     }
+1238                                                  
+1239           1                                  8      return;
+1240                                                  }
+1241                                                  
+1242                                                  #
+1243                                                  # write_slave_info subroutine retrieves MySQL binlog position of the
+1244                                                  # master server in a replication setup and saves it in a file. It
+1245                                                  # also saves it in $msql_slave_position variable.
+1246                                                  #
+1247                                                  sub write_slave_info {
+1248  ***      0                    0             0      my @lines;
+1249  ***      0                                  0      my @info_lines;
+1250  ***      0                                  0      my $position = '';
+1251  ***      0                                  0      my $filename = '';
+1252  ***      0                                  0      my $master   = '';
+1253                                                  
+1254                                                     # get slave status. Use single quotes here, otherwise
+1255                                                     # \G is evaluated as a control character.
+1256  ***      0                                  0      mysql_send 'SHOW SLAVE STATUS\G;';
+1257                                                  
+1258                                                     # get output of the "show slave status" command from mysql output
+1259                                                     # and extract binlog position of the master server
+1260  ***      0                                  0      file_to_array( $mysql_stdout, \@lines );
+1261  ***      0                                  0      for (@lines) {
+1262  ***      0      0                           0         $master   = $1 if /Master_Host:\s*(\S*)\s*$/;
+1263  ***      0      0                           0         $filename = $1 if /Master_Log_File:\s*(\S*)\s*$/;
+1264  ***      0      0                           0         $position = $1 if /Master_Log_Pos:\s*(\S*)\s*$/;
+1265                                                     }
+1266                                                  
+1267                                                     # print slave status to a file
+1268  ***      0      0                           0      if ( !$o->{'remote-host'} ) {
+1269  ***      0      0                           0         open( FILE, ">$slave_info" )
+1270                                                           || Die "Failed to open file '$slave_info': $OS_ERROR";
+1271                                                     }
+1272                                                     else {
+1273  ***      0      0                           0         open( FILE, "| ssh $o->{'remote-host'} 'cat > $slave_info'" )
+1274                                                           || Die
+1275                                                           "Failed to open file '$o->{'remote-host'}:$slave_info': $OS_ERROR";
+1276                                                     }
+1277  ***      0                                  0      print FILE
+1278                                                        "CHANGE MASTER TO MASTER_LOG_FILE='$filename', MASTER_LOG_POS=$position\n";
+1279  ***      0                                  0      close(FILE);
+1280                                                  
+1281  ***      0      0                           0      if ( $o->{'stream'} eq 'tar' ) {
+1282  ***      0                                  0         system_call("cd $o->{'tmpdir'}; tar chf - xtrabackup_slave_info");
+1283  ***      0      0                           0         unlink $slave_info or Die "Failed to delete '$slave_info': $OS_ERROR";
+1284                                                     }
+1285                                                  
+1286                                                     $mysql_slave_position =
+1287  ***      0                                  0         "master host '$master', filename '$filename', position $position";
+1288                                                  
+1289  ***      0                                  0      return;
+1290                                                  }
+1291                                                  
+1292                                                  #
+1293                                                  # mysql_lockall subroutine puts a read lock on all tables in all databases.
+1294                                                  #
+1295                                                  sub mysql_lockall {
+1296           1                    1            16      $now = current_time();
+1297           1                                 46      print STDERR "$now  $prefix Starting to lock all tables...\n";
+1298                                                  
+1299           1                                 21      mysql_send "USE mysql;";
+1300                                                  
+1301                                                  #    mysql_send "DROP TABLE IF EXISTS ibbackup_binlog_marker;";
+1302                                                  #    if (compare_versions($mysql_server_version, '4.1.0') == -1) {
+1303                                                  #        # MySQL server version is 4.0 or older, ENGINE keyword not supported
+1304                                                  #        mysql_send "CREATE TABLE ibbackup_binlog_marker(a INT) TYPE=INNODB;";
+1305                                                  #    } else {
+1306                                                  #        # MySQL server version is 4.1 or newer, use ENGINE keyword
+1307                                                  #        mysql_send "CREATE TABLE ibbackup_binlog_marker(a INT) ENGINE=INNODB;";
+1308                                                  #    }
+1309           1                                 19      mysql_send "SET AUTOCOMMIT=0;";
+1310                                                  
+1311                                                     #    mysql_send "INSERT INTO ibbackup_binlog_marker VALUES (1);";
+1312  ***      1     50     33                   42      if (  compare_versions( $mysql_server_version, '4.0.22' ) == 0
+1313                                                        || compare_versions( $mysql_server_version, '4.1.7' ) == 0 )
+1314                                                     {
+1315                                                  
+1316                                                        # MySQL server version is 4.0.22 or 4.1.7
+1317  ***      0                                  0         mysql_send "COMMIT;";
+1318  ***      0                                  0         mysql_send "FLUSH TABLES WITH READ LOCK;";
+1319                                                     }
+1320                                                     else {
+1321                                                  
+1322                                                        # MySQL server version is other than 4.0.22 or 4.1.7
+1323           1                                 13         mysql_send "FLUSH TABLES WITH READ LOCK;";
+1324           1                                 34         mysql_send "COMMIT;";
+1325                                                     }
+1326           1                                 47      write_binlog_info;
+1327  ***      1     50                          10      write_slave_info if $o->{'slave-info'};
+1328                                                  
+1329           1                                 19      $now = current_time();
+1330           1                                 39      print STDERR "$now  $prefix All tables locked and flushed to disk\n";
+1331                                                  
+1332           1                                  5      return;
+1333                                                  }
+1334                                                  
+1335                                                  #
+1336                                                  # mysql_unlockall subroutine releases read locks on all tables in all
+1337                                                  # databases.
+1338                                                  #
+1339                                                  sub mysql_unlockall {
+1340           1                    1            17      mysql_send "UNLOCK TABLES;";
+1341                                                  
+1342                                                     #    mysql_send "DROP TABLE IF EXISTS ibbackup_binlog_marker;";
+1343                                                  
+1344           1                                 35      $now = current_time();
+1345           1                                 58      print STDERR "$now  $prefix All tables unlocked\n";
+1346                                                  }
+1347                                                  
+1348                                                  #
+1349                                                  # catch_sigpipe subroutine is a signal handler for SIGPIPE.
+1350                                                  #
+1351                                                  sub catch_sigpipe {
+1352  ***      0                    0             0      my $rcode;
+1353                                                  
+1354  ***      0      0      0                    0      if (
+      ***                    0                        
+1355                                                        $mysql_pid
+1356                                                        && ( -1 == ( $rcode = waitpid( $mysql_pid, &WNOHANG ) )
+1357                                                           || $rcode == $mysql_pid )
+1358                                                        )
+1359                                                     {
+1360  ***      0                                  0         my $reason = `cat $mysql_stderr`;
+1361  ***      0                                  0         print STDERR "Pipe to mysql child process broken: $reason at";
+1362  ***      0                                  0         system("date +'%H:%M:%S'");
+1363  ***      0                                  0         exit(1);
+1364                                                     }
+1365                                                     else {
+1366  ***      0                                  0         Die "Broken pipe";
+1367                                                     }
+1368                                                  }
+1369                                                  
+1370                                                  #
+1371                                                  # kill_child_processes subroutine kills all child processes of this process.
+1372                                                  #
+1373                                                  sub kill_child_processes {
+1374  ***      0      0             0             0      if ($ibbackup_pid) {
+1375  ***      0                                  0         kill( $kill_signal, $ibbackup_pid );
+1376  ***      0                                  0         $ibbackup_pid = '';
+1377                                                     }
+1378                                                  
+1379  ***      0      0                           0      if ($mysql_pid) {
+1380  ***      0                                  0         kill( $kill_signal, $mysql_pid );
+1381  ***      0                                  0         $mysql_pid = '';
+1382                                                     }
+1383                                                  }
+1384                                                  
+1385                                                  #
+1386                                                  # require_external subroutine checks that an external program is runnable
+1387                                                  # via the shell. This is tested by calling the program with the
+1388                                                  # given arguments. It is checked that the program returns 0 and does
+1389                                                  # not print anything to stderr. If this check fails, this subroutine exits.
+1390                                                  #    Parameters:
+1391                                                  #       program      pathname of the program file
+1392                                                  #       args         arguments to the program
+1393                                                  #       pattern      a string containing a regular expression for finding
+1394                                                  #                    the program version.
+1395                                                  #                    this pattern should contain a subpattern enclosed
+1396                                                  #                    in parentheses which is matched with the version.
+1397                                                  #       version_ref  a reference to a variable where the program version
+1398                                                  #                    string is returned. Example "2.0-beta2".
+1399                                                  #
+1400                                                  sub require_external {
+1401           2                    2            12      my $program     = shift;
+1402           2                                 10      my $args        = shift;
+1403           2                                 10      my $pattern     = shift;
+1404           2                                 10      my $version_ref = shift;
+1405           2                                  8      my @lines;
+1406           2                                144      my $tmp_stdout = tmpnam();
+1407           2                                 46      my $tmp_stderr = tmpnam();
+1408           2                                  8      my $rcode;
+1409           2                                  6      my $error;
+1410                                                  
+1411           2                                 50      $rcode = system_call("$program $args >$tmp_stdout 2>$tmp_stderr", 1);
+1412  ***      2     50                          32      if ($rcode) {
+1413  ***      0                                  0         $error = $OS_ERROR;
+1414                                                     }
+1415           2                              14814      my $stderr = `cat $tmp_stderr`;
+1416           2                                216      unlink $tmp_stderr;
+1417  ***      2     50                          68      if ( $stderr ne '' ) {
+      ***            50                               
+1418                                                  
+1419                                                        # failure
+1420  ***      0                                  0         unlink $tmp_stdout;
+1421  ***      0                                  0         Die "Couldn't run $program: $stderr";
+1422                                                     }
+1423                                                     elsif ($rcode) {
+1424                                                  
+1425                                                        # failure
+1426  ***      0                                  0         unlink $tmp_stdout;
+1427  ***      0                                  0         Die "Couldn't run $program: $error";
+1428                                                     }
+1429                                                  
+1430                                                     # success
+1431           2                              11754      my $stdout = `cat $tmp_stdout`;
+1432           2                                182      unlink $tmp_stdout;
+1433           2                                108      @lines = split( /\n|;/, $stdout );
+1434           2                                414      print STDERR "$prefix Using $lines[0]\n";
+1435                                                  
+1436                                                     # get version string from the first output line of the program
+1437           2                                 46      ${$version_ref} = '';
+               2                                 26   
+1438  ***      2     50                         154      if ( $lines[0] =~ /$pattern/ ) {
+1439           2                                 10         ${$version_ref} = $1;
+               2                                 66   
+1440                                                     }
+1441                                                  }
+1442                                                  
+1443                                                  # compare_versions subroutine compares two GNU-style version strings.
+1444                                                  # A GNU-style version string consists of three decimal numbers delimitted
+1445                                                  # by dots, and optionally followed by extra attributes.
+1446                                                  # Examples: "4.0.1", "4.1.1-alpha-debug".
+1447                                                  #    Parameters:
+1448                                                  #       str1   a GNU-style version string
+1449                                                  #       str2   a GNU-style version string
+1450                                                  #    Return value:
+1451                                                  #       -1   if str1 < str2
+1452                                                  #        0   if str1 == str2
+1453                                                  #        1   is str1 > str2
+1454                                                  sub compare_versions {
+1455           2                    2            22      my $str1   = shift;
+1456           2                                 16      my $str2   = shift;
+1457           2                                 11      my $extra1 = '';
+1458           2                                 10      my $extra2 = '';
+1459           2                                 11      my @array1 = ();
+1460           2                                  8      my @array2 = ();
+1461           2                                  8      my $i;
+1462                                                  
+1463                                                     # remove possible extra attributes
+1464           2                                 42      ( $str1, $extra1 ) = $str1 =~ /^([0-9.]*)(.*)/;
+1465           2                                 24      ( $str2, $extra2 ) = $str2 =~ /^([0-9.]*)(.*)/;
+1466                                                  
+1467                                                     # split "dotted" decimal number string into an array
+1468           2                                 21      @array1 = split( '\.', $str1 );
+1469           2                                 17      @array2 = split( '\.', $str2 );
+1470                                                  
+1471                                                     # compare in lexicographic order
+1472                                                     for ( $i = 0; $i <= $#array1 && $i <= $#array2; $i++ ) {
+1473  ***      0      0                           0         if ( $array1[$i] < $array2[$i] ) {
+      ***             0                               
+1474  ***      0                                  0            return -1;
+1475                                                        }
+1476                                                        elsif ( $array1[$i] > $array2[$i] ) {
+1477  ***      0                                  0            return 1;
+1478                                                        }
+1479  ***      2            33                   18      }
+1480  ***      2     50                          31      if ( $#array1 < $#array2 ) {
+      ***             0                               
+1481           2                                 47         return -1;
+1482                                                     }
+1483                                                     elsif ( $#array1 > $#array2 ) {
+1484  ***      0                                  0         return 1;
+1485                                                     }
+1486                                                     else {
+1487  ***      0                                  0         return 0;
+1488                                                     }
+1489                                                  }
+1490                                                  
+1491                                                  #
+1492                                                  # init subroutine initializes global variables and performs some checks on the
+1493                                                  # system we are running on.
+1494                                                  #
+1495                                                  sub init {
+1496           2                    2            12      my $mysql_version    = '';
+1497           2                                  8      my $ibbackup_version = '';
+1498           2                                 10      my $run              = '';
+1499                                                  
+1500                                                     # print some instructions to the user
+1501  ***      2     50     33                   92      if ( !$o->{'apply-log'} && !$o->{'copy-back'} ) {
+      ***             0                               
+1502           2                                 12         $run = 'backup';
+1503                                                     }
+1504                                                     elsif ( $o->{'copy-back'} ) {
+1505  ***      0                                  0         $run = 'copy-back';
+1506                                                     }
+1507                                                     else {
+1508  ***      0                                  0         $run = 'apply-log';
+1509                                                     }
+1510           2                                 36      print STDERR
+1511                                                        "IMPORTANT: Please check that the $run run completes successfully.\n";
+1512           2                                 32      print STDERR
+1513                                                        "           At the end of a successful $run run $innobackup_script\n";
+1514           2                                 20      print STDERR "           prints \"completed OK!\".\n\n";
+1515                                                  
+1516                                                     # check that MySQL client program and InnoDB Hot Backup program
+1517                                                     # are runnable via shell
+1518  ***      2     50                          20      if ( !$o->{'copy-back'} ) {
+1519                                                  
+1520                                                        # we are making a backup or applying log to backup
+1521  ***      2     50                          14         if ( !$o->{'apply-log'} ) {
+1522                                                  
+1523                                                           # we are making a backup, we need mysql server
+1524           2                                 10            my $output = '';
+1525           2                                 12            my @lines  = ();
+1526                                                  
+1527                                                           # check that we have mysql client program
+1528           2                                 34            require_external( 'mysql', '--version', 'Ver ([^,]+)',
+1529                                                              \$mysql_version );
+1530                                                  
+1531                                                           # get mysql server version
+1532           2                                 42            my $options = get_mysql_options();
+1533           2                              27220            @lines = split( '\n', `mysql $options -e "select \@\@version"` );
+1534           2                                108            $mysql_server_version = $lines[1];
+1535           2                                146            print STDERR
+1536                                                              "$prefix Using mysql server version $mysql_server_version\n";
+1537                                                        }
+1538                                                  
+1539                                                        #require_external($o->{'ibbackup-binary'}, '--license',
+1540                                                        #                 'version (\S+)', \$ibbackup_version);
+1541           2                                 32         print STDERR "\n";
+1542                                                  
+1543  ***      2     50     33                   58         if (  $o->{'include'}
+      ***                   33                        
+1544                                                           && $ibbackup_version
+1545                                                           && $ibbackup_version le "2.0" )
+1546                                                        {
+1547                                                  
+1548                                                           # --include option was given, but ibbackup is too
+1549                                                           # old to support it
+1550  ***      0                                  0            Die "--include option was given, but ibbackup is too old"
+1551                                                              . " to support it. You must upgrade to InnoDB Hot Backup"
+1552                                                              . " v2.0 in order to use --include option.\n";
+1553                                                        }
+1554                                                     }
+1555                                                  
+1556                                                     # set signal handlers
+1557           2                                142      $SIG{PIPE} = \&catch_sigpipe;
+1558                                                  
+1559                                                     # read MySQL options file
+1560                                                     #read_config_file($config_file, \%config);
+1561           2                                 80      read_config_file( \%config );
+1562                                                  
+1563  ***      2     50                          26      if ( !$o->{'tmpdir'} ) {
+1564           2                                 34         $o->{'tmpdir'} = get_option( \%config, 'mysqld', 'tmpdir' );
+1565                                                     }
+1566                                                  
+1567                                                     # get innodb log home directory from options file
+1568                                                     #$innodb_log_group_home_dir =
+1569                                                     #    get_option(\%config, 'mysqld', 'innodb_log_group_home_dir');
+1570                                                  
+1571  ***      2     50     33                   54      if ( !$o->{'apply-log'} && !$o->{'copy-back'} ) {
+      ***             0                               
+1572                                                  
+1573                                                        # we are making a backup, create a new backup directory
+1574  ***      2     50                          14         if ( !$o->{'remote-host'} ) {
+1575           2                                 30            $backup_dir = File::Spec->rel2abs( make_backup_dir() );
+1576                                                        }
+1577                                                        else {
+1578  ***      0                                  0            $backup_dir = make_backup_dir();
+1579                                                        }
+1580           2                                544         print STDERR "$prefix Created backup directory $backup_dir\n";
+1581  ***      2     50     33                   66         if ( !$o->{'remote-host'} && !$o->{'stream'} ) {
+1582           2                                 18            $backup_config_file = $backup_dir . '/backup-my.cnf';
+1583           2                                 16            $suspend_file       = $backup_dir . '/xtrabackup_suspended';
+1584           2                                 30            $mysql_stdout       = $backup_dir . '/mysql-stdout';
+1585           2                                 16            $mysql_stderr       = $backup_dir . '/mysql-stderr';
+1586           2                                  8            $binlog_info        = $backup_dir . '/xtrabackup_binlog_info';
+1587           2                                 12            $slave_info         = $backup_dir . '/xtrabackup_slave_info';
+1588                                                        }
+1589                                                        else {
+1590  ***      0                                  0            $suspend_file = get_option( \%config, 'mysqld', 'datadir' )
+1591                                                              . '/xtrabackup_suspended';
+1592  ***      0                                  0            $tmp_logfile  = $o->{'tmpdir'} . '/xtrabackup_logfile';