!/usr/bin/perl
$Header: rdbms/demo/rman_xttconvert/xttdriver.pl /main/10 2015/05/18 06:18:23 asathyam Exp $
xttdriver.pl
Copyright (c) 2013, 2015, Oracle and/or its affiliates. All rights reserved.
NAME
xttdriver.pl - Cross Platform Transportable Tablespace DRIVER perl
script
DESCRIPTION
The script that is run to perform the main steps of the XTTS with Cross
Platform Incremental Backups procedure.
VERSION
2.0
NOTES
In version 2 12C options have been added which supports
"backup for transport" and "restore from platform"
In version 1.4 two new options -P and -G have been added.
In the current flow the datafiles are transported using a staging area
in the source and desination. This has been eliminated by using
dbms_file_transfer.
Parallelism is supported for rollforward if rollparallel is set
Bug Fixes
==========
Apr 24 2015 [Version 2]
----------------------------
1. Bug 20916691: --backup option broken
2. Bug 21028174: Add message when -L option is used
Nov 19 2014 [Version 2]
------------------------------
Project 47110: New options have been added
1. --backup
2. --restore
3. --bkpincr
4. --bkpexport
5. --resincrdmp
6. Bug 20192155: Fix for ORA-15126
7. Added --version option to give version
8. Added multiple source and destination directory support in getfile.
9. Removed putfile code
Nov 14 2014 [Version 1.4.2]
------------------------------
1. Enhancement: Added getparallel option to transfer datafiles in
parallel.
March 24 2014 [Version 1.4.1]
------------------------------
1. 18456868 - Made sure sqlplus and rman is present in the PATH
2. 18456834 - Added new option -F/--propfile to pass the location
of properties file if required. This was requested by EM.
3. 18459238 - dfcopydir was not required when we run using -G
option. The checking has been enhanced.
4. Even when convert instance is used, the -G should be run only
from destination instance and not the conversion instance
5. Impdp added ';' at the end which resulted in error. Fixed this
6. Added more debugging messages
7. Do more error checking before proceeding to next steps
8. Bug 17819946 - When number of tablespaces is more, the length
of list exceeds 2499 and fails. This is also fixed
9. If debug option is set to more than 1 the temporary files are
preserved. Otherwise it is deleted.
10. Bug 18797439 - Add new option -I/--propdir. All required files
will be picked from the runtime location of xttdriver.pl
11. Clean up the code such that the temp files are more readable
and can be mapped to backups
MODIFIED (MM/DD/YY)
asathyam 12/24/14 - Ver2 more changes
asathyam 11/18/14 - Version 2
asathyam 11/11/14 - Get parallel implemenation for getfile
asathyam 05/19/14 - EM wanted only propfile to be picked from
specified location.
asathyam 03/26/14 - Bug fixes. Details mentioned above
asathyam 01/30/14 - Implement doug's comments
asathyam 11/17/13 - Added support for same endian support
asathyam 10/20/13 - Bug 17673485 :- Added new option to support
individual specified tablespaces to be roll
forwarded in parallel
asathyam 10/02/13 - Bug 17673476 :- Fixed ASM related issues
asathyam 05/28/13 - New version 1.4
svrrao 03/15/13 - Enhance to v1.3. Introduce parallelism
fsanchez 03/15/13 - Creation
Globals
use Getopt::Long qw(:config no_ignore_case);
use POSIX ":sys_wait_h";
use strict;
use vars qw/ %opt /;
our %transfer = ();
our $context = %opt;
our @tablespaces = ();
our @properties = ();
our %props;
our $tmp;
our $xttpath;
our $rmantfrdf;
our $rmandstdf;
our $xttprep;
our $rmanpath;
our $connectstring;
our $sqlSettings;
our $errfile;
our $getfile;
our $xtts_incr_backup = "xib";
our @rolltbsArray = ();
my %tbsHash;
my $fixCnvSql;
my $fixRollSql;
our @forkArray = ();
my $xttrollforwardp;
my $rollParallel = 0;
my $getParallel = 0;
my $metaTransfer = 0;
my $scpParms = 0;
our $xttprop;
our $cnvrSql = "xttcnvrtbkupdest.sql";
our $stageondest;
our $backupondest;
our $platformid;
our $connectstringcnvinst;
our $myversion = "2.0";
our %dirHash;
our $dirmaxVal = 100;
Following constants are for the options that are used in the perl script
use constant PREPARE => 1;
use constant BCKPINCR => 2;
use constant NEWPLAN => 3;
use constant GETFILE => 5;
use constant BACKUP => 6;
use constant RESTORE => 7;
use constant RECOVER => 8;
use constant ROLLFORWARD => 9;
use constant RESINCRDMP => 10;
Used for generating xttplugin.txt
use constant LOCALFILE => 1;
use constant LINK => 2;
Used for checking version
use constant VER11 => 1;
use constant VER12 => 2;
Function : parseArg
Purpose : Command line options processing
Inputs : None
Returns : None
sub parseArg
{
GetOptions ($context,
'backup|b',
'bkpincr|B',
'convert|c',
'debug|d:i',
'bkpexport|E',
'generate|e',
'incremental|i',
'orahome|o=s',
'prepare|p',
'rollforward|r',
'determinescn|s',
'xttdir|D=s',
'propfile|F=s',
'getfile|G',
'propdir|I',
'clearerrorfile|L',
'orasid|O=s',
'restore|R',
'recover|X',
'resincrdmp|M',
'rolltbs|T=s',
'setupgetfile|S',
'ignoreerrors',
'version|v',
'help|h'
) or usage();
if ($context->{"help"})
{
usage();}
if ($context->{"version"})
{
PrintMessage ("Version is $myversion");
exit (1);}
if (defined ($context->{"debug"}) && ($context->{"debug"} == 0))
{
$context->{"debug"} = 1;}
if ($ENV{'XTTDEBUG'})
{
$context->{"debug"} = $ENV{'XTTDEBUG'};}
# User provided a directory, start from there to pick up files
if ($context->{"propdir"})
{
use File::Basename;
chdir (dirname($0));}
if ($context->{"propfile"})
{
$xttprop = $context->{"propfile"};}
else
{
$xttprop = "xtt.properties";}
}
Function : touchErrFile
Purpose : Create the error file if requested
sub touchErrFile
{
my $message = $_[0];
open ERRFILE, ">>$errfile";
print ERRFILE "$messagen";
close ERRFILE;
}
Function : Unlink
Purpose : Delete the file if the debug level is less than 2
sub Unlink
{
my $delFile = $_[0];
my $force = $_[1];
if ($force || ($context->{"debug"} < 2))
{
unlink ($delFile);}
}
Function : GetRMANTrace
Purpose : get the trace file name
sub GetRMANTrace
{
my $fileAppend = $_[0];
my $trace = "";
my $traceFile;
if ($context->{"debug"})
{
$traceFile = "$tmp/rmantrc_".GetTimeStamp().
"_".$fileAppend.".trc";
$trace = "debug trace $traceFile";}
return ($trace, $traceFile);
}
Function : deleteErrFile
Purpose : check if the error file exists and delete
sub deleteErrFile
{
PrintMessage ("Deleting error file");
if (-e $errfile)
{
Unlink ($errfile, 1);}
}
Function : checkErrFile
Purpose : check if the error file exists
sub checkErrFile
{
if (-e $errfile)
{
{die "
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
Error:
Some failure occurred. Check $errfile for more details
If you have fixed the issue, please delete $errfile and run it
again OR run xttdriver.pl with -L option!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
";
}}
}
Function : debugprint
Purpose : print if debug value is >= passed debug level
sub debugprint
{
my $message = $_[0];
my $debuglevel = $_[1];
if ($context -> {"debug"} >= $debuglevel)
{
print $_[0] . "\n";}
}
Function : debug
Purpose : print with level being 1
sub debug
{
debugprint ($_[0], 1);
}
Function : debug3
Purpose : print with level being 3
sub debug3
{
debugprint ($_[0], 3);
}
Function : debug4
Purpose : print with level being 4
sub debug4
{
debugprint ($_[0], 4);
}
Function : Die
Purpose : Print message and exit
sub Die
{
my $message = $_[0];
touchErrFile($message);die "
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
Error:
$message
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
";
}
Function : trim
Purpose : To remove whitespace from the start and end of the string
sub trim
{
my $string = $_[0];
$string =~ s/^s+//;
$string =~ s/\s+$//;
return $string;
}
Function : checkError
Purpose : check if any error was there and bail out
sub checkError
{
my ($errorMessage, $output) = @_;
#No need to check for error when user does not want to
if (defined($context->{"ignoreerrors"}))
{
return;}
chomp ($output);
$output = trim ($output);
if (($output =~ /ORA[-][0-9]/) || ($output =~ /SP2-.*/))
{
debug $output;
Die("$errorMessage");}
debug $output;
}
Function : PrintMessage
Purpose : Print the message that is passed to it
Inputs : Any text
Outputs : None
NOTES : None
sub PrintMessage
{
my $message = $_[0];
print "
$message
";
}
Function : parseProperties
Purpose : Parse the properties file xtt.properties
sub parseProperties
{
PrintMessage ("Parsing properties");
# Check if any failure occured and stop exection
checkErrFile();
@properties = qw(tablespaces stageondest storageondest dfcopydir
backupondest backupformat platformid oracle_home_cnvinst
oracle_sid_cnvinst asm_home asm_sid dstlink
srcdir dstdir srclink rollparallel getfileparallel
metatransfer desthost desttmpdir destuser);open my $in, "$xttprop" or Die "$xttprop not found: $!";
while(<$in>)
{
next if /^#/;
$props{$1}=$2 while m/(\S+)=(.+)/g;}
close $in;
if ($context -> {"debug"})
{
foreach my $pkey (keys %props)
{
print "Key: $pkey\n";
print "Values: $props{$pkey}\n";
}}
@tablespaces = split(/,/, $props{'tablespaces'});
PrintMessage ("Done parsing properties");
}
Function : check
Purpose : check if the properties were defined
sub check
{
my $arg = $_[0];
my $key = $_[1];
debug "ARGUMENT $key";
if (!defined ($arg))
{
Die ("Please define xtt.properties:$key");}
}
Function : checkNoPwdSSHEnabled
Purpose : For putfile option few properties will be not be required, the
same applies for the plan option
sub checkNoPwdSSHEnabled
{
my $outFile = "";
if ($metaTransfer == 0)
{
return;}
$outFile = "$tmp/transferFile".GetTimeStamp().".log";
unless (system ("ssh $scpParms \"echo host\" 2> $outFile") == 0)
{
my @failArray = ();
open FAIL, "$outFile";
@failArray = <FAIL>;
close FAIL;
Die ("Passwordless SSH not enabled to machine\n@failArray");}
}
Function : transferFiles
Purpose : For putfile option few properties will be not be required, the
same applies for the plan option
sub transferFiles
{
my @trnsfrFiles = @_;
my $output = 0;
my $files = "";
my $scpParmsL = "";
my $outFile = "$tmp/transferFile".GetTimeStamp().".log";
if ($metaTransfer == 0)
{
return;}
foreach my $x (@trnsfrFiles)
{
chomp($x);
$files = $files."$x ";}
$scpParmsL =
"-o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null -o ".
"NumberOfPasswordPrompts=0 ";unless (system ("scp $scpParmsL $files ".$context -> {"remoteConnect"}.
":".$context->{'desttmp'}." 2> $outFile") == 0){
print "scp $scpParmsL $files ".$context -> {"remoteConnect"}.
":".$context->{'desttmp'}." 2> $outFile";
my @failArray = ();
open FAIL, "$outFile";
@failArray = <FAIL>;
close FAIL;
Die ("Unable to transfer files to destination machine\n@failArray");}
Unlink ($outFile);
}
Function : getParallelProp
Purpose : Find how many files can be fetchde in parallel
sub getParallelProp
{
my $propValue = $_[0];
# We need to find how how many cores are there in the machine and then use
# that number to see if what the user has provided is less than that
# For now we assume that max is 8
# use Sys::Info;
# use Sys::Info::Constants qw( :device_cpu );
# my $info = Sys::Info->new;
# my $cpu = $info->device( CPU => %options );
#
# printf "CPU: %sn", scalar($cpu->identify) || 'N/A';
# printf "CPU speed is %s MHzn", $cpu->speed || 'N/A';
# printf "There are %d CPUsn" , $cpu->count || 1;
# printf "CPU load: %sn" , $cpu->load || 0;
if ($propValue > 8)
{
$propValue = 8;
PrintMessage ("Maximum $propValue files will be fetched in parallel");}
return $propValue;
}
Function : checkProps
Purpose : For putfile option few properties will be not be required, the
same applies for the plan option
sub checkProps
{
PrintMessage ("Checking properties");
# Check if any failure occured and stop exection
checkErrFile();
# The following are required irrespective of what option is used
check $props{'tablespaces'}, $properties[0];
check $props{'platformid'}, $properties[6];
check $props{'backupformat'}, $properties[5];
check $props{'stageondest'}, $properties[1];
if (!defined($props{'parallel'}) ||
$props{'parallel'} <= 0){
$props{'parallel'} = 8;}
if (defined($props{'metatransfer'}))
{
if (!defined($props{'desthost'}))
{
Die ("Files transfered requested, but remote host not defined");
}
if (!defined($props{'desttmpdir'}))
{
Die ("Files transfered requested, but remote dir not defined");
}
if (defined($props{'destuser'}))
{
$context -> {"remoteConnect"} =
$props{'destuser'}."@".$props{'desthost'};
}
else
{
$context -> {"remoteConnect"} = $props{'desthost'};
}
$context -> {"desttmp"} = $props{'desttmpdir'};
$metaTransfer = 1;
$scpParms =
"-o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null -o ".
"NumberOfPasswordPrompts=0 ".$props{'desthost'};}
if (!defined($props{'getfileparallel'}) ||
$props{'getfileparallel'} <= 0){
$getParallel = 1;}
else
{
$getParallel = getParallelProp($props{'getfileparallel'});}
# Depending on option the checks are done
if (defined($context->{"setupgetfile"}) ||
defined($context->{"getfile"})){
check $props{'srcdir'}, $properties[12];
check $props{'dstdir'}, $properties[13];
check $props{'srclink'}, $properties[14];}
if (defined($context->{"prepare"}))
{
check $props{'dfcopydir'}, $properties[3];}
if (defined($context->{"rollforward"}))
{
check $props{'backupondest'}, $properties[4];}
if (defined($context->{"srcdir"}) &&
defined($context->{"dstdir"})){
my @srcDir = split(/,/, $props{'srcdir'});
my @dstDir = split(/,/, $props{'dstdir'});
my $dstCount = scalar (@dstDir);
my $srcCount = scalar (@srcDir);
if (($dstCount > 1) && ($srcCount != $dstCount))
{
Die ("checkProps: Number of source objects does not match ".
"destination objects");
}
if ($dstCount >= $dirmaxVal)
{
Die ("checkProps: Number of dir objects cannot exceed $dirmaxVal");
}}
PrintMessage ("Done checking properties");
}
Function : warnMesg
Purpose : Print message and exit
sub warnMesg
{
my $message = $_[0];
print "
Warning:
$message
";
}
Function : checkDbLink
Purpose : To check if the given DB link works
sub checkDbLink
{
my $sqlOutput ;
my $dblink = $_[0];
my $sqlQuery =
"select 'Count=' || count(*) from dual@"."$dblink;";
$sqlOutput = `sqlplus -L -s $connectstring <
$sqlSettings
$sqlQuery
quit;
EOF
`;chomp ($sqlOutput);
$sqlOutput = trim ($sqlOutput);
if ($sqlOutput =~ m/^Count=(.*)/)
{
if ($1 <= 0)
{
Die ("Database link $props{'dstlink'} is not working");
}}
else
{
Die ($sqlOutput);}
}
Function : checkDBState
Purpose : To check state of database
sub checkDBState
{
my $sqlOutput ;
my $dblink = $_[0];
my $sqlQuery =
'select \'STATUS=\' || status FROM v\$instance;';
$sqlOutput = `sqlplus -L -s $connectstring <
$sqlSettings
$sqlQuery
quit;EOF
`;chomp ($sqlOutput);
$sqlOutput = trim ($sqlOutput);
if ($sqlOutput =~ m/^STATUS=(.*)/)
{
my $startStatus = trim ($1);
if ($startStatus ne "STARTED")
{
Die ("Open database in nomount mode and try rollforward again");
}}
else
{
Die ($sqlOutput);}
}
Function : checkCompat
Purpose : To check state of database
sub checkCompat
{
my $sqlOutput ;
my $sqlQuery =
'select to_number(replace(RPAD(value, 10, \'.0\'), \'.\')) from '.
'v\$parameter WHERE name = \'compatible\';';
$sqlOutput = `sqlplus -s -L $connectstring <
$sqlSettings
$sqlQuery
quit;EOF
`;
chomp ($sqlOutput);
$sqlOutput = trim ($sqlOutput);
debug "$sqlOutputn";
if ($sqlOutput =~ m/.ORA-./)
{
Die ("Unable to check database compatibility");}
if ($sqlOutput >= 121000)
{
return VER12;}
else
{
return VER11;}
}
Function : getPlatName
Purpose : To get name of source platform
sub getPlatName
{
my $sqlOutput ;
my $platid = $props{'platformid'};
my $sqlQuery =
'select platform_name from v\$transportable_platform '.
'where platform_id = '.$platid.';';
$sqlOutput = `sqlplus -s -L $connectstring <
$sqlSettings
$sqlQuery
quit;EOF
`;
chomp ($sqlOutput);
$sqlOutput = trim ($sqlOutput);
if ($sqlOutput =~ m/.ORA-./)
{
Die ("Unable to fetch platform name");}
return $sqlOutput;
}
Function : fetchDirEntry
Purpose : In order to transfer the files we need to define directory
objects, this function will check if they are defined.
sub fetchDirEntry
{
my $dirtoCheck = $_[0];
my $remoteLink = $_[1];
my @sqlOutput ;
my $sqlQuery ;
debug3 "fetchDirEntry: parms $remoteLink, $dirtoCheckn";
if ($remoteLink eq "")
{
debug "fetchDirEntry: remotelink not present\n";
$sqlQuery =
"SELECT 'DIRECTORY_NAME=' || DIRECTORY_NAME,
'DIRECTORY_PATH=' || DIRECTORY_PATH FROM ".
"ALL_DIRECTORIES WHERE DIRECTORY_NAME in ($dirtoCheck);";}
else
{
$sqlQuery =
"SELECT 'DIRECTORY_NAME=' || DIRECTORY_NAME,
'DIRECTORY_PATH=' || DIRECTORY_PATH FROM ".
"ALL_DIRECTORIES\@".
"$remoteLink WHERE DIRECTORY_NAME in ($dirtoCheck);";}
@sqlOutput = `sqlplus -L -s $connectstring <
$sqlSettings
$sqlQuery
quit;
EOF
`;
chomp (@sqlOutput);
return @sqlOutput;
}
Function : fetchCheckDirObjectsDST
Purpose : In order to transfer the files we need to define directory
objects, this function will check if they are defined.
sub fetchCheckDirObjectsDST
{
my $dirtoCheck = $_[0];
my $remoteLink = $_[1];
my $dirObjects = $_[2];
my $dirtoCheckLink;
my $dirObjPath;
my @sqlOutput ;
my $sqlQuery ;
my $found ;
my %dstHash = ();
debug "fetchCheckDirObjectsDST: Check dir path $remoteLinkn";
my @srcDir = split(/,/, $props{'srcdir'});
my @dstDir = split(/,/, $props{'dstdir'});
my $tempDir = '';
my $idx = 0;
my $dstCount = scalar (@dstDir);
my $srcCount = scalar (@srcDir);
if (($dstCount > 1) && ($srcCount != $dstCount))
{
Die ("fetchCheckDirObjectsDST: Number of source objects does not match ".
"destination objects");}
foreach my $var (@dstDir)
{
$var = trim($var);
$tempDir = $tempDir."\'$var\',";
$dstHash{"$var"} = trim($dstDir[$idx]);
debug3 "fetchCheckDirObjectsDST: DestDir: ".$dstHash{"$var"}."\n";
if ($dstCount > 1)
{
$idx = $idx + 1;
}}
if ($tempDir =~ m/(.*),/)
{
$tempDir = $1;}
@sqlOutput = fetchDirEntry ($tempDir, $remoteLink);
foreach my $x (@sqlOutput)
{
$x = trim ($x);
if ($x =~ m/^DIRECTORY_NAME=(.*)DIRECTORY_PATH=(.*)/)
{
my $nameTemp = $1;
$dirObjPath = $2;
$nameTemp = trim($nameTemp);
if ($dirObjPath =~ m/(.*)\/$/) # Removes trailing spaces
{
$dirObjPath = $1;
}
$dirObjects->{$nameTemp} = $dirObjPath;
}}
if ((keys%$dirObjects) == 0)
{
print "fetchCheckDirObjectsDST: Directory ".
"object \"$dirtoCheck\" does not exist\n";
Die (@sqlOutput);}
return $dirObjPath;
}
Function : fetchCheckDirObjectsSRC
Purpose : In order to transfer the files we need to define directory
objects, this function will check if they are defined.
sub fetchCheckDirObjectsSRC
{
my $dirtoCheck = $_[0];
my $remoteLink = $_[1];
my $dirObjects = $_[2];
my $dirObjPath;
my @sqlOutput ;
my $sqlQuery ;
my $found ;
my %srcHash = ();
debug "fetchCheckDirObjectsSRC: Check dir path $remoteLinkn";
my @srcDir = split(/,/, $props{'srcdir'});
my @dstDir = split(/,/, $props{'dstdir'});
my $tempDir = '';
my $idx = 0;
my $dstCount = scalar (@dstDir);
my $srcCount = scalar (@srcDir);
if (($dstCount > 1) && ($srcCount != $dstCount))
{
Die ("fetchCheckDirObjectsSRC: Number of source objects does not match ".
"destination objects");}
foreach my $var (@srcDir)
{
$var = trim($var);
$tempDir = $tempDir."\'$var\',";
$srcHash{"$var"} = trim($dstDir[$idx]);
debug3 "fetchCheckDirObjectsSRC: SRCDIR: ".$srcHash{"$var"}."\n";
if ($dstCount > 1)
{
$idx = $idx + 1;
}}
if ($tempDir =~ m/(.*),/)
{
$tempDir = $1;}
@sqlOutput = fetchDirEntry ($tempDir, $remoteLink);
foreach my $x (@sqlOutput)
{
$x = trim ($x);
if ($x =~ m/^DIRECTORY_NAME=(.*)DIRECTORY_PATH=(.*)/)
{
my $nameTemp = $1;
$dirObjPath = $2;
$nameTemp = trim($nameTemp);
if ($dirObjPath =~ m/(.*)\/$/)
{
$dirObjPath = $1;
}
# Create a hash with SRC directory and the DST directory object names.
$dirObjects->{$dirObjPath}->{"SRC"} = $nameTemp;
$dirObjects->{$dirObjPath}->{"DST"} = $srcHash{"$nameTemp"};
}}
if ((keys%$dirObjects) == 0)
{
print "fetchCheckDirObjectsSRC: Directory ".
"object \"$dirtoCheck\" does not exist\n";
Die (@sqlOutput);}
return;
}
Function : fixXTTNewDatafiles
Purpose : Fix the destination file by replacing the tag DESTDIR with the
actual location
sub fixXTTNewDatafiles
{
my $dirObjects = $_[0];
my $replaceFile = 0;
my @destArray = ();
debug "fixXTTNewDatafiles: Entered";
open(RMANDSTDF, "$rmandstdf") ||
Die "Cant find $rmandstdf";@destArray = ;
close RMANDSTDF;
foreach my $line (@destArray)
{
if ($line =~ /.*DESTDIR:.*/)
{
$replaceFile = 1;
last;
}}
if ($replaceFile)
{
open(RMANDSTDF1, ">$rmandstdf"."temp") ||
Die "Cant find $rmandstdf";
foreach my $line (@destArray)
{
if ($line =~ m/(.*),DESTDIR:(.*)\,(.*)/)
{
debug3 "fixXTTNewDatafiles: $1\n";
my $dest = $dirObjects->{$2}->{"DST"};
print RMANDSTDF1 "$1,$dest".":$3\n";
}
else
{
print RMANDSTDF1 "$line";
}
}
close RMANDSTDF1;
Unlink ("$rmandstdf", 1);
system("\\cp $rmandstdf"."temp $rmandstdf");}
}
Function : verifySrcdirDatafiles
Purpose : Verify if the datafiles are present in the same directory
as defined in the source directory object
sub verifySrcdirDatafiles
{
my $dfPath = "$tmp/xttprepare.cmd";
my @dfList = ();
my @unidfList = ();
my %seen;
my $name;
debug ("verifySrcdirDatafiles: Entered");
open DFLIST, $dfPath ;
@dfList = ;
close DFLIST;
foreach my $df (@dfList)
{
chomp ($df);
debug3 "verifySrcdirDatafiles: $df";
if ($df =~ /^#DNAME:(.*)/)
{
$name = $1;
if (! (grep { $_ eq $name } @unidfList))
{
push (@unidfList, $1);
}
}}
foreach my $key (keys %dirHash)
{
debug4 "verifySrcdirDatafiles: Hash key".$key."\n";
debug4 "verifySrcdirDatafiles: Hash value".$dirHash{"$key"}."\n";}
foreach my $df (@unidfList)
{
debug3 "verifySrcdirDatafiles: $df\n";
if (!defined($dirHash{$df}))
{
Die ("Datafile path $df and source directory object ".
"path ".$dirHash{$df}." doest not match");
}}
}
This routine is called from
Prepare Src
Backup Incr (backincr)
New Plan (newplan)
Getfile
Helper routine to batch the tablespaces sent into control file
queries, this way too many controlfile reads is avoided.
It takes one parameter, to tell who called it
1 => Prepare, 2 => backincr, 3 => newplan, 5 => getfile
sub generate_batch_tsoutput()
{
my $option = $_[0];
my $stageondest = $props{'stageondest'};
my $platform = "'$props{'platform'}'";
my $storageondest = $props{'storageondest'};
my $dfcopydir = $props{'dfcopydir'};
my $backupformat = $props{'backupformat'};
my $script_type = "PREPARE";
my $output;
my $tsbkupmap = "$tmp/tsbkupmap.txt";
my $incrbkups = "$tmp/incrbackups.txt";
my $number_of_tablespaces_per_batch =
int(($#tablespaces + 1)/$props{'parallel'});
# Check if any failure occured and stop exection
checkErrFile();
$number_of_tablespaces_per_batch = ($number_of_tablespaces_per_batch == 0)
? 1
: $number_of_tablespaces_per_batch;
my $total_sets = $number_of_tablespaces_per_batch * $props{'parallel'};
debug3 $connectstring;
debug3 "size of tablespace " . scalar(@tablespaces);
debug3 "No. of tablespaces per batch " . $number_of_tablespaces_per_batch;
my $countno = 0;
my $tablespace_str = "";
my $old_tablespace_str = "";
if ($option == BACKUP)
{
checkMove ($tsbkupmap);
checkMove ($incrbkups);}
## Generate the rmanconvert.cmd and xttplan.txt from the output
## for Prepare
if (($option == PREPARE) || ($option == BACKUP) || ($option == GETFILE))
{
open(XTTPLAN, ">$xttpath") ||
die 'Cant find xttplan.txt, TMPDIR undefined';
if ($option == PREPARE)
{
open(RMANCONVERT, ">$rmanpath") ||
die 'Cant find rmanconvert.cmd, TMPDIR undefined';
}
# Generate new datafiles for 12c backup
elsif ($option == BACKUP)
{
$script_type = "BACKUP";
open(RMANDSTDF, ">$rmandstdf") ||
die 'Cant find $rmandstdf, TMPDIR undefined';
}
else
{
$script_type = "TRANSFER";
open(RMANDSTDF, ">$rmandstdf") ||
die 'Cant find $rmandstdf, TMPDIR undefined';
}}
elsif ($option == BCKPINCR)
{
open XTTNEWPLAN, ">$tmp/xttplan.txt.new" or die $!;
$script_type = 'DETNEW';}
elsif ($option == NEWPLAN)
{
$script_type = 'PREPNEXT';}
## Based on parallelism, do so many tablespaces at a time.
my $ind = 0;
while ($ind < $total_sets ||
$ind < scalar(@tablespaces)){
## Remove leading and trailing spaces.
$tablespaces[$ind] =~ s/^\s+//;
$tablespaces[$ind] =~ s/\s+$//;
## grab the rest
while ($ind < scalar(@tablespaces) &&
$ind >= $total_sets)
{
$tablespace_str .= "'" . $tablespaces[$ind] . "'";
if ($ind != $#tablespaces)
{
$tablespace_str .= ",";
}
$ind++;
}
if ($ind < $total_sets)
{
$tablespace_str .= "'" . $tablespaces[$ind] . "'";
if (($ind % $number_of_tablespaces_per_batch) !=
($number_of_tablespaces_per_batch-1))
{
$tablespace_str .= ",";
}
$countno++;
$ind++;
}
if ($countno == $number_of_tablespaces_per_batch ||
$ind == scalar(@tablespaces))
{
debug "TABLESPACE STRING :" . $tablespace_str;
$countno = 0;
## Subst. for tablespace names
open my $in, "xttprep.tmpl" or die $!;
if (($option == PREPARE) || ($option == BACKUP) ||
($option == GETFILE))
{
print "Prepare source for Tablespaces:
$tablespace_str $stageondest\n";
## Open the pareparesrc.sql file and substitute all the parameters
open my $prepout, ">xttpreparesrc.sql" or die $!;
while(<$in>)
{
s/%%stageondest%%/$stageondest/;
s/%%storageondest%%/$storageondest/;
s/%%dfcopydir%%/$dfcopydir/;
s/%%tmp%%/$tmp/;
s/%%parallel%%/$props{'parallel'}/;
s/%%type%%/$script_type/;
s/%%backupformat%%/$backupformat/;
if ($_ =~ /%%TABLESPACES%%/)
{
my @tbs = split(/,/, $tablespace_str);
foreach (@tbs)
{
print $prepout "$_,\n";
}
print $prepout "NULL\n";
}
else
{
print $prepout "$_";
}
}
close $in;
close $prepout;
## timestamp here -- start
print "xttpreparesrc.sql for $tablespace_str started at ".
(localtime) . "\n";
## Reset tablespace string
$old_tablespace_str = $tablespace_str;
$tablespace_str = "";
## Substitution ends here and xttpreparesrc.sql generated
my $output = `sqlplus -L -s $connectstring \@xttpreparesrc.sql`;
## timestamp here -- end
print "xttpreparesrc.sql for $tablespace_str ended at ".
(localtime) . "\n";
checkError ("Error in executing xttpreparesrc.sql", $output);
my @line = split /\n/, $output;
if (($option == BACKUP) || ($option == GETFILE))
{
foreach my $line (@line)
{
if ($line =~ /^#PLAN:/)
{
$line =~ s/^#PLAN://;
print XTTPLAN "$line\n";
if ($line =~ /(\S+)::::(\S+)/)
{
print RMANDSTDF "::$1\n";
}
}
elsif ($line =~ /^#TRANSFER:/)
{
$line =~ s/^#TRANSFER://;
if ($line =~ /.*source_file_name=(.*?),(.*?),(.*)/)
{
my $tsname = $1;
my $fullPath = trim($2);
my $fname = trim($3);
# Remove the trailing "/"
if ($fullPath =~ m/(.*)\/$/)
{
$fullPath = $1;
}
my $fullPath = $fullPath."/".$fname;
push(@{$transfer{$tsname}}, $fullPath);
}
}
elsif ($line =~ /^#NEWDESTDF:/)
{
$line =~ s/^#NEWDESTDF://;
print RMANDSTDF "$line\n";
}
}
# Verify that the files are in proper directory.
&verifySrcdirDatafiles();
}
if (($option == BACKUP) || ($option == PREPARE))
{
foreach my $line (@line)
{
if ($line =~ /^#PLAN:/)
{
$line =~ s/^#PLAN://;
print XTTPLAN "$line\n";
}
elsif ($line =~ /^#CONVERT:/)
{
$line =~ s/^#CONVERT://;
print RMANCONVERT "$line \n";
}
}
## Invoke the backup as copy routine once generated as the last
## step
my $rmancopycmd = "$tmp/xttprepare.cmd";
my ($rmanTrace, $traceFile) = GetRMANTrace("prepare");
$output = `rman target \/ $rmanTrace cmdfile $rmancopycmd`;
if ($output =~ /ERROR MESSAGE/)
{
Die("$output $!");
}
Unlink ($traceFile);
if ($option == BACKUP)
{
# We need to generate tsbkpupmap.txt for
&gentablespace_backupmap( $output ) ;
}
}
}
elsif ($option == BCKPINCR)
{
## Subst. for tablespace names
print "Prepare newscn for Tablespaces: $tablespace_str \n";
## Open the pareparesrc.sql file and substitute all the parameters
open my $prepout, ">xttdetnewfromscnsrc.sql" or die $!;
while(<$in>)
{
s/%%tmp%%/$tmp/;
s/%%type%%/$script_type/;
if ($_ =~ /%%TABLESPACES%%/)
{
my @tbs = split(/,/, $tablespace_str);
foreach (@tbs)
{
print $prepout "$_,\n";
}
print $prepout "NULL\n";
}
else
{
print $prepout "$_";
}
}
close $in;
close $prepout;
## Reset tablespace string
$tablespace_str = "";
## Substitution ends here and xttdetnewfromscnsrc.sql generated
$output = `sqlplus -L -s $connectstring \@xttdetnewfromscnsrc.sql`;
checkError ("Error in executing xttdetnewfromscnsrc.sql", $output);
my @line = split /\n/, $output;
foreach my $line (@line)
{
print XTTNEWPLAN $line . "\n";
}
}
elsif ($option == NEWPLAN)
{
## Subst. for tablespace names
print "Prepare newscn for Tablespaces: $tablespace_str \n";
## Open the pareparesrc.sql file and substitute all the parameters
open my $prepout, ">xttpreparenextiter.sql" or die $!;
while(<$in>)
{
s/%%tmp%%/$tmp/;
s/%%type%%/$script_type/;
if ($_ =~ /%%TABLESPACES%%/)
{
my @tbs = split(/,/, $tablespace_str);
foreach (@tbs)
{
print $prepout "$_,\n";
}
print $prepout "NULL\n";
}
else
{
print $prepout "$_";
}
}
close $in;
close $prepout;
## Reset tablespace string
$tablespace_str = "";
## Substitution ends here and xttpreparenextiter.sql generated
$output = `sqlplus -L -s $connectstring \@xttpreparenextiter.sql`;
checkError ("Error in executing xttpreparenextiter.sql", $output);
}
}}
if (($option == PREPARE) || ($option == BACKUP) || ($option == GETFILE))
{
close (XTTPLAN);
if ($option == PREPARE)
{
close (RMANCONVERT);
}
elsif ($option == GETFILE)
{
close (RMANDSTDF);
# Replace the paths with the directory destination objects.
fixXTTNewDatafiles (\%dirHash);
# Ver: 1.4.1 We will generate the SQL file in the destination.
my $transferCount = 0;
open GETFILE1, ">$getfile";
foreach my $user (sort keys %transfer)
{
debug "$user: @{$transfer{$user}}\n";
foreach my $file (@{$transfer{$user}})
{
# Bug 17673476: If the destination file is for ASM, it does not
# work with automated filenames. So we convert the names here.
# The automated filenames will be of format "x.y.z". This will
# converted to "x_y_z"
my $srcFile;
my $destFile;
my $srcPath;
my $dstPath;
if ($file =~ m/(.*)\/(.*)/)
{
$srcFile = $2;
$srcPath = $dirHash{"$1"}->{"SRC"};
$dstPath = $dirHash{"$1"}->{"DST"};
}
if ($srcFile =~ m/(.*)\.([0-9]+)\.([0-9]+)/)
{
$destFile = "$1_$2_$3";
}
else
{
$destFile = $srcFile;
}
print GETFILE1
"$transferCount,$srcPath,$srcFile,$dstPath,$destFile\n";
}
$transferCount = $transferCount + 1;
}
close GETFILE1;
}
elsif ($option == BACKUP)
{
close (RMANDSTDF);
}}
elsif ($option == BCKPINCR)
{
close (XTTNEWPLAN);}
if ($metaTransfer)
{
my @trnsfrFiles = ();
if ($option == GETFILE)
{
push (@trnsfrFiles, "$tmp/xttnewdatafiles.txt");
push (@trnsfrFiles, "$tmp/getfile.sql");
transferFiles (@trnsfrFiles);
}
if ($option == BCKPINCR)
{
push (@trnsfrFiles, "$tmp/xttplan.txt");
transferFiles (@trnsfrFiles);
}
if ($option == PREPARE)
{
push (@trnsfrFiles, "$tmp/rmanconvert.cmd");
transferFiles (@trnsfrFiles);
@trnsfrFiles = ();
$context->{"desttmp"} = $props{'stageondest'};
push (@trnsfrFiles, $props{'dfcopydir'}."/*");
transferFiles (@trnsfrFiles);
$context -> {"desttmp"} = $props{'desttmpdir'};
}
if ($option == BACKUP)
{
@trnsfrFiles = ();
push (@trnsfrFiles, "$tmp/tsbkupmap.txt");
push (@trnsfrFiles, "$tmp/xttnewdatafiles.txt");
transferFiles (@trnsfrFiles);
open FILE, "$tmp/incrbackups.txt";
@trnsfrFiles = <FILE>;
close FILE;
$context->{"desttmp"} = $props{'stageondest'};
transferFiles (@trnsfrFiles);
$context -> {"desttmp"} = $props{'desttmpdir'};
}}
}
End generate_batch_tsoutput
Function : assignGlobVars
Purpose : Assign global variables
sub assignGlobVars
{
if (! defined($context->{"xttdir"}))
{
if (defined($ENV{'TMPDIR'}))
{
$tmp = $ENV{'TMPDIR'};
}
else
{
Die ("TMPDIR not defined");
}}
else
{
$tmp = $context->{"xttdir"};}
$xttpath = "$tmp/xttplan.txt";
$rmantfrdf = "$tmp/rmantfrdf.sql";
$rmandstdf = "$tmp/xttnewdatafiles.txt";
$xttprep = "$tmp/xttprepare.cmd";
$rmanpath = "$tmp/rmanconvert.cmd";
$errfile = "$tmp/FAILED";
$getfile = "$tmp/getfile.sql";
$connectstring = "/ as sysdba";
$sqlSettings =
"SET TRIMSPOOL OFF LINES 32767 PAGES 0 FEEDBACK OFF ".
"VERIFY OFF DEFINE "&" TERMOUT OFF";
}
Function : checkMove
Purpose : Check if entry is present and move it
sub checkMove
{
my $srcPath = $_[0];
my $dstPath = $_[1];
if (!$dstPath)
{
my $timenow = time;
$dstPath = $srcPath.$timenow;}
if (-e $srcPath)
{
system("\\mv $srcPath $dstPath");}
}
Function : fixXTTDestFile
Purpose : Fix the destination file by replacing the tag DESTDIR with the
actual location
sub fixXTTDestFile
{
my $replaceFile = 0;
my @destArray = ();
my %dirHash;
open(RMANDSTDF, "$rmandstdf") ||
Die "Cant find $rmandstdf";@destArray = ;
close RMANDSTDF;
foreach my $line (@destArray)
{
if (($line !~ m/::.*/) && ($line =~ m/.*\:.*/))
{
$replaceFile = 1;
last;
}}
if ($replaceFile)
{
&fetchCheckDirObjectsDST($props{'dstdir'}, "", \%dirHash);
open(RMANDSTDF1, ">$rmandstdf"."temp") ||
Die "Cant find $rmandstdf";
foreach my $line (@destArray)
{
if (($line !~ m/::.*/) && ($line =~ /.*,(.*):.*/))
{
my $tempDir = $1;
$line =~ s/$tempDir:/$dirHash{"$tempDir"}/;
}
if ($line =~ m/(.*)\/(.*)\.([0-9]+)\.(.*)/)
{
$line = "$1/$2_$3_$4\n";
}
print RMANDSTDF1 "$line";
}
close RMANDSTDF1;}
if ($replaceFile)
{
Unlink ("$rmandstdf", 1);
system("\\cp $rmandstdf"."temp $rmandstdf");}
}
Function : getFilesSource
Purpose : Get files from the source database.
sub getFilesSource
{
PrintMessage ("Getting datafiles from source");
my $output;
my $connectstringcnvinst;
my $pid;
my @getArray = ();
my $getFileTemp;
&checkDbLink($props{'srclink'});
fixXTTDestFile();
$connectstringcnvinst = "/ as sysdba";
open FILE, "$getfile" or Die ("Cannot open $getfile");;
@getArray = ;
close FILE;
foreach my $x (@getArray)
{
chomp ($x);
if ($x =~ m/(.*?),(.*?),(.*?),(.*?),(.*)/)
{
my $sqlQuery =
"BEGIN
DBMS_FILE_TRANSFER.GET_FILE(
source_directory_object => '".$2."',
source_file_name => '".$3."',
source_database => '".$props{'srclink'}."',
destination_directory_object => '".$4."',
destination_file_name => '".$5."');
END;
/
";
$getFileTemp = "getfile"."_$2"."_$3"."_$1".".sql";
$getFileTemp = lc ($getFileTemp);
open FILE, ">$getFileTemp";
print FILE "$sqlQuery\nquit\n";
close FILE;
ChecktoProceed($getParallel);
$pid = fork();
if ($pid == 0)
{
PrintMessage ("Executing getfile for $getFileTemp");
$output = `sqlplus -L -s \"$connectstringcnvinst\" \@$getFileTemp`;
checkError ("Error in executing $getFileTemp", $output);
Unlink ($getFileTemp);
exit (0);
}
else
{
UpdateForkArray ($pid, $getParallel);
}
}}
while((my $pid = wait()) > 0)
{
#sleep (1);}
PrintMessage ("Completed getting datafiles from source");
}
Function : prepare
Purpose : Initial preparation for script to run.
sub prepare
{
###
### Prepare starts here
###
PrintMessage ("Starting prepare phase");
# Check if any failure occured and stop exection
checkErrFile();
my $timenow = time;
## Perform cleanup of files by renaming the xttplan.txt, rmanconvert.cmd
## and xttprep.cmd (datafile copy)
checkMove($xttpath, $xttpath.$timenow);
checkMove($rmanpath, $rmanpath.$timenow);
checkMove($xttprep, $xttprep.$timenow);
## For each tablespace, lets generate the scripts
my $stageondest = $props{'stageondest'};
my $platform = "'$props{'platform'}'";
my $storageondest = $props{'storageondest'};
my $dfcopydir = $props{'dfcopydir'};
debug "Parallel:" . $props{'parallel'};
## Remove trailing '/'s
$dfcopydir = $1 if($dfcopydir=~/(.*)\/$/);
## Check if previous ".tf" files present.
##
my @present = glob("$dfcopydir/*.tf");
if (@present)
{
## Try deleting any existing copied datafiles
system("\\rm -f $dfcopydir/*.tf");
sleep 5;}
if ($context->{"setupgetfile"})
{
&fetchCheckDirObjectsSRC($props{'srcdir'}, "", \%dirHash);
foreach my $keys (keys %dirHash)
{
debug4 "prepare: Key is $keys\n";
debug4 "prepare: Value is ".$dirHash{"$keys"}."\n";
}
&generate_batch_tsoutput(GETFILE);}
elsif ($context->{"backup"})
{
&generate_batch_tsoutput(BACKUP);}
else
{
&generate_batch_tsoutput(PREPARE);}
PrintMessage ("Done with prepare phase");
}
Function : checkExec
Purpose : Check if the rman and sqlplus executables are present in path
sub checkExec
{
if (defined ($context->{"orahome"}))
{
$ENV{'ORACLE_HOME'} = $context->{"orahome"};}
else
{
if (defined ($ENV{'ORACLE_HOME'}))
{
$context->{"orahome"} = $ENV{'ORACLE_HOME'};
}
else
{
Die ("Niether ORACLE_HOME defined or orahome passed to script") ;
}}
if (defined ($context->{"orasid"}))
{
$ENV{'ORACLE_SID'} = $context->{"orasid"};}
else
{
if (defined ($ENV{'ORACLE_SID'}))
{
$context->{"orasid"} = $ENV{'ORACLE_SID'};
}
else
{
Die ("Niether ORACLE_SID defined or orasid passed to script") ;
}}
debug "ORACLE_SID : $context->{"orasid"}";
debug "ORACLE_HOME : $context->{"orahome"}";
$ENV{'PATH'} = "$context->{"orahome"}/bin".":".$ENV{'PATH'};
$context->{'sqlexec'} = "$context->{"orahome"}/bin/sqlplus";
$context->{'rmanexec'} = "$context->{"orahome"}/bin/rman";
if (! -x $context->{"rmanexec"})
{
Die ("RMAN executable not found in path");}
if (! -x $context->{"sqlexec"})
{
Die ("SQLPLUS executable not found in path");}
}
Function : checkArg
Purpose : check if given arguments are fine
sub checkArg
{
if ($context->{"backup"} || $context->{"bkpincr"} ||
$context->{"bkpexport"} || $context->{"restore"} ||
$context->{"recover"} || $context->{"resincrdmp"}){
my $ver = checkCompat();
if ($ver < VER12)
{
Die ("Unable to use given option with this version of DB. Min ver".
" required is 12.1.0.0");
}}
}
Function : Main
Purpose : Main entry point for the program
sub Main
{
parseArg();
assignGlobVars();
checkArg();
# User wanted to clear file, do it so here
if ($context->{"clearerrorfile"})
{
Unlink ($errfile, 1);}
parseProperties();
checkProps();
checkExec();
$context->{"platname"} = getPlatName();
#If we want specify tablespaces to be rolled forward, then store them in
#a hash
if ($context->{"rolltbs"})
{
@rolltbsArray = split (',', $context->{"rolltbs"});
foreach my $x (@rolltbsArray)
{
$tbsHash{"$x"}= 1;
}}
if (($context->{"incremental"}) ||
($context->{"bkpincr"}) ||
($context->{"bkpexport"})){
backincr();}
elsif ($context->{"rollforward"})
{
fixXTTDestFile();
rollforward();}
elsif ($context->{"restore"})
{
fixXTTDestFile();
resrecBkp(RESTORE);}
elsif (($context->{"recover"}) ||
($context->{"resincrdmp"})){
fixXTTDestFile();
resrecBkp(RECOVER);
if ($context->{"resincrdmp"})
{
createDumpFile();
plugin(LOCALFILE);
}}
elsif ($context->{"determinescn"})
{
newplan();}
elsif ($context->{"convert"})
{
#If the transfer is across the same endian then platformid will be
#set as 0.
if ($props{'platformid'} == 0)
{
genConvertDFNames();
}
else
{
convert();
}}
elsif ($context->{"generate"})
{
plugin(LINK);}
elsif (($context->{"prepare"}) || ($context->{"backup"}) ||
($context->{"setupgetfile"})){
checkNoPwdSSHEnabled ();
prepare();}
elsif ($context->{"getfile"})
{
getFilesSource();}
else
{
usage();}
}
Incremental Starts here
Generates /tsbkupmap.txt
that maps tablespace to backup
sub gentablespace_backupmap
{
my @line = split /n/, $_[0];
my $tsbkupmap = "$tmp/tsbkupmap.txt";
my $incrbkups = "$tmp/incrbackups.txt";
my $backupformat = $props{'backupformat'};
my $i = 0;
my @fnums = ();
my @fnumorder = ();
my $chan;
my %bpfn;
my %bpts;
my %chfn;
my $tsname;
my $fno;
my $order = 0;
my $dmpFile = 0;
open(TSBKMAP, ">>$tsbkupmap") ||
Die("Cant open tablespace backup map file $!");open(INCRBKUPS, ">>$incrbkups") || Die("Cant open incr backups file $!");
while ($i <= $#line)
{
my $str = $line[$i];
if ($str =~ /^ts::(.*)$/)
{
$tsname = $1;
$order = 0;
}
elsif ($str =~ /channel (.*): specifying datafile/)
{
$chan = $1;
}
elsif ($str =~ /.*input Data Pump dump file.*/)
{ ## piece name is on the next line
$i++;
$str = $line[$i];
$chan = $1;
$dmpFile = 1;
}
## In HP, an issue was reported where in the RMAN output was
## shown as 'input datafile fno' instead of 'input datafile file number'.
## So parse for both here.
elsif (($str =~ /input datafile file number=(\d+) name/) ||
($str =~ /input datafile fno=(\d+) name/))
{
$fno = $1 + 0;
push(@fnums, $fno);
$i++;
next;
}
elsif (defined($chan) && $#fnums >= 0 )
{
my @new = @fnums;
$chfn{$chan} -> {"fnumarray"} = \@new;
@fnums = ();
}
elsif ($str =~ /channel (.*): finished piece/)
{
## piece name is on the next line
$i++;
$str = $line[$i];
$chan = $1;
if ($str =~ /piece handle=(.+)[\/](\S+) tag/)
{
if ($dmpFile)
{
my $piece = $2;
debug "backup piece:" . $piece . "\n" ;
debug "TSNAME:" . $tsname;
print TSBKMAP "DMPEXP::$piece\n";
print INCRBKUPS $backupformat."/$piece \n";
}
else
{
$bpfn{$2} -> {"fnumarray"} = $chfn{$chan} -> {"fnumarray"};
$order = $order + 1;
$bpfn{$2} -> {"fnumorder"} = $order;
debug "TSNAME:" . $tsname;
$bpts{$2} = $tsname;
}
}
}
elsif ($str =~ /including current control file in backup set/)
{
do
{
$i++;
$str = $line[$i];
}
while ($str !~ /Finished backup/);
}
$i++;}
foreach my $pkey (keys %bpfn)
{
print INCRBKUPS $backupformat . "/$pkey\n";
my @fns = @{$bpfn{$pkey} -> {"fnumarray"}};
my $sizefns = @fns;
print TSBKMAP $bpts{$pkey} . "::";
my $orderx = $bpfn{$pkey} -> {"fnumorder"};
foreach my $v (@fns)
{
$sizefns--;
print TSBKMAP $v;
print TSBKMAP "," if ($sizefns > 0);
}
print TSBKMAP ":::". $orderx;
print TSBKMAP "=" . $pkey;
print TSBKMAP "\n";}
close(TSBKMAP);
close(INCRBKUPS);
}
sub backincr()
{
PrintMessage ("Backup incremental");
checkErrFile();
## Move out any existing xttplan.txt.new
my $xttpathnew = "$tmp/xttplan.txt.new";
my @trnsfrFiles = ();
my $tsbkupmap = "$tmp/tsbkupmap.txt";
my $incrbkups = "$tmp/incrbackups.txt";
if ( -e $xttpathnew )
{
my $timenow = time;
system("\\mv $xttpathnew $xttpath" . $timenow);}
## Generate the next round xttplan.txt
&generate_batch_tsoutput(BCKPINCR);
## At this point, we must have a new xttplan.txt.new
## populated with required from_scn's for next incremental backup.
debug "Start backup incremental" ;
# Clean up any rmanincr.cmd from TMPDIR area.
my $rmanincrpath = "$tmp/rmanincr.cmd";
my $timenow = time;
if ( -e $rmanincrpath )
{
system("\\mv $rmanincrpath $rmanincrpath" . $timenow);}
debug "Crossed mv " ;
my $backupformat = $props{'backupformat'};
debug "Crossed mv $backupformat" ;
## Remove trailing '/'s
$backupformat = $1 if($backupformat=~/(.*)\/$/);
if ($context->{"bkpexport"})
{
open(XTTPLAN, $xttpath) || die 'Cant find xttplan.txt, TMPDIR undefined';
my $rman_str1 = "set nocfau;";
my $rman_str;
my @scnArray = ();
my @scnSortedArray = ();
my $scn;
my $rmCmd;
while (<XTTPLAN>)
{
if (/(\S+)::::(\S+)/)
{
push (@scnArray, $2);
}
}
close XTTPLAN;
if (!@scnArray)
{
ErrorMessage ("BACKUPINCR: Could not find lowest SCN");
}
@scnSortedArray = sort (@scnArray);
$scn = $scnSortedArray[0];
$rmCmd = "BACKUP FOR TRANSPORT INCREMENTAL from scn $scn TABLESPACE ".
" $props{'tablespaces'}".
" FORMAT '$backupformat/%U'".
" DATAPUMP FORMAT '$backupformat/%U';";
open(RMANINCR, ">$tmp/rmanincr.cmd") || Die("Cant open rmanincr.cmd $!");
print RMANINCR "$rmCmd";
close RMANINCR;}
else
{
## Generate $tmp/rmanincr.cmd
debug "Generate $tmp/rmanincr.cmd";
open(RMANINCR, ">$tmp/rmanincr.cmd") || Die("Cant open rmanincr.cmd $!");
## Parse out xttplan.txt and build the rman command
open(XTTPLAN, $xttpath) || die 'Cant find xttplan.txt, TMPDIR undefined';
my $rman_str1 = "set nocfau;";
my $rman_str;
while (<XTTPLAN>)
{
if (/(\S+)::::(\S+)/)
{
my $tablespace = $1;
my $scn = $2;
my $rman_str;
print RMANINCR $rman_str1 . "\n";
$rman_str = "host 'echo ts::$tablespace';";
print RMANINCR $rman_str . "\n";
if ($context->{"bkpincr"})
{
$rman_str = "backup for transport allow INCONSISTENT ".
"incremental from scn $scn ";
}
else
{
$rman_str = "backup incremental from scn $scn ";
}
print RMANINCR $rman_str . "\n";
if ($context->{"incremental"})
{
$rman_str = " tag tts_incr_update tablespace '$tablespace' ".
" format";
print RMANINCR $rman_str . "\n";
}
else
{
$rman_str = " tablespace '$tablespace' format";
print RMANINCR $rman_str . "\n";
}
$rman_str = " '$backupformat/%U';";
print RMANINCR $rman_str . "\n";
}
}
close(XTTPLAN);
close(RMANINCR);}
## Execute the rman command here
my ($rmanTrace, $traceFile) = GetRMANTrace("incrbackup");
my $output_str = "rman target \/ $rmanTrace cmdfile $rmanincrpath";
print $output_str . "n";
my $output = rman target \/ $rmanTrace cmdfile $rmanincrpath;
print $output . "n";
checkMove ($tsbkupmap);
checkMove ($incrbkups);
&gentablespace_backupmap( $output ) ;
if ($metaTransfer)
{
@trnsfrFiles = ();
push (@trnsfrFiles, "$tmp/tsbkupmap.txt");
transferFiles (@trnsfrFiles);
open FILE, "$tmp/incrbackups.txt";
@trnsfrFiles = <FILE>;
close FILE;
$context->{"desttmp"} = $props{'stageondest'};
transferFiles (@trnsfrFiles);
$context -> {"desttmp"} = $props{'desttmpdir'};}
Unlink ($traceFile);
PrintMessage ("Done backing up incrementals");
exit;
}
Incremental Ends here
Check if element exists in array.
sub checkInArray
{
my $element = $_[0];
if (@rolltbsArray)
{
if ($tbsHash{"$element"})
{
return 1;
}
else
{
return 0;
}}
else
{
return 1;}
}
Rollforward Starts here - on destination
New changes in v1.1
xttrollforwarddest.sql is now a generated file.
All file processing is handled by perl itself.
xttrollforwarddest.sql will be called for each tablespace
The destination database will be started up in nomount
until all the tablespaces are rollforwarded.
sub rmconvertedincr
{
# Check if any failure occured and stop exection
checkErrFile();
my $backupondest = $props{'backupondest'};
my $asmhome = $props{'asm_home'};
my $asmsid = $props{'asm_sid'};
my $rmcmd = "";
if (defined $props{'asm_home'})
{
## Lets first delete the incremental backup if any
## this will happen through asmcmd
my $oh_saved = $ENV{'ORACLE_HOME'};
my $ohsid_saved = $ENV{'ORACLE_SID'};
my $asmcmd = 0 ;
my $asmcmd_str;
$ENV{'ORACLE_HOME'} = $asmhome;
$ENV{'ORACLE_SID'} = $asmsid;
# Remove trailing spaces
$backupondest =~ s/\s+$//;
$asmsid =~ s/\s+$//;
$asmcmd_str = "asmcmd rm $backupondest/$xtts_incr_backup";
debug $asmcmd_str . " $asmhome .. $asmsid \n" ;
$asmcmd = `asmcmd rm $backupondest/$xtts_incr_backup`;
debug "ASMCMD: $asmcmd\n";
$ENV{'ORACLE_HOME'} = $oh_saved;
$ENV{'ORACLE_SID'} = $ohsid_saved;
if ($asmcmd == 0)
{
Unlink ("$backupondest/$xtts_incr_backup", 1);
}}
else
{
Unlink ("$backupondest/$xtts_incr_backup", 1);}
}
Function : ChecktoProceed
Purpose : When running the roll forward in parallel, we will check if we can
fork any more jobs
sub ChecktoProceed
{
my $parallel = $_[0];
# Check if any failure occured and stop exection
checkErrFile();
my $running = 0;
if ($#forkArray <= 0)
{
return;}
do
{
$running = 0;
foreach my $index (0 .. $#forkArray)
{
my $x = $forkArray[$index];
if ($x <= 0)
{
next;
}
my $kid = waitpid($x, WNOHANG);
if ($kid >= 0)
{
$running = $running + 1;
}
else
{
$forkArray[$index] = 0;
}
}} while ($running >= $parallel);
return;
}
sub UpdateForkArray
{
my ($pid, $parallel) = @_;
if ($#forkArray < $parallel)
{
push (@forkArray, $pid);}
else
{
foreach my $index (0 .. $#forkArray)
{
my $x = $forkArray[$index];
if ($x == 0)
{
$forkArray[$index] = $pid;
last;
}
}}
}
Function : FixCnvScripts
Purpose : Fix the scripts that has details about incremental backup
sub FixCnvScripts
{
my $toFixSql = $_[0];
my $inpSql = $_[1];
my $fixedStr = $_[2];
my $platformid = $props{'platformid'};
my $fixedStrL = "";
my $len = 0;
open XTTS_INCR_BACKUP, "<$inpSql";
open XTTS_INCR_BACKUP1, ">$toFixSql";
my @arrayXttincr = ;
# Bug 20192155: Use xib instead of "xtts_incr_backup" to prevent
# ORA error ORA-15126 with ASM
$fixedStrL = substr($fixedStr, 0, 42);
$xtts_incr_backup = "xib"."_".$fixedStrL;
$len = length ($xtts_incr_backup);
if ($len > 50)
{
ErrorMessage ("Length of backupiece exceeds 50 chars $xtts_incr_backup");}
foreach my $x (@arrayXttincr)
{
chomp($x);
if ($x =~ m/(.*)xtts_incr_backup(.*)\,/)
{
print XTTS_INCR_BACKUP1 "$1$xtts_incr_backup$2,\n";
}
elsif ($x =~ m/(.*)xtts_incr_backup(.*)/)
{
print XTTS_INCR_BACKUP1 "$1$xtts_incr_backup$2\n";
}
elsif (!(($platformid == 0) && ($x =~ m/(.*)pltfrmfr(.*)/)))
{
print XTTS_INCR_BACKUP1 "$x\n";
}
else
{
print XTTS_INCR_BACKUP1 "$x\n";
}}
close XTTS_INCR_BACKUP1;
close XTTS_INCR_BACKUP;
}
Function : sortArrayOrder
Purpose : Sort the Array based on piece
sub sortArrayOrder
{
return sort {
(($a =~ /::(.*):::.*/)[0] <=> ($b =~ /::(.*):::.*/)[0] ||
($a =~ /:::(.*?)=/)[0] <=> ($b =~ /:::(.*?)=/)[0]
)
} @_;}
UTIL functions
Following functions are useful for conversion, rollforward etc
sub ConvertBackup
{
my $backup = $_[0];
my $dfno = $_[1];
my $fixCnvSql;
my $outputCnvrt;
$fixCnvSql = "$tmp/xxttconv_$backup"."_$dfno.sql";
FixCnvScripts ($fixCnvSql, $cnvrSql, $backup."_".$dfno);
Unlink ("$backupondest/$xtts_incr_backup", 1);
my $outputCnvrt =
`sqlplus -L -s \"$connectstringcnvinst\" \@$fixCnvSql $stageondest/$backup $backupondest $platformid`;checkError ("$fixCnvSql execution failed", $outputCnvrt);
Unlink ($fixCnvSql);
}
sub RollPiece
{
my $sqlfile = $_[0];
my $outputCnvrt;
## now call generated rollforward
$outputCnvrt =
`sqlplus -L -s \"/ as sysdba\" \@$sqlfile`;checkError ("$sqlfile execution failed", $outputCnvrt);
}
sub ConvertRoll
{
my ($fixedStr, $oldre, $rb, $rend, $bkupList, $rmList) = @_;
my $rollFile;
$rollFile = "$tmp/xxttroll_$fixedStr.sql";
open (XTTROLL, ">$rollFile") or Die $!;
print XTTROLL $rb;
foreach my $y (@{$rmList})
{
print XTTROLL $y;}
foreach my $backup (@{$bkupList})
{
my $re = $oldre;
ConvertBackup ($backup, $fixedStr);
$re =~ s/##xtts_incr_backup/$xtts_incr_backup/;
print XTTROLL $re;}
print XTTROLL $rend;
close XTTROLL;
RollPiece ($rollFile);
rmconvertedincr();
}
sub RestoreRecover
{
my ($fixedStr, $finalRes) = @_;
my $cmdfile = "$tmp/xttresrec_$fixedStr.cmd";
open RMANRE, ">$cmdfile";
print RMANRE "$finalResn";
close RMANRE;
my ($rmanTrace, $traceFile) = GetRMANTrace("resrec");
my $output = rman target \/ $rmanTrace cmdfile $cmdfile;
debug ($output);
if ($output =~ /ERROR MESSAGE/)
{
Die("$output $!");}
Unlink ($traceFile);
}
End of UTIL functions
Following functions are useful for conversion, rollforward etc
Function : clearUpRollfwd
Purpose : Clear the scripts and converted incrementals after rollfwd
sub clearUpRollfwd
{
Unlink ($fixCnvSql);
Unlink ($xttrollforwardp);
Unlink ($fixRollSql);
rmconvertedincr();
}
sub rollforward()
{
PrintMessage ("Start rollforward");
# Check if any failure occured and stop exection
checkErrFile();
my $connectstringdest = "/ as sysdba";
my $ohcnv = $props{'cnvinst_home'};
my $ohcnvsid = $props{'cnvinst_sid'};
my $tsbkupmappath = "$tmp/tsbkupmap.txt";
my $tsn;
my $fixedSql;
my $pid = 0;
my $i = 0;
my $parent = 0;
my $count = 0;
my $newrm;
my $oldre;
my $rb = q(
set serveroutput on;
DECLARE
outhandle varchar2(512) ;
outtag varchar2(30) ;
done boolean ;
failover boolean ;
devtype VARCHAR2(512);
BEGIN
DBMS_OUTPUT.put_line('Entering RollForward');
-- Now the rolling forward.
devtype := sys.dbms_backup_restore.deviceAllocate;
sys.dbms_backup_restore.applySetDatafile(
check_logical => FALSE, cleanup => FALSE) ;
DBMS_OUTPUT.put_line('After applySetDataFile');
);
my $rm = q(
sys.dbms_backup_restore.applyDatafileTo(
dfnumber => ##fno,
toname => ##fname,
fuzziness_hint => 0, max_corrupt => 0, islevel0 => 0,
recid => 0, stamp => 0);
);
my $rmend = q(
DBMS_OUTPUT.put_line('Done: applyDataFileTo');
);
my $re = q(
DBMS_OUTPUT.put_line('Done: applyDataFileTo');
-- Restore Set Piece
sys.dbms_backup_restore.restoreSetPiece(
handle => '##backupondest/##xtts_incr_backup',
tag => null, fromdisk => true, recid => 0, stamp => 0) ;
DBMS_OUTPUT.put_line('Done: RestoreSetPiece');
-- Restore Backup Piece
sys.dbms_backup_restore.restoreBackupPiece(
done => done, params => null, outhandle => outhandle,
outtag => outtag, failover => failover);
DBMS_OUTPUT.put_line('Done: RestoreBackupPiece');
);
my $rend = q(
sys.dbms_backup_restore.restoreCancel(TRUE);
sys.dbms_backup_restore.deviceDeallocate;
END;
/
exit
);
$stageondest = $props{'stageondest'};
$backupondest = $props{'backupondest'};
$platformid = $props{'platformid'};
$re =~ s/##backupondest/$backupondest/;
$oldre = $re;
if (!defined($ohcnv))
{
$connectstringcnvinst = "/ as sysdba";}
else
{
debug "convert instance: $ohcnv \n";
debug "convert instance: $ohcnvsid \n";
$connectstringcnvinst =
"/\@(DESCRIPTION=(ADDRESS=(PROTOCOL=BEQ)(PROGRAM=$ohcnv/bin/oracle)".
"(ARGV0=oracle$ohcnvsid)(ARGS='(DESCRIPTION=(LOCAL=YES)".
"(ADDRESS=(PROTOCOL=BEQ)))')".
"(ENVS='ORACLE_HOME=$ohcnv,ORACLE_SID=$ohcnvsid'))".
"(CONNECT_DATA=(SID=$ohcnvsid))) as sysdba";}
my %tsbkupmap;
my @tsArray = ();
open my $in, $tsbkupmappath or Die ("$tsbkupmappath $!");
@tsArray = <$in>;
close $in;
foreach my $x (sortArrayOrder @tsArray)
{
$_ = $x;
next if /^#/;
if (m/(\S+):::.*?=(\S+)/g)
{
push (@{$tsbkupmap{$1}}, $2);
}}
##
## Putting database on target in nomount
## as it could cause the following error.
## ORA-00600: internal error code, arguments: [2130], [33], [32], [4]
## The reason for this is :
##
## The code is trying to access KCCDEDBF (datafile) record# 33 when there
## is only record# 32. It looks when you try to apply the incremental
## backup on linux box, you are expecting the datafile# 33 to exists in the
## target database. However, that can't be always true.
##
## This is worked around by starting the target database iin nomount.
## The convert call/script should work in nomount state of database too.
##
if (defined($context->{"rolltbs"}))
{
checkDBState();}
debug3 ("ROLLFORWARD: Starting DB in nomount mode");
my $outputstart = sqlplus -L -s \"/ as sysdba\" \@xttstartupnomount.sql;
checkError ("Error in executing xttstartupnomount.sql", $outputstart);
## Generate xttrollforwarddest.sql that is the script
## that will rollforward all the converted datafiles.
my $tsbkcount = scalar keys %tsbkupmap;
if ($tsbkcount == 0)
{
Die ("No tablepsace entries found");}
my @sortedkeys = sort keys %tsbkupmap;
foreach $tsn (@sortedkeys)
{
my ($ts, $rdfno, $order) = split(/::/, $tsn);
my $fixedStr;
if ($context->{"rolltbs"})
{
my $checkArray = checkInArray($ts);
if ($checkArray == 0)
{
next;
}
}
debug "rdfno " . $rdfno . "\n";
my @rdfnos = split /,/, $rdfno;
open (ROLLPLAN, "$tmp/xttnewdatafiles.txt") or Die $!;
my $scrape = 0;
# Check if any failure occured and stop exection
checkErrFile();
debug "BEFORE ROLLPLAN\n";
my @rmList = ();
while (<ROLLPLAN>)
{
if ($scrape == 1 && $_ !~ /::/)
{
chop;
my $oldrm = $rm;
my $dfstr = $_;
my ($dfno, $dfname) = split /,/, $dfstr;
my $ind;
## include the dfno only if present in the tsbkupmap.txt list
## of dfnos.
my $found = 0;
for ($ind = 0; $ind <= $#rdfnos ; $ind++)
{
if ($dfno == $rdfnos[$ind])
{
$found = 1;
last;
}
}
if ($found == 1)
{
debug "datafile number : $dfno \n";
debug "datafile name : $dfname\n";
$newrm = $rm;
$newrm =~ s/##fno/$dfno/;
$newrm =~ s/##fname/'$dfname'/;
push (@rmList, $newrm);
}
}
if (/^::$ts$/)
{
$scrape = 1;
}
elsif (/^::/)
{
$scrape = 0;
}
}
push (@rmList, $rmend);
close(ROLLPLAN);
debug "AFTER ROLLPLAN\n";
$rollParallel = $props{'rollparallel'};
$fixedStr = $rdfno;
$fixedStr =~ tr/,/_/;
# Bug 20192155: Use xib instead of "xtts_incr_backup" to prevent
# ORA error ORA-15126 with ASM
my $fixedStrL = substr($fixedStr, 0, 25);
if ($rollParallel)
{
ChecktoProceed($rollParallel);
$pid = fork();
if ($pid == 0)
{
ConvertRoll ($fixedStrL, $oldre, $rb ,$rend, \@{$tsbkupmap{$tsn}},
\@rmList);
exit (0);
}
else
{
UpdateForkArray ($pid, $rollParallel);
}
}
else
{
ConvertRoll ($fixedStrL, $oldre, $rb ,$rend, \@{$tsbkupmap{$tsn}},
\@rmList);
}}
while((my $pid = wait()) > 0)
{
#sleep (1);}
# Check if any failure occured and stop exection
checkErrFile();
my $outputstart = sqlplus -L -s \"/ as sysdba\" \@xttdbopen.sql;
PrintMessage ("End of rollforward phase");
exit;
}
Function : resrecBkp
Purpose : Restore recover backup piece
sub resrecBkp
{
my $option = $_[0];
PrintMessage ("Start restore/recover");
# Check if any failure occured and stop exection
checkErrFile();
my $tsbkupmappath = "$tmp/tsbkupmap.txt";
my $tsn;
my $fixedSql;
my $pid = 0;
my $i = 0;
my $parent = 0;
my $count = 0;
my $newrm;
my $oldre;
my $platName = $context->{"platname"};
$stageondest = $props{'stageondest'};
$platformid = $props{'platformid'};
my %tsbkupmap;
my @tsArray = ();
open my $in, $tsbkupmappath or Die ("$tsbkupmappath $!");
@tsArray = <$in>;
close $in;
foreach my $x (sortArrayOrder @tsArray)
{
$_ = $x;
next if /^#/;
if (m/(\S+):::.*?=(\S+)/g)
{
push (@{$tsbkupmap{$1}}, $2);
}}
my $tsbkcount = scalar keys %tsbkupmap;
if ($tsbkcount == 0)
{
Die ("No tablepsace entries found");}
my @sortedkeys = sort keys %tsbkupmap;
my $res = '';
my $finalRes = '';
foreach $tsn (@sortedkeys)
{
my ($ts, $rdfno, $order) = split(/::/, $tsn);
my $fixedStr;
debug "rdfno " . $rdfno . "\n";
my @rdfnos = split /,/, $rdfno;
open (ROLLPLAN, "$tmp/xttnewdatafiles.txt") or Die $!;
my $scrape = 0;
# Check if any failure occured and stop exection
checkErrFile();
debug "BEFORE ROLLPLAN\n";
my @rmList = ();
my $dfnofinal = 0;
$res = '';
while (<ROLLPLAN>)
{
if ($_ !~ /::/)
{
chop;
my $dfstr = $_;
my ($dfno, $dfname) = split /,/, $dfstr;
my $ind;
## include the dfno only if present in the tsbkupmap.txt list
## of dfnos.
my $found = 0;
for ($ind = 0; $ind <= $#rdfnos ; $ind++)
{
if ($dfno == $rdfnos[$ind])
{
$found = 1;
if (($option == RESTORE) || ($option == RECOVER))
{
if ($res ne '')
{
$res = $res.",";
}
if ($option == RECOVER)
{
$res = $res."'$dfname'";
}
else
{
$res = $res."$dfno format '$dfname'";
}
}
}
}
}
}
if ($option == RESTORE)
{
$finalRes =
"restore from platform '$platName' FOREIGN DATAFILE ".
$res.
" from backupset '$stageondest/@{$tsbkupmap{$tsn}}';\n";
}
elsif ($option == RECOVER)
{
$finalRes =
" recover from platform '$platName' FOREIGN DATAFILECOPY ".
$res.
" from backupset '$stageondest/@{$tsbkupmap{$tsn}}';\n";
}
close(ROLLPLAN);
debug "AFTER ROLLPLAN\n";
$rollParallel = $props{'rollparallel'};
$fixedStr = $rdfno;
$fixedStr =~ tr/,/_/;
if ($rollParallel)
{
ChecktoProceed($rollParallel);
$pid = fork();
if ($pid == 0)
{
RestoreRecover ($fixedStr, $finalRes);
exit (0);
}
else
{
UpdateForkArray ($pid, $rollParallel);
}
}
else
{
RestoreRecover ($fixedStr, $finalRes);
}}
while((my $pid = wait()) > 0)
{
#sleep (1);}
# Check if any failure occured and stop exection
checkErrFile();
PrintMessage ("End of restore/recover phase");
}
sub createDumpFile
{
my $option = $_[0];
my $finalRes = '';
my $bkPiece = '';
my $platName = $context->{"platname"};
PrintMessage ("Start creating dumpfile");
# Check if any failure occured and stop exection
checkErrFile();
my $tsbkupmappath = "$tmp/tsbkupmap.txt";
my %tsbkupmap;
my @tsArray = ();
open my $in, $tsbkupmappath or Die ("$tsbkupmappath $!");
@tsArray = <$in>;
close $in;
foreach my $x (sortArrayOrder @tsArray)
{
$_ = $x;
next if /^#/;
if (m/.*DMPEXP::(.*)/)
{
$bkPiece = $1;
last;
}}
my $dmpFile = "impdp".GetTimeStamp().".dmp";
my $dumpDir;
$context->{"dmpfile"} = $dmpFile;
if (defined($props{'dumpdir'}))
{
$dumpDir = $props{'dumpdir'};
if (!-e $dumpDir)
{
$dumpDir = $tmp;
}}
else
{
$dumpDir = $tmp;}
$finalRes =
" restore from platform '$platName' ".
" dump file '$dmpFile' ".
" datapump destination '$dumpDir' ".
" from backupset '$stageondest/$bkPiece';\n";
debug "$finalResn";
open RMANRE, ">rman_createdmp.cmd";
print RMANRE "$finalResn";
close RMANRE;
my ($rmanTrace, $traceFile) = GetRMANTrace("convert");
my $output = rman target \/ $rmanTrace cmdfile rman_createdmp.cmd;
debug ($output);
if ($output =~ /ERROR MESSAGE/)
{
Die("$output $!");}
Unlink ($traceFile);
# Check if any failure occured and stop exection
checkErrFile();
PrintMessage ("End of creating dumpfile");
}
Rollforward Ends here - on destination
xttplan.txt with new fromscn -- STARTS
sub newplan()
{
# Check if any failure occured and stop exection
checkErrFile();
## Move the current xttplan.txt.new as xttplan.txt
## The xttplan.txt.new gets generated during backincr()
my $xttplanpath = "$tmp/xttplan.txt";
my $xttplanpathnew = "$tmp/xttplan.txt.new";
if ( -e $xttplanpath )
{
my $timenow = time;
system("\\mv $xttplanpath $xttplanpath" . $timenow);
system("\\mv $xttplanpathnew $xttplanpath");}
## Checks that no tablespace went read only
## or datafiles offline
&generate_batch_tsoutput(NEWPLAN);
print "New $tmp/xttplan.txt with FROM SCN's generatedn";
exit;
}
xttplan.txt with new fromscn -- ENDS
Convert Starts here - on destination
sub convert()
{
PrintMessage ("Performing convert");
# Check if any failure occured and stop exection
checkErrFile();
my ($rmanTrace, $traceFile) = GetRMANTrace("convert");
my $output = rman target \/ $rmanTrace cmdfile $rmanpath;
if ($output =~ /ERROR MESSAGE/)
{
Die("$output $!");}
Unlink ($traceFile);
my @lines = split /n/, $output;
my $xttnewdata = "$tmp/xttnewdatafiles.txt";
if ( -e $xttnewdata )
{
my $timenow = time;
system("\\mv $xttnewdata $xttnewdata" . $timenow);}
open(XTTNEW, ">$xttnewdata") || Die("Cant open xttnewdatafiles.txt");
foreach my $line (@lines)
{
my $tsname;
my $filno;
$_ = $line;
if (/converted datafile=(.+)\/(\w+)[_](\d+)\.xtf/)
{
print XTTNEW "$3,";
$line =~ s/.*converted datafile=//;
print XTTNEW "$line\n";
}
elsif(/^ts(\S+)/)
{
print XTTNEW $1 . "\n";
$tsname = $1;
}
}
close(XTTNEW);
PrintMessage ("Converted datafiles listed in: $xttnewdata");
exit;
}
Function : genConvertDFNames
Purpose : When script is used to transport tablespaces between same endian
this function will be called. Here we create xttnewdatafiles.txt
sub genConvertDFNames
{
my @convertArray = ();
# Check if any failure occured and stop exection
checkErrFile();
open(RMANCONVERT, "$rmanpath") ||
die 'Cant find rmanconvert.cmd, TMPDIR undefined';@convertArray = ;
close RMANCONVERT;
open(RMANDSTDF, ">$rmandstdf") ||
Die "Cant find $rmandstdf";
foreach my $x (@convertArray)
{
chomp($x);
$x = trim($x);
if ($x =~ /'(.*)\.tf'/)
{
$x = $1.".tf";
if ($x =~ /.*(.+)\/(\w+)[_](\d+)\.tf/)
{
print RMANDSTDF "::$2\n";
print RMANDSTDF "$3,$x\n";
}
}}
close RMANDSTDF;
exit;
}
Convert Ends here - on destination
Generate plugin/impdp command template as xttplugin.txt
- Starts here, on destination
sub plugin()
{
my $option = $_[0];
PrintMessage ("Generating plugin");
# Check if any failure occured and stop exection
checkErrFile();
my $xttplugin = "$tmp/xttplugin.txt";
my $tts = "transport_tablespaces=";
my $tdf = "transport_datafiles=";
my $comma = 0;
my $xttnewdata = "$tmp/xttnewdatafiles.txt";
my $command_str;
my $dmpFile = $context->{"dmpfile"};
if ( -e $xttplugin )
{
my $timenow = time;
system("\\mv $xttplugin $xttplugin" . $timenow);}
open(XTTPLUG, ">$xttplugin") || Die("Unable to open file $xttplugin");
if ($option == LINK)
{
$command_str =
"impdp directory=<DATA_PUMP_DIR> logfile=<tts_imp.log> \\" . "\n" .
"network_link=<ttslink> transport_full_check=no \\" . "\n" ;}
else
{
$command_str =
"impdp directory=<DATA_PUMP_DIR> logfile=<tts_imp.log> \\" . "\n" .
"dumpfile=$dmpFile \\" . "\n" ;}
print XTTPLUG $command_str;
if ($option == LINK)
{
print XTTPLUG $tts;
open(XTTPLAN, $xttpath) || Die("Cant find xttplan.txt\n $!");
while (<XTTPLAN>)
{
if ($comma == 1 && /::::/)
{
print XTTPLUG ",";
$comma = 0;
}
if (/(\S+)::::(\S+)/)
{
print XTTPLUG $1;
$comma = 1;
}
}
close(XTTPLAN);
print XTTPLUG " \\\n";}
print XTTPLUG $tdf;
$comma = 0;
open(XTTNEWDATA, $xttnewdata) || Die("Cant find xttnewdatafiles.txt\n $!");
while ()
{
if ($comma == 1)
{
print XTTPLUG ",";
$comma = 0;
}
if (! /^::\S+/)
{
chop;
my ($dfno, $dfname) = split /,/, $_;
print XTTPLUG "'" . $dfname . "'";
$comma = 1;
}}
print XTTPLUG "n";
close(XTTNEWDATA);
close(XTTPLUG);
PrintMessage ("Done generating plugin file $xttplugin");
exit;
}
Generate plugin/impdp command - Ends here, on destination
Function : usage
Purpose : Message about this program and how to use it
sub usage
{
print STDERR << "EOF";
This program prepares, backsup and rollsforward tablespaces
for cross-platform transportable tablespaces.
usage: $0
{[--backup|-b] || [--bkpincr|-B] || [--bkpexport/E]
[--resincrdmp|M]
[--convert/-c] || [--generate|-e] || [--incremental|-i] ||
[[--prepare|-p] || [--getfile|-G]] ||
[--restore|R] || [--recover|X]
[--rollforward|-r [--rolltbs|-T <TBS1[,TBS2]>] ||
[--determinescn|-s] ||
[--orasid/O] || [--orahome|-o]]
[--help|-h]}
Additional options
------------------
[--debug|d] [--clearerrorfile|-C] [--xttdir|Dir <tmpdir>]
[-F/--propfile] [-I/--propdir]
-b : For 12c and above, generate transportable backups
-B : For 12c and above, generate level 1 transportable backups
-c : conversion of datafiles
-M : create the dump file from the generated backup
-e : generate impdp script: export over new link
-i : incremental backup
-p : prepare
-G : get datafiles from source database using get_file, should not
be used together with -p
-r : roll forward datafiles
-s : new from_scn values into xttplan.txt
-R : For 12c restore the datafiles from the backups
-X : For 12c recover the datafiles from the backups
-T : roll forward specific tablespace(s)
-h : this (help) message (Default)
-d : provides more debug information, also rman is called with debug
option so that tracing is better.
-L : delete the ERROR FILE and proceed with the execution
-D : Instead of defining environement variable, user can pass tmpdir
through xttdir
-O : Use this option to pass ORACLE_SID to override the environment
variable
-o : Use this option to pass ORACLE_HOME to override the environment
variable
-I : Use this option to mention the location from where the script
will pick the properties file etc
-F : Use this option to mention the location from where the script
will pick the properties file.
example: $0 -p
$0 -i
$0 -r
$0 -s
EOF
exit;
}
Function : GetTimeStamp
Purpose : Get the time stamp
Inputs : None
Outputs : Timestamp
NOTES : None
sub GetTimeStamp
{
my $timeStamp = $$."_".int(rand(1000));
return ($timeStamp);}
Call main function
Main();
