PHP SplFileObject::flock方法代码示例

 public function create($filename)
 {
     $now = date('Y_m_d_H_i_s');
     $fileob = new \SplFileObject($this->path . $now . '_' . $filename . '.php', 'w');
     $classname = $this->getClassByFileName(str_replace('_table', '', $filename));
     $fileob->flock(LOCK_EX);
     $fileob->fwrite("<?php\nuse Lib\\Migration;\nclass {$classname} extends Migration\n{\n    public function up()\n    {\n    }\n    public function down()\n    {\n    }\n} \n?>");
     $fileob->flock(LOCK_UN);
     return true;
 }

 /**
  * コンストラクタ
  * 副作用が大量にあるので注意
  */
 public function __construct(ClientInterface $client, $filename = 'stamp.json', $span = 0, $mark_limit = 10000, $back_limit = 3600)
 {
     // ヘッダの送出
     if (!headers_sent()) {
         header('Content-Type: text/html; charset=UTF-8');
     }
     // エラー表示の設定
     error_reporting(-1);
     ini_set('log_errors', PHP_SAPI === 'cli');
     ini_set('display_errors', PHP_SAPI !== 'cli');
     // 重複起動防止
     $file = new \SplFileObject($filename, 'a+b');
     if (!$file->flock(LOCK_EX | LOCK_NB)) {
         throw new \RuntimeException('Failed to lock file.');
     }
     // JSONとして保存してあるデータを取得
     clearstatcache();
     $json = $file->getSize() > 0 ? json_decode($file->fread($file->getSize()), true) : [];
     // JSONに前回実行時刻が保存されていた時
     if (isset($json['prev'])) {
         // 十分に時間が空いたかどうかをチェック
         if (!static::expired($json['prev'], $span)) {
             throw new \RuntimeException('Execution span is not enough.');
         }
     }
     // JSONにマーク済みステータス一覧が記録されていたとき復元する
     if (isset($json['marked'])) {
         $this->marked = array_map('filter_var', (array) $json['marked']);
     }
     $this->client = $client;
     $this->file = $file;
     $this->prev = (new \DateTimeImmutable('now', new \DateTimeZone('UTC')))->format('r');
     $this->mark_limit = $mark_limit;
     $this->back_limit = $back_limit;
 }

 public function __construct($rewriteRuleFile = false)
 {
     if (function_exists('apache_get_modules') && !in_array('mod_rewrite', apache_get_modules())) {
         throw new \Exception('mod_rewrite module must be activated');
     }
     $rewriteRuleFile = $rewriteRuleFile ? $rewriteRuleFile : PATH_ROOT . '.htaccess';
     $this->setRewriteRuleFile($rewriteRuleFile);
     $fileRule = new \SplFileObject($this->_rewriteRuleFile, 'r');
     if ($fileRule->flock(LOCK_EX)) {
         foreach ($fileRule as $line) {
             if (strpos($line, 'RewriteRule') !== false && strpos($line, '#') === false) {
                 $this->setRewriteRule($line);
             }
         }
         $fileRule->flock(LOCK_UN);
     }
 }

 /**
  * Free the used slots
  *
  * @param $sliced_report_definitions_count
  */
 private function freeUsedRequestCount($sliced_report_definitions_count)
 {
     $this->file_counter->flock(LOCK_EX);
     $this->file_counter->rewind();
     $used_request_count = (int) $this->file_counter->fgets();
     $new_used_request_count = $used_request_count - $sliced_report_definitions_count;
     $this->file_counter->ftruncate(0);
     $this->file_counter->fwrite($new_used_request_count);
     $this->file_counter->flock(LOCK_UN);
 }

 public function __construct($params = array())
 {
     if (!extension_loaded('apcu') && !extension_loaded('apc')) {
         throw new \Exception('Apcu extension not loaded try change your PHP configuration');
     }
     parent::init($params);
     Logger::getInstance()->addGroup('cache' . $this->_name, 'Cache ' . $this->_name, true, true);
     //create dynamic key and add to prefix (it's for multi applications)
     if (!file_exists(PATH_CACHE . $this->_name)) {
         $key = rand();
         $file = new \SplFileObject(PATH_CACHE . 'ApcuKey' . $this->_name, 'w+');
         if ($file->flock(LOCK_EX)) {
             $file->fwrite($key);
             $file->flock(LOCK_UN);
         }
         $this->_prefix .= $key;
     } else {
         $this->_prefix .= file_get_contents(PATH_CACHE . $this->_name);
     }
 }

 /**
  * Writes the record data from memory into the file store.
  *
  * @return void
  */
 public function save()
 {
     $tmpHandle = new \SplFileObject('php://temp', 'w+');
     $tmpData = '';
     $tmpHandle->fputcsv($this->model->columns());
     foreach ($this->all() as $record) {
         $tmpHandle->fputcsv($record->toArray());
         $record->exists = true;
     }
     $tmpHandle->rewind();
     while (!$tmpHandle->eof()) {
         $tmpData .= $tmpHandle->fgets();
     }
     $this->file->flock(\LOCK_EX | \LOCK_NB);
     $this->file->ftruncate(0);
     $this->file->rewind();
     $this->file->fwrite($tmpData);
     $this->file->flock(\LOCK_UN);
 }

 /**
  * Index the file by getting key/value positions within the file
  *
  * @return array
  */
 public function buildIndex()
 {
     $this->file->flock(LOCK_SH);
     $this->file->fseek(0);
     $indexes = [];
     while (!$this->file->eof()) {
         $position = $this->file->ftell();
         // Grab key and value lengths - if its the last (empty) line, break
         if (!($metadata = $this->getMetadata())) {
             break;
         }
         // Gets the key and adds the key and position to the index
         $indexes[$this->file->fread($metadata->klen)] = $position;
         //Skip over the value, to the next key/value pair
         $this->file->fseek($metadata->vlen, SEEK_CUR);
     }
     $this->file->flock(LOCK_UN);
     return $indexes;
 }

 /**
  * Read a key from the cache
  *
  * @param string $key Identifier for the data
  * @return mixed The cached data, or false if the data doesn't exist, has
  *   expired, or if there was an error fetching it
  */
 public function read($key)
 {
     $key = $this->_key($key);
     if (!$this->_init || $this->_setKey($key) === false) {
         return false;
     }
     if ($this->_config['lock']) {
         $this->_File->flock(LOCK_SH);
     }
     $this->_File->rewind();
     $time = time();
     $cachetime = (int) $this->_File->current();
     if ($cachetime !== false && ($cachetime < $time || $time + $this->_config['duration'] < $cachetime)) {
         if ($this->_config['lock']) {
             $this->_File->flock(LOCK_UN);
         }
         return false;
     }
     $data = '';
     $this->_File->next();
     while ($this->_File->valid()) {
         $data .= $this->_File->current();
         $this->_File->next();
     }
     if ($this->_config['lock']) {
         $this->_File->flock(LOCK_UN);
     }
     $data = trim($data);
     if ($data !== '' && !empty($this->_config['serialize'])) {
         if ($this->_config['isWindows']) {
             $data = str_replace('\\\\\\\\', '\\', $data);
         }
         $data = unserialize((string) $data);
     }
     return $data;
 }

 public function read($key)
 {
     if (!$this->is_init || $this->_openFile($key) === false) {
         return false;
     }
     if ($this->settings['lock']) {
         $this->file->flock(LOCK_SH);
     }
     $this->file->rewind();
     $time = time();
     $cachetime = intval($this->file->current());
     //check for expiry
     if ($cachetime !== false && ($cachetime < $time || $time + $this->settings['cache_duration'] < $cachetime)) {
         if ($this->settings['lock']) {
             $this->file->flock(LOCK_UN);
         }
         return false;
     }
     $data = '';
     $this->file->next();
     while ($this->file->valid()) {
         $data .= $this->file->current();
         $this->file->next();
     }
     if ($this->settings['lock']) {
         $this->file->flock(LOCK_UN);
     }
     $data = trim($data);
     if ($data !== '' && !empty($this->settings['serialize'])) {
         if ($this->settings['is_windows']) {
             $data = str_replace('\\\\\\\\', '\\', $data);
         }
         $data = json_decode((string) $data, TRUE);
     }
     return $data;
 }

 /**
  * Generates a uuid.
  *
  * @return string
  */
 private function getJobFilename($queueName)
 {
     $path = $this->baseDirectory . '/bernard.meta';
     if (!is_file($path)) {
         touch($path);
     }
     $file = new \SplFileObject($path, 'r+');
     $file->flock(LOCK_EX);
     $meta = unserialize($file->fgets());
     $id = isset($meta[$queueName]) ? $meta[$queueName] : 0;
     $id++;
     $filename = sprintf('%d.job', $id);
     $meta[$queueName] = $id;
     $content = serialize($meta);
     $file->fseek(0);
     $file->fwrite($content, strlen($content));
     $file->flock(LOCK_UN);
     return $filename;
 }

 private function updateOrDelete($id, $data = null)
 {
     /* Thanks to https://www.daniweb.com/web-development/php/threads/102279/deleting-a-line-from-a-file#post1353582 */
     /*
      * Create a new SplFileObject representation of the file
      * Open it for reading and writing and place the pointer at the beginning of the file
      * @see fopen for additional modes
      */
     $file = new \SplFileObject($this->filename, 'a+');
     /*
      * Set a bitmask of the flags to apply - Only relates to reading from file
      * In this case SplFileObject::DROP_NEW_LINE to remove new line charachters
      * and SplFileObject::SKIP_EMPTY to remove empty lines
      */
     $file->setFlags(7);
     /*
      * Lock the file so no other user can interfere with reading and writing while we work with it
      */
     $file->flock(LOCK_EX);
     /*
      * Create a SplTempFileObject
      * 0 indicates not to use memory to store the temp file.
      * This is probably slower than using memory, but for a large file it will be much more effective
      * than loading the entire file into memory
      * @see http://www.php.net/manual/en/spltempfileobject.construct.php for more details
      */
     $temp = new \SplTempFileObject(0);
     /*
      * Lock the temp file just in case
      */
     $temp->flock(LOCK_EX);
     /*
      * Iterate over each line of the file only loading one line into memory at any point in time
      */
     foreach ($file as $key => $line) {
         if ($key != $id) {
             /*
              * If this line does NOT match out delete write it to the temp file
              * Append a line ending to it
              */
             $temp->fwrite($line . PHP_EOL);
         } else {
             if ($data !== null) {
                 $temp->fwrite($data . PHP_EOL);
             }
         }
     }
     /*
      * Truncate the existing file to 0
      */
     $file->ftruncate(0);
     /*
      * Write the temp file back to the existing file
      */
     foreach ($temp as $line) {
         /*
          * Iterate over temp file and put each line back into original file
          */
         $file->fwrite($line);
     }
     /*
      * Release the file locks
      */
     $temp->flock(LOCK_UN);
     $file->flock(LOCK_UN);
     return true;
 }

 protected function _writeLogs()
 {
     if (!empty($this->_logs)) {
         $file = new \SplFileObject($this->_selectLogDir() . date('d') . '.' . self::$_logExt, 'a+');
         if ($file->flock(LOCK_EX)) {
             $file->fwrite($this->_logs);
             $file->flock(LOCK_UN);
         }
         $this->_logs = '';
     }
 }

 /**
  * @return $this
  */
 public function RUnlock()
 {
     $this->_file->flock(LOCK_UN);
 }

 /**
  * Compiles the javascript files for the passed shop template.
  *
  * @param $timestamp
  * @param Shop\Template $template
  * @param Shop\Shop $shop
  */
 public function compileJavascript($timestamp, Shop\Template $template, Shop\Shop $shop)
 {
     if ($shop->getMain()) {
         $shop = $shop->getMain();
     }
     $file = $this->pathResolver->getJsFilePath($shop, $timestamp);
     $file = new \SplFileObject($file, "a");
     if (!$file->flock(LOCK_EX)) {
         return;
     }
     $file->ftruncate(0);
     $settings = $this->service->getSystemConfiguration(AbstractQuery::HYDRATE_OBJECT);
     $javascriptFiles = $this->collectJavascriptFiles($template, $shop);
     $content = '';
     foreach ($javascriptFiles as $jsFile) {
         $content .= file_get_contents($jsFile) . "\n";
     }
     if ($settings->getCompressJs()) {
         $content = $this->jsCompressor->compress($content);
     }
     $file->fwrite($content);
     $file->flock(LOCK_UN);
     // release the lock
 }

 /**
  * Function that writes history to the uncompiled history-file.
  * History-files are "uncompiled" before Hicurl::compileHistory has been called on them, which generates a
  * history-file of cosed state.
  * In its uncompiled state its structure is as follows:
  *		(historyData without closing bracket and brace)+(tempHistoryData)+(sizeOfTempHistoryData)
  * historyData is the following json-object: {"pages":[]}
  * But in the uncompiled file it is without the closing bracket+brace as stated above. Each element in its
  * pages-array is the following:<pre>
  * {	"formData"://this is present if it was a POST-request, and will contain the sent form-data
  *		,"name"://a name-string for the page that will be shown in the history-viewer. Set via historyData>name
  *		,"parentIndex": int//may hold an pointing to an index of another page in the pages-array. This will then be
  *			shown in the tree-view of the history-viewer. This is set up with loadSingle>historyData>id/parentId
  *		,"customData": //contains what was passed to customData-parameter of the load method if anything
  *		,"exchanges": [//An array of request&response pairs. Usually this will only contain one
  *								//element but more will be added for each failed request
  *			{
  *				"error": false if no error, otherwise an explanation of the error
  *				"content": the content of the page sent from the server
  *				"headers": ...and the headers
  *			}
  *		...
  *		]
  * }
  * </pre>
  * @param SplFileObject $historyFileObject
  * @param string $data A undecoded page-object, explained in the description of this method.
  * @param array $settings
  * @param array $historyData*/
 private static function writeHistory($historyFileObject, $data, $settings, $historyData)
 {
     if (!isset($historyFileObject)) {
         $historyFileObject = new SplFileObject($settings['history'], 'c+');
     }
     $historyFileObject->flock(LOCK_EX);
     //check if the historyFile is empty. we don't have to check for file-existence because it will always
     //have been created by now byt simply creating the SplFileObject
     if (!$historyFileObject->fstat()['size']) {
         $dataPrefix = '{"pages":[';
         $historyFileTempData = ['numPages' => 0, 'idIndices' => []];
     } else {
         $dataPrefix = ',';
         $tempDataSize = Hicurl::seekHistoryFileTempData($historyFileObject);
         $historyFileTempData = json_decode($historyFileObject->fread($tempDataSize), true);
         $historyFileObject->fseek(-4 - $tempDataSize, SEEK_END);
     }
     if (isset($historyData['id'])) {
         $historyFileTempData['idIndices'][$historyData['id']] = $historyFileTempData['numPages'];
     }
     if (isset($historyData['parentId'])) {
         $data['parentIndex'] = $historyFileTempData['idIndices'][$historyData['parentId']];
     }
     ++$historyFileTempData['numPages'];
     $historyFileObject->fwrite($dataPrefix . json_encode($data));
     $tempDataSize = $historyFileObject->fwrite(json_encode($historyFileTempData));
     $historyFileObject->fwrite(pack('N', $tempDataSize));
     $historyFileObject->flock(LOCK_UN);
 }