PageRenderTime 110ms CodeModel.GetById 21ms RepoModel.GetById 0ms app.codeStats 0ms

/deployMintCore.php

https://github.com/acobrotsen/DeployMint
PHP | 1041 lines | 367 code | 23 blank | 651 comment | 47 complexity | acf376805e5588d1ced1394635d1f2d8 MD5 | raw file
Possible License(s): GPL-3.0

Large files files are truncated, but you can click here to view the full file

    

  1. <?php

    2. 

  2. 

    3. 

  3. /*

    4. 

  4.   Author: Mark Maunder <mmaunder@gmail.com>

    5. 

  5.   Author website: http://markmaunder.com/

    6. 

  6.   License: GPL 3.0

    7. 

  7. */

    8. 

  8. 

    9. 

  9. 

    10. 

  10. define( 'ERRORLOGFILE' , '/var/log/wp_errors' );

    11. 

  11. 

    12. 

  12. class deploymint{

    13. 

  13. 

    14. 

  14.   private static $wpTables = array(

    15. 

  15.     'commentmeta' ,

    16. 

  16.     'comments' ,

    17. 

  17.     'links' ,

    18. 

  18.     'options' ,

    19. 

  19.     'postmeta' ,

    20. 

  20.     'posts' ,

    21. 

  21.     'term_relationships' ,

    22. 

  22.     'term_taxonomy' ,

    23. 

  23.     'terms'

    24. 

  24.   );

    25. 

  25. 

    26. 

  26.   public static function installPlugin(){

    27. 

  27.     $sql_createTables = array(

    28. 

  28.       "CREATE TABLE IF NOT EXISTS `dep_options` (

    29. 

  29.          `name` VARCHAR(100) NOT NULL PRIMARY KEY ,

    30. 

  30.          `val` VARCHAR(255) DEFAULT ''

    31. 

  31.        ) DEFAULT CHARSET=utf8" ,

    32. 

  32.       "CREATE TABLE IF NOT EXISTS `dep_projects` (

    33. 

  33.          `id` INT(11) UNSIGNED NOT NULL AUTO_INCREMENT PRIMARY KEY ,

    34. 

  34.          `ctime` INT(11) UNSIGNED NOT NULL ,

    35. 

  35.          `name` VARCHAR(100) NOT NULL ,

    36. 

  36.          `dir` VARCHAR(120) NOT NULL ,

    37. 

  37.          `deleted` TINYINT UNSIGNED DEFAULT 0

    38. 

  38.        ) DEFAULT CHARSET=utf8" ,

    39. 

  39.       "CREATE TABLE IF NOT EXISTS `dep_members` (

    40. 

  40.          `blog_id` INT(11) UNSIGNED NOT NULL ,

    41. 

  41.          `project_id` INT(11) UNSIGNED NOT NULL ,

    42. 

  42.          `deleted` TINYINT UNSIGNED DEFAULT 0 ,

    43. 

  43.          KEY k1( `blog_id` , `project_id` )

    44. 

  44.        ) DEFAULT CHARSET=utf8"

    45. 

  45.     );

    46. 

  46.     if( !( $dbh = mysql_connect( DB_HOST , DB_USER , DB_PASSWORD , true ) )

    47. 

  47.         || !mysql_select_db( DB_NAME , $dbh ) )

    48. 

  48.       die( 'Database error creating table for DeployMint: ' . mysql_error( $dbh ) );

    49. 

  49.     foreach( $sql_createTables as $sql_statement ){

    50. 

  50.       mysql_query( $sql_statement , $dbh);

    51. 

  51.       if( mysql_error( $dbh ) )

    52. 

  52.         die( 'Database error creating table for DeployMint: ' . mysql_error( $dbh ) );

    53. 

  53.     }

    54. 

  54.     $options = self::getOptions();

    55. 

  55.     foreach (array('git', 'mysql', 'mysqldump', 'rsync') as $n) {

    56. 

  56.       $options[$n] = $options[$n] ? $options[$n] : trim(self::mexec("which $n"));

    57. 

  57.     }

    58. 

  58.     self::updateOptions($options);

    59. 

  59.   }

    60. 

  60. 

    61. 

  61.   private static function getDefaultOptions(){

    62. 

  62.     return array(

    63. 

  63.       'git'               => '' ,

    64. 

  64.       'mysql'             => '' ,

    65. 

  65.       'mysqldump'         => '' ,

    66. 

  66.       'rsync'             => '' ,

    67. 

  67.       'numBackups'        => 5 ,

    68. 

  68.       'datadir'           => '' ,

    69. 

  69.       'preserveBlogName'  => 1 ,

    70. 

  70.       'backupDisabled'    => 0 ,

    71. 

  71.       'temporaryDatabase' => '' ,

    72. 

  72.       'backupDatabase'    => ''

    73. 

  73.     );

    74. 

  74.   }

    75. 

  75. 

    76. 

  76.   private static function getOptions( $createTemporaryDatabase = false , $createBackupDatabase = false ){

    77. 

  77.     global $wpdb;

    78. 

  78.     if( !( $dbh = mysql_connect( DB_HOST , DB_USER , DB_PASSWORD , true ) )

    79. 

  79.         || !mysql_select_db( DB_NAME , $dbh ) )

    80. 

  80.       die( 'Database error in DeployMint: ' . mysql_error( $dbh ) );

    81. 

  81.     $res = $wpdb->get_results( $wpdb->prepare( 'SELECT `name` , `val` FROM `dep_options`' ) , ARRAY_A );

    82. 

  82.     $options = self::getDefaultOptions();

    83. 

  83.     for( $i = 0 , $c = count( $res ) ; $i < $c ; $i++ ){

    84. 

  84.       $options[$res[$i]['name']] = $res[$i]['val'];

    85. 

  85.     }

    86. 

  86.     $options['backupDisabled'] = ( $options['backupDisabled']=='1' );

    87. 

  87.     $options['temporaryDatabaseCreated'] = false;

    88. 

  88.     if( $options['temporaryDatabase']=='' && $createTemporaryDatabase ){

    89. 

  89.       for( $i = 1 ; $i < 10 ; $i++ ){

    90. 

  90.         $options['temporaryDatabase'] = 'dep_tmpdb' . preg_replace( '/\./' , '' , microtime( true ) );

    91. 

  91.         $res = $wpdb->get_results( $wpdb->prepare( 'SHOW TABLES FROM ' . $options['temporaryDatabase'] ) , ARRAY_A );

    92. 

  92.         if( count( $res ) < 1 )

    93. 

  93.           break;

    94. 

  94.         if( $i > 4 )

    95. 

  95.           self::ajaxError( 'We could not create a temporary database name after 5 tries. You may not have the create DB privilege.' );

    96. 

  96.       }

    97. 

  97.       $wpdb->query( $wpdb->prepare( 'CREATE DATABASE ' . $options['temporaryDatabase'] ) );

    98. 

  98.       $options['temporaryDatabaseCreated'] = true;

    99. 

  99.     }

    100. 

  100.     $options['backupDatabaseCreated'] = false;

    101. 

  101.     if( $createBackupDatabase && !$options['backupDisabled'] && $options['numBackups']!=1 ){

    102. 

  102.       $dbPrefix = ( $options['backupDatabase']=='' ? 'depbak' : $options['backupDatabase'] );

    103. 

  103.       $options['backupDatabase'] = $dbPrefix . '__' . preg_replace( '/\./' , '' , microtime( true ) );

    104. 

  104.       if( !mysql_query( 'CREATE DATABASE ' . $options['backupDatabase'] , $dbh ) )

    105. 

  105.         self::ajaxError( 'Could not create backup database. ' . mysql_error( $dbh ) );

    106. 

  106.       $options['backupDatabaseCreated'] = true;

    107. 

  107.     }

    108. 

  108.     return $options;

    109. 

  109.   }

    110. 

  110. 

    111. 

  111.   private static function emptyDatabase( $database , $connection ){

    112. 

  112.     if( $result = mysql_query( 'SHOW TABLES IN ' . $database , $connection ) ){

    113. 

  113.       while( $row = mysql_fetch_array( $result , MYSQL_NUM ) ){

    114. 

  114.         mysql_query( 'DROP TABLE IF EXISTS ' . $row[0] , $connection );

    115. 

  115.       }

    116. 

  116.     }

    117. 

  117.   }

    118. 

  118. 

    119. 

  119.   private static function updateOptions( $o ){

    120. 

  120.     foreach( $o as $n => $v ){

    121. 

  121.       self::setOption( $n , $v );

    122. 

  122.     }

    123. 

  123.   }

    124. 

  124. 

    125. 

  125.   private static function setOption( $name , $val ){

    126. 

  126.     global $wpdb;

    127. 

  127.     $wpdb->query( $wpdb->prepare( 'INSERT INTO `dep_options` ( `name` , `val` ) VALUES ( %s , %s ) ON DUPLICATE KEY UPDATE `val` = %s' , $name , $val , $val ) );

    128. 

  128.   }

    129. 

  129. 

    130. 

  130.   private static function allOptionsSet(){

    131. 

  131.     global $wpdb;

    132. 

  132.     $options = self::getOptions();

    133. 

  133.     foreach( array( 'git' , 'mysql' , 'mysqldump' , 'rsync' , 'datadir' ) as $v ){

    134. 

  134.       if( !$options[$v] )

    135. 

  135.         return false;

    136. 

  136.     }

    137. 

  137.     return preg_match( '/^\d+$/' , $options['numBackups'] );

    138. 

  138.   }

    139. 

  139. 

    140. 

  140.   public static function setup(){

    141. 

  141.     global $wpdb;

    142. 

  142.     if( is_network_admin() && is_multisite() ){

    143. 

  143.       add_action( 'network_admin_menu' , 'deploymint::adminMenuHandler' );

    144. 

  144.     }elseif( is_admin() && !is_multisite() ){

    145. 

  145.       add_action( 'admin_menu' , 'deploymint::adminMenuHandler' );

    146. 

  146.     }

    147. 

  147.     add_action( 'init', 'deploymint::initHandler');

    148. 

  148.     add_action( 'wp_enqueue_scripts', 'deploymint::enqueue_scripts');

    149. 

  149.     add_action( 'wp_enqueue_styles', 'deploymint::enqueue_styles');

    150. 

  150.     

    151. 

  151.     add_action( 'wp_ajax_deploymint_deploy' , 'deploymint::ajax_deploy_callback' );

    152. 

  152.     add_action( 'wp_ajax_deploymint_createProject' , 'deploymint::ajax_createProject_callback' );

    153. 

  153.     add_action( 'wp_ajax_deploymint_reloadProjects' , 'deploymint::ajax_reloadProjects_callback' );

    154. 

  154.     add_action( 'wp_ajax_deploymint_updateCreateSnapshot' , 'deploymint::ajax_updateCreateSnapshot_callback' );

    155. 

  155.     add_action( 'wp_ajax_deploymint_updateDeploySnapshot' , 'deploymint::ajax_updateDeploySnapshot_callback' );

    156. 

  156.     add_action( 'wp_ajax_deploymint_updateSnapDesc' , 'deploymint::ajax_updateSnapDesc_callback' );

    157. 

  157.     add_action( 'wp_ajax_deploymint_createSnapshot' , 'deploymint::ajax_createSnapshot_callback' );

    158. 

  158.     add_action( 'wp_ajax_deploymint_deploySnapshot' , 'deploymint::ajax_deploySnapshot_callback' );

    159. 

  159.     add_action( 'wp_ajax_deploymint_undoDeploy' , 'deploymint::ajax_undoDeploy_callback' );

    160. 

  160.     add_action( 'wp_ajax_deploymint_addBlogToProject' , 'deploymint::ajax_addBlogToProject_callback' );

    161. 

  161.     add_action( 'wp_ajax_deploymint_removeBlogFromProject' , 'deploymint::ajax_removeBlogFromProject_callback' );

    162. 

  162.     add_action( 'wp_ajax_deploymint_deleteProject' , 'deploymint::ajax_deleteProject_callback' );

    163. 

  163.     add_action( 'wp_ajax_deploymint_deleteBackups' , 'deploymint::ajax_deleteBackups_callback' );

    164. 

  164.     add_action( 'wp_ajax_deploymint_updateOptions' , 'deploymint::ajax_updateOptions_callback' );

    165. 

  165.     if( !self::allOptionsSet() ){

    166. 

  166.       if( is_multisite() ){

    167. 

  167.         add_action( 'network_admin_notices' , 'deploymint::msgDataDir' );

    168. 

  168.       }else{

    169. 

  169.         add_action( 'admin_notices' , 'deploymint::msgDataDir' );

    170. 

  170.       }

    171. 

  171.     }

    172. 

  172.   }

    173. 

  173. 

    174. 

  174.   public static function enqueue_scripts(){

    175. 

  175.     /*

    176. 

  176.     wp_deregister_script( 'jquery' );

    177. 

  177.     wp_enqueue_script( 'jquery' , plugin_dir_url( __FILE__ ) . 'js/jquery-1.6.2.js' , array( ) );

    178. 

  178.     */

    179. 

  179.   }

    180. 

  180. 

    181. 

  181.   public static function enqueue_styles(){

    182. 

  182.     wp_register_style( 'DeployMintCSS' , plugin_dir_url( __FILE__ ) . 'css/admin.css' );

    183. 

  183.     wp_enqueue_style( 'DeployMintCSS' );

    184. 

  184.   }

    185. 

  185. 

    186. 

  186.   public static function __callStatic( $name , $args ){

    187. 

  187.     $matches = array();

    188. 

  188.     if( preg_match( '/^projectMenu(\d+)$/' , $name , $matches ) ){

    189. 

  189.       self::projectMenu( $matches[1] );

    190. 

  190.     }else{

    191. 

  191.       die( "Method $name doesn't exist!" );

    192. 

  192.     }

    193. 

  193.   }

    194. 

  194. 

    195. 

  195.   private static function checkPerms(){

    196. 

  196.     if( !is_user_logged_in() )

    197. 

  197.       die( '<h2>You are not logged in.</h2>' );

    198. 

  198.     if( ( is_multisite() && !current_user_can( 'manage_network' ) ) 

    199. 

  199.      || ( !is_multisite() && !current_user_can( 'manage_options' ) ) )

    200. 

  200.       die( '<h2>You do not have permission to access this page.</h2><p>You need the "manage_network" Super Admin capability to use DeployMint.</p>' );

    201. 

  201.   }

    202. 

  202. 

    203. 

  203.   public static function projectMenu( $projectid ){

    204. 

  204.     self::checkPerms();

    205. 

  205.     global $wpdb;

    206. 

  206.     if( !self::allOptionsSet() ){

    207. 

  207.       echo '<div class="wrap"><h2 class="depmintHead">Please visit the options page and configure all options</h2></div>';

    208. 

  208.       return;

    209. 

  209.     }

    210. 

  210.     $res = $wpdb->get_results($wpdb->prepare( 'SELECT * FROM `dep_projects` WHERE `id` = %d AND `deleted` = 0' , $projectid ) , ARRAY_A );

    211. 

  211.     $proj = $res[0];

    212. 

  212.     include( 'views/projectPage.php' );

    213. 

  213.   }

    214. 

  214. 

    215. 

  215.   public static function ajax_createProject_callback(){

    216. 

  216.     self::checkPerms();

    217. 

  217.     global $wpdb;

    218. 

  218.     $opt = self::getOptions();

    219. 

  219.     extract( $opt , EXTR_OVERWRITE );

    220. 

  220.     $exists = $wpdb->get_results( $wpdb->prepare( 'SELECT `name` FROM `dep_projects` WHETE `name` = %s AND `deleted` = 0' , $_POST['name'] ) , ARRAY_A );

    221. 

  221.     if( count( $exists ) )

    222. 

  222.       die( json_encode( array( 'err' => 'A project with that name already exists.' ) ) );

    223. 

  223.     $dir = $_POST['name'];

    224. 

  224.     $dir = preg_replace( '/[^a-zA-Z0-9]+/' , '_' , $dir );

    225. 

  225.     $fulldir = $dir . '-1';

    226. 

  226.     $counter = 2;

    227. 

  227.     while( is_dir( $datadir . $fulldir ) ){

    228. 

  228.       $fulldir = preg_replace( '/\-\d+$/' , '' , $fulldir );

    229. 

  229.       $fulldir .= '-' . $counter;

    230. 

  230.       $counter++;

    231. 

  231.       if( $counter > 1000 )

    232. 

  232.         die( json_encode( array( 'err' => "Too many directories already exist starting with \"$dir\"" ) ) );

    233. 

  233.     }

    234. 

  234.     $finaldir = $datadir . $fulldir;

    235. 

  235.     if( !@mkdir( $finaldir , 0755 ) )

    236. 

  236.       die( json_encode( array( 'err' => "Could not create directory $finaldir" ) ) );

    237. 

  237.     $git1 = self::mexec( "$git init ; $git add . " , $finaldir );

    238. 

  238.     $wpdb->query( $wpdb->prepare( 'INSERT INTO `dep_projects` ( `ctime` , `name` , `dir` ) VALUES ( UNIX_TIMESTAMP() , %s , %s )' , $_POST['name'] , $fulldir ) );

    239. 

  239.     die( json_encode( array( 'ok' => 1 ) ) );

    240. 

  240.   }

    241. 

  241. 

    242. 

  242.   public static function ajax_updateOptions_callback(){

    243. 

  243.     self::checkPerms();

    244. 

  244.     $defaultOptions = self::getDefaultOptions();

    245. 

  245.     $P = array_map( 'trim' , $_POST );

    246. 

  246.     $git               = $P['git'];

    247. 

  247.     $mysql             = $P['mysql'];

    248. 

  248.     $mysqldump         = $P['mysqldump'];

    249. 

  249.     $rsync             = $P['rsync'];

    250. 

  250.     $numBackups        = $P['numBackups'];

    251. 

  251.     $temporaryDatabase = $P['temporaryDatabase'];

    252. 

  252.     $backupDisabled    = ( $P['backupDisabled']!='' ? 1 : 0 );

    253. 

  253.     $backupDatabase    = $P['backupDatabase'];

    254. 

  254.     $datadir           = $P['datadir'];

    255. 

  255.     if( substr( $datadir , -1 )!='/' )

    256. 

  256.       $datadir .= '/';

    257. 

  257.     $errs = array();

    258. 

  258.     if( !( $git && $mysql && $mysqldump && $rsync && $datadir ) )

    259. 

  259.       $errs[] = 'You must specify a value for all options.';

    260. 

  260.     if( !preg_match('/^\d+$/' , $numBackups ) ){

    261. 

  261.       if( $backupDisabled ){

    262. 

  262.         $numBackups = $defaultOptions['numBackups'];

    263. 

  263.       } else {

    264. 

  264.         $errs[] = 'The number of backups you specify must be a number or 0 to keep all backups.';

    265. 

  265.       }

    266. 

  266.     }

    267. 

  267.     $preserveBlogName = trim($_POST['preserveBlogName']);

    268. 

  268.     if( $preserveBlogName!=0 && $preserveBlogName!=1 )

    269. 

  269.       $errs[] = "Invalid value for preserveBlogName. Expected 1 or 0. Received $preserveBlogName";

    270. 

  270.     if( count( $errs ) )

    271. 

  271.       die( json_encode( array( 'errs' => $errs ) ) );

    272. 

  272.     if( !file_exists( $mysql ) )

    273. 

  273.       $errs[] = "The file '$mysql' specified for mysql doesn't exist.";

    274. 

  274.     if( !file_exists( $mysqldump ) )

    275. 

  275.       $errs[] = "The file '$mysqldump' specified for mysqldump doesn't exist.";

    276. 

  276.     if( !file_exists( $rsync ) )

    277. 

  277.       $errs[] = "The file '$rsync' specified for rsync doesn't exist.";

    278. 

  278.     if( !file_exists( $git ) )

    279. 

  279.       $errs[] = "The file '$git' specified for git doesn't exist.";

    280. 

  280.     if( !is_dir( $datadir ) ){

    281. 

  281.       $errs[] = "The directory '$datadir' specified as the data directory doesn't exist.";

    282. 

  282.     }else{

    283. 

  283.       $fh = fopen( $datadir . '/test.tmp' , 'w' );

    284. 

  284.       if( !fwrite( $fh , 't' ) )

    285. 

  285.         $errs[] = "The directory $datadir is not writeable.";

    286. 

  286.       fclose( $fh );

    287. 

  287.       unlink( $datadir . '/test.tmp' );

    288. 

  288.     }

    289. 

  289.     if( count( $errs ) )

    290. 

  290.       die( json_encode( array( 'errs' => $errs ) ) );

    291. 

  291.     $options = array(

    292. 

  292.       'git'               => $git ,

    293. 

  293.       'mysql'             => $mysql ,

    294. 

  294.       'mysqldump'         => $mysqldump ,

    295. 

  295.       'rsync'             => $rsync ,

    296. 

  296.       'datadir'           => $datadir ,

    297. 

  297.       'numBackups'        => $numBackups ,

    298. 

  298.       'temporaryDatabase' => $temporaryDatabase ,

    299. 

  299.       'backupDisabled'    => $backupDisabled ,

    300. 

  300.       'backupDatabase'    => $backupDatabase ,

    301. 

  301.       'preserveBlogName'  => $preserveBlogName

    302. 

  302.     );

    303. 

  303.     self::updateOptions( $options );

    304. 

  304.     die( json_encode( array( 'ok' => 1 ) ) );

    305. 

  305.   }

    306. 

  306. 

    307. 

  307.   public static function ajax_deleteBackups_callback(){

    308. 

  308.     self::checkPerms();

    309. 

  309.     if( !( $dbh = mysql_connect( DB_HOST , DB_USER , DB_PASSWORD , true ) ) )

    310. 

  310.       self::ajaxError( 'A database error occured: ' . substr( mysql_error( $dbh ) , 0 , 200 ) );

    311. 

  311.     $toDel = $_POST['toDel'];

    312. 

  312.     for( $i = 0 , $c = count( $toDel ) ; $i < $c ; $i++ ){

    313. 

  313.       mysql_query( 'DROP DATABASE ' . $toDel[$i] , $dbh );

    314. 

  314.       if( mysql_error( $dbh ) )

    315. 

  315.         self::ajaxError( 'Could not drop database ' . $toDel[$i] . '. Error: ' . mysql_error( $dbh ) );

    316. 

  316.     }

    317. 

  317.     die( json_encode( array( 'ok' => 1 ) ) );

    318. 

  318.   }

    319. 

  319. 

    320. 

  320.   public static function ajax_deleteProject_callback(){

    321. 

  321.     self::checkPerms();

    322. 

  322.     global $wpdb;

    323. 

  323.     $wpdb->query( $wpdb->prepare( 'UPDATE `dep_members` SET `deleted` = 1 WHERE `project_id` = %d' , $_POST['blogID'] , $_POST['projectID'] ) );

    324. 

  324.     $wpdb->query( $wpdb->prepare( 'UPDATE `dep_projects` SET `deleted` = 1 WHERE `id` = %d' , $_POST['projectID'] ) );

    325. 

  325.     die( json_encode( array( 'ok' => 1 ) ) );

    326. 

  326.   }

    327. 

  327. 

    328. 

  328.   public static function ajax_removeBlogFromProject_callback(){

    329. 

  329.     self::checkPerms();

    330. 

  330.     global $wpdb;

    331. 

  331.     $wpdb->query( $wpdb->prepare( 'UPDATE `dep_members` SET `deleted` = 1 WHERE `blog_id` = %d AND `project_id` = %d' , $_POST['blogID'] , $_POST['projectID'] ) );

    332. 

  332.     die( json_encode( array( 'ok' => 1 ) ) );

    333. 

  333.   }

    334. 

  334. 

    335. 

  335.   public static function ajax_addBlogToProject_callback(){

    336. 

  336.     self::checkPerms();

    337. 

  337.     global $wpdb;

    338. 

  338.     $det = get_blog_details( $_POST['blogID'] );

    339. 

  339.     if( !$det )

    340. 

  340.       die( json_encode( array( 'err' => 'Please select a valid blog to add.' ) ) );

    341. 

  341.     $wpdb->query( $wpdb->prepare( 'INSERT INTO `dep_members` ( `blog_id` , `project_id` ) VALUES ( %d , %d )' , $_POST['blogID'] , $_POST['projectID'] ) );

    342. 

  342.     die( json_encode( array( 'ok' => 1 ) ) );

    343. 

  343.   }

    344. 

  344. 

    345. 

  345.   public static function ajax_createSnapshot_callback(){

    346. 

  346.     self::checkPerms();

    347. 

  347.     global $wpdb;

    348. 

  348.     $opt = self::getOptions();

    349. 

  349.     extract( $opt , EXTR_OVERWRITE );

    350. 

  350.     $pid = $_POST['projectid'];

    351. 

  351.     $blogid = $_POST['blogid'];

    352. 

  352.     $name = $_POST['name'];

    353. 

  353.     $desc = $_POST['desc'];

    354. 

  354.     if( !preg_match( '/\w+/' , $name ) )

    355. 

  355.       self::ajaxError( 'Please enter a name for this snapshot' );

    356. 

  356.     if( strlen( $name ) > 20 )

    357. 

  357.       self::ajaxError( 'Your snapshot name must be 20 characters or less.' );

    358. 

  358.     if( preg_match( '/[^a-zA-Z0-9\_\-\.]/' , $name ) )

    359. 

  359.       self::ajaxError( 'Your snapshot name can only contain characters a-z A-Z 0-9 and dashes, underscores and dots.' );

    360. 

  360.     if( !$desc )

    361. 

  361.       self::ajaxError( 'Please enter a description for this snapshot.' );

    362. 

  362.     $prec = $wpdb->get_results( $wpdb->prepare( 'SELECT * FROM `dep_projects` WHERE `id` = %d AND `deleted` = 0' , $pid ) , ARRAY_A );

    363. 

  363.     if( !count( $prec ) )

    364. 

  364.       self::ajaxError( 'That project does not exist.' );

    365. 

  365.     $proj = $prec[0];

    366. 

  366.     $dir = $datadir . $proj['dir'] . '/';

    367. 

  367.     $mexists = $wpdb->get_results( $wpdb->prepare( 'SELECT `blog_id` FROM `dep_members` WHERE `blog_id` = %d AND `project_id` = %d AND `deleted` = 0' , $blogid , $pid ) , ARRAY_A );

    368. 

  368.     if( !count( $mexists ) )

    369. 

  369.       self::ajaxError( 'That blog does not exist or is not a member of this project.' );

    370. 

  370.     if( !is_dir( $dir ) )

    371. 

  371.       self::ajaxError( "The directory $dir for this project doesn't exist for some reason. Did you delete it?" );

    372. 

  372.     $branchOut = self::mexec( "$git branch 2>&1" , $dir );

    373. 

  373.     if( preg_match( '/fatal/' , $branchOut ) )

    374. 

  374.       self::ajaxError( "The directory $dir is not a valid git repository. The output we received is: $branchOut" );

    375. 

  375.     $branches = preg_split( '/[\r\n\s\t\*]+/' , $branchOut );

    376. 

  376.     $bdup = array();

    377. 

  377.     for( $i = 0 , $c = count( $branches ) ; $i < $c ; $i++ ){

    378. 

  378.       $bdup[$branches[$i]] = 1;

    379. 

  379.     }

    380. 

  380.     if( array_key_exists( $name , $bdup ) )

    381. 

  381.       self::ajaxError( "A snapshot with the name $name already exists. Please choose another." );

    382. 

  382.     $cout1 = self::mexec( "$git checkout master 2>&1" , $dir );

    383. 

  383.    // Before we do our initial commit we will get an error trying to checkout master because it doesn't exist.

    384. 

  384.     if( !preg_match( "/(?:Switched to branch|Already on|error: pathspec 'master' did not match)/" , $cout1 ) )

    385. 

  385.       self::ajaxError( "We could not switch the git repository in $dir to 'master'. The output was: $cout1" );

    386. 

  386.     $prefix = '';

    387. 

  387.     if( $blogid==1 ){

    388. 

  388.       $prefix = $wpdb->base_prefix;

    389. 

  389.     } else {

    390. 

  390.       $prefix = $wpdb->base_prefix . $blogid . '_';

    391. 

  391.     }

    392. 

  392.     $prefixFile = $dir . 'deployData.txt';

    393. 

  393.     $fh2 = fopen( $prefixFile , 'w' );

    394. 

  394.     if( !fwrite( $fh2 , $prefix . ':' . microtime( true ) ) )

    395. 

  395.       self::ajaxError( "We could not write to deployData.txt in the directory $dir" );

    396. 

  396.     fclose( $fh2 );

    397. 

  397.     $prefixOut = self::mexec( "$git add deployData.txt 2>&1" , $dir );

    398. 

  398. 

    399. 

  399.    // Add the Media locations

    400. 

  400.     $files = self::mexec( "$rsync -r -d " . WP_CONTENT_DIR . "/blogs.dir/$blogid/* {$dir}blogs.dir/" );

    401. 

  401.     $filesOut = self::mexec( "$git add blogs.dir/ 2>&1" , $dir );

    402. 

  402. 

    403. 

  403.     $siteURLRes = $wpdb->get_results( $wpdb->prepare( 'SELECT `option_name` , `option_value` FROM `' . $prefix . 'options` WHERE `option_name` = "siteurl"' ) , ARRAY_A );

    404. 

  404.     $siteURL = $siteURLRes[0]['option_value'];

    405. 

  405.     $desc = "Snapshot of: {$siteURL}\n{$desc}";

    406. 

  406. 

    407. 

  407.     $dumpErrs = array();

    408. 

  408.     foreach( self::$wpTables as $t ){

    409. 

  409.       $tableFile = $t . '.sql';

    410. 

  410.       $tableName = $prefix . $t;

    411. 

  411.       $path = $dir . $tableFile;

    412. 

  412.       $dbuser = DB_USER;

    413. 

  413.       $dbpass = DB_PASSWORD;

    414. 

  414.       $dbhost = DB_HOST;

    415. 

  415.       $dbname = DB_NAME;

    416. 

  416.       $o1 = self::mexec( "{$mysqldump} --skip-comments --extended-insert --complete-insert --skip-comments -u {$dbuser} -p{$dbpass} -h {$dbhost} {$dbname} {$tableName} > {$path} 2>&1" , $dir );

    417. 

  417.       if( preg_match( '/\w+/' , $o1 ) ){

    418. 

  418.         array_push( $dumpErrs , $o1 );

    419. 

  419.       }else{

    420. 

  420.         $grepOut = self::mexec( "grep CREATE $path 2>&1" );

    421. 

  421.         if( !preg_match( '/CREATE/' , $grepOut ) ){

    422. 

  422.           array_push( $dumpErrs , "We could not create a valid table dump file for $tableName" );

    423. 

  423.         }else{

    424. 

  424.           $gitAddOut = self::mexec( "$git add $tableFile 2>&1" , $dir );

    425. 

  425.           if( preg_match( '/\w+/' , $gitAddOut ) )

    426. 

  426.             self::ajaxError("We encountered an error running '$git add $tableFile' the error was: $gitAddOut");

    427. 

  427.         }

    428. 

  428.       }

    429. 

  429.     }

    430. 

  430.     if( count( $dumpErrs ) ){

    431. 

  431.       $resetOut = self::mexec( "$git reset --hard HEAD 2>&1" , $dir );

    432. 

  432.       if (!preg_match('/HEAD is now at/', $resetOut))

    433. 

  433.         self::ajaxError( "Errors occured during mysqldump and we could not revert the git repository in {$dir} back to it's original state using '{$git} reset --hard HEAD'. The output we got was: {$resetOut}" );

    434. 

  434.       self::ajaxError( 'Errors occured during mysqldump: ' . implode( ', ' , $dumpErrs ) );

    435. 

  435.     }

    436. 

  436.     $tmpfile = $datadir . microtime( true ) . '.tmp';

    437. 

  437.     $fh = fopen( $tmpfile , 'w' );

    438. 

  438.     fwrite( $fh , $desc );

    439. 

  439.     fclose( $fh );

    440. 

  440.     global $current_user;

    441. 

  441.     get_currentuserinfo();

    442. 

  442.     $commitUser = $current_user->user_firstname . ' ' . $current_user->user_lastname . ' <' . $current_user->user_email . '>';

    443. 

  443.     $commitOut2 = self::mexec( "$git commit --author=\"$commitUser\" -a -F \"$tmpfile\" 2>&1" , $dir );

    444. 

  444.     unlink( $tmpfile );

    445. 

  445.     if( !preg_match( '/files changed/' , $commitOut2 ) )

    446. 

  446.       self::ajaxError( "git commit failed. The output we got was: $commitOut2" );

    447. 

  447.     $brOut2 = self::mexec( "$git branch $name 2>&1 " , $dir );

    448. 

  448.     if( preg_match( '/\w+/' , $brOut2 ) )

    449. 

  449.       self::ajaxError( "We encountered an error running '$git branch $name' the output was: $brOut2" );

    450. 

  450.     die( json_encode( array( 'ok' => 1 ) ) );

    451. 

  451.   }

    452. 

  452. 

    453. 

  453.   public static function ajax_undoDeploy_callback(){

    454. 

  454.     self::checkPerms();

    455. 

  455.     global $wpdb;

    456. 

  456.     $opt = self::getOptions( true );

    457. 

  457.     extract( $opt , EXTR_OVERWRITE );

    458. 

  458.     $sourceDBName = $_POST['dbname'];

    459. 

  459.     if( !( $dbh = mysql_connect( DB_HOST , DB_USER , DB_PASSWORD , true ) )

    460. 

  460.         || !mysql_select_db( $sourceDBName , $dbh ) )

    461. 

  461.       self::ajaxError( 'A database error occured: ' . substr( mysql_error( $dbh ) , 0 , 200 ) );

    462. 

  462.     $res1 = mysql_query( 'SHOW TABLES' , $dbh );

    463. 

  463.     if( mysql_error( $dbh ) )

    464. 

  464.       self::ajaxError( 'A database error occured: ' . substr( mysql_error( $dbh ) , 0 , 200 ) );

    465. 

  465.     $allTables = array();

    466. 

  466.     while( $row1 = mysql_fetch_array( $res1 , MYSQL_NUM ) ){

    467. 

  467.       if( !preg_match( '/^dep_/' , $row1[0] ) )

    468. 

  468.         array_push( $allTables , $row1[0] );

    469. 

  469.     }

    470. 

  470.     $renames = array();

    471. 

  471.     foreach( $allTables as $t ){

    472. 

  472.       array_push( $renames , "{$dbname}.{$t} TO {$temporaryDatabase}.{$t} , {$sourceDBName}.{$t} TO {$dbname}.{$t}" );

    473. 

  473.     }

    474. 

  474.     $stime = microtime( true );

    475. 

  475.     mysql_query( 'RENAME TABLE ' . implode( ', ' , $renames ) , $dbh );

    476. 

  476.     if( mysql_error( $dbh ) )

    477. 

  477.       self::ajaxError( 'A database error occured: ' . substr( mysql_error( $dbh ) , 0 , 200 ) );

    478. 

  478.     $lockTime = sprintf( '%.4f' , microtime( true ) - $stime );

    479. 

  479.     if( $temporaryDatabaseCreated ){

    480. 

  480.       mysql_query( "DROP DATABASE {$temporaryDatabase}" , $dbh );

    481. 

  481.     }else{

    482. 

  482.       self::emptyDatabase( $temporaryDatabase , $dbh );

    483. 

  483.     }

    484. 

  484.     foreach( $allTables as $t ){

    485. 

  485.       mysql_query( "CREATE TABLE {$sourceDBName}.{$t} LIKE {$dbname}.{$t}" , $dbh );

    486. 

  486.       if( mysql_error( $dbh ) )

    487. 

  487.         self::ajaxError( 'A database error occured trying to recreate the backup database, but the deployment completed. Error: ' . substr( mysql_error( $dbh ) , 0 , 200 ) );

    488. 

  488.       mysql_query( "INSERT INTO {$sourceDBName}.{$t} SELECT * FROM {$dbname}.{$t}" , $dbh );

    489. 

  489.       if (mysql_error($dbh))

    490. 

  490.         self::ajaxError( 'A database error occured trying to recreate the backup database, but the deployment completed. Error: ' . substr( mysql_error( $dbh ) , 0 , 200 ) );

    491. 

  491.     }

    492. 

  492.     if( mysql_error( $dbh ) )

    493. 

  493.       self::ajaxError( 'A database error occured (but the revert was completed!): ' . substr( mysql_error( $dbh ) , 0 , 200 ) );

    494. 

  494.     die( json_encode( array( 'ok' => 1 , 'lockTime' => $lockTime ) ) );

    495. 

  495.   }

    496. 

  496. 

    497. 

  497.   public static function ajax_deploySnapshot_callback(){

    498. 

  498.     self::checkPerms();

    499. 

  499.     global $wpdb;

    500. 

  500.     $opt = self::getOptions( true , true );

    501. 

  501.     extract( $opt , EXTR_OVERWRITE );

    502. 

  502.     $pid = $_POST['projectid'];

    503. 

  503.     $blogid = $_POST['blogid'];

    504. 

  504.     $name = $_POST['name'];

    505. 

  505.     $leaveComments = true; //$_POST['leaveComments'];

    506. 

  506. 

    507. 

  507.     if( !preg_match( '/\w+/' , $name ) )

    508. 

  508.       self::ajaxError( 'Please select a snapshot to deploy.' );

    509. 

  509.     $prec = $wpdb->get_results( $wpdb->prepare( 'SELECT * FROM `dep_projects` WHERE `id` = %d AND `deleted` = 0' , $pid ) , ARRAY_A );

    510. 

  510.     if( !count( $prec ) )

    511. 

  511.       self::ajaxError( 'That project does not exist.');

    512. 

  512.     $proj = $prec[0];

    513. 

  513.     $dir = $datadir . $proj['dir'] . '/';

    514. 

  514.     $mexists = $wpdb->get_results( $wpdb->prepare( 'SELECT `blog_id` FROM `dep_members` WHERE `blog_id` = %d AND `project_id` = %d AND `deleted` = 0' , $blogid , $pid ) , ARRAY_A );

    515. 

  515.     if( !count( $mexists ) )

    516. 

  516.       self::ajaxError( 'That blog does not exist or is not a member of this project. Please select a valid blog to deploy to.' );

    517. 

  517.     if( !is_dir( $dir ) )

    518. 

  518.       self::ajaxError( "The directory {$dir} for this project does not exist for some reason. Did you delete it?" );

    519. 

  519.     $co1 = self::mexec( "$git checkout $name 2>&1" , $dir );

    520. 

  520.     if( !preg_match( '/(?:Switched|Already)/' , $co1 ) )

    521. 

  521.       self::ajaxError( "We could not find snapshot $name in the git repository. The error was: $co1" );

    522. 

  522.     $destTablePrefix = '';

    523. 

  523.     if( $blogid==1 ){

    524. 

  524.       $destTablePrefix = $wpdb->base_prefix;

    525. 

  525.     }else{

    526. 

  526.       $destTablePrefix = $wpdb->base_prefix . $blogid . '_';

    527. 

  527.     }

    528. 

  528.     $optionsToRestore = array( 'siteurl' , 'home' , 'upload_path' );

    529. 

  529.     if( $opt['preserveBlogName'] )

    530. 

  530.       $optionsToRestore[] = 'blogname';

    531. 

  531.     $res3 = $wpdb->get_results( $wpdb->prepare( "SELECT `option_name` , `option_value` FROM {$destTablePrefix}options WHERE option_name IN (\"" . implode( '","' , $optionsToRestore ) . '")' ) , ARRAY_A );

    532. 

  532.     if( !count( $res3 ) )

    533. 

  533.       self::ajaxError( 'We could not find the data we need for the blog you are trying to deploy to.' );

    534. 

  534.     $options = array();

    535. 

  535.     for( $i = 0 , $c = count( $res3 ) ; $i < $c ; $i++ ){

    536. 

  536.       $options[$res3[$i]['option_name']] = $res3[$i]['option_value'];

    537. 

  537.     }

    538. 

  538. 

    539. 

  539.     // Update the Media folder

    540. 

  540.     $files = self::mexec( "$rsync -r -d $dir" . "blogs.dir/* " . WP_CONTENT_DIR . "/blogs.dir/{$blogid}/" );

    541. 

  541.     

    542. 

  542.     $fh = fopen( $dir . 'deployData.txt' , 'r' );

    543. 

  543.     $deployData = fread( $fh , 100 );

    544. 

  544.     $depDat = explode( ':' , $deployData );

    545. 

  545.     $sourceTablePrefix = $depDat[0];

    546. 

  546.     if( !$sourceTablePrefix )

    547. 

  547.       self::ajaxError( "We could not read the table prefix from $dir/deployData.txt" );

    548. 

  548.     $dbuser = DB_USER;

    549. 

  549.     $dbpass = DB_PASSWORD;

    550. 

  550.     $dbhost = DB_HOST;

    551. 

  551.     $dbname = DB_NAME;

    552. 

  552.     $slurp1 = self::mexec( "cat *.sql | $mysql -u $dbuser -p$dbpass -h $dbhost $temporaryDatabase " , $dir );

    553. 

  553.     if( preg_match( '/\w+/' , $slurp1 ) )

    554. 

  554.       self::ajaxError( "We encountered an error importing the data files from snapshot $name into database $temporaryDatabase $dbuser:$dbpass@$dbhost. The error was: " . substr( $slurp1 , 0 , 1000 ) );

    555. 

  555.     if( !( $dbh = mysql_connect( $dbhost , $dbuser , $dbpass , true ) ) && mysql_error( $dbh ) )

    556. 

  556.       self::ajaxError( 'A database error occured: ' . substr( mysql_error( $dbh ) , 0 , 200 ) );

    557. 

  557.     if( !mysql_select_db( $temporaryDatabase , $dbh ) )

    558. 

  558.       self::ajaxError( "Could not select temporary database $temporaryDatabase : " . mysql_error( $dbh ) );

    559. 

  559.     $curdbres = mysql_query( 'SELECT DATABASE()' , $dbh );

    560. 

  560.     $curdbrow = mysql_fetch_array( $curdbres , MYSQL_NUM );

    561. 

  561.     if( mysql_error( $dbh ) )

    562. 

  562.       self::ajaxError( 'A database error occured: ' . substr( mysql_error( $dbh ) , 0 , 200 ) );

    563. 

  563.     $destSiteURL = $options['siteurl'];

    564. 

  564.     $res4 = mysql_query( "SELECT `option_value` FROM `{$sourceTablePrefix}options` WHERE `option_name` = 'siteurl'" , $dbh );

    565. 

  565.     if( mysql_error( $dbh ) ){

    566. 

  566.       self::ajaxError( 'A database error occured: ' . substr( mysql_error( $dbh ) , 0 , 200 ) );

    567. 

  567.     if( !$res4 )

    568. 

  568.       self::ajaxError( 'We could not get the siteurl from the database we are about to deploy. That could mean that we could not create the DB or the import failed.' );

    569. 

  569.     $row = mysql_fetch_array( $res4 , MYSQL_ASSOC );

    570. 

  570.     if( mysql_error( $dbh ) )

    571. 

  571.       self::ajaxError( 'A database error occured: ' . substr( mysql_error( $dbh ) , 0 , 200 ) );

    572. 

  572.     if( !$row )

    573. 

  573.       self::ajaxError( 'We could not get the siteurl from the database we are about to deploy. That could mean that we could not create the DB or the import failed. (2)' );

    574. 

  574.     $sourceSiteURL = $row['option_value'];

    575. 

  575.     if( !$sourceSiteURL )

    576. 

  576.       self::ajaxError( 'We could not get the siteurl from the database we are about to deploy. That could mean that we could not create the DB or the import failed. (3)' );

    577. 

  577.     $destHost = preg_replace( '/^https?:\/\/([^\/]+).*$/i' , '$1' , $destSiteURL );

    578. 

  578.     $sourceHost = preg_replace( '/^https?:\/\/([^\/]+).*$/i' , '$1' , $sourceSiteURL );

    579. 

  579.     foreach( $options as $oname => $val ){

    580. 

  580.       mysql_query( "UPDATE {$sourceTablePrefix}options SET option_value = '" . mysql_real_escape_string( $val ) . "' WHERE option_name='" . mysql_real_escape_string( $oname ) . "'", $dbh );

    581. 

  581.       if( mysql_error( $dbh ) )

    582. 

  582.         self::ajaxError( 'A database error occured: ' . substr( mysql_error( $dbh ) , 0 , 200 ) );

    583. 

  583.     }

    584. 

  584.     $res5 = mysql_query( "SELECT id , post_content , guid FROM {$sourceTablePrefix}posts" , $dbh );

    585. 

  585.     if( mysql_error( $dbh ) )

    586. 

  586.       self::ajaxError( 'A database error occured: ' . substr( mysql_error( $dbh ) , 0 , 200 ) );

    587. 

  587.     while( $row = mysql_fetch_array( $res5 , MYSQL_ASSOC ) ){

    588. 

  588.       $content = preg_replace( '/(https?:\/\/)' . $sourceHost . '/i' , '$1' . $destHost , $row['post_content'] );

    589. 

  589.       $guid = preg_replace( '/(https?:\/\/)' . $sourceHost . '/i' , '$1' . $destHost , $row['guid'] );

    590. 

  590.       mysql_query( "UPDATE {$sourceTablePrefix}posts SET post_content = '" . mysql_real_escape_string( $content ) . "' , guid = '" . mysql_real_escape_string( $guid ) . "' WHERE ID=" . $row['ID'] , $dbh );

    591. 

  591.       if( mysql_error( $dbh ) )

    592. 

  592.         self::ajaxError( 'A database error occured: ' . substr( mysql_error( $dbh ) , 0 , 200 ) );

    593. 

  593.     }

    594. 

  594. 

    595. 

  595.     mysql_query( "UPDATE {$temporaryDatabase}.{$sourceTablePrefix}options SET option_name = '{$destTablePrefix}user_roles' WHERE option_name = '{$sourceTablePrefix}user_roles'" , $dbh );

    596. 

  596.     if( mysql_error( $dbh ) )

    597. 

  597.       self::ajaxError( 'A database error occured while updating the user_roles option in the destination database: ' . substr( mysql_error( $dbh ) , 0 , 200 ) );

    598. 

  598. 

    599. 

  599.     if( $leaveComments ){

    600. 

  600.      // Delete comments from DB we're deploying

    601. 

  601.       mysql_query( "DELETE FROM {$sourceTablePrefix}comments" , $dbh );

    602. 

  602.       if( mysql_error( $dbh ) )

    603. 

  603.         self::ajaxError( 'A database error occured: ' . substr( mysql_error( $dbh ) , 0 , 200 ) );

    604. 

  604.       mysql_query( "DELETE FROM {$sourceTablePrefix}commentmeta" , $dbh );

    605. 

  605.       if( mysql_error( $dbh ) )

    606. 

  606.         self::ajaxError( 'A database error occured: ' . substr( mysql_error( $dbh ) , 0 , 200 ) );

    607. 

  607.       //Bring comments across from live (destination) DB

    608. 

  608.       mysql_query( "INSERT INTO {$temporaryDatabase}.{$sourceTablePrefix}comments SELECT * FROM {$dbname}.{$destTablePrefix}comments" , $dbh );

    609. 

  609.        if( mysql_error( $dbh ) )

    610. 

  610.         self::ajaxError( 'A database error occured: ' . substr( mysql_error( $dbh ) , 0 , 200 ) );

    611. 

  611.       mysql_query( "INSERT INTO {$temporaryDatabase}.{$sourceTablePrefix}commentmeta SELECT * FROM {$dbname}.{$destTablePrefix}commentmeta" , $dbh );

    612. 

  612.       if( mysql_error( $dbh ) )

    613. 

  613.         self::ajaxError( 'A database error occured: ' . substr( mysql_error( $dbh ) , 0 , 200 ) );

    614. 

  614. 

    615. 

  615.      // Then remap comments to posts based on the "slug" which is the post_name

    616. 

  616.       $res6 = mysql_query( "SELECT dp.post_name AS destPostName , dp.ID AS destID , sp.post_name AS sourcePostName , sp.ID AS sourceID FROM {$dbname}.{$destTablePrefix}posts as dp , {$temporaryDatabase}.{$sourceTablePrefix}posts AS sp WHERE dp.post_name = sp.post_name" , $dbh );

    617. 

  617.       if( mysql_error( $dbh ) )

    618. 

  618.         self::ajaxError( 'A database error occured: ' . substr( mysql_error( $dbh ) , 0 , 200 ) );

    619. 

  619.       if( !$res6 )

    620. 

  620.         self::ajaxError( 'DB error creating maps betweeb post slugs: ' . mysql_error( $dbh ) );

    621. 

  621.       $pNameMap = array();

    622. 

  622.       while( $row = mysql_fetch_array( $res6 , MYSQL_ASSOC ) ){

    623. 

  623.         $pNameMap[$row['destID']] = $row['sourceID'];

    624. 

  624.       }

    625. 

  625. 

    626. 

  626.       $res10 = mysql_query( "SELECT comment_ID , comment_post_ID FROM {$sourceTablePrefix}comments" , $dbh );

    627. 

  627.       if( mysql_error( $dbh ) )

    628. 

  628.         self::ajaxError( 'A database error occured: ' . substr( mysql_error( $dbh ) , 0 , 200 ) );

    629. 

  629.       while( $row = mysql_fetch_array( $res10 , MYSQL_ASSOC ) ){

    630. 

  630.         if( array_key_exists( $row['comment_post_ID'] , $pNameMap ) ){

    631. 

  631.          // If a post exists in the source with the same slug as the destination, then associate the destination's comments with that post.

    632. 

  632.           mysql_query( "UPDATE {$sourceTablePrefix}comments set comment_post_ID = " . $pNameMap[$row['comment_post_ID']] . " WHERE comment_ID = " . $row['comment_ID'] , $dbh );

    633. 

  633.           if( mysql_error( $dbh ) )

    634. 

  634.             self::ajaxError( 'A database error occured: ' . substr( mysql_error( $dbh ) , 0 , 200 ) );

    635. 

  635.         }else{

    636. 

  636.          // Otherwise delete the comment because it is associated with a post on the destination which does not exist in the source we're about to deploy

    637. 

  637.           mysql_query( "DELETE FROM {$sourceTablePrefix}comments WHERE comment_ID = " . $row['comment_ID'] , $dbh );

    638. 

  638.           if( mysql_error( $dbh ) )

    639. 

  639.             self::ajaxError( 'A database error occured: ' . substr( mysql_error( $dbh ) , 0 , 200 ) );

    640. 

  640.         }

    641. 

  641.       }

    642. 

  642.       $res11 = mysql_query( "SELECT id FROM {$sourceTablePrefix}posts" , $dbh );

    643. 

  643.       if( mysql_error( $dbh ) )

    644. 

  644.         self::ajaxError( 'A database error occured: ' . substr( mysql_error( $dbh ) , 0 , 200 ) );

    645. 

  645.       while ($row = mysql_fetch_array($res11, MYSQL_ASSOC)) {

    646. 

  646.         $res12 = mysql_query( "SELECT COUNT(*) AS cnt FROM {$sourceTablePrefix}comments WHERE comment_post_ID = " . $row['ID'] , $dbh );

    647. 

  647.         if( mysql_error( $dbh ) )

    648. 

  648.           self::ajaxError( 'A database error occured: ' . substr( mysql_error( $dbh ) , 0 , 200 ) );

    649. 

  649.         $row5 = mysql_fetch_array($res12, MYSQL_ASSOC);

    650. 

  650.         mysql_query( "UPDATE {$sourceTablePrefix}posts SET comment_count = " . $row5['cnt'] . " WHERE id = " . $row['ID'] , $dbh );

    651. 

  651.         if( mysql_error( $dbh ) )

    652. 

  652.           self::ajaxError( 'A database error occured: ' . substr( mysql_error( $dbh ) , 0 , 200 ) );

    653. 

  653.       }

    654. 

  654.     }

    655. 

  655.     if( !$backupDisabled ){

    656. 

  656.       if( !mysql_select_db( $dbname , $dbh ) )

    657. 

  657.         self::ajaxError( "Could not select database {$dbname} : " . mysql_error( $dbh ) );

    658. 

  658.       $curdbres = mysql_query( 'SELECT DATABASE()' , $dbh );

    659. 

  659.       $curdbrow = mysql_fetch_array( $curdbres , MYSQL_NUM );

    660. 

  660.       if( mysql_error( $dbh ) )

    661. 

  661.         self::ajaxError( 'A database error occured: ' . substr( mysql_error( $dbh ) , 0 , 200 ) );

    662. 

  662.       $res14 = mysql_query( 'SHOW TABLES' , $dbh );

    663. 

  663.       if( mysql_error( $dbh ) )

    664. 

  664.         self::ajaxError( 'A database error occured: ' . substr( mysql_error( $dbh ) , 0 , 200 ) );

    665. 

  665.       $allTables = array();

    666. 

  666.       while( $row = mysql_fetch_array( $res14 , MYSQL_NUM ) ){

    667. 

  667.         array_push( $allTables , $row[0] );

    668. 

  668.       }

    669. 

  669.       if( mysql_error( $dbh ) )

    670. 

  670.         self::ajaxError( 'A database error occured: ' . substr( mysql_error( $dbh ) , 0 , 200 ) );

    671. 

  671.       if( !mysql_select_db( $backupDatabase , $dbh ) )

    672. 

  672.         self::ajaxError("Could not select backup database {$backupDatabase} : " . mysql_error( $dbh ) );

    673. 

  673.       error_log( "BACKUPDB: {$backupDatabase}" );

    674. 

  674.       $curdbres = mysql_query( 'SELECT DATABASE()' , $dbh );

    675. 

  675.       $curdbrow = mysql_fetch_array( $curdbres , MYSQL_NUM );

    676. 

  676. 

    677. 

  677.       self::emptyDatabase( $backupDatabase , $dbh );

    678. 

  678.       foreach( $allTables as $t ){

    679. 

  679.        // We're taking across all tables including dep_ tables just so we have a backup. We won't deploy dep_ tables though

    680. 

  680.         mysql_query( "CREATE TABLE {$backupDatabase}.{$t} LIKE {$dbname}.{$t}" , $dbh );

    681. 

  681.         if( mysql_error( $dbh ) )

    682. 

  682.           self::ajaxError( "Could not create table {$t} in backup DB: " . mysql_error( $dbh ) );

    683. 

  683.         mysql_query( "INSERT INTO {$t} SELECT * FROM {$dbname}.{$t}" , $dbh );

    684. 

  684.         if( mysql_error( $dbh ) )

    685. 

  685.           self::ajaxError( "Could not copy table {$t} from {$dbname} database: " . mysql_error( $dbh ) );

    686. 

  686.       }

    687. 

  687.       mysql_query( "CREATE TABLE dep_backupdata ( name VARCHAR(20) NOT NULL , val VARCHAR(255) DEFAULT '')" , $dbh );

    688. 

  688.       if( mysql_error( $dbh ) )

    689. 

  689.         self::ajaxError( 'A database error occured: ' . substr( mysql_error( $dbh ) , 0 , 200 ) );

    690. 

  690.       mysql_query( "INSERT INTO dep_backupdata VALUES ('blogid', '{$blogid}')" , $dbh );

    691. 

  691.       if( mysql_error( $dbh ) )

    692. 

  692.         self::ajaxError( 'A database error occured: ' . substr( mysql_error( $dbh ) , 0 , 200 ) );

    693. 

  693.       mysql_query( "INSERT INTO dep_backupdata VALUES ('prefix', '{$destTablePrefix}')", $dbh);

    694. 

  694.       if( mysql_error( $dbh ) )

    695. 

  695.         self::ajaxError( 'A database error occured: ' . substr( mysql_error( $dbh ) , 0 , 200 ) );

    696. 

  696.       mysql_query( "INSERT INTO dep_backupdata VALUES ('deployTime', '" . microtime(true) . "')", $dbh);

    697. 

  697.       if( mysql_error( $dbh ) )

    698. 

  698.         self::ajaxError( 'A database error occured: ' . substr( mysql_error( $dbh ) , 0 , 200 ) );

    699. 

  699.       mysql_query( "INSERT INTO dep_backupdata VALUES ('deployFrom', '{$sourceHost}')", $dbh);

    700. 

  700.       if( mysql_error( $dbh ) )

    701. 

  701.         self::ajaxError( 'A database error occured: ' . substr( mysql_error( $dbh ) , 0 , 200 ) );

    702. 

  702.       mysql_query( "INSERT INTO dep_backupdata VALUES ('deployTo', '{$destHost}')", $dbh);

    703. 

  703.       if( mysql_error( $dbh ) )

    704. 

  704.         self::ajaxError( 'A database error occured: ' . substr( mysql_error( $dbh ) , 0 , 200 ) );

    705. 

  705.       mysql_query( "INSERT INTO dep_backupdata VALUES ('snapshotName', '{$name}')", $dbh);

    706. 

  706.       if( mysql_error( $dbh ) )

    707. 

  707.         self::ajaxError( 'A database error occured: ' . substr( mysql_error( $dbh ) , 0 , 200 ) );

    708. 

  708.       mysql_query( "INSERT INTO dep_backupdata VALUES ('projectID', '{$pid}')", $dbh);

    709. 

  709.       if( mysql_error( $dbh ) )

    710. 

  710.         self::ajaxError( 'A database error occured: ' . substr( mysql_error( $dbh ) , 0 , 200 ) );

    711. 

  711.       mysql_query( "INSERT INTO dep_backupdata VALUES ('projectName', '" . $proj['name'] . "')", $dbh);

    712. 

  712.       if( mysql_error( $dbh ) )

    713. 

  713.         self::ajaxError( 'A database error occured: ' . substr( mysql_error( $dbh ) , 0 , 200 ) );

    714. 

  714.     }

    715. 

  715. 

    716. 

  716.     if( !mysql_select_db( $temporaryDatabase , $dbh ) )

    717. 

  717.       self::ajaxError( "Could not select temporary database {$temporaryDatabase} : " . mysql_error( $dbh ) );

    718. 

  718.         $curdbres = mysql_query( 'SELECT DATABASE()' , $dbh );

    719. 

  719.         $curdbrow = mysql_fetch_array( $curdbres , MYSQL_NUM );

    720. 

  720. 

    721. 

  721.         $renames = array();

    722. 

  722.         foreach( self::$wpTables as $t ){

    723. 

  723.           array_push( $renames , "{$dbname}.{$destTablePrefix}{$t} TO {$temporaryDatabase}.old_{$t} , {$temporaryDatabase}.{$sourceTablePrefix}$t TO {$dbname}.{$destTablePrefix}{$t}" );

    724. 

  724.         }

    725. 

  725.         $stime = microtime( true );

    726. 

  726.         mysql_query( 'RENAME TABLE ' . implode( ', ', $renames ) , $dbh );

    727. 

  727.         $lockTime = sprintf( '%.4f' , microtime( true ) - $stime );

    728. 

  728.         if( mysql_error( $dbh ) )

    729. 

  729.           self::ajaxError( 'A database error occured: ' . substr( mysql_error( $dbh ) , 0 , 200 ) );

    730. 

  730.         if( $temporaryDatabaseCreated ){

    731. 

  731.           mysql_query( "DROP DATABASE {$temporaryDatabase}" , $dbh );

    732. 

  732.         }else{

    733. 

  733.           self::emptyDatabase( $temporaryDatabase , $dbh );

    734. 

  734.         }

    735. 

  735.         if( mysql_error( $dbh ) )

    736. 

  736.           self::ajaxError( 'A database error occured trying to drop an old temporary database, but the deployment completed. Error was: ' . substr( mysql_error( $dbh ) , 0 , 200 ) );

    737. 

  737.         if( !$backupDisabled )

    738. 

  738.           self::deleteOldBackupDatabases();

    739. 

  739.         die( json_encode( array( 'ok' => 1 , 'lockTime' => $lockTime ) ) );

    740. 

  740.       }

    741. 

  741.   }

    742. 

  742. 

    743. 

  743.   public static function ajax_updateSnapDesc_callback(){

    744. 

  744.     self::checkPerms();

    745. 

  745.     global $wpdb;

    746. 

  746.     $opt = self::getOptions();

    747. 

  747.     extract( $opt , EXTR_OVERWRITE );

    748. 

  748.     $pid = $_POST['projectid'];

    749. 

  749.     $snapname = $_POST['snapname'];

    750. 

  750.     $res = $wpdb->get_results( $wpdb->prepare( 'SELECT dir FROM dep_projects WHERE id = %d' , $pid ) , ARRAY_A );

    751. 

  751.     $dir = $res[0]['dir'];

    752. 

  752.     $fulldir = $datadir . $dir;

    753. 

  753.     $logOut = self::mexec( "$git checkout $snapname >/dev/null 2>&1 ; $git log -n 1 2>&1 ; $git checkout master >/dev/null 2>&1" , $fulldir );

    754. 

  754.     $logOut = preg_replace( '/^commit [0-9a-fA-F]+[\r\n]+/' , '' , $logOut );

    755. 

  755.     if( preg_match( '/fatal: bad default revision/' , $logOut ) )

    756. 

  756.       die( json_encode( array( 'desc' => '' ) ) );

    757. 

  757.     die( json_encode( array( 'desc' => $logOut ) ) );

    758. 

  758.   }

    759. 

  759. 

    760. 

  760.   public static function ajax_updateDeploySnapshot_callback(){

    761. 

  761.     self::checkPerms();

    762. 

  762.     global $wpdb;

    763. 

  763.     $opt = self::getOptions();

    764. 

  764.     extract( $opt , EXTR_OVERWRITE );

    765. 

  765.     $pid = $_POST['projectid'];

    766. 

  766.     $blogsTable = $wpdb->base_prefix . 'blogs';

    767. 

  767.     $blogs = $wpdb->get_results( $wpdb->prepare( "SELECT {$blogsTable}.blog_id AS blog_id , {$blogsTable}.domain AS domain , $blogsTable.path AS path FROM dep_members , $blogsTable WHERE dep_members.blog_id = {$blogsTable}.blog_id AND dep_members.project_id = %d AND dep_members.deleted = 0" , $pid ) , ARRAY_A );

    768. 

  768.     $res1 = $wpdb->get_results( $wpdb->prepare( "SELECT dir FROM dep_projects WHERE id = %d" , $pid ) , ARRAY_A );

    769. 

  769.     $dir = $datadir . $res1[0]['dir'];

    770. 

  770.     if( !is_dir( $dir ) )

    771. 

  771.       self::ajaxError( "The directory $dir for this project does not exist." );

    772. 

  772.     $bOut = self::mexec( "$git branch 2>&1" , $dir );

    773. 

  773.     $branches = preg_split( '/[\r\n\s\t\*]+/' , $bOut );

    774. 

  774.     $snapshots = array();

    775. 

  775.     for( $i = 0 , $c = count( $branches ) ; $i < $c ; $i++ ){

    776. 

  776.       if( preg_match( '/\w+/' , $branches[$i] ) ){

    777. 

  777.         $bname = $branches[$i];

    778. 

  778.         if( $bname=='master' )

    779. 

  779.           continue;

    780. 

  780.         $dateOut = self::mexec( "$git checkout $bname 2>&1; $git log -n 1 | grep Date 2>&1" , $dir );

    781. 

  781.         $m = '';

    782. 

  782.         if( preg_match( '/Date:\s+(.+)$/' , $dateOut , $m ) ){

    783. 

  783.           $ctime = strtotime($m[1]);

    784. 

  784.           $date = $m[1];

    785. 

  785.           array_push( $snapshots , array('name' => $branches[$i] , 'created' => $date , 'ctime' => $ctime ) );

    786. 

  786.         }

    787. 

  787.       }else{

    788. 

  788.         unset( $branches[$i] );

    789. 

  789.       }

    790. 

  790.     }

    791. 

  791.     if( count( $snapshots ) ){

    792. 

  792.       function ctimeSort( $b , $a ){

    793. 

  793.         if( $a['ctime']==$b['ctime'] )

    794. 

  794.           return 0;

    795. 

  795.         return ( $a['ctime'] < $b['ctime'] ? -1 : 1 );

    796. 

  796.       }

    797. 

  797.       usort( $snapshots , 'ctimeSort' );

    798. 

  798.     }

    799. 

  799.     die( json_encode( array( 'blogs' => $blogs , 'snapshots' => $snapshots ) ) );

    800. 

  800.   }

    801. 

  801. 

    802. 

  802.   public static function ajax_updateCreateSnapshot_callback(){

    803. 

  803.     self::checkPerms();

    804. 

  804.     global $wpdb;

    805. 

  805.     $pid = $_POST['projectid'];

    806. 

  806.     $blogsTable = $wpdb->base_prefix . 'blogs';

    807. 

  807.     $blogs = $wpdb->get_results( $wpdb->prepare( "SELECT {$blogsTable}.blog_id AS blog_id , {$blogsTable}.domain AS domain, {$blogsTable}.path AS path FROM dep_members , {$blogsTable} WHERE dep_members.blog_id = {$blogsTable}.blog_id AND dep_members.project_id = %d AND dep_members.deleted = 0" , $pid ) , ARRAY_A );

    808. 

  808.     die( json_encode( array( 'blogs' => $blogs ) ) );

    809. 

  809.   }

    810. 

  810. 

    811. 

  811.   public static function ajax_reloadProjects_callback(){

    812. 

  812.     self::checkPerms();

    813. 

  813.     global $wpdb;

    814. 

  814.     $blogsTable = $wpdb->base_prefix . 'blogs';

    815. 

  815.     $projects = $wpdb->get_results( $wpdb->prepare( 'SELECT id , name FROM dep_projects WHERE deleted = 0' ) , ARRAY_A );

    816. 

  816.     $allBlogs = $wpdb->get_results( $wpdb->prepare( "SELECT blog_id , domain , path FROM $blogsTable ORDER BY domain ASC" ) , ARRAY_A );

    817. 

  817.     for( $i = 0 , $c = count( $projects ) ; $i < $c ; $i++ ){

    818. 

  818.       $mem = $wpdb->get_results($wpdb->prepare( "SELECT $blogsTable.blog_id AS blog_id , $blogsTable.domain AS domain , $blogsTable.path AS path FROM dep_members , $blogsTable WHERE dep_members.deleted=0 AND dep_members.project_id=%d AND dep_members.blog_id = $blogsTable.blog_id" , $projects[$i]['id'] ) , ARRAY_A );

    819. 

  819.       $projects[$i]['memberBlogs'] = $mem;

    820. 

  820.       $memids = array();

    821. 

  821.       $notSQL = '';

    822. 

  822.       if( count( $mem ) ){

    823. 

  823.         for( $j = 0 , $d = count( $mem ) ; $j < $d ; $j++ ){

    824. 

  824.           array_push( $memids , $mem[$j]['blog_id'] );

    825. 

  825.         }

    826. 

  826.         $notSQL = ' WHERE blog_id NOT IN (' . implode( ',' , $memids ) . ')';

    827. 

  827.       }

    828. 

  828.       $nonmem = $wpdb->get_results( $wpdb->prepare( "SELECT blog_id , domain , path FROM {$blogsTable}{$notSQL} ORDER BY domain ASC" ) , ARRAY_A );

    829. 

  829.       $projects[$i]['nonmemberBlogs'] = $nonmem;

    830. 

  830.       $projects[$i]['numNonmembers'] = count( $nonmem );

    831. 

  831.     }

    832. 

  832.     die( json_encode( array( 'projects' => $projects ) ) );

    833. 

  833.   }

    834. 

  834. 

    835. 

  835.   public static function ajax_deploy_callback(){

    836. 

  836.     self::checkPerms();

    837. 

  837.     global $wpdb;

    838. 

  838.     $fromid = $_POST['deployFrom'];

    839. 

  839.     $toid = $_POST['deployTo'];

    840. 

  840.     $msgs = array();

    841. 

  841.     $fromBlog = $wpdb->get_results( $wpdb->prepare( 'SELECT blog_id , domain , path FROM wp_blogs WHERE blog_id = %d' , $fromid ) , ARRAY_A );

    842. 

  842.     $toBlog = $wpdb->get_results( $wpdb->prepare( 'SELECT blog_id , domain , path FROM wp_blogs WHERE blog_id = %d' , $toid ) , ARRAY_A );

    843. 

  843.     if( count( $fromBlog )!=1 )

    844. 

  844.       die( 'We could not find the blog you are deploying from.' );

    845. 

  845.     if( count( $toBlog )!=1 )

    846. 

  846.       die( 'We could not find the blog you are deploying to.');

    847. 

  847.     $fromPrefix = 'wp_';

    848. 

  848.     $toPrefix = 'wp_';

    849. 

  849. 

    850. 

  850.     if( $fromid!=1 )

    851. 

  851.       $fromPrefix .= $fromid . '_';

    852. 

  852.     if( $toid!=1 )

    853. 

  853.       $toPrefix .= $toid . '_';

    854. 

  854.     $t_fromPosts = $fromPrefix . 'posts';

    855. 

  855.     $t_toPosts = $toPrefix . 'posts';

    856. 

  856.     $fromPostTotal = $wpdb->get_results( $wpdb->prepare( "SELECT COUNT(*) AS cnt FROM $t_fromPosts WHERE post_status = 'publish'" , $fromid ) , ARRAY_A );

    857. 

  857.     $toPostTotal = $wpdb->get_results( $wpdb->prepare( "SELECT COUNT(*) AS cnt FROM $t_toPosts WHERE post_status = 'publish'" , $toid ) , ARRAY_A );

    858. 

  858.     $fromNewestPost = $wpdb->get_results( $wpdb->prepare( "SELECT post_title FROM $t_fromPosts WHERE post_status = 'publish' ORDER BY post_modified DESC LIMIT 1" , $fromid ) , ARRAY_A );

    859. 

  859.     $toNewestPost = $wpdb->get_results( $wpdb->prepare( "SELECT post_title FROM $t_toPosts WHERE post_status = 'publish' ORDER BY post_modified DESC LIMIT 1" , $toid ) , ARRAY_A );

    860. 

  860.     die( json_encode( array(

    861. 

  861.       'fromid'              => $fromid ,

    862. 

  862.       'toid'                => $toid ,

    863. 

  863.       'fromDomain'          => $fromBlog[0]['domain'] ,

    864. 

  864.       'fromPostTotal'       => $fromPostTotal[0]['cnt'] ,

    865. 

  865.       'fromNewestPostTitle' => $fromNewestPost[0]['post_title'] ,

    866. 

  866.       'toDomain'            => $toBlog[0]['domain'] ,

    867. 

  867.       'toPostTotal'         => $toPostTotal[0]['cnt'] ,

    868. 

  868.       'toNewestPostTitle'   => $toNewestPost[0]['post_title']

    869. 

  869.     ) ) );

    870. 

  870.   }

    871. 

  871. 

    872. 

  872.   public static function initHandler(){

    873. 

  873.     if( is_admin() ){

    874. 

  874.       wp_enqueue_script( 'jquery-templates' , plugin_dir_url( __FILE__ ) . 'js/jquery.tmpl.min.js' , array( 'jquery' ) );

    875. 

  875.       wp_enqueue_script( 'deploymint-js' , plugin_dir_url( __FILE__ ) . 'js/deploymint.js' , array( 'jquery' ) );

    876. 

  876.       wp_localize_script( 'deploymint-js' , 'DeployMintVars' , array( 'ajaxURL' => admin_url( 'admin-ajax.php' ) ) );

    877. 

  877.     }

    878. 

  878.   }

    879. 

  879. 

    880. 

  880.   public static function adminMenuHandler(){

    881. 

  881.     global $wpdb;

    882. 

  882.     extract( self::getOptions() , EXTR_OVERWRITE );

    883. 

  883.     $capability = ( is_multisite() ? 'manage_network' : 'manage_options' );

    884. 

  884.     add_submenu_page( 'DeployMint' , 'Manage Projects' , 'Manage Projects' , $capability , 'DeployMint' , 'deploymint::deploymintMenu' );

    885. 

  885.     add_menu_page( 'DeployMint' , 'DeployMint' , $capability , 'DeployMint' , 'deploymint::deploymintMenu' , WP_PLUGIN_URL . '/DeployMint/images/deployMintIcon.png' );

    886. 

  886.     $projects = $wpdb->get_results($wpdb->prepare( 'SELECT id , name FROM dep_projects WHERE deleted = 0' ) , ARRAY_A );

    887. 

  887.     for( $i = 0 , $c = count( $projects ) ; $i < $c ; $i++ ){

    888. 

  888.       add_submenu_page( 'DeployMint' , 'Proj: ' . $projects[$i]['name'] , 'Proj: ' . $projects[$i]['name'] , $capability , 'DeployMintProj' . $projects[$i]['id'] , 'deploymint::projectMenu' . $projects[$i]['id'] );

    889. 

  889.     }

    890. 

  890.     if( !$backupDisabled )

    891. 

  891.       add_submenu_page( 'DeployMint' , 'Emergency Revert' , 'Emergency Revert' , $capability , 'DeployMintBackout' , 'deploymint::undoLog' );

    892. 

  892.     add_submenu_page( 'DeployMint' , 'Options' , 'Options' , $capability , 'DeployMintOptions' , 'deploymint::myOptions' );

    893. 

  893.     add_submenu_page( 'DeployMint' , 'Help' , 'Help' , $capability , 'DeployMintHelp' , 'deploymint::help' );

    894. 

  894.   }

    895. 

  895. 

    896. 

  896.   public static function deploymintMenu(){

    897. 

  897.     if( !self::allOptionsSet() ){

    898. 

  898.       echo '<div class="wrap"><h2 class="depmintHead">Please visit the options page and configure all options</h2></div>';

    899. 

  899.       return;

    900. 

  900.     }

    901. 

  901.     include( 'views/deploymintHome.php' );

    902. 

  902.   }

    903. 

  903. 

    904. 

  904.   public static function help(){

    905. 

  905.     include( 'views/help.php' );

    906. 

  906.   }

    907. 

  907. 

    908. 

  908.   public static function myOptions(){

    909. 

  909.     $opt = self::getOptions();

    910. 

  910.     include( 'views/myOptions.php' );

    911. 

  911.   }

    912. 

  912. 

    913. 

  913.   private static function deleteOldBackupDatabases(){

    914. 

  914.     self::checkPerms();

    915. 

  915.     $opt = self::getOptions();

    916. 

  916.     extract( $opt , EXTR_OVERWRITE );

    917. 

  917.     if( $numBackups < 1 )

    918. 

  918.       return;

    919. 

  919.     $dbh = mysql_connect( DB_HOST , DB_USER , DB_PASSWORD , true );

    920. 

  920.     mysql_select_db( DB_NAME , $dbh );

    921. 

  921.     $res1 = mysql_query( 'SHOW DATABASES' , $dbh );

    922. 

  922.     if( mysql_error( $dbh ) ){

    923. 

  923.       error_log( 'A database error occured: ' . mysql_error( $dbh ) );

    924. 

  924.       return;

    925. 

  925.     }

    926. 

  926.     $dbs = array();

    927. 

  927.     while( $row1 = mysql_fetch_array( $res1 , MYSQL_NUM ) ){

    928. 

  928.       $dbPrefix = ( $backupDatabase=='' ? 'depbak' : $backupDatabase );

    929. 

  929.       if( preg_match( '/^' . $dbPrefix . '__/' , $row1[0] ) ){

    930. 

  930.         $dbname = $row1[0];

    931. 

  931.         $res2 = mysql_query( "SELECT val FROM $dbname.dep_backupdata WHERE name = 'deployTime'" , $dbh );

    932. 

  932.         if( mysql_error( $dbh ) ){

    933. 

  933.           error_log( "Could not get deployment time for $dbname database" );

    934. 

  934.           return;

    935. 

  935.         }

    936. 

  936.         $row2 = mysql_fetch_array( $res2 , MYSQL_ASSOC );

    937. 

  937.         if( $row2 && $row2['val'] ){

    938. 

  938.           array_push( $dbs , array( 'dbname' => $dbname , 'deployTime' => $row2['val'] ) );

    939. 

  939.         }else{

    940. 

  940.           error_log( "Could not get deployment time for backup database $dbname" );

    941. 

  941.           return;

    942. 

  942.         }

    943. 

  943.       }

    944. 

  944.     }

    945. 

  945.     if( count( $dbs ) > $numBackups ){

    946. 

  946.       function deployTimeSort( $a , $b ){

    947. 

  947.         if…
    948.

Large files files are truncated, but you can click here to view the full file