<?php
include_once 'path.php';

$is_periodic 				= false;
$_SESSION["progress_stat"]	= 0;
$pidPathForSearch 			= "";
$backupset_display 			= "";
$archive_per 				= '';
$selected_backupset 		= '';
$total_perc 				= 0;
$archive 					= 0;
$periodic_perc_error 		= 0;
$emptyFoldersList			= '';

$currentPath			= getcwd();
if($userName == '') {
	$userName 				= getUserName($currentPath);
	$nasUsername	= getNasUserName($currentPath);
	Scheduler::SetSchedulerPath($webDir, $userName, $nasUsername, $machine);
}
unset($_SESSION['serverAddr']);
getEVSServerAddr();

$pcntlProcess = 0;
# Subroutine that processes SIGINT and SIGTERM signal received by the script during backup 
if( extension_loaded('pcntl') && function_exists('pcntl_signal') ){
	declare(ticks = 1);
	pcntl_signal(SIGTERM, 'process_term');// Termination ('kill' was called)
	pcntl_signal(SIGINT, 'process_term'); // Interrupted (Ctrl-C is pressed)

}
# This runs in background, so session will be invalid. Re-assign the values so that the scripts can pick the user from Scheduler
# This change helps in logging also
$archive_dir				= Scheduler::$archiveclean_dir;

if(!empty($argv[2])) {
	$backupset_display 			= $argv[2];
	$_SESSION['archive_per'] 	= $argv[1];
	$archive_per 				= $_SESSION['archive_per'];
	$selected_backupset 		= Scheduler::$manual_dir;
	$jobName 					= $selected_backupset;
	$pidPathForSearch 			= "{$archive_dir}{$jobName}/{$pidPath}";
} else {		
	$splitPath 		= explode("/", $currentPath);
	$currentDir 	= $splitPath[count($splitPath) - 1];
	$jobName 		= startPeriodicCleanup($currentDir);
	$is_periodic 	= true;

	if(empty($jobName) || empty($userName)) {
		Scheduler::Log("Jobname or user name is empty. jobname: $jobName Username: $userName");
		fclose($handle);
		return;
	}
}

Scheduler::Log(AR_PERIODIC . "pidpath" . $pidPathForSearch);
@chmod($archive_dir,$permissionVal);
@chmod($jobName,$permissionVal);
$handle = NULL;
if(!($handle = fopen($pidPathForSearch, "w"))){
	Scheduler::Log(AR_PERIODIC . "[$jobName]" . AR_FAILED . AR_PID_MISS);
	exit;
}
else{
	@chmod($pidPathForSearch,$permissionVal);
	if(!flock($handle, LOCK_EX|LOCK_NB)){
		Scheduler::Log("Not able to lock " . $pidPathForSearch);	
	}
	fwrite($handle, ARCHIVE_JOB);
}

$restoreList	= Scheduler::$restore_list_dir."/";
$searchDir 		= Scheduler::$user_dir."Restore/.+searchList";

$cleanupStatusFile	= "$archive_dir$jobName/".CLEANUP_STATUS;
Scheduler::Log("Cleanup status File [$cleanupStatusFile]");

$resultFile = "$archive_dir$jobName/".ARCHIVERESULT;
$emptyFoldersList = "$archive_dir$jobName/".EMPTY_FOLDERS_LIST;
$backupLocation = Scheduler::GetHost($userName);
Scheduler::Log("Cleanup[backupLocation] $backupLocation");

if(isset($jobName)){
	cleanupOperation();
}
else{
	$_SESSION["progress_stat"] = 1;
}
/****************************************************************************************************
* Function Name         : cleanupOperation
* Objective             : Function for doing cleanup operation.
* Added By              : Sajana K
*****************************************************************************************************/
function cleanupOperation()
{
	GLOBAL $backupset_display;
	GLOBAL $excludePartialFilePath;
	GLOBAL $pidPathForSearch;
	GLOBAL $backupLocation;
	GLOBAL $resultFile;
	GLOBAL $archive_per;
	GLOBAL $archive_dir;
	GLOBAL $jobName; 
	GLOBAL $OutOutputFilePath;
	GLOBAL $is_periodic;
	GLOBAL $cleanupStatusFile;
	GLOBAL $selected_backupset;
	GLOBAL $archive, $filesOnly, $countFile;
	GLOBAL $emptyFoldersList,$permissionVal,$dedupDetailFile;
	
	@unlink($cleanupStatusFile);
	
	$errStr = "";
	$filesOnly = "$archive_dir$jobName/".FILESONLY;
	
	$backup_set = array();
	$archive = 1;
	
	$countFile = "$archive_dir$jobName/".ARCHIVECOUNT;
	
	if(file_exists($backupset_display) && customFileSize($backupset_display)>0)
	{	
		$total_count = 0;
		$not_exit_count = 0;
		$hiddenFlag = false;
		
		$_SESSION['operation_status'] = "scanning";
		$_SESSION['total_count'] = $total_count;
		$_SESSION['files_scanned'] = "";
		$backupset_display_content = file_get_contents($backupset_display);

		$backup_set = explode("\n",$backupset_display_content);
		$backup_set_count = count($backup_set)-1;
		$count = 0;
		$ret = showHiddenStatus();
		if($ret == "Hide")
			$hiddenFlag = true;
		
		session_write_close();

		for($m = 0; $m < $backup_set_count; $m = $m+4) {
			if($hiddenFlag === true) {
				if(preg_match("/\/\./",$backup_set[$m],$matches))
					continue;
			} 
			
			if($backup_set[$m+1]=="file")
			{	
				$count++;
				if(($count % 10 == 0) && !file_exists($pidPathForSearch)) {
					$errStr= 'ERR_STR_VAL';
					session_start();
					errorcleanup($errStr);
				}
				
				if(file_exists($dedupDetailFile))
					$file_name = $backup_set[$m] . "\n";
				else
					$file_name = $backupLocation . $backup_set[$m] . "\n";
				file_put_contents($filesOnly, $file_name, FILE_APPEND);
				@chmod($filesOnly,$permissionVal);
			} else {
				if(!file_exists($pidPathForSearch)){
					$errStr= 'ERR_STR_VAL';
					session_start();
					errorcleanup($errStr);
				}   
				if(file_exists($dedupDetailFile))
					$searchPath=$backup_set[$m]."/";
				else
					$searchPath=$backupLocation.$backup_set[$m]."/";
				$errStr = getArchiveSearchResult($searchPath,$jobName);
				if($errStr != ""){
					session_start();
					errorcleanup($errStr);
				}
			}
		}
		# checking file status in remote
		if(file_exists($filesOnly)) {
			$filestatusflag = fileStatusRemote(FILESTATUSOP,$filesOnly);
			if($filestatusflag === true){
				$OutOutputFilePath = "$archive_dir$jobName/".OUTPUTFILE;
				rename($filesOnly, $OutOutputFilePath);
				$cmd = getCleanupCmd($jobName);
				exec($cmd);
			} 
		}
		
		session_start();
		$_SESSION["progress_stat"] = 1;

		if(file_exists($countFile)) {
			$values = file_get_contents($countFile);
			$tempval=explode("\n",$values);
			$total_count = isset($tempval[2])?$tempval[2]:0;
			$not_exit_count = isset($tempval[3])?$tempval[3]:0;
		}
		
		if($not_exit_count > 0 && $total_count > 0){
			$errStr = calcArchivePerc($not_exit_count, $total_count);	
			if($is_periodic == true){
				$deleteFile = Scheduler::$archiveclean_dir.$selected_backupset."/".ARCHIVERESULT;
				$archiveDelStatus = deleteItems(PERIODICARCHIVEOP,$deleteFile, "", $not_exit_count);
				/* checking delete status for periodic cleanup and writing the error msgs to log file.*/
				if($archiveDelStatus == 'AR_DEL_LOG_DIR')
					$delLog = AR_FAILED.AR_DEL_LOG_DIR;
				else if($archiveDelStatus == 'AR_DEL_LOG')
					$delLog = AR_FAILED.AR_DEL_LOG;
				else if($archiveDelStatus == 'AR_PID')
					$delLog = AR_FAILED.AR_PID;
				else
					$delLog = $archiveDelStatus;
				Scheduler::Log(AR_PERIODIC . "[$jobName]" . $delLog);
			}		
		}
		else
			$errStr = 'AR_NO_ITEM';
	}
	else
		$errStr = 'AR_FILE_MISS';
	
errorcleanup($errStr);	
}

/****************************************************************************************************
* Function Name         : errorcleanup
* Objective             : 
* Added By              : 
*****************************************************************************************************/
function errorcleanup($errStr = '')
{
	GLOBAL $is_periodic, $jobName, $cleanupStatusFile, $pidPathForSearch, $countFile, $filesOnly, $OutOutputFilePath, $permissionVal, $handle, $archive_dir, $selected_backupset;
	
	fclose($handle);
	if($errStr != ""){
		if($is_periodic==true){
			/* changed by Avinash 04-07-2016 */
			//Scheduler::debug_Log(AR_PERIODIC . "[$jobName]" . AR_FAILED . $errStr);
			Scheduler::Log(AR_PERIODIC . "[$jobName]" . AR_FAILED . AR_NO_ITEM);
			
		} else{
			file_put_contents($cleanupStatusFile,"ERR=$errStr\n",FILE_APPEND);
		}
	}
	
	$_SESSION["progress_stat"] = 1;
	file_put_contents($cleanupStatusFile,"progress_stat=1\n",FILE_APPEND);
	@chmod($cleanupStatusFile,$permissionVal);
	
	if($is_periodic == true || $errStr != 'AR_DATA_READY'){	
		@unlink($pidPathForSearch);
	}
	if(file_exists($countFile) && ($errStr != 'AR_PERC_ERR' || $is_periodic == true)){
		
		//	unlink($countFile);
	}
	if($errStr == 'AR_PERC_ERR'){
		$temp = $archive_dir."/$selected_backupset/temp/";
		if(is_dir($temp))
			removeItems($temp);
	}
	if(file_exists($filesOnly))
		unlink($filesOnly);
	if(file_exists($OutOutputFilePath))
		unlink($OutOutputFilePath);
	
	exit;
}

/****************************************************************************************************
* Function Name         : calcArchivePerc
* Objective             : Calculating archive percentage for Cleanup
* Added By              : Sajana K
*****************************************************************************************************/
//function calcArchivePerc($not_exit_count, $total_count ,$resultFile)
function calcArchivePerc($not_exit_count, $total_count )
{	
	GLOBAL $jobName;
	GLOBAL $is_periodic;
	GLOBAL $cleanupStatusFile;
	GLOBAL $archive_per;
	GLOBAL $total_perc;
	GLOBAL $periodic_perc_error;
	
	$error = "";
	
	$per_count = ($not_exit_count/$total_count)*100; 
	$per_count_rnd = round($per_count,2);
	$total_perc = $per_count_rnd;
	
	if($is_periodic == false){
		if($archive_per >= $per_count)
			$error = 'AR_DATA_READY'; 
		else
			$error = 'AR_PERC_ERR';
	}
	else{
		if($archive_per >= $per_count){
			$periodic_perc_error = 1;
		}
		else{
			$periodic_perc_error = 0;
			Scheduler::Log(AR_PERIODIC . "[$jobName]" . AR_FAILED . AR_PERC_ERR);
		}
	}
	return $error;
}	

/****************************************************************************************************
* Function Name         : getArchiveSearchResult
* Objective             : Function for getting the remoteList for Cleanup.
* Added By              : Sajana K
# Modified By			: Sabin Cheruvattil
*****************************************************************************************************/
function getArchiveSearchResult($searchPath,$jobName)
{
	GLOBAL $idevsutilBinaryPath, $whiteSpace, $idevsutilArgument, $assignmentOperator;
	GLOBAL $archive_dir, $pidPathForSearch, $OutErrorFilePath, $OutOutputFilePath;
	GLOBAL $permissionVal, $appPath, $is_periodic, $emptyFoldersList, $archiveUtfFile;
	#GLOBAL $dedupDetailFile;
	
	$searchItem = "*";
	$errStr = "";
	
	/* to get the php error message in $php_errormsg variable. */
	ini_set('track_errors', 1);			
	
	/* get the utf8 file for search operation for archive cleanup */

	$archiveUtfFile = getOperationFile(SEARCHOP, $searchItem, $searchPath);
	@chmod($archiveUtfFile,$permissionVal);
	if(!file_exists($archiveUtfFile)){
		$errStr= 'AR_START_ERR';
		userCancel($errStr);
		return $errStr;
	}
	
	/* running the evs search command */
	$idevsutilCommandLine = $idevsutilBinaryPath.$whiteSpace.$idevsutilArgument.$assignmentOperator."\"$archiveUtfFile\"";

	pclose(popen("$idevsutilCommandLine &","r"));	 
	
	/* check till output or error file have some content */
	while(!@customFileSize($OutOutputFilePath) and !@customFileSize($OutErrorFilePath)){
		if(!file_exists($pidPathForSearch)){
			$errStr= 'ERR_STR_VAL';
			userCancel($errStr);
			return $errStr;
		}
		sleep(1);
	}	
	// added by anil on 6sep2017 for archive cleanup issue fix
	if(@customFileSize($OutErrorFilePath) > 0) {
		$evsError = file_get_contents($OutErrorFilePath);
		if(stristr($evsError,'ERROR'))
		{		
			if(stristr($evsError,'failed to get the device information') || stristr($evsError,'encryption verification failed'))
			{
				@unlink($dedupDetailFile);
			}
			$errStrArray = explode("\n",$evsError);		
			$matches = preg_grep("/@ERROR/", $errStrArray);
			$errStr = str_replace("@ERROR:","",$matches[0]);
			$evsError = ucfirst(trim($errStr)).". ".ERROR_RELOGIN;
			return $evsError;
		}
	}	
	
	/* run cleanup list perl only if process is still alive */
	if(file_exists($pidPathForSearch)){
		$cmd = getCleanupCmd($jobName);
		$isFolderEmpty = shell_exec($cmd);
		$isFolderEmpty = trim($isFolderEmpty);
		if($isFolderEmpty=='true'){
			file_put_contents($emptyFoldersList,"$searchPath\n",FILE_APPEND);
			@chmod($emptyFoldersList,$permissionVal);
		}
	}
	userCancel($errStr);
	return $errStr;
}
/****************************************************************************************************
* Function Name         : userCancel
* Objective             : 
* Added By              : 
*****************************************************************************************************/
function userCancel($errStr = '')
{
	GLOBAL $archiveUtfFile, $OutOutputFilePath, $OutErrorFilePath;
	if(file_exists($archiveUtfFile))
		unlink($archiveUtfFile);

	if(file_exists($OutOutputFilePath))
		unlink($OutOutputFilePath);

	if(file_exists($OutErrorFilePath))
		unlink($OutErrorFilePath);
}
/****************************************************************************************************
* Function Name         : startPeriodicCleanup
* Objective             : Function for starting periodic Cleanup.
* Added By              : Sajana K
*****************************************************************************************************/
function startPeriodicCleanup($periodicBackupset)
{
	GLOBAL $pidPath;
	GLOBAL $archive_dir;
	GLOBAL $pidPathForSearch;
	GLOBAL $backupset_display;
	GLOBAL $is_periodic;
	GLOBAL $permissionVal;
	GLOBAL $archive_per;
	GLOBAL $selected_backupset;
	GLOBAL $emptyFoldersList;
	
	$jobs = Scheduler::ReadJobs();						//call from command line
	$is_periodic = true;
	$selected_backupset = $periodicBackupset;
	$jobName = $periodicBackupset;
	$jobName_type = "Backup_".$jobName;
	$archive_per = $jobs[$jobName_type]["periodic"]["perc"];
     
	$backupset_display = Scheduler::$backup_dir.$jobName."/".BACKUPSETFILEDISPLAY;
	$pidPathForSearch = "$archive_dir$jobName/$pidPath";
	
	if(file_exists($pidPathForSearch))
		return;
	
	$countFile = "$archive_dir$jobName/".ARCHIVECOUNT;
	$resultFile = "$archive_dir$jobName/".ARCHIVERESULT;
	$jobcheckpath = Scheduler::$backup_dir;
	$jobRunning = checkIfJobRunning($jobcheckpath); // checking any job is running
	if($jobRunning == 1)
		Scheduler::Log(AR_PERIODIC . "[$jobName]Delaying cleanup operation. Reason: Backup is in progress.");
	
	session_write_close();
	while($jobRunning == 1){
		sleep(60);
		$jobcheckpath = Scheduler::$backup_dir;
		$jobRunning = checkIfJobRunning($jobcheckpath); // checking any job is running
	}
	session_start();
	
	if(file_exists($countFile))
		unlink($countFile);
		
	if(file_exists($resultFile))
		unlink($resultFile);
	
	$temp = $archive_dir."/$selected_backupset/temp/";
		
	if(is_dir($temp)){
		removeItems($temp);
	}
	$pidDir = "$archive_dir/$jobName";

	if(!is_dir($archive_dir)){
		if(!mkdir($archive_dir, $permissionVal)){
			echo "AR_DIR";
			Scheduler::Log(AR_PERIODIC . "[$jobName]file:startarchive" . AR_DIR);
			exit;
		}		
		@chmod($archive_dir,$permissionVal);
	}

	if(!is_dir($pidDir)){
		if(!mkdir($pidDir, $permissionVal)){
			echo "JOB_DIR";
			Scheduler::Log(AR_PERIODIC . "[$jobName]" . "file:startarchive" . AR_JOB);
			exit;
		}		
		@chmod($pidDir,$permissionVal);
	}
	return $jobName;
}

#****************************************************************************************************
# 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 			  : Pooja Havaldar, Sabin Cheruvattil
#*****************************************************************************************************/
function process_term($signal)
{
	GLOBAL $pidPathForSearch, $pidPath;;
	
	if(file_exists($pidPathForSearch)) {
		@unlink($pidPathForSearch);
	}
	if(file_exists($pidPath)) {
		@unlink($pidPath);
	}
}
exit;
?>