#!/bin/env perl
#
# $Header: tfa/src/orachk/src/psqlplus /main/20 2015/09/27 22:36:31 apriyada Exp $
#
# psqlplus
#
# Copyright (c) 2013, 2015, Oracle and/or its affiliates. All rights reserved.
#
#    NAME
#      psqlplus - Run SQL queries parallelly.
#
#    DESCRIPTION
#      <short description of component this file declares/defines>
#
#    NOTES
#      <other useful comments, qualifications, etc.>
#
#    MODIFIED   (MM/DD/YY)
#    apriyada    08/24/15 - Bug 20872968
#    rojuyal     01/09/14	- Running as 'ROOT'
#    rojuyal     30/06/14	- Running as 'ROOT' 
#    rojuyal     02/04/14 	- Creation


#Section:MODULES----------
use strict;
use warnings;

use Getopt::Long;
use Sys::Hostname;
use Config;
use POSIX;
use File::Spec;
use File::Basename;
use File::Copy;
use Cwd;
use Time::Local;

#Section:VARIABLES--------
umask 0000;

my ($SHOW_HELP)			= 0;
my ($OSNAME)       		= $Config{'osname'};
my ($BASENAME)			= basename $0;
my ($LIMIT)    			= 0;
my ($APPTYPE)                     = "GENERIC";
my (@PIDS);
my ($PID);

my ($LOCALNODE)			= ( split '\.', hostname )[0] || '';
my ($SYS_TEMP_DIR) 		= $ENV{TMPDIR} || "/tmp" || getcwd() || getdcwd();
my ($BASH_SCR) 			= "/bin/env bash";
my ($BASH_SOURCE) 		= "if [ -e \"/etc/profile\" ] ; then . /etc/profile >/dev/null 2>&1; fi; if [ -e \"\$HOME/.bash_profile\" ] ; then . \$HOME/.bash_profile >/dev/null 2>&1; elif [ -e \"\$HOME/.bash_login\" ]; then . \$HOME/.bash_login >/dev/null 2>&1; elif [ -e \"\$HOME/.profile\" ] ; then . \$HOME/.profile >/dev/null 2>&1; fi;set +u";

my ($CHKMETAFILE)   		= File::Spec->catfile( $SYS_TEMP_DIR, $BASENAME . '.meta' );
my ($DBFILE)	 		= File::Spec->catfile( $SYS_TEMP_DIR, $BASENAME . '_db.data' );
my ($STATFIL)	 		= File::Spec->catfile( $SYS_TEMP_DIR, $BASENAME . '_stat.data' );
my ($OUTPUTDIR)  		= $SYS_TEMP_DIR;
my ($OUTPUTDIR_NEW) 		= $SYS_TEMP_DIR;
my ($INPUTDIR)      		= $SYS_TEMP_DIR;
my ($RTEMPDIR)      		= $SYS_TEMP_DIR;
my ($SKIPFIL) 			= File::Spec->catfile( $SYS_TEMP_DIR, $BASENAME . '_skipped_checks.log' );
my ($ENVFIL)            	= File::Spec->catfile( $SYS_TEMP_DIR, $BASENAME . '_env.out' );
my ($CHECK_TIMINGS)     	= File::Spec->catfile( $SYS_TEMP_DIR, $BASENAME . '_timings.out' );
my ($CHK_TIMINGS)     		= File::Spec->catfile( $SYS_TEMP_DIR, $BASENAME . '_epoch_timings.out' );
my ($ORCLENVFIL)        	= File::Spec->catfile( $SYS_TEMP_DIR, $BASENAME . '_orcl_env.out' );
my ($ERRFIL)            	= File::Spec->catfile( $SYS_TEMP_DIR, $BASENAME . '_error.log' );

my ($RUNLOG)			= File::Spec->catfile( $SYS_TEMP_DIR, $BASENAME . '_' . $LOCALNODE . '_run' . '.log' );

my ($RGLOG);
my ($HOUSEKEEPING)		= 0;

my ($RAT_DB_APP_USER)		= "apps";

my ($CHECKID)       		= "DUMMY";
my ($COMTYPE)       		= "GENERIC";
my ($COM_REPORT);
my ($COMMAND);
my ($AU_CHK_NAME)          	= "CHECK";
my ($RAT_RUNMODE_INTERNAL) 	= "master";
my ($OUTFILNAM);
my ($NEEDS_RUNNING)     	= "RDBMS";
my ($COLLECTION_NAME);
my ($STACK_ASM_SID);
my ($STACK_ASM_HOME);
my ($PARAM_PATH);
my ($ROW);

my ($DEBUG)			= $ENV{RAT_SCRIPT_DEBUG}||0;
my ($TMP_OUTPUT)		= $ENV{TMPDIR} || "/tmp" || getcwd() || getdcwd();

my ($DEBUG_FLG)			= "";
my ($MERGE)   			= 0;
my ($MODE)     			= 0;
my ($CHG_USER) 			= 0;
my ($KEEP_LCMD)			= 0;

my ($rHOST);

my ($SCOPY) 			= "/usr/bin/scp -o UserKnownHostsFile=/dev/null -o StrictHostKeyChecking=no -q";
my ($SSHELL) 			= "/usr/bin/ssh -o UserKnownHostsFile=/dev/null -o StrictHostKeyChecking=no -q";

my ($bash_scr)	= "/bin/env bash";
if ( ! -f "/bin/bash" || ! -f "/bin/env" ) { $bash_scr=`which bash`; }


#Section:FUNCTIONS--------

sub get_dbOwner {
    my $OHOME = shift;
    my $RHOST = shift;
    my $FILENAME;
    my $OH_OWNER_UID;
    my %USER;

    if (defined $OHOME) {
      	$FILENAME = File::Spec->catfile( $OHOME, 'bin', 'oracle' );
      	if ( $RHOST ne $LOCALNODE ) {
            my ($t_CURRENT_OH_OWNER,$t_CURRENT_OH_GROUP,$t_HOME_DIR);

	    my $SSH_STATUS;
 	    $SSH_STATUS=`$SSHELL -o NumberOfPasswordPrompts=0 $RHOST ls >/dev/null 2>&1;echo \$?`; chomp($SSH_STATUS);
	    if ( defined $SSH_STATUS && $SSH_STATUS == 0 ) {
                $t_CURRENT_OH_OWNER = `$SSHELL -T $RHOST "ls -l $OHOME/bin/oracle 2>/dev/null >&1|awk '{print \\\$3}'"`;	chomp($t_CURRENT_OH_OWNER);
                $t_CURRENT_OH_GROUP = `$SSHELL -T $RHOST "groups $t_CURRENT_OH_OWNER|cut -d: -f2|awk '{print \\\$1}'|sed 's/ //g'"`; chomp($t_CURRENT_OH_GROUP);
                $t_HOME_DIR 	      = `$SSHELL -T $RHOST "cat /etc/passwd|grep -w "$t_CURRENT_OH_OWNER"|cut -d":" -f6"`;	chomp($t_HOME_DIR);

                $USER{CURRENT_OH_OWNER}   = $t_CURRENT_OH_OWNER;
                $USER{CURRENT_OH_GROUP}   = $t_CURRENT_OH_GROUP;
                $USER{HOME_DIR}	    = $t_HOME_DIR;
	    } else {
	        if ( -e $FILENAME ) {
                    $OH_OWNER_UID = ( stat "$FILENAME" )[4];

                    $USER{CURRENT_OH_OWNER}   = ( getpwuid $OH_OWNER_UID )[0];
                    $USER{CURRENT_OH_GROUP}   = ( getpwuid $OH_OWNER_UID )[3]; 
                    $USER{HOME_DIR}           = ( getpwuid $OH_OWNER_UID )[7]; 
	        } else {
    	            $USER{CURRENT_OH_OWNER}   = getpwuid($<);
    	            $USER{CURRENT_OH_GROUP}   = getpwuid($();
    	            $USER{HOME_DIR}   	      = ( getpwuid $> )[7];
	        }
	    }
    	} else {
    	    if ( -e $FILENAME ) {
    	        $OH_OWNER_UID = ( stat "$FILENAME" )[4];

    	        $USER{CURRENT_OH_OWNER}   = ( getpwuid $OH_OWNER_UID )[0];
    	        $USER{CURRENT_OH_GROUP}   = ( getpwuid $OH_OWNER_UID )[3]; 
    	        $USER{HOME_DIR}   	  = ( getpwuid $OH_OWNER_UID )[7]; 
    	    } else {
    	        $USER{CURRENT_OH_OWNER}   = getpwuid($<);
    	        $USER{CURRENT_OH_GROUP}   = getpwuid($();
    	        $USER{HOME_DIR}   	  = ( getpwuid $> )[7];
    	    }
    	}
    } else {
      $USER{CURRENT_OH_OWNER}   = getpwuid($<);
      $USER{CURRENT_OH_GROUP}   = getpwuid($();
      $USER{HOME_DIR}   	= ( getpwuid $> )[7];
    }

    return \%USER; 
}

sub no_of_cpus {
    my ($PROCESSORS)   = 2;
    if ( lc($OSNAME) eq 'linux' ) {
        $PROCESSORS =
          `$bash_scr -c "cat /proc/cpuinfo 2>/dev/null|grep -w 'processor'|wc -l|sed 's/ //g'"`;
    }
    elsif ( lc($OSNAME) eq 'solaris' ) {
        $PROCESSORS =
          `$bash_scr -c "psrinfo -v 2>/dev/null|grep 'Status of processor'|wc -l|sed 's/ //g'"`;
        if ( $PROCESSORS == 0 ) {
	    $PROCESSORS = `$bash_scr -c "/usr/bin/kstat -m cpu_info 2>/dev/null |egrep 'chip_id'|uniq|wc -l|sed 's/ //g'"`; 
	}
    }
    elsif ( lc($OSNAME) eq 'aix' ) {
        $PROCESSORS = `$bash_scr -c "lsdev -Cc processor 2>/dev/null|wc -l|sed 's/ //g'"`;
    }
    elsif ( lc($OSNAME) eq 'hp-ux' ) {
        $PROCESSORS =
          `$bash_scr -c "cat /var/adm/syslog/syslog.log 2>/dev/null|grep 'processor'|wc -l|sed 's/ //g'"`;
    }

    if ( $PROCESSORS !~ m/^\d+$/ ) { $PROCESSORS = 2; }
 
    return $PROCESSORS;
}

sub no_of_child_proc {
    my ($PROCESSORS)   = 2;
    my ($DEF_CHLD_CNT) = 1;

    $PROCESSORS=no_of_cpus();

    $DEF_CHLD_CNT = ceil( 25 / 100 * $PROCESSORS );

    set_run_log($RGLOG ,  "Number of Processors: $PROCESSORS");

    return $DEF_CHLD_CNT;
}

sub housekeeping {
    unlink glob( File::Spec->catfile( $OUTPUTDIR, "*_$CHECKID*.log" ) );
    unlink glob( File::Spec->catfile( $INPUTDIR , "*_$CHECKID*.log" ) );

    unlink glob( File::Spec->catfile( $OUTPUTDIR, "*_$CHECKID*.out" ) );
    unlink glob( File::Spec->catfile( $INPUTDIR , "*_$CHECKID*.out" ) );

    unlink glob( File::Spec->catfile( $OUTPUTDIR, "*_$CHECKID*.prt" ) );
    unlink glob( File::Spec->catfile( $INPUTDIR , "*_$CHECKID*.prt" ) );

    unlink glob( File::Spec->catfile( $INPUTDIR , "*_$CHECKID*.sql" ) );
    unlink glob( File::Spec->catfile( $INPUTDIR , "$CHECKID*.sql" ) );

    unlink glob( File::Spec->catfile( $INPUTDIR, "*$CHECKID*_stat.data" ) );

    unlink glob( File::Spec->catfile( $INPUTDIR, "tmp_env_file*$CHECKID*" ) );
    unlink glob( File::Spec->catfile( $RTEMPDIR, "tmp_env_file*$CHECKID*" ) );
    if ( $CHG_USER == 1) { unlink glob( File::Spec->catfile( $TMP_OUTPUT, "tmp_env_file*$CHECKID*" ) ); }
    
    if ( $KEEP_LCMD == 0 ) {
        unlink glob( File::Spec->catfile( $INPUTDIR, "localcmd*$CHECKID*" ) );
        unlink glob( File::Spec->catfile( $RTEMPDIR, "localcmd*$CHECKID*" ) );
        if ( $CHG_USER == 1) { unlink glob( File::Spec->catfile( $TMP_OUTPUT, "localcmd*$CHECKID*" ) ); }
    }
}

sub current_user {
    my ($USERNAME) = $ENV{LOGNAME} || $ENV{USER} || getpwuid($<);
    return $USERNAME;
}

sub set_run_log {
    my ($FH)	= shift;
    my ($STMT)	= shift;

    my ($TIMESTAMP) = strftime "%a %b %d %H:%M:%S %Y", localtime(time);

    print $FH "[ $TIMESTAMP ] $STMT\n";

}

sub get_current_epoch {
   my ($EPOCH_TIME) = 0;
 
   my ($T_EPOCH_TIME) = `date +%3N`; 
   chomp($T_EPOCH_TIME);

   $EPOCH_TIME = `date +%s`; 
   chomp($EPOCH_TIME);

   if ( length($T_EPOCH_TIME) > 3 ) {
       $EPOCH_TIME = $EPOCH_TIME . substr($T_EPOCH_TIME, -3);
   } else {
       $EPOCH_TIME=`date +%s%3N`;
       chomp($EPOCH_TIME);
   }

   if ( $EPOCH_TIME =~ m/%3N$/ || $EPOCH_TIME !~ m/^[0-9]*$/ ) {
	$EPOCH_TIME=`date +%s`;
	if ( $EPOCH_TIME =~ m/%s$/ ) {
           my $sysDateYear	=`date '+%Y'`;
           my $sysDateMonth	=`date '+%m'|sed 's/^0//'`;
           my $sysDateDay	=`date '+%d'|sed 's/^0//'`; 

           chomp($sysDateYear);
  	   chomp($sysDateMonth);
           chomp($sysDateDay);
	   $EPOCH_TIME = timelocal(00,00,00,"$sysDateDay",$sysDateMonth-1,$sysDateYear); 
	}
   }
   chomp($EPOCH_TIME);
   return $EPOCH_TIME
}

sub move_failed_to_skipped {
    my ($ICODE)   = shift;
    my ($IMSG)    = shift;
    my ($IDETAIL) = shift;
    my ($SKIPFIL) = shift;
    my ($STATFIL) = shift;
    my ($RSTYPE)  = shift;
    my ($ALVL)	  = shift;

    my ($CALL_GET_LOG_RESULT) = 0;
    my ($SKIP_THIS_VERSION)   = 0;

    my (%RET_HASH);

    my ($REASON_FAILED);
    if ( $ICODE > 100 ) {
        $REASON_FAILED = "was killed.";
    }
    else {
        $REASON_FAILED = "failed with exit code $ICODE.";
    }

    open( my $SKF, ">>", "$SKIPFIL" ) or die "Cannot open $SKIPFIL: $!";
    open( my $STATF, ">>", "$STATFIL" ) or die "Cannot open $STATFIL: $!";

    if ( $ICODE != 0 ) {
        $CALL_GET_LOG_RESULT = 0;
        $SKIP_THIS_VERSION   = 1;

        if ( !defined $IDETAIL ) {
            if ( !defined $IMSG ) {
                print $SKF "skipping $AU_CHK_NAME(checkid:-$CHECKID) because audit check execution $REASON_FAILED\n";
            }
            else {
                print $SKF "skipping $IMSG because audit check execution $REASON_FAILED\n";
            }
        }
        else {
            print $SKF "[$IDETAIL]skipping $AU_CHK_NAME(checkid:-$CHECKID) because audit check execution $REASON_FAILED\n";
        }
    }
    #print $STATF "$RSTYPE:$CHECKID:$IDETAIL:$ICODE\n";
    if (defined $ALVL) {
        print $STATF "$CHECKID:$IDETAIL:$ICODE:$ALVL\n";
    }
    else {
        print $STATF "$CHECKID:$IDETAIL:$ICODE\n";
    }

    close($STATF);
    close($SKF);

    $RET_HASH{SKIP_THIS_VERSION}   = $SKIP_THIS_VERSION;
    $RET_HASH{CALL_GET_LOG_RESULT} = $CALL_GET_LOG_RESULT;

    return \%RET_HASH;
}

sub merge {
    my ($MFILE)		= shift;
    my ($PATTERN) 	= shift; 
    my ($DIR)		= shift;

    set_run_log($RGLOG , "Below Files merged into '$MFILE':");

    open( my $GFH, ">>", "$MFILE" ) or die "Cannot open $MFILE: $!";
    foreach
      my $file ( glob( File::Spec->catfile( $DIR, "$PATTERN" ) ) )
    {
	if ( $PATTERN eq "*.log" ) {
	    next 
	    if ( $file =~ m/_error\.log/
	      or $file =~ m/_exc\.log/
	      or $file =~ m/_skipped_checks\.log/
	      or $file =~ m/_env\.out/);
     	}
	elsif ( $PATTERN eq "*.out" ) {
	    next 
	    if ( $file =~ m/_exc\.out/
	      or $file =~ m/_timings\.out/
	      or $file =~ m/_report\.out/);
	}
	
        next if ( $file !~ m/$CHECKID/ );

	set_run_log($RGLOG , $file);

        open( my $FH, "<", "$file" ) or die "Cannot open $file: $!";
        while (<$FH>) {
            if ( $MERGE == 1 ) { print $GFH $_; }
	    if ( $PATTERN =~ m/\.prt$/ ) { print $_; } 
        }
        close($FH);
    }
    close($GFH);
    if ( $MERGE == 0 ) { unlink($MFILE); }
}

sub store_localcmd {
    my ($FILE1) = shift;
    my ($FILE2) = shift;
    my ($NLOCALCMD) = File::Spec->catfile( $OUTPUTDIR, basename($FILE2) );

    open ( my $NLCMD, ">>", $NLOCALCMD ) or die "Cannot open $NLOCALCMD: $!"; 
 
    open ( my $F1, "<", $FILE1 ) or die "Cannot open $FILE1: $!";   
    while(<$F1>) {
	print $NLCMD $_;
    }
    close($F1);
 
    print $NLCMD "\n"; 

    open ( my $F2, "<", $FILE2 ) or die "Cannot open $FILE2: $!";   
    while(<$F2>) {
	print $NLCMD $_;
    }
    close($F2);

    close($NLCMD);
}

sub update_ld_lib_path {
    my ($LD_LIBRARY_PATH)	= shift;
    my ($REPLACE_HOME)		= shift;
    my ($TMP_ENVFIL)		= shift;

    open( my $TOEF, ">>", "$TMP_ENVFIL" ) or die "Cannot open $TMP_ENVFIL: $!";
    print $TOEF "if [[ \"\${LD_LIBRARY_PATH:-unset}\"  = \"unset\" ]] ; then LD_LIBRARY_PATH=\"\"; fi\n";
    if ( $LD_LIBRARY_PATH !~ m/^${REPLACE_HOME}\/lib:/ ) {
        print $TOEF "LD_LIBRARY_PATH=$REPLACE_HOME/lib:$LD_LIBRARY_PATH\n";
        print $TOEF "export LD_LIBRARY_PATH=$REPLACE_HOME/lib:$LD_LIBRARY_PATH\n";
    } else {
        print $TOEF "LD_LIBRARY_PATH=$LD_LIBRARY_PATH\n";
        print $TOEF "export LD_LIBRARY_PATH=$LD_LIBRARY_PATH\n";
    }
    close($TOEF);
}

sub copy_env_files_to_tmp {
    my ($TMP_ENVFIL)  		= shift;
    my ($RUNNING_HOST)     	= shift;

    my ($b_ENVFIL) = basename $ENVFIL;

    my ($OLD_RTEMPDIR) 		= $RTEMPDIR;
    if ( $CHG_USER == 1 ) {   $RTEMPDIR=$TMP_OUTPUT; }

    my ($TRGTORCLENV) 		= basename $TMP_ENVFIL; $TRGTORCLENV = File::Spec->catfile( $RTEMPDIR, $TRGTORCLENV );
 
    if ( $CHG_USER == 1) { if ( "$TMP_ENVFIL" ne "$TRGTORCLENV" ) { `rm -f $TRGTORCLENV`; } }

    if ( $MODE == 0 ) {
        if ( $RUNNING_HOST eq $LOCALNODE ) {
            if ( !-e $TRGTORCLENV ) { copy( $TMP_ENVFIL, $TRGTORCLENV ); }
            if ( !-e File::Spec->catfile( $RTEMPDIR, $b_ENVFIL ) ) { copy( $ENVFIL, File::Spec->catfile( $RTEMPDIR, $b_ENVFIL ) ); }
        }
        else {
            my ($remote_trgtenvfile) = `$SSHELL $RUNNING_HOST  "ls -l $TRGTORCLENV 2>/dev/null|wc -l"`;
            if ( $remote_trgtenvfile <= 0 ) {
                my $shell_out = <<SHELL;
                    $SCOPY $TMP_ENVFIL $RUNNING_HOST:$RTEMPDIR >/dev/null 2>&1;
SHELL
		`$shell_out`;
            }

            my ($t_ENVFIL) = File::Spec->catfile( $RTEMPDIR, $b_ENVFIL );
            $remote_trgtenvfile = `$SSHELL $RUNNING_HOST  "ls -l $t_ENVFIL 2>/dev/null|wc -l"`;
            if ( $remote_trgtenvfile <= 0 ) {
                my $shell_out = <<SHELL;
                    $SCOPY $ENVFIL $RUNNING_HOST:$RTEMPDIR >/dev/null;
SHELL
		`$shell_out`;
            }
        }
    }

    if ( $CHG_USER == 1 ) { $RTEMPDIR=$OLD_RTEMPDIR; } 
}

sub set_alvl {
    my $RCODE =  shift;
    my $ALVL;
    my $RETURNCODE = $RCODE;
    my %RET_HASH;

    if ( $RCODE == 10 ) {
  	$ALVL =  "INFO";
	$RETURNCODE = 0;
    } 
    elsif ( $RCODE == 11 ) {
  	$ALVL =  "WARN";
	$RETURNCODE = 0;
    } 
    elsif ( $RCODE == 12 ) {
  	$ALVL =  "ERROR";
	$RETURNCODE = 0;
    } 
    elsif ( $RCODE == 13 ) {
  	$ALVL =  "FAIL";
	$RETURNCODE = 0;
    }

    $RET_HASH{ALVL} = $ALVL;
    $RET_HASH{RCODE} = $RETURNCODE;

    return \%RET_HASH;
}

sub usage {
    print
	"Usage: $0 
	   -c CHECK METAFILE 
	   -d DBFILE 
	   -g STATFILE
	   -o OUTPUTDIR 
	   -w OUTPUTDIR_NEW 
	   -i INPUTDIR 
	   -t RTEMPDIR 
	   -e ERRFIL
	   -p ENVFILE
	   -u LIMIT					   
	   -m (MERGE(1) or SEPARATE(0)) 
	   -v CHECK_TIMINGS
           -f CHK_TIMINGS    
	   -a ORCLENVFIL
	   -s (OFFLINE(1) or ONLINE(0) 
	   -n LOCALNODE 
	   -r rHOST
	   -b HOUSEKEEPING(1) or (0)
	   -k KEEP localcmd.sh (1) or (0)
           -z SKIPPED_CHECKS
	   -j TMP OUTPUT DIR (for root run)
	   -k APP TYPE
	   -h HELP
	\n\n";
    exit;
}

#Main Script--------------
if ( @ARGV == 0 ) {
    usage();
}

GetOptions(
    "c=s" => \$CHKMETAFILE,
    "d=s" => \$DBFILE,
    "g=s" => \$STATFIL,
    "o=s" => \$OUTPUTDIR,
    "w=s" => \$OUTPUTDIR_NEW,
    "i=s" => \$INPUTDIR,
    "t=s" => \$RTEMPDIR,
    "e=s" => \$ERRFIL,
    "p=s" => \$ENVFIL,
    "u=n" => \$LIMIT,
    "m=n" => \$MERGE,
    "v=s" => \$CHECK_TIMINGS,
    "f=s" => \$CHK_TIMINGS,
    "a=s" => \$ORCLENVFIL,
    "s=n" => \$MODE,
    "n=s" => \$LOCALNODE,
    "r=s" => \$rHOST,
    "b=n" => \$HOUSEKEEPING,
    "k=n" => \$KEEP_LCMD,
    "z=s" => \$SKIPFIL,
    "j=s" => \$TMP_OUTPUT,
    "k=s" => \$APPTYPE,
    "h"	  => \$SHOW_HELP,
) or usage();

if (defined $OUTPUTDIR) {
    $RUNLOG	= File::Spec->catfile( $OUTPUTDIR, $BASENAME . '_' . $LOCALNODE . '_run' . '.log' );
}
my ($STFIL)    	= File::Spec->catfile( $RTEMPDIR, $BASENAME . '_sql_collect.prt' );

open( $RGLOG, ">>", "$RUNLOG" ) or die "Cannot open $RUNLOG: $!";

$LIMIT = no_of_child_proc() if ( $LIMIT == 0 || ! defined $LIMIT );

my ($PROCESSORS) = no_of_cpus();
if ( $LIMIT > $PROCESSORS ) {
    $LIMIT = $PROCESSORS
}

set_run_log($RGLOG ,  "Processes Generated : $LIMIT");

if ( $SHOW_HELP == 1 ) {
    usage();
    exit;
}

my ($CUR_USERN) = current_user();
my ($CUR_USERI) = $<;

set_run_log($RGLOG , "User: $CUR_USERN\n");

if ( $CUR_USERN eq 'root' or $CUR_USERI == 0 ) {
    my ($ROOT_RUN) = $ENV{RAT_ROOT_RUN};
    if ( $ROOT_RUN == 1 ) { $CHG_USER = 1; }
}

if ( defined $CHKMETAFILE ) {
    set_run_log($RGLOG , "CHECK META FILE CONTENT:");	
 
    open( my $FH, "<", "$CHKMETAFILE" ) or die "Cannot open $CHKMETAFILE: $!";
    while ( my $line = <$FH> ) {
        next if ( $line =~ m/^\s*#/ );
        my ($rawline) = $line;
        chomp($line);

	set_run_log($RGLOG , $line);

        if ( $line =~ m/^CHECKID=/ ) {
            $line =~ s/^CHECKID=//g;
            $CHECKID = $line;
        }
        elsif ( $line =~ m/^COMTYPE=/ ) {
            $line =~ s/^COMTYPE=//g;
            $COMTYPE = $line;
        }
        elsif ( $line =~ m/^COM_REPORT_START=/ ) {
            $rawline =~ s/^COM_REPORT_START=//g;
            $COM_REPORT = $rawline;
	    while (my $line = <$FH> ) {
		if ( $line =~ m/^\s*COM_REPORT_END\s*$/ ){
		    last;
		}	
		$COM_REPORT .= $line;
	    }
	    chomp($COM_REPORT);
        }
        elsif ( $line =~ m/^COM_START=/ ) {
            $rawline =~ s/^COM_START=//g;
            $COMMAND = $rawline;
	    while (my $line = <$FH> ) {
		if ( $line =~ m/^\s*COM_END\s*$/ ){
		    last;
		}	
		$COMMAND .= $line;
	    }
	    chomp($COMMAND);
        }
        elsif ( $line =~ m/^AUDIT_CHECK_NAME=/ ) {
            $line =~ s/^AUDIT_CHECK_NAME=//g;
            $AU_CHK_NAME = $line;
        }
        elsif ( $line =~ m/^RAT_RUNMODE_INTERNAL=/ ) {
            $line =~ s/^RAT_RUNMODE_INTERNAL=//g;
            $RAT_RUNMODE_INTERNAL = $line;
        }
        elsif ( $line =~ m/^NEEDS_RUNNING=/ ) {
            $line =~ s/^NEEDS_RUNNING=//g;
            $NEEDS_RUNNING = $line;
        }
        elsif ( $line =~ m/^COLLECTION_NAME=/ ) {
            $line =~ s/^COLLECTION_NAME=//g;
            $COLLECTION_NAME = $line;
        }
        elsif ( $line =~ m/^OUTFILNAM=/ ) {
            $line =~ s/^OUTFILNAM=//g;
            $OUTFILNAM = $line;
        }
        elsif ( $line =~ m/^STACK_ASM_SID=/ ) {
            $line =~ s/^STACK_ASM_SID=//g;
            $STACK_ASM_SID = $line;
        }
        elsif ( $line =~ m/^STACK_ASM_HOME=/ ) {
            $line =~ s/^STACK_ASM_HOME=//g;
            $STACK_ASM_HOME = $line;
        }
        elsif ( $line =~ m/^PARAM_PATH=/ ) {
            $line =~ s/^PARAM_PATH=//g;
            $PARAM_PATH = $line;
        }
        elsif ( $line =~ m/^ROW=/ ) {
            $line =~ s/^ROW=//g;
            $ROW = $line;
        }
    }
}

my ($CHILDREN) = 0;

open( my $FH, "<", "$DBFILE" ) or die "Cannot open $DBFILE: $!";
while (<$FH>) {

    #Format: DBNAME,ORACLE_SID,ORACLE_HOME,DBROLE,DBROLEMCNT,DBTYPE,DBTYPEMCNT,DBUSR,DBPWD,PDB_USER,SYSPWD,CONSTR,CHKSYSDBA,RUNNING_HOST
    if ( $CHILDREN == $LIMIT ) {
        $PID = wait();
        $CHILDREN--;
    }

    next if ( $_ =~ /^\s*$/ || $_ =~ /^\s*#/ );
    my (
        $DBNAME, $ORACLE_SID, $ORACLE_HOME, $DBROLE, $DBROLEMCNT,
        $DBTYPE, $DBTYPEMCNT, $DBUSR,       $DBPWD,  $PDB_USER,
        $SYSPWD, $CONSTR,     $CHKSYSDBA,   $RUNNING_HOST, $DBAPPUSR
    ) = split( ",", $_ );
    chomp($DBAPPUSR);
    chomp($RUNNING_HOST);
    
    my ($t_RUNLOG) = File::Spec->catfile( $INPUTDIR, $RUNNING_HOST . '_-' .  $CHECKID . '_-' . $DBNAME . '_-' . 'run.log' );
    open( my $RLOG, ">>", "$t_RUNLOG" )
    	or die "Cannot open $t_RUNLOG: $!";

    set_run_log($RLOG , "[RUNNING_HOST: $RUNNING_HOST] [DBNAME: $DBNAME] [ORACLE_SID: $ORACLE_SID] [ORACLE_HOME: $ORACLE_HOME]");

    $ENV{ORACLE_HOME} = "$ORACLE_HOME";
    $ENV{ORACLE_SID}  = "$ORACLE_SID";

    my ($SQLPLUS) = File::Spec->catfile( $ENV{ORACLE_HOME}, 'bin', 'sqlplus' ); 

    $PID = fork();
    if ($PID) {
        $CHILDREN++;
        push @PIDS, $PID;
    }
    elsif ( $PID == 0 ) {
        my ($dbConnectString);
        if ( $DBTYPE eq "PDB" ) {
            $dbConnectString = "$PDB_USER/$SYSPWD\@$SYSPWD as sysdba";
        }
        else {
            $dbConnectString = "$DBUSR/$DBPWD as sysdba";
        }
	
	if ( defined $DEBUG && $DEBUG == 1 ) {
	    $DEBUG_FLG="set -x";
	}

        my ($FILENAME);
        my ($OH_OWNER_UID);
	my ($RETURNCODE);

        my ($USER_HASH);
	my ($CURRENT_OH_OWNER, $CURRENT_OH_GROUP,$HOME_DIR);

	my ($MVS_HASH);
  	my ($ALVL_HASH);

	my ($t_SKIPFIL,$t_CHK_TIMINGS,$t_STATFIL);
	my ($PROCESS_IDIR,$PROCESS_ODIR,$PROCESS_RDIR);
	if ( $CHG_USER == 0 ) {
	    $PROCESS_IDIR 	= $INPUTDIR;
 	    $PROCESS_ODIR 	= $OUTPUTDIR;	  
	    $PROCESS_RDIR 	= $RTEMPDIR;
	}
	else {
 	    $PROCESS_IDIR 	= $TMP_OUTPUT;	  
 	    $PROCESS_ODIR 	= $TMP_OUTPUT;	  
	    $PROCESS_RDIR 	= $TMP_OUTPUT;
	}
	($t_SKIPFIL)		= File::Spec->catfile( $PROCESS_IDIR, $RUNNING_HOST . '_-' . $CHECKID . '_-' . $DBNAME . '_-'.'skipped_checks.log' );
	($t_CHK_TIMINGS) 	= File::Spec->catfile( $PROCESS_IDIR, $RUNNING_HOST . '_-' . $CHECKID . '_-' . $DBNAME . '_-'.'epoch_timings.out' );
	($t_STATFIL)		= File::Spec->catfile( $PROCESS_IDIR, $RUNNING_HOST . '_-' . $CHECKID . '_-' . $DBNAME . '_-'.'stat.data' );

        open( my $CHKT, ">", "$t_CHK_TIMINGS" ) or die "Cannot open $t_CHK_TIMINGS: $!";
        my ($EPOCH_TIME) = 0;

        if ( $COMTYPE eq 'GENERIC' ) {
            my ($INFIL)         = File::Spec->catfile( $PROCESS_IDIR, $CHECKID . '_-' . $DBNAME . '.sql' );
            my ($OUTFIL)        = File::Spec->catfile( $PROCESS_ODIR, $CHECKID . '_-' . $DBNAME . '.out' );

            open( my $INH, ">", "$INFIL" ) or die "Cannot open $INFIL: $!";
            print $INH "$COMMAND\n";
            close($INH);

            if ( $RUNNING_HOST eq $LOCALNODE ) {
                my $shell_out = <<SHELL;
                                $SQLPLUS -s "$dbConnectString" >/dev/null 2>&1 <<EOF
                                set head off
                                set lines 80
                                set feedback off
                                set serveroutput on
                                spool $OUTFIL;
                                \@\@$INFIL;
                                spool off
                                exit
EOF
SHELL
		$EPOCH_TIME = get_current_epoch();
	        print $CHKT "[CHECK:$CHECKID][HOST: $RUNNING_HOST][TAG1: $DBNAME] Execution Start Time: $EPOCH_TIME\n";

                if ( $CHG_USER == 0 ) {
                    `$shell_out`;
                    $RETURNCODE = `echo $?`;
                }
                else {
		    $USER_HASH = get_dbOwner($ORACLE_HOME,$RUNNING_HOST);
		    ($CURRENT_OH_OWNER,$CURRENT_OH_GROUP,$HOME_DIR) = ($USER_HASH->{CURRENT_OH_OWNER}, $USER_HASH->{CURRENT_OH_GROUP}, $USER_HASH->{HOME_DIR});

		    `chown $CURRENT_OH_OWNER:$CURRENT_OH_GROUP $INFIL`;
                    if ( -e $HOME_DIR) { `cd $HOME_DIR`; }
		    `su $CURRENT_OH_OWNER -c "$shell_out"`;
		    $RETURNCODE = `echo $?`;

		    if ( "$OUTFIL" ne "$OUTPUTDIR" ) { `cp $OUTFIL $OUTPUTDIR`; }
                }

		$EPOCH_TIME = get_current_epoch();
	        print $CHKT "[CHECK:$CHECKID][HOST: $RUNNING_HOST][TAG1: $DBNAME] Execution End Time: $EPOCH_TIME\n";
            }
            else {
                my ($SQLTORUN)      = File::Spec->catfile( $PROCESS_RDIR, 'sqltorun_' . $CHECKID . '_-' . $DBNAME . '_-' . $RUNNING_HOST . '.sql' );
                my ($SPOOLFILE)     = File::Spec->catfile( $PROCESS_RDIR, 'sqltorun_' . $CHECKID . '_-' . $DBNAME . '_-' . $RUNNING_HOST . '.out' );

		$EPOCH_TIME = get_current_epoch();
		print $CHKT "[CHECK:$CHECKID][HOST: $RUNNING_HOST][TAG1: $DBNAME] Execution Start Time: $EPOCH_TIME\n";

		my $shell_out;
		if ( $CHG_USER == 0 ) {
                    $shell_out = <<SHELL;
                                $SCOPY $INFIL $RUNNING_HOST:$SQLTORUN
                                $SSHELL $RUNNING_HOST bash <<EOF2
                                export ORACLE_HOME=$ORACLE_HOME;
                                export ORACLE_SID=$ORACLE_SID;
                                $SQLPLUS -s "$dbConnectString" >/dev/null 2>&1 <<EOF
                                set head off
                                set lines 80
                                set feedback off
                                set serveroutput on
                                spool $SPOOLFILE;
                                \@\@$SQLTORUN;
                                spool off
                                exit
EOF
EOF2
SHELL
		    `$shell_out`;
                    $RETURNCODE = `echo $?`;
		}
		else {
		    $USER_HASH = get_dbOwner($ORACLE_HOME,$RUNNING_HOST);
		    ($CURRENT_OH_OWNER,$CURRENT_OH_GROUP,$HOME_DIR) = ($USER_HASH->{CURRENT_OH_OWNER}, $USER_HASH->{CURRENT_OH_GROUP}, $USER_HASH->{HOME_DIR});

                    $shell_out = <<SHELL;
                                $SCOPY $INFIL $RUNNING_HOST:$SQLTORUN
				$SSHELL $RUNNING_HOST "chown $CURRENT_OH_OWNER:$CURRENT_OH_GROUP $SQLTORUN"
                                $SSHELL $RUNNING_HOST bash <<EOF2
				if [[ -e $HOME_DIR ]]; then cd $HOME_DIR; fi;
                                export ORACLE_HOME=$ORACLE_HOME;
                                export ORACLE_SID=$ORACLE_SID;
                                su $CURRENT_OH_OWNER -c "$SQLPLUS -s \"$dbConnectString\" >/dev/null 2>&1 <<EOF
                                set head off
                                set lines 80
                                set feedback off
                                set serveroutput on
                                spool $SPOOLFILE;
                                \@\@$SQLTORUN;
                                spool off
                                exit
EOF
"
EOF2
SHELL
		    `$shell_out`; 
                    $RETURNCODE = `echo $?`;
		}

		$EPOCH_TIME = get_current_epoch();
		print $CHKT "[CHECK:$CHECKID][HOST: $RUNNING_HOST][TAG1: $DBNAME] Execution End Time: $EPOCH_TIME\n";

                $shell_out = <<SHELL;
                        $SCOPY $RUNNING_HOST:$SPOOLFILE $RTEMPDIR >/dev/null 2>&1
			$SSHELL $RUNNING_HOST "rm -rf $SPOOLFILE  >/dev/null 2>&1"
SHELL
		`$shell_out`;
            }
            $MVS_HASH = move_failed_to_skipped( $RETURNCODE, "", "$RUNNING_HOST:$DBNAME", $t_SKIPFIL, $t_STATFIL, "Execute" );
        }
        elsif ( $COMTYPE eq 'SQL' ) {
            if ( $DBROLEMCNT >= 1 && $DBTYPEMCNT >= 1 ) {
                my ($DBACTUAL)	= File::Spec->catfile( $PROCESS_ODIR, 'd_actual' . '_-' .  $CHECKID . '_-' . $DBNAME . '.out' );
		
		if ( $MODE == 0 && $rHOST eq $LOCALNODE && $RAT_RUNMODE_INTERNAL eq 'master' ) {
                    my ($INFIL) 	= File::Spec->catfile( $INPUTDIR, $CHECKID . '_-' . $DBNAME . '.sql' );
                    my ($OUTFIL) 	= File::Spec->catfile( $OUTPUTDIR, 'd_check' . '_-' . $CHECKID . '_-' . $DBNAME . '.out' );

                    open( my $INH, ">", "$INFIL" ) or die "Cannot open $INFIL: $!";
                    if ( $DBTYPE eq "PDB" ) {
                        print $INH "alter session set container=$DBNAME;\n";
                    }
		    $RAT_DB_APP_USER = $DBAPPUSR;
		    #$COMMAND=`echo $COMMAND | sed "s/#APP_USER#/$RAT_DB_APP_USER/g"`;

                    print $INH "$COMMAND\n";
                    close($INH);

                    if ( defined $CHKSYSDBA && $CHKSYSDBA =~ m/\d+/ && $CHKSYSDBA == 0 ) {
                        if ( $RUNNING_HOST eq $LOCALNODE ) {
			    $EPOCH_TIME = get_current_epoch();
			    print $CHKT "[CHECK:$CHECKID][HOST: $RUNNING_HOST][TAG1: $DBNAME] Execution Start Time: $EPOCH_TIME\n";

			    my $shell_out;
			    if ( $CHG_USER == 0 ) {
				#$RAT_DB_APP_USER = $DBAPPUSR;

				`sed -i 's/#APP_USER#/$RAT_DB_APP_USER/g' $INFIL`;

                                $shell_out = <<SHELL;
                                            $SQLPLUS -s "$dbConnectString" >/dev/null 2>&1 <<EOF
                                            set head off
                                            set lines 80
                                            set feedback off
                                            set serveroutput on
                                            spool $OUTFIL;
                                            \@\@$INFIL;
                                            spool off
                                            exit
EOF
SHELL
			        `$shell_out`;
		    	        $RETURNCODE = `echo $?`;
			    }
			    else {	
                                my ($NEW_INFIL)         = File::Spec->catfile( $PROCESS_IDIR, $CHECKID . '_-' . $DBNAME . '.sql' );
                                my ($NEW_OUTFIL)        = File::Spec->catfile( $PROCESS_ODIR, 'd_check' . '_-' . $CHECKID . '_-' . $DBNAME . '.out' );

                                $USER_HASH = get_dbOwner($ORACLE_HOME,$RUNNING_HOST);
                                ($CURRENT_OH_OWNER,$CURRENT_OH_GROUP,$HOME_DIR) = ($USER_HASH->{CURRENT_OH_OWNER}, $USER_HASH->{CURRENT_OH_GROUP}, $USER_HASH->{HOME_DIR});

                                if ( $INFIL ne $NEW_INFIL ) { copy ( $INFIL , $NEW_INFIL); }
                                `chown $CURRENT_OH_OWNER:$CURRENT_OH_GROUP $NEW_INFIL`;
					
	                        #$RAT_DB_APP_USER =  $DBAPPUSR;


                                `sed -i 's/#APP_USER#/$RAT_DB_APP_USER/g' $NEW_INFIL`;

                                $shell_out = <<SHELL;
                                            su $CURRENT_OH_OWNER -c "$SQLPLUS -s \"$dbConnectString\" >/dev/null 2>&1 <<EOF
                                            set head off
                                            set lines 80
                                            set feedback off
                                            set serveroutput on
                                            spool $NEW_OUTFIL;
                                            \@\@$NEW_INFIL;
                                            spool off
                                            exit
EOF
"
SHELL
			        `$shell_out`;
		    	        $RETURNCODE = `echo $?`;

                                $shell_out = <<SHELL;
                                        rm -f $NEW_INFIL;
                                        if [ "$NEW_OUTFIL" != "$OUTFIL" ]; then cp $NEW_OUTFIL $OUTFIL; fi;
SHELL
                                `$shell_out`;
			    }

			    $EPOCH_TIME = get_current_epoch();
			    print $CHKT "[CHECK:$CHECKID][HOST: $RUNNING_HOST][TAG1: $DBNAME] Execution End Time: $EPOCH_TIME\n";
                        }
                        else {
                            my ($SQLTORUN) 	= File::Spec->catfile( $RTEMPDIR, 'sqltorun_' . $CHECKID . '_-' . $DBNAME . '_-' . $RUNNING_HOST . '.sql' );
                            my ($SPOOLFILE)	= File::Spec->catfile( $RTEMPDIR, 'sqltorun_' . $CHECKID . '_-' . $DBNAME . '_-' . $RUNNING_HOST . '.out' );
			    my ($SQLTORUNAPP)      = File::Spec->catfile( $RTEMPDIR, 'd_app_user' . '_-' . $DBNAME .'.sql' );
                            my ($SPOOLFILEAPP)     = File::Spec->catfile( $RTEMPDIR, 'd_app_user' . '_-' . $DBNAME .'.out' );

			    $EPOCH_TIME = get_current_epoch();
			    print $CHKT "[CHECK:$CHECKID][HOST: $RUNNING_HOST][TAG1: $DBNAME] Execution Start Time: $EPOCH_TIME\n";

			    my $shell_out;
			    if ( $CHG_USER == 0 ) {
				#$RAT_DB_APP_USER =  $DBAPPUSR;


                                `sed -i 's/#APP_USER#/$RAT_DB_APP_USER/g' $INFIL`;

                                $shell_out = <<SHELL;
                                            $SCOPY $INFIL $RUNNING_HOST:$SQLTORUN
                                            $SSHELL $RUNNING_HOST bash <<EOF2
                                            export ORACLE_HOME=$ORACLE_HOME;
                                            export ORACLE_SID=$ORACLE_SID;
                                            $SQLPLUS -s "$dbConnectString" >/dev/null 2>&1 <<EOF
                                            set head off
                                            set lines 80
                                            set feedback off
                                            set serveroutput on
                                            spool $SPOOLFILE;
                                            \@\@$SQLTORUN;
                                            spool off
                                            exit
EOF
EOF2
SHELL
			        `$shell_out`;
		    	        $RETURNCODE = `echo $?`;
			    } 
			    else {
                                my ($NEW_INFIL)         = File::Spec->catfile( $PROCESS_IDIR, $CHECKID . '_-' . $DBNAME . '.sql' );
                                my ($NEW_OUTFIL)        = File::Spec->catfile( $PROCESS_ODIR, 'd_check' . '_-' . $CHECKID . '_-' . $DBNAME . '.out' );

                                $USER_HASH = get_dbOwner($ORACLE_HOME,$RUNNING_HOST);
                                ($CURRENT_OH_OWNER,$CURRENT_OH_GROUP,$HOME_DIR) = ($USER_HASH->{CURRENT_OH_OWNER}, $USER_HASH->{CURRENT_OH_GROUP}, $USER_HASH->{HOME_DIR});

                                if ( "$INFIL" ne "$NEW_INFIL" ) { copy ( $INFIL , $NEW_INFIL); }
				#$RAT_DB_APP_USER =  $DBAPPUSR;
                                

                                `sed -i 's/#APP_USER#/$RAT_DB_APP_USER/g' $NEW_INFIL`;
				
                                $shell_out = <<SHELL;
                                            $SCOPY $NEW_INFIL $RUNNING_HOST:$SQLTORUN
                                            $SSHELL $RUNNING_HOST "chown $CURRENT_OH_OWNER:$CURRENT_OH_GROUP $SQLTORUN"
                                            $SSHELL $RUNNING_HOST bash <<EOF2
                                            if [[ -e $HOME_DIR ]]; then cd $HOME_DIR; fi;
                                            export ORACLE_HOME=$ORACLE_HOME;
                                            export ORACLE_SID=$ORACLE_SID;
                                            su $CURRENT_OH_OWNER -c "$SQLPLUS -s \"$dbConnectString\" as sysdba >/dev/null 2>&1 <<EOF
                                            set head off
                                            set lines 80
                                            set feedback off
                                            set serveroutput on
                                            spool $SPOOLFILE;
                                            \@\@$SQLTORUN;
                                            spool off
                                            exit
EOF
"
EOF2
SHELL
                                `$shell_out`;
                                $RETURNCODE = `echo $?`;
			    }

			    $EPOCH_TIME = get_current_epoch();
			    print $CHKT "[CHECK:$CHECKID][HOST: $RUNNING_HOST][TAG1: $DBNAME] Execution End Time: $EPOCH_TIME\n";

                            $shell_out = <<SHELL;
		    		    $SCOPY $RUNNING_HOST:$SPOOLFILE $RTEMPDIR >/dev/null 2>&1
				    $SSHELL $RUNNING_HOST "rm -rf $SPOOLFILE  >/dev/null 2>&1"
SHELL
			    `$shell_out`;
                        }
                    }
                    else {
                        if ( $RUNNING_HOST eq $LOCALNODE ) {
			    $EPOCH_TIME = get_current_epoch();
			    print $CHKT "[CHECK:$CHECKID][HOST: $RUNNING_HOST][TAG1: $DBNAME] Execution Start Time: $EPOCH_TIME\n";

			    my $shell_out;
			    if ( $CHG_USER == 0 ) {
                                #$RAT_DB_APP_USER =  $DBAPPUSR;


                                `sed -i 's/#APP_USER#/$RAT_DB_APP_USER/g' $INFIL`;

                                $shell_out = <<SHELL;
                                            $SQLPLUS -s / as sysdba >/dev/null 2>&1 <<EOF
                                            set head off
                                            set lines 80
                                            set feedback off
                                            set serveroutput on
                                            spool $OUTFIL;
                                            \@\@$INFIL;
                                            spool off
                                            exit
EOF
SHELL
				`$shell_out`;
		    	    	$RETURNCODE = `echo $?`;
			    }
			    else {
                    		my ($NEW_INFIL) 	= File::Spec->catfile( $PROCESS_IDIR, $CHECKID . '_-' . $DBNAME . '.sql' );
                    		my ($NEW_OUTFIL) 	= File::Spec->catfile( $PROCESS_ODIR, 'd_check' . '_-' . $CHECKID . '_-' . $DBNAME . '.out' );

		    		$USER_HASH = get_dbOwner($ORACLE_HOME,$RUNNING_HOST);
		    		($CURRENT_OH_OWNER,$CURRENT_OH_GROUP,$HOME_DIR) = ($USER_HASH->{CURRENT_OH_OWNER}, $USER_HASH->{CURRENT_OH_GROUP}, $USER_HASH->{HOME_DIR});

				if ( $INFIL ne $NEW_INFIL ) { copy ( $INFIL , $NEW_INFIL); }
				`chown $CURRENT_OH_OWNER:$CURRENT_OH_GROUP $NEW_INFIL`;
				#$RAT_DB_APP_USER =  $DBAPPUSR;


                                `sed -i 's/#APP_USER#/$RAT_DB_APP_USER/g' $NEW_INFIL`;

                                $shell_out = <<SHELL;
					    if [[ -e $HOME_DIR ]]; then cd $HOME_DIR; fi;
                                            su $CURRENT_OH_OWNER -c "$SQLPLUS -s / as sysdba >/dev/null 2>&1 <<EOF
                                            set head off
                                            set lines 80
                                            set feedback off
                                            set serveroutput on
                                            spool $NEW_OUTFIL;
                                            \@\@$NEW_INFIL;
                                            spool off
                                            exit
EOF
"
SHELL
			    	`$shell_out`;
		    	    	$RETURNCODE = `echo $?`;
	
				$shell_out = <<SHELL;
					rm -f $NEW_INFIL; 
					if [ "$NEW_OUTFIL" != "$OUTFIL" ]; then cp $NEW_OUTFIL $OUTFIL; fi; 
SHELL
			    	`$shell_out`;
			    }

	   		    $EPOCH_TIME = get_current_epoch();
			    print $CHKT "[CHECK:$CHECKID][HOST: $RUNNING_HOST][TAG1: $DBNAME] Execution End Time: $EPOCH_TIME\n";
                        }
                        else {
                            my ($SQLTORUN)	= File::Spec->catfile( $PROCESS_RDIR, 'sqltorun_' . $CHECKID . '_-' . $DBNAME . '_-' . $RUNNING_HOST . '.sql' );
                            my ($SPOOLFILE) 	= File::Spec->catfile( $PROCESS_RDIR, 'sqltorun_' . $CHECKID . '_-' . $DBNAME . '_-' . $RUNNING_HOST . '.out' );
			    my ($SQLTORUNAPP)      = File::Spec->catfile( $PROCESS_RDIR, 'd_app_user' . '_-' . $DBNAME .'.sql' );
                            my ($SPOOLFILEAPP)     = File::Spec->catfile( $PROCESS_RDIR, 'd_app_user' . '_-' . $DBNAME .'.out' );

			    $EPOCH_TIME = get_current_epoch();
			    print $CHKT "[CHECK:$CHECKID][HOST: $RUNNING_HOST][TAG1: $DBNAME] Execution Start Time: $EPOCH_TIME\n";

			    my $shell_out;
			    if ( $CHG_USER == 0 ) {
				#$RAT_DB_APP_USER =  $DBAPPUSR;


                               `sed -i 's/#APP_USER#/$RAT_DB_APP_USER/g' $INFIL`;

                                $shell_out = <<SHELL;
                                            $SCOPY $INFIL $RUNNING_HOST:$SQLTORUN
                                            $SSHELL $RUNNING_HOST bash <<EOF2
                                            export ORACLE_HOME=$ORACLE_HOME;
                                            export ORACLE_SID=$ORACLE_SID;
                                            $SQLPLUS -s / as sysdba >/dev/null 2>&1 <<EOF
                                            set head off
                                            set lines 80
                                            set feedback off
                                            set serveroutput on
                                            spool $SPOOLFILE;
                                            \@\@$SQLTORUN;
                                            spool off
                                            exit
EOF
EOF2
SHELL
			    	`$shell_out`;
		    	    	$RETURNCODE = `echo $?`;
			    }
			    else {
                    		my ($NEW_INFIL) 	= File::Spec->catfile( $PROCESS_IDIR, $CHECKID . '_-' . $DBNAME . '.sql' );
                    		my ($NEW_OUTFIL) 	= File::Spec->catfile( $PROCESS_ODIR, 'd_check' . '_-' . $CHECKID . '_-' . $DBNAME . '.out' );

		    		$USER_HASH = get_dbOwner($ORACLE_HOME,$RUNNING_HOST);
		    		($CURRENT_OH_OWNER,$CURRENT_OH_GROUP,$HOME_DIR) = ($USER_HASH->{CURRENT_OH_OWNER}, $USER_HASH->{CURRENT_OH_GROUP}, $USER_HASH->{HOME_DIR});

				if ( "$INFIL" ne "$NEW_INFIL" ) { copy ( $INFIL , $NEW_INFIL); }
				#$RAT_DB_APP_USER =  $DBAPPUSR;
                                `sed -i 's/#APP_USER#/$RAT_DB_APP_USER/g' $NEW_INFIL`;

                                $shell_out = <<SHELL;
                                            $SCOPY $NEW_INFIL $RUNNING_HOST:$SQLTORUN
					    $SSHELL $RUNNING_HOST "chown $CURRENT_OH_OWNER:$CURRENT_OH_GROUP $SQLTORUN"
                                            $SSHELL $RUNNING_HOST bash <<EOF2
					    if [[ -e $HOME_DIR ]]; then cd $HOME_DIR; fi;
                                            export ORACLE_HOME=$ORACLE_HOME;
                                            export ORACLE_SID=$ORACLE_SID;
                                            su $CURRENT_OH_OWNER -c "$SQLPLUS -s / as sysdba >/dev/null 2>&1 <<EOF
                                            set head off
                                            set lines 80
                                            set feedback off
                                            set serveroutput on
                                            spool $SPOOLFILE;
                                            \@\@$SQLTORUN;
                                            spool off
                                            exit
EOF
"
EOF2
SHELL
			    	`$shell_out`;
		    	    	$RETURNCODE = `echo $?`;
			    }

			    $EPOCH_TIME = get_current_epoch();
			    print $CHKT "[CHECK:$CHECKID][HOST: $RUNNING_HOST][TAG1: $DBNAME] Execution End Time: $EPOCH_TIME\n";

                            $shell_out = <<SHELL;
		    	  	    $SCOPY $RUNNING_HOST:$SPOOLFILE $RTEMPDIR >/dev/null 2>&1
SHELL
			    `$shell_out`;
                        }
                    }
		    $MVS_HASH = move_failed_to_skipped( $RETURNCODE, "", "$RUNNING_HOST:$DBNAME", $t_SKIPFIL, $t_STATFIL, "Execute" );
                }
                else {

                }

                if ($COM_REPORT && $MODE == 0 && $rHOST eq $LOCALNODE && $RAT_RUNMODE_INTERNAL eq 'master' ) {
                    my ($INFIL_REPORT) 		= File::Spec->catfile( $INPUTDIR, $CHECKID . '_-' . $DBNAME . '_-' . 'report.sql' );
                    my ($SOURCEFIL_REPORT) 	= File::Spec->catfile( $OUTPUTDIR, $CHECKID . '_-' . $DBNAME . '_-' . 'report.out' );

                    open( my $INHR, ">", "$INFIL_REPORT" )
                      or die "Cannot open $INFIL_REPORT: $!";
                    if ( $DBTYPE eq "PDB" ) {
                        print $INHR "alter session set container=$DBNAME;\n";
                    }

		    #$COM_REPORT=`echo $COM_REPORT | sed "s/#APP_USER#/$RAT_DB_APP_USER/g"`;

                    print $INHR "$COM_REPORT\n";
                    close($INHR);

                    if ( defined $CHKSYSDBA && $CHKSYSDBA =~ m/\d+/ && $CHKSYSDBA == 0 ) {
                        if ( $RUNNING_HOST eq $LOCALNODE ) {
			    my $shell_out;
			    if ( $CHG_USER == 0 ) {
			`sed -i 's/#APP_USER#/$RAT_DB_APP_USER/g' $INFIL_REPORT`;
                                $shell_out = <<SHELL;
                                            $SQLPLUS -s "$dbConnectString" >/dev/null 2>&1 <<EOF
                                            set head off
                                            set lines 80
                                            set feedback off
	        			    set timing off
                                            set serveroutput on
                                            spool $SOURCEFIL_REPORT;
                                            \@\@$INFIL_REPORT;
                                            spool off
                                            exit
EOF
SHELL
			        `$shell_out`;
			        $RETURNCODE = `echo $?`;
			    } 
			    else {
                                my ($NEW_INFIL_REPORT)          = File::Spec->catfile( $PROCESS_RDIR, $CHECKID . '_-' . $DBNAME . '_-' . 'report.sql' );
                                my ($NEW_ROOT_SOURCEFIL_REPORT) = File::Spec->catfile( $PROCESS_RDIR, $CHECKID . '_-' . $DBNAME . '_-' . 'report.out' );

                                $USER_HASH = get_dbOwner($ORACLE_HOME,$RUNNING_HOST);
                                ($CURRENT_OH_OWNER,$CURRENT_OH_GROUP,$HOME_DIR) = ($USER_HASH->{CURRENT_OH_OWNER}, $USER_HASH->{CURRENT_OH_GROUP}, $USER_HASH->{HOME_DIR});

                                if ( "$INFIL_REPORT" ne "$NEW_INFIL_REPORT" ) { copy ( $INFIL_REPORT , $NEW_INFIL_REPORT); }
				`sed -i 's/#APP_USER#/$RAT_DB_APP_USER/g' $NEW_INFIL_REPORT`;
                                `chown $CURRENT_OH_OWNER:$CURRENT_OH_GROUP $NEW_INFIL_REPORT`;
                                $shell_out = <<SHELL;
                                            if [[ -e $HOME_DIR ]]; then cd $HOME_DIR; fi;
                                            su $CURRENT_OH_OWNER -c "$SQLPLUS -s \"$dbConnectString\" as sysdba >/dev/null 2>&1 <<EOF
                                            set head off
                                            set lines 80
                                            set feedback off
                                            set timing off
                                            set serveroutput on
                                            spool $NEW_ROOT_SOURCEFIL_REPORT;
                                            \@\@$NEW_INFIL_REPORT;
                                            spool off
                                            exit
EOF
"
SHELL
                                `$shell_out`;
                                $RETURNCODE = `echo $?`;

                                $shell_out = <<SHELL;
                                        rm -f $NEW_INFIL_REPORT;
                                        if [ "$NEW_ROOT_SOURCEFIL_REPORT" != "$SOURCEFIL_REPORT" ]; then cp $NEW_ROOT_SOURCEFIL_REPORT $SOURCEFIL_REPORT; fi;
SHELL
                                `$shell_out`;
			    }
                        }
                        else {
                            my ($SQLTORUN)	= File::Spec->catfile( $RTEMPDIR, 'sqltorun_' . $CHECKID . '_-' . $DBNAME . '_-' . $RUNNING_HOST . '_-' . 'report.sql' );
                            my ($SPOOLFILE) 	= File::Spec->catfile( $RTEMPDIR, 'sqltorun_' . $CHECKID . '_-' . $DBNAME . '_-' . $RUNNING_HOST . '_-' . 'report.out' );

			    my $shell_out;
			    if ( $CHG_USER == 0 ) {
				`sed -i 's/#APP_USER#/$RAT_DB_APP_USER/g' $SQLTORUN`;
                                $shell_out = <<SHELL;
                                            $SCOPY $INFIL_REPORT $RUNNING_HOST:$SQLTORUN
                                            $SSHELL $RUNNING_HOST bash <<EOF2
                                            export ORACLE_HOME=$ORACLE_HOME;
                                            export ORACLE_SID=$ORACLE_SID;
                                            $SQLPLUS -s "$dbConnectString" >/dev/null 2>&1 <<EOF
                                            set head off
                                            set lines 80
                                            set feedback off
                                            set serveroutput on
	                	    	    set timing off
                                            spool $SPOOLFILE;
                                            \@\@$SQLTORUN;
                                            spool off
                                            exit
EOF
EOF2
SHELL
			    `$shell_out`;
	            	    $RETURNCODE = `echo $?`;
			    }
			    else {
                                my ($NEW_INFIL_REPORT)          = File::Spec->catfile( $PROCESS_RDIR, $CHECKID . '_-' . $DBNAME . '_-' . 'report.sql' );
                                my ($NEW_ROOT_SOURCEFIL_REPORT) = File::Spec->catfile( $PROCESS_RDIR, $CHECKID . '_-' . $DBNAME . '_-' . 'report.out' );

                                $USER_HASH = get_dbOwner($ORACLE_HOME,$RUNNING_HOST);
                                ($CURRENT_OH_OWNER,$CURRENT_OH_GROUP,$HOME_DIR) = ($USER_HASH->{CURRENT_OH_OWNER}, $USER_HASH->{CURRENT_OH_GROUP}, $USER_HASH->{HOME_DIR});

                                if ( "$INFIL_REPORT" ne "$NEW_INFIL_REPORT" ) { copy ( $INFIL_REPORT , $NEW_INFIL_REPORT); }
				`sed -i 's/#APP_USER#/$RAT_DB_APP_USER/g' $SQLTORUN`;
                                $shell_out = <<SHELL;
                                            $SCOPY $NEW_INFIL_REPORT $RUNNING_HOST:$SQLTORUN
                                            $SSHELL $RUNNING_HOST "chown $CURRENT_OH_OWNER:$CURRENT_OH_GROUP $SQLTORUN"
                                            $SSHELL $RUNNING_HOST bash <<EOF2
                                            if [[ -e $HOME_DIR ]]; then cd $HOME_DIR; fi;
                                            export ORACLE_HOME=$ORACLE_HOME;
                                            export ORACLE_SID=$ORACLE_SID;
                                            su $CURRENT_OH_OWNER -c "$SQLPLUS -s \"$dbConnectString\" as sysdba >/dev/null 2>&1 <<EOF
                                            set head off
                                            set lines 80
                                            set feedback off
                                            set serveroutput on
                                            spool $SPOOLFILE;
                                            \@\@$SQLTORUN;
                                            spool off
                                            exit
EOF
"
EOF2
SHELL
                                `$shell_out`;
                                $RETURNCODE = `echo $?`;
			    }

                            $shell_out = <<SHELL;
	            	  	    $SCOPY $RUNNING_HOST:$SPOOLFILE $RTEMPDIR >/dev/null 2>&1
			  	    $SSHELL $RUNNING_HOST "rm -rf $SPOOLFILE  >/dev/null 2>&1"
SHELL
			    `$shell_out`;
                        }
                    }
                    else {
                        if ( $RUNNING_HOST eq $LOCALNODE ) {
			    my $shell_out;	
			    if ( $CHG_USER == 0 ) {
				`sed -i 's/#APP_USER#/$RAT_DB_APP_USER/g' $INFIL_REPORT`;
                                $shell_out = <<SHELL;
                                            $SQLPLUS -s / as sysdba >/dev/null 2>&1 <<EOF
                                            set head off
                                            set lines 80
                                            set feedback off
	                		    set timing off
                                            set serveroutput on
                                            spool $SOURCEFIL_REPORT;
                                            \@\@$INFIL_REPORT;
                                            spool off
                                            exit
EOF
SHELL
			    	`$shell_out`;
	            	        $RETURNCODE = `echo $?`;
			    }
			    else {
				my ($NEW_INFIL_REPORT)  	= File::Spec->catfile( $PROCESS_RDIR, $CHECKID . '_-' . $DBNAME . '_-' . 'report.sql' );
				my ($NEW_ROOT_SOURCEFIL_REPORT)	= File::Spec->catfile( $PROCESS_RDIR, $CHECKID . '_-' . $DBNAME . '_-' . 'report.out' );

		    		$USER_HASH = get_dbOwner($ORACLE_HOME,$RUNNING_HOST);
		    		($CURRENT_OH_OWNER,$CURRENT_OH_GROUP,$HOME_DIR) = ($USER_HASH->{CURRENT_OH_OWNER}, $USER_HASH->{CURRENT_OH_GROUP}, $USER_HASH->{HOME_DIR});

				if ( "$INFIL_REPORT" ne "$NEW_INFIL_REPORT" ) { copy ( $INFIL_REPORT , $NEW_INFIL_REPORT); }
				`sed -i 's/#APP_USER#/$RAT_DB_APP_USER/g' $NEW_INFIL_REPORT`;
			        `chown $CURRENT_OH_OWNER:$CURRENT_OH_GROUP $NEW_INFIL_REPORT`;
                                $shell_out = <<SHELL;
					    if [[ -e $HOME_DIR ]]; then cd $HOME_DIR; fi;
                                            su $CURRENT_OH_OWNER -c "$SQLPLUS -s / as sysdba >/dev/null 2>&1 <<EOF
                                            set head off
                                            set lines 80
                                            set feedback off
	                		    set timing off
                                            set serveroutput on
                                            spool $NEW_ROOT_SOURCEFIL_REPORT;
                                            \@\@$NEW_INFIL_REPORT;
                                            spool off
                                            exit
EOF
"
SHELL
			    	`$shell_out`;
	            	    	$RETURNCODE = `echo $?`;

				$shell_out = <<SHELL;
					rm -f $NEW_INFIL_REPORT; 
					if [ "$NEW_ROOT_SOURCEFIL_REPORT" != "$SOURCEFIL_REPORT" ]; then cp $NEW_ROOT_SOURCEFIL_REPORT $SOURCEFIL_REPORT; fi; 
SHELL
				`$shell_out`;
			    }
                        }
                        else {
                            my ($SQLTORUN)	= File::Spec->catfile( $PROCESS_RDIR, 'sqltorun_' . $CHECKID . '_-' . $DBNAME . '_-' . $RUNNING_HOST . '_-' . 'report.sql' );
                            my ($SPOOLFILE)     = File::Spec->catfile( $PROCESS_RDIR, 'sqltorun_' . $CHECKID . '_-' . $DBNAME . '_-' . $RUNNING_HOST . '_-' . 'report.out' );

			    my $shell_out;
			    if ( $CHG_USER == 0 ) {
				`sed -i 's/#APP_USER#/$RAT_DB_APP_USER/g' $SQLTORUN`;
                                $shell_out = <<SHELL;
                                            $SCOPY $INFIL_REPORT $RUNNING_HOST:$SQLTORUN
                                            $SSHELL $RUNNING_HOST bash <<EOF2
                                            export ORACLE_HOME=$ORACLE_HOME;
                                            export ORACLE_SID=$ORACLE_SID;
                                            $SQLPLUS -s / as sysdba >/dev/null 2>&1 <<EOF
                                            set head off
                                            set lines 80
                                            set feedback off
                                            set serveroutput on
                                            spool $SPOOLFILE;
                                            \@\@$SQLTORUN;
                                            spool off
                                            exit
EOF
EOF2
SHELL
				`$shell_out`;
	            	    	$RETURNCODE = `echo $?`;
			    }
			    else {
				my ($NEW_INFIL_REPORT)  	= File::Spec->catfile( $PROCESS_RDIR, $CHECKID . '_-' . $DBNAME . '_-' . 'report.sql' );
				my ($NEW_ROOT_SOURCEFIL_REPORT)	= File::Spec->catfile( $PROCESS_RDIR, $CHECKID . '_-' . $DBNAME . '_-' . 'report.out' );

		    		$USER_HASH = get_dbOwner($ORACLE_HOME,$RUNNING_HOST);
		    		($CURRENT_OH_OWNER,$CURRENT_OH_GROUP,$HOME_DIR) = ($USER_HASH->{CURRENT_OH_OWNER}, $USER_HASH->{CURRENT_OH_GROUP}, $USER_HASH->{HOME_DIR});

				if ( "$INFIL_REPORT" ne "$NEW_INFIL_REPORT" ) { copy ( $INFIL_REPORT , $NEW_INFIL_REPORT); }
				`sed -i 's/#APP_USER#/$RAT_DB_APP_USER/g' $SQLTORUN`;
                                $shell_out = <<SHELL;
                                            $SCOPY $NEW_INFIL_REPORT $RUNNING_HOST:$SQLTORUN
					    $SSHELL $RUNNING_HOST "chown $CURRENT_OH_OWNER:$CURRENT_OH_GROUP $SQLTORUN"
                                            $SSHELL $RUNNING_HOST bash <<EOF2
					    if [[ -e $HOME_DIR ]]; then cd $HOME_DIR; fi;
                                            export ORACLE_HOME=$ORACLE_HOME;
                                            export ORACLE_SID=$ORACLE_SID;
                                            su $CURRENT_OH_OWNER -c "$SQLPLUS -s / as sysdba >/dev/null 2>&1 <<EOF
                                            set head off
                                            set lines 80
                                            set feedback off
                                            set serveroutput on
                                            spool $SPOOLFILE;
                                            \@\@$SQLTORUN;
                                            spool off
                                            exit
EOF
"
EOF2
SHELL
			    	`$shell_out`;
	            	    	$RETURNCODE = `echo $?`;
			    }

                            $shell_out = <<SHELL;
	            		$SCOPY $RUNNING_HOST:$SPOOLFILE $RTEMPDIR >/dev/null 2>&1
				$SSHELL $RUNNING_HOST "rm -rf $SPOOLFILE  >/dev/null 2>&1"
SHELL
			    `$shell_out`;
                        }
                    }
                }
                else {

		}
            }
	    else {

	    }
	}
	elsif ( $COMTYPE eq 'SQL_COLLECT' ) {
	    my ($t_CHECK_TIMINGS) = File::Spec->catfile( $INPUTDIR , $RUNNING_HOST . '_-' . $CHECKID . '_-' . $DBNAME . '_-' . 'timings.out' );

	    if ( $DBROLEMCNT >= 1 && $DBTYPEMCNT >= 1 ) {
            	my ($INFIL)     = File::Spec->catfile( $INPUTDIR, 'd_' . $OUTFILNAM . '_-' . $CHECKID . '_-' . $DBNAME . '.sql' );
            	my ($OUTFIL)    = File::Spec->catfile( $OUTPUTDIR, 'd_' . $OUTFILNAM . '_-' . $CHECKID . '_-' . $DBNAME . '.out' );

		my ($NEW_INFIL, $NEW_OUTFIL);

		if ( $CHG_USER == 1 ) {
		    $NEW_INFIL 	= File::Spec->catfile( $PROCESS_IDIR, 'd_' . $OUTFILNAM . '_-' . $CHECKID . '_-' . $DBNAME . '.sql' );	
		    $NEW_OUTFIL	= File::Spec->catfile( $PROCESS_ODIR, 'd_' . $OUTFILNAM . '_-' . $CHECKID . '_-' . $DBNAME . '.out' );
		}

	        if ( $NEEDS_RUNNING eq 'ASM' ) {
		    ($OUTFIL)    = File::Spec->catfile( $OUTPUTDIR, 'a_' . $OUTFILNAM . '_-' . $CHECKID . '_-' . $DBNAME . '.out' );
		    if ( $CHG_USER == 1 ) {
			($NEW_OUTFIL)    = File::Spec->catfile( $PROCESS_ODIR, 'a_' . $OUTFILNAM . '_-' . $CHECKID . '_-' . $DBNAME . '.out' );
		    }
		}

                my ($m_OUTFIL) = basename $OUTFIL;
                $m_OUTFIL =~ s/_$CHECKID//g;
                $m_OUTFIL = File::Spec->catfile( $OUTPUTDIR, $m_OUTFIL );

		exit if ( -e $m_OUTFIL ); 

                my ($COMSUBSTR) = substr( $COMMAND, 0, 67 );
                chomp($COMSUBSTR);
                open( my $INH, ">", "$INFIL" )
                    or die "Cannot open $INFIL: $!";

		$RAT_DB_APP_USER =  $DBAPPUSR;
		#$COMMAND=`echo $COMMAND | sed "s/#APP_USER#/$RAT_DB_APP_USER/g"`;

                print $INH "$COMMAND\n";

                if ( "$COMMAND" =~ m/begin/i ) {
                    print $INH "/";
                }
                close($INH);

                my ($t_STFIL) = File::Spec->catfile( $INPUTDIR , $RUNNING_HOST . '_-' . $CHECKID . '_-' . $DBNAME . '.sql_collect.prt' );
                if ( $NEEDS_RUNNING eq 'ASM' ) {
                    open( my $STF, ">>", "$t_STFIL" )
                      or die "Cannot open $t_STFIL: $!";
                    if ( -z "$COLLECTION_NAME" ) {
                        print $STF "Collecting - $COMSUBSTR\n";
                    }
                    else {
                        print $STF "Collecting - $COLLECTION_NAME\n ";
                    }
                    close($STF);

                    my ($CRS112) = 0;
                    my ($CRS_HOME);
                    open( my $EF, "<", "$ENVFIL" ) or die "Cannot open $ENVFIL: $!";
                    while ( my $line = <$EF> ) {
                        if ( $line =~ m/CRS_ACTIVE_VERSION/ && $line =~ m/11\.2/ ) {
                            $CRS112++;
                        }
                        if ( $line =~ m/CRS_HOME/ ) {
                            $CRS_HOME = $line;
                            $CRS_HOME =~ s/CRS_HOME=//g;
                            $CRS_HOME =~ s/ //g;
                        }
                    }
                    close($EF);
                    if ( defined $CRS112 && $CRS112 > 1 ) {
                        $ENV{ORACLE_SID}    = $STACK_ASM_SID;
                        $ENV{ORACLE_HOME}   = $CRS_HOME;
                    }
                    else {
                        $ENV{ORACLE_SID}    = $STACK_ASM_SID;
                        $ENV{ORACLE_HOME}   = $STACK_ASM_HOME;
                    }

                    if ( -e $t_CHECK_TIMINGS ) {
                        open( my $CT, ">>", "$t_CHECK_TIMINGS" )
                          or die "Cannot open $t_CHECK_TIMINGS: $!";
                        my ($TIMESTAMP) = strftime "%a %b %d %H:%M:%S %Y", localtime(time);
                        print $CT "$TIMESTAMP - $COLLECTION_NAME\n\n";
                        close($CT);
                    }
                    if ( defined $CHKSYSDBA && $CHKSYSDBA =~ m/\d+/ && $CHKSYSDBA == 0 && 1 == 2 ) {
			$EPOCH_TIME = get_current_epoch();
		  	print $CHKT "[CHECK:$CHECKID][HOST: $RUNNING_HOST][TAG1: $STACK_ASM_SID] Execution Start Time: $EPOCH_TIME\n";	

			my $shell_out;
			if ( $CHG_USER == 0 ) {
				#$RAT_DB_APP_USER =  $DBAPPUSR;


                                `sed -i 's/#APP_USER#/$RAT_DB_APP_USER/g' $INFIL`;

                            $shell_out = <<SHELL;
                                         $SQLPLUS -s "$dbConnectString" >/dev/null 2>&1 <<EOF
                                         set head off
                                         set lines 80
                                         set feedback off
                                         set timing off
                                         set serveroutput on
                                         spool $OUTFIL;
                                         \@\@$INFIL;
                                         spool off
                                         exit
EOF
SHELL
			    `$shell_out`;
			}
			else {
                            $USER_HASH = get_dbOwner($ORACLE_HOME,$RUNNING_HOST);
                            ($CURRENT_OH_OWNER,$CURRENT_OH_GROUP,$HOME_DIR) = ($USER_HASH->{CURRENT_OH_OWNER}, $USER_HASH->{CURRENT_OH_GROUP}, $USER_HASH->{HOME_DIR});

                            if ( "$INFIL" ne "$NEW_INFIL" ) { copy ( $INFIL , $NEW_INFIL); }
                            `chown $CURRENT_OH_OWNER:$CURRENT_OH_GROUP $NEW_INFIL`;

				#$RAT_DB_APP_USER =  $DBAPPUSR;


                                `sed -i 's/#APP_USER#/$RAT_DB_APP_USER/g' $NEW_INFIL`;

                            $shell_out = <<SHELL;
                                         if [[ -e $HOME_DIR ]]; then cd $HOME_DIR; fi;
                                         su $CURRENT_OH_OWNER -c "$SQLPLUS -s \"$dbConnectString\" as sysdba >/dev/null 2>&1 <<EOF
                                         set head off
                                         set lines 80
                                         set feedback off
                                         set timing off
                                         set serveroutput on
                                         spool $NEW_OUTFIL;
                                         \@\@$NEW_INFIL;
                                         spool off
                                         exit
EOF
"
SHELL
                            `$shell_out`;
                            $shell_out = <<SHELL;
                                        rm -f $NEW_INFIL;
                                        if [ "$NEW_OUTFIL" != "$OUTFIL" ]; then cp $NEW_OUTFIL $OUTFIL; fi;
SHELL
                            `$shell_out`;
			}

			$EPOCH_TIME = get_current_epoch();
			print $CHKT "[CHECK:$CHECKID][HOST: $RUNNING_HOST][TAG1: $STACK_ASM_SID] Execution End Time: $EPOCH_TIME\n";
                    }
                    else {
			$EPOCH_TIME = get_current_epoch();
			print $CHKT "[CHECK:$CHECKID][HOST: $RUNNING_HOST][TAG1: $STACK_ASM_SID] Execution Start Time: $EPOCH_TIME\n";

			my $shell_out;
			if ( $CHG_USER == 0 ) {

				#$RAT_DB_APP_USER =  $DBAPPUSR;


                                `sed -i 's/#APP_USER#/$RAT_DB_APP_USER/g' $INFIL`;

                            $shell_out = <<SHELL;
                                         $SQLPLUS -s / as sysdba >/dev/null 2>&1 <<EOF
                                         set head off
                                         set lines 80
                                         set feedback off
                                         set timing off
                                         set serveroutput on
                                         spool $OUTFIL;
                                         \@\@$INFIL;
                                         spool off
                                         exit
EOF
SHELL
			    `$shell_out`;
			}
			else {
		    	    $USER_HASH = get_dbOwner($ORACLE_HOME,$RUNNING_HOST);
		    	    ($CURRENT_OH_OWNER,$CURRENT_OH_GROUP,$HOME_DIR) = ($USER_HASH->{CURRENT_OH_OWNER}, $USER_HASH->{CURRENT_OH_GROUP}, $USER_HASH->{HOME_DIR});

			    if ( "$INFIL" ne "$NEW_INFIL" ) { copy ( $INFIL , $NEW_INFIL); }
			    `chown $CURRENT_OH_OWNER:$CURRENT_OH_GROUP $NEW_INFIL`;

			#	$RAT_DB_APP_USER =  $DBAPPUSR;


                                `sed -i 's/#APP_USER#/$RAT_DB_APP_USER/g' $NEW_INFIL`;

                            $shell_out = <<SHELL;
					 if [[ -e $HOME_DIR ]]; then cd $HOME_DIR; fi;
                                         su $CURRENT_OH_OWNER -c "$SQLPLUS -s / as sysdba >/dev/null 2>&1 <<EOF
                                         set head off
                                         set lines 80
                                         set feedback off
                                         set timing off
                                         set serveroutput on
                                         spool $NEW_OUTFIL;
                                         \@\@$NEW_INFIL;
                                         spool off
                                         exit
EOF
"
SHELL
			    `$shell_out`;
			    $shell_out = <<SHELL;
					rm -f $NEW_INFIL; 
					if [ "$NEW_OUTFIL" != "$OUTFIL" ]; then cp $NEW_OUTFIL $OUTFIL; fi;
SHELL
			    `$shell_out`;
			}

			$EPOCH_TIME = get_current_epoch();
			print $CHKT "[CHECK:$CHECKID][HOST: $RUNNING_HOST][TAG1: $STACK_ASM_SID] Execution End Time: $EPOCH_TIME\n";
                    }
                }
                else {
                    open( my $STF, ">>", "$t_STFIL" )
                      or die "Cannot open $t_STFIL: $!";
                    if ( -z "$COLLECTION_NAME" ) {
                        print $STF "Collecting - $COMSUBSTR for $DBNAME database\n";
                    }
                    else {
                        print $STF "Collecting - $COLLECTION_NAME for $DBNAME database\n";
                    }
                    close($STF);

                    if ( -e $t_CHECK_TIMINGS ) {
                        open( my $CT, ">>", "$t_CHECK_TIMINGS" )
                          or die "Cannot open $t_CHECK_TIMINGS: $!";
                        my ($TIMESTAMP) = strftime "%a %b %d %H:%M:%S %Y", localtime(time);
                        print $CT "$TIMESTAMP - $COLLECTION_NAME on $DBNAME\n\n";
                        close($CT);
                    }

                    if ( defined $CHKSYSDBA && $CHKSYSDBA =~ m/\d+/ && $CHKSYSDBA == 0 ) {
                        if ( $RUNNING_HOST eq $LOCALNODE ) {
			    $EPOCH_TIME = get_current_epoch();
			    print $CHKT "[CHECK:$CHECKID][HOST: $RUNNING_HOST][TAG1: $ORACLE_SID] Execution Start Time: $EPOCH_TIME\n";

			    my $shell_out;
			    if ( $CHG_USER == 0 ) {
			#	$RAT_DB_APP_USER =  $DBAPPUSR;


                                `sed -i 's/#APP_USER#/$RAT_DB_APP_USER/g' $INFIL`;

                                $shell_out = <<SHELL;
                                             $SQLPLUS -s "$dbConnectString" >/dev/null 2>&1 <<EOF
                                             set head off
                                             set lines 80
                                             set feedback off
                                             set serveroutput on
                                             spool $OUTFIL;
                                             \@\@$INFIL;
                                             spool off
                                             exit
EOF
SHELL
			        `$shell_out`;
			    }
			    else {
                                $USER_HASH = get_dbOwner($ORACLE_HOME,$RUNNING_HOST);
                                ($CURRENT_OH_OWNER,$CURRENT_OH_GROUP,$HOME_DIR) = ($USER_HASH->{CURRENT_OH_OWNER}, $USER_HASH->{CURRENT_OH_GROUP}, $USER_HASH->{HOME_DIR});

                                if ( $INFIL ne $NEW_INFIL ) { copy ( $INFIL, $NEW_INFIL); }
                                `chown $CURRENT_OH_OWNER:$CURRENT_OH_GROUP $NEW_INFIL`;
		#		$RAT_DB_APP_USER =  $DBAPPUSR;


                                `sed -i 's/#APP_USER#/$RAT_DB_APP_USER/g' $NEW_INFIL`;

                                $shell_out = <<SHELL;
                                     if [[ -e $HOME_DIR ]]; then cd $HOME_DIR; fi;
                                     su $CURRENT_OH_OWNER -c "$SQLPLUS -s \"$dbConnectString\" as sysdba >/dev/null 2>&1 <<EOF
                                     set head off
                                     set lines 80
                                     set feedback off
                                     set serveroutput on
                                     spool $NEW_OUTFIL;
                                     \@\@$NEW_INFIL;
                                     spool off
                                     exit
EOF
"
SHELL
                                `$shell_out`;
                                $shell_out = <<SHELL;
                                        rm -f $NEW_INFIL;
                                        if [ "$NEW_OUTFIL" != "$OUTFIL" ]; then cp $NEW_OUTFIL $OUTFIL; fi;
SHELL
                                `$shell_out`;
			    }

			    $EPOCH_TIME = get_current_epoch();
			    print $CHKT "[CHECK:$CHECKID][HOST: $RUNNING_HOST][TAG1: $ORACLE_SID] Execution End Time: $EPOCH_TIME\n";
                        }
                        else {
                            my ($SQLTORUN)  = File::Spec->catfile( $RTEMPDIR, 'sqltorun_' . 'd_' . $OUTFILNAM . '_-' . $CHECKID . '_-' . $DBNAME . '_-' . $RUNNING_HOST . '.sql' ); 
                            my ($SPOOLFILE) = File::Spec->catfile( $RTEMPDIR, 'sqltorun_' . 'd_' . $OUTFILNAM . '_-' . $CHECKID . '_-' . $DBNAME . '_-' . $RUNNING_HOST . '.out' );
			    my ($SQLTORUNAPP)  = File::Spec->catfile( $RTEMPDIR,  'd_app_user' . '_-' . $DBNAME .'.sql' );
                            my ($SPOOLFILEAPP) = File::Spec->catfile( $RTEMPDIR,  'd_app_user' . '_-' . $DBNAME .'.out' );

                	    my ($m_OUTFIL) = basename $SPOOLFILE;
			    $m_OUTFIL =~ s/sqltorun_//g;
                	    $m_OUTFIL =~ s/_-$CHECKID//g;
                	    $m_OUTFIL = File::Spec->catfile( $OUTPUTDIR, $m_OUTFIL );

			    exit if ( -e $m_OUTFIL ); 

			    $EPOCH_TIME = get_current_epoch();
			    print $CHKT "[CHECK:$CHECKID][HOST: $RUNNING_HOST][TAG1: $ORACLE_SID] Execution Start Time: $EPOCH_TIME\n";

			    my $shell_out;
			    if ( $CHG_USER == 0 ) {
#				$RAT_DB_APP_USER =  $DBAPPUSR;


                                `sed -i 's/#APP_USER#/$RAT_DB_APP_USER/g' $INFIL`;

                                 $shell_out = <<SHELL;
                                             $SCOPY $INFIL $RUNNING_HOST:$SQLTORUN
                                             $SSHELL $RUNNING_HOST bash <<EOF2
                                             export ORACLE_HOME=$ORACLE_HOME;
                                             export ORACLE_SID=$ORACLE_SID;
                                             $SQLPLUS -s "$dbConnectString" >/dev/null 2>&1 <<EOF
                                             set head off
                                             set lines 80
                                             set feedback off
                                             set serveroutput on
                                             spool $SPOOLFILE;
                                             \@\@$SQLTORUN;
                                             spool off
                                             exit
EOF
EOF2
SHELL
    			        `$shell_out`;
			    }
			    else {
                                $USER_HASH = get_dbOwner($ORACLE_HOME,$RUNNING_HOST);
                                ($CURRENT_OH_OWNER,$CURRENT_OH_GROUP,$HOME_DIR) = ($USER_HASH->{CURRENT_OH_OWNER}, $USER_HASH->{CURRENT_OH_GROUP}, $USER_HASH->{HOME_DIR});

                                if ( $INFIL ne $NEW_INFIL ) { copy ( $INFIL, $NEW_INFIL); }
#				$RAT_DB_APP_USER =  $DBAPPUSR;


                                `sed -i 's/#APP_USER#/$RAT_DB_APP_USER/g' $INFIL`;

                                $shell_out = <<SHELL;
                                            $SCOPY $INFIL $RUNNING_HOST:$SQLTORUN
                                            $SSHELL $RUNNING_HOST "chown $CURRENT_OH_OWNER:$CURRENT_OH_GROUP $SQLTORUN"
                                            $SSHELL $RUNNING_HOST bash <<EOF2
                                            if [[ -e $HOME_DIR ]]; then cd $HOME_DIR; fi;
                                            export ORACLE_HOME=$ORACLE_HOME;
                                            export ORACLE_SID=$ORACLE_SID;
                                            su $CURRENT_OH_OWNER -c "$SQLPLUS -s \"$dbConnectString\" as sysdba >/dev/null 2>&1 <<EOF
                                            set head off
                                            set lines 80
                                            set feedback off
                                            set serveroutput on
                                            spool $SPOOLFILE;
                                            \@\@$SQLTORUN;
                                            spool off
                                            exit
EOF
"
EOF2
SHELL
                                `$shell_out`;
			    }

			    $EPOCH_TIME = get_current_epoch();
			    print $CHKT "[CHECK:$CHECKID][HOST: $RUNNING_HOST][TAG1: $ORACLE_SID] Execution End Time: $EPOCH_TIME\n";

                            $shell_out = <<SHELL;
                                    $SCOPY $RUNNING_HOST:$SPOOLFILE $RTEMPDIR >/dev/null 2>&1
				    $SSHELL $RUNNING_HOST "rm -rf $SPOOLFILE  >/dev/null 2>&1"
SHELL
			    `$shell_out`;
                        }
                    }
                    else {
                        if ( $RUNNING_HOST eq $LOCALNODE ) {
			    $EPOCH_TIME = get_current_epoch();
			    print $CHKT "[CHECK:$CHECKID][HOST: $RUNNING_HOST][TAG1: $ORACLE_SID] Execution Start Time: $EPOCH_TIME\n";

			    my $shell_out;

			    if ( $CHG_USER == 0 ) {
#				$RAT_DB_APP_USER =  $DBAPPUSR;


                                `sed -i 's/#APP_USER#/$RAT_DB_APP_USER/g' $INFIL`;

                                $shell_out = <<SHELL;
                                     $SQLPLUS -s / as sysdba >/dev/null 2>&1 <<EOF
                                     set head off
                                     set lines 80
                                     set feedback off
                                     set serveroutput on
                                     spool $OUTFIL;
                                     \@\@$INFIL;
                                     spool off
                                     exit
EOF
SHELL
			  	`$shell_out`;
			    }
			    else {
		    		$USER_HASH = get_dbOwner($ORACLE_HOME,$RUNNING_HOST);
		    		($CURRENT_OH_OWNER,$CURRENT_OH_GROUP,$HOME_DIR) = ($USER_HASH->{CURRENT_OH_OWNER}, $USER_HASH->{CURRENT_OH_GROUP}, $USER_HASH->{HOME_DIR});

				if ( $INFIL ne $NEW_INFIL ) { copy ( $INFIL, $NEW_INFIL); }
				`chown $CURRENT_OH_OWNER:$CURRENT_OH_GROUP $NEW_INFIL`;
#				$RAT_DB_APP_USER =  $DBAPPUSR;

                                `sed -i 's/#APP_USER#/$RAT_DB_APP_USER/g' $NEW_INFIL`;
                                $shell_out = <<SHELL;
				     if [[ -e $HOME_DIR ]]; then cd $HOME_DIR; fi;
                                     su $CURRENT_OH_OWNER -c "$SQLPLUS -s / as sysdba >/dev/null 2>&1 <<EOF
                                     set head off
                                     set lines 80
                                     set feedback off
                                     set serveroutput on
                                     spool $NEW_OUTFIL;
                                     \@\@$NEW_INFIL;
                                     spool off
                                     exit
EOF
"
SHELL
			    	`$shell_out`;
			    	$shell_out = <<SHELL;
					rm -f $NEW_INFIL; 
					if [ "$NEW_OUTFIL" != "$OUTFIL" ]; then cp $NEW_OUTFIL $OUTFIL; fi;
SHELL
				`$shell_out`;
			    }

			    $EPOCH_TIME = get_current_epoch();
			    print $CHKT "[CHECK:$CHECKID][HOST: $RUNNING_HOST][TAG1: $ORACLE_SID] Execution End Time: $EPOCH_TIME\n";
                        }
                        else {
                            my ($SQLTORUN)  = File::Spec->catfile( $PROCESS_RDIR, 'sqltorun_' . 'd_' . $OUTFILNAM . '_-' . $CHECKID . '_-' . $DBNAME . '_-' . $RUNNING_HOST . '.sql' );
                            my ($SPOOLFILE) = File::Spec->catfile( $PROCESS_RDIR, 'sqltorun_' . 'd_' . $OUTFILNAM . '_-' . $CHECKID . '_-' . $DBNAME . '_-' . $RUNNING_HOST . '.out' );
			    my ($SQLTORUNAPP)  = File::Spec->catfile( $PROCESS_RDIR,  'd_app_user' . '_-' . $DBNAME .'.sql');
                            my ($SPOOLFILEAPP) = File::Spec->catfile( $PROCESS_RDIR,  'd_app_user' . '_-' . $DBNAME .'.out');

			    $EPOCH_TIME = get_current_epoch();
			    print $CHKT "[CHECK:$CHECKID][HOST: $RUNNING_HOST][TAG1: $ORACLE_SID] Execution Start Time: $EPOCH_TIME\n";

			    my $shell_out;
			    if ( $CHG_USER == 0 ) {
#				$RAT_DB_APP_USER =  $DBAPPUSR;


                                `sed -i 's/#APP_USER#/$RAT_DB_APP_USER/g' $INFIL`;
                                $shell_out = <<SHELL;
                                            $SCOPY $INFIL $RUNNING_HOST:$SQLTORUN
                                            $SSHELL $RUNNING_HOST bash <<EOF2
                                            export ORACLE_HOME=$ORACLE_HOME;
                                            export ORACLE_SID=$ORACLE_SID;
                                            $SQLPLUS -s / as sysdba >/dev/null 2>&1 <<EOF
                                            set head off
                                            set lines 80
                                            set feedback off
                                            set serveroutput on
                                            spool $SPOOLFILE;
                                            \@\@$SQLTORUN;
                                            spool off
                                            exit
EOF
EOF2
SHELL
				`$shell_out`;
			    }
			    else {
		    		$USER_HASH = get_dbOwner($ORACLE_HOME,$RUNNING_HOST);
		    		($CURRENT_OH_OWNER,$CURRENT_OH_GROUP,$HOME_DIR) = ($USER_HASH->{CURRENT_OH_OWNER}, $USER_HASH->{CURRENT_OH_GROUP}, $USER_HASH->{HOME_DIR});

				if ( $INFIL ne $NEW_INFIL ) { copy ( $INFIL, $NEW_INFIL); }
#				$RAT_DB_APP_USER =  $DBAPPUSR;


                               `sed -i 's/#APP_USER#/$RAT_DB_APP_USER/g' $INFIL`;

                                $shell_out = <<SHELL;
                                            $SCOPY $INFIL $RUNNING_HOST:$SQLTORUN
					    $SSHELL $RUNNING_HOST "chown $CURRENT_OH_OWNER:$CURRENT_OH_GROUP $SQLTORUN"
                                            $SSHELL $RUNNING_HOST bash <<EOF2
				            if [[ -e $HOME_DIR ]]; then cd $HOME_DIR; fi;
                                            export ORACLE_HOME=$ORACLE_HOME;
                                            export ORACLE_SID=$ORACLE_SID;
                                            su $CURRENT_OH_OWNER -c "$SQLPLUS -s / as sysdba >/dev/null 2>&1 <<EOF
r
                                            set head off
                                            set lines 80
                                            set feedback off
                                            set serveroutput on
                                            spool $SPOOLFILE;
                                            \@\@$SQLTORUN;
                                            spool off
                                            exit
EOF
"
EOF2
SHELL
			    	`$shell_out`; 
			    }

			    $EPOCH_TIME = get_current_epoch();
			    print $CHKT "[CHECK:$CHECKID][HOST: $RUNNING_HOST][TAG1: $ORACLE_SID] Execution End Time: $EPOCH_TIME\n";

                            $shell_out = <<SHELL;
                                $SCOPY $RUNNING_HOST:$SPOOLFILE $RTEMPDIR >/dev/null 2>&1
				$SSHELL $RUNNING_HOST "rm -rf $SPOOLFILE  >/dev/null 2>&1"
SHELL
			    `$shell_out`;
                        }
                    }
                }
            }
        }
	elsif ( $COMTYPE eq 'OS' ) {
            my ($t_OSSPOOLFIL) = File::Spec->catfile( $PROCESS_ODIR, 'o_check' . '_-' . $LOCALNODE . '_-' . $CHECKID . '_-' . $DBNAME . '.out' );

            my ($USERN);
	    my ($CURRENT_OH_OWNER,$CURRENT_OH_GROUP,$HOME_DIR);
            if ( $MODE == 0 ) {
		$USER_HASH = get_dbOwner($ORACLE_HOME,$RUNNING_HOST);
    		($CURRENT_OH_OWNER,$CURRENT_OH_GROUP,$HOME_DIR) = ($USER_HASH->{CURRENT_OH_OWNER}, $USER_HASH->{CURRENT_OH_GROUP}, $USER_HASH->{HOME_DIR});
                $USERN                  = current_user();
            }
            else {
                my ($CURREN_OH);
                open( my $EF, "<", "$ENVFIL" ) or die "Cannot open $ENVFIL: $!";
                while ( my $line = <$EF> ) {
                    if ( $line =~ m/CURRENT_USER/ ) {
                        $USERN = $line;
                        $USERN =~ s/CURRENT_USER = //g;
                        $USERN =~ s/ //g;
                    }
                    elsif ( $line =~ m/DB_NAME = $DBNAME/ ) {
                        $CURREN_OH = $line;
                        $CURREN_OH =~ s/DB_NAME = //g;
                        $CURREN_OH = ( split '|', $CURREN_OH )[2];
                        $CURREN_OH =~ s/ //g;
                    }
                    elsif ( $line =~ m/RDBMS_ORACLE_HOME = $CURREN_OH/ ) {
                        $CURRENT_OH_OWNER = $line;
                        $CURRENT_OH_OWNER =~ s/RDBMS_ORACLE_HOME = //g;
                        $CURRENT_OH_OWNER = ( split '|', $CURREN_OH )[2];
                    }
                }
		if (!defined $CURRENT_OH_OWNER) { $CURRENT_OH_OWNER = getpwuid($<);; }
		$CURRENT_OH_GROUP = (getpwnam $CURRENT_OH_OWNER)[3];
		$HOME_DIR = (getpwnam $CURRENT_OH_OWNER)[7];
                close($EF);
            }

            open( my $EF, "<", "$ENVFIL" ) or die "Cannot open $ENVFIL: $!";
            my ($INST_MODE);
            my ($INST_NAME);
            while ( my $line = <$EF> ) {
                next if ( $line =~ m/^\s*#/ );
                if ( $line =~ m/$rHOST\.$DBNAME\.INSTANCE_MODE/ ) {
                    $INST_MODE = $line;
                    $INST_MODE =~ s/$rHOST\.$DBNAME\.INSTANCE_MODE\s*=\s*//g;
                }
                elsif ( $line =~ m/$rHOST\.$DBNAME\.INSTANCE_NAME/ ) {
                    $INST_NAME = $line;
                    $INST_NAME =~ s/$rHOST\.$DBNAME\.INSTANCE_NAME\s*=\s*//g;
                }
            }
            close($EF);
	
            if ( $DBROLEMCNT >= 1 && $DBTYPEMCNT >= 1 ) {
                my ($t_CHECK_TIMINGS) = File::Spec->catfile( $PROCESS_IDIR, $rHOST . '_-' . $CHECKID . '_-' . $DBNAME . '_-' . 'timings.out' );
                if ( $MODE == 0 && $INST_MODE == 3 ) {
                    open( my $CT, ">>", "$t_CHECK_TIMINGS" )
                      or die "Cannot open $t_CHECK_TIMINGS: $!";
                    my ($TIMESTAMP) = strftime "%a %b %d %H:%M:%S %Y", localtime(time);
                    print $CT "start time - $TIMESTAMP  - $AU_CHK_NAME on $rHOST for $DBNAME database\n\n";
                    close($CT);

		    my ($LD_LIBRARY_PATH);
                    my ($TMP_ENVFIL) = File::Spec->catfile( $PROCESS_IDIR, 'tmp_env_file' . '_-' . $LOCALNODE . '_-' . $CHECKID . '_-' . $DBNAME . '.sh' );
                    open( my $OEF, "<", "$ORCLENVFIL" ) or die "Cannot open $ORCLENVFIL: $!";
                    open( my $TOEF, ">>", "$TMP_ENVFIL" ) or die "Cannot open $TMP_ENVFIL: $!";
                    while (<$OEF>) {
			if ( $_ =~ m/^LD_LIBRARY_PATH=/ ) { $LD_LIBRARY_PATH = "$_"; chomp($LD_LIBRARY_PATH); $LD_LIBRARY_PATH = (split "=",$LD_LIBRARY_PATH)[1]; $LD_LIBRARY_PATH =~ s/ //g;}

                        if ( $_ !~ m/ORACLE_SID/ && $_ !~ m/ORACLE_HOME/ && $_ !~ m/LD_LIBRARY_PATH/ ) {
                            print $TOEF $_;
                        }
                    }
                    print $TOEF "export ORACLE_SID=$INST_NAME\n";
                    print $TOEF "export ORACLE_HOME=$ORACLE_HOME\n";

                    close($TOEF);
                    close($OEF);

		    update_ld_lib_path("$LD_LIBRARY_PATH", "$ORACLE_HOME", "$TMP_ENVFIL");

                    my ($TRGTORCLENV) = basename $TMP_ENVFIL;
		    if ( $CHG_USER == 0 ) {
                        $TRGTORCLENV = File::Spec->catfile( $RTEMPDIR, $TRGTORCLENV );
		    }
		    else {
                        $TRGTORCLENV = File::Spec->catfile( $TMP_OUTPUT, $TRGTORCLENV );
		    }

                    if ( $rHOST eq $LOCALNODE ) {
                        if ( "$TMP_ENVFIL" ne "$TRGTORCLENV" ) {
                            copy( $TMP_ENVFIL, $TRGTORCLENV );
                        }
                    }
                    else {
                        my $shell_out = <<SHELL;
                            $SCOPY $TMP_ENVFIL $rHOST:$RTEMPDIR >/dev/null 2>&1;
SHELL
			`$shell_out`;
                    }
                    copy_env_files_to_tmp( $TMP_ENVFIL, $rHOST);

		    my ($LOCALCMD, $O_CHK_FIL, $OLD_O_CHK_FIL, $t_ERRFIL);
		    if ( $CHG_USER == 0 ) {
                        ($LOCALCMD) 	= File::Spec->catfile( $RTEMPDIR, 'localcmd' . '_-' . $LOCALNODE . '_-' . $CHECKID . '_-' . $DBNAME . '.sh' );
                        ($O_CHK_FIL) 	= File::Spec->catfile( $OUTPUTDIR, $LOCALNODE . '_-' . $CHECKID . '_-' . $DBNAME . '_-' . 'report.out' );
                        ($t_ERRFIL) 	= File::Spec->catfile( $INPUTDIR, $rHOST . '_-' . $CHECKID . '_-' . $DBNAME . '_-' . 'error.log' );
		    }
		    else {
                        ($LOCALCMD) 	= File::Spec->catfile( $TMP_OUTPUT, 'localcmd' . '_-' . $LOCALNODE . '_-' . $CHECKID . '_-' . $DBNAME . '.sh' );
                        ($O_CHK_FIL) 	= File::Spec->catfile( $PROCESS_ODIR, $LOCALNODE . '_-' . $CHECKID . '_-' . $DBNAME . '_-' . 'report.out' );
                        ($OLD_O_CHK_FIL)= File::Spec->catfile( $PROCESS_ODIR, $LOCALNODE . '_-' . $CHECKID . '_-' . $DBNAME . '_-' . 'report.out' );
                        ($t_ERRFIL) 	= File::Spec->catfile( $PROCESS_IDIR, $rHOST . '_-' . $CHECKID . '_-' . $DBNAME . '_-' . 'error.log' );
		    } 
                    open( my $LCMD, ">", "$LOCALCMD" )
                      or die "Cannot open $LOCALCMD: $!";
                    print $LCMD "#!$BASH_SCR\n";
		    print $LCMD "$DEBUG_FLG\n";
                    print $LCMD "$BASH_SOURCE\n";
                    print $LCMD ". $TRGTORCLENV\n";

                    if ($COM_REPORT) {
                        open( my $CHKF, ">", "$O_CHK_FIL" )
                          or die "Cannot open $O_CHK_FIL: $!";
                        print $CHKF "TO REVIEW COLLECTED DATA FROM "
                          . uc($rHOST) . " - "
                          . uc($DBNAME)
                          . " DATABASE - "
                          . uc($AU_CHK_NAME)
                          . "\n\n\n";
                        close($CHKF);
                    }

                    my ($FILVAL);
                    my ($RETURNCODE);
                    if ( $rHOST eq $LOCALNODE ) {
                        print $LCMD "$COMMAND\n";
                        if ($COM_REPORT) {
                            print $LCMD "$COM_REPORT >> $O_CHK_FIL 2>>$t_ERRFIL\n";
                        }
                        print $LCMD "exit 0\n";
                        close($LCMD);
                        chmod( 0744, $LOCALCMD );
                        chmod( 0744, $TRGTORCLENV );

			$EPOCH_TIME = get_current_epoch();
			print $CHKT "[CHECK:$CHECKID][HOST: $RUNNING_HOST][TAG1: $DBNAME] Execution Start Time: $EPOCH_TIME\n";

                        if ( $CHG_USER == 0 ) {
                            $FILVAL = `$LOCALCMD 2>>$t_ERRFIL`;
                            $RETURNCODE = `echo $?`;
                        }
                        else {
			    `chown $CURRENT_OH_OWNER:$CURRENT_OH_GROUP $TRGTORCLENV`;
			    `chown $CURRENT_OH_OWNER:$CURRENT_OH_GROUP $LOCALCMD`;
                            $FILVAL = `if [[ -e $HOME_DIR ]]; then cd $HOME_DIR; fi; su $CURRENT_OH_OWNER -c "$LOCALCMD 2>>$t_ERRFIL"`;
                            $RETURNCODE = `echo $?`;
			
			    if ($COM_REPORT) {
			        my $TMP_FILVAL = `if [ "$O_CHK_FIL" != "$OLD_O_CHK_FIL" ]; then cp $O_CHK_FIL $OLD_O_CHK_FIL; fi`;
			    }
                        }

			$EPOCH_TIME = get_current_epoch();
			print $CHKT "[CHECK:$CHECKID][HOST: $RUNNING_HOST][TAG1: $DBNAME] Execution End Time: $EPOCH_TIME\n";

                        if ( -e $LOCALCMD ) {
			    if ( $KEEP_LCMD == 0 ) {
                                unlink($LOCALCMD);
			    }
			    else {
				store_localcmd($TMP_ENVFIL,$LOCALCMD);
			    }
                        }
                    }
                    else {
			my ($t_LOCALCMD, $t_O_CHK_FIL);
			if ( $CHG_USER == 0 ) {
                            ($t_LOCALCMD)    = File::Spec->catfile( $RTEMPDIR, basename($LOCALCMD) );
                            ($t_O_CHK_FIL)   = File::Spec->catfile( $RTEMPDIR, basename($O_CHK_FIL) );
			}
			else {
                            ($t_LOCALCMD)    = File::Spec->catfile( $TMP_OUTPUT, basename($LOCALCMD) );
                            ($t_O_CHK_FIL)   = File::Spec->catfile( $TMP_OUTPUT, basename($O_CHK_FIL) );
			}

                        print $LCMD "$COMMAND\n";
                        if ($COM_REPORT) {
                            print $LCMD "$COM_REPORT >> $t_O_CHK_FIL 2>>$t_ERRFIL\n";
                        }
                        print $LCMD "exit 0\n";
                        close($LCMD);

			if ( $KEEP_LCMD == 1 ) {
			    store_localcmd($TMP_ENVFIL,$LOCALCMD);
			}

			$EPOCH_TIME = get_current_epoch();
			print $CHKT "[CHECK:$CHECKID][HOST: $RUNNING_HOST][TAG1: $DBNAME] Execution Start Time: $EPOCH_TIME\n";

                        if ( $CHG_USER == 0 ) {
                            my $shell_out = <<SHELL;
                              $SCOPY $LOCALCMD $rHOST:$RTEMPDIR >/dev/null 2>&1
                              $SCOPY $O_CHK_FIL $rHOST:$RTEMPDIR >/dev/null 2>&1
SHELL
                           `$shell_out`;

			    $shell_out = <<SHELL;
                              $SSHELL $rHOST "chmod 744 $t_LOCALCMD >/dev/null 2>&1"
SHELL
			    `$shell_out`;

                            $FILVAL = `$SSHELL $rHOST "$t_LOCALCMD" 2>>$t_ERRFIL`;
			    $RETURNCODE = `echo $?`;
                        }
                        else {
                            my $shell_out = <<SHELL;
                              $SCOPY $LOCALCMD $rHOST:$TMP_OUTPUT >/dev/null 2>&1
                              $SCOPY $O_CHK_FIL $rHOST:$TMP_OUTPUT >/dev/null 2>&1
SHELL
                           `$shell_out`;

			    $shell_out = <<SHELL;
                              $SSHELL $rHOST "chmod 744 $TRGTORCLENV >/dev/null 2>&1"
                              $SSHELL $rHOST "chmod 744 $t_LOCALCMD >/dev/null 2>&1"
                              $SSHELL $rHOST "chmod 777 $t_ERRFIL >/dev/null 2>&1"
			      $SSHELL $rHOST "chown $CURRENT_OH_OWNER:$CURRENT_OH_GROUP $TRGTORCLENV"
			      $SSHELL $rHOST "chown $CURRENT_OH_OWNER:$CURRENT_OH_GROUP $t_LOCALCMD"
SHELL
			    `$shell_out`;

                            $FILVAL = `if [[ -e $HOME_DIR ]]; then cd $HOME_DIR; fi; $SSHELL $rHOST "su $CURRENT_OH_OWNER -c $t_LOCALCMD" 2>>$t_ERRFIL`;
			    $RETURNCODE = `echo $?`;
                        }

			$EPOCH_TIME = get_current_epoch();
			print $CHKT "[CHECK:$CHECKID][HOST: $RUNNING_HOST][TAG1: $DBNAME] Execution End Time: $EPOCH_TIME\n";

                        my $shell_out = <<SHELL;
                            $SCOPY $rHOST:$t_O_CHK_FIL $OUTPUTDIR >/dev/null 2>&1
                            $SSHELL $rHOST "rm -f $t_LOCALCMD $t_O_CHK_FIL>/dev/null 2>&1"
SHELL
			`$shell_out`;
                    }

	 	    $ALVL_HASH = set_alvl($RETURNCODE);
	 	    $RETURNCODE = $ALVL_HASH->{RCODE};
		    my $ALVL = $ALVL_HASH->{ALVL};

                    my ($SHASH)     = move_failed_to_skipped( $RETURNCODE, "", "$rHOST:$DBNAME", $t_SKIPFIL, $t_STATFIL, "Execute", $ALVL );

                    open( my $OSF, ">>", "$t_OSSPOOLFIL" )
                      or die "Cannot open $t_OSSPOOLFIL: $!";
                    print $OSF "\n";
                    #print $OSF "$DBNAME $PARAM_PATH $ROW == $FILVAL\n";
                    print $OSF "$DBNAME $PARAM_PATH $CHECKID == $FILVAL\n";
                }
	    }
	}
        close($CHKT);
        exit;
    }
    else {
	set_run_log($RLOG , "Unable to spawn process, skipping!");
        exit; 
    }

    close($RLOG);
}
close($FH);

for my $pid (@PIDS) {
    waitpid $pid, 0;
}


foreach
  my $file ( glob( File::Spec->catfile( $OUTPUTDIR, "*$CHECKID*_run.log" ) ) )
{
    open( my $FH, "<", "$file" ) or die "Cannot open $file: $!";
    while (<$FH>) {
        print $RGLOG $_;
    }
    close($FH);
}
if ( $MERGE == 1 ) {
    set_run_log($RGLOG , "Started Merging");
}
else {
    set_run_log($RGLOG , "Not Merging as [ parameter : MERGE = $MERGE ]");
}


merge ( $STFIL , "*.prt" , $INPUTDIR ) ;

if ( $MERGE == 1 ) {
    merge ( $SKIPFIL , "*$CHECKID*_-skipped_checks.log" , $INPUTDIR );

    merge ( $STATFIL , "*$CHECKID*_-stat.data" , $INPUTDIR );

    merge ( $CHECK_TIMINGS , "*$CHECKID*_-timings.out" , $INPUTDIR );

    merge ( $ERRFIL , "*$CHECKID*_-error.log" , $INPUTDIR );

    merge ( $CHK_TIMINGS , "*$CHECKID*_-epoch_timings.out" , $INPUTDIR );

    if ( $COMTYPE eq 'SQL' ) {
    	foreach
    	  my $SPOOL ( glob( File::Spec->catfile( $RTEMPDIR, "sqltorun_$CHECKID*.out" ) ) )
    	{
	    next if ($SPOOL !~ m/_-/);

    	    my ($t_SPOOL) = basename $SPOOL;
    	    $t_SPOOL =~ s/sqltorun_//g;
    	    $t_SPOOL =~ s/\.out//g;

    	    my ($OUTFIL);
    	    if ( $SPOOL =~ m/_-report/ ) {
    	        $t_SPOOL =~ s/_-report//g;

    	        my ( $t_CHECKID, $t_DBNAME, $t_HOST ) = split( '_-', $t_SPOOL );
    	        $OUTFIL = File::Spec->catfile( $OUTPUTDIR,
    	            $t_CHECKID . '_' . $t_DBNAME . '_' . 'report.out' );
    	    }
    	    else {
    	        my ( $t_CHECKID, $t_DBNAME, $t_HOST ) = split( '_-', $t_SPOOL );
    	        $OUTFIL = File::Spec->catfile( $OUTPUTDIR,
    	            'd_check' . '_' . $t_DBNAME . '.out' );
    	    }

	    set_run_log($RGLOG, "$SPOOL -> $OUTFIL");

    	    open( my $OFH, ">>", "$OUTFIL" ) or die "Cannot open $OUTFIL: $!";
    	    open( my $SFH, "<", "$SPOOL" )  or die "Cannot open $SPOOL: $!";
    	    while (<$SFH>) {
    	        print $OFH $_;
    	    }
    	    close($OUTFIL);
    	    close($SPOOL);
    	} 
	
	if ( $CHG_USER == 1) {
	    if ( -d $TMP_OUTPUT ) {
    		foreach
    		  my $SPOOL ( glob( File::Spec->catfile( $TMP_OUTPUT, "sqltorun_$CHECKID*.out" ) ) )
    		{
	    	    next if ($SPOOL !~ m/_-/);

    		    my ($t_SPOOL) = basename $SPOOL;
    		    $t_SPOOL =~ s/sqltorun_//g;
    		    $t_SPOOL =~ s/\.out//g;

    		    my ($OUTFIL);
    		    if ( $SPOOL =~ m/_-report/ ) {
    		        $t_SPOOL =~ s/_-report//g;

    		        my ( $t_CHECKID, $t_DBNAME, $t_HOST ) = split( '_-', $t_SPOOL );
    		        $OUTFIL = File::Spec->catfile( $OUTPUTDIR,
    		            $t_CHECKID . '_' . $t_DBNAME . '_' . 'report.out' );
    		    }
    		    else {
    		        my ( $t_CHECKID, $t_DBNAME, $t_HOST ) = split( '_-', $t_SPOOL );
    		        $OUTFIL = File::Spec->catfile( $OUTPUTDIR,
    		            'd_check' . '_' . $t_DBNAME . '.out' );
    		    }

		    set_run_log($RGLOG, "$SPOOL -> $OUTFIL");

    		    open( my $OFH, ">>", "$OUTFIL" ) or die "Cannot open $OUTFIL: $!";
    		    open( my $SFH, "<", "$SPOOL" )  or die "Cannot open $SPOOL: $!";
    		    while (<$SFH>) {
    		        print $OFH $_;
    		    }
    		    close($OUTFIL);
    		    close($SPOOL);
    		} 

	    }
	}

	foreach
	  my $C_SPOOL ( glob( File::Spec->catfile( $OUTPUTDIR, "d_check_-$CHECKID*.out" ) ) )
	{
	    next if ($C_SPOOL !~ m/_-/);

	    my ($t_SPOOL) = basename $C_SPOOL;			
	    $t_SPOOL =~ s/d_check_-//g;
	    $t_SPOOL =~ s/\.out//g;

	    my ($OUTFIL);
	    my ( $t_CHECKID, $t_DBNAME ) = split( '_-', $t_SPOOL );
	    if (defined $t_CHECKID && defined $t_DBNAME ) {
		$OUTFIL = File::Spec->catfile( $OUTPUTDIR, 'd_check' . '_'. $t_DBNAME . '.out' );

	        set_run_log($RGLOG, "$C_SPOOL -> $OUTFIL");

		open( my $OFH, ">>", "$OUTFIL" ) or die "Cannot open $OUTFIL: $!";
		open( my $SFH, "<", "$C_SPOOL" )  or die "Cannot open $C_SPOOL: $!";
		while (<$SFH>) {
		    print $OFH $_;
		}
		close($OFH);
		close($SFH);
	    }
	}
    }
    elsif ( $COMTYPE eq 'SQL_COLLECT' ) {
        foreach
          my $C_SPOOL ( glob( File::Spec->catfile( $OUTPUTDIR, "d_*$CHECKID*.out" ) ) )
        {
	    next if ($C_SPOOL !~ m/_-/);

            my ($OUTFIL) = basename $C_SPOOL;
            $OUTFIL =~ s/_-$CHECKID//g;
            $OUTFIL = File::Spec->catfile( $OUTPUTDIR, $OUTFIL );

            set_run_log($RGLOG, "$C_SPOOL -> $OUTFIL");

            open( my $OFH, ">", "$OUTFIL" ) or die "Cannot open $OUTFIL: $!";
            open( my $SFH, "<", "$C_SPOOL" )  or die "Cannot open $C_SPOOL: $!";
            while (<$SFH>) {
                print $OFH $_;
            }
            close($OFH);
            close($SFH);

	    my ($new_name) = $C_SPOOL;
	    $new_name =~ s/_-/_/g;
	    move($C_SPOOL , $new_name);
        }

        foreach
          my $C_SPOOL ( glob( File::Spec->catfile( $OUTPUTDIR, "a_*$CHECKID*.out" ) ) )
        {
	    next if ($C_SPOOL !~ m/_-/);

            my ($OUTFIL) = basename $C_SPOOL;
            $OUTFIL =~ s/_-$CHECKID//g;
            $OUTFIL = File::Spec->catfile( $OUTPUTDIR, $OUTFIL );

            set_run_log($RGLOG, "$C_SPOOL -> $OUTFIL");

            open( my $OFH, ">>", "$OUTFIL" ) or die "Cannot open $OUTFIL: $!";
            open( my $SFH, "<", "$C_SPOOL" )  or die "Cannot open $C_SPOOL: $!";
            while (<$SFH>) {
                print $OFH $_;
            }
            close($OFH);
            close($SFH);

	    my ($new_name) = $C_SPOOL;
	    $new_name =~ s/_-/_/g;
	    move($C_SPOOL , $new_name);
        }

        foreach
          my $SPOOL ( glob( File::Spec->catfile( $RTEMPDIR, "sqltorun_d_*$CHECKID*.out" ) ) )
        {
	    next if ($SPOOL !~ m/_-/);

	    my ($t_SPOOL) = basename $SPOOL;
	    $t_SPOOL =~ s/sqltorun_d_//g;
	    $t_SPOOL =~ s/\.out//g;

	    my ( $t_OUTFILNAM , $t_CHECKID, $t_DBNAME, $t_HOST ) = split( '_-', $t_SPOOL );
	    my ($OUTFIL) = File::Spec->catfile( $OUTPUTDIR, 'd_' . $t_OUTFILNAM . '_' . $t_DBNAME . '.out' );

            set_run_log($RGLOG, "$SPOOL -> $OUTFIL");

            open( my $OFH, ">", "$OUTFIL" ) or die "Cannot open $OUTFIL: $!";
            open( my $SFH, "<", "$SPOOL" )  or die "Cannot open $SPOOL: $!";
            while (<$SFH>) {
                print $OFH $_;
            }
            close($OUTFIL);
            close($SPOOL);

	    my ($new_name) = $SPOOL;
	    $new_name =~ s/_-/_/g;
	    move($SPOOL , $new_name);
        }

	if ( $CHG_USER == 1 ) {
	    if ( -d $TMP_OUTPUT ) {
        	foreach
        	  my $SPOOL ( glob( File::Spec->catfile( $TMP_OUTPUT, "sqltorun_d_*$CHECKID*.out" ) ) )
        	{
	    	    next if ($SPOOL !~ m/_-/);

		    my ($t_SPOOL) = basename $SPOOL;
		    $t_SPOOL =~ s/sqltorun_d_//g;
		    $t_SPOOL =~ s/\.out//g;

		    my ( $t_OUTFILNAM , $t_CHECKID, $t_DBNAME, $t_HOST ) = split( '_-', $t_SPOOL );
		    my ($OUTFIL) = File::Spec->catfile( $OUTPUTDIR, 'd_' . $t_OUTFILNAM . '_' . $t_DBNAME . '.out' );

        	    set_run_log($RGLOG, "$SPOOL -> $OUTFIL");

        	    open( my $OFH, ">", "$OUTFIL" ) or die "Cannot open $OUTFIL: $!";
        	    open( my $SFH, "<", "$SPOOL" )  or die "Cannot open $SPOOL: $!";
        	    while (<$SFH>) {
        	        print $OFH $_;
        	    }
        	    close($OUTFIL);
        	    close($SPOOL);

		    my ($new_name) = $SPOOL;
		    $new_name =~ s/_-/_/g;
		    move($SPOOL , $new_name);
        	}
	    }
	}
    }
    elsif ( $COMTYPE eq 'OS' ) {
        foreach
          my $O_SPOOL ( glob( File::Spec->catfile( $TMP_OUTPUT, "o_check_-*$CHECKID*.out" ) ) )
        {
	    next if ($O_SPOOL !~ m/_-/);

            my ($t_SPOOL) = basename $O_SPOOL;
            $t_SPOOL =~ s/o_check_-//g;
            $t_SPOOL =~ s/\.out//g;

            my ($OUTFIL);
            my ( $t_HOST, $t_CHECKID, $t_DBNAME ) = split( '_-', $t_SPOOL );
            if ( defined $t_HOST && defined $t_CHECKID && defined $t_DBNAME ) {
                $OUTFIL = File::Spec->catfile( $OUTPUTDIR, 'o_check' . '_'. $t_HOST . '.out' );

	        set_run_log($RGLOG, "$O_SPOOL -> $OUTFIL");

                open( my $OFH, ">>", "$OUTFIL" ) or die "Cannot open $OUTFIL: $!";
                open( my $SFH, "<", "$O_SPOOL" )  or die "Cannot open $O_SPOOL: $!";
                while (<$SFH>) {
                    print $OFH $_;
                }
                close($OFH);
                close($SFH);
            }
        }

        foreach
          my $CHK_SPOOL ( glob( File::Spec->catfile( $TMP_OUTPUT, "*_-$CHECKID*_-report.out" ) ) )
        {
	    next if ($CHK_SPOOL !~ m/_-/);

            my ($t_SPOOL) = basename $CHK_SPOOL;
            $t_SPOOL =~ s/\.out//g;
	    $t_SPOOL =~ s/_-report//g;

            my ($OUTFIL);
            my ( $t_HOST, $t_CHECKID, $t_DBNAME ) = split( '_-', $t_SPOOL );
            if ( defined $t_HOST && defined $t_CHECKID && $t_CHECKID eq $CHECKID && defined $t_DBNAME ) {
                $OUTFIL = File::Spec->catfile( $OUTPUTDIR, $t_CHECKID . '_' . $t_HOST . '_report.out' );

	        set_run_log($RGLOG, "$CHK_SPOOL -> $OUTFIL");

                open( my $OFH, ">>", "$OUTFIL" ) or die "Cannot open $OUTFIL: $!";
                open( my $SFH, "<", "$CHK_SPOOL" )  or die "Cannot open $CHK_SPOOL: $!";
                while (<$SFH>) {
                    print $OFH $_;
                }
                close($OFH);
                close($SFH);
            }
        }
        foreach
          my $O_SPOOL ( glob( File::Spec->catfile( $OUTPUTDIR, "o_check_-*$CHECKID*.out" ) ) )
        {
	    next if ($O_SPOOL !~ m/_-/);

            my ($t_SPOOL) = basename $O_SPOOL;
            $t_SPOOL =~ s/o_check_-//g;
            $t_SPOOL =~ s/\.out//g;

            my ($OUTFIL);
            my ( $t_HOST, $t_CHECKID, $t_DBNAME ) = split( '_-', $t_SPOOL );
            if ( defined $t_HOST && defined $t_CHECKID && defined $t_DBNAME ) {
                $OUTFIL = File::Spec->catfile( $OUTPUTDIR, 'o_check' . '_'. $t_HOST . '.out' );

	        set_run_log($RGLOG, "$O_SPOOL -> $OUTFIL");

                open( my $OFH, ">>", "$OUTFIL" ) or die "Cannot open $OUTFIL: $!";
                open( my $SFH, "<", "$O_SPOOL" )  or die "Cannot open $O_SPOOL: $!";
                while (<$SFH>) {
                    print $OFH $_;
                }
                close($OFH);
                close($SFH);
            }
        }

        foreach
          my $CHK_SPOOL ( glob( File::Spec->catfile( $OUTPUTDIR, "*_-$CHECKID*_-report.out" ) ) )
        {
	    next if ($CHK_SPOOL !~ m/_-/);

            my ($t_SPOOL) = basename $CHK_SPOOL;
            $t_SPOOL =~ s/\.out//g;
	    $t_SPOOL =~ s/_-report//g;

            my ($OUTFIL);
            my ( $t_HOST, $t_CHECKID, $t_DBNAME ) = split( '_-', $t_SPOOL );
            if ( defined $t_HOST && defined $t_CHECKID && $t_CHECKID eq $CHECKID && defined $t_DBNAME ) {
                $OUTFIL = File::Spec->catfile( $OUTPUTDIR, $t_CHECKID . '_' . $t_HOST . '_report.out' );

	        set_run_log($RGLOG, "$CHK_SPOOL -> $OUTFIL");

                open( my $OFH, ">>", "$OUTFIL" ) or die "Cannot open $OUTFIL: $!";
                open( my $SFH, "<", "$CHK_SPOOL" )  or die "Cannot open $CHK_SPOOL: $!";
                while (<$SFH>) {
                    print $OFH $_;
                }
                close($OFH);
                close($SFH);
            }
        }
    }
    elsif ( $COMTYPE eq 'GENERIC' ) {
        foreach
          my $SPOOL ( glob( File::Spec->catfile( $RTEMPDIR, "sqltorun_*.out" ) ) )
        {
	    next if ( $SPOOL !~ m/_-/);

            my ($t_SPOOL) = $SPOOL;
            $t_SPOOL =~ s/$RTEMPDIR\/sqltorun_//g;
            $t_SPOOL =~ s/\.out//g;

            my ($OUTFIL);
            my ( $t_CHECKID, $t_DBNAME, $t_HOST ) = split( '_-', $t_SPOOL );
                $OUTFIL = File::Spec->catfile( $OUTPUTDIR, $t_CHECKID . '_' . $t_DBNAME . '.out' );

	    set_run_log($RGLOG, "$SPOOL -> $OUTFIL");

            open( my $OFH, ">>", "$OUTFIL" ) or die "Cannot open $OUTFIL: $!";
            open( my $SFH, "<", "$SPOOL" )  or die "Cannot open $SPOOL: $!";
            while (<$SFH>) {
                print $OFH $_;
            }
            close($OUTFIL);
            close($SPOOL);
        }

	if ( $CHG_USER == 1 ) {
	    if ( -d $TMP_OUTPUT ) {
        	foreach
        	  my $SPOOL ( glob( File::Spec->catfile( $TMP_OUTPUT, "sqltorun_*.out" ) ) )
        	{
	    	    next if ( $SPOOL !~ m/_-/);

        	    my ($t_SPOOL) = $SPOOL;
        	    $t_SPOOL =~ s/$TMP_OUTPUT\/sqltorun_//g;
        	    $t_SPOOL =~ s/\.out//g;

        	    my ($OUTFIL);
        	    my ( $t_CHECKID, $t_DBNAME, $t_HOST ) = split( '_-', $t_SPOOL );
        	        $OUTFIL = File::Spec->catfile( $OUTPUTDIR, $t_CHECKID . '_' . $t_DBNAME . '.out' );

		    set_run_log($RGLOG, "$SPOOL -> $OUTFIL");

        	    open( my $OFH, ">>", "$OUTFIL" ) or die "Cannot open $OUTFIL: $!";
        	    open( my $SFH, "<", "$SPOOL" )  or die "Cannot open $SPOOL: $!";
        	    while (<$SFH>) {
        	        print $OFH $_;
        	    }
        	    close($OUTFIL);
        	    close($SPOOL);
        	}

	    }
	}
    }
}

foreach my $FILE ( glob( File::Spec->catfile( $RTEMPDIR, "*_-*" ) ) )
{
    my ($new_name) = $FILE;
    $new_name =~ s/_-/_/g;
    move($FILE , $new_name);
}

foreach my $FILE ( glob( File::Spec->catfile( $OUTPUTDIR, "*_-*" ) ) )
{
    my ($new_name) = $FILE;
    $new_name =~ s/_-/_/g;
    move($FILE , $new_name);
}

foreach my $FILE ( glob( File::Spec->catfile( $INPUTDIR, "*_-*" ) ) )
{
    my ($new_name) = $FILE;
    $new_name =~ s/_-/_/g;
    move($FILE , $new_name);
}

if ( $CHG_USER == 1 ){
    if ( -d $TMP_OUTPUT ) {
	foreach my $FILE ( glob( File::Spec->catfile( $TMP_OUTPUT, "*_-*" ) ) )
	{
	    my ($new_name) = $FILE;
	    $new_name =~ s/_-/_/g;
	    move($FILE , $new_name);
	}
    }
}

if ( $HOUSEKEEPING == 1 ) {
    housekeeping();
}

set_run_log($RGLOG , "\n----------------\n\n");
close($RGLOG);

exit(0);

