PageRenderTime 50ms CodeModel.GetById 16ms RepoModel.GetById 0ms app.codeStats 1ms

/wp-content/plugins/backupbuddy/lib/mysqlbuddy/mysqlbuddy.php

https://bitbucket.org/summitds/bloomsburgpa.org
PHP | 868 lines | 539 code | 155 blank | 174 comment | 82 complexity | 73a255b06f205c55ff47f9417fd5261d MD5 | raw file
Possible License(s): GPL-2.0, AGPL-1.0, BSD-3-Clause, GPL-3.0, LGPL-2.1 
    

  1. <?php
    2. 

  2. /*	pb_backupbuddy_mysqlbuddy class
    3. 

  3.  *	
    4. 

  4.  *	@since 3.0.0
    5. 

  5.  *
    6. 

  6.  *	Helps backup and restore database tables.
    7. 

  7.  *	Dumps a mysql database (all tables, tables with a certain prefix, or none) with additional inclusions/exclusions of tables possible.
    8. 

  8.  *	Automatically determines available dump methods (unless method is forced). Runs methods in order of preference. Falls back automatically
    9. 

  9.  *	to any `lesser` methods if any fail.
    10. 

  10.  *
    11. 

  11.  *	Requirements:
    12. 

  12.  *
    13. 

  13.  *		Expects mysql to already be set up and connected.
    14. 

  14.  *
    15. 

  15.  *	General process order:
    16. 

  16.  *
    17. 

  17.  *		Construction: __construct() -> [available_zip_methods()]
    18. 

  18.  *		Dump: dump() -> _calculate_tables() -> [_mysql and/or _php]
    19. 

  19.  *
    20. 

  20.  		Method process:
    21. 

  21.  *			_mysql method (FAST):
    22. 

  22.  *				Builds the command line -> runs command via exec() -> checks exit code -> verifies .sql file was created; falls to next method if exit code is bad or .sql file is missing.
    23. 

  23.  *			_php method (SLOW; compatibility mode; only mode pre-3.0):
    24. 

  24.  *				Iterates through all tables issuing SQL commands to server to get create statements and all database content. Very brute force method.
    25. 

  25.  *
    26. 

  26.  *	@author Dustin Bolton < http://dustinbolton.com >
    27. 

  27.  */
    28. 

  28. class pb_backupbuddy_mysqlbuddy {
    29. 

  29. 	
    30. 

  30. 	
    31. 

  31. 	const COMMAND_LINE_LENGTH_CHECK_THRESHOLD = 250;													// If command line is longer than this then we will try to determine max command line length.
    32. 

  32. 	
    33. 

  33. 	
    34. 

  34. 	/********** Properties **********/
    35. 

  35. 	
    36. 

  36. 	
    37. 

  37. 	private $_version = '0.0.1';																		// Internal version number for this library.
    38. 

  38. 	
    39. 

  39. 	private $_database_host = '';																		// Database host/server. @see __construct().
    40. 

  40. 	private $_database_socket = '';																		// If using sockets, points to socket file. Left blank if sockets not in use. @see __construct().
    41. 

  41. 	private $_database_name = '';																		// Database name. @see __construct().
    42. 

  42. 	private $_database_user = '';																		// Database username. @see __construct().
    43. 

  43. 	private $_database_pass = '';																		// Database password. @see __construct().
    44. 

  44. 	private $_database_prefix = '';																		// Database table prefix to backup when in prefix mode. @see __construct().
    45. 

  45. 	
    46. 

  46. 	private $_base_dump_mode = '';																		// Determines base tables to include in backup. Ex: none, all, or by prefix. @see __construct().
    47. 

  47. 	private $_additional_includes = array();															// Additional tables to backup in addition to those determined by base mode.
    48. 

  48. 	private $_additional_excludes = array();															// Tables to exclude from ( $_additional_includes + those determined by base mode ).
    49. 

  49. 	private $_methods = array();																		// Available mechanisms for dumping in order of preference.
    50. 

  50. 	private $_mysql_directories = array();																// Populated by _calculate_mysql_directory().
    51. 

  51. 	private $_default_mysql_directories = array( '/usr/bin/', '/usr/bin/mysql/', '/usr/local/bin/' );	// If mysql tells us where its installed we prepend to this. Beginning and trailing slashes.
    52. 

  52. 	private $_mysql_directory = '';																		// Tested working mysql directory to use for actual dump.
    53. 

  53. 	private $_commandbuddy;
    54. 

  54. 	
    55. 

  55. 	/********** Methods **********/
    56. 

  56. 	
    57. 

  57. 	
    58. 

  58. 	/*	__construct()
    59. 

  59. 	 *	
    60. 

  60. 	 *	Default constructor.
    61. 

  61. 	 *	
    62. 

  62. 	 *	@param		string		$database_host			Host / server of database to pull from. May be in the format: `localhost` for normal; `localhost:/path/to/mysql.sock` for sockets. If sockets then parased and internal class variables set appropriately.
    63. 

  63. 	 *	@param		string		$database_name			Name of database to pull from.
    64. 

  64. 	 *	@param		string		$database_user			User of database to pull from.
    65. 

  65. 	 *	@param		string		$database_pass			Pass of database to pull from.
    66. 

  66. 	 *	@param		string		$database_prefix		Prefix of tables in database to pull from / insert into (only used if base mode is `prefix`).
    67. 

  67. 	 *	@param		array		$force_methods			Optional parameter to override automatic method detection. Skips test and runs first method first.  Falls back to other methods if any failure. Possible methods:  commandline, php
    68. 

  68. 	 *	@return		
    69. 

  69. 	 */
    70. 

  70. 	public function __construct( $database_host, $database_name, $database_user, $database_pass, $database_prefix, $force_methods = array() ) {
    71. 

  71. 		
    72. 

  72. 		// Handles command line execution.
    73. 

  73. 		require_once( pb_backupbuddy::plugin_path() . '/lib/commandbuddy/commandbuddy.php' );
    74. 

  74. 		$this->_commandbuddy = new pb_backupbuddy_commandbuddy();
    75. 

  75. 		
    76. 

  76. 		// Check for use of sockets in host. Handle if using sockets.
    77. 

  77. 		//$database_host = 'localhost:/Applications/XAMPP/xamppfiles/var/mysql/mysql.sock';
    78. 

  78. 		if ( strpos( $database_host, ':' ) === false ) { // Normal host.
    79. 

  79. 			pb_backupbuddy::status( 'details', 'Database host for dumping: `' . $database_host . '`' );
    80. 

  80. 			$this->_database_host = $database_host;
    81. 

  81. 		} else { // Non-normal host specification.
    82. 

  82. 			$host_split = explode( ':', $database_host );
    83. 

  83. 			if ( !is_numeric( $host_split[1] ) ) { // String so assume a socket.
    84. 

  84. 				pb_backupbuddy::status( 'details', 'Database host (socket) for dumping. Host: `' . $host_split[0] . '`; Socket: `' . $host_split[1] . '`.' );
    85. 

  85. 				$this->_database_host = $host_split[0];
    86. 

  86. 				$this->_database_socket = $host_split[1];
    87. 

  87. 			} else { // Numeric, treat as port and leave as one piece.
    88. 

  88. 				$this->_database_host = $database_host;
    89. 

  89. 			}
    90. 

  90. 		}
    91. 

  91. 		unset( $host_split );
    92. 

  92. 		
    93. 

  93. 		pb_backupbuddy::status( 'details', 'Loading mysqldump library.' );
    94. 

  94. 		pb_backupbuddy::status( 'details', 'Mysql server default directories: `' . implode( ',', $this->_default_mysql_directories ) . '`' );
    95. 

  95. 		
    96. 

  96. 		$this->_database_name = $database_name;
    97. 

  97. 		$this->_database_user = $database_user;
    98. 

  98. 		$this->_database_pass = $database_pass;
    99. 

  99. 		$this->_database_prefix = $database_prefix;
    100. 

  100. 		
    101. 

  101. 		if ( is_array( $force_methods ) ) {
    102. 

  102. 			pb_backupbuddy::status( 'details', 'mysqlbuddy: Force method sound of `' . count( $force_methods ) . '` passed.' );
    103. 

  103. 		} else {
    104. 

  104. 			pb_backupbuddy::status( 'details', 'mysqlbuddy: Force method not an array.' );
    105. 

  105. 		}
    106. 

  106. 		
    107. 

  107. 		// Set mechanism for dumping / restoring.
    108. 

  108. 		if ( count( $force_methods ) > 0 ) { // Mechanism forced. Overriding automatic check.
    109. 

  109. 			pb_backupbuddy::status( 'message', 'mysqlbuddy: Settings overriding automatic detection of available database dump methods. Using forced override methods: `' . implode( ',', $force_methods ) . '`.' );
    110. 

  110. 			$this->_methods = $force_methods;
    111. 

  111. 		} else { // No method defined; auto-detect the best.
    112. 

  112. 			pb_backupbuddy::status( 'message', 'mysqlbuddy: Method not forced. About to detect directory and available methods.' );
    113. 

  113. 			// Try to determine mysql location / possible locations.
    114. 

  114. 			$this->_mysql_directories = $this->_calculate_mysql_dir(); // Don't need to check this in forced mode.
    115. 

  115. 			
    116. 

  116. 			$this->_methods = $this->available_dump_methods(); // Run after _calculate_mysql_dir().
    117. 

  117. 		}
    118. 

  118. 		pb_backupbuddy::status( 'message', 'mysqlbuddy: Detected database dump methods: `' . implode( ',', $this->_methods ) . '`.' );
    119. 

  119. 		
    120. 

  120. 	} // End __construct().
    121. 

  121. 	
    122. 

  122. 	
    123. 

  123. 	
    124. 

  124. 	/*	available_dump_methods()
    125. 

  125. 	 *	
    126. 

  126. 	 *	function description
    127. 

  127. 	 *	
    128. 

  128. 	 *	@param		
    129. 

  129. 	 *	@return		string				Possible returns:  mysqldump, php
    130. 

  130. 	 */
    131. 

  131. 	public function available_dump_methods() {
    132. 

  132. 		
    133. 

  133. 		pb_backupbuddy::status( 'details', 'mysqldump test: Testing available mysql database dump methods.' );
    134. 

  134. 		if ( function_exists( 'exec' ) ) { // Exec is available so test mysqldump from here.
    135. 

  135. 			pb_backupbuddy::status( 'details', 'mysqldump test: exec() function exists. Testing running mysqldump via exec().' );
    136. 

  136. 			
    137. 

  137. 			
    138. 

  138. 			/********** Begin preparing command **********/
    139. 

  139. 			// Handle Windows wanting .exe.
    140. 

  140. 			if ( stristr( PHP_OS, 'WIN' ) && !stristr( PHP_OS, 'DARWIN' ) ) { // Running Windows. (not darwin)
    141. 

  141. 				$command = 'msqldump.exe';
    142. 

  142. 			} else {
    143. 

  143. 				$command = 'mysqldump';
    144. 

  144. 			}
    145. 

  145. 			
    146. 

  146. 			$command .= " --version";
    147. 

  147. 			
    148. 

  148. 			// Redirect STDERR to STDOUT.
    149. 

  149. 			$command .= '  2>&1';
    150. 

  150. 			
    151. 

  151. 			/********** End preparing command **********/
    152. 

  152. 			
    153. 

  153. 			// Loop through all possible directories to run command through.
    154. 

  154. 			foreach( $this->_mysql_directories as $mysql_directory ) { // Try each possible directory. mysql directory included trailing slash.
    155. 

  155. 				
    156. 

  156. 				// Run command.
    157. 

  157. 				pb_backupbuddy::status( 'details', 'mysqldump test running next.' );
    158. 

  158. 				list( $exec_output, $exec_exit_code ) = $this->_commandbuddy->execute( $mysql_directory . $command );
    159. 

  159. 				
    160. 

  160. 				if ( stristr( implode( ' ', $exec_output ), 'Ver' ) !== false ) { // String Ver appeared in response (expected response to mysqldump --version
    161. 

  161. 					pb_backupbuddy::status( 'details', 'mysqldump test: Command appears to be accessible and returns expected response.' );
    162. 

  162. 					$this->_mysql_directory = $mysql_directory; // Set to use this directory for the real dump.
    163. 

  163. 					return array( 'commandline', 'php' ); // mysqldump best, php next.
    164. 

  164. 				}
    165. 

  165. 			}
    166. 

  166. 			
    167. 

  167. 			
    168. 

  168. 		} else { // No exec() so must fall back to PHP method only.
    169. 

  169. 			pb_backupbuddy::status( 'details', 'mysqldump test: exec() unavailable so skipping command line mysqldump check.' );
    170. 

  170. 			pb_backupbuddy::status( 'message', 'mysqldump test: Falling back to database compatibility mode (PHPdump emulation). This is slower.' );
    171. 

  171. 			return array( 'php' );
    172. 

  172. 		}
    173. 

  173. 		
    174. 

  174. 		return array( 'php' );
    175. 

  175. 		
    176. 

  176. 	} // End available_dump_method().
    177. 

  177. 	
    178. 

  178. 	
    179. 

  179. 	
    180. 

  180. 	/*	_calculate_mysql_dir()
    181. 

  181. 	 *	
    182. 

  182. 	 *	Tries to determine the path to where mysql is installed.  Needed for running by command line.  Prepends found location to list of possible default mysql directories.
    183. 

  183. 	 *	
    184. 

  184. 	 *	@return		array			Array of directories in preferred order.
    185. 

  185. 	 */
    186. 

  186. 	private function _calculate_mysql_dir() {
    187. 

  187. 		
    188. 

  188. 		pb_backupbuddy::status( 'details', 'mysqlbuddy: Attempting to calculate exact mysql directory.' );
    189. 

  189. 		$failed = true;
    190. 

  190. 		$mysql_directories = $this->_default_mysql_directories;
    191. 

  191. 		
    192. 

  192. 		$result = mysql_query( "SHOW VARIABLES LIKE 'basedir'" );
    193. 

  193. 		if ( $result !== false ) {
    194. 

  194. 			$row = mysql_fetch_row( $result );
    195. 

  195. 			if ( $row !== false ) {
    196. 

  196. 				
    197. 

  197. 				$basedir = rtrim( $row[1], '/\\' ); // Trim trailing slashes.
    198. 

  198. 				$mysqldir = $basedir . '/bin/';
    199. 

  199. 				array_unshift( $mysql_directories, $mysqldir ); // Prepends the just found directory to the beginning of the list.
    200. 

  200. 				pb_backupbuddy::status( 'details', 'mysqlbuddy: Mysql reported its directory. Reported: `' . $row[1] . '`; Adding binary location to beginning of mysql directory list: `' . $mysqldir . '`' );
    201. 

  201. 				$failed = false;
    202. 

  202. 				
    203. 

  203. 			}
    204. 

  204. 			mysql_free_result( $result ); // Free memory.
    205. 

  205. 		}
    206. 

  206. 		
    207. 

  207. 		if ( $failed === true ) {
    208. 

  208. 			pb_backupbuddy::status( 'details', 'mysqlbuddy: Mysql would not report its directory.' );
    209. 

  209. 		}
    210. 

  210. 		
    211. 

  211. 		return $mysql_directories;
    212. 

  212. 		
    213. 

  213. 	} // End _calculate_mysql_dir().
    214. 

  214. 	
    215. 

  215. 	
    216. 

  216. 	
    217. 

  217. 	/*	dump()
    218. 

  218. 	 *	
    219. 

  219. 	 *	function description
    220. 

  220. 	 *
    221. 

  221. 	 *	@see _mysqldump().
    222. 

  222. 	 *	@see _phpdump().
    223. 

  223. 	 *	
    224. 

  224. 	 *	@param		string		$output_directory		Directory to output to. May also be used as a temporary file location. Trailing slash auto-added if missing.
    225. 

  225. 	 *	@param		array		$tables					Array of tables to dump.
    226. 

  226. 	 *	REMOVED: @param		string		$base_dump_mode			Determines which database tables to dump by default. $additional_[includes/excludes] modified. Modes: all, none, or prefix.
    227. 

  227. 	 *	REMOVED: @param		array		$additional_includes	Array of additional table(s) to INCLUDE in dump. Added in addition to those found by the $base_dump_mode
    228. 

  228. 	 *	REMOVED: @param		array		$additional_excludes	Array of additional table(s) to EXCLUDE from dump. Removed from those found by the $base_dump_mode + $additional_includes.
    229. 

  229. 	 *	@return
    230. 

  230. 	 */
    231. 

  231. 	public function dump( $output_directory, $tables = array() ) { //, $base_dump_mode, $additional_includes = array(), $additional_excludes = array() ) {
    232. 

  232. 		$return = false;
    233. 

  233. 		
    234. 

  234. 		$output_directory = rtrim( $output_directory, '/' ) . '/'; // Make sure we have trailing slash.
    235. 

  235. 		pb_backupbuddy::status( 'action', 'start_database' );
    236. 

  236. 		pb_backupbuddy::status( 'message', 'Starting database dump procedure.' );
    237. 

  237. 		pb_backupbuddy::status( 'details', "mysqlbuddy: Output directory: `{$output_directory}`." );
    238. 

  238. 		if ( count( $tables ) == 1 ) {
    239. 

  239. 			pb_backupbuddy::status( 'details', 'Dumping single table `' . $tables[0] . '`.' );
    240. 

  240. 		} else {
    241. 

  241. 			pb_backupbuddy::status( 'details', 'Table dump count: `' . count( $tables ) . '`.' );
    242. 

  242. 		}
    243. 

  243. 		if ( file_exists( $output_directory . 'db_1.sql' ) ) {
    244. 

  244. 			pb_backupbuddy::status( 'details', 'Database SQL file exists. It will be appended to.' );
    245. 

  245. 		}
    246. 

  246. 		
    247. 

  247. 		// Attempt each method in order.
    248. 

  248. 		pb_backupbuddy::status( 'details', 'Preparing to dump using available method(s) by priority. Methods: `' . implode( ',', $this->_methods ) . '`' );
    249. 

  249. 		foreach( $this->_methods as $method ) {
    250. 

  250. 			if ( method_exists( $this, "_dump_{$method}" ) ) {
    251. 

  251. 				pb_backupbuddy::status( 'details', 'mysqlbuddy: Attempting dump method `' . $method . '`.' );
    252. 

  252. 				$result = call_user_func( array( $this, "_dump_{$method}" ), $output_directory, $tables );
    253. 

  253. 				
    254. 

  254. 				if ( $result === true ) { // Dump completed succesfully with this method.
    255. 

  255. 					pb_backupbuddy::status( 'details', 'mysqlbuddy: Dump method `' . $method . '` completed successfully.' );
    256. 

  256. 					$return = true;
    257. 

  257. 					break;
    258. 

  258. 				} elseif ( $result === false ) { // Dump failed this method. Will try compatibility fallback to next mode if able.
    259. 

  259. 					// Do nothing. Will try next mode next loop.
    260. 

  260. 					pb_backupbuddy::status( 'details', 'mysqlbuddy: Dump method `' . $method . '` failed. Trying another compatibility mode next if able.' );
    261. 

  261. 				} else { // Something else returned; need to resume? TODO: this is for future use for resuming dump.
    262. 

  262. 					pb_backupbuddy::status( 'details', 'mysqlbuddy: Unexepected response: `' . implode( ',', $result ) . '`' );
    263. 

  263. 				}
    264. 

  264. 			}
    265. 

  265. 		}
    266. 

  266. 		
    267. 

  267. 		//pb_backupbuddy::status( 'status', 'database_end' );
    268. 

  268. 		pb_backupbuddy::status( 'action', 'finish_database' );
    269. 

  269. 		
    270. 

  270. 		if ( $return === true ) { // Success.
    271. 

  271. 			pb_backupbuddy::status( 'message', 'Database dump procedure succeeded.' );
    272. 

  272. 			return true;
    273. 

  273. 		} else { // Overall failure.
    274. 

  274. 			pb_backupbuddy::status( 'error', 'Database dump procedure failed.' );
    275. 

  275. 			return false;
    276. 

  276. 		}
    277. 

  277. 		
    278. 

  278. 	} // End dump().
    279. 

  279. 	
    280. 

  280. 	
    281. 

  281. 	
    282. 

  282. 	/*	_dump_commandline()
    283. 

  283. 	 *	
    284. 

  284. 	 *	function description
    285. 

  285. 	 *	
    286. 

  286. 	 *	@param		string		$output_directory		Directory to output to. May also be used as a temporary file location. Trailing slash required. dump() auto-adds trailing slash before passing.
    287. 

  287. 	 *	@param		array		$tables					Array of tables to dump.
    288. 

  288. 	 *	REMOVED: @param		string		$base_dump_mode			Base dump mode. Used to tell whether or not to dump entire database or piecemeal tables. Try to keep command line short.
    289. 

  289. 	 *	REMOVED: @param		array		$additional_excludes	Additional excludes. Used to tell whether or not to dump entire database or piecemeal tables. Try to keep command line short.
    290. 

  290. 	 *	@return		
    291. 

  291. 	 */
    292. 

  292. 	private function _dump_commandline( $output_directory, $tables ) { //, $base_dump_mode, $additional_excludes ) {
    293. 

  293. 		
    294. 

  294. 		$output_file = $output_directory . 'db_1.sql';
    295. 

  295. 		pb_backupbuddy::status( 'details', 'mysqlbuddy: Preparing to run command line mysqldump via exec().' );
    296. 

  296. 		$exclude_command = '';
    297. 

  297. 		
    298. 

  298. 		/*
    299. 

  299. 		if ( ( $base_dump_mode == 'all' ) && ( count( $additional_excludes ) == 0 ) ) { // Dumping ALL tables in the database so do not specify tables in command line.
    300. 

  300. 			// Do nothing. Just dump full database.
    301. 

  301. 			pb_backupbuddy::status( 'details', 'mysqlbuddy: Dumping entire database with no exclusions.' );
    302. 

  302. 		} elseif ( ( $base_dump_mode == 'all' ) && ( count( $additional_excludes ) > 0 ) ) { // Dumping all tables by default BUT also excluding certain ones.
    303. 

  303. 			pb_backupbuddy::status( 'details', 'mysqlbuddy: Dumping entire database with additional exclusions.' );
    304. 

  304. 			// Handle additional exclusions.
    305. 

  305. 			$additional_excludes = array_filter( $additional_excludes ); // ignore any phantom excludes.
    306. 

  306. 			foreach( $additional_excludes as $additional_exclude ) {
    307. 

  307. 				$exclude_command .= " --ignore-table={$this->_database_name}.{$additional_exclude}";
    308. 

  308. 			}
    309. 

  309. 		} else { // Only dumping certain 
    310. 

  310. 			pb_backupbuddy::status( 'details', 'mysqlbuddy: Dumping specific tables.' );
    311. 

  311. 			$tables_string = implode( ' ', $tables ); // Specific tables listed to dump.
    312. 

  312. 		}
    313. 

  313. 		*/
    314. 

  314. 		
    315. 

  315. 		$tables_string = implode( ' ', $tables ); // Specific tables listed to dump.
    316. 

  316. 		
    317. 

  317. 		
    318. 

  318. 		/********** Begin preparing command **********/
    319. 

  319. 		// Handle Windows wanting .exe.
    320. 

  320. 		if ( stristr( PHP_OS, 'WIN' ) && !stristr( PHP_OS, 'DARWIN' ) ) { // Running Windows. (not darwin)
    321. 

  321. 			$command = $this->_mysql_directory . 'msqldump.exe';
    322. 

  322. 		} else {
    323. 

  323. 			$command = $this->_mysql_directory . 'mysqldump';
    324. 

  324. 		}
    325. 

  325. 		
    326. 

  326. 		// Handle possible sockets.
    327. 

  327. 		if ( $this->_database_socket != '' ) {
    328. 

  328. 			$command .= " --socket={$this->_database_socket}";
    329. 

  329. 			pb_backupbuddy::status( 'details', 'mysqlbuddy: Using sockets in command.' );
    330. 

  330. 		}
    331. 

  331. 		
    332. 

  332. 		// TODO WINDOWS NOTE: information in the MySQL documentation about mysqldump needing to use --result-file= on Windows to avoid some issue with line endings.
    333. 

  333. 		/*
    334. 

  334. 		Notes:
    335. 

  335. 			--skip-opt				Skips some default options. MUST add back in create-options else autoincrement will be lost! See http://dev.mysql.com/doc/refman/5.5/en/mysqldump.html#option_mysqldump_opt
    336. 

  336. 			--quick
    337. 

  337. 			--skip-comments			Dont bother with extra comments.
    338. 

  338. 			--create-options		Required to add in auto increment option.
    339. 

  339. 			--disable-keys			Prevent re-indexing the database after each and every insert until the entire table is inserted. Prevents timeouts when a db table has fulltext keys especially.
    340. 

  340. 		*/
    341. 

  341. 		$command .= " --host={$this->_database_host} --user={$this->_database_user} --password={$this->_database_pass} --skip-opt --quick --disable-keys --skip-comments --create-options {$exclude_command} {$this->_database_name} {$tables_string} >> {$output_file}";
    342. 

  342. 		/********** End preparing command **********/
    343. 

  343. 		
    344. 

  344. 		
    345. 

  345. 		/********** Begin command line length check **********/
    346. 

  346. 		// Simple check command line length. If it appears long then do advanced check via command line to see what actual limit is. Falls back if too long to execute our process in one go.
    347. 

  347. 		// TODO: In the future handle fallback better by possibly breaking the command up if possible rather than strict fallback to PHP dumping.
    348. 

  348. 		$command_length = strlen( $command );
    349. 

  349. 		pb_backupbuddy::status( 'details', 'mysqlbuddy: Command length: `' . $command_length . '`.' );
    350. 

  350. 		if ( $command_length > self::COMMAND_LINE_LENGTH_CHECK_THRESHOLD ) { // Arbitrary length. Seems standard max lengths are > 200000 on Linux. ~8600 on Windows?
    351. 

  351. 			pb_backupbuddy::status( 'details', 'mysqlbuddy: Command line length of `' . $command_length . '` (bytes) is large enough ( >' . self::COMMAND_LINE_LENGTH_CHECK_THRESHOLD . ' ) to verify compatibility. Checking maximum allowed command line length for this sytem.' );
    352. 

  352. 			list( $exec_output, $exec_exit_code ) = $this->_commandbuddy->execute( 'echo $(( $(getconf ARG_MAX) - $(env | wc -c) ))' ); // Value will be a number. This is the maximum byte size of the command line.
    353. 

  353. 			pb_backupbuddy::status( 'details', 'mysqlbuddy: Command output: `' . implode( ',', $exec_output ) . '`; Exit code: `' . $exec_exit_code . '`; Exit code description: `' . pb_backupbuddy::$filesystem->exit_code_lookup( $exec_exit_code ) . '`' );
    354. 

  354. 			if ( is_array( $exec_output ) && is_numeric( $exec_output[0] ) ) {
    355. 

  355. 				pb_backupbuddy::status( 'details', 'mysqlbuddy: Detected maximum command line length for this system: `' . $exec_output[0] . '`.' );
    356. 

  356. 				if ( $command_length > ( $exec_output[0] - 100 ) ) { // Check if we exceed maximum length. Subtract 100 to make room for path definition.
    357. 

  357. 					pb_backupbuddy::status( 'details', 'mysqlbuddy: This system\'s maximum command line length of `' . $exec_output[0] . '` is shorter than command length of `' . $command_length . '`. Falling back into compatibility mode to insure database dump integrity.' );
    358. 

  358. 				} else {
    359. 

  359. 					pb_backupbuddy::status( 'details', 'mysqlbuddy: This system\'s maximum command line length of `' . $exec_output[0] . '` is longer than command length of `' . $command_length . '`. Continuing.' );
    360. 

  360. 				}
    361. 

  361. 			} else {
    362. 

  362. 				pb_backupbuddy::status( 'details', 'mysqlbuddy: Unable to determine maximum command line length. Falling back into compatibility mode to insure database dump integrity.' );
    363. 

  363. 				return false; // Fall back to compatibilty mode just in case.
    364. 

  364. 			}
    365. 

  365. 		} else {
    366. 

  366. 			pb_backupbuddy::status( 'details', 'mysqlbuddy: Command line length length check skipped since it is less than check threshold `' . self::COMMAND_LINE_LENGTH_CHECK_THRESHOLD . '`.' );
    367. 

  367. 		}
    368. 

  368. 		/********** End command line length check **********/
    369. 

  369. 		
    370. 

  370. 		
    371. 

  371. 		// Run command.
    372. 

  372. 		pb_backupbuddy::status( 'details', 'mysqlbuddy: Running dump via commandline next.' );
    373. 

  373. 		list( $exec_output, $exec_exit_code ) = $this->_commandbuddy->execute( $command );
    374. 

  374. 		
    375. 

  375. 		
    376. 

  376. 		// If mysql went away while we were busy with command line try to re-establish.
    377. 

  377. 		global $wpdb;
    378. 

  378. 		if ( @mysql_ping( $wpdb->dbh ) !== true ) { // No longer connected to database.
    379. 

  379. 			pb_backupbuddy::status( 'error', 'mysqlbuddy: Error #43849374. Database went away from PHP while running from command line. The PHP <--> mysql connection likely timed out while we were doing other things.' );
    380. 

  380. 			
    381. 

  381. 			// Clean up connection.
    382. 

  382. 			@mysql_close( $wpdb->dbh );
    383. 

  383. 			$wpdb->ready = false;
    384. 

  384. 			
    385. 

  385. 			// Attempt to reconnect.
    386. 

  386. 			$wpdb->db_connect();
    387. 

  387. 			
    388. 

  388. 			// Check if reconnect worked.
    389. 

  389. 			if ( ( NULL == $wpdb->dbh ) || ( !mysql_ping( $wpdb->dbh ) ) ) { // Reconnect failed if we have a null resource or ping fails
    390. 

  390. 				pb_backupbuddy::status( 'error', __('Database Server reconnection failed.', 'it-l10n-backupbuddy' ) );
    391. 

  391. 			} else {
    392. 

  392. 				pb_backupbuddy::status( 'details', __( 'Database Server reconnection successful.', 'it-l10n-backupbuddy' ) );
    393. 

  393. 				$result = true;
    394. 

  394. 			}
    395. 

  395. 		}
    396. 

  396. 		
    397. 

  397. 		
    398. 

  398. 		// Check the result of the 
    399. 

  399. 		if ( $exec_exit_code == '0' ) {
    400. 

  400. 			pb_backupbuddy::status( 'details', 'mysqlbuddy: Command appears to succeeded and returned proper response.' );
    401. 

  401. 			if ( file_exists( $output_file ) ) { // SQL file found. SUCCESS!
    402. 

  402. 				pb_backupbuddy::status( 'message', 'mysqlbuddy: Database dump SQL file exists.' );
    403. 

  403. 				
    404. 

  404. 				// Display final SQL file size.
    405. 

  405. 				$sql_filesize = pb_backupbuddy::$format->file_size( filesize( $output_file ) );
    406. 

  406. 				pb_backupbuddy::status( 'details', 'Final SQL database dump file size of `' . basename( $output_file ) . '`: ' . $sql_filesize . '.' );
    407. 

  407. 				
    408. 

  408. 				return true;
    409. 

  409. 			} else { // SQL file MISSING. FAILURE!
    410. 

  410. 				pb_backupbuddy::status( 'error', 'mysqlbuddy: Though command reported success database dump SQL file is missing: `' . $output_file . '`.' );
    411. 

  411. 				return false;
    412. 

  412. 			}
    413. 

  413. 		} else {
    414. 

  414. 			pb_backupbuddy::status( 'details', 'mysqlbuddy: Warning #9030. Command did not exit normally. This is normal is your server does not support command line mysql functionality. Falling back to database dump compatibility modes.' );
    415. 

  415. 			return false;
    416. 

  416. 		}
    417. 

  417. 		
    418. 

  418. 		
    419. 

  419. 		// Should never get to here.
    420. 

  420. 		pb_backupbuddy::status( 'error', 'mysqlbuddy: Uncaught exception #453890.' );
    421. 

  421. 		return false;
    422. 

  422. 		
    423. 

  423. 	} // End _dump_commandline().
    424. 

  424. 	
    425. 

  425. 	
    426. 

  426. 	
    427. 

  427. 	/*	_phpdump()
    428. 

  428. 	 *	
    429. 

  429. 	 *	PHP-based dumping of SQL data. Compatibility mode. Was only mode pre-3.0.
    430. 

  430. 	 *	
    431. 

  431. 	 *	@param		string		$output_directory		Directory to output to. May also be used as a temporary file location. Trailing slash required. dump() auto-adds trailing slash before passing.
    432. 

  432. 	 *	@param		array		$tables					Array of tables to dump.
    433. 

  433. 	 *	REMOVED: @param		string		$base_dump_mode			Base dump mode. NOT USED. Consistent with other dump mode.
    434. 

  434. 	 *	REMOVED: @param		array		$additional_excludes	Additional excludes. NOT USED. Consistent with other dump mode.
    435. 

  435. 	 *	@return		
    436. 

  436. 	 */
    437. 

  437. 	private function _dump_php( $output_directory, $tables ) { //, $base_dump_mode, $additional_excludes ) {
    438. 

  438. 		
    439. 

  439. 		$output_file = $output_directory . 'db_1.sql';
    440. 

  440. 		pb_backupbuddy::status( 'details', 'mysqlbuddy: Preparing to run PHP mysqldump compatibility mode.' );
    441. 

  441. 		
    442. 

  442. 		if ( false === ( $file_handle = fopen( $output_file, 'a' ) ) ) {
    443. 

  443. 			pb_backupbuddy::status( 'error', 'Error #9018: Database file is not creatable/writable. Check your permissions for file `' . $output_file . '` in directory `' . $output_directory . '`.' );
    444. 

  444. 			return false;
    445. 

  445. 		}
    446. 

  446. 		
    447. 

  447. 		
    448. 

  448. 		global $wpdb;
    449. 

  449. 		if ( !is_object( $wpdb ) ) {
    450. 

  450. 			pb_backupbuddy::status( 'error', 'WordPress database object $wpdb did not exist. This should not happen.' );
    451. 

  451. 			error_log( 'WordPress database object $wpdb did not exist. This should not happen. BackupBuddy Error #8945587973.' );
    452. 

  452. 			return false;
    453. 

  453. 		}
    454. 

  454. 		
    455. 

  455. 		// Connect if not connected for importbuddy.
    456. 

  456. 		if ( !mysql_ping( $wpdb->dbh ) ) {
    457. 

  457. 			mysql_connect( $this->_database_host, $this->_database_user, $this->_database_pass );
    458. 

  458. 			mysql_select_db( $this->_database_name );
    459. 

  459. 		}
    460. 

  460. 		
    461. 

  461. 		$_count = 0;
    462. 

  462. 		$insert_sql = '';
    463. 

  463. 		
    464. 

  464. 		global $wpdb; // Used later for checking that we are still connected to DB.
    465. 

  465. 		
    466. 

  466. 		// Iterate through all the tables to backup.
    467. 

  467. 		// TODO: Future ability to break up DB exporting to multiple page loads if needed. Really still need this now that we have command line dump?
    468. 

  468. 		foreach( $tables as $table_key => $table ) {
    469. 

  469. 			$create_table = mysql_query("SHOW CREATE TABLE `{$table}`");
    470. 

  470. 			
    471. 

  471. 			if ( $create_table === false ) {
    472. 

  472. 				pb_backupbuddy::status( 'error', 'Unable to access and dump database table `' . $table . '`. Table may not exist. Skipping backup of this table.' );
    473. 

  473. 				//pb_backupbuddy::$classes['core']->mail_error( 'Error #4537384: Unable to access and dump database table `' . $table . '`. Table may not exist. Skipping backup of this table.' );
    474. 

  474. 				continue; // Skip this iteration as accessing this table failed.
    475. 

  475. 			}
    476. 

  476. 			
    477. 

  477. 			// Table creation text.
    478. 

  478. 			$create_table_array = mysql_fetch_array( $create_table );
    479. 

  479. 			mysql_free_result( $create_table ); // Free memory.
    480. 

  480. 			$insert_sql .= str_replace( "\n", '', $create_table_array[1] ) . ";\n"; // Remove internal linebreaks; only put one at end.
    481. 

  481. 			unset( $create_table_array );
    482. 

  482. 			
    483. 

  483. 			// Disable keys for this table.
    484. 

  484. 			$insert_sql .= "/*!40000 ALTER TABLE `{$table}` DISABLE KEYS */;\n";
    485. 

  485. 			
    486. 

  486. 			// Row creation text for all rows within this table.
    487. 

  487. 			$table_query = mysql_query("SELECT * FROM `$table`") or pb_backupbuddy::status( 'error', 'Error #9001: Unable to read database table `' . $table . '`. Your backup will not include data from this table (you may ignore this warning if you do not need this specific data). This is due to the following error: ' . mysql_error() );
    488. 

  488. 			if ( $table_query === false ) {
    489. 

  489. 				pb_backupbuddy::status( 'error', 'ERROR #85449745. Unable to retrieve data from table `' . $table . '`. This table may be corrupt (try repairing the database) or too large to hold in memory (increase mysql and/or PHP memory). Check your PHP error log for further errors which may provide further information. Not continuing database dump to insure backup integrity.' );
    490. 

  490. 				return false;
    491. 

  491. 			}
    492. 

  492. 			
    493. 

  493. 			$num_fields = mysql_num_fields($table_query);
    494. 

  494. 			while ( $fetch_row = mysql_fetch_array( $table_query ) ) {
    495. 

  495. 				$insert_sql .= "INSERT INTO `$table` VALUES(";
    496. 

  496. 				for ( $n=1; $n<=$num_fields; $n++ ) {
    497. 

  497. 					$m = $n - 1;
    498. 

  498. 									
    499. 

  499. 					if ( $fetch_row[$m] === NULL ) {
    500. 

  500. 						$insert_sql .= "NULL, ";
    501. 

  501. 					} else {
    502. 

  502. 						$insert_sql .= "'" . mysql_real_escape_string( $fetch_row[$m] ) . "', ";
    503. 

  503. 					}
    504. 

  504. 				}
    505. 

  505. 				$insert_sql = substr( $insert_sql, 0, -2 );
    506. 

  506. 				$insert_sql .= ");\n";
    507. 

  507. 				
    508. 

  508. 				fwrite( $file_handle, $insert_sql );
    509. 

  509. 				$insert_sql = '';
    510. 

  510. 				
    511. 

  511. 				// Help keep HTTP alive.
    512. 

  512. 				$_count++;
    513. 

  513. 				if ($_count >= 400) {
    514. 

  514. 					echo ' ';
    515. 

  515. 					flush();
    516. 

  516. 					$_count = 0;
    517. 

  517. 				}
    518. 

  518. 			} // End foreach $tables.
    519. 

  519. 			
    520. 

  520. 			// Re-enable keys for this table.
    521. 

  521. 			$insert_sql .= "/*!40000 ALTER TABLE `{$table}` ENABLE KEYS */;\n";
    522. 

  522. 			
    523. 

  523. 			// testing: mysql_close( $wpdb->dbh );
    524. 

  524. 			// Verify database is still connected and working properly. Sometimes mysql runs out of memory and dies in the above foreach.
    525. 

  525. 			// No point in reconnecting as we can NOT trust that our dump was succesful anymore (it most likely was not).
    526. 

  526. 			if ( @mysql_ping( $wpdb->dbh ) ) { // Still connected to database.
    527. 

  527. 				mysql_free_result( $table_query ); // Free memory.
    528. 

  528. 			} else { // Database not connected.
    529. 

  529. 				pb_backupbuddy::status( 'error', __( 'ERROR #9026: The mySQL server went away unexpectedly during database dump. This is almost always caused by mySQL running out of memory. The backup integrity can no longer be guaranteed so the backup has been halted.' ) . ' ' . __( 'Last table dumped before database server went away: ' ) . '`' . $table . '`.' );
    530. 

  530. 				return false;
    531. 

  531. 			}
    532. 

  532. 			
    533. 

  533. 			// Help keep HTTP alive.
    534. 

  534. 			echo ' ';
    535. 

  535. 			pb_backupbuddy::status( 'details', 'Dumped database table `' . $table . '`.' );
    536. 

  536. 			flush();
    537. 

  537. 			
    538. 

  538. 			//unset( $tables[$table_key] );
    539. 

  539. 		}
    540. 

  540. 		
    541. 

  541. 		fclose( $file_handle );
    542. 

  542. 		unset( $file_handle );
    543. 

  543. 		
    544. 

  544. 		
    545. 

  545. 		pb_backupbuddy::status( 'details', __('Finished PHP based SQL dump method.', 'it-l10n-backupbuddy' ) );
    546. 

  546. 		
    547. 

  547. 		return true;
    548. 

  548. 		
    549. 

  549. 	} // End _phpdump().
    550. 

  550. 	
    551. 

  551. 	
    552. 

  552. 	
    553. 

  553. 	/*	get_methods()
    554. 

  554. 	 *	
    555. 

  555. 	 *	Get an array of methods. Note: If force overriding methods then detected methods will not be able to display.
    556. 

  556. 	 *	
    557. 

  557. 	 *	@return		array				Array of methods.
    558. 

  558. 	 */
    559. 

  559. 	public function get_methods() {
    560. 

  560. 		return $this->_methods;
    561. 

  561. 	}
    562. 

  562. 	
    563. 

  563. 	
    564. 

  564. 	
    565. 

  565. 	/*	import()
    566. 

  566. 	 *	
    567. 

  567. 	 *	Import SQL contents of a .sql file into the database. Only modification is to table prefix if needed. Prefixes (new and old) provided in constructor.
    568. 

  568. 	 *	Automatically handles fallback based on best available methods.
    569. 

  569. 	 *	
    570. 

  570. 	 *	@param		string		$sql_file				Full absolute path to .sql file to import from.
    571. 

  571.  	 *	@param		string		$old_prefix				Old database prefix. New prefix provided in constructor.
    572. 

  572.  	 *	@param		int			$query_start			Query number (aka line number) to resume import at.
    573. 

  573.  	 *	@param		boolean		$ignore_existing		Whether or not to allow import if tables exist already. Default: false.
    574. 

  574. 	 *	@return		mixed								true on success (boolean)
    575. 

  575. 	 *													false on failure (boolean)
    576. 

  576. 	 *													integer (int) on needing a resumse (integer is resume number for next page loads $query_start)
    577. 

  577. 	 */
    578. 

  578. 	public function import( $sql_file, $old_prefix, $query_start = 0, $ignore_existing = false ) {
    579. 

  579. 		$return = false;
    580. 

  580. 		
    581. 

  581. 		// Require a new table prefix.
    582. 

  582. 		if ( $this->_database_prefix == '' ) {
    583. 

  583. 			pb_backupbuddy::status( 'error', 'ERROR 9008: A database prefix is required for importing.' );
    584. 

  584. 		}
    585. 

  585. 		
    586. 

  586. 		if ( $query_start > 0 ) {
    587. 

  587. 			pb_backupbuddy::status( 'message', 'Continuing to restore database dump starting at query ' . $query_start . '.' );
    588. 

  588. 		} else {
    589. 

  589. 			pb_backupbuddy::status( 'message', 'Restoring database dump. This may take a moment...' );
    590. 

  590. 		}
    591. 

  591. 		
    592. 

  592. 		// Check whether or not tables already exist that might collide.
    593. 

  593. 		if ( $ignore_existing === false ) {
    594. 

  594. 			if ( $query_start == 0 ) { // Check number of tables already existing with this prefix. Skips this check on substeps of DB import.
    595. 

  595. 				$result = mysql_query( "SHOW TABLES LIKE '" . mysql_real_escape_string( str_replace( '_', '\_', $this->_database_prefix ) ) . "%'" );
    596. 

  596. 				if ( mysql_num_rows( $result ) > 0 ) {
    597. 

  597. 					pb_backupbuddy::status( 'error', 'Error #9014: Database import halted to prevent overwriting existing WordPress data.', 'The database already contains a WordPress installation with this prefix (' . mysql_num_rows( $result ) . ' tables). Restore has been stopped to prevent overwriting existing data. *** Please go back and enter a new database name and/or prefix OR select the option to wipe the database prior to import from the advanced settings on the first import step. ***' );
    598. 

  598. 					return false;
    599. 

  599. 				}
    600. 

  600. 				unset( $result );
    601. 

  601. 			}
    602. 

  602. 		}
    603. 

  603. 		
    604. 

  604. 		
    605. 

  605. 		pb_backupbuddy::status( 'message', 'Starting database import procedure.' );
    606. 

  606. 		pb_backupbuddy::status( 'details', 'mysqlbuddy: Maximum execution time for this run: ' . pb_backupbuddy::$options['max_execution_time'] . ' seconds.' );
    607. 

  607. 		pb_backupbuddy::status( 'details', 'mysqlbuddy: Old prefix: `' . $old_prefix . '`; New prefix: `' . $this->_database_prefix . '`.' );
    608. 

  608. 		pb_backupbuddy::status( 'details', "mysqlbuddy: Importing SQL file: `{$sql_file}`. Old prefix: `{$old_prefix}`. Query start: `{$query_start}`." );
    609. 

  609. 		flush();
    610. 

  610. 		
    611. 

  611. 		// Attempt each method in order.
    612. 

  612. 		pb_backupbuddy::status( 'details', 'Preparing to import using available method(s) by priority. Basing import methods off dump methods: `' . implode( ',', $this->_methods ) . '`' );
    613. 

  613. 		foreach( $this->_methods as $method ) {
    614. 

  614. 			if ( method_exists( $this, "_import_{$method}" ) ) {
    615. 

  615. 				pb_backupbuddy::status( 'details', 'mysqlbuddy: Attempting import method `' . $method . '`.' );
    616. 

  616. 				$result = call_user_func( array( $this, "_import_{$method}" ), $sql_file, $old_prefix, $query_start, $ignore_existing );
    617. 

  617. 				
    618. 

  618. 				if ( $result === true ) { // Dump completed succesfully with this method.
    619. 

  619. 					pb_backupbuddy::status( 'details', 'mysqlbuddy: Import method `' . $method . '` completed successfully.' );
    620. 

  620. 					$return = true;
    621. 

  621. 					break;
    622. 

  622. 				} elseif ( $result === false ) { // Dump failed this method. Will try compatibility fallback to next mode if able.
    623. 

  623. 					// Do nothing. Will try next mode next loop.
    624. 

  624. 					pb_backupbuddy::status( 'details', 'mysqlbuddy: Import method `' . $method . '` failed. Trying another compatibility mode next if able.' );
    625. 

  625. 				} else { // Something else returned; used for resuming (integer) or a message (string).
    626. 

  626. 					pb_backupbuddy::status( 'details', 'mysqlbuddy: Non-boolean response (usually means resume is needed): `' . $result . '`' );
    627. 

  627. 					return $result; // Dont fallback if this happens. Usually means resume is needed to finish.
    628. 

  628. 				}
    629. 

  629. 			}
    630. 

  630. 		}
    631. 

  631. 				
    632. 

  632. 		if ( $return === true ) { // Success.
    633. 

  633. 			pb_backupbuddy::status( 'message', 'Database import procedure succeeded.' );
    634. 

  634. 			return true;
    635. 

  635. 		} else { // Overall failure.
    636. 

  636. 			pb_backupbuddy::status( 'error', 'Database import procedure did not complete or failed.' );
    637. 

  637. 			return false;
    638. 

  638. 		}
    639. 

  639. 		
    640. 

  640. 	} // End import().
    641. 

  641. 	
    642. 

  642. 	
    643. 

  643. 	
    644. 

  644. 	public function _import_commandline( $sql_file, $old_prefix, $query_start = 0, $ignore_existing = false ) {
    645. 

  645. 		pb_backupbuddy::status( 'details', 'mysqlbuddy: Preparing to run command line mysql import via exec().' );
    646. 

  646. 		
    647. 

  647. 		
    648. 

  648. 		// If prefix has changed then need to update the file.
    649. 

  649. 		if ( $old_prefix != $this->_database_prefix ) {
    650. 

  650. 			if ( !isset( pb_backupbuddy::$classes['textreplacebuddy'] ) ) {
    651. 

  651. 				require_once( pb_backupbuddy::plugin_path() . '/lib/textreplacebuddy/textreplacebuddy.php' );
    652. 

  652. 				pb_backupbuddy::$classes['textreplacebuddy'] = new pb_backupbuddy_textreplacebuddy();
    653. 

  653. 			};
    654. 

  654. 			pb_backupbuddy::$classes['textreplacebuddy']->set_methods( array( 'commandline' ) ); // dont fallback into text version here.
    655. 

  655. 			
    656. 

  656. 			$regex_condition = "(INSERT INTO|CREATE TABLE|REFERENCES|CONSTRAINT|ALTER TABLE) (`?){$old_prefix}";
    657. 

  657. 			pb_backupbuddy::$classes['textreplacebuddy']->string_replace( $sql_file, $old_prefix, $this->_database_prefix, $regex_condition );
    658. 

  658. 			
    659. 

  659. 			$sql_file = $sql_file . '.tmp'; // New SQL file created by textreplacebuddy.
    660. 

  660. 		}
    661. 

  661. 		
    662. 

  662. 		
    663. 

  663. 		/********** Begin preparing command **********/
    664. 

  664. 		// Handle Windows wanting .exe. Note: executable directory path is prepended on exec() line of code.
    665. 

  665. 		if ( stristr( PHP_OS, 'WIN' ) && !stristr( PHP_OS, 'DARWIN' ) ) { // Running Windows. (not darwin)
    666. 

  666. 			$command = 'msql.exe';
    667. 

  667. 		} else {
    668. 

  668. 			$command = 'mysql';
    669. 

  669. 		}
    670. 

  670. 		
    671. 

  671. 		// Handle possible sockets.
    672. 

  672. 		if ( $this->_database_socket != '' ) {
    673. 

  673. 			$command .= " --socket={$this->_database_socket}";
    674. 

  674. 			pb_backupbuddy::status( 'details', 'mysqlbuddy: Using sockets in command.' );
    675. 

  675. 		}
    676. 

  676. 		
    677. 

  677. 		$command .= " --host={$this->_database_host} --user={$this->_database_user} --password={$this->_database_pass} --default_character_set utf8 {$this->_database_name} < {$sql_file}";
    678. 

  678. 		/********** End preparing command **********/
    679. 

  679. 		
    680. 

  680. 		// Run command.
    681. 

  681. 		pb_backupbuddy::status( 'details', 'mysqlbuddy: Running import via command line next.' );
    682. 

  682. 		list( $exec_output, $exec_exit_code ) = $this->_commandbuddy->execute( $this->_mysql_directory . $command );
    683. 

  683. 		
    684. 

  684. 		
    685. 

  685. 		// TODO: Removed mysql pinging here. Do we need (or even want) that here?
    686. 

  686. 		
    687. 

  687. 		
    688. 

  688. 		// Check the result of the execution.
    689. 

  689. 		if ( $exec_exit_code == '0' ) {
    690. 

  690. 			pb_backupbuddy::status( 'details', 'mysqlbuddy: Command appears to succeeded and returned proper response.' );
    691. 

  691. 			return true;
    692. 

  692. 		} else {
    693. 

  693. 			pb_backupbuddy::status( 'error', 'mysqlbuddy: Command did not exit normally. Falling back to database dump compatibility modes.' );
    694. 

  694. 			return false;
    695. 

  695. 		}
    696. 

  696. 		
    697. 

  697. 		
    698. 

  698. 		// Should never get to here.
    699. 

  699. 		pb_backupbuddy::status( 'error', 'mysqlbuddy: Uncaught exception #433053890.' );
    700. 

  700. 		return false;
    701. 

  701. 	} // End _import_commandline().
    702. 

  702. 	
    703. 

  703. 	
    704. 

  704. 	
    705. 

  705. 	function string_begins_with( $string, $search ) {
    706. 

  706. 		return ( strncmp( $string, $search, strlen($search) ) == 0 );
    707. 

  707. 	}
    708. 

  708. 	
    709. 

  709. 	
    710. 

  710. 	
    711. 

  711. 	/*	_import_php()
    712. 

  712. 	 *	
    713. 

  713. 	 *	Import from .SQL file into database via PHP by reading in file line by line.
    714. 

  714. 	 *	Using codebase from BackupBuddy / importbuddy 2.x.
    715. 

  715. 	 *	@see import().
    716. 

  716. 	 *	@since 2.x.
    717. 

  717. 	 *	
    718. 

  718. 	 *	@param		SEE import() PARAMETERS!!
    719. 

  719. 	 *	@return		mixed			True on success (and completion), integer on incomplete (resume needed via $query_start), false on failure.
    720. 

  720. 	 */
    721. 

  721. 	public function _import_php( $sql_file, $old_prefix, $query_start = 0, $ignore_existing = false ) {
    722. 

  722. 		
    723. 

  723. 		$this->time_start = time();
    724. 

  724. 		
    725. 

  725. 		pb_backupbuddy::status( 'message', 'Starting import of SQL data... This may take a moment...' );
    726. 

  726. 		$file_stream = fopen( $sql_file, 'r' );
    727. 

  727. 		
    728. 

  728. 		if ( false === $file_stream ) {
    729. 

  729. 			pb_backupbuddy::status( 'error', 'Error #9009: Unable to find any database backup data in the selected backup or could not open file (possibly due to permissions). Tried opening file `' . $sql_file . '`. Error #9009.' );
    730. 

  730. 			return false;
    731. 

  731. 		}
    732. 

  732. 		
    733. 

  733. 		// Iterate through each full row action and import it one at a time.
    734. 

  734. 			
    735. 

  735. 		$query_count = 0;
    736. 

  736. 		$file_data = '';
    737. 

  737. 		/* $in_create_table_block = false; */
    738. 

  738. 		
    739. 

  739. 		while ( ! feof( $file_stream ) ) {
    740. 

  740. 		
    741. 

  741. 			while ( false === strpos( $file_data, ";\n" ) ) {
    742. 

  742. 				$file_data .= fread( $file_stream, 4096 );
    743. 

  743. 			}
    744. 

  744. 			
    745. 

  745. 			$queries = explode( ";\n", $file_data );
    746. 

  746. 			
    747. 

  747. 			if ( preg_match( "/;\n$/", $file_data ) ) {
    748. 

  748. 				$file_data = '';
    749. 

  749. 			} else {
    750. 

  750. 				$file_data = array_pop( $queries );
    751. 

  751. 			}
    752. 

  752. 			
    753. 

  753. 			// TODO: DEBUGGING:
    754. 

  754. 			//pb_backupbuddy::$options['max_execution_time'] = 0.41;
    755. 

  755. 			
    756. 

  756. 			// Loops through each full query.
    757. 

  757. 			foreach ( (array) $queries as $query ) {
    758. 

  758. 				if ( $query_count < ( $query_start - 1 ) ) { // Handle skipping any queries up to the point we are at.
    759. 

  759. 					$query_count++;
    760. 

  760. 					continue; // Continue to next foreach iteration.
    761. 

  761. 				} else {
    762. 

  762. 					$query_count++;
    763. 

  763. 				}
    764. 

  764. 				
    765. 

  765. 				$query = trim( $query );
    766. 

  766. 				
    767. 

  767. 				if ( empty( $query ) || ( $this->string_begins_with( $query, '/*!40103' ) ) ) { // If blank line or starts with /*!40103 (mysqldump file has this junk in it).
    768. 

  768. 					continue;
    769. 

  769. 				}
    770. 

  770. 				
    771. 

  771. 				/*
    772. 

  772. 				if ( $in_create_table_block === true ) {
    773. 

  773. 				} else { // Watch for beginning of CREATE TABLE block if not in one.
    774. 

  774. 					// Handle broken up CREATE TABLE blocks caused by mysqldump.
    775. 

  775. 					if ( $this->string_begins_with( $query, 'CREATE TABLE' ) ) {
    776. 

  776. 						$in_create_table_block = true;
    777. 

  777. 					}
    778. 

  778. 				}
    779. 

  779. 				*/
    780. 

  780. 				
    781. 

  781. 				$result = $this->_import_sql_dump_line( $query, $old_prefix, $ignore_existing );
    782. 

  782. 				
    783. 

  783. 				if ( false === $result ) { // Skipped query
    784. 

  784. 					continue;
    785. 

  785. 				}
    786. 

  786. 				
    787. 

  787. 				if ( 0 === ( $query_count % 2000 ) ) { // Display Working every 1500 queries imported.
    788. 

  788. 					pb_backupbuddy::status( 'message', 'Working... Imported ' . $query_count . ' queries so far.' );
    789. 

  789. 				}
    790. 

  790. 				/*
    791. 

  791. 				if ( 0 === ( $query_count % 6000 ) ) {
    792. 

  792. 					echo "<br>\n";
    793. 

  793. 				}
    794. 

  794. 				*/
    795. 

  795. 				
    796. 

  796. 				// If we are within 1 second of reaching maximum PHP runtime then stop here so that it can be picked up in another PHP process...
    797. 

  797. 				if ( ( ( microtime( true ) - $this->time_start ) + 1 ) >= pb_backupbuddy::$options['max_execution_time'] ) {
    798. 

  798. 					// TODO: Debugging:
    799. 

  799. 					//if ( ( ( microtime( true ) - $this->time_start ) ) >= pb_backupbuddy::$options['max_execution_time'] ) {
    800. 

  800. 					pb_backupbuddy::status( 'message', 'Exhausted available PHP time to import for this page load. Last query: ' . $query_count . '.' );
    801. 

  801. 					
    802. 

  802. 					fclose( $file_stream );
    803. 

  803. 					
    804. 

  804. 					return ( $query_count + 1 );
    805. 

  805. 					//break 2;
    806. 

  806. 				} // End if.
    807. 

  807. 				
    808. 

  808. 			} // End foreach().
    809. 

  809. 			
    810. 

  810. 		} // End while().
    811. 

  811. 		
    812. 

  812. 		fclose( $file_stream );
    813. 

  813. 		
    814. 

  814. 		pb_backupbuddy::status( 'message', 'Import of SQL data in compatibility mode (PHP) complete.' );			
    815. 

  815. 		pb_backupbuddy::status( 'message', 'Took ' . round( microtime( true ) - $this->time_start, 3 ) . ' seconds on ' . $query_count . ' queries. ' );
    816. 

  816. 		
    817. 

  817. 		return true;
    818. 

  818. 		
    819. 

  819. 	} // End _import_php().
    820. 

  820. 	
    821. 

  821. 	
    822. 

  822. 	
    823. 

  823. 	/**
    824. 

  824. 	 *	_import_sql_dump_line()
    825. 

  825. 	 *
    826. 

  826. 	 *	Imports a line/query into the database.
    827. 

  827. 	 *	Handles using the specified table prefix.
    828. 

  828. 	 *	@since 2.x.
    829. 

  829. 	 *
    830. 

  830. 	 *	@param		string		$query			Query string to run for importing.
    831. 

  831. 	 *	@param		string		$old_prefix		Old prefix. (new prefix was passed in constructor).
    832. 

  832. 	 *	@return		boolean						True=success, False=failed.
    833. 

  833. 	 *
    834. 

  834. 	 */
    835. 

  835. 	function _import_sql_dump_line( $query, $old_prefix, $ignore_existing ) {
    836. 

  836. 		$new_prefix = $this->_database_prefix;
    837. 

  837. 		
    838. 

  838. 		$query_operators = 'INSERT INTO|CREATE TABLE|REFERENCES|CONSTRAINT|ALTER TABLE';
    839. 

  839. 		
    840. 

  840. 		// Replace database prefix in query.
    841. 

  841. 		if ( $old_prefix !== $new_prefix ) {
    842. 

  842. 			$query = preg_replace( "/^($query_operators)(\s+`?)$old_prefix/i", "\${1}\${2}$new_prefix", $query ); // 4-29-11
    843. 

  843. 		}
    844. 

  844. 		
    845. 

  845. 		// Run the query
    846. 

  846. 		// Disabled to prevent from running on EVERY line. Now just running before this. mysql_query("SET NAMES 'utf8'"); // Force UTF8
    847. 

  847. 		$result = mysql_query( $query );
    848. 

  848. 		
    849. 

  849. 		if ( false === $result ) {
    850. 

  850. 			if ( $ignore_existing !== true ) {
    851. 

  851. 				$mysql_error = mysql_error();
    852. 

  852. 				pb_backupbuddy::status( 'error', 'Error #9010: Unable to import SQL query: ' . $mysql_error );
    853. 

  853. 				if ( false !== stristr( $mysql_error, 'server has gone away' ) ) { // if string denotes that mysql server has gone away bail since it will likely just flood user with errors...
    854. 

  854. 					pb_backupbuddy::status( 'error', 'Error #9010b: Halting backup process as mysql server has gone away and database data could not be imported. Typically the restore cannot continue so the process has been halted. This is usually caused by a problematic mysql server at your hosting provider, low mysql timeouts, etc. Contact your hosting company for support.' );
    855. 

  855. 					die( 'BACKUP HALTED' );
    856. 

  856. 				}
    857. 

  857. 			}
    858. 

  858. 			return false;
    859. 

  859. 		} else {
    860. 

  860. 			return true;
    861. 

  861. 		}
    862. 

  862. 		
    863. 

  863. 	} // End _import_sql_dump_line().
    864. 

  864. 	
    865. 

  865. 	
    866. 

  866. 	
    867. 

  867. } // End pb_backupbuddy_mysqlbuddy class.
    868. 

  868. ?>
    869.