559 lines
16 KiB
PHP
559 lines
16 KiB
PHP
<?php
|
|
|
|
use Duplicator\Libs\Snap\SnapUtil;
|
|
|
|
defined('ABSPATH') || defined('DUPXABSPATH') || exit;
|
|
// Exit if accessed directly
|
|
if (!defined('DUPLICATOR_VERSION')) {
|
|
exit;
|
|
}
|
|
|
|
/**
|
|
* Helper Class for logging
|
|
*
|
|
* @package Duplicator\classes
|
|
*/
|
|
abstract class Dup_ErrorBehavior
|
|
{
|
|
const LogOnly = 0;
|
|
const ThrowException = 1;
|
|
const Quit = 2;
|
|
}
|
|
|
|
class DUP_Log
|
|
{
|
|
/**
|
|
* The file handle used to write to the package log file
|
|
*/
|
|
private static $logFileHandle = null;
|
|
|
|
/**
|
|
* Get the setting which indicates if tracing is enabled
|
|
*/
|
|
private static $traceEnabled = false;
|
|
|
|
public static $profileLogs = null;
|
|
|
|
/**
|
|
* Init this static object
|
|
*/
|
|
public static function Init()
|
|
{
|
|
self::$traceEnabled = (DUP_Settings::Get('trace_log_enabled') == 1);
|
|
}
|
|
|
|
/**
|
|
* Open a log file connection for writing to the package log file
|
|
*
|
|
* @param string $nameHas The Name of the log file to create
|
|
*
|
|
* @return nul
|
|
*/
|
|
public static function Open($nameHash)
|
|
{
|
|
if (!isset($nameHash)) {
|
|
throw new Exception("A name value is required to open a file log.");
|
|
}
|
|
self::Close();
|
|
if ((self::$logFileHandle = @fopen(DUP_Settings::getSsdirLogsPath() . "/{$nameHash}.log", "a+")) === false) {
|
|
self::$logFileHandle = null;
|
|
return false;
|
|
} else {
|
|
/**
|
|
* By initializing the error_handler on opening the log, I am sure that when a package is processed, the handler is active.
|
|
*/
|
|
DUP_Handler::init_error_handler();
|
|
return true;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Close the package log file connection if is opened
|
|
*
|
|
* @return bool Returns TRUE on success or FALSE on failure.
|
|
*/
|
|
public static function Close()
|
|
{
|
|
$result = true;
|
|
|
|
if (!is_null(self::$logFileHandle)) {
|
|
$result = @fclose(self::$logFileHandle);
|
|
self::$logFileHandle = null;
|
|
} else {
|
|
$result = true;
|
|
}
|
|
return $result;
|
|
}
|
|
|
|
/**
|
|
* General information send to the package log if opened
|
|
*
|
|
* REPLACE TO DEBUG: Memory consumption as script runs
|
|
* $results = DUP_Util::byteSize(memory_get_peak_usage(true)) . "\t" . $msg;
|
|
*
|
|
* @fwrite(self::$logFileHandle, "{$results} \n");
|
|
*
|
|
* @param string $msg The message to log
|
|
*
|
|
* @return null
|
|
*/
|
|
public static function Info($msg)
|
|
{
|
|
if (self::$traceEnabled) {
|
|
self::Trace($msg);
|
|
}
|
|
if (!is_null(self::$logFileHandle)) {
|
|
@fwrite(self::$logFileHandle, $msg . "\n");
|
|
}
|
|
}
|
|
|
|
/**
|
|
* General information send to the package log and trace log
|
|
*
|
|
* @param string $msg The message to log
|
|
*
|
|
* @return null
|
|
*/
|
|
public static function infoTrace($msg, $calling_function_override = null)
|
|
{
|
|
self::Info($msg);
|
|
self::Trace($msg, $calling_function_override);
|
|
}
|
|
|
|
public static function print_r_info($val, $name = '')
|
|
{
|
|
$msg = empty($name) ? '' : 'VALUE ' . $name . ': ';
|
|
$msg .= print_r($val, true);
|
|
self::info($msg);
|
|
}
|
|
|
|
/**
|
|
* Does the trace file exists
|
|
*
|
|
* @return bool Returns true if an active trace file exists
|
|
*/
|
|
public static function TraceFileExists()
|
|
{
|
|
$file_path = self::getTraceFilepath();
|
|
return file_exists($file_path);
|
|
}
|
|
|
|
/**
|
|
* Gets the current file size of the active trace file
|
|
*
|
|
* @return string Returns a human readable file size of the active trace file
|
|
*/
|
|
public static function getTraceStatus()
|
|
{
|
|
$file_path = DUP_Log::getTraceFilepath();
|
|
$backup_path = DUP_Log::getBackupTraceFilepath();
|
|
|
|
if (file_exists($file_path)) {
|
|
$filesize = is_file($file_path) ? @filesize($file_path) : 0;
|
|
|
|
//Its possible mulitple trace log files exist due to size
|
|
if (is_file($backup_path)) {
|
|
$filesize += @filesize($backup_path);
|
|
}
|
|
|
|
$message = sprintf('%1$s', DUP_Util::byteSize($filesize));
|
|
} else {
|
|
$message = esc_html__('No Log', 'duplicator');
|
|
}
|
|
|
|
return $message;
|
|
}
|
|
|
|
// RSR TODO: Swap trace logic out for real trace later
|
|
public static function Trace($message, $calling_function_override = null)
|
|
{
|
|
|
|
if (self::$traceEnabled) {
|
|
$unique_id = sprintf("%08x", abs(crc32($_SERVER['REMOTE_ADDR'] . $_SERVER['REQUEST_TIME'] . $_SERVER['REMOTE_PORT'])));
|
|
|
|
if ($calling_function_override == null) {
|
|
$calling_function = SnapUtil::getCallingFunctionName();
|
|
} else {
|
|
$calling_function = $calling_function_override;
|
|
}
|
|
|
|
if (is_object($message)) {
|
|
$ov = get_object_vars($message);
|
|
$message = print_r($ov, true);
|
|
} elseif (is_array($message)) {
|
|
$message = print_r($message, true);
|
|
}
|
|
|
|
$logging_message = "{$unique_id}|{$calling_function} | {$message}";
|
|
$ticks = time() + ((int) get_option('gmt_offset') * 3600);
|
|
$formatted_time = date('d-m-H:i:s', $ticks);
|
|
$formatted_logging_message = "{$formatted_time}|DUP|{$logging_message} \r\n";
|
|
|
|
// Always write to error log - if they don't want the info they can turn off WordPress error logging or tracing
|
|
self::ErrLog($logging_message);
|
|
|
|
// Everything goes to the plugin log, whether it's part of package generation or not.
|
|
self::WriteToTrace($formatted_logging_message);
|
|
}
|
|
}
|
|
|
|
public static function print_r_trace($val, $name = '', $calling_function_override = null)
|
|
{
|
|
$msg = empty($name) ? '' : 'VALUE ' . $name . ': ';
|
|
$msg .= print_r($val, true);
|
|
self::trace($msg, $calling_function_override);
|
|
}
|
|
|
|
public static function errLog($message)
|
|
{
|
|
$message = 'DUP:' . $message;
|
|
SnapUtil::errorLog($message);
|
|
}
|
|
|
|
public static function TraceObject($msg, $o, $log_private_members = true)
|
|
{
|
|
if (self::$traceEnabled) {
|
|
if (!$log_private_members) {
|
|
$o = get_object_vars($o);
|
|
}
|
|
self::Trace($msg . ':' . print_r($o, true));
|
|
}
|
|
}
|
|
|
|
public static function GetDefaultKey()
|
|
{
|
|
$auth_key = defined('AUTH_KEY') ? AUTH_KEY : 'atk';
|
|
$auth_key .= defined('DB_HOST') ? DB_HOST : 'dbh';
|
|
$auth_key .= defined('DB_NAME') ? DB_NAME : 'dbn';
|
|
$auth_key .= defined('DB_USER') ? DB_USER : 'dbu';
|
|
return hash('md5', $auth_key);
|
|
}
|
|
|
|
/**
|
|
* Gets the current file size of the old trace file "1"
|
|
*
|
|
* @return string Returns a human readable file size of the active trace file
|
|
*/
|
|
public static function GetBackupTraceFilepath()
|
|
{
|
|
$default_key = self::getDefaultKey();
|
|
$backup_log_filename = "dup_$default_key.log1";
|
|
$backup_path = DUP_Settings::getSsdirLogsPath() . "/" . $backup_log_filename;
|
|
return $backup_path;
|
|
}
|
|
|
|
/**
|
|
* Gets the active trace file path
|
|
*
|
|
* @return string Returns the full path to the active trace file
|
|
*/
|
|
public static function GetTraceFilepath()
|
|
{
|
|
$default_key = self::getDefaultKey();
|
|
$log_filename = "dup_$default_key.log";
|
|
$file_path = DUP_Settings::getSsdirLogsPath() . "/" . $log_filename;
|
|
return $file_path;
|
|
}
|
|
|
|
/**
|
|
* Deletes the trace log and backup trace log files
|
|
*
|
|
* @return null
|
|
*/
|
|
public static function DeleteTraceLog()
|
|
{
|
|
$file_path = self::GetTraceFilepath();
|
|
$backup_path = self::GetBackupTraceFilepath();
|
|
self::trace("deleting $file_path");
|
|
@unlink($file_path);
|
|
self::trace("deleting $backup_path");
|
|
@unlink($backup_path);
|
|
}
|
|
|
|
/**
|
|
* Called when an error is detected and no further processing should occur
|
|
*
|
|
* @param string $msg The message to log
|
|
* @param string $detail Additional details to help resolve the issue if possible
|
|
* @param int $behavior
|
|
*/
|
|
public static function error($msg, $detail = '', $behavior = Dup_ErrorBehavior::Quit)
|
|
{
|
|
|
|
SnapUtil::errorLog($msg . ' DETAIL:' . $detail);
|
|
$source = self::getStack(debug_backtrace());
|
|
|
|
$err_msg = "\n==================================================================================\n";
|
|
$err_msg .= "DUPLICATOR ERROR\n";
|
|
$err_msg .= "Please try again! If the error persists see the Duplicator 'Help' menu.\n";
|
|
$err_msg .= "---------------------------------------------------------------------------------\n";
|
|
$err_msg .= "MESSAGE:\n\t{$msg}\n";
|
|
if (strlen($detail)) {
|
|
$err_msg .= "DETAILS:\n\t{$detail}\n";
|
|
}
|
|
$err_msg .= "TRACE:\n{$source}";
|
|
$err_msg .= "==================================================================================\n\n";
|
|
@fwrite(self::$logFileHandle, "{$err_msg}");
|
|
|
|
switch ($behavior) {
|
|
case Dup_ErrorBehavior::ThrowException:
|
|
DUP_LOG::trace("throwing exception");
|
|
throw new Exception($msg);
|
|
break;
|
|
|
|
case Dup_ErrorBehavior::Quit:
|
|
DUP_LOG::trace("quitting");
|
|
die("DUPLICATOR ERROR: Please see the 'Backup Log' file link below.");
|
|
break;
|
|
|
|
default:
|
|
// Nothing
|
|
}
|
|
}
|
|
|
|
/**
|
|
* The current stack trace of a PHP call
|
|
*
|
|
* @param $stacktrace The current debug stack
|
|
*
|
|
* @return string
|
|
*/
|
|
public static function getStack($stacktrace)
|
|
{
|
|
$output = "";
|
|
$i = 1;
|
|
foreach ($stacktrace as $node) {
|
|
$output .= "\t $i. " . basename($node['file']) . " : " . $node['function'] . " (" . $node['line'] . ")\n";
|
|
$i++;
|
|
}
|
|
return $output;
|
|
}
|
|
|
|
/**
|
|
* Manages writing the active or backup log based on the size setting
|
|
*
|
|
* @return null
|
|
*/
|
|
private static function WriteToTrace($formatted_logging_message)
|
|
{
|
|
$log_filepath = self::GetTraceFilepath();
|
|
|
|
if (@file_exists($log_filepath) && @filesize($log_filepath) > DUPLICATOR_MAX_LOG_SIZE) {
|
|
$backup_log_filepath = self::GetBackupTraceFilepath();
|
|
|
|
if (file_exists($backup_log_filepath)) {
|
|
if (@unlink($backup_log_filepath) === false) {
|
|
self::errLog("Couldn't delete backup log $backup_log_filepath");
|
|
}
|
|
}
|
|
|
|
if (@rename($log_filepath, $backup_log_filepath) === false) {
|
|
self::errLog("Couldn't rename log $log_filepath to $backup_log_filepath");
|
|
}
|
|
}
|
|
|
|
if (@file_put_contents($log_filepath, $formatted_logging_message, FILE_APPEND) === false) {
|
|
// Not en error worth reporting
|
|
}
|
|
}
|
|
}
|
|
|
|
class DUP_Handler
|
|
{
|
|
const MODE_OFF = 0; // don't write in log
|
|
const MODE_LOG = 1; // write errors in log file
|
|
const MODE_VAR = 2; // put php errors in $varModeLog static var
|
|
const SHUTDOWN_TIMEOUT = 'tm';
|
|
|
|
/**
|
|
*
|
|
* @var bool
|
|
*/
|
|
private static $initialized = false;
|
|
|
|
/**
|
|
*
|
|
* @var array
|
|
*/
|
|
private static $shutdownReturns = array(
|
|
'tm' => 'timeout'
|
|
);
|
|
|
|
/**
|
|
*
|
|
* @var int
|
|
*/
|
|
private static $handlerMode = self::MODE_LOG;
|
|
|
|
/**
|
|
*
|
|
* @var bool // print code reference and errno at end of php error line [CODE:10|FILE:test.php|LINE:100]
|
|
*/
|
|
private static $codeReference = true;
|
|
|
|
/**
|
|
*
|
|
* @var bool // print prefix in php error line [PHP ERR][WARN] MSG: .....
|
|
*/
|
|
private static $errPrefix = true;
|
|
|
|
/**
|
|
*
|
|
* @var string // php errors in MODE_VAR
|
|
*/
|
|
private static $varModeLog = '';
|
|
|
|
/**
|
|
* This function only initializes the error handler the first time it is called
|
|
*/
|
|
public static function init_error_handler()
|
|
{
|
|
if (!self::$initialized) {
|
|
@set_error_handler(array(__CLASS__, 'error'));
|
|
@register_shutdown_function(array(__CLASS__, 'shutdown'));
|
|
self::$initialized = true;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Error handler
|
|
*
|
|
* @param integer $errno Error level
|
|
* @param string $errstr Error message
|
|
* @param string $errfile Error file
|
|
* @param integer $errline Error line
|
|
*
|
|
* @return void
|
|
*/
|
|
public static function error($errno, $errstr, $errfile, $errline)
|
|
{
|
|
switch (self::$handlerMode) {
|
|
case self::MODE_OFF:
|
|
if ($errno == E_ERROR) {
|
|
$log_message = self::getMessage($errno, $errstr, $errfile, $errline);
|
|
DUP_Log::error($log_message);
|
|
}
|
|
break;
|
|
case self::MODE_VAR:
|
|
self::$varModeLog .= self::getMessage($errno, $errstr, $errfile, $errline) . "\n";
|
|
break;
|
|
case self::MODE_LOG:
|
|
default:
|
|
switch ($errno) {
|
|
case E_ERROR:
|
|
$log_message = self::getMessage($errno, $errstr, $errfile, $errline);
|
|
DUP_Log::error($log_message);
|
|
break;
|
|
case E_NOTICE:
|
|
case E_WARNING:
|
|
default:
|
|
$log_message = self::getMessage($errno, $errstr, $errfile, $errline);
|
|
DUP_Log::Info($log_message);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
private static function getMessage($errno, $errstr, $errfile, $errline)
|
|
{
|
|
$result = '';
|
|
|
|
if (self::$errPrefix) {
|
|
$result = '[PHP ERR]';
|
|
switch ($errno) {
|
|
case E_ERROR:
|
|
$result .= '[FATAL]';
|
|
break;
|
|
case E_WARNING:
|
|
$result .= '[WARN]';
|
|
break;
|
|
case E_NOTICE:
|
|
$result .= '[NOTICE]';
|
|
break;
|
|
default:
|
|
$result .= '[ISSUE]';
|
|
break;
|
|
}
|
|
$result .= ' MSG:';
|
|
}
|
|
|
|
$result .= $errstr;
|
|
|
|
if (self::$codeReference) {
|
|
$result .= ' [CODE:' . $errno . '|FILE:' . $errfile . '|LINE:' . $errline . ']';
|
|
$result .= "\n" . wp_debug_backtrace_summary();
|
|
}
|
|
|
|
return $result;
|
|
}
|
|
|
|
/**
|
|
* if setMode is called without params set as default
|
|
*
|
|
* @param int $mode
|
|
* @param bool $errPrefix // print prefix in php error line [PHP ERR][WARN] MSG: .....
|
|
* @param bool $codeReference // print code reference and errno at end of php error line [CODE:10|FILE:test.php|LINE:100]
|
|
*/
|
|
public static function setMode($mode = self::MODE_LOG, $errPrefix = true, $codeReference = true)
|
|
{
|
|
switch ($mode) {
|
|
case self::MODE_OFF:
|
|
case self::MODE_VAR:
|
|
self::$handlerMode = $mode;
|
|
break;
|
|
case self::MODE_LOG:
|
|
default:
|
|
self::$handlerMode = self::MODE_LOG;
|
|
}
|
|
|
|
self::$varModeLog = '';
|
|
self::$errPrefix = $errPrefix;
|
|
self::$codeReference = $codeReference;
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @return string // return var log string in MODE_VAR
|
|
*/
|
|
public static function getVarLog()
|
|
{
|
|
return self::$varModeLog;
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @return string // return var log string in MODE_VAR and clean var
|
|
*/
|
|
public static function getVarLogClean()
|
|
{
|
|
$result = self::$varModeLog;
|
|
self::$varModeLog = '';
|
|
return $result;
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @param string $status // timeout
|
|
* @param string
|
|
*/
|
|
public static function setShutdownReturn($status, $str)
|
|
{
|
|
self::$shutdownReturns[$status] = $str;
|
|
}
|
|
|
|
/**
|
|
* Shutdown handler
|
|
*
|
|
* @return void
|
|
*/
|
|
public static function shutdown()
|
|
{
|
|
if (($error = error_get_last())) {
|
|
if (preg_match('/^Maximum execution time (?:.+) exceeded$/i', $error['message'])) {
|
|
echo self::$shutdownReturns[self::SHUTDOWN_TIMEOUT];
|
|
}
|
|
self::error($error['type'], $error['message'], $error['file'], $error['line']);
|
|
}
|
|
}
|
|
}
|