#!/usr/bin/ksh

##########  Trapping ^C(Signal 2) or kill <pid>(Signal 15)  ##########
trap trapped 2 15

### must be modify ####
export ORACLE_SID=EPP					# ΌφΑ€

##########  SCRIPT PATH  ##########
# You must modify a parameter below.
SCRIPT_PATH=/usr/openv/script

########## SCRIPT ENVIRONMENT PARAMETER ##########
# Don't modify parameters below.
X=1
MACHINE=`/usr/bin/uname -s`
NBU_PATH=/usr/openv/netbackup/bin
##LOG_PATH=${SCRIPT_PATH}/logs
LOG_PATH=/usr/openv/netbackup/logs/oralog
VAR_PATH=${SCRIPT_PATH}/vars
SQL_PATH=${SCRIPT_PATH}/sqls
CTL_PATH=${SCRIPT_PATH}/ctls
LOGFILE=${LOG_PATH}/hot_backup.log.`/usr/bin/date +%Y%m%d`

##########  THE NUMBER OF DRIVE  ##########
# You must modify a parameter below.
NUM_OF_DRV=1

##########  ORACLE DATABASE INFO  ##########
# You must modify parameters below.
DBA=oraepp
DBA_GROUP=dba
ORACLE_SID=EPP
ARCHIVE_FILE=/oracle/GRP/oraarch/*.dbf
ARC_REMAIN=0	# Remain Archivlog File
ARC_REMAIN_DATE=7

##########  VERITAS NETBACKUP POLICY INFO  ##########
# You must modify parameters below.
HOSTNAME=epprda

NAME=epprda_ORA
DBF_POLICY="${NAME}_EPP"
DBF_SCHEDULE=onback
#ARC_POLICY="${NAME}_ARCH"
#ARC_SCHEDULE="${NAME}_ARCH_D"
#ARC_SCHEDULE_DEL="${NAME}_ARCH_DEL"
CTL_POLICY="${NAME}_EPP"
CTL_SCHEDULE=ctls

HOST_TYPE=CLIENT							# SERVER or CLIENT
STORAGE_UNIT_TYPE=TAPE							# TAPE or DISK

##########  SCRIPT CONTROL PARAMETER  ###########
# You must modify parameters below.
IS_TEST=FALSE									# TRUE or FALSE
IS_PER_TABLESPACE=FALSE				# TRUE or FALSE

##########  BEGIN OF FUNCTION  ##########
trapped()
{
	echo "++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++"
	echo "+ When `/usr/bin/date '+%Y.%m.%d %H:%M:%S'`, a ^C or kill <pid> was occured!!! +" >> ${LOGFILE}
	echo "++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++"
	echo "+++ Begin Tablespace end backup by trap." >> ${LOGFILE}
	
	end_backup

	echo "+++ Completed Tablespace end backup by trap." >> ${LOGFILE}
	
	exit 1
}

initialize()
{
	if
		[[ ! -d ${LOG_PATH} ]]
	then
		mkdir ${LOG_PATH}
		chmod -R 777 ${LOG_PATH}
	else
		find  ${LOG_PATH}/* -mtime +7 -exec rm {} \;
		find  ${CTL_PATH}/* -mtime +7 -exec rm {} \;
	fi

	echo "###########################" >> ${LOGFILE}
	echo "# Begin initialize()..... #" >> ${LOGFILE}
	echo "###########################" >> ${LOGFILE}
	
	echo "Initial SQL_PATH"  >> ${LOGFILE}
	
	if
		[[ ! -d ${SQL_PATH} ]]
	then
		mkdir ${SQL_PATH}
		chmod -R 777 ${SQL_PATH}
		
		print "select 'Datafile ' || file_name from dba_data_files;" > ${SQL_PATH}/datafile.sql
		print "exit" >> ${SQL_PATH}/datafile.sql

		print "alter system archive log current;" > ${SQL_PATH}/switch_logfile.sql
		print "exit" >> ${SQL_PATH}/switch_logfile.sql

		print "select 'TBS ' || tablespace_name from dba_tablespaces where contents != 'TEMPORARY';" > ${SQL_PATH}/tbs_list.sql
		print "exit" >> ${SQL_PATH}/tbs_list.sql

		print "select distinct(t.name), b.status from v\$backup b, v\$datafile d, v\$tablespace t where d.ts# = t.ts# and d.file# = b.file# and b.status = 'ACTIVE';" > ${SQL_PATH}/vbackup.sql
		print "exit" >> ${SQL_PATH}/vbackup.sql
		
		CTL_FILE="${CTL_PATH}/controlfile.`/usr/bin/date +'%Y%m%d-%H:%M:%S'`"
		TRACE_FILE="${CTL_PATH}/tracefile.`/usr/bin/date +'%Y%m%d-%H:%M:%S'`"
		print "alter database backup controlfile to '${CTL_FILE}';" > ${SQL_PATH}/backup_ctl.sql
		print "alter database backup controlfile to trace as '${TRACE_FILE}';" >> ${SQL_PATH}/backup_ctl.sql
		print "alter database backup controlfile to trace;" >> ${SQL_PATH}/backup_ctl.sql
		print "exit" >> ${SQL_PATH}/backup_ctl.sql
	else
		CTL_FILE="${CTL_PATH}/controlfile.`/usr/bin/date +'%Y%m%d-%H:%M:%S'`"
		TRACE_FILE="${CTL_PATH}/tracefile.`/usr/bin/date +'%Y%m%d-%H:%M:%S'`"
		
		if
			[[ -f ${CTL_FILE} ]]
		then
			mv ${CTL_FILE} ${CTL_FILE}.$$
		fi
		
		print "alter database backup controlfile to '${CTL_FILE}';" > ${SQL_PATH}/backup_ctl.sql
		print "alter database backup controlfile to trace as '${TRACE_FILE}';" >> ${SQL_PATH}/backup_ctl.sql
		print "alter database backup controlfile to trace;" >> ${SQL_PATH}/backup_ctl.sql
		print "exit" >> ${SQL_PATH}/backup_ctl.sql

		print "SET VERIFY OFF" > ${SQL_PATH}/size.sql
                print "SET NEWPAGE 0" >> ${SQL_PATH}/size.sql
                print "SET SPACE 0" >> ${SQL_PATH}/size.sql
                print "SET LINESIZE 80" >> ${SQL_PATH}/size.sql
                print "SET PAGESIZE 0" >> ${SQL_PATH}/size.sql
                print "SET ECHO OFF" >> ${SQL_PATH}/size.sql
                print "SET FEEDBACK OFF" >> ${SQL_PATH}/size.sql
                print "SET HEADING OFF" >> ${SQL_PATH}/size.sql
                print "set timing off" >> ${SQL_PATH}/size.sql
                print "col file_name format a60" >> ${SQL_PATH}/size.sql
                print "select file_name, bytes/1024 from dba_data_files where status='AVAILABLE' order by bytes;" >> ${SQL_PATH}/size.sql
                print "SPOOL /usr/openv/netbackup/ext/vars/Data_Files_Size_org.log" >> ${SQL_PATH}/size.sql
                print "/" >> ${SQL_PATH}/size.sql
                print "SPOOL OFF" >> ${SQL_PATH}/size.sql
                print "SET ECHO ON" >> ${SQL_PATH}/size.sql
                print "SET FEEDBACK ON" >> ${SQL_PATH}/size.sql
                print "exit" >> ${SQL_PATH}/size.sql
	fi
	
	echo "Initial CTL_PATH"  >> ${LOGFILE}
	
	if
		[[ ! -d ${CTL_PATH} ]]
	then
		mkdir ${CTL_PATH}
		chmod -R 777 ${CTL_PATH}
	fi

	echo "Initial VAR_PATH"  >> ${LOGFILE}
	
	if
		[[ ! -d ${VAR_PATH} ]]
	then
		mkdir ${VAR_PATH}
		chmod -R 777 ${VAR_PATH}
 	else
		\rm ${VAR_PATH}/*
	fi

	echo "Initial ps option"  >> ${LOGFILE}
	
	case "${MACHINE}" in
		HP*)
				PS="/usr/bin/ps -efx"
				;;
			*)
				PS="/usr/bin/ps -ef"
				;;
	esac

	echo "Initial Storage Unit Type"  >> ${LOGFILE}
	
	case "${STORAGE_UNIT_TYPE}" in
		TAPE*)
					STU="bptm"
					;;
		DISK*)
					STU="bpdm"
					;;
	esac
	
	echo "#########################" >> ${LOGFILE}
	echo "# End initialize()..... #" >> ${LOGFILE}
	echo "#########################" >> ${LOGFILE}

	return
}

datafile_list()
{
	echo "##############################" >> ${LOGFILE}
	echo "# Begin datafile_list()..... #" >> ${LOGFILE}
	echo "##############################" >> ${LOGFILE}
	
	DBF_LIST=${VAR_PATH}/dbf.lst
	TMP_DBF_LIST=${VAR_PATH}/temp.txt
	DBFILE_QUERY=${VAR_PATH}/dbf.txt
	
	sqlplus "/ as sysdba" @${SQL_PATH}/datafile.sql > ${DBFILE_QUERY} 2>&1

	cat ${DBFILE_QUERY} >> ${LOGFILE}
	cat ${DBFILE_QUERY} | awk '$1 == "Datafile" { print $2 }' > ${DBF_LIST}

	DBF_NUM=`cat ${DBF_LIST} | wc -l`

	while 
		[[ ${DBF_NUM} -gt 0 ]]
	do
		X=1

		while 
			[[ ${X} -le ${NUM_OF_DRV} ]]
		do
			cat ${DBF_LIST} | head -1 >> ${VAR_PATH}/backuplist${X}.txt
			sed '1d' ${DBF_LIST} > ${TMP_DBF_LIST}
			cp ${TMP_DBF_LIST} ${DBF_LIST}

			X=`expr ${X} + 1`

			DBF_NUM=`cat ${DBF_LIST} | wc -l`

			if
				[[ ${DBF_NUM} -eq 0 ]]
			then
				break;
			fi
		done
	done
	
	echo "############################" >> ${LOGFILE}
	echo "# End datafile_list()..... #" >> ${LOGFILE}
	echo "############################" >> ${LOGFILE}

	return
}

vbackup_chk()
{
	echo "############################" >> ${LOGFILE}
	echo "# Begin vbackup_chk()..... #" >> ${LOGFILE}
	echo "############################" >> ${LOGFILE}
	
	TBS_STAT=${VAR_PATH}/vbackup.txt
	VBACKUP_LIST=${VAR_PATH}/vbackup.lst

	sqlplus "/ as sysdba" @${SQL_PATH}/vbackup.sql > ${TBS_STAT} 2>&1
	
	cat ${SQL_PATH}/vbackup.sql >> ${LOGFILE}
	cat ${TBS_STAT} >> ${LOGFILE}
	
	cat ${TBS_STAT} | awk '$2 == "ACTIVE" { print $1 }' > ${VBACKUP_LIST}
	cat ${VBACKUP_LIST} >> ${LOGFILE}
	
	echo "##########################" >> ${LOGFILE}
	echo "# End vbackup_chk()..... #" >> ${LOGFILE}
	echo "##########################" >> ${LOGFILE}

	return
}

begin_backup()
{
	echo "#############################" >> ${LOGFILE}
	echo "# Begin begin_backup()..... #" >> ${LOGFILE}
	echo "#############################" >> ${LOGFILE}
	
	TBS_LIST=${VAR_PATH}/tbs_list.txt
	BEGIN_BACKUP_SQL=${SQL_PATH}/begin_backup.sql

	sqlplus "/ as sysdba" @${SQL_PATH}/tbs_list.sql > ${TBS_LIST} 2>&1

	cat ${TBS_LIST} | awk '$1 == "TBS" {print $2}' | while read TBS_NAME
	do
		print "alter tablespace ${TBS_NAME} begin backup;" >> ${BEGIN_BACKUP_SQL}
	done
		
	if
		[[ ${IS_TEST} = "FALSE" ]]
	then
		print "exit" >> ${BEGIN_BACKUP_SQL}
		
		sqlplus "/ as sysdba" @${BEGIN_BACKUP_SQL} > /dev/null 2>&1
	fi

	cat ${BEGIN_BACKUP_SQL} >> ${LOGFILE}
	\rm ${BEGIN_BACKUP_SQL}
	
	echo "###########################" >> ${LOGFILE}
	echo "# End begin_backup()..... #" >> ${LOGFILE}
	echo "###########################" >> ${LOGFILE}

	return
}

end_backup()
{
	set -x
	echo "###########################" >> ${LOGFILE}
	echo "# Begin end_backup()..... #" >> ${LOGFILE}
	echo "###########################" >> ${LOGFILE}
	
	TBS_STAT=${VAR_PATH}/vbackup.txt
	VBACKUP_LIST=${VAR_PATH}/vbackup.lst
	END_BACKUP_STAT=${VAR_PATH}/end_backup.log
	END_BACKUP_SQL=${SQL_PATH}/end_backup.sql

	sqlplus "/ as sysdba" @${SQL_PATH}/vbackup.sql > ${TBS_STAT} 2>&1
	
	cat ${SQL_PATH}/vbackup.sql >> ${LOGFILE}
	cat ${TBS_STAT} >> ${LOGFILE}

	cat ${TBS_STAT} | awk '$2 == "ACTIVE" { print $1 }' > ${VBACKUP_LIST}
	cat ${VBACKUP_LIST} >> ${LOGFILE}	

	NUM_OF_ACT=`cat ${VBACKUP_LIST} | wc -l`

	while
		[[ ${NUM_OF_ACT} -gt 0 ]]
	do
		print "alter tablespace `cat ${VBACKUP_LIST} | head -1 ` end backup;" >> ${END_BACKUP_SQL}

		sed '1d' ${VBACKUP_LIST} > ${VAR_PATH}/temp.txt
		cp ${VAR_PATH}/temp.txt ${VBACKUP_LIST}

		NUM_OF_ACT=`cat ${VBACKUP_LIST} | wc -l`
	done

	if
		[[ -f ${END_BACKUP_SQL} ]]
	then
		#print "exit" >> ${END_BACKUP_STAT}
		print "exit" >> ${END_BACKUP_SQL}
		
		echo "Begin Tablespace end backup marking....." >> ${LOGFILE}
		
		sqlplus "/ as sysdba" @${END_BACKUP_SQL} > ${END_BACKUP_STAT} 2>&1

		cat ${END_BACKUP_SQL} >> ${LOGFILE}
		cat ${END_BACKUP_STAT} >> ${LOGFILE}
				
		echo "End Tablespace end backup marking....." >> ${LOGFILE}

		\rm ${END_BACKUP_SQL}
	fi
	
	echo "#########################" >> ${LOGFILE}
	echo "# End end_backup()..... #" >> ${LOGFILE}
	echo "#########################" >> ${LOGFILE}

	return
}

bpbackup_start()
{
	echo "###############################" >> ${LOGFILE}
	echo "# Begin bpbackup_start()..... #" >> ${LOGFILE}
	echo "###############################" >> ${LOGFILE}
	
	X=1
	
	if
		[[ ${NUM_OF_DRV} -eq 1 ]]
	then
		if 
			[[ -f ${VAR_PATH}/backuplist${X}.txt ]]
		then
			if
				[[ ${IS_TEST} = "FALSE" ]]
			then
				print "${NBU_PATH}/bpbackup -p ${DBF_POLICY} -s ${DBF_SCHEDULE} -h ${HOSTNAME} -t 0 -w 0 -f ${VAR_PATH}/backuplist${X}.txt -L ${LOGFILE}" >> ${LOGFILE}
				${NBU_PATH}/bpbackup -p ${DBF_POLICY} -s ${DBF_SCHEDULE} -h ${HOSTNAME} -t 0 -w 0 -f ${VAR_PATH}/backuplist${X}.txt -L ${LOGFILE} 2>&1
			else
				print "${NBU_PATH}/bpbackup -p ${DBF_POLICY} -s ${DBF_SCHEDULE} -h ${HOSTNAME} -t 0 -w 0 -f ${VAR_PATH}/backuplist${X}.txt -L ${LOGFILE}" >> ${LOGFILE}
			fi
		fi
	else
		while
			[[ ${X} -le ${NUM_OF_DRV} ]]
		do
			if 
				[[ -f ${VAR_PATH}/backuplist${X}.txt ]]
			then
				if
					[[ ${IS_TEST} = "FALSE" ]]
				then
					print "${NBU_PATH}/bpbackup -p ${DBF_POLICY} -s ${DBF_SCHEDULE} -h ${HOSTNAME} -t 0 -f ${VAR_PATH}/backuplist${X}.txt -L ${LOGFILE}" >> ${LOGFILE}
					${NBU_PATH}/bpbackup -p ${DBF_POLICY} -s ${DBF_SCHEDULE} -h ${HOSTNAME} -t 0 -f ${VAR_PATH}/backuplist${X}.txt -L ${LOGFILE} 2>&1
				else
					print "${NBU_PATH}/bpbackup -p ${DBF_POLICY} -s ${DBF_SCHEDULE} -h ${HOSTNAME} -t 0 -f ${VAR_PATH}/backuplist${X}.txt -L ${LOGFILE}" >> ${LOGFILE}
				fi			
			fi

			X=`expr ${X} + 1`
		done
	fi
	
	if
		[[ ${IS_TEST} = "FALSE" && ${NUM_OF_DRV} -gt 1 ]]
	then
			sleep 120
	fi
	
	echo "#############################" >> ${LOGFILE}
	echo "# End bpbackup_start()..... #" >> ${LOGFILE}
	echo "#############################" >> ${LOGFILE}

	return
}

chk_backup_stat()
{
	echo "################################" >> ${LOGFILE}
	echo "# Begin chk_backup_stat()..... #" >> ${LOGFILE}
	echo "################################" >> ${LOGFILE}
	
	if
		[[ ${IS_TEST} = "FALSE" ]]
	then
		while true
		do
			if
				[[ "${HOST_TYPE}" = "SERVER" ]]
			then
					BACKUP_STAT=`${PS} | grep ${STU} | grep -v grep | grep ${DBF_POLICY} | wc -l`
			elif
				[[ "${HOST_TYPE}" = "CLIENT" ]]
			then
					BACKUP_STAT=`${PS} | grep bpbkar | grep -v grep | grep ${DBF_POLICY} | wc -l`
			fi

			if
				[[ ${BACKUP_STAT} -eq 0 ]]
			then
				echo "Backup Job was Completed !!!" >> ${LOGFILE}
				break;
			else
				echo "Backup Job is running !!!" >> ${LOGFILE}
				sleep 15
			fi
		done
	else
		echo "Testing..." >> ${LOGFILE}
	fi
	
	echo "##############################" >> ${LOGFILE}
	echo "# End chk_backup_stat()..... #" >> ${LOGFILE}
	echo "##############################" >> ${LOGFILE}

	return
}

backup_per_tbs()
{
	echo "###############################" >> ${LOGFILE}
	echo "# Begin backup_per_tbs()..... #" >> ${LOGFILE}
	echo "###############################" >> ${LOGFILE}
	
	TBS_LIST=${VAR_PATH}/tbs.lst
	TMP_SQL_PATH=${SQL_PATH}/TMP
	TMP_VAR_PATH=${VAR_PATH}/TMP
	TMP_LST=${TMP_VAR_PATH}/temp.txt

	if
		[[ ! -d ${TMP_SQL_PATH} ]]
	then
		mkdir ${TMP_SQL_PATH}
		chmod -R 777 ${TMP_SQL_PATH}
	else
		\rm ${TMP_SQL_PATH}/*		
	fi

	if
		[[ ! -d ${TMP_VAR_PATH} ]]
	then
		mkdir ${TMP_VAR_PATH}
		chmod -R 777 ${TMP_VAR_PATH}
	else
		\rm ${TMP_VAR_PATH}/*		
	fi

	sqlplus "/ as sysdba" @${SQL_PATH}/tbs_list.sql > ${TBS_LIST} 2>&1
	cat ${TBS_LIST} >> ${LOGFILE}

	cat ${TBS_LIST} | awk '$1 == "TBS" {print $2}' | while read TBS_NAME
	do
		GET_DBF_SQL=${TMP_SQL_PATH}/${TBS_NAME}_dbf.sql
		TBS_DBF_LST=${TMP_VAR_PATH}/${TBS_NAME}_dbf.lst
		TMP_TBS_DBF_LST=${TMP_VAR_PATH}/TMP_${TBS_NAME}_dbf.lst
		BEGIN_TBS=${TMP_SQL_PATH}/begin_${TBS_NAME}.sql
		END_TBS=${TMP_SQL_PATH}/end_${TBS_NAME}.sql
		
		print "alter tablespace ${TBS_NAME} begin backup;" > ${BEGIN_TBS}
		print "exit" >> ${BEGIN_TBS}
		
		print "alter tablespace ${TBS_NAME} end backup;" > ${END_TBS}
		print "exit" >> ${END_TBS}
		
		print "select 'Datafile ' || file_name from dba_data_files where tablespace_name = '${TBS_NAME}';" > ${GET_DBF_SQL}
		print "exit" >> ${GET_DBF_SQL}

		/kli_appl/appl/oracle/bin/sqlplus "/ as sysdba" @${GET_DBF_SQL} > ${TMP_TBS_DBF_LST} 2>&1
		
		cat ${TMP_TBS_DBF_LST} | awk '$1 == "Datafile" { print $2 }' > ${TBS_DBF_LST}
		
		DBF_NUM=`cat ${TBS_DBF_LST} | wc -l`

		while 
			[[ ${DBF_NUM} -gt 0 ]]
		do
			X=1

			while 
				[[ ${X} -le ${NUM_OF_DRV} ]]
			do
				cat ${TBS_DBF_LST} | head -1 >> ${VAR_PATH}/backuplist${X}.txt
				sed '1d' ${TBS_DBF_LST} > ${TMP_LST}
				cp ${TMP_LST} ${TBS_DBF_LST}

				X=`expr ${X} + 1`

				DBF_NUM=`cat ${TBS_DBF_LST} | wc -l`

				if
					[[ ${DBF_NUM} -eq 0 ]]
				then
					break;
				fi				
			done
		done
		
		if
			[[ ${IS_TEST} = "FALSE" ]]
		then
			cat ${BEGIN_TBS}>> ${LOGFILE}
			sqlplus "/ as sysdba" @${BEGIN_TBS} > /dev/null 2>&1
		else
			cat ${BEGIN_TBS}>> ${LOGFILE}
		fi

		bpbackup_start			### DATAFILE BACKUP START
		chk_backup_stat			### CHECK BACKUP STATUS
	
		if
			[[ ${IS_TEST} = "FALSE" ]]
		then
			cat ${END_TBS} >> ${LOGFILE}
			sqlplus "/ as sysdba" @${END_TBS} > /dev/null 2>&1
		else
			cat ${END_TBS} >> ${LOGFILE}
		fi
		
		\rm ${VAR_PATH}/backuplist*.txt
		\rm ${TMP_VAR_PATH}/*
		\rm ${TMP_SQL_PATH}/*
	done
	
	\rm -rf ${TMP_VAR_PATH}
	\rm -rf ${TMP_SQL_PATH}
	
	echo "#############################" >> ${LOGFILE}
	echo "# End backup_per_tbs()..... #" >> ${LOGFILE}
	echo "#############################" >> ${LOGFILE}

	return
}

switch_logfile()
{
	echo "###############################" >> ${LOGFILE}
	echo "# Begin switch_logfile()..... #" >> ${LOGFILE}
	echo "###############################" >> ${LOGFILE}
	
	SWITCH_LOG=${VAR_PATH}/switch_logfile.txt

	if
		[[ ${IS_TEST} = "FALSE" ]]
	then
		sqlplus "/ as sysdba" @${SQL_PATH}/switch_logfile.sql > ${SWITCH_LOG} 2>&1
		
		cat ${SQL_PATH}/switch_logfile.sql >> ${LOGFILE}
		cat ${SWITCH_LOG} >> ${LOGFILE}
		sleep 10
	else
		cat ${SQL_PATH}/switch_logfile.sql >> ${LOGFILE}
	fi
	
	echo "#############################" >> ${LOGFILE}
	echo "# End switch_logfile()..... #" >> ${LOGFILE}
	echo "#############################" >> ${LOGFILE}

	return
}

backup_archivelog()
{
	echo "##################################" >> ${LOGFILE}
	echo "# Begin backup_archivelog()..... #" >> ${LOGFILE}
	echo "##################################" >> ${LOGFILE}
	
	ls -ltr ${ARCHIVE_FILE} > ${VAR_PATH}/archivefile.txt
	COUNT=`cat ${VAR_PATH}/archivefile.txt | wc -l`

	COUNT=`expr ${COUNT} - ${ARC_REMAIN}`

	cat ${VAR_PATH}/archivefile.txt | head -${COUNT} | awk '{ print $9 }' > ${VAR_PATH}/archivefile.lst

	cat ${VAR_PATH}/archivefile.lst >> ${LOGFILE}

	if
		[[ ${IS_TEST} = "FALSE" ]]
	then
		print "${NBU_PATH}/bpbackup -p ${ARC_POLICY} -s ${ARC_SCHEDULE} -h ${HOSTNAME} -t 0 -w 0 -f ${VAR_PATH}/archivefile.lst -L ${LOGFILE}" >> ${LOGFILE}
		${NBU_PATH}/bpbackup -p ${ARC_POLICY} -s ${ARC_SCHEDULE} -h ${HOSTNAME} -t 0 -w 0 -f ${VAR_PATH}/archivefile.lst -L ${LOGFILE} 2>&1
	else
		print "${NBU_PATH}/bpbackup -p ${ARC_POLICY} -s ${ARC_SCHEDULE} -h ${HOSTNAME} -t 0 -w 0 -f ${VAR_PATH}/archivefile.lst -L ${LOGFILE}" >> ${LOGFILE}
	fi
	
	echo "################################" >> ${LOGFILE}
	echo "# End backup_archivelog()..... #" >> ${LOGFILE}
	echo "################################" >> ${LOGFILE}

	ls -t ${ARCHIVE_FILE} | tail +3 > ${VAR_PATH}/archivefile_del.txt
	cat ${VAR_PATH}/archivefile_del.txt > ${VAR_PATH}/archivefile_del.lst
	cat ${VAR_PATH}/archivefile_del.lst >> ${LOGFILE}
		${NBU_PATH}/bparchive -p ${ARC_POLICY} -s ${ARC_SCHEDULE_DEL} -h ${HOSTNAME} -t 0 -w 0 -f ${VAR_PATH}/archivefile_del.lst -L ${LOGFILE} 2>&1

	return
}

backup_controlfile()
{
	echo "###################################" >> ${LOGFILE}
	echo "# Begin backup_controlfile()..... #" >> ${LOGFILE}
	echo "###################################" >> ${LOGFILE}
	
	CTL_LOG=${VAR_PATH}/ctl_log.txt
	
	if
		[[ ${IS_TEST} = "FALSE" ]]
	then
		sqlplus "/ as sysdba" @${SQL_PATH}/backup_ctl.sql > ${CTL_LOG} 2>&1

		cat ${SQL_PATH}/backup_ctl.sql >> ${LOGFILE}
		
		cat ${CTL_LOG} >> ${LOGFILE}

		print "${NBU_PATH}/bpbackup -p ${CTL_POLICY} -s ${CTL_SCHEDULE} -h ${HOSTNAME} -t 0 -w 0 -L ${LOGFILE} ${CTL_PATH}" >> ${LOGFILE}
		${NBU_PATH}/bpbackup -p ${CTL_POLICY} -s ${CTL_SCHEDULE} -h ${HOSTNAME} -t 0 -w 0 -L ${LOGFILE} ${CTL_PATH} 2>&1
	else
		cat ${SQL_PATH}/backup_ctl.sql >> ${LOGFILE}
		print "${NBU_PATH}/bpbackup -p ${CTL_POLICY} -s ${CTL_SCHEDULE} -h ${HOSTNAME} -t 0 -w 0 -L ${LOGFILE} ${CTL_PATH}" >> ${LOGFILE}
	fi
	
	echo "#################################" >> ${LOGFILE}
	echo "# End backup_controlfile()..... #" >> ${LOGFILE}
	echo "#################################" >> ${LOGFILE}
	
	return
}

make_datafile_size()
{
set -x
count=1;                                                  export count;
start_line=1;                                             export start_line;
start_line_sum=0;                                         export start_line;
end_line=0;                                               export end_line;
size_mod=0;                                               export size_mod;
size_part=0;                                              export size_part;
size_part_sum=0;                                          export size_part_sum;
size_sum=0;                                               export size_sum;
count_num=1;                                              export count_num;
count_reverse=0;                                          export count_reverse;

# { Making DataFile List Order by Size } #

sqlplus "/ as sysdba" @${SQL_PATH}/size.sql > ${DBFILE_QUERY} 2>&1

/bin/cat ${VAR_PATH}/Data_Files_Size_org.log | grep -v "SQL" > ${VAR_PATH}/Data_Files_Size.log
/bin/cat ${VAR_PATH}/Data_Files_Size.log | while read Filename Filesize

do
 size_sum=`expr $size_sum + $Filesize`
done
 size_mod=`expr $size_sum / $NUM_OF_DRV`

/bin/cat ${VAR_PATH}/Data_Files_Size.log | while read Filename Filesize
do
  size_part=`expr $size_part_sum + $size_part + $Filesize`
  size_part_sum=0
  if [ $count -lt $NUM_OF_DRV ]
    then
    if [ $size_part -le $size_mod ]
     then
       end_line=`expr $end_line + 1`
     else
       tail +$start_line ${VAR_PATH}/Data_Files_Size.log | head -$end_line | awk '{print $2}' > ${VAR_PATH}/Data_Files_tmp$count.log
        count=`expr $count + 1`
        size_part_sum=$Filesize
        size_part=0
        start_line_sum=`expr $start_line_sum + $end_line`
        start_line=`expr $start_line_sum + 1`
        end_line=1
     fi
  fi
 tail +$start_line ${VAR_PATH}/Data_Files_Size.log | awk '{print $2}' > ${VAR_PATH}/Data_Files_tmp$count.log
done
}
##########  END OF FUNCTION  ##########

##########  MAIN  ##########
initialize
end_backup

if
	[[ ${IS_PER_TABLESPACE} = "TRUE" ]]
then
	backup_per_tbs
else
	datafile_list
	begin_backup
#	make_datafile_size
	bpbackup_start
	chk_backup_stat
	end_backup
fi

switch_logfile
#backup_archivelog
backup_controlfile
########## END OF SCRIPT ##########