search/Zend/Search/Lucene/LockManager.php

   1 <?php
   2 /**
   3  * Zend Framework
   4  *
   5  * LICENSE
   6  *
   7  * This source file is subject to the new BSD license that is bundled
   8  * with this package in the file LICENSE.txt.
   9  * It is also available through the world-wide-web at this URL:
  10  * http://framework.zend.com/license/new-bsd
  11  * If you did not receive a copy of the license and are unable to
  12  * obtain it through the world-wide-web, please send an email
  13  * to license@zend.com so we can send you a copy immediately.
  14  *
  15  * @category   Zend
  16  * @package    Zend_Search_Lucene
  17  * @copyright  Copyright (c) 2005-2008 Zend Technologies USA Inc. (http://www.zend.com)
  18  * @license    http://framework.zend.com/license/new-bsd     New BSD License
  19  */
  20
  21
  22 /** Zend_Search_Lucene_Exception */
  23 require_once 'Zend/Search/Lucene/Exception.php';
  24
  25 /** Zend_Search_Lucene_Storage_Directory */
  26 require_once 'Zend/Search/Lucene/Storage/Directory.php';
  27
  28 /** Zend_Search_Lucene_Storage_File */
  29 require_once 'Zend/Search/Lucene/Storage/File.php';
  30
  31
  32
  33 /**
  34  * This is an utility class which provides index locks processing functionality
  35  *
  36  * @category   Zend
  37  * @package    Zend_Search_Lucene
  38  * @copyright  Copyright (c) 2005-2008 Zend Technologies USA Inc. (http://www.zend.com)
  39  * @license    http://framework.zend.com/license/new-bsd     New BSD License
  40  */
  41 class Zend_Search_Lucene_LockManager
  42 {
  43     const WRITE_LOCK_FILE        = 'write.lock.file';
  44     const READ_LOCK_FILE         = 'read.lock.file';
  45     const OPTIMIZATION_LOCK_FILE = 'optimization.lock.file';
  46
  47     /**
  48      * Obtain exclusive write lock on the index
  49      *
  50      * @param Zend_Search_Lucene_Storage_Directory $lockDirectory
  51      * @return Zend_Search_Lucene_Storage_File
  52      * @throws Zend_Search_Lucene_Exception
  53      */
  54     public static function obtainWriteLock(Zend_Search_Lucene_Storage_Directory $lockDirectory)
  55     {
  56         $lock = $lockDirectory->createFile(self::WRITE_LOCK_FILE);
  57         if (!$lock->lock(LOCK_EX)) {
  58             throw new Zend_Search_Lucene_Exception('Can\'t obtain exclusive index lock');
  59         }
  60         return $lock;
  61     }
  62
  63     /**
  64      * Release exclusive write lock
  65      *
  66      * @param Zend_Search_Lucene_Storage_Directory $lockDirectory
  67      */
  68     public static function releaseWriteLock(Zend_Search_Lucene_Storage_Directory $lockDirectory)
  69     {
  70         $lock = $lockDirectory->getFileObject(self::WRITE_LOCK_FILE);
  71         $lock->unlock();
  72     }
  73
  74     /**
  75      * Obtain shared read lock on the index
  76      *
  77      * It doesn't block other read or update processes, but prevent index from the premature cleaning-up
  78      *
  79      * @param Zend_Search_Lucene_Storage_Directory $defaultLockDirectory
  80      * @return Zend_Search_Lucene_Storage_File
  81      * @throws Zend_Search_Lucene_Exception
  82      */
  83     public static function obtainReadLock(Zend_Search_Lucene_Storage_Directory $lockDirectory)
  84     {
  85         $lock = $lockDirectory->createFile(self::READ_LOCK_FILE);
  86         if (!$lock->lock(LOCK_SH)) {
  87             throw new Zend_Search_Lucene_Exception('Can\'t obtain shared reading index lock');
  88         }
  89         return $lock;
  90     }
  91
  92     /**
  93      * Release shared read lock
  94      *
  95      * @param Zend_Search_Lucene_Storage_Directory $lockDirectory
  96      */
  97     public static function releaseReadLock(Zend_Search_Lucene_Storage_Directory $lockDirectory)
  98     {
  99         $lock = $lockDirectory->getFileObject(self::READ_LOCK_FILE);
 100         $lock->unlock();
 101     }
 102
 103     /**
 104      * Escalate Read lock to exclusive level
 105      *
 106      * @param Zend_Search_Lucene_Storage_Directory $lockDirectory
 107      * @return boolean
 108      */
 109     public static function escalateReadLock(Zend_Search_Lucene_Storage_Directory $lockDirectory)
 110     {
 111         $lock = $lockDirectory->getFileObject(self::READ_LOCK_FILE);
 112
 113         // Try to escalate read lock
 114         if (!$lock->lock(LOCK_EX, true)) {
 115             // Restore lock state
 116             $lock->lock(LOCK_SH);
 117             return false;
 118         }
 119         return true;
 120     }
 121
 122     /**
 123      * De-escalate Read lock to shared level
 124      *
 125      * @param Zend_Search_Lucene_Storage_Directory $lockDirectory
 126      */
 127     public static function deEscalateReadLock(Zend_Search_Lucene_Storage_Directory $lockDirectory)
 128     {
 129         $lock = $lockDirectory->getFileObject(self::READ_LOCK_FILE);
 130         $lock->lock(LOCK_SH);
 131     }
 132
 133     /**
 134      * Obtain exclusive optimization lock on the index
 135      *
 136      * Returns lock object on success and false otherwise (doesn't block execution)
 137      *
 138      * @param Zend_Search_Lucene_Storage_Directory $lockDirectory
 139      * @return mixed
 140      */
 141     public static function obtainOptimizationLock(Zend_Search_Lucene_Storage_Directory $lockDirectory)
 142     {
 143         $lock = $lockDirectory->createFile(self::OPTIMIZATION_LOCK_FILE);
 144         if (!$lock->lock(LOCK_EX, true)) {
 145             return false;
 146         }
 147         return $lock;
 148     }
 149
 150     /**
 151      * Release exclusive optimization lock
 152      *
 153      * @param Zend_Search_Lucene_Storage_Directory $lockDirectory
 154      */
 155     public static function releaseOptimizationLock(Zend_Search_Lucene_Storage_Directory $lockDirectory)
 156     {
 157         $lock = $lockDirectory->getFileObject(self::OPTIMIZATION_LOCK_FILE);
 158         $lock->unlock();
 159     }
 160
 161 }