support.inc.php.svn-base

来自「PHP 知识管理系统（基于树结构的知识管理系统）, 英文原版的PHP源码。」· SVN-BASE 代码 · 共 836 行 · 第 1/2 页

<?php

/**
 * $Id:$
 *
 * KnowledgeTree Community Edition
 * Document Management Made Simple
 * Copyright (C) 2008 KnowledgeTree Inc.
 * Portions copyright The Jam Warehouse Software (Pty) Limited
 * 
 * This program is free software; you can redistribute it and/or modify it under
 * the terms of the GNU General Public License version 3 as published by the
 * Free Software Foundation.
 * 
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 * FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
 * details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 * 
 * You can contact KnowledgeTree Inc., PO Box 7775 #87847, San Francisco, 
 * California 94120-7775, or email [e-mail].
 * 
 * The interactive user interfaces in modified source and object code versions
 * of this program must display Appropriate Legal Notices, as required under
 * Section 5 of the GNU General Public License version 3.
 * 
 * In accordance with Section 7(b) of the GNU General Public License version 3,
 * these Appropriate Legal Notices must retain the display of the "Powered by
 * KnowledgeTree" logo and retain the original copyright notice. If the display of the 
 * logo is not reasonably feasible for technical reasons, the Appropriate Legal Notices
 * must display the words "Powered by KnowledgeTree" and retain the original 
 * copyright notice.
 * Contributor( s): ______________________________________
 *
 */


/**
 * TODO: refactor into seperate comparison object
 *
 */
class MD5SourceTree
{
	private $rootDir;
	private $logFilename;
	private $logFile;
	private $numDirectories;
	private $numFiles;
	private $comparisonFailure;
	private $exclusions;

	public function __construct($exclusions = array())
	{
		$this->numDirectories = 0;
		$this->numFiles = 0;
		$this->exclusions = $exclusions;
	}

	/**
	 * Helper function to traverse the directories. Called initially by scan()
	 *
	 * @param string $dir
	 */
	private function _scan($dir)
	{
		if (in_array($dir, $this->exclusions))
		{
			return;
		}
		if (is_dir($dir))
		{
    		if ($dh = opendir($dir))
    		{
        		while (($filename = readdir($dh)) !== false)
        		{
        			if (substr($filename,0,1) == '.')
        			{
        				continue;
        			}

        			$path = $dir . '/' . $filename;
        			if (is_dir($path))
        			{
        				$this->numDirectories++;
        				$this->_scan($path);
        			}
        			else
        			{
        				$this->numFiles++;
        				if (is_readable($path))
        				{
							$md5 = md5_file($path);
							$path = substr($path, strlen($this->rootDir) + 1);
							fwrite($this->logFile, "$md5:$path\n");
        				}
        			}
        		}
        		closedir($dh);
    		}
		}
	}

	/**
	 * This does the scan of the directory.
	 *
	 * @param string $rootDir
	 * @param string $reportFile
	 */
	public function scan($rootDir, $reportFile)
	{
		$this->rootDir = $rootDir;
		$this->logFilename = $reportFile;
		$this->logFile = fopen($reportFile,'wt');
		$this->_scan($rootDir);
		fclose($this->logFile);
	}


	/**
	 * Used by the compare function, to load a md5 file
	 *
	 * @param string $path
	 * @return array
	 */
	private function _loadDirectory($path)
	{
		$dirs = array();
		$numFiles = 0;
		$numDirectories = 0;
		$fp = fopen($path, 'rt');
		while (!feof($fp))
		{
			$line = fgets($fp, 10240);
			list($md5, $path) = explode(':',$line);
			$dirname = dirname($path);
			$filename = basename($path);
			$numFiles++;
			$dirs[$dirname][$filename] = $md5;
		}
		fclose($fp);
		return array('numFiles'=>$numFiles, 'numDirectories'=>$numDirectories, 'dirs'=>$dirs);
	}

	/**
	 * Internal function used to compare two md5 directory structures.
	 *
	 * @param array $prev
	 * @param array $cur
	 * @param string $msg
	 */
	private function _compare($prev, $cur, $msg)
	{
		foreach($prev['dirs'] as $prevDir=>$prevDirFiles)
		{
			if (!array_key_exists($prevDir, $cur['dirs']))
			{
				print "$msg: $prevDir does not exist in target.\n";
			}
			else
			{
				foreach($prevDirFiles as $prevFilename=>$prevMD5)
				{
					if (!array_key_exists($prevFilename, $cur['dirs'][$prevDir]))
					{
						$prevFilename = substr($prevFilename,0,-1);
						print "$msg: $prevFilename does not exist in $prevDir.\n";
					}
					else
					{
						if (in_array($prevDir . '/' . $prevFilename, $this->comparisonFailure))
						{
							continue;
						}

						$newMD5 = $cur['dirs'][$prevDir][$prevFilename];
						if ($prevMD5 != $newMD5)
						{
							$this->comparisonFailure[] = $prevDir . '/' . $prevFilename;
							$prevFilename = substr($prevFilename,0,-1);
							print "$msg: $prevFilename does not match md5; $prevMD5 != $newMD5.\n";
						}
					}
				}
			}
		}
	}

	/**
	 * Compare to md5 report files
	 *
	 * @param string $reportA
	 * @param string $reportB
	 */
	public function compare($reportA, $reportB)
	{
		if (is_null($reportB))
		{
			$reportB = $this->logFilename;
		}
		$this->comparisonFailure = array();
		$prev = $this->_loadDirectory($reportA);
		$cur = $this->_loadDirectory($reportB);

		if ($prev['numDirectories'] != $cur['numDirectories'])
		{
			print "Folder count mismatch!\n";
		}

		if ($prev['numFiles'] != $cur['numFiles'])
		{
			print "File count mismatch!\n";
		}

		$this->_compare($prev, $cur,'>');
		$this->_compare($cur,$prev,'<');
	}
}

class SupportUtil
{
	private $path;
	private $innodb;
	private $noninnodb;

	/**
	 * Constructor for SupportUtil. Creates a folder with format support-YYYY-MM-DD_HH-mm-ss
	 *
	 */
	function __construct()
	{
		$config = KTConfig::getSingleton();
		$tempdir = $config->get('urls/tmpDirectory');

		$this->path = $tempdir . "/support-" . date('Y-m-d_H-i-s');

		mkdir($this->path);
	}

	/**
	 * Main function to capture as much info that is reasonable.
	 *
	 */
	public function capture()
	{
		// get php info
		$this->capture_phpinfo($this->path . '/phpinfo.htm');

		// get db schema
		$tables = $this->capture_db_schema($this->path);

		// get zseq counters from taables
		$this->capture_zseqs($tables, $this->path . '/zseqreport.htm');

		// get md5 on table
		$exclusions = array(
			KT_DIR . '/var',
			realpath(KT_DIR . '/../var')
		);
		$tree = new MD5SourceTree($exclusions);
		$config = KTConfig::getSingleton();
		$sourcePath = $config->get('KnowledgeTree/fileSystemRoot');
		$tree->scan($sourcePath, $this->path . '/md5report.txt');

		// get plugins
		$this->capture_plugins($this->path . '/plugins.htm');

		// get logs
		$this->capture_logs($this->path);

		// get sys info
		$this->get_sysinfo($this->path);

		// get storage engine list
		$this->create_storage_engine($this->path);

		// get disk space listing
		$this->capture_df($this->path);

		// get process listing
		$this->capture_ps($this->path);

		// get version files
		$this->capture_version_files($this->path);

		// get system settings
		$this->capture_system_settings($this->path);

		// create out index file
		$this->create_index($this->path);

	}

	/**
	 * Main helper function to cleanup after creating zip file
	 *
	 * @param stirng $path
	 */
	private function _cleanup($path)
	{
		$dh = opendir($path);
		while (($filename = readdir($dh)) !== false)
		{
			if (substr($filename,0,1) == '.') continue;

			$fullname = $path . '/' . $filename;
			if (is_dir($fullname))
			{
				$this->_cleanup($fullname);
			}
			else
			{
				unlink($fullname);
			}
        }
		closedir($dh);
		rmdir($path);
	}

	/**
	 * Main cleanup function
	 *
	 */
	public function cleanup()
	{
		$this->_cleanup($this->path);
	}

	/**
	 * Creates an archive file
	 *
	 * @return string
	 */
	public function archive()
	{
		$zip = KTUtil::findCommand('export/zip', 'zip');

		chdir(dirname($this->path));
		$subdir = basename($this->path);
		$archivename = $this->path . '.zip';
		$cmd = "\"$zip\" -r \"$archivename\" \"$subdir\"";

		KTUtil::pexec($cmd);

		return $archivename;
	}

	/**
	 * Tries to get list of running processes
	 *
	 * @param string $path
	 */
	private function capture_ps($path)
	{
		$ps = KTUtil::findCommand('externalBinary/ps', 'ps');
		if (!file_exists($ps) || !is_executable($ps))
		{
			return;
		}

		$cmd = "'$ps' waux";
		// TODO: refactor to use KTUtil::pexec

		$ps = popen($cmd, 'r');
		$content = fread($ps , 10240);
		pclose($ps);

		file_put_contents($path . '/ps.txt', $content);
	}

	/**
	 * Get list of KnowledgeTree version files
	 *
	 * @param string $path
	 */
	private function capture_version_files($path)
	{
		$path = $path . '/versions';
		mkdir($path);

		$ver_path = KT_DIR . '/docs';
		$dh = opendir($ver_path);
		while (($filename = readdir($dh)) !== false)
		{
			if (substr($filename, 0, 7) == 'VERSION')
			{
				copy($ver_path . '/' . $filename, $path . '/' . $filename);
			}
        }
		closedir($dh);
	}

	/**
	 * Dump the system_settings table, except for dashboard-state entries.
	 *
	 * @param string $path
	 */
	private function capture_system_settings($path)
	{
		$sql = "SELECT id, name, value FROM system_settings";
		$rs = DBUtil::getResultArray($sql);
		$html = "<h1>System Settings</h1>";
		$html .= '<br><table border=1 cellpadding=0 cellspacing=0>';
		foreach($rs as $rec)
		{
			$id = $rec['id'];
			$name = $rec['name'];
			$value = $rec['value'];
			if (substr($name, 0, 15) == 'dashboard-state') continue;
			$html .= "<tr><td>$id<td>$name<td>$value\r\n";
		}

		$html .= '</table>';
		file_put_contents($path . '/systemsettings.htm', $html);
	}