~percona-dev/percona-xtrabackup/win_tests

#!/usr/bin/perl -w

#

# A script for making backups of InnoDB and MyISAM tables, indexes and .frm

# files.

#

# Copyright 2003, 2009 Innobase Oy and Percona Inc 2009-2011. All Rights Reserved.

#

use strict;

use Getopt::Long;

use File::Spec;

use Pod::Usage qw(pod2usage);

use POSIX "strftime";

use POSIX ":sys_wait_h";

use POSIX "tmpnam";

use FileHandle;

use File::Basename;

use English qw(-no_match_vars);

# 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

and Percona Inc 2009-2011.  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

$| = 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 $option_help = '';

my $option_version = '';

my $option_apply_log = '';

my $option_redo_only = '';

my $option_copy_back = '';

my $option_include = '';

my $option_databases = '';

my $option_tables_file = '';

my $option_throttle = '';

my $option_sleep = '';

my $option_compress = 999;

my $option_uncompress = '';

my $option_export = '';

my $option_use_memory = '';

my $option_mysql_password = '';

my $option_mysql_user = '';

my $option_mysql_port = '';

my $option_mysql_socket = '';

my $option_mysql_host = '';

my $option_no_timestamp = '';

my $option_slave_info = '';

my $option_no_lock = '';

my $option_ibbackup_binary = 'autodetect';

my $option_defaults_file = '';

my $option_incremental = '';

my $option_incremental_basedir = '';

my $option_incremental_dir = '';

my $option_incremental_lsn = '';

my $option_extra_lsndir = '';

my $option_remote_host = '';

my $option_stream = '';

my $option_tmpdir = '';

my $option_tar4ibd = '';

my $option_force_tar = '';

my $option_scp_opt = '-Cp -c arcfour';

my $option_parallel = '';

my $option_safe_slave_backup = '';

my $option_safe_slave_backup_timeout = 300;

# name of the my.cnf configuration file

#my $config_file = '';

# 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;

# list of tables to be included in a backup

my %table_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 = 'stderr';

# name of the file where stdout of mysql process is directed

my $mysql_stdout = '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");

my $xtrabackup_binary_file = 'xtrabackup_binary';

######################################################################

# program execution begins here

######################################################################

# check command-line args

check_args();

# print program version and copyright

print_version();

# initialize global variables and perform some checks

if ($option_copy_back) {

    $option_ibbackup_binary = 'xtrabackup_51';

} elsif ($option_apply_log) {

	# Read XtraBackup version from backup dir

	if (-e "$backup_dir/$xtrabackup_binary_file") {

		# Read XtraBackup version from file

		open XTRABACKUP_BINARY, "$backup_dir/$xtrabackup_binary_file"

			or die "Cannot open file $backup_dir/$xtrabackup_binary_file: $!\n";

		$option_ibbackup_binary = <XTRABACKUP_BINARY>;

		close XTRABACKUP_BINARY;

		}

	else {

		if( $option_ibbackup_binary eq "autodetect" ){

			# Try to connect MySQL and get the version

			print "option_ibbackup_binary is autodetect, trying to connect to MySQL\n";

			my $options = get_mysql_options();

			$mysql_pid = open(*MYSQL_WRITER, "| mysql $options >$mysql_stdout 2>$mysql_stderr ");

			print "Connected to MySQL with pid $mysql_pid\n";

			sleep 1;

			if ($mysql_pid && $mysql_pid == waitpid($mysql_pid, &WNOHANG)) {

				my $reason = `cat $mysql_stderr`;

				$mysql_pid = '';

				# Failed to connect to MySQL

				die "Failed to connect to MySQL server to detect version.\nYou must set xtrabackup version to use with --ibbackup option.\nPossible values are xtrabackup_51 (for MySQL 5.0 and 5.1) or xtrabackup (for MySQL 5.1 with InnoDB plugin or Percona Server)\n";

				}

			else{

				mysql_close();

				print "Connected successfully\n";

				$option_ibbackup_binary = set_xtrabackup_version();

				}

			}

		}

} else {

    $option_ibbackup_binary = set_xtrabackup_version();

}

init();

my $ibbackup_exit_code = 0;

if ($option_copy_back) {

    # copy files from backup directory back to their original locations

    copy_back();

} elsif ($option_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.

    $ibbackup_exit_code = backup();

    open XTRABACKUP_BINARY, "> $backup_dir/$xtrabackup_binary_file"

    	or die "Cannot open file $backup_dir/$xtrabackup_binary_file: $!\n";

    print XTRABACKUP_BINARY $option_ibbackup_binary;

    close XTRABACKUP_BINARY;

}

$now = current_time();

if ($option_stream eq 'tar') {

   print STDERR "$prefix You must use -i (--ignore-zeros) option for extraction of the tar stream.\n";

}

if ( $ibbackup_exit_code == 0 ) {

   # program has completed successfully

   print STDERR "$now  $prefix completed OK!\n";

}

else {

   print STDERR "$now  $prefix $option_ibbackup_binary failed! (exit code $ibbackup_exit_code)  The backup may not be complete.\n";

}

exit $ibbackup_exit_code;

######################################################################

# end of program execution

######################################################################

#

# 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 {

   my $msg = shift || '';

   pod2usage({ -msg => $msg, -verbose => 1});

   return 0;

}

#

# 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'";

    }

    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 (!$option_remote_host && !$option_stream) {

        wait_for_ibbackup_suspend();

    }

    if (!$option_incremental) {

        # connect to database

        mysql_open();

        if ( $option_safe_slave_backup ) {

          wait_for_safe_slave();

        }

        # flush tables with read lock

        mysql_check();

        mysql_lockall() if !$option_no_lock;

    }

    # backup .frm, .MRG, .MYD, .MYI, .TRG, .TRN, .ARM, .ARZ, .CSM, .CSV and .opt files

    backup_files();

    # resume ibbackup and wait till it has finished

    my $ibbackup_exit_code = resume_ibbackup();

    if (!$option_incremental) {

        # release read locks on all tables

        mysql_unlockall() if !$option_no_lock;

       if ( $option_safe_slave_backup ) {

         print STDERR "$prefix: Starting slave SQL thread\n";

         mysql_send('START SLAVE SQL_THREAD;');

       }

        # disconnect from database

        mysql_close();

    }

    if ($option_remote_host) {

        system("scp $option_scp_opt '$tmp_logfile' '$option_remote_host:$backup_dir/xtrabackup_logfile'")

            and Die "Failed to scp file '$option_remote_host:$backup_dir/xtrabackup_logfile': $!";

        unlink $tmp_logfile || Die "Failed to delete '$tmp_logfile': $!";

        system("scp $option_scp_opt '$orig_datadir/xtrabackup_checkpoints' '$option_remote_host:$backup_dir/xtrabackup_checkpoints'")

            and Die "Failed to scp file '$option_remote_host:$backup_dir/xtrabackup_checkpoints': $!";

        unlink "$orig_datadir/xtrabackup_checkpoints" || Die "Failed to delete '$orig_datadir/xtrabackup_checkpoints': $!";

    } elsif ($option_stream eq 'tar') {

        system("cd $option_tmpdir; tar chf - xtrabackup_logfile")

            and Die "Failed to stream 'xtrabackup_logfile': $!";

        unlink $tmp_logfile || Die "Failed to delete '$tmp_logfile': $!";

        system("cd $orig_datadir; tar chf - xtrabackup_checkpoints")

            and Die "Failed to stream 'xtrabackup_checkpoints': $!";

        unlink "$orig_datadir/xtrabackup_checkpoints" || Die "Failed to delete '$orig_datadir/xtrabackup_checkpoints': $!";

    }

    print STDERR "\n$prefix Backup created in directory '$backup_dir'\n";

    if ($mysql_binlog_position) {

        print STDERR "$prefix MySQL binlog position: $mysql_binlog_position\n";

    }

    if ($mysql_slave_position && $option_slave_info) {

        print STDERR "$prefix MySQL slave binlog position: $mysql_slave_position\n";

    }

    return $ibbackup_exit_code;

}

#

# 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': $!\n";

    print STDERR "$prefix Starting to copy MyISAM tables, indexes,\n"; 

    print STDERR "$prefix .MRG, .TRG, .TRN, .ARM, .ARZ, .CSM, .CSV, .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("mkdir \"".escape_path("$orig_datadir/$file")."\"") 

                    and Die "Failed to create directory "

                            . "'$orig_datadir/$file' : $!";

            }

            opendir(SUBDIR, "$subdir") 

                || Die "Can't open directory '$subdir': $!\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("$CP_CMD \"$src_name\" \"$dst_name\"")

                    and Die "Failed to copy file '$file': $!";

            }

            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("$CP_CMD \"$src_name\" \"$dst_name\"")

                and Die "Failed to copy file '$file': $!";

        }

    }

    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("$CP_CMD \"$src_name\" \"$dst_name\"")

            and Die "Failed to copy file '$filename': $!";

    }

    # copy InnoDB log files to original InnoDB log directory

    opendir(DIR, $backup_dir) 

        || Die "Can't open directory '$backup_dir': $!\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("$CP_CMD \"$src_name\" \"$dst_name\"")

                and Die "Failed to copy file '$file': $!";

        }

    }

    closedir(DIR);

    print STDERR "$prefix Finished copying back files.\n\n";

}

#

# 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 ($option_defaults_file) {

        $options = $options . " --defaults-file=\"$option_defaults_file\" ";

    }

    $options = $options . "--prepare --target-dir=$backup_dir";

    if ($option_uncompress) {

        $options = $options . ' --uncompress';

    }

    if ($option_export) {

        $options = $options . ' --export';

    }

    if ($option_redo_only) {

        $options = $options . ' --apply-log-only';

    }

    if ($option_use_memory) {

        $options = $options . " --use-memory=$option_use_memory";

    }

    if ($option_incremental_dir) {

        $options = $options . " --incremental-dir=$option_incremental_dir";

    }

    # run ibbackup as a child process

    $cmdline = "$option_ibbackup_binary $options";

    $now = current_time();

    print STDERR "\n$now  $prefix Starting ibbackup with command: $cmdline\n\n";

    $rcode = system("$cmdline");

    if ($rcode) {

        # failure

        Die "\n$prefix ibbackup failed";

    }

    # We should not create ib_logfile files if we prepare for following incremental applies

    # Also we do not prepare ib_logfile if we applied incremental changes

    if (!( ($option_redo_only) or ($option_incremental_dir))) { 

    $now = current_time();

    print STDERR "\n$now  $prefix Restarting xtrabackup with command: $cmdline\nfor creating ib_logfile*\n\n";

    $rcode = system("$cmdline");

    if ($rcode) {

        # failure

        Die "\n$prefix xtrabackup (2nd execution) failed";

    }

    }

}

#

# 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': $!";

    # wait for ibbackup to finish

    waitpid($ibbackup_pid, 0);

    $ibbackup_pid = '';

    return $CHILD_ERROR >> 8;

}

#

# 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 ($option_defaults_file) {

        $options = $options . " --defaults-file=\"$option_defaults_file\" ";

    }

    $options = $options . "--backup --suspend-at-end";

    if (!$option_remote_host && !$option_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 ($option_throttle) {

        $options = $options . " --throttle=$option_throttle";

    }

    if ($option_sleep) {

        $options = $options . " --sleep=$option_sleep";

    }

    if ($option_compress) {

        $options = $options . " --compress=$option_compress";

    }

    if ($option_use_memory) {

        $options = $options . " --use-memory=$option_use_memory";

    }

    if ($option_include) {

        $options = $options . " --tables='$option_include'";

    }

    if ($option_extra_lsndir) {

        $options = $options . " --extra-lsndir='$option_extra_lsndir'";

    }

    if ($option_incremental) {

        if($option_incremental_lsn) {

          $options = $options . " --incremental-lsn='$option_incremental_lsn'";

	} else {

          $options = $options . " --incremental-basedir='$incremental_basedir'";

	}

    }

    if ($option_tables_file) {

        $options = $options . " --tables_file='$option_tables_file'";

    }

    if ($option_parallel) {

        $options = $options. " --parallel=$option_parallel";

    }

    $cmdline = "$option_ibbackup_binary $options";

    # run ibbackup as a child process

    $now = current_time();