1: <?php
  2: /*
  3:  You may not change or alter any portion of this comment or credits
  4:  of supporting developers from this source code or any supporting source code
  5:  which is considered copyrighted (c) material of the original comment or credit authors.
  6: 
  7:  This program is distributed in the hope that it will be useful,
  8:  but WITHOUT ANY WARRANTY; without even the implied warranty of
  9:  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 10: */
 11: 
 12: namespace Xoops\Core\Cache;
 13: 
 14: use Stash\Pool;
 15: use Stash\Interfaces\DriverInterface;
 16: use Xoops\Core\Cache\DriverList;
 17: use Xoops\Core\Cache\Access;
 18: use Xoops\Core\Yaml;
 19: 
 20: /**
 21:  * Provides a standardized cache access
 22:  *
 23:  * @category  Xoops\Core\Cache
 24:  * @package   CacheManager
 25:  * @author    Richard Griffith <richard@geekwright.com>
 26:  * @copyright 2015 The XOOPS Project https://github.com/XOOPS
 27:  * @license   GNU GPL 2 or later (http://www.gnu.org/licenses/gpl-2.0.html)
 28:  * @link      http://xoops.org
 29:  */
 30: class CacheManager
 31: {
 32:     /**
 33:      * Cache Access objects for pools
 34:      *
 35:      * @var Access[]
 36:      */
 37:     protected $pools = array();
 38: 
 39:     /**
 40:      * Pool definitions
 41:      *
 42:      * @var array
 43:      */
 44:     protected $poolDefs = array(
 45:         );
 46: 
 47:     /**
 48:      * Xoops instance
 49:      *
 50:      * @var \Xoops
 51:      */
 52:     protected $xoops;
 53: 
 54:     /**
 55:      * __construct
 56:      */
 57:     public function __construct()
 58:     {
 59:         $this->xoops = \Xoops::getInstance();
 60:         $defaults = $this->getDefaults();
 61:         $xoops_var_path = \XoopsBaseConfig::get('var-path');
 62:         $cache_file = $xoops_var_path . '/configs/cache.php';
 63:         $poolDefs = Yaml::readWrapped($cache_file);
 64:         if (empty($poolDefs)) {
 65:             Yaml::saveWrapped($defaults, $cache_file);
 66:         }
 67:         $poolDefs = is_array($poolDefs) ? $poolDefs : array();
 68:         $this->poolDefs = array_merge($defaults, $poolDefs);
 69:     }
 70: 
 71:     /**
 72:      * getDefaults get default cache configuration used if there is no config file
 73:      *
 74:      * @return array cache configuration
 75:      */
 76:     private static function getDefaults()
 77:     {
 78:         $defaults = array(
 79:             'default' => array(
 80:                 'driver' => 'FileSystem',
 81:                 'options' => array(
 82:                     'path' => \XoopsBaseConfig::get('var-path') . '/stash/',
 83:                     ),
 84:                     'dirSplit' => 1,
 85:                 ),
 86:             'temp' => array(
 87:                 'driver' => 'Ephemeral',
 88:                 'options' => array(),
 89:                 ),
 90:             );
 91:         return $defaults;
 92:     }
 93: 
 94:     /**
 95:      * Create a default configuration file, used in installation
 96:      *
 97:      * When using Windows NTFS, PHP has a maximum path length of 260 bytes. Each key level in a
 98:      * Stash hierarchical key corresponds to a directory, and is normalized as an md5 hash. Also,
 99:      * Stash uses 2 levels for its own integrity ad locking mechanisms. The full key length used
100:      * in XoopCore can reach 202 charachters.
101:      *
102:      * If the combined path length would excede 260, we will try and switch to SQLite driver if
103:      * it is available when running on a Windows system.
104:      *
105:      * @return void
106:      */
107:     public static function createDefaultConfig()
108:     {
109:         $configFile = \XoopsBaseConfig::get('var-path') . '/configs/cache.php';
110:         if (file_exists($configFile)) {
111:             return;
112:         }
113:         $defaults = self::getDefaults();
114:         if (false !== stripos(PHP_OS, 'WIN')) {
115:             $pathLen = strlen($defaults['default']['options']['path']);
116:             if (260 <= ($pathLen+202)) {
117:                 // try alternative driver as filesystem has max path length issues on Windows
118:                 if (array_key_exists("SQLite", \Stash\DriverList::getAvailableDrivers())) {
119:                     $defaults['default']['driver'] = 'SQLite';
120:                     unset($defaults['default']['options']['dirSplit']);
121:                     @mkdir($defaults['default']['options']['path']);
122:                 } else {
123:                     trigger_error("Manual cache configuration required.");
124:                 }
125:             }
126:         }
127:         Yaml::saveWrapped($defaults, $configFile);
128:     }
129: 
130:     /**
131:      * Get a cache corresponding to the specified name
132:      *
133:      * @param string $name Name of cache definition
134:      *
135:      * @return Access object
136:      */
137:     public function getCache($name)
138:     {
139:         $pool = false;
140:         if (array_key_exists($name, $this->pools)) {
141:             $pool =  $this->pools[$name];
142:         } elseif (array_key_exists($name, $this->poolDefs)) {
143:             $pool =  $this->startPoolAccess($name);
144:         }
145:         if ($pool === false) {
146:             $pool = $this->getDefaultPool($name);
147:         }
148: 
149:         $this->pools[$name] = $pool;
150: 
151:         return $pool;
152:     }
153: 
154:     /**
155:      * Instantiate an Access object from named configuration, including
156:      * instantiating pool and driver
157:      *
158:      * @param string $name name of pool configuration to start
159:      *
160:      * @return Access|false pool or false if a pool cannot be created
161:      */
162:     protected function startPoolAccess($name)
163:     {
164:         $pool = false;
165:         $options = false;
166:         if (isset($this->poolDefs[$name]['options'])) {
167:             $options = $this->poolDefs[$name]['options'];
168:         }
169:         $driverName = $this->poolDefs[$name]['driver'];
170:         if (0 === strcasecmp($driverName, 'Composite')) {
171:             $drivers = array();
172:             foreach ($this->poolDefs[$name]['options']['drivers'] as $subDriver) {
173:                 $drivers[] = $this->getDriver($subDriver['driver'], $subDriver['options']);
174:             }
175:             $options['drivers'] = $drivers;
176:         }
177: 
178:         $driver = $this->getDriver($driverName, $options);
179:         if ($driver!==false) {
180:             $pool = new Pool($driver);
181:             if (is_object($pool)) {
182:                 $pool->setLogger($this->xoops->logger());
183:                 $pool->setNamespace($this->xoops->db()->prefix());
184:             }
185:         }
186:         if (!$pool) {
187:             $this->xoops->logger()->warn('Could not create cache pool '.$name);
188:             return $pool;
189:         }
190: 
191:         return new Access($pool);
192:     }
193: 
194:     /**
195:      * getDriver
196:      *
197:      * @param string $driverName short name of the driver
198:      * @param array  $options    array of options for the driver
199:      *
200:      * @return DriverInterface|false driver object or false if it could not be instantiated
201:      */
202:     protected function getDriver($driverName, $options)
203:     {
204:         $driver = false;
205:         $driverClass = DriverList::getDriverClass($driverName);
206: 
207:         if ($driverClass!==false && $driverClass::isAvailable()) {
208:             $options = is_array($options) ? $options : array();
209:             $driver = new $driverClass();
210:             $driver->setOptions($options);
211:         }
212:         return ($driver instanceof DriverInterface) ? $driver : false;
213:     }
214: 
215:     /**
216:      * Get an Access object based on the default pool. If it isn't set, create it.
217:      * If no definition exists for default, use Stash default (Ephimeral.)
218:      *
219:      * @param string $originalName originally requested pool configuration name
220:      *
221:      * @return Access object
222:      */
223:     protected function getDefaultPool($originalName)
224:     {
225:         $this->xoops->events()->triggerEvent('debug.log', 'Substituting default cache pool for '.$originalName);
226:         $name = 'default';
227:         if (array_key_exists($name, $this->pools)) {
228:             return $this->pools[$name];
229:         }
230:         $pool = $this->startPoolAccess($name);
231:         if ($pool===false) {
232:             $this->xoops->logger()->error('Could not create default cache pool');
233:             $pool = new Access(new \Stash\Pool());
234:         }
235:         $this->pools[$name] = $pool;
236:         return $pool;
237:     }
238: }
239: