985 lines
30 KiB
PHP
Executable File
985 lines
30 KiB
PHP
Executable File
<?php
|
|
$processName = "main";
|
|
$filesonly = 0;
|
|
$restoreDisplayPath = "./RestoresetDisplayFile.txt";
|
|
$periodOperator = ".";
|
|
$operationComplete = "100";
|
|
$idevsutilCommandLine = '';
|
|
$pid_OutputProcess = '';
|
|
$filesConsideredCount = '';
|
|
//$restoreExit = false;
|
|
$headerWrite = 0;
|
|
$filecount = 0;
|
|
$Restorefilecount = 0;
|
|
$relative = 0;
|
|
$current_source = "";
|
|
$next_source = "";
|
|
$filehandleNoRel = '';
|
|
$filehandle = '';
|
|
$restore_errorfile = "RESTORE_ERRORFILE";
|
|
$filesOnlyFile_count = 0;
|
|
$RestoreFile = "";
|
|
$restoreUtfFile = "";
|
|
$RestoresetFile_norelative = TEMP_FILES.PATHSEPARATOR.RESTORESETFILE_NORELATIVE;
|
|
$RestoresetFile_filesOnly = TEMP_FILES.PATHSEPARATOR.RESTORESETFILE_ONLYFILES;
|
|
$RestoresetFile_relative = TEMP_FILES.PATHSEPARATOR.RESTORESETFILE_RELATIVE;
|
|
$fileOnlySetName = $RestoresetFile_filesOnly;
|
|
$noRelIndex = 0;
|
|
$isErrorFileOpen = 1;
|
|
$fileJobTerminationPath = $webDir.PATHSEPARATOR.APPDIR.PATHSEPARATOR.SCRIPTS.PATHSEPARATOR.JOBTERMINATIONFILE;
|
|
$ErrorArgumentsExit = array(
|
|
"No route to host",
|
|
"not enough free space on device",
|
|
"Input/output error",
|
|
"invalid source path for operation",
|
|
"Device not configured",
|
|
"failed to get the device information",
|
|
"encryption verification failed"
|
|
);
|
|
$operationStartTimeRestore = time();
|
|
|
|
$checkCPUUsage = 0;
|
|
|
|
# If job in progress then don't run again
|
|
$jobDir = $jobrunningDir."/";
|
|
$varManualTask = '+ManualTask/';
|
|
$varTrashManualTask = '+TrashManualTask/';
|
|
|
|
# String to be logged when user cancels job
|
|
$cancelStr = "";
|
|
|
|
# Output File Name
|
|
$outputFileName = "RESTORE";
|
|
define('ERROR_RELOGIN',"Operation could not be completed. Reason : <ERROR>. Please logout & login again.");
|
|
|
|
|
|
# Count of files which could not be backed up/synced due to unspecified errors
|
|
$countOtherErrors = 0;
|
|
|
|
#Checking whether current job is ManualTask or Scheduled
|
|
if(strpos( $jobDir, $varManualTask ) === false && strpos( $jobDir, $varTrashManualTask ) === false)
|
|
$taskType = SCHEDULED;
|
|
|
|
#Checking whether current job is from Trash or not
|
|
if (strpos( $jobDir, $varTrashManualTask ) !== false)
|
|
$trash = 1;
|
|
|
|
$rel_Data = "";
|
|
if($isLocalRestore != 1)
|
|
{
|
|
# hard coded for now.
|
|
$rel_Data = NORELATIVE;
|
|
}
|
|
else
|
|
{
|
|
# offline only --relative.
|
|
$rel_Data = RELATIVE;
|
|
$relative = 1;
|
|
$current_source = "/";
|
|
}
|
|
|
|
$hostName = getRestoreLocation();
|
|
$sourceIdx = 0;
|
|
#******************************************************************************************************************
|
|
# Subroutine Name : removeRestoreTempFiles.
|
|
# Objective : This subroutine remove temporary files and folder. Also cleanup condition based files
|
|
# and folder e.g local search etc.
|
|
# Added By : Vijay Vinoth
|
|
#******************************************************************************************************************/
|
|
function removeRestoreTempFiles()
|
|
{
|
|
GLOBAL $successFiles;
|
|
GLOBAL $userDir;
|
|
|
|
#if(file_exists(STATUSFILE))
|
|
# unlink(STATUSFILE);
|
|
|
|
if(file_exists(OPERATION_SUMMERY_ERROR_FILE))
|
|
unlink(OPERATION_SUMMERY_ERROR_FILE);
|
|
|
|
# cleanup local search data.
|
|
if($successFiles > 0){
|
|
$localSearchPath = $userDir.PATHSEPARATOR.BACKUP.PATHSEPARATOR.".+searchList/*";
|
|
#exec("/bin/rm -rf $localSearchPath");
|
|
removeItems($localSearchPath);
|
|
}
|
|
|
|
# cleanup intermediate files and folder.
|
|
$arrayToRemove = array(EXEC_ERRORFILE, ERROR_DIR, TEMP_FILES, "search", TOTAL_SIZE_PATH, STATUSFILE."*", PROGRESS_PATH."*");
|
|
removeItems($arrayToRemove);
|
|
}
|
|
|
|
#****************************************************************************************************
|
|
# Subroutine Name : generateRestoresetFiles.
|
|
# Objective : Generating restore set file/files based on user's restore set file
|
|
# content. Check for file/folder type based on that, if entry element of
|
|
# restore set file is folder then execute search command to get the list of
|
|
# files associated with that folder. Count number for files considered for
|
|
# restore. Write the required data to info_file.
|
|
# Added By : Vijay Vinoth.
|
|
#*****************************************************************************************************/
|
|
function generateRestoresetFiles()
|
|
{
|
|
GLOBAL $isLocalRestore, $databaseLB, $RestoreFile, $totalFiles, $idevsutilBinaryPath, $filesonlycount, $relative, $filecount;
|
|
GLOBAL $restoreDisplayPath, $outputErrorFile, $isErrorFileOpen, $errorFile, $openRestoreFileOrg, $RestoresetFile_filesOnly;
|
|
GLOBAL $dbh_LB, $current_source, $totalSize, $RestoresetFile_relative, $filehandle, $RestoresetFile_filesOnly, $errStr, $processName;
|
|
|
|
$processName = "generate";
|
|
$result = -1;
|
|
$res = "";
|
|
$totalSize = 0;
|
|
$outputErrorFile = fopen($errorFile, 'w');
|
|
$filesonlycount = 0;
|
|
$idx = 0;
|
|
|
|
if($relative == 1){
|
|
$filehandle = fopen($RestoresetFile_relative, "w");
|
|
if(!$filehandle){
|
|
traceLog("Unable to open file $RestoresetFile_relative to write, Reason: ".customErrorMsg());
|
|
$errStr = "Unable to generate list of files to restore.";
|
|
generateRestoresetErrorFiles($errStr);
|
|
|
|
}
|
|
$RestoreFile = $RestoresetFile_relative;
|
|
}
|
|
else {
|
|
$filehandle = fopen($RestoresetFile_filesOnly, "w");
|
|
if(!$filehandle){
|
|
traceLog("Unable to open file $RestoresetFile_filesOnly to write, Reason: ".customErrorMsg());
|
|
$errStr = "Unable to generate list of files to restore.";
|
|
generateRestoresetErrorFiles($errStr);
|
|
}
|
|
$RestoreFile = $RestoresetFile_filesOnly;
|
|
}
|
|
@chmod($RestoreFile,PERMISSIONVAL);
|
|
|
|
if(!$outputErrorFile)
|
|
{
|
|
$isErrorFileOpen = 0;
|
|
traceLog("Unable to open $errorFile to write, Reason:".customErrorMsg());
|
|
}
|
|
|
|
# Read restore set display file to get information about file or folder.
|
|
$RestoreDispArray = file($restoreDisplayPath);
|
|
|
|
if(!$RestoreDispArray)
|
|
{
|
|
$errStr = "\n Cannot open file $restoreDisplayPath, Reason: ".customErrorMsg().LINEFEED;
|
|
generateRestoresetErrorFiles($errStr);
|
|
return;
|
|
}
|
|
|
|
# open DB connection
|
|
if($isLocalRestore == 1)
|
|
{
|
|
if(!file_exists($databaseLB))
|
|
{
|
|
generateRestoresetErrorFiles($errStr);
|
|
return;
|
|
}
|
|
if(!createLBDB())
|
|
{
|
|
traceLog("Create LBDB failed.");
|
|
generateRestoresetErrorFiles($errStr);
|
|
return;
|
|
}
|
|
# create file for original file name set
|
|
$openRestoreFileOrg = fopen($RestoreFile."_org", 'w');
|
|
if(!$openRestoreFileOrg)
|
|
{
|
|
$errStr = "Cannot open $RestoreFile"."_org to write.".LINEFEED;
|
|
generateRestoresetErrorFiles($errStr);
|
|
return;
|
|
}
|
|
}
|
|
|
|
# check for version restore.
|
|
if(preg_match('/_IBVER+\d$/',trim($RestoreDispArray[0])))
|
|
{
|
|
$outputFile = fopen($RestoreFile, 'a+');
|
|
|
|
/** To test Retry
|
|
if($filesonlycount%2 != 0)
|
|
$RestoreDispArray[0] = $RestoreDispArray[0]."_ODD";
|
|
**/
|
|
fwrite($outputFile,trim($RestoreDispArray[0]).PHP_EOL);
|
|
$filesonlycount++;
|
|
$totalFiles++;
|
|
generateRestoresetErrorFiles();
|
|
return;
|
|
}
|
|
|
|
$RestoreDispArrayCount = count($RestoreDispArray);
|
|
|
|
for ($idx = 1; $idx <= $RestoreDispArrayCount; $idx +=4 )
|
|
{
|
|
if(!file_exists(PIDFILE))
|
|
break;
|
|
|
|
if(preg_match('/^$/',trim($RestoreDispArray[$idx - 1]))|| preg_match('/^$/',trim($RestoreDispArray[$idx])))
|
|
continue;
|
|
|
|
$result = true;
|
|
# check from restore display file that it is folder.
|
|
if(trim($RestoreDispArray[$idx]) == FOLDER)
|
|
{
|
|
$result = createRestoreSetFromFolder(trim($RestoreDispArray[$idx - 1],"\n"));
|
|
if($result == false)
|
|
{
|
|
//$errStr = "Check from restore display file that it is folder failed".LINEFEED;
|
|
generateRestoresetErrorFiles($errStr);
|
|
return;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if($isLocalRestore == 0)
|
|
$RestoreFile = $RestoresetFile_filesOnly;
|
|
|
|
$result = createRestoreSetFromFile(trim($RestoreDispArray[$idx - 1],"\n"));
|
|
if($result == false){
|
|
$errStr = "Intermediate restore file set creation failed".LINEFEED;
|
|
generateRestoresetErrorFiles($errStr);
|
|
return;
|
|
}
|
|
|
|
if($isLocalRestore == 1)
|
|
{
|
|
$totalSize += getFileSizeFromLocal(trim($RestoreDispArray[$idx - 1],"\n"));
|
|
}
|
|
else
|
|
{
|
|
$propertyUtf8 = getOperationFile(array("opType" => PROPERTIES,
|
|
"itemPath" => trim($RestoreDispArray[$idx - 1],"\n")));
|
|
|
|
# EVS command to execute for properties
|
|
$propertiesCmd = $idevsutilBinaryPath.WHITESPACE.IDEVSUTIL_ARG.ASSIGNMENTOP."\"$propertyUtf8\"";
|
|
|
|
$out = exec("$propertiesCmd 2>".EXEC_ERRORFILE);
|
|
$out = trim($out,"\n");
|
|
$tmpArr = preg_match("/\d+/", $out, $matches);
|
|
if(!isset($matches[0])){
|
|
if(customFileSize(ERRORFILE) > 0)
|
|
{
|
|
$error = file_get_contents(ERRORFILE);
|
|
checkDedupDeviceError($error);
|
|
}
|
|
} else
|
|
$totalSize += trim($matches[0]);
|
|
}
|
|
}
|
|
}
|
|
|
|
# create totalsize.txt
|
|
$totalFileSize = fopen(TOTAL_SIZE_PATH, 'w+');
|
|
|
|
if($totalFileSize)
|
|
{
|
|
fwrite($totalFileSize,$totalSize);
|
|
fclose($totalFileSize);
|
|
}
|
|
else
|
|
traceLog("Can not open ".TOTAL_SIZE_PATH.", Reason: ".customErrorMsg().LINEFEED);
|
|
|
|
generateRestoresetErrorFiles();
|
|
}
|
|
|
|
#****************************************************************************************************
|
|
# Subroutine Name : getFileSizeFromLocal.
|
|
# Objective : This subroutine is for fetching the file size from the local backup device.
|
|
# Added By : Anil Kumar.
|
|
#*****************************************************************************************************/
|
|
function getFileSizeFromLocal($item)
|
|
{
|
|
GLOBAL $dbh_LB, $localBackupLocationFile, $dedupDetailFile, $deDup, $hostNameLB, $username;
|
|
|
|
$serverRoot = '';
|
|
if($deDup == true)
|
|
{
|
|
if(file_exists($localBackupLocationFile)) {
|
|
$dbpaths = $hostNameLB . '/' . $username . '/dbpaths.xml';
|
|
$serverRoot = getServerRoot($dbpaths,$localBackupLocationFile);
|
|
}
|
|
}
|
|
$explodeItem = explode('/', $item);
|
|
$filename = array_pop($explodeItem);
|
|
$dirName = implode('/', $explodeItem);
|
|
$dirName = $dirName."/";
|
|
|
|
if($deDup == true)
|
|
$dirName = $serverRoot . $dirName;
|
|
|
|
$queryToGetDirID = "SELECT DIRID from ibfolder where NAME=\"'".$dirName."'\"";
|
|
|
|
$preQueryGetDirID = $dbh_LB->prepare($queryToGetDirID);
|
|
$preQueryGetDirID->execute();
|
|
$dirIDValue = $preQueryGetDirID->fetch();
|
|
$preQueryGetDirID->closeCursor();
|
|
$dirID = $dirIDValue[0];
|
|
|
|
$queryToGetFileSize = "SELECT FILE_SIZE from ibfile where DIRID = ".$dirID." and NAME=\"'".$filename."'\"";
|
|
$preQueryToGetFileSize = $dbh_LB->prepare($queryToGetFileSize);
|
|
$preQueryToGetFileSize->execute();
|
|
$fileSizeValue = $preQueryToGetFileSize->fetch();
|
|
$preQueryToGetFileSize->closeCursor();
|
|
$fileSize = $fileSizeValue[0];
|
|
|
|
return $fileSize;
|
|
}
|
|
|
|
#****************************************************************************************************
|
|
# Subroutine Name : generateRestoresetErrorFiles.
|
|
# Objective : This subroutine is for error handling of generateRestoreset function
|
|
# Added By : Vijay Vinoth.
|
|
#*****************************************************************************************************/
|
|
function generateRestoresetErrorFiles($errStr = '')
|
|
{
|
|
GLOBAL $isLocalRestore, $databaseLB;
|
|
GLOBAL $RestoreFile, $totalFiles;
|
|
GLOBAL $idevsutilBinaryPath;
|
|
GLOBAL $filesonlycount, $relative, $filecount;
|
|
GLOBAL $filehandle, $outputErrorFile, $fileOnlySetName, $filehandleNoRel;
|
|
GLOBAL $current_source, $isErrorFileOpen, $errorFile;
|
|
GLOBAL $openRestoreFileOrg, $dbh_LB, $failedFilesCount, $outputFile, $logOutputHandle;
|
|
|
|
if($relative == 1 and $filecount == 0)
|
|
@unlink($RestoreFile);
|
|
else if($filesonlycount == 0)
|
|
@unlink($fileOnlySetName);
|
|
|
|
@chmod(INFOFILE,PERMISSIONVAL);
|
|
$fd_write= fopen(INFOFILE, 'a');
|
|
|
|
if($relative == 1 and $filecount > 0)
|
|
fwrite($fd_write, "$RestoreFile ".RELATIVE." $current_source \n");
|
|
else if($filesonlycount >0)
|
|
{
|
|
$current_source = "/";
|
|
fwrite($fd_write, "$fileOnlySetName ".NORELATIVE." $current_source\n");
|
|
}
|
|
|
|
fwrite($fd_write, "TOTALFILES $totalFiles\n");
|
|
fwrite($fd_write, "FAILEDCOUNT $failedFilesCount");
|
|
fclose($fd_write);
|
|
|
|
if($isErrorFileOpen)
|
|
@fclose($outputErrorFile);
|
|
|
|
if($outputFile)
|
|
@fclose($outputFile);
|
|
|
|
if($logOutputHandle)
|
|
@fclose($logOutputHandle);
|
|
|
|
if($openRestoreFileOrg)
|
|
@fclose($openRestoreFileOrg);
|
|
|
|
if($filehandle)
|
|
@fclose($filehandle);
|
|
|
|
if($filehandleNoRel)
|
|
@fclose($filehandleNoRel);
|
|
|
|
# close DB connection for offline restore
|
|
if($dbh_LB)
|
|
unset($dbh_LB);
|
|
|
|
# write $errStr to status file.
|
|
if($errStr != ""){
|
|
@unlink(PIDFILE);
|
|
$exit_flag = "1-$errStr";
|
|
writeOperationErrorToErrorFile($errStr);
|
|
}
|
|
}
|
|
|
|
#****************************************************************************************************
|
|
# Subroutine Name : createRestoreSetFromFile.
|
|
# Objective : Take remote folder as argument and execute serach/DB query on that
|
|
# Create set of 1k files. Count number of files considered for restore.
|
|
# Added By : Vijay Vinoth.
|
|
#*****************************************************************************************************/
|
|
function createRestoreSetFromFile($fileName)
|
|
{
|
|
GLOBAL $isLocalRestore, $RestoreFile, $current_source, $totalFiles;
|
|
GLOBAL $relative, $filesonlycount,$filecount, $filehandle;
|
|
|
|
#if offline fire sqlite sql query and construct restore set file content.
|
|
if($isLocalRestore == 1)
|
|
{
|
|
if(LOCAL_FILE_FOLDER_SELECT_FAILURE == writeActualAndEncSet($fileName))
|
|
{
|
|
//traceLog("Local file/folder search failed for [".$fileName."]");
|
|
appendEnumerationError($fileName);
|
|
return true;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
$totalFiles++;
|
|
//$fd_write = fopen($RestoreFile, 'a+');
|
|
fwrite($filehandle,$fileName.LINEFEED);
|
|
$current_source = "/";
|
|
}
|
|
|
|
if($relative == 0)
|
|
{
|
|
$filesonlycount++;
|
|
$filecount = $filesonlycount;
|
|
}
|
|
else
|
|
$filecount++;
|
|
|
|
if($filecount == FILE_MAX_COUNT){
|
|
if(!createRestoreSetFiles1k("FILESONLY"))
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
#****************************************************************************************************
|
|
# Subroutine Name : createRestoreSetFiles1k.
|
|
# Objective : Construct the restore set file/files based on relative or no relative.
|
|
# Added By : Pooja Havaldar
|
|
# Modified By : Vijay Vinoth.
|
|
#*****************************************************************************************************/
|
|
function createRestoreSetFiles1k($filesOnly_flag='')
|
|
{
|
|
GLOBAL $Restorefilecount, $relative, $filesonly, $RestoreFile;
|
|
GLOBAL $filesOnlyFile_count, $filehandle, $fileOnlySetName;
|
|
GLOBAL $current_source,$noRelIndex, $filehandleNoRel;
|
|
GLOBAL $openRestoreFileOrg, $filecount, $filesonlycount,$RestoresetFile_filesOnly;
|
|
GLOBAL $RestoresetFile_relative, $RestoresetFile_norelative;
|
|
|
|
$Restorefilecount++;
|
|
session_write_close();
|
|
|
|
if($relative == 0)
|
|
{
|
|
if($filesOnly_flag == "FILESONLY")
|
|
{
|
|
$filesonly = 1;
|
|
$filesOnlyFile_count++;
|
|
fclose($filehandle);
|
|
file_put_contents(INFOFILE,"$fileOnlySetName ".NORELATIVE." $current_source\n",FILE_APPEND);
|
|
$fileOnlySetName = $RestoresetFile_filesOnly."_".$filesOnlyFile_count;
|
|
$filesonlycount = 0;
|
|
|
|
$filehandle = fopen($fileOnlySetName,"w");
|
|
@chmod($fileOnlySetName,PERMISSIONVAL);
|
|
if(!$filehandle)
|
|
{
|
|
traceLog("Unable to open file $fileOnlySetName, Reason: ".customErrorMsg());
|
|
return 0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
fclose($filehandleNoRel);
|
|
file_put_contents(INFOFILE,"$RestoreFile ".RELATIVE." $current_source\n",FILE_APPEND);
|
|
@chmod(INFOFILE,PERMISSIONVAL);
|
|
$RestoreFile = $RestoresetFile_norelative."$noRelIndex"."_$Restorefilecount";
|
|
$filehandleNoRel = fopen($RestoreFile,"w");
|
|
@chmod($RestoreFile,PERMISSIONVAL);
|
|
if(!$filehandleNoRel)
|
|
{
|
|
traceLog("Unable to open file $RestoreFile, Reason: ".customErrorMsg());
|
|
return 0;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
fclose($filehandle);
|
|
file_put_contents(INFOFILE,"$RestoreFile ".RELATIVE." $current_source\n",FILE_APPEND);
|
|
@chmod(INFOFILE,PERMISSIONVAL);
|
|
$RestoreFile = $RestoresetFile_relative."_$Restorefilecount";
|
|
@chmod($RestoreFile,PERMISSIONVAL);
|
|
|
|
$filehandle = fopen($RestoreFile,"w");
|
|
@chmod($RestoreFile,PERMISSIONVAL);
|
|
if(!$filehandle)
|
|
{
|
|
traceLog("Unable to open file $RestoreFile, Reason: ".customErrorMsg());
|
|
return 0;
|
|
}
|
|
|
|
if($isLocalRestore == 1)
|
|
{
|
|
fclose($openRestoreFileOrg);
|
|
$openRestoreFileOrg = fopen($RestoreFile."_org","a");
|
|
if(!$openRestoreFileOrg)
|
|
{
|
|
traceLog("Can't open $RestoreFile"."_org to write, Reason: ".customErrorMsg());
|
|
return 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
$filecount = 0;
|
|
return CREATE_THOUSANDS_FILES_SET_SUCCESS;
|
|
}
|
|
|
|
#****************************************************************************************************
|
|
# Subroutine Name : writeActualAndEncSet.
|
|
# Objective : write actual file name to actual file set amd fire sql query, construct
|
|
# enc path then write to enc set file.
|
|
# Added By : Vijay Vinoth.
|
|
#*****************************************************************************************************/
|
|
function writeActualAndEncSet($fileName)
|
|
{
|
|
GLOBAL $dbh_LB, $current_source, $totalFiles, $RestoreFile, $localBackupLocationFile;
|
|
GLOBAL $filecount, $dedupDetailFile, $deDup, $hostNameLB, $username;
|
|
$fileNameInput = $fileName;
|
|
$ridx = strrpos($fileName, "/");
|
|
$folderPath = substr($fileName, 0, $ridx+1);
|
|
$fileName = substr($fileName, $ridx+1);
|
|
$preStatement = "";
|
|
$serverRoot = $serverRootSlash = '';
|
|
|
|
if(file_exists($localBackupLocationFile)) {
|
|
$deDup = true;
|
|
$dbpaths = $hostNameLB . '/' . $username . '/dbpaths.xml';
|
|
$serverRoot = getServerRoot($dbpaths,$localBackupLocationFile);
|
|
|
|
if(file_exists($dedupDetailFile)) {
|
|
$serverRootSlash = '/' . $serverRoot;
|
|
}
|
|
}
|
|
|
|
$statement = "select FOLDER_ID, ENC_NAME from ibfile where NAME=? AND DIRID=(select DIRID from ibfolder where NAME=?)";
|
|
|
|
try
|
|
{
|
|
if($dbh_LB)
|
|
{
|
|
$preStatement = $dbh_LB->prepare($statement);
|
|
$fileName = "'$fileName'";
|
|
$folderPath = "'$serverRoot$folderPath'";
|
|
$status = $preStatement->execute(array($fileName,$folderPath));
|
|
}
|
|
}
|
|
catch (PDOException $e)
|
|
{
|
|
|
|
$errStr = "Couldn't prepare statement.";
|
|
//traceLog("Can't execute SELECT query, Reason: ".$e->getMessage());
|
|
}
|
|
|
|
$row = $preStatement->fetch();
|
|
$preStatement->closeCursor();
|
|
|
|
if(empty($row))
|
|
{
|
|
$errStr = "Couldn't prepare statement.";
|
|
return LOCAL_FILE_FOLDER_SELECT_FAILURE;
|
|
//traceLog($errStr);
|
|
}
|
|
$startIndex = strpos ($fileNameInput, '/',1);
|
|
$next_source = substr($fileNameInput, 0, $startIndex);
|
|
|
|
if($current_source != $next_source)
|
|
{
|
|
if($filecount > 0)
|
|
{
|
|
if(!createRestoreSetFiles1k(""))
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
$current_source = $next_source;
|
|
}
|
|
|
|
$totalFiles++;
|
|
$folderId = $row[0];
|
|
$encName = $row[1];
|
|
file_put_contents($RestoreFile."_org",$serverRootSlash.$fileNameInput.LINEFEED,FILE_APPEND);
|
|
file_put_contents($RestoreFile,"/$folderId/$encName".LINEFEED,FILE_APPEND);
|
|
@chmod($RestoreFile,PERMISSIONVAL);
|
|
return LOCAL_SELECT_SUCCESS;
|
|
}
|
|
|
|
#****************************************************************************************************
|
|
# Subroutine Name : enumerateLocal.
|
|
# Objective : Take localfolder as argument and execute sqlite query on that. Create set of 1k
|
|
# files. Count number of files considered for restore.
|
|
# Added By : Vijay Vinoth.
|
|
#*****************************************************************************************************/
|
|
function enumerateLocal($dirName)
|
|
{
|
|
GLOBAL $dbh_LB, $RestoreFile, $filecount, $totalFiles, $totalSize;
|
|
GLOBAL $dedupDetailFile, $hostNameLB, $username, $localBackupLocationFile;
|
|
$serverRoot = $serverRootSlash = '';
|
|
|
|
/*if(!file_exists(PIDFILE))
|
|
break;*/
|
|
|
|
if(file_exists($localBackupLocationFile)) {
|
|
$dbpaths = $hostNameLB.'/'.$username.'/dbpaths.xml';
|
|
$serverRoot = getServerRoot($dbpaths,$localBackupLocationFile);
|
|
|
|
if(file_exists($dedupDetailFile)) {
|
|
$serverRootSlash = '/';
|
|
}
|
|
}
|
|
|
|
|
|
$statementNew = "SELECT FOLDER_ID, ENC_NAME, ibfile.NAME, ibfolder.NAME, ibfile.FILE_SIZE from ibfile INNER JOIN ibfolder ON ibfolder.DIRID = ibfile.DIRID where ibfolder.NAME like ?";
|
|
|
|
try
|
|
{
|
|
$preStatementNew = $dbh_LB->prepare($statementNew);
|
|
$dirName = "'$serverRoot$dirName/%";
|
|
$preStatementNew->execute(array($dirName));
|
|
}
|
|
catch (PDOException $e)
|
|
{
|
|
//traceLog("Can't execute SELECT query, Reason: ".$e->getMessage());
|
|
return LOCAL_FILE_FOLDER_SELECT_FAILURE;
|
|
}
|
|
|
|
while($folderIdEncActNamerow = $preStatementNew->fetch())
|
|
{
|
|
$folderName = substr($folderIdEncActNamerow[3], 1, -1);
|
|
$fileName = substr($folderIdEncActNamerow[2], 1, -1);
|
|
$totalSize += $folderIdEncActNamerow[4];
|
|
|
|
# write actual file name to restore_org file
|
|
file_put_contents($RestoreFile."_org",$serverRootSlash.$folderName.$fileName.LINEFEED,FILE_APPEND);
|
|
@chmod($RestoreFile."_org",PERMISSIONVAL);
|
|
|
|
# write encrypted file name to restore file
|
|
file_put_contents($RestoreFile,"/$folderIdEncActNamerow[0]/$folderIdEncActNamerow[1]".LINEFEED,FILE_APPEND);
|
|
@chmod($RestoreFile,PERMISSIONVAL);
|
|
|
|
$totalFiles++;
|
|
$filecount++;
|
|
|
|
if($filecount == FILE_MAX_COUNT){
|
|
if(!file_exists(PIDFILE))
|
|
break;
|
|
|
|
if(!createRestoreSetFiles1k(""))
|
|
return THOUSANDS_FILES_SET_ERROR;
|
|
}
|
|
}
|
|
|
|
$preStatementNew->closeCursor();
|
|
return LOCAL_SELECT_SUCCESS;
|
|
}
|
|
|
|
#****************************************************************************************************
|
|
# Subroutine Name : createRestoreSetFromFolder.
|
|
# Objective : Take remote folder as argument and execute serach/DB query on that
|
|
# Create set of 1k files. Count number of files considered for restore.
|
|
# Added By : Avinash Kumar.
|
|
#*****************************************************************************************************/
|
|
function createRestoreSetFromFolder($dirName)
|
|
{
|
|
GLOBAL $RestoresetFile_norelative, $noRelIndex, $isLocalRestore, $filecount;
|
|
GLOBAL $relative, $filehandleNoRel, $current_source;
|
|
GLOBAL $RestoreFile, $errStr;
|
|
|
|
if($relative == 0)
|
|
{
|
|
$Restorefilecount = 0;
|
|
$noRelIndex++;
|
|
$RestoreFile = $RestoresetFile_norelative."$noRelIndex";
|
|
$filecount = 0;
|
|
$sourceIdx = strrpos($dirName, "/");
|
|
$source[$noRelIndex]= substr($dirName, 0, $sourceIdx);
|
|
|
|
if($source[$noRelIndex] == "")
|
|
$source[$noRelIndex] = "/";
|
|
|
|
$current_source = $source[$noRelIndex];
|
|
$filehandleNoRel = fopen($RestoreFile,"w");
|
|
@chmod($RestoreFile,PERMISSIONVAL);
|
|
if(!$filehandleNoRel)
|
|
{
|
|
$errStr = "Cannot open file $RestoreFile, Reason: ".customErrorMsg();
|
|
traceLog($errStr);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
$resEnumerate = 0;
|
|
|
|
if($isLocalRestore == 1)
|
|
{
|
|
$startIndex = strpos($dirName, "/",1);
|
|
if($startIndex == -1 || $startIndex == '')
|
|
$next_source = $dirName;
|
|
else
|
|
$next_source = substr($dirName, 0, $startIndex);
|
|
|
|
if($current_source != $next_source)
|
|
{
|
|
if($filecount > 0)
|
|
{
|
|
if(!createRestoreSetFiles1k(""))
|
|
return false;
|
|
}
|
|
$current_source = $next_source;
|
|
}
|
|
$resEnumerate = enumerateLocal($dirName);
|
|
}
|
|
else
|
|
$resEnumerate = enumerateRemote($dirName);
|
|
|
|
|
|
if($resEnumerate === false){
|
|
return false;
|
|
}
|
|
else if((REMOTE_SEARCH_CMD_ERROR == $resEnumerate) || (REMOTE_SEARCH_FAIL == $resEnumerate) || (REMOTE_SEARCH_OUTPUT_PARSE_FAIL == $resEnumerate) || (LOCAL_FILE_FOLDER_SELECT_FAILURE == $resEnumerate)){
|
|
appendEnumerationError($dirName);
|
|
}
|
|
else if((REMOTE_SEARCH_THOUSANDS_FILES_SET_ERROR == $resEnumerate) || (REMOTE_SEARCH_RELOGIN == $resEnumerate)){
|
|
return false;
|
|
}
|
|
|
|
if($filecount == 0)
|
|
@unlink($RestoreFile);
|
|
|
|
if($relative == 0 and $filecount > 0){
|
|
$FD_WRITE = fopen(INFOFILE, 'a');
|
|
if(!$FD_WRITE)
|
|
traceLog("Unable to open ".INFOFILE.", Reason: ".customErrorMsg());
|
|
else{
|
|
fwrite($FD_WRITE, "$RestoreFile ".RELATIVE." $current_source\n");
|
|
fclose($FD_WRITE);
|
|
}
|
|
|
|
@chmod(INFOFILE,PERMISSIONVAL);
|
|
$filecount = 0;
|
|
|
|
if(ftell($filehandleNoRel) != -1)
|
|
fclose($filehandleNoRel);
|
|
}
|
|
|
|
if($errStr != "")
|
|
traceLog($errStr);
|
|
return true;
|
|
}
|
|
|
|
#****************************************************************************************************
|
|
# Subroutine Name : enumerateRemote.
|
|
# Objective : Take remote folder as argument and execute search on that. Create set of 1k
|
|
# files. Count number of files considered for restore.
|
|
# Added By : Avinash Kumar.
|
|
# Modified By : Sabin Cheruvattil
|
|
#*****************************************************************************************************/
|
|
function enumerateRemote($remoteFolder, $retry = 0)
|
|
{
|
|
GLOBAL $idevsutilBinaryPath, $relative, $current_source, $filehandleNoRel, $RestoreFile, $totalFiles, $filecount, $totalSize;
|
|
GLOBAL $dedupDetailFile, $dedupRestoreDeviceID, $errStr, $checkCPUUsage;
|
|
|
|
if(++$checkCPUUsage%100 === 0)
|
|
usleep(1000); // 1000 == 1 millisecond
|
|
|
|
/*if(!file_exists(PIDFILE))
|
|
break;*/
|
|
|
|
$searchForRestore = 1;
|
|
# remove / from begining for folder to avoid // while creating utf8 file.
|
|
if($retry == 0)
|
|
$remoteFolder = substr($remoteFolder, 1);
|
|
|
|
# final EVS command to execute
|
|
if(!is_dir(SEARCH))
|
|
{
|
|
if(!mkdir(SEARCH, PERMISSIONVAL))
|
|
{
|
|
$errStr = "Cannot create search directory, Reason: ".customErrorMsg();
|
|
traceLog("$errStr");
|
|
return false;
|
|
}
|
|
}
|
|
|
|
# get utf8 file for EVS search command execute.
|
|
$searchUtfFile = getOperationFile(array("opType" => SEARCH,
|
|
"searchPatteren" => $remoteFolder,
|
|
"searchForRestore" => $searchForRestore));
|
|
$searchUtfFile = "'".$searchUtfFile."'";
|
|
|
|
if(!chdir(SEARCH))
|
|
{
|
|
$errStr = "Cannot change directory to search, Reason: ".customErrorMsg()."\n";
|
|
traceLog("$errStr");
|
|
return false;
|
|
}
|
|
|
|
$idevsutilCommandLine = $idevsutilBinaryPath.WHITESPACE.IDEVSUTIL_ARG.ASSIGNMENTOP.$searchUtfFile;
|
|
# EVS command execute
|
|
$res = `$idevsutilCommandLine`;
|
|
|
|
$res = trim($res);
|
|
if($res != '')
|
|
{
|
|
$errStr = "Search cmd error found [$res $searchUtfFile]\n";
|
|
traceLog("$errStr");
|
|
chdir("..");
|
|
return REMOTE_SEARCH_CMD_ERROR;
|
|
}
|
|
|
|
# update server address if cmd failed due to wrong evs server address
|
|
if(checkErrorAndUpdateServerAddr()){
|
|
$retVal = enumerateRemote($remoteFolder,1);
|
|
if($retVal != REMOTE_SEARCH_SUCCESS)
|
|
return $retVal;
|
|
}
|
|
|
|
if(customFileSize(ERRORFILE) > 0)
|
|
{
|
|
$error = file_get_contents(ERRORFILE);
|
|
checkDedupDeviceError($error);
|
|
@unlink($searchUtfFile);
|
|
chdir("..");
|
|
if(stristr($error,"failed to get the device information") || stristr($error,"encryption verification failed") || stristr($error,"bad response from proxy") || stristr($error,"Unable to proceed as device is deleted/removed")){
|
|
$errStr = "Operation could not be completed. Reason :".$error;
|
|
traceLog("REMOTE_SEARCH_RELOGIN");
|
|
return REMOTE_SEARCH_RELOGIN;
|
|
}
|
|
traceLog("REMOTE_SEARCH_FAIL");
|
|
$errStr = "Remote folder enumeration has failed.\n";
|
|
return REMOTE_SEARCH_FAIL;
|
|
}
|
|
|
|
@unlink($searchUtfFile);
|
|
|
|
$handle = fopen(OUTPUTFILE, "r");
|
|
if(!$handle){
|
|
chdir("..");
|
|
return REMOTE_SEARCH_OUTPUT_PARSE_FAIL;
|
|
}
|
|
|
|
if(!chdir(".."))
|
|
{
|
|
//$errStr = "Cannot change directory to job directory, Reason: ".customErrorMsg();
|
|
//traceLog("$errStr");
|
|
return false;
|
|
}
|
|
|
|
$itemsFound = '/files_found/';
|
|
if(file_exists($dedupDetailFile))
|
|
$itemsFound = '/items_found/';
|
|
|
|
$extendedAsciiChars = getExtendedASCIIChrOrd();
|
|
while(1){
|
|
$buffer = fread($handle, LIMIT);
|
|
|
|
if(!file_exists(PIDFILE))
|
|
break;
|
|
|
|
if(0 === strlen($buffer)){
|
|
if(customFileSize(ERRORFILE)){
|
|
$error = file_get_contents(ERRORFILE);
|
|
checkDedupDeviceError($error);
|
|
break;
|
|
}
|
|
sleep(WAIT_FOR);
|
|
fseek($handle, 0, 1); //to clear eof flag
|
|
continue;
|
|
}
|
|
|
|
//need to check appending partial record to packet or to first line of packet
|
|
if("" != $lastLine)
|
|
$buffer = $lastLine.$buffer;
|
|
|
|
if(!preg_match('/\n$/', $buffer)){
|
|
$lastNewlinePos = strrpos($buffer, "\n");
|
|
$resultList = substr($buffer,0,$lastNewlinePos+1);
|
|
$lastLine = substr($buffer,$lastNewlinePos+1);
|
|
} else {
|
|
$resultList = $buffer;
|
|
$lastLine = '';
|
|
}
|
|
|
|
if(preg_match($itemsFound, $resultList))
|
|
$flag = 1;
|
|
|
|
$noOfLines = substr_count($resultList,"\n");
|
|
$resultListXML = $resultListXMLOri = "<root>$resultList</root>";
|
|
|
|
$xml = simplexml_load_string($resultListXML);
|
|
|
|
$isutf8 = FALSE;
|
|
if(!$xml) {
|
|
$resultListXML = utf8_encode($resultListXML);
|
|
$xml = simplexml_load_string($resultListXML);
|
|
$isutf8 = TRUE;
|
|
}
|
|
|
|
if(!$xml) {
|
|
$resultListXML = str_replace($extendedAsciiChars['chr'], $extendedAsciiChars['ord'], $resultListXMLOri);
|
|
$xml = simplexml_load_string($resultListXML);
|
|
$isutf8 = FALSE;
|
|
}
|
|
|
|
if(!$xml) {
|
|
if($flag === 1)
|
|
break;
|
|
|
|
continue;
|
|
}
|
|
|
|
foreach ($xml->item as $value) {
|
|
$fileName[5] = trim($value['fname'], "\n");
|
|
|
|
if($isutf8) {
|
|
$fileName[5] = utf8_decode($fileName[5]);
|
|
}
|
|
|
|
$totalSize += $value['size'];
|
|
$temp = $fileName[5];
|
|
$quoted_remoteFolder = $remoteFolder;
|
|
$quoted_current_source = $current_source;
|
|
$quoted_remoteFolder = $quoted_remoteFolder."/";
|
|
/** To Test Retry
|
|
if($filecount%2 != 0)
|
|
$temp = $temp."_ODD";
|
|
**/
|
|
if(strpos( $temp, $quoted_remoteFolder ) !== false) {
|
|
if($relative == 0) {
|
|
if($current_source != "/") {
|
|
$temp = substr($temp, strlen($quoted_current_source));
|
|
if($temp) {
|
|
//file_put_contents($RestoreFile,$temp.LINEFEED,FILE_APPEND);
|
|
fwrite($filehandleNoRel,$temp.LINEFEED);
|
|
$totalFiles++;
|
|
$filecount++;
|
|
}
|
|
} else {
|
|
//file_put_contents($RestoreFile,$temp.LINEFEED,FILE_APPEND);
|
|
fwrite($filehandleNoRel,$temp.LINEFEED);
|
|
$totalFiles++;
|
|
$filecount++;
|
|
}
|
|
} else {
|
|
$current_source = "/";
|
|
//file_put_contents($RestoreFile,$temp.LINEFEED,FILE_APPEND);
|
|
fwrite($filehandleNoRel,$temp.LINEFEED);
|
|
$totalFiles++;
|
|
$filecount++;
|
|
}
|
|
}
|
|
|
|
if($filecount == FILE_MAX_COUNT) {
|
|
if(!file_exists(PIDFILE))
|
|
break;
|
|
if(!createRestoreSetFiles1k("")) {
|
|
traceLog($errStr);
|
|
return REMOTE_SEARCH_THOUSANDS_FILES_SET_ERROR;
|
|
}
|
|
}
|
|
}
|
|
|
|
if($flag == 1)
|
|
break;
|
|
}
|
|
|
|
@chmod($RestoreFile,PERMISSIONVAL);
|
|
traceLog($errStr);
|
|
return REMOTE_SEARCH_SUCCESS;
|
|
}
|