668 lines
21 KiB
PHP
Executable File
668 lines
21 KiB
PHP
Executable File
<?php
|
|
GLOBAL $webDir, $APPDIR, $currentFilePath;
|
|
include('sqliteDB.php');
|
|
include('generateRestoresetFiles.php');
|
|
|
|
if(extension_loaded('pcntl') && function_exists('pcntl_signal')) {
|
|
// Subroutine that processes SIGINT and SIGTERM signal received by the script during restore
|
|
declare(ticks = 1);
|
|
pcntl_signal(SIGTERM, 'process_term');// Termination ('kill' was called)
|
|
pcntl_signal(SIGINT, 'process_term'); // Interrupted (Ctrl-C is pressed)
|
|
}
|
|
|
|
#create pid.txt if required.
|
|
createPid($taskType);
|
|
$operationName = RESTORE;
|
|
|
|
# machine state handling
|
|
$evspid = 0;
|
|
$opprocpid = 0;
|
|
$issignal = FALSE;
|
|
# pre cleanup intermediate file and folder.
|
|
removeRestoreTempFiles();
|
|
checkBinaryExists();
|
|
createLogFiles($outputFileName);
|
|
writeLogHeader();
|
|
|
|
$restoreSetEmpty = checkIfSetEmpty($restoreDisplayPath);
|
|
if($restoreSetEmpty) {
|
|
if(!($logOutputHandle = fopen($logOutputFilePath,"a"))){
|
|
traceLog("Could not open file $logOutputFilePath, Reason:".customErrorMsg().LINEFEED);
|
|
exit_cleanup();
|
|
}
|
|
fwrite($logOutputHandle, "Your Restore set is empty.".LINEFEED);
|
|
fclose($logOutputHandle);
|
|
exit_cleanup();
|
|
}
|
|
|
|
$exec_cores = getSystemCpuCores();
|
|
startRestore();
|
|
waitForEnginesToFinish();
|
|
|
|
if($errStr != "")
|
|
writeOperationErrorToErrorFile($errStr);
|
|
exit_cleanup();
|
|
|
|
|
|
#******************************************************************************************************************
|
|
# Subroutine Name : writeLogHeader.
|
|
# Objective : This subroutine construct log header message and return constructed message.
|
|
# Added By : Vijay Vinoth
|
|
#******************************************************************************************************************/
|
|
function writeLogHeader()
|
|
{
|
|
GLOBAL $headerMsg, $logOutputFilePath, $nasUsername;
|
|
GLOBAL $username, $hostName;
|
|
$errStr = '';
|
|
|
|
# added by anil for log related issues
|
|
verifyLastUserLog(LOGPIDFILE);
|
|
|
|
# require to open log file to show job in progress as well as to log exclude details
|
|
$logOutputHandle = fopen($logOutputFilePath, 'a+');
|
|
|
|
if($logOutputHandle)
|
|
{
|
|
# As log file is opened so create logpid file as well
|
|
$currPath = trim(getcwd());
|
|
if(file_put_contents(LOGPIDFILE,"$currPath/$logOutputFilePath"))
|
|
chmod(LOGPIDFILE,PERMISSIONVAL);
|
|
else {
|
|
$errStr = "Unable to open file ".LOGPIDFILE.", Reason:".customErrorMsg();
|
|
fwrite($logOutputHandle,$errStr.PHP_EOL);
|
|
fclose($logOutputHandle);
|
|
traceLog($errStr);
|
|
exit_cleanup();
|
|
}
|
|
chmod($logOutputFilePath,PERMISSIONVAL);
|
|
}
|
|
else {
|
|
$errStr = "Failed to create $logOutputFilePath, Reason:".customErrorMsg();
|
|
traceLog($errStr);
|
|
exit_cleanup();
|
|
}
|
|
|
|
//$headerMsg = "Restore Start Time: ".WHITESPACE.date("D M d H:i:s Y").LINEFEED;
|
|
$headerMsg = "Restore Start Time: ".WHITESPACE.trim(shell_exec('date +"%a %b %d %T %Y"')).LINEFEED;
|
|
$logheader = $headerMsg.LINEFEED."NAS User name: ".$nasUsername.LINEFEED;
|
|
$logheader .= "IDrive User name: ".$username.LINEFEED;
|
|
|
|
$headerMsg .= getHeaderMsg();
|
|
$headerMsg .= "Restore Location: $hostName".LINEFEED;
|
|
|
|
$logheader .= getHeaderMsg();
|
|
$logheader .= "Restore Location: $hostName".LINEFEED.LINEFEED;
|
|
|
|
# write log header.
|
|
fwrite($logOutputHandle,$logheader.PHP_EOL);
|
|
if($logOutputHandle)
|
|
fclose($logOutputHandle);
|
|
}
|
|
|
|
#****************************************************************************************************
|
|
# Subroutine Name : startRestore.
|
|
# Objective : Start restore operation by reading the content of info_file.
|
|
# The info_file is getting created and written by generateRestoresetFiles()
|
|
# subroutine. Check the retry condition and perform retry to restore,
|
|
# if needed.
|
|
# Added By : Avinash Kumar.
|
|
#*****************************************************************************************************/
|
|
function startRestore($startRestoreInitiateVar = 0)
|
|
{
|
|
GLOBAL $retrycount,$totalEngineRestore, $totalFiles, $startRestore, $failedfiles_index, $current_source, $processName;
|
|
GLOBAL $jobrunningDir, $statusFileHash, $exec_cores, $phpPath, $webDir, $APPDIR, $logOutputFilePath, $RestoreForkchilds;
|
|
$engineID = 1;
|
|
if($startRestoreInitiateVar == 0){
|
|
# creating temp folder for storing intermediate restore set files and info file
|
|
if(!is_dir(TEMP_FILES)){
|
|
if(!mkdir(TEMP_FILES)){
|
|
$errStr = "Unable to create directory ".TEMP_FILES.", Reason:".customErrorMsg();
|
|
exitError($errStr);
|
|
}
|
|
@chmod(TEMP_FILES,PERMISSIONVAL);
|
|
}
|
|
|
|
file_put_contents(ENGINE_LOCKE_FILE,"");
|
|
@chmod(ENGINE_LOCKE_FILE,PERMISSIONVAL);
|
|
|
|
$ourFileHandle = fopen(INFOFILE, 'w+');
|
|
if(!$ourFileHandle){
|
|
$errStr = "Could not open file ".INFOFILE." to write, Reason:".customErrorMsg();
|
|
traceLog($errStr);
|
|
return;
|
|
}
|
|
@chmod(INFOFILE,PERMISSIONVAL);
|
|
fclose($ourFileHandle);
|
|
|
|
if( extension_loaded('pcntl') && function_exists('pcntl_fork') ){
|
|
$pidGen = pcntl_fork();
|
|
if($pidGen == -1){
|
|
$errStr = "Unable to start generateRestoresetFiles operation";
|
|
traceLog($errStr);
|
|
return;
|
|
}
|
|
|
|
if($pidGen == 0){
|
|
$processName = "generate";
|
|
generateRestoresetFiles();
|
|
if($dbh_LB) {
|
|
unset($dbh_LB);
|
|
}
|
|
exit;
|
|
}
|
|
} else {
|
|
$forkProcessPath = $webDir.PATHSEPARATOR.APPDIR.PATHSEPARATOR.SCRIPTS.PATHSEPARATOR.FORKPROCESSFILE;
|
|
$cmd = "$phpPath $forkProcessPath 'restore' '$logOutputFilePath'";
|
|
$pidGen = exec("$cmd > /dev/null 2>".EXEC_ERRORFILE." & echo $!");
|
|
}
|
|
}
|
|
$fdRead = fopen(INFOFILE,"r+");
|
|
if(!$fdRead){
|
|
$errStr = "Could not open file ".INFOFILE." to read, Reason:".customErrorMsg();
|
|
traceLog($errStr);
|
|
return;
|
|
}
|
|
|
|
while (1)
|
|
{
|
|
if(!file_exists(PIDFILE))
|
|
break;
|
|
|
|
if(empty($line))
|
|
$line = fgets($fdRead);
|
|
|
|
if(empty($line)){
|
|
sleep(1);
|
|
fseek($fdRead, 0, 1); #to clear eof flag
|
|
continue;
|
|
}
|
|
|
|
if(preg_match('/^TOTALFILES/', $line) === 1)
|
|
{
|
|
$lineSplit = explode(' ', $line,2);
|
|
$totalFiles = trim($lineSplit[1]);
|
|
$line = "";
|
|
sleep(2);
|
|
break;
|
|
}
|
|
|
|
$line = trim($line);
|
|
if(($totalEngineRestore > 1) && extension_loaded('pcntl') && function_exists('pcntl_fork'))
|
|
{
|
|
$retVal = isEngineRunning(PIDFILE."_$engineID");
|
|
if($retVal === false){
|
|
if(isAnyEngineRunning(ENGINE_LOCKE_FILE)){
|
|
#check if any engine is running if running then check down code block or skip
|
|
while(1){
|
|
if(!file_exists(PIDFILE) or !isAnyEngineRunning(ENGINE_LOCKE_FILE))
|
|
break;
|
|
|
|
$exec_loads = sys_getloadavg();
|
|
if($exec_loads[1] > $exec_cores){
|
|
sleep(20);
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
if(!file_exists(PIDFILE))
|
|
break;
|
|
|
|
if($failedfiles_index != -1) {
|
|
$failedfiles_index++;
|
|
if($failedfiles_index > 2000000000){
|
|
$failedfiles_index = 0;
|
|
}
|
|
}
|
|
|
|
$pid_generate_doRestore = pcntl_fork();
|
|
if($pid_generate_doRestore == -1){
|
|
$errStr = "Unable to start doRestoreOperation. Reason:".customErrorMsg();
|
|
exit_cleanup();
|
|
}
|
|
else if ($pid_generate_doRestore == 0) # this child process will create all backup set files with 1000-1000 files set
|
|
{
|
|
$processName = 'dorestore';
|
|
doRestoreOperation($line,$engineID,$failedfiles_index);
|
|
exit;
|
|
}
|
|
else{
|
|
$RestoreForkchilds[] = $pid_generate_doRestore;
|
|
if(isset($exec_loads[1]) && ($exec_loads[1] > $exec_cores))
|
|
sleep(2);
|
|
else
|
|
sleep(1);
|
|
}
|
|
$line = "";
|
|
}
|
|
|
|
$engineID++;
|
|
if($engineID > $totalEngineRestore){
|
|
$engineID = 1;
|
|
sleep(2);
|
|
}
|
|
foreach($RestoreForkchilds as $key => $pid) {
|
|
$res = pcntl_waitpid($pid, $status, WNOHANG);
|
|
|
|
// If the process has already exited
|
|
if($res == -1 || $res > 0){
|
|
unset($RestoreForkchilds[$key]);
|
|
}
|
|
}
|
|
}
|
|
else{
|
|
if($failedfiles_index != -1) {
|
|
$failedfiles_index++;
|
|
if($failedfiles_index > 2000000000){
|
|
$failedfiles_index = 0;
|
|
}
|
|
}
|
|
doRestoreOperation($line,1,$failedfiles_index);
|
|
$line = "";
|
|
}
|
|
}
|
|
|
|
waitForProcess($pidGen,NOSCANERRORFILE);
|
|
waitForEnginesToFinish();
|
|
|
|
$line = fgets($fdRead);
|
|
if(preg_match('/^FAILEDCOUNT/', $line) === 1){
|
|
$lineSplit = explode(' ', $line,2);
|
|
$failedFilesCount = trim($lineSplit[1]);
|
|
}
|
|
fclose($fdRead);
|
|
|
|
if($totalFiles == 0){
|
|
$fdRead = fopen(INFOFILE,"r");
|
|
if(!$fdRead){
|
|
$errStr = "Could not open file ".INFOFILE." to read, Reason:".customErrorMsg();
|
|
traceLog($errStr);
|
|
return;
|
|
}
|
|
|
|
fclose($fdRead);
|
|
$file_content = file(INFOFILE);
|
|
|
|
foreach($file_content as $file_content_data)
|
|
{
|
|
if(preg_match('/^TOTALFILES/', $file_content_data) === 1){
|
|
$split_totalFiles = explode(' ',$file_content_data,2);
|
|
$totalFiles = trim($split_totalFiles[1]);
|
|
}
|
|
|
|
if(preg_match('/^FAILEDCOUNT/', $file_content_data) === 1){
|
|
$lineSplit = explode(' ', $file_content_data,2);
|
|
$failedFilesCount = trim($lineSplit[1]);
|
|
}
|
|
}
|
|
|
|
if($totalFiles == 0)
|
|
traceLog("Unable to find total file count from info file.");
|
|
}
|
|
|
|
if(file_exists(RETRY_INFOFILE) && @customFileSize(RETRY_INFOFILE) > 0 && $retrycount < MAX_RETRY && file_exists(PIDFILE))
|
|
{
|
|
rename(RETRY_INFOFILE, INFOFILE);
|
|
if (file_exists(INFOFILE))
|
|
{
|
|
$fd_write = fopen(INFOFILE, 'a');
|
|
if(!$fd_write){
|
|
$errStr = "Could not open file ".INFOFILE." to read in retry case, Reason:".customErrorMsg();
|
|
traceLog($errStr);
|
|
return;
|
|
}
|
|
fwrite($fd_write, "TOTALFILES $totalFiles\n FAILEDCOUNT $failedFilesCount");
|
|
fclose($fd_write);
|
|
@chmod(INFOFILE,PERMISSIONVAL);
|
|
}
|
|
|
|
updateRetryCount();
|
|
if($retrycount == MAX_RETRY - 1)
|
|
$failedfiles_index = -1;
|
|
|
|
startRestore(1);
|
|
}
|
|
}
|
|
|
|
#****************************************************************************************************
|
|
# Subroutine Name : doRestoreOperation.
|
|
# Objective : This subroutine performs the actual task of backing up files. It creates
|
|
# a child process which executes the restore command. It also creates a process
|
|
# which continuously monitors the temporary output file. At the end of restore,
|
|
# it inspects the temporary error file if present. It then deletes the temporary
|
|
# output file, temporary error file and the temporary directory created by
|
|
# idevsutil binary.
|
|
# Modified By : Vijay Vinoth, Sabin Cheruvattil
|
|
#*****************************************************************************************************/
|
|
function doRestoreOperation($line, $engineID, $failedfiles_index)
|
|
{
|
|
GLOBAL $isLocalRestore, $idevsutilBinaryPath, $dedupDetailFile, $webDir, $phpPath, $localBackupLocationFile, $logOutputFilePath, $filesonly, $operationStartTimeRestore;
|
|
GLOBAL $errStr, $restoreUtfFile, $retrycount, $hostNameLB, $username, $evspid, $opprocpid;
|
|
$pid_OutputProcess = '';
|
|
|
|
$startPidFileLock = fopen(ENGINE_LOCKE_FILE, 'a+');
|
|
$locked = flock($startPidFileLock, LOCK_SH|LOCK_NB);
|
|
// Creating PID based on engine
|
|
$engineFp = fopen(PIDFILE."_$engineID", 'w+');
|
|
fwrite($engineFp," ");
|
|
$isLocked = flock($engineFp, LOCK_EX|LOCK_NB);
|
|
if(!$isLocked){
|
|
return;
|
|
}
|
|
@chmod(PIDFILE."_$engineID",PERMISSIONVAL);
|
|
|
|
$opType = RESTORE;
|
|
$parameters = $line;
|
|
$parameter_list = explode(' ', $parameters, SPLIT_LIMIT_INFO_LINE);
|
|
$source = '';
|
|
|
|
if($isLocalRestore == 1){
|
|
$opType = LOCALRESTORE;
|
|
if(file_exists($localBackupLocationFile) && file_exists($dedupDetailFile)){
|
|
$dbpaths = $hostNameLB.'/'.$username.'/dbpaths.xml';
|
|
$serverRoot = getServerRoot($dbpaths,$localBackupLocationFile);
|
|
$source = isset($parameter_list[2])?'/'.$serverRoot:'/'.'/'.$serverRoot;
|
|
}
|
|
}
|
|
|
|
if($source == '')
|
|
$source = isset($parameter_list[2])?$parameter_list[2]:'/';
|
|
|
|
$restoreUtfFile = getOperationFile(array("opType" => $opType,
|
|
"backupsetFile" => $parameter_list[0],
|
|
"backupType" => $parameter_list[1],
|
|
"source" => $source,
|
|
"engineID" => $engineID));
|
|
# EVS command to execute for restore
|
|
$idevsutilCommandLine = $idevsutilBinaryPath.WHITESPACE.IDEVSUTIL_ARG.ASSIGNMENTOP."\"$restoreUtfFile\"";
|
|
if(file_exists(PIDFILE)) {
|
|
$pid = exec("$idevsutilCommandLine > /dev/null 2>".EXEC_ERRORFILE." & echo $!");
|
|
$evspid = $pid;
|
|
# restore child process for output file parsing
|
|
$fileChildProcessPath = $webDir.PATHSEPARATOR.APPDIR.PATHSEPARATOR.SCRIPTS.PATHSEPARATOR.RESTORE_CHILDPROCESSFILE;
|
|
|
|
# fix for source which contains special characters like "", '' etc.
|
|
if($retrycount == 0)
|
|
$source = preg_quote($source);
|
|
$childCmd = "$phpPath $fileChildProcessPath \"$logOutputFilePath\" \"$parameter_list[0]\" \"$parameter_list[1]\" \"$source\" \"$filesonly\" \"$operationStartTimeRestore\" \"$engineID\" \"$failedfiles_index\" > /dev/null 2>".EXEC_ERRORFILE." & echo $!";
|
|
$pid_OutputProcess = exec($childCmd);
|
|
$opprocpid = $pid_OutputProcess;
|
|
waitForEVS($pid, SCANERRORFILE, $engineID);
|
|
$evspid = 0;
|
|
}
|
|
|
|
# update server address if cmd failed due to wrong evs server address
|
|
checkErrorAndUpdateServerAddr("_$engineID");
|
|
$outputFile = fopen(OUTPUTFILE."_$engineID", 'a+');
|
|
if($outputFile) {
|
|
fwrite($outputFile,"CHILD_PROCESS_COMPLETED".PHP_EOL);
|
|
fclose($outputFile);
|
|
} else {
|
|
traceLog("Unable to open file ".OUTPUTFILE.", Reason: ".customErrorMsg());
|
|
@unlink(UTFFILE."_$engineID");
|
|
fclose($engineFp);
|
|
@unlink(PIDFILE."_$engineID");
|
|
flock($startPidFileLock, LOCK_UN);
|
|
fclose($startPidFileLock);
|
|
return 0;
|
|
}
|
|
|
|
if($pid_OutputProcess != '') {
|
|
waitForEVS($pid_OutputProcess, NOSCANERRORFILE);
|
|
$opprocpid = 0;
|
|
}
|
|
|
|
@unlink(UTFFILE."_$engineID");
|
|
fclose($engineFp);
|
|
@unlink(PIDFILE."_$engineID");
|
|
flock($startPidFileLock, LOCK_UN);
|
|
fclose($startPidFileLock);
|
|
return RESTORE_SUCCESS;
|
|
}
|
|
|
|
#****************************************************************************************************
|
|
# Subroutine Name : checkErrorFile.
|
|
# Objective : This function will compare error.txt content with error msgs and terminate the job if required.
|
|
# Added By : Vijay Vinoth.
|
|
#*****************************************************************************************************/
|
|
function checkErrorFile(&$prevErrorSize, $engineID)
|
|
{
|
|
GLOBAL $ErrorArgumentsExit, $phpPath, $fileJobTerminationPath;
|
|
#GLOBAL $dedupDetailFile, $dedupRestoreDeviceID;
|
|
|
|
#checking if error.txt has size
|
|
if(!customFileSize(ERRORFILE."_$engineID"))
|
|
{
|
|
return 0;
|
|
}
|
|
$errorFileContents = file(ERRORFILE."_$engineID");
|
|
if(!$errorFileContents)
|
|
{
|
|
traceLog("Unable to open file ".ERRORFILE.", Reason:".customErrorMsg());
|
|
return 0;
|
|
}
|
|
|
|
$linesRestoreErrorFile = $errorFileContents;
|
|
$errorline = "idevs error";
|
|
$linesRestoreErrorFileCount = count($linesRestoreErrorFile);
|
|
|
|
for($i = 0; $i<= $linesRestoreErrorFileCount; $i++)
|
|
{
|
|
if($linesRestoreErrorFile[$i] == "" or strpos( $linesRestoreErrorFile[$i], $errorline ) !== false)
|
|
{
|
|
continue;
|
|
}
|
|
$ErrorArgumentsExitCount = count($ErrorArgumentsExit);
|
|
|
|
for($j=0; $j<=$ErrorArgumentsExitCount; $j++)
|
|
{
|
|
if(strpos( $linesRestoreErrorFile[$i], $ErrorArgumentsExit[$j] ) !== false)
|
|
{
|
|
checkDedupDeviceError($linesRestoreErrorFile[$i]);
|
|
$errStr = "Operation could not be completed. Reason : $ErrorArgumentsExit[$j] \ntotalFiles : $totalFiles \n";
|
|
exec("$phpPath $fileJobTerminationPath 2 '".$ErrorArgumentsExit[$j]."'");
|
|
unlink(ERRORFILE."_$engineID");
|
|
return 1;
|
|
}
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
#****************************************************************************************************
|
|
# Subroutine Name : appendEnumerationError.
|
|
# Objective : Enumeration of a folder from restore set file gets fail then write
|
|
# proper error message to log file.
|
|
# Added By : Vijay Vinoth.
|
|
#*****************************************************************************************************/
|
|
function appendEnumerationError($fileName)
|
|
{
|
|
GLOBAL $jobrunningDir, $outputErrorFile, $errorFile;
|
|
GLOBAL $failedFilesCount, $totalFiles;
|
|
|
|
$errorFile = $jobrunningDir.PATHSEPARATOR.ERROR_DIR.PATHSEPARATOR.TEMP_FILES.PATHSEPARATOR.FAILEDFILES;
|
|
|
|
if($outputErrorFile)
|
|
fwrite($outputErrorFile,"[".trim(shell_exec('date +"%a %b %d %T %Y"'))."] [FAILED] [$fileName] Reason : No such file or directory.".LINEFEED);
|
|
|
|
$failedFilesCount++;
|
|
$totalFiles++;
|
|
}
|
|
|
|
#****************************************************************************************************
|
|
# Subroutine Name : exit_cleanup.
|
|
# Objective : This function will execute the major functions required at the time of exit
|
|
# Added By : Deepak Chaurasia
|
|
# Modified By : Avinash Kumar, Sabin Cheruvattil
|
|
#*****************************************************************************************************/
|
|
function exit_cleanup()
|
|
{
|
|
GLOBAL $jobrunningDir, $restoreUtfFile, $errStr, $successFiles, $syncedFiles, $failedFiles, $cancelFlag, $status;
|
|
GLOBAL $cancelFlag, $exit_flag, $issignal, $processName, $issignal;
|
|
list($successFiles, $syncedFiles, $failedFiles, $exit_flag) = getParameterValueFromStatusFile(array('FILES_COUNT_INDEX', 'SYNC_COUNT_FILES_INDEX', 'FAILED_COUNT_FILES_INDEX', 'EXIT_FLAG_INDEX'));
|
|
|
|
/*if(file_exists(EVS_TEMP))
|
|
removeItems(EVS_TEMP);*/
|
|
|
|
if(file_exists(PIDFILE)) {
|
|
unlink(PIDFILE);
|
|
} else if(!$issignal) {
|
|
# In childprocess, if we exit due to some exit scenario, then this exit_flag will be true with error msg
|
|
$exit = explode("-",$exit_flag,2);
|
|
|
|
$cancelFlag = true;
|
|
if($exit[0] && $exit[1] != ""){
|
|
$errStr = $exit[1];
|
|
checkDedupDeviceError($errStr);
|
|
} else
|
|
$errStr = readFromUserCancel();
|
|
|
|
traceLog($errStr);
|
|
} else if($issignal) {
|
|
$cancelFlag = TRUE;
|
|
}
|
|
|
|
writeOperationSummary(RESTORE);
|
|
@unlink($jobrunningDir."/error.txt");
|
|
getOperationStatus();
|
|
updateLogFileName();
|
|
sendMail();
|
|
@unlink($restoreUtfFile);
|
|
@unlink(OUTPUTFILE);
|
|
removeItems(OUTPUTFILE."*");
|
|
removeItems(UTFFILE."*");
|
|
removeRestoreTempFiles();
|
|
//@fclose($fhsPid);
|
|
@unlink(STARTPIDFILE);
|
|
@unlink(CANCEL_PATH);
|
|
if(file_exists(ENGINE_LOCKE_FILE))
|
|
@unlink(ENGINE_LOCKE_FILE);
|
|
if(file_exists("operation_".ERROR_FILE))
|
|
@unlink("operation_".ERROR_FILE);
|
|
if(file_exists("operation_".OUTPUTFILE))
|
|
@unlink("operation_".OUTPUTFILE);
|
|
if(file_exists("operation_".UTF8_FILE))
|
|
@unlink("operation_".UTF8_FILE);
|
|
if(file_exists(TEMP_OPERATION_FILE))
|
|
@unlink(TEMP_OPERATION_FILE);
|
|
if(file_exists(OPERATION_SUMMERY_ERROR_FILE))
|
|
@unlink(OPERATION_SUMMERY_ERROR_FILE);
|
|
exit;
|
|
}
|
|
|
|
#****************************************************************************************************
|
|
# Subroutine Name : process_term.
|
|
# Objective : The signal handler invoked when SIGINT or SIGTERM signal is received by the script
|
|
# Added By : Arnab Gupta
|
|
# Modified by : Vijay Vinoth, Sabin Cheruvattil
|
|
#*****************************************************************************************************/
|
|
function process_term($signal)
|
|
{
|
|
GLOBAL $isErrorFileOpen, $processName, $pidGen, $pid_OutputProcess, $errStr, $dbh, $FD_WRITE, $bacSync, $issignal;
|
|
GLOBAL $totalFiles, $failedFilesCount, $outputFile, $openRestoreFileOrg, $filehandle, $outputErrorFile, $evspid, $opprocpid;
|
|
$issignal = TRUE;
|
|
|
|
if($processName == "main") {
|
|
if(file_exists(PIDFILE)) {
|
|
@unlink(PIDFILE);
|
|
}
|
|
|
|
if(file_exists(STARTPIDFILE)) {
|
|
@unlink(STARTPIDFILE);
|
|
}
|
|
|
|
waitForProcess($pidGen, NOSCANERRORFILE);
|
|
|
|
/* if($opprocpid) {
|
|
waitForEVS($opprocpid, NOSCANERRORFILE);
|
|
} */
|
|
waitForEnginesToFinish();
|
|
|
|
$filecontent = file(INFOFILE);
|
|
for($i = count($filecontent)-1; $i >= 0; $i--) {
|
|
if(preg_match("/^FAILEDCOUNT/",$filecontent[$i])) {
|
|
$lineSplit = preg_split('/ /', $filecontent[$i],2);
|
|
$failedFilesCount = $lineSplit[1];
|
|
$failedFilesCount = trim($failedFilesCount);
|
|
}
|
|
if(preg_match("/^TOTALFILES/",$filecontent[$i])) {
|
|
$split_totalFiles = preg_split('/ /',$filecontent[$i],2);
|
|
$totalFiles = $split_totalFiles[1];
|
|
$totalFiles = trim($totalFiles);
|
|
}
|
|
}
|
|
$errStr = "Operation could not be completed. Reason: Process has been killed due to restart/shutdown.";
|
|
exit_cleanup();
|
|
} else if($processName == "dorestore") {
|
|
if($evspid) {
|
|
`kill $evspid`;
|
|
}
|
|
|
|
if($opprocpid) {
|
|
waitForEVS($opprocpid, NOSCANERRORFILE);
|
|
}
|
|
|
|
// waitForEnginesToFinish();
|
|
# engines lock will release
|
|
if(file_exists(ENGINE_LOCKE_FILE)) {
|
|
@unlink(ENGINE_LOCKE_FILE);
|
|
}
|
|
} else if($processName == "generate") {
|
|
fwrite($FD_WRITE, "TOTALFILES $totalFiles\n");
|
|
fwrite($FD_WRITE, "FAILEDCOUNT $failedFilesCount");
|
|
fclose($FD_WRITE);
|
|
|
|
if($isErrorFileOpen){
|
|
@fclose($outputErrorFile);
|
|
}
|
|
|
|
if($outputFile){
|
|
@fclose($outputFile);
|
|
}
|
|
|
|
if($openRestoreFileOrg){
|
|
@fclose($openRestoreFileOrg);
|
|
}
|
|
|
|
if($filehandle){
|
|
@fclose($filehandle);
|
|
}
|
|
# close DB connection for offline restore
|
|
if($dbh_LB){
|
|
unset($dbh_LB);
|
|
}
|
|
|
|
if($errStr != ""){
|
|
# write $errStr to status file.
|
|
writeOperationErrorToErrorFile($errStr);
|
|
}
|
|
}
|
|
}
|
|
#****************************************************************************************************
|
|
# Subroutine Name : waitForEnginesToFinish.
|
|
# Objective : wait for fork process to complete
|
|
# Added By : Vijay Vinoth
|
|
#*****************************************************************************************************/
|
|
|
|
function waitForEnginesToFinish()
|
|
{
|
|
GLOBAL $RestoreForkchilds;
|
|
while(count($RestoreForkchilds) > 0) {
|
|
foreach($RestoreForkchilds as $key => $pid) {
|
|
$res = pcntl_waitpid($pid, $status, WNOHANG);
|
|
|
|
// If the process has already exited
|
|
if($res == -1 || $res > 0){
|
|
unset($RestoreForkchilds[$key]);
|
|
}
|
|
}
|
|
|
|
sleep(1);
|
|
}
|
|
while(isAnyEngineRunning(ENGINE_LOCKE_FILE))
|
|
sleep(1);
|
|
|
|
return;
|
|
}
|
|
?>
|