816 lines
27 KiB
PHP
Executable File
816 lines
27 KiB
PHP
Executable File
<?php
|
|
GLOBAL $currentFilePath;
|
|
require('sqliteDB.php');
|
|
|
|
$operationComplete = "100%";
|
|
$jobType = "Restore_";
|
|
$lineCount = 0;
|
|
$currentRestoreset = array();
|
|
$prevLineCount = 0;
|
|
$sleep_count = 0;
|
|
$jobrunningDir = `pwd`;
|
|
$jobrunningDir = trim($jobrunningDir);
|
|
$failedfiles_array = array();
|
|
$failedfiles_array_Encrypted = array();
|
|
$xtrafileRestoreCount = 0;
|
|
$xtrafileSyncCount = 0;
|
|
$xtraSuccessCounter = 0;
|
|
$current_RestoresetHash = array();
|
|
$estoresetHashOrig_Encrypted = array();
|
|
|
|
#Indicates whether the script should retry the backup operation
|
|
$retryAttempt = false;
|
|
|
|
# parameters sent with the script calling
|
|
$logOutputFilePath = $argv[1];
|
|
$current_restoresetfile = $argv[2];
|
|
$relative = $argv[3];
|
|
$current_source = $argv[4];
|
|
$filesonly = $argv[5];
|
|
$opStartTimeRestore = $argv[6];
|
|
$restore_error = $current_restoresetfile."_ERROR";
|
|
$engineID = $argv[7];
|
|
$failedfiles_index = $argv[8];
|
|
|
|
#Errors encountered during restore operation for which the script should retry the restore operation
|
|
$ErrorArgumentsRetry = array(
|
|
"io timeout",
|
|
"Operation timed out",
|
|
"nodename nor servname provided, or not known",
|
|
"failed to connect",
|
|
"Connection refused",
|
|
"unauthorized user",
|
|
"connection unexpectedly closed",
|
|
/* "No such file or directory"*/
|
|
);
|
|
|
|
# Errors encountered during restore operation for which the script should not retry the restore operation
|
|
$ErrorArgumentsExit = array(
|
|
"encryption verification failed",
|
|
"some files could not be transferred due to quota over limit",
|
|
"skipped-over limit",
|
|
"account is under maintenance",
|
|
"account has been cancelled",
|
|
"account has been expired",
|
|
"protocol version mismatch",
|
|
"password mismatch",
|
|
"No route to host",
|
|
"bad response from proxy",
|
|
"invalid source path for operation",
|
|
"out of memory",
|
|
"failed to get the device information",
|
|
"Unable to proceed as device is deleted/removed",
|
|
"Device not configured",
|
|
"Input/output error",
|
|
"error in file write",
|
|
"error in file IO",
|
|
"No space left on device",
|
|
);
|
|
|
|
#Checking whether current job is offline/online.
|
|
$jobDir = $jobrunningDir."/";
|
|
$skip = 0;
|
|
|
|
if( extension_loaded('pcntl') && function_exists('pcntl_signal') ){
|
|
declare(ticks = 1); //To handle signals (Kill/Term/..etc)
|
|
pcntl_signal(SIGINT, 'process_term');
|
|
pcntl_signal(SIGTERM, 'process_term');
|
|
}
|
|
#Checking whether current job is local or online
|
|
if($isLocalRestore == 1)
|
|
loadToHashLocal($current_restoresetfile);
|
|
else
|
|
loadToHash($current_restoresetfile);
|
|
|
|
subOutputProcess();
|
|
subErrorRoutine();
|
|
writeParameterValuesToStatusFile($engineID);
|
|
|
|
#****************************************************************************************************
|
|
# Subroutine Name : loadToHashLocal.
|
|
# Objective : This function creates a hash of RestoreSet items incase of Local Restore
|
|
# Added By : Vijay Vinoth
|
|
#*****************************************************************************************************/
|
|
function loadToHashLocal($current_restoresetfile)
|
|
{
|
|
GLOBAL $current_RestoresetHash, $RestoresetHashOrig_Encrypted, $currentRestoreset, $deDup, $engineID;
|
|
|
|
$origRestoresetFile = $current_restoresetfile."_org";
|
|
$currentRestoresetEncrypted = file($current_restoresetfile);
|
|
$currentRestoreset = file($origRestoresetFile);
|
|
|
|
if(empty($currentRestoresetEncrypted))
|
|
{
|
|
$errStr = "Unable to open current restore file $currentRestoresetEncrypted, Reason:".customErrorMsg()."\n";
|
|
traceLog($errStr);
|
|
writeBackupErrorMsgToStatusFile($errStr,$engineID);
|
|
exit;
|
|
}
|
|
if(empty($currentRestoreset))
|
|
{
|
|
$errStr = "Unable to open current restore file $currentRestoreset, Reason:".customErrorMsg()."\n";
|
|
traceLog($errStr);
|
|
writeBackupErrorMsgToStatusFile($errStr,$engineID);
|
|
exit;
|
|
}
|
|
|
|
# only one file will be there for version restore
|
|
$currentRestoreset[0] = preg_replace('/_IBVER+\d$/', '', $currentRestoreset[0]);
|
|
|
|
reset($currentRestoreset);
|
|
foreach($currentRestoreset as $key => $item){
|
|
$currentRestoresetValue = trim($item,"\n");
|
|
$current_RestoresetHash[$currentRestoresetValue] = 0;
|
|
$RestoresetHashOrig_Encrypted[$currentRestoresetValue] = trim($currentRestoresetEncrypted[$key],"\n");
|
|
}
|
|
}
|
|
|
|
#****************************************************************************************************
|
|
# Subroutine Name : loadToHash.
|
|
# Objective : This function manage the hash for failed file check.
|
|
# Added By : Vijay Vinoth
|
|
#*****************************************************************************************************/
|
|
function loadToHash($current_restoresetfile)
|
|
{
|
|
GLOBAL $current_RestoresetHash, $currentRestoreset, $engineID;
|
|
|
|
$currentRestoreset = file($current_restoresetfile);
|
|
if(empty($currentRestoreset))
|
|
{
|
|
$errStr = "Unable to open current restore file $current_restoresetfile, Reason:".customErrorMsg()."\n";
|
|
traceLog($errStr);
|
|
writeBackupErrorMsgToStatusFile($errStr,$engineID);
|
|
exit;
|
|
}
|
|
|
|
$current_restoresetfile_size = customFileSize($current_restoresetfile);
|
|
if($current_restoresetfile_size>0)
|
|
{
|
|
# only one file will be there for version restore
|
|
$currentRestoreset[0] = preg_replace('/_IBVER+\d$/', '', $currentRestoreset[0]);
|
|
|
|
reset($currentRestoreset);
|
|
foreach($currentRestoreset as $key => $item){
|
|
$item = trim($item,"\n");
|
|
if(empty($item))
|
|
continue;
|
|
$current_RestoresetHash[$item] = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
#****************************************************************************************************
|
|
# Subroutine Name : subOutputProcess.
|
|
# Objective : This function monitors and parse the evs output file and creates the App
|
|
# log file which is shown to user.
|
|
# Modified By : Deepak Chaurasia, Vijay Vinoth.
|
|
#*****************************************************************************************************/
|
|
function subOutputProcess()
|
|
{
|
|
GLOBAL $logOutputFilePath, $operationComplete, $opStartTimeRestore, $filesonly, $isLocalRestore, $skip, $restore_error;
|
|
GLOBAL $current_RestoresetHash, $engineID, $xtrafileRestoreCount, $xtrafileSyncCount;
|
|
|
|
$Restoretype = "";
|
|
# Flags to determine the status of OUTFILE
|
|
$fileOpened = 0;
|
|
$termData = "CHILD_PROCESS_COMPLETED";
|
|
|
|
$fields_in_progress = 10;
|
|
$byteRead = 0;
|
|
$lastLine = "";
|
|
# Waiting for EVS output file to open
|
|
while(!$fileOpened)
|
|
{
|
|
if(!file_exists(PIDFILE))
|
|
break;
|
|
|
|
if(file_exists(OUTPUTFILE."_$engineID")){
|
|
if($tempOutputFile = fopen(OUTPUTFILE."_$engineID",'r')){
|
|
$fileOpened = 1;
|
|
} else {
|
|
traceLog("Could not open file : ".OUTPUTFILE.", Reason : ".customErrorMsg());
|
|
break;
|
|
}
|
|
}
|
|
sleep(2);
|
|
}
|
|
|
|
# As while is an indefinite loop for now so this condition will not make any sense but we may use it later
|
|
if($fileOpened === 0)
|
|
{
|
|
traceLog("Unable to open file ".OUTPUTFILE);
|
|
return;
|
|
}
|
|
|
|
# App log file open for parsed output
|
|
$logOutputHandle = fopen($logOutputFilePath,"a");
|
|
if(!$logOutputHandle)
|
|
{
|
|
traceLog("Unable to open file $logOutputFilePath, Reason:".customErrorMsg());
|
|
fclose($tempOutputFile);
|
|
fclose($logOutputHandle);
|
|
chmod($logOutputFilePath,PERMISSIONVAL);
|
|
return;
|
|
}
|
|
$prevTransferedSize = 0;
|
|
$totalTransfered = 0;
|
|
if(file_exists(PROGRESS_PATH."_$engineID") && customFileSize(PROGRESS_PATH."_$engineID")){
|
|
$progressContent = file(PROGRESS_PATH."_$engineID");
|
|
$totalTransfered = isset($progressContent[3]) ? trim($progressContent[3]):'';
|
|
unset($progressContent);
|
|
}
|
|
|
|
$progressPath = PROGRESS_PATH."_$engineID";
|
|
|
|
$extendedAsciiChars = getExtendedASCIIChrOrd();
|
|
|
|
while(1) {
|
|
$buffer = fread($tempOutputFile, LIMIT);
|
|
if(empty($buffer)){
|
|
if(!file_exists(PIDFILE))
|
|
break;
|
|
|
|
sleep(2);
|
|
fseek($tempOutputFile, 0, 1); #to clear eof flag
|
|
continue;
|
|
}
|
|
|
|
//need to check appending partial record to packet or to first line of packet
|
|
if(!empty($lastLine))
|
|
$buffer = $lastLine.$buffer;
|
|
|
|
if(!preg_match('/\n$/', $buffer)){
|
|
$lastNewlinePos = strrpos($buffer, "\n");
|
|
$resultList = substr($buffer,0,$lastNewlinePos);
|
|
$lastLine = substr($buffer,$lastNewlinePos);
|
|
} else {
|
|
$resultList = $buffer;
|
|
$lastLine = '';
|
|
}
|
|
unset($buffer);
|
|
|
|
$noOfLines = substr_count($resultList,"\n");
|
|
$resultListXML = "<root>$resultList</root>";
|
|
|
|
$xml = simplexml_load_string($resultListXML);
|
|
|
|
if(!$xml){
|
|
$resultListXML = checkAndConstructXML($resultList);
|
|
$resultListXML = "<root>$resultListXML</root>";
|
|
$xml = simplexml_load_string($resultListXML);
|
|
}
|
|
|
|
if($isLocalRestore !== 1 && !$xml) {
|
|
$resultListXML = str_replace($extendedAsciiChars['chr'], $extendedAsciiChars['ord'], $resultListXML);
|
|
$xml = simplexml_load_string($resultListXML);
|
|
}
|
|
|
|
$toCheck = 0;
|
|
reset($xml);
|
|
foreach ($xml->item as $value) {
|
|
$filename = trim($value['fname'],"\n");
|
|
$trf_type = trim($value['trf_type']);
|
|
$size = trim($value['size']);
|
|
$tottrf_sz = (int) trim($value['tottrf_sz']);
|
|
$rate_trf = trim($value['rate_trf']);
|
|
$per = (string) trim($value['per']);
|
|
|
|
$changedName = html_entity_decode($filename);
|
|
if($changedName !== (string)$filename) {
|
|
if(isset($current_RestoresetHash[$changedName])) {
|
|
$current_RestoresetHash[$changedName] = 1;
|
|
} else {
|
|
$filename = $changedName;
|
|
}
|
|
}
|
|
|
|
if($tottrf_sz === 0 && $trf_type === "FILE IN SYNC"){
|
|
$totalTransfered += $size;
|
|
} else {
|
|
$totalTransfered += $tottrf_sz - $prevTransferedSize;
|
|
$prevTransferedSize = $tottrf_sz;
|
|
}
|
|
updateProgressFile($trf_type, $filename, $size, $totalTransfered, $rate_trf, $opStartTimeRestore, $size, $per, $progressPath );
|
|
|
|
if($per === $operationComplete ){
|
|
$Restoretype = "";
|
|
$keyString = $filename;
|
|
|
|
if($isLocalRestore !== 1)
|
|
$keyString = PATHSEPARATOR.$keyString;
|
|
|
|
# check if file in sync
|
|
if($trf_type === "FILE IN SYNC")
|
|
$Restoretype = "Sync Restore";
|
|
else if($trf_type === "FULL")
|
|
$Restoretype = "Full Restore";
|
|
else if($trf_type === "INCREMENTAL")
|
|
$Restoretype = "Incremental Restore";
|
|
|
|
if(!empty($Restoretype)) {
|
|
if(isset($current_RestoresetHash[$keyString]))
|
|
$current_RestoresetHash[$keyString] = (($Restoretype === "Sync Restore")? 2 : 1);
|
|
else {
|
|
$tempFullPath = getFullPathofFile($keyString);
|
|
if($tempFullPath != '' && isset($current_RestoresetHash[$tempFullPath]))
|
|
$current_RestoresetHash[$tempFullPath] = (($Restoretype === 'Sync Restore')? 2 : 1);
|
|
else {
|
|
if($Restoretype === 'Sync Restore')
|
|
$xtrafileSyncCount++;
|
|
else
|
|
$xtrafileRestoreCount++;
|
|
}
|
|
}
|
|
|
|
if($Restoretype !== "Sync Restore"){
|
|
$restoreFinishTime = trim(exec('date +"%a %b %d %T %Y"'));
|
|
$fileSize = convertFileSize($size);
|
|
|
|
if($filesonly === 1 && strrpos($filename, "/") >1)
|
|
$filename = substr($filename,strrpos($filename, "/")+1);
|
|
|
|
#log this message to App logs
|
|
if($isLocalRestore !== 1)
|
|
$filename = PATHSEPARATOR.$filename;
|
|
$outputArray[] = "[$restoreFinishTime] [$Restoretype] [SUCCESS] [$filename] [$fileSize] ".LINEFEED;
|
|
}
|
|
}
|
|
}
|
|
++$toCheck;
|
|
unset($filename,$trf_type,$size,$tottrf_sz,$rate_trf,$per,$keyString,$restoreFinishTime,$fileSize);
|
|
}
|
|
|
|
if($outputArray)
|
|
{
|
|
$isLocked = flock($logOutputHandle,LOCK_EX);
|
|
if($isLocked){
|
|
fwrite($logOutputHandle, implode("",$outputArray));
|
|
flock($logOutputHandle,LOCK_UN);
|
|
}
|
|
else
|
|
{
|
|
fwrite($logOutputHandle, implode("",$outputArray));
|
|
traceLog("Unable to lock LOG file");
|
|
}
|
|
}
|
|
unset($xml,$outputArray);
|
|
|
|
if(strpos($resultList,$termData) !== FALSE) {
|
|
|
|
$skip = 1;
|
|
break;
|
|
}
|
|
else if($noOfLines > $toCheck){
|
|
$exp = explode("\n",$resultList);
|
|
foreach($exp as $key=>$data){
|
|
$data = trim($data);
|
|
if(!empty($data) && strpos($data,"<item")===false && strpos($data,"size=")===false && strpos($data,'receiving file list') === false && strpos($data,'connection established') === false && strpos($data,'bytes received') === false)
|
|
addtionalErrorInfo($data,$restore_error);
|
|
}
|
|
unset($exp);
|
|
}
|
|
|
|
if($skip === 1){
|
|
$skip = 0;
|
|
break;
|
|
}
|
|
}
|
|
fclose($tempOutputFile);
|
|
fclose($logOutputHandle);
|
|
@unlink(OUTPUTFILE."_$engineID");
|
|
chmod($logOutputFilePath,PERMISSIONVAL);
|
|
}
|
|
|
|
#****************************************************************************************************
|
|
# Subroutine Name : subErrorRoutine.
|
|
# Objective : This subroutine checks if the temporary error file is present.
|
|
# If present, it scans the temporary error file.In case the account is under maintenance / has expired /
|
|
# has been canceled, it exits the restore operation
|
|
# Also file names are added to the hash representing error in file restore in case
|
|
# errors are encountered while restore is in progress
|
|
# Also the subroutine checks for errors for which it should retry the restore operation
|
|
#
|
|
# Modified By : Vijay Vinoth.
|
|
#*****************************************************************************************************/
|
|
function subErrorRoutine()
|
|
{
|
|
GLOBAL $restore_error, $jobrunningDir, $retryAttempt;
|
|
GLOBAL $failedfiles_array, $failedfiles_count, $isLocalRestore;
|
|
GLOBAL $relative, $current_source, $failedfiles_array_Encrypted,$engineID,$failedfiles_index;
|
|
|
|
# get restore failed file count.
|
|
getFailedFileCount();
|
|
$failedfiles = "";
|
|
|
|
#Copying evs generated error.txt to RESTORE_ERRORFILE
|
|
copyTempErrorFile($restore_error,"_$engineID");
|
|
|
|
$individual_errorfile = $jobrunningDir."/".ERROR_DIR."/$restore_error";
|
|
if(file_exists($individual_errorfile) && customFileSize($individual_errorfile) > 0 && $failedfiles_index != -1 && file_exists(PIDFILE)){
|
|
if(!checkretryAttempt($individual_errorfile)){
|
|
getFinalErrorFile();
|
|
updateFailedFileCount();
|
|
return;
|
|
}
|
|
}
|
|
else {
|
|
getFinalErrorFile();
|
|
updateFailedFileCount();
|
|
return;
|
|
}
|
|
|
|
if(!$retryAttempt || $failedfiles_index == -1)
|
|
getFinalErrorFile();
|
|
else
|
|
{
|
|
if($failedfiles_count > 0)
|
|
{
|
|
$failedfiles = TEMP_FILES."/failedfiles.txt".$failedfiles_index;
|
|
$oldfile_error = $jobrunningDir."/".ERROR_DIR."/$restore_error";
|
|
$newfile_error = $jobrunningDir."/".ERROR_DIR."/$failedfiles"."_ERROR";
|
|
|
|
if(file_exists($oldfile_error) || file_exists($oldfile_error."_FINAL"))
|
|
rename($oldfile_error, $newfile_error);
|
|
|
|
if($isLocalRestore === 1){
|
|
$failedfileOrig = $failedfiles."_org";
|
|
$FD = fopen($failedfileOrig, 'w');
|
|
|
|
if(!$FD){
|
|
traceLog("Unable to open file $failedfileOrig, Reason:".customErrorMsg());
|
|
updateFailedFileCount();
|
|
return;
|
|
}
|
|
$arrayContent = join("\n", $failedfiles_array);
|
|
fwrite($FD,"$arrayContent\n");
|
|
fclose($FD);
|
|
$failedfiles_array = array();
|
|
$failedfiles_array = $failedfiles_array_Encrypted;
|
|
}
|
|
|
|
$FAILEDLIST = fopen($failedfiles, 'w');
|
|
if(!$FAILEDLIST){
|
|
traceLog("Unable to open file $failedfiles, Reason:".customErrorMsg());
|
|
updateFailedFileCount();
|
|
return;
|
|
}
|
|
/* To Test Retry
|
|
$i = 0;
|
|
foreach ($failedfiles_array as $key => $val)
|
|
{
|
|
if($i %2 == 0)
|
|
$failedfiles_array[$key] = str_replace("_ODD", "", $val);
|
|
$i++;
|
|
}
|
|
*/
|
|
$arrayContent = join("\n", $failedfiles_array);
|
|
fwrite($FAILEDLIST,"$arrayContent\n");
|
|
fclose($FAILEDLIST);
|
|
}
|
|
|
|
if(file_exists($failedfiles)){
|
|
$RETRYINFO = fopen(RETRY_INFOFILE, 'a');
|
|
if(!$RETRYINFO){
|
|
traceLog("Unable to open file ".RETRY_INFOFILE.", Reason:".customErrorMsg());
|
|
updateFailedFileCount();
|
|
return;
|
|
}
|
|
flock($RETRYINFO, LOCK_EX);
|
|
fwrite($RETRYINFO,"$failedfiles $relative $current_source\n");
|
|
fflush($RETRYINFO);
|
|
flock($RETRYINFO, LOCK_UN);
|
|
fclose($RETRYINFO);
|
|
}
|
|
}
|
|
|
|
updateFailedFileCount();
|
|
}
|
|
|
|
#****************************************************************************************************
|
|
# Subroutine Name : getFailedFileCount.
|
|
# Objective : This function calculate failed file count by checking current restore
|
|
# hash value zero for failed file.
|
|
# Added By : Vijay Vinoth
|
|
#*****************************************************************************************************/
|
|
function getFailedFileCount()
|
|
{
|
|
GLOBAL $currentRestoreset, $failedfiles_array, $failedfiles_count, $current_RestoresetHash, $isLocalRestore, $failedfiles_array_Encrypted;
|
|
GLOBAL $RestoresetHashOrig_Encrypted, $fileOperationCount, $fileSyncCount, $xtrafileRestoreCount, $xtrafileSyncCount, $xtraSuccessCounter;
|
|
|
|
$j = 0;
|
|
reset($currentRestoreset);
|
|
foreach($currentRestoreset as $key => $item){
|
|
$tempCurrentRestoreset = trim($item,"\n");
|
|
if(empty($tempCurrentRestoreset))
|
|
continue;
|
|
|
|
if($current_RestoresetHash[$tempCurrentRestoreset] === 0){
|
|
$failedfiles_array[$j] = $tempCurrentRestoreset;
|
|
if($isLocalRestore === 1)
|
|
$failedfiles_array_Encrypted[$j] = $RestoresetHashOrig_Encrypted[$tempCurrentRestoreset];
|
|
$j++;
|
|
}
|
|
elseif($current_RestoresetHash[$tempCurrentRestoreset] === 1)
|
|
$fileOperationCount++;
|
|
elseif($current_RestoresetHash[$tempCurrentRestoreset] === 2)
|
|
$fileSyncCount++;
|
|
}
|
|
|
|
$failedfiles_count = $j - ($xtrafileRestoreCount + $xtrafileSyncCount);
|
|
$fileOperationCount += $xtrafileRestoreCount;
|
|
$fileSyncCount += $xtrafileSyncCount;
|
|
$xtraSuccessCounter = $xtrafileRestoreCount + $xtrafileSyncCount;
|
|
}
|
|
|
|
#****************************************************************************************************************************
|
|
# Subroutine Name : getFullPathofFile
|
|
# Objective : This subroutine gets the full path of files that have backed up
|
|
# Added By : Vijay Vinoth
|
|
# Modified By : Sabin Cheruvattil
|
|
#******************************************************************************************************************************/
|
|
function getFullPathofFile($fileToCheck)
|
|
{
|
|
GLOBAL $currentRestoreset, $current_RestoresetHash;
|
|
$returnItem = '';
|
|
$retStr = trim($fileToCheck, "\n");
|
|
|
|
reset($currentRestoreset);
|
|
$currentRestoresetReverse = array_reverse($currentRestoreset);
|
|
reset($currentRestoresetReverse);
|
|
foreach($currentRestoresetReverse as $key => $item) {
|
|
$item = trim($item, "\n");
|
|
$currentRestoresetTemp = ((strrpos($retStr, '/') === 0)? strrpos($item, '/') : strpos($item, '/'));
|
|
$match = substr($item, $currentRestoresetTemp);
|
|
|
|
if($retStr === $match) {
|
|
$returnItem = $item;
|
|
break;
|
|
}
|
|
}
|
|
|
|
unset($currentRestoresetReverse);
|
|
return $returnItem;
|
|
}
|
|
|
|
#****************************************************************************************************
|
|
# Subroutine Name : checkretryAttempt.
|
|
# Objective : This function checks whether restore has to retry
|
|
# Added By : Vijay Vinoth
|
|
#*****************************************************************************************************/
|
|
function checkretryAttempt($individual_errorfile)
|
|
{
|
|
GLOBAL $ErrorArgumentsExit, $ErrorArgumentsRetry, $retryAttempt, $phpPath;
|
|
GLOBAL $webDir,$engineID;
|
|
#GLOBAL $dedupDetailFile, $dedupRestoreDeviceID;
|
|
|
|
$errorline = "idevs error";
|
|
$linesRestoreErrorFile = file($individual_errorfile);
|
|
|
|
#To check the individual error file for exit scenarios
|
|
reset($linesRestoreErrorFile);
|
|
foreach($linesRestoreErrorFile as $key => $item){
|
|
if(empty($item) || strpos($item,$errorline) !== FALSE)
|
|
continue;
|
|
reset($ErrorArgumentsExit);
|
|
foreach($ErrorArgumentsExit as $index => $val){
|
|
if(strpos($item,$val) !== FALSE)
|
|
{
|
|
@unlink(OUTPUTFILE."_$engineID");
|
|
|
|
/*if(file_exists(EVS_TEMP))
|
|
removeItems(EVS_TEMP);*/
|
|
|
|
#kill evs and then exit
|
|
$fileJobTerminationPath = $webDir.PATHSEPARATOR.APPDIR.PATHSEPARATOR.SCRIPTS.PATHSEPARATOR.JOBTERMINATIONFILE;
|
|
$cmd = "$phpPath $fileJobTerminationPath 2 '$val'";
|
|
exec($cmd);
|
|
if(($val == "account has been cancelled")|| ($val == "account is under maintenance") || ($val == "account has been blocked") || ($val == "account has been expired")){
|
|
//update user status to account settings file
|
|
updateUserStatus($val);
|
|
}
|
|
return 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
#To check the individual error file for retry case
|
|
reset($linesRestoreErrorFile);
|
|
foreach($linesRestoreErrorFile as $key => $item){
|
|
if(empty($item) || strpos($item,$errorline) !== FALSE)
|
|
continue;
|
|
|
|
reset($ErrorArgumentsRetry);
|
|
foreach($ErrorArgumentsRetry as $inx => $val){
|
|
if(strpos($item,$val) !== FALSE){
|
|
$retryAttempt = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if($retryAttempt){
|
|
reduceRetryFileSizeInprogress();
|
|
break;
|
|
}
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
#****************************************************************************************************
|
|
# Subroutine Name : reduceRetryFileSizeInprogress.
|
|
# Objective : This function is used to reduce the file size of files which got failed.
|
|
# Added By : Anil Kumar
|
|
# Modified By :
|
|
#*****************************************************************************************************
|
|
function reduceRetryFileSizeInprogress()
|
|
{
|
|
GLOBAL $engineID;
|
|
$progressPath = PROGRESS_PATH."_$engineID";
|
|
|
|
$progressFile = file_get_contents($progressPath);
|
|
$progressData = explode("\n", $progressFile);
|
|
|
|
if($progressData[8] != '100%' && $progressData[7] > 0){
|
|
$progressData[2] -= $progressData[7];
|
|
}
|
|
|
|
updateProgressFile($progressData[0], $progressData[1], $progressData[2], $progressData[3], $progressData[4], $progressData[6], $progressData[7], $progressData[8], $progressPath);
|
|
}
|
|
|
|
|
|
#****************************************************************************************************
|
|
# Subroutine Name : updateFailedFileCount.
|
|
# Objective : This function manage the counts of failed files during retry case.
|
|
# Added By : Vijay Vinoth
|
|
#*****************************************************************************************************/
|
|
function updateFailedFileCount()
|
|
{
|
|
GLOBAL $currentRestoreset, $failedfiles_count, $restore_error, $engineID;
|
|
|
|
list($orig_count) = getParameterValueFromStatusFile(array("FAILED_COUNT_FILES_INDEX"), $engineID);
|
|
if(strpos( $restore_error,"failedfiles.txt" ) !== false){
|
|
$size_Restoreset = count($currentRestoreset);
|
|
$newcount = ($orig_count - $size_Restoreset) + $failedfiles_count;
|
|
$failedfiles_count = $newcount;
|
|
}
|
|
else{
|
|
$orig_count += $failedfiles_count;
|
|
$failedfiles_count = $orig_count;
|
|
}
|
|
}
|
|
|
|
#****************************************************************************************************************************
|
|
# Subroutine Name : getFinalErrorFile
|
|
# Objective : This subroutine creates a final ERROR file for each backupset, which has to be displayed in LOGS
|
|
# Modified By : Vijay Vinoth
|
|
#******************************************************************************************************************************/
|
|
function getFinalErrorFile()
|
|
{
|
|
GLOBAL $jobrunningDir, $restore_error, $exit_flag;
|
|
GLOBAL $failedfiles_count, $failedfiles_array, $RestoresetHashOrig_Encrypted, $hostNameLB,$username;
|
|
GLOBAL $current_source, $isLocalRestore, $engineID, $xtraSuccessCounter, $webDir;
|
|
$restoreErrors = '';
|
|
$cancel = 0;
|
|
$failedWithReason = 0;
|
|
$individual_errorfile = $jobrunningDir."/".ERROR_DIR."/$restore_error";
|
|
|
|
if(!$exit_flag){
|
|
if(!file_exists(PIDFILE))
|
|
$cancel = 1;
|
|
}
|
|
|
|
if($failedfiles_count > 0){
|
|
$ERROR_FINAL = fopen($individual_errorfile."_FINAL", 'w+');
|
|
|
|
if(!$ERROR_FINAL){
|
|
traceLog("Unable to open file $individual_errorfile"."_FINAL, Reason:".customErrorMsg());
|
|
return;
|
|
}
|
|
else{
|
|
if(!file_exists($individual_errorfile)){
|
|
if($exit_flag or $cancel !== 0)
|
|
$failedfiles_count = $failedWithReason;
|
|
if($cancel===1)
|
|
traceLog("Unable to open $individual_errorfile.");
|
|
}
|
|
else
|
|
$restoreErrors = file($individual_errorfile);
|
|
}
|
|
|
|
if($restoreErrors){
|
|
sort($failedfiles_array);
|
|
|
|
$j = 0;
|
|
$last_index = count($restoreErrors);
|
|
$destPath = trim($hostNameLB."/$username$current_source");
|
|
$failedfiles_arrayCount = count($failedfiles_array);
|
|
|
|
for($i = 0; $i < $failedfiles_arrayCount; $i++){
|
|
$matched = 0;
|
|
#reset the initial and last limit for internal for loop for new item if required
|
|
if($j > $last_index){
|
|
$j = 0;
|
|
$last_index = count($restoreErrors);
|
|
}
|
|
|
|
#fill the last matched index for later use
|
|
$index = $j;
|
|
if($isLocalRestore === 1) {
|
|
$failedfile = $failedfiles_array[$i];
|
|
} else {
|
|
$failedfile = substr($failedfiles_array[$i],1);
|
|
}
|
|
|
|
#try to find a match between start and end point of error file
|
|
for($j=0;$j < $last_index; $j++){
|
|
if(!empty($restoreErrors[$j])){
|
|
if(strpos( $restoreErrors[$j], $failedfile ))
|
|
{
|
|
$failedfile = phpQuoteMeta($failedfile);
|
|
$Reason = trim(preg_replace("/.*$failedfile.*:/", '', $restoreErrors[$j]));
|
|
if($Reason == '-3') {
|
|
$Reason = "Decryption failed";
|
|
// need to run auth list to confirm and logout
|
|
$res = validatePvtKeyUsingAuthList();
|
|
if(!$res){
|
|
$needToLogout = "$webDir/".APPDIR.PATHSEPARATOR."logout.txt";
|
|
traceLog("logout trigger".$needToLogout);
|
|
$errDetails = DECRYPTIONFAILED;
|
|
writeOperationErrorToErrorFile($errDetails);
|
|
traceLog($errDetails);
|
|
if(file_put_contents($needToLogout, DECRYPTIONFAILED))
|
|
chmod($needToLogout,0777);
|
|
}
|
|
}
|
|
fwrite($ERROR_FINAL,"[".trim(exec('date +"%a %b %d %T %Y"'))."] [FAILED] [$failedfiles_array[$i]]. Reason: $Reason ".LINEFEED);
|
|
|
|
$matched = 1;
|
|
$failedWithReason++;
|
|
#got a match so resetting the last index
|
|
$last_index = count($restoreErrors);
|
|
$j++;
|
|
break;
|
|
}
|
|
}
|
|
#if no match till last item and intial index is not zero try for remaining error file content
|
|
if($j === $last_index && $index !== 0)
|
|
{
|
|
$j = 0;
|
|
$last_index = $index;
|
|
$index = $j;
|
|
}
|
|
}
|
|
|
|
if($matched === 0 && !$exit_flag && $cancel === 0) {
|
|
if($xtraSuccessCounter <= 0) {
|
|
$errorContent = "[".trim(exec('date +"%a %b %d %T %Y"'))."] [FAILED] [$failedfiles_array[$i]] ".LINEFEED;
|
|
} else {
|
|
$xtraSuccessCounter--;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
}
|
|
else if($cancel === 0){
|
|
$localtime = trim(exec('date +"%a %b %d %T %Y"'));
|
|
foreach($failedfiles_array as $failedItem){
|
|
if($xtraSuccessCounter <= 0) {
|
|
$failedfile = substr($failedItem,1);
|
|
$errorContent = "[$localtime] [FAILED] [$failedfile] ".LINEFEED ;
|
|
} else {
|
|
$xtraSuccessCounter--;
|
|
}
|
|
}
|
|
}
|
|
|
|
if(!$exit_flag and $cancel === 0)
|
|
fwrite($ERROR_FINAL, $errorContent);
|
|
fclose($ERROR_FINAL);
|
|
}
|
|
|
|
if($exit_flag or $cancel !== 0)
|
|
$failedfiles_count = $failedWithReason;
|
|
@unlink($individual_errorfile);
|
|
}
|
|
|
|
#****************************************************************************************************
|
|
# Subroutine Name : process_term
|
|
# Objective : The signal handler invoked when SIGTERM signal is received by the script
|
|
# Added By : Vijay Vinoth
|
|
#*****************************************************************************************************/
|
|
function process_term()
|
|
{
|
|
GLOBAL $tempOutputFile, $logOutputHandle, $logOutputFilePath,$engineID;
|
|
if($tempOutputFile)
|
|
fclose($tempOutputFile);
|
|
|
|
if($logOutputHandle)
|
|
fclose($logOutputHandle);
|
|
|
|
chmod($logOutputFilePath,PERMISSIONVAL);
|
|
|
|
writeParameterValuesToStatusFile($engineID);
|
|
exit;
|
|
}
|
|
?>
|