__construct() public method

Class constructor
public __construct ( $dsn = FALSE ) : object
$dsn bool|string
return object
Example #1
0
 /**
  * Check for existence of the wincache extension This method cannot be invoked externally. The driver must
  * be instantiated using the `Cache::instance()` method.
  *
  * @param  array     configuration
  * @throws Kohana_Cache_Exception
  */
 protected function __construct(array $config)
 {
     if (!extension_loaded('wincache')) {
         throw new Kohana_Cache_Exception('PHP wincache extension is not available.');
     }
     parent::__construct($config);
 }
Example #2
0
 /**
  * Sets up the PDO SQLite table and
  * initialises the PDO connection
  *
  * @param  array     configuration
  * @throws  Kohana_Cache_Exception
  */
 protected function __construct(array $config)
 {
     parent::__construct($config);
     $database = Arr::get($this->_config, 'database', NULL);
     if ($database === NULL) {
         throw new Kohana_Cache_Exception('Database path not available in Kohana Cache configuration');
     }
     // Load new Sqlite DB
     $this->_db = new PDO('sqlite:' . $database);
     // Test for existing DB
     $result = $this->_db->query("SELECT * FROM sqlite_master WHERE name = 'caches' AND type = 'table'")->fetchAll();
     // If there is no table, create a new one
     if (0 == count($result)) {
         $database_schema = Arr::get($this->_config, 'schema', NULL);
         if ($database_schema === NULL) {
             throw new Kohana_Cache_Exception('Database schema not found in Kohana Cache configuration');
         }
         try {
             // Create the caches table
             $this->_db->query(Arr::get($this->_config, 'schema', NULL));
         } catch (PDOException $e) {
             throw new Kohana_Cache_Exception('Failed to create new SQLite caches table with the following error : :error', array(':error' => $e->getMessage()));
         }
     }
 }
Example #3
0
 /**
  * Responsiblity of the constructor is crucial.
  * 1.Get the cache file path.
  * 2.Create the cache file if it doesn't exists.
  * 3.Get the area data if the file exists.
  */
 public function __construct()
 {
     parent::__construct();
     $this->areaService = new AreaService();
     $this->filepath = parent::$path . '/' . self::$filename;
     if (!file_exists($this->filepath)) {
         $this->provinces = $this->areaService->getProvincesWithoutDirect();
         $this->provincesWithSub = $this->areaService->getProvincesWithoutDirect();
         $this->areaService->fillSubareas($this->provincesWithSub);
         $this->cities = $this->areaService->getCitiesIncludeDirect();
         $this->provinces_json = json_encode($this->provinces);
         $this->provincesWithSub_json = json_encode($this->provincesWithSub);
         $this->cities_json = json_encode($this->cities);
         $this->writeIntoFile($this->provinces_json, $this->provincesWithSub_json, $this->cities_json);
     } else {
         $areaCacheFile = fopen($this->filepath, 'r') or die('File: ' . $this->filepath . ' open failed!');
         $this->provinces_json = fgets($areaCacheFile);
         $this->provincesWithSub_json = fgets($areaCacheFile);
         $this->cities_json = fgets($areaCacheFile);
         fclose($areaCacheFile);
         $this->provinces = json_decode($this->provinces_json);
         $this->provincesWithSub = json_decode($this->provincesWithSub_json);
         $this->cities = json_decode($this->cities_json);
     }
 }
Example #4
0
 /**
  * Check for existence of the APC extension This method cannot be invoked externally. The driver must
  * be instantiated using the `Cache::instance()` method.
  * @param  array $config configuration
  * @throws Cache_Exception
  */
 protected function __construct(array $config)
 {
     if (!extension_loaded('apc')) {
         throw new Cache_Exception('PHP APC extension is not available.');
     }
     parent::__construct($config);
 }
Example #5
0
 public function __construct($prefix = '')
 {
     parent::__construct($prefix);
     if (is_null(self::$cache)) {
         // TODO allow configuring a RedisArray, see https://github.com/nicolasff/phpredis/blob/master/arrays.markdown#redis-arrays
         self::$cache = new \Redis();
         $config = \OC::$server->getSystemConfig()->getValue('redis', array());
         if (isset($config['host'])) {
             $host = $config['host'];
         } else {
             $host = '127.0.0.1';
         }
         if (isset($config['port'])) {
             $port = $config['port'];
         } else {
             $port = 6379;
         }
         if (isset($config['timeout'])) {
             $timeout = $config['timeout'];
         } else {
             $timeout = 0.0;
             // unlimited
         }
         self::$cache->connect($host, $port, $timeout);
     }
 }
Example #6
0
 /**
  * Constructs the file cache driver. This method cannot be invoked externally. The file cache driver must
  * be instantiated using the `Cache::instance()` method.
  *
  * @param   array    config 
  * @throws  Cache_Exception
  */
 protected function __construct(array $config)
 {
     // Setup parent
     parent::__construct($config);
     try {
         $directory = Arr::get($this->_config, 'cache_dir', Kohana::$cache_dir);
         $this->_cache_dir = new SplFileInfo($directory);
     } catch (ErrorException $e) {
         $this->_cache_dir = $this->_make_directory($directory, 0777, TRUE);
     } catch (UnexpectedValueException $e) {
         $this->_cache_dir = $this->_make_directory($directory, 0777, TRUE);
     }
     // If the defined directory is a file, get outta here
     if ($this->_cache_dir->isFile()) {
         throw new Cache_Exception('Unable to create cache directory as a file already exists : :resource', array(':resource' => $this->_cache_dir->getRealPath()));
     }
     // Check the read status of the directory
     if (!$this->_cache_dir->isReadable()) {
         throw new Cache_Exception('Unable to read from the cache directory :resource', array(':resource' => $this->_cache_dir->getRealPath()));
     }
     // Check the write status of the directory
     if (!$this->_cache_dir->isWritable()) {
         throw new Cache_Exception('Unable to write to the cache directory :resource', array(':resource' => $this->_cache_dir->getRealPath()));
     }
 }
Example #7
0
 /**
  * Check for existence of the APC extension
  *
  * @throws  Kohana_Cache_Exception
  */
 protected function __construct()
 {
     parent::__construct();
     if (!extension_loaded('apc')) {
         throw new Kohana_Cache_Exception('PHP APC extension is not available.');
     }
 }
 /**
  * Check for existence of the eAccelerator extension
  *
  * @param  array     configuration
  * @throws Kohana_Cache_Exception
  */
 protected function __construct(array $config)
 {
     if (!extension_loaded('eaccelerator')) {
         throw new Kohana_Cache_Exception('PHP eAccelerator extension is not available.');
     }
     parent::__construct($config);
 }
Example #9
0
 /**
  * Check for existence of the APC extension
  *
  * [!!] This method cannot be invoked externally
  *
  * The driver must be instantiated using the `Cache::instance()` method.
  *
  * @param  array  $config  configuration
  *
  * @throws Cache_Exception
  */
 protected function __construct(array $config)
 {
     if (!function_exists('apc_store') or !ini_get('apc.enabled')) {
         throw new Cache_Exception('You must have PHP APC installed and enabled to use.');
     }
     parent::__construct($config);
 }
Example #10
0
 /**
  * Constructs the file cache driver. This method cannot be invoked externally. The file cache driver must
  * be instantiated using the `Cache::instance()` method.
  *
  * @param   array    config 
  * @throws  Kohana_Cache_Exception
  */
 protected function __construct(array $config)
 {
     // Setup parent
     parent::__construct($config);
     try {
         $directory = Arr::get($this->_config, 'cache_dir', APPPATH . Cache_File::CACHE_DIR);
         $this->_cache_dir = new RecursiveDirectoryIterator($directory);
     } catch (UnexpectedValueException $e) {
         if (!mkdir($directory, 0777, TRUE)) {
             throw new Kohana_Cache_Exception('Failed to create the defined cache directory : :directory', array(':directory' => $directory));
         }
         chmod($directory, 0777);
         $this->_cache_dir = new RecursiveDirectoryIterator($directory);
     }
     // If the defined directory is a file, get outta here
     if ($this->_cache_dir->isFile()) {
         throw new Kohana_Cache_Exception('Unable to create cache directory as a file already exists : :resource', array(':resource' => $this->_cache_dir->getRealPath()));
     }
     // Check the read status of the directory
     if (!$this->_cache_dir->isReadable()) {
         throw new Kohana_Cache_Exception('Unable to read from the cache directory :resource', array(':resource' => $this->_cache_dir->getRealPath()));
     }
     // Check the write status of the directory
     if (!$this->_cache_dir->isWritable()) {
         throw new Kohana_Cache_Exception('Unable to write to the cache directory :resource', array(':resource' => $this->_cache_dir->getRealPath()));
     }
 }
Example #11
0
 public function __construct($options = array())
 {
     parent::__construct($options);
     $this->file = $this->optionable[self::PARAM_DIRECTORY] . self::KEY_PREFIX;
     $this->fileTtl = $this->optionable[self::PARAM_DIRECTORY] . self::TTL_PREFIX;
     $this->directory = $this->optionable[self::PARAM_DIRECTORY];
     //        $this->throwDbException();
 }
Example #12
0
 public function __construct($config)
 {
     parent::__construct($config);
     $servers = $this->_config['servers'];
     $server = array_shift($servers);
     $this->_redis = new Redis();
     $this->_redis->connect($server['host'], $server['port']);
 }
Example #13
0
 /**
  * Constructs the memcached object
  *
  * @param   array     configuration
  * @throws  Kohana_Cache_Exception
  */
 public function __construct(array $config)
 {
     // Check that memcached is loaded
     if (!extension_loaded('memcached')) {
         throw new Kohana_Cache_Exception('Memcached extension is not loaded');
     }
     parent::__construct($config);
     // Check whether this is a persistent connection
     if ($config['persistent'] == FALSE) {
         // Setup a non-persistent memcached connection
         $this->_memcached = new Memcached();
     } else {
         // Setup a persistent memcached connection
         $this->_memcached = new Memcached($this->_config['persistent_id']);
     }
     // Load servers from configuration
     $servers = Arr::get($this->_config, 'servers', NULL);
     if (!$servers) {
         // Throw exception if no servers found in configuration
         throw new Kohana_Cache_Exception('No Memcache servers defined in configuration');
     }
     // Add memcache servers
     foreach ($servers as $server) {
         if (!$this->_memcached->addServer($server['host'], $server['port'], $server['weight'])) {
             throw new Kohana_Cache_Exception('Could not connect to memcache host at \':host\' using port \':port\'', array(':host' => $server['host'], ':port' => $server['port']));
         }
     }
     // Load memcached options from configuration
     $options = Arr::get($this->_config, 'options', NULL);
     // Make sure there are options to set
     if ($options != NULL) {
         // Set the options
         foreach ($options as $key => $value) {
             // Special cases for a few options
             switch ($key) {
                 case 'serializer':
                     $value = $this->_serializer_map[$value];
                     break;
                 case 'hash':
                     $value = $this->_hash_map[$value];
                     break;
                 case 'distribution':
                     $value = $this->_distribution_map[$value];
                     break;
                 case 'prefix_key':
                     // Throw exception is key prefix is greater than 128 characters
                     if (strlen($value) > 128) {
                         throw new Kohana_Cache_Exception('Memcached prefix key cannot exceed 128 characters');
                     }
                     break;
                 default:
                     break;
             }
             $this->_memcached->setOption($this->_options_map[$key], $value);
         }
     }
 }
Example #14
0
 public function __construct($prefix = '')
 {
     parent::__construct($prefix);
     if (is_null(self::$cache)) {
         self::$cache = new \Memcached();
         list($host, $port) = \OC_Config::getValue('memcached_server', array('localhost', 11211));
         self::$cache->addServer($host, $port);
     }
 }
Example #15
0
 /**
  * Constructs the redis Kohana_Cache object
  *
  * @param   array     configuration
  * @throws  Kohana_Cache_Exception
  */
 public function __construct(array $config)
 {
     // Check for the Rediska module
     if (!class_exists('Rediska')) {
         throw new Kohana_Cache_Exception('Rediska module not loaded');
     }
     parent::__construct($config);
     $instance = Arr::get($this->_config, 'instance', Rediska::DEFAULT_NAME);
     $this->_rediska = Rediska_Manager::get($instance);
 }
Example #16
0
 public function __construct()
 {
     parent::__construct();
     $this->filepath = parent::$path . '/' . self::$filename;
     if (!file_exists($this->filepath)) {
         $this->huge_pics = $this->createDefaultCache($this->filepath);
     } else {
         $this->huge_pics = $this->readCacheFile();
     }
 }
Example #17
0
 function __construct($bin)
 {
     global $conf;
     // Assign the path on the following order: bin specific -> default specific -> /tmp/filepath
     $this->fspath = $conf['cacherouter'][$bin]['path'];
     if (!isset($conf['cacherouter'][$bin]['path'])) {
         if (isset($conf['cacherouter']['default']['path'])) {
             $this->fspath = $conf['cacherouter']['default']['path'];
         }
     }
     parent::__construct($bin);
 }
Example #18
0
 /**
  * Sets up the MongoDB table and
  * initialises the MongoDB connection
  *
  * @param  array  $config  configuration
  * @throws  Cache_Exception
  */
 protected function __construct(array $config)
 {
     parent::__construct($config);
     $database = Arr::get($this->_config, 'database', NULL);
     if ($database === NULL) {
         throw new Cache_Exception('Database path not available in Kohana Cache configuration');
     }
     $this->_client = new MongoClient('mongodb://' . $this->_config['host'] . ':' . $this->_config['port']);
     $this->_database = $this->_client->{$database};
     $this->_collection = $this->_database->{$this->_config['collection']};
     $this->_collection->ensureIndex(array('tags' => 1));
     $this->_collection->ensureIndex(array('lifetime' => 1));
 }
Example #19
0
 function __construct($bin, $options, $default_options)
 {
     // Assign the path on the following order: bin specific -> default specific -> /tmp/filepath
     if (isset($options['path'])) {
         $this->fspath = $options['path'];
     } elseif (isset($default_options['path'])) {
         $this->fspath = $default_options['path'];
     }
     if (substr($this->fspath, -1) == '/') {
         $this->fspath = substr($this->fspath, 0, strlen($this->fspath) - 2);
     }
     parent::__construct($bin, $options, $default_options);
 }
Example #20
0
 protected function __construct(array $config)
 {
     parent::__construct($config);
     $this->_memcache = new Memcache();
     $servers = $this->_config['servers'];
     $config = array('host' => 'localhost', 'port' => 11211, 'persistent' => FALSE, 'weight' => 1, 'timeout' => 1, 'retry_interval' => 15, 'status' => TRUE, 'failure_callback' => NULL);
     foreach ($servers as $server) {
         $server += $config;
         if (!$this->_memcache->addServer($server['host'], $server['port'], $server['persistent'], $server['weight'], $server['timeout'], $server['retry_interval'], $server['status'], $server['failure_callback'])) {
             throw new Kohana_Exception('Memcache could not connect to host \':host\' using port \':port\'', array(':host' => $server['host'], ':port' => $server['port']));
         }
     }
     $this->_flags = Arr::get($this->_config, 'compression', FALSE) ? MEMCACHE_COMPRESSED : FALSE;
 }
Example #21
0
 /** Constructor that sets up the DiskCache.
  *
  * @param	string	$directory	The directory to use. (Optional)
  * @access	public
  */
 public function __construct($directory = null)
 {
     parent::__construct();
     if ($directory != null) {
         $this->directory = $directory;
     } else {
         $this->directory = sys_get_temp_dir() . '/lastfm.cache';
     }
     if (!file_exists($this->directory)) {
         @mkdir($this->directory);
     }
     if (!is_dir($this->directory)) {
         $this->directory = dirname($this->directory);
     }
 }
Example #22
0
 /**
  * Check for existence of the PhpRedis extension
  *
  * [!!] This method cannot be invoked externally
  *
  * The driver must be instantiated using the `Cache::instance()` method.
  *
  * @param  array  $config  configuration
  *
  * @throws Cache_Exception
  */
 protected function __construct(array $config)
 {
     // Check that the PhpRedis extension is loaded.
     if (!extension_loaded('redis')) {
         throw new Cache_Exception('You must have PhpRedis installed and enabled to use.');
     }
     // Define a default settings array.
     $default_settings = array('host' => 'localhost', 'port' => 6379);
     // Merge the default settings with the user-defined settings.
     $this->config(Arr::merge($default_settings, $config));
     // Create a new Redis instance and start a connection using the settings provided.
     $this->_redis = new Redis();
     $this->_redis->connect($this->config('host'), $this->config('port'));
     parent::__construct($config);
 }
Example #23
0
 /**
  * Constructs the redis Kohana_Cache object
  *
  * @param   array     configuration
  * @throws  Kohana_Cache_Exception
  */
 protected function __construct(array $config)
 {
     if (!extension_loaded('redis')) {
         throw new Cache_Exception('PHP redis extension is not available.');
     }
     parent::__construct($config);
     $host = isset($config['host']) ? $config['host'] : $this->_default_config['host'];
     $port = isset($config['port']) ? $config['port'] : $this->_default_config['port'];
     $this->_redis = new Redis();
     $this->_redis->connect($host, $port, 1);
     if (@$config['igbinary_serialize'] === true) {
         $this->_redis->setOption(Redis::OPT_SERIALIZER, Redis::SERIALIZER_IGBINARY);
     }
     $db_num = isset($config['db_num']) ? $config['db_num'] : $this->_default_config['db_num'];
     $this->_redis->select($db_num);
 }
Example #24
0
 /**
  * Sets up the PDO SQLite table and
  * initialises the PDO connection
  *
  * @throws  Kohana_Cache_Exception
  */
 protected function __construct()
 {
     parent::__construct();
     $this->_db = new PDO('sqlite:' . Kohana::config('cache.sqlite.database'));
     // Test for existing DB
     $result = $this->_db->query("SELECT * FROM sqlite_master WHERE name = 'caches' AND type = 'table'")->fetchAll();
     // If there is no table, create a new one
     if (0 == count($result)) {
         try {
             // Create the caches table
             $this->_db->query(Kohana::config('cache.sqlite.schema'));
         } catch (PDOException $e) {
             throw new Kohana_Cache_Exception('Failed to create new SQLite caches table with the following error : :error', array(':error' => $e->getMessage()));
         }
     }
 }
Example #25
0
 function __construct($bin)
 {
     global $conf;
     // Assign the servers on the following order: bin specific -> default specific -> localhost port 11211
     $this->settings['servers'] = $conf['cacherouter'][$this->name]['server'];
     if (!isset($conf['cacherouter'][$this->name]['server'])) {
         if (isset($conf['cacherouter']['default']['server'])) {
             $this->settings['servers'] = $conf['cacherouter']['default']['server'];
         } else {
             $this->settings['servers'] = array('localhost:11211');
         }
     }
     $this->settings['compress'] = isset($conf['cacherouter'][$this->name]['compress']) ? MEMCACHE_COMPRESSED : 0;
     $this->settings['shared'] = isset($conf['cacherouter'][$this->name]['shared']) ? $conf['cacherouter'][$this->name]['shared'] : TRUE;
     parent::__construct($bin);
     $this->connect();
 }
Example #26
0
 public function __construct($prefix = '')
 {
     parent::__construct($prefix);
     if (is_null(self::$cache)) {
         self::$cache = new \Memcached();
         $servers = \OC_Config::getValue('memcached_servers');
         if (!$servers) {
             $server = \OC_Config::getValue('memcached_server');
             if ($server) {
                 $servers = array($server);
             } else {
                 $servers = array(array('localhost', 11211));
             }
         }
         self::$cache->addServers($servers);
     }
 }
Example #27
0
 protected function __construct(array $config)
 {
     if (!extension_loaded('memcached')) {
         // exception missing memcached extension
         throw new Kohana_Cache_Exception('memcached extension is not loaded');
     }
     parent::__construct($config);
     $this->memcached_instance = new Memcached();
     // load servers from configuration
     $servers = Arr::get($this->_config, 'servers', array());
     if (empty($servers)) {
         // exception no server found
         throw new Kohana_Cache_Exception('no Memcached servers in config/cache.php');
     }
     // load options from configuration
     $options = Arr::get($this->_config, 'options', array());
     // set options
     foreach ($options as $option => $value) {
         if ($option === Memcached::OPT_SERIALIZER && $value === Memcached::SERIALIZER_IGBINARY && !Memcached::HAVE_IGBINARY) {
             // exception serializer Igbinary not supported
             throw new Kohana_Cache_Exception('serializer Igbinary not supported, please fix config/cache.php');
         }
         if ($option === Memcached::OPT_SERIALIZER && $value === Memcached::SERIALIZER_JSON && !Memcached::HAVE_JSON) {
             // exception serializer JSON not supported
             throw new Kohana_Cache_Exception('serializer JSON not supported, please fix config/cache.php');
         }
         $this->memcached_instance->setOption($option, $value);
     }
     // add servers
     foreach ($servers as $pos => $server) {
         $host = Arr::get($server, 'host');
         $port = Arr::get($server, 'port', NULL);
         $weight = Arr::get($server, 'weight', NULL);
         $status = Arr::get($server, 'status', TRUE);
         if (!empty($host)) {
             // status can be used by an external healthcheck to mark the memcached instance offline
             if ($status === TRUE) {
                 $this->memcached_instance->addServer($host, $port, $weight);
             }
         } else {
             // exception no server host
             throw new Kohana_Cache_Exception('no host defined for server[' . $pos . '] in config/cache.php');
         }
     }
 }
Example #28
0
 /**
  * Constructor.
  *
  * @param   mixed  $options  An options array, or an object that implements \ArrayAccess
  *
  * @since   1.0
  * @throws  \RuntimeException
  */
 public function __construct($options = array())
 {
     if (!extension_loaded('memcached') || !class_exists('Memcached')) {
         throw new \RuntimeException('Memcached not supported.');
     }
     // Parent sets up the caching options and checks their type
     parent::__construct($options);
     // These options must be set to something, so if not set make them false
     if (!isset($this->options['memcache.pool'])) {
         $this->options['memcache.pool'] = false;
     }
     if (!isset($this->options['memcache.compress'])) {
         $this->options['memcache.compress'] = false;
     }
     if (!isset($this->options['memcache.servers'])) {
         $this->options['memcache.servers'] = false;
     }
 }
Example #29
0
File: File.php Project: jasny/Q
 /**
  * Class constructor
  * 
  * @param $options  Configuration options
  */
 public function __construct($options = array())
 {
     if (empty($options['path'])) {
         if (!empty($options['cachedir'])) {
             $options['path'] = $options['cachedir'];
         } elseif (!empty($options[0])) {
             $options['path'] = $options[0];
         } else {
             $options['path'] = (function_exists('sys_get_temp_dir') ? sys_get_temp_dir() : '/tmp') . '/cache.' . $this->options['key'];
         }
     }
     $options['path'] = preg_replace('/\\{\\$(.*?)\\}/e', "isset(\$_SERVER['\$1']) ? \$_SERVER['\$1'] : \$_ENV['\$1']", $options['path']);
     if (!is_dir($options['path']) && (file_exists($options['path']) || !mkdir($options['path'], 0770, true))) {
         throw new Exception("Unable to create Cache of type 'file'. Directory '{$this->options['cachedir']}' does not exists and could not be created.");
     }
     parent::__construct($options);
     if ($this->options['gc_probability'] >= 1 || mt_rand(1, 1 / $this->options['gc_probability']) == 1) {
         $this->clean();
     }
 }
Example #30
0
 function __construct($bin, $options, $default_options)
 {
     // Assign the servers on the following order: bin specific -> default specific -> localhost port 11211
     if (isset($options['servers'])) {
         $this->settings['servers'] = $options['servers'];
         $this->settings['compress'] = isset($options['compress']) ? memcached_COMPRESSED : 0;
         $this->settings['shared'] = isset($options['shared']) ? $options['shared'] : TRUE;
     } else {
         if (isset($default_options['servers'])) {
             $this->settings['servers'] = $default_options['servers'];
             $this->settings['compress'] = isset($default_options['compress']) ? memcached_COMPRESSED : 0;
             $this->settings['shared'] = isset($default_options['shared']) ? $default_options['shared'] : TRUE;
         } else {
             $this->settings['servers'] = array('localhost:11211');
             $this->settings['compress'] = 0;
             $this->settings['shared'] = TRUE;
         }
     }
     parent::__construct($bin, $options, $default_options);
     $this->connect();
 }