PHP DUP_Util::FcgiFlush方法代码示例

 private function phpDump()
 {
     global $wpdb;
     $wpdb->query("SET session wait_timeout = " . DUPLICATOR_DB_MAX_TIME);
     $handle = fopen($this->dbStorePath, 'w+');
     $tables = $wpdb->get_col('SHOW TABLES');
     $filterTables = isset($this->FilterTables) ? explode(',', $this->FilterTables) : null;
     $tblAllCount = count($tables);
     $tblFilterOn = $this->FilterOn ? 'ON' : 'OFF';
     $qryLimit = DUP_Settings::Get('package_phpdump_qrylimit');
     if (is_array($filterTables) && $this->FilterOn) {
         foreach ($tables as $key => $val) {
             if (in_array($tables[$key], $filterTables)) {
                 unset($tables[$key]);
             }
         }
     }
     $tblCreateCount = count($tables);
     $tblFilterCount = $tblAllCount - $tblCreateCount;
     DUP_Log::Info("TABLES: total:{$tblAllCount} | filtered:{$tblFilterCount} | create:{$tblCreateCount}");
     DUP_Log::Info("FILTERED: [{$this->FilterTables}]");
     $sql_header = "/* DUPLICATOR MYSQL SCRIPT CREATED ON : " . @date("Y-m-d H:i:s") . " */\n\n";
     $sql_header .= "SET FOREIGN_KEY_CHECKS = 0;\n\n";
     fwrite($handle, $sql_header);
     //BUILD CREATES:
     //All creates must be created before inserts do to foreign key constraints
     foreach ($tables as $table) {
         //$sql_del = ($GLOBALS['duplicator_opts']['dbadd_drop']) ? "DROP TABLE IF EXISTS {$table};\n\n" : "";
         //@fwrite($handle, $sql_del);
         $create = $wpdb->get_row("SHOW CREATE TABLE `{$table}`", ARRAY_N);
         @fwrite($handle, "{$create[1]};\n\n");
     }
     //BUILD INSERTS:
     //Create Insert in 100 row increments to better handle memory
     foreach ($tables as $table) {
         $row_count = $wpdb->get_var("SELECT Count(*) FROM `{$table}`");
         //DUP_Log::Info("{$table} ({$row_count})");
         if ($row_count > $qryLimit) {
             $row_count = ceil($row_count / $qryLimit);
         } else {
             if ($row_count > 0) {
                 $row_count = 1;
             }
         }
         if ($row_count >= 1) {
             fwrite($handle, "\n/* INSERT TABLE DATA: {$table} */\n");
         }
         for ($i = 0; $i < $row_count; $i++) {
             $sql = "";
             $limit = $i * $qryLimit;
             $query = "SELECT * FROM `{$table}` LIMIT {$limit}, {$qryLimit}";
             $rows = $wpdb->get_results($query, ARRAY_A);
             if (is_array($rows)) {
                 foreach ($rows as $row) {
                     $sql .= "INSERT INTO `{$table}` VALUES(";
                     $num_values = count($row);
                     $num_counter = 1;
                     foreach ($row as $value) {
                         if (is_null($value) || !isset($value)) {
                             $num_values == $num_counter ? $sql .= 'NULL' : ($sql .= 'NULL, ');
                         } else {
                             $num_values == $num_counter ? $sql .= '"' . @esc_sql($value) . '"' : ($sql .= '"' . @esc_sql($value) . '", ');
                         }
                         $num_counter++;
                     }
                     $sql .= ");\n";
                 }
                 fwrite($handle, $sql);
             }
         }
         //Flush buffer if enabled
         if ($this->networkFlush) {
             DUP_Util::FcgiFlush();
         }
         $sql = null;
         $rows = null;
     }
     $sql_footer = "\nSET FOREIGN_KEY_CHECKS = 1; \n\n";
     $sql_footer .= "/* Duplicator WordPress Timestamp: " . date("Y-m-d H:i:s") . "*/\n";
     $sql_footer .= "/* " . DUPLICATOR_DB_EOF_MARKER . " */\n";
     fwrite($handle, $sql_footer);
     $wpdb->flush();
     fclose($handle);
 }

 /**
  *  CREATE
  *  Creates the zip file and adds the SQL file to the archive
  */
 public static function Create(DUP_Archive $archive)
 {
     try {
         $timerAllStart = DUP_Util::GetMicrotime();
         $package_zip_flush = DUP_Settings::Get('package_zip_flush');
         self::$compressDir = rtrim(DUP_Util::SafePath($archive->PackDir), '/');
         self::$sqlPath = DUP_Util::SafePath("{$archive->Package->StorePath}/{$archive->Package->Database->File}");
         self::$zipPath = DUP_Util::SafePath("{$archive->Package->StorePath}/{$archive->File}");
         self::$zipArchive = new ZipArchive();
         self::$networkFlush = empty($package_zip_flush) ? false : $package_zip_flush;
         $filterDirs = empty($archive->FilterDirs) ? 'not set' : $archive->FilterDirs;
         $filterExts = empty($archive->FilterExts) ? 'not set' : $archive->FilterExts;
         $filterOn = $archive->FilterOn ? 'ON' : 'OFF';
         //LOAD SCAN REPORT
         $json = file_get_contents(DUPLICATOR_SSDIR_PATH_TMP . "/{$archive->Package->NameHash}_scan.json");
         self::$scanReport = json_decode($json);
         DUP_Log::Info("\n********************************************************************************");
         DUP_Log::Info("ARCHIVE (ZIP):");
         DUP_Log::Info("********************************************************************************");
         $isZipOpen = self::$zipArchive->open(self::$zipPath, ZIPARCHIVE::CREATE) === TRUE;
         if (!$isZipOpen) {
             DUP_Log::Error("Cannot open zip file with PHP ZipArchive.", "Path location [" . self::$zipPath . "]");
         }
         DUP_Log::Info("ARCHIVE DIR:  " . self::$compressDir);
         DUP_Log::Info("ARCHIVE FILE: " . basename(self::$zipPath));
         DUP_Log::Info("FILTERS: *{$filterOn}*");
         DUP_Log::Info("DIRS:  {$filterDirs}");
         DUP_Log::Info("EXTS:  {$filterExts}");
         DUP_Log::Info("----------------------------------------");
         DUP_Log::Info("COMPRESSING");
         DUP_Log::Info("SIZE:\t" . self::$scanReport->ARC->Size);
         DUP_Log::Info("STATS:\tDirs " . self::$scanReport->ARC->DirCount . " | Files " . self::$scanReport->ARC->FileCount);
         //ADD SQL
         $isSQLInZip = self::$zipArchive->addFile(self::$sqlPath, "database.sql");
         if ($isSQLInZip) {
             DUP_Log::Info("SQL ADDED: " . basename(self::$sqlPath));
         } else {
             DUP_Log::Error("Unable to add database.sql to archive.", "SQL File Path [" . self::$sqlath . "]");
         }
         self::$zipArchive->close();
         self::$zipArchive->open(self::$zipPath, ZipArchive::CREATE);
         //ZIP DIRECTORIES
         foreach (self::$scanReport->ARC->Dirs as $dir) {
             if (self::$zipArchive->addEmptyDir(ltrim(str_replace(self::$compressDir, '', $dir), '/'))) {
                 self::$countDirs++;
             } else {
                 //Don't warn when dirtory is the root path
                 if (strcmp($dir, rtrim(self::$compressDir, '/')) != 0) {
                     DUP_Log::Info("WARNING: Unable to zip directory: '{$dir}'" . rtrim(self::$compressDir, '/'));
                 }
             }
         }
         /* ZIP FILES: Network Flush
          *  This allows the process to not timeout on fcgi 
          *  setups that need a response every X seconds */
         if (self::$networkFlush) {
             foreach (self::$scanReport->ARC->Files as $file) {
                 if (self::$zipArchive->addFile($file, ltrim(str_replace(self::$compressDir, '', $file), '/'))) {
                     self::$limitItems++;
                     self::$countFiles++;
                 } else {
                     DUP_Log::Info("WARNING: Unable to zip file: {$file}");
                 }
                 //Trigger a flush to the web server after so many files have been loaded.
                 if (self::$limitItems > DUPLICATOR_ZIP_FLUSH_TRIGGER) {
                     $sumItems = self::$countDirs + self::$countFiles;
                     self::$zipArchive->close();
                     self::$zipArchive->open(self::$zipPath);
                     self::$limitItems = 0;
                     DUP_Util::FcgiFlush();
                     DUP_Log::Info("Items archived [{$sumItems}] flushing response.");
                 }
             }
             //Normal
         } else {
             foreach (self::$scanReport->ARC->Files as $file) {
                 if (self::$zipArchive->addFile($file, ltrim(str_replace(self::$compressDir, '', $file), '/'))) {
                     self::$countFiles++;
                 } else {
                     DUP_Log::Info("WARNING: Unable to zip file: {$file}");
                 }
             }
         }
         DUP_Log::Info(print_r(self::$zipArchive, true));
         //--------------------------------
         //LOG FINAL RESULTS
         DUP_Util::FcgiFlush();
         $zipCloseResult = self::$zipArchive->close();
         $zipCloseResult ? DUP_Log::Info("COMPRESSION RESULT: '{$zipCloseResult}'") : DUP_Log::Error("ZipArchive close failure.", "This hosted server may have a disk quota limit.\nCheck to make sure this archive file can be stored.");
         $timerAllEnd = DUP_Util::GetMicrotime();
         $timerAllSum = DUP_Util::ElapsedTime($timerAllEnd, $timerAllStart);
         self::$zipFileSize = @filesize(self::$zipPath);
         DUP_Log::Info("COMPRESSED SIZE: " . DUP_Util::ByteSize(self::$zipFileSize));
         DUP_Log::Info("ARCHIVE RUNTIME: {$timerAllSum}");
         DUP_Log::Info("MEMORY STACK: " . DUP_Server::GetPHPMemory());
     } catch (Exception $e) {
//.........这里部分代码省略.........

 private static function flushResponse()
 {
     //Check if were over our count*/
     if (self::$limitItems > self::$limit) {
         $sumItems = self::$countDirs + self::$countFiles + self::$countLinks;
         self::$zipArchive->close();
         self::$zipArchive->open(self::$zipPath);
         self::$limitItems = 0;
         DUP_Util::FcgiFlush();
         DUP_Log::Info("Items archived [{$sumItems}] flushing response.");
     }
 }