PHP Kurogo::getCache方法代码示例

 function __construct($device = null)
 {
     $this->version = intval(Kurogo::getSiteVar('MOBI_SERVICE_VERSION'));
     $this->userAgent = isset($_SERVER['HTTP_USER_AGENT']) ? $_SERVER['HTTP_USER_AGENT'] : '';
     if ($device && strlen($device)) {
         Kurogo::log(LOG_DEBUG, "Setting device to {$device} (override)", "deviceDetection");
         $this->setDevice($device);
         // user override of device detection
     } elseif (isset($_COOKIE[$this->cookieKey()])) {
         Kurogo::log(LOG_DEBUG, "Setting device to " . $_COOKIE[$this->cookieKey()] . " (cookie)", "deviceDetection");
         $this->setDevice($_COOKIE[$this->cookieKey()]);
     } elseif (isset($_SERVER['HTTP_USER_AGENT'])) {
         if ($cache = Kurogo::getCache($this->cacheKey($this->userAgent))) {
             $this->setDevice($cache);
             return $cache;
         }
         if ($data = Kurogo::getSiteVar('MOBI_SERVICE_USE_EXTERNAL') ? $this->detectDeviceExternal($this->userAgent) : $this->detectDeviceInternal($this->userAgent)) {
             if ($data['pagetype'] == 'tablet' && !Kurogo::getOptionalSiteVar('TABLET_ENABLED', 1)) {
                 $data['pagetype'] = 'compliant';
                 if ($data['platform'] == 'ipad') {
                     $data['platform'] = 'iphone';
                     // currently not used but just in case
                 }
             }
             $this->pagetype = $data['pagetype'];
             $this->platform = $data['platform'];
             $this->certs = $data['supports_certificate'];
             Kurogo::log(LOG_DEBUG, "Setting device to " . $this->getDevice(), "deviceDetection");
             $this->setDeviceCookie();
             Kurogo::setCache($this->cacheKey($this->userAgent), $this->getDevice());
         }
     }
 }

 protected function getConfig($area, $type, $opts = 0)
 {
     if ($type instanceof Module) {
         $key = $type->getConfigModule() . '-' . $area;
     } else {
         $key = $type . '-' . $area;
     }
     if (!isset($this->configs[$key])) {
         if ($config = Kurogo::getCache("config-" . $key)) {
             $this->configs[$key] = $config;
         } else {
             Kurogo::log(LOG_INFO, "Loading config {$key}", 'config');
             $this->configs[$key] = $this->loadConfig($area, $type, $opts);
             Kurogo::setCache("config-" . $key, $this->configs[$key]);
         }
     }
     return $this->configs[$key];
 }

 protected function loadFile($_file)
 {
     if (empty($_file)) {
         return false;
     }
     $cacheKey = 'configfile-' . md5($_file);
     if ($cache = Kurogo::getCache($cacheKey)) {
         // a little sanity in case we update the structure
         if (isset($cache['vars'], $cache['sectionVars'], $cache['file'])) {
             $this->addVars($cache['vars']);
             $this->addSectionVars($cache['sectionVars']);
             return $cache['file'];
         }
     }
     if (!($file = realpath_exists($_file))) {
         return false;
     }
     $vars = parse_ini_file($file, false);
     $this->addVars($vars);
     $sectionVars = parse_ini_file($file, true);
     $this->addSectionVars($sectionVars);
     Kurogo::setCache($cacheKey, array('vars' => $vars, 'sectionVars' => $sectionVars, 'file' => $file));
     Kurogo::log(LOG_DEBUG, "Loaded config file {$file}", 'config');
     return $file;
 }

 /**
  * Factory method. Used to instantiate a subclass
  * @param string $id, the module id to load
  * @param string $type, the type of module to load (web/api)
  */
 public static function factory($id, $type = null)
 {
     Kurogo::log(LOG_INFO, "Initializing {$type} module {$id}", 'module');
     $configModule = $id;
     //attempt to load config/$id/module.ini
     if ($config = ModuleConfigFile::factory($id, 'module', ModuleConfigFile::OPTION_DO_NOT_CREATE)) {
         //use the ID parameter if it's present, otherwise use the included id
         $id = $config->getOptionalVar('id', $id);
     } elseif (!Kurogo::getOptionalSiteVar('CREATE_DEFAULT_CONFIG', false, 'modules')) {
         Kurogo::log(LOG_ERR, "Module config file not found for module {$id}", 'module');
         throw new KurogoModuleNotFound(Kurogo::getLocalizedString('ERROR_MODULE_NOT_FOUND', $id));
     }
     // see if the class location has been cached
     if ($moduleFile = Kurogo::getCache(self::cacheKey($id, $type))) {
         $className = basename($moduleFile, '.php');
         include_once $moduleFile;
         $module = new $className();
         $module->setConfigModule($configModule);
         if ($config) {
             $module->setConfig('module', $config);
         }
         return $module;
     }
     // when run without a type it will find either
     $classNames = array('web' => ucfirst($id) . 'WebModule', 'api' => ucfirst($id) . 'APIModule');
     // if we specified a type, include only that type in the array
     if ($type) {
         if (isset($classNames[$type])) {
             $classNames = array($classNames[$type]);
         } else {
             throw new KurogoException("Invalid module type {$type}");
         }
     }
     // possible module paths.
     // 1. Site Folder SiteMODULEIDXXXModule
     // 2. Site Folder MODULEIDXXXModule
     // 3. Project folder MODULEIDXXXModule
     $modulePaths = array(SITE_MODULES_DIR . "/{$id}/Site%s.php" => "Site%s", SITE_MODULES_DIR . "/{$id}/%s.php" => "%s", MODULES_DIR . "/{$id}/%s.php" => "%s");
     //cycle module paths
     foreach ($modulePaths as $path => $className) {
         //cycle class names to find a valid module
         foreach ($classNames as $class) {
             $className = sprintf($className, $class);
             $path = sprintf($path, $class);
             Kurogo::log(LOG_DEBUG, "Looking for {$path} for {$id}", 'module');
             // see if it exists
             $moduleFile = realpath_exists($path);
             if ($moduleFile && (include_once $moduleFile)) {
                 //found it
                 $info = new ReflectionClass($className);
                 if (!$info->isAbstract()) {
                     Kurogo::log(LOG_INFO, "Found {$moduleFile} for {$id}", 'module');
                     $module = new $className();
                     $module->setConfigModule($configModule);
                     if ($config) {
                         $module->setConfig('module', $config);
                     }
                     // cache the location of the class (which also includes the classname)
                     Kurogo::setCache(self::cacheKey($id, $type), $moduleFile);
                     return $module;
                 }
                 Kurogo::log(LOG_NOTICE, "{$class} found at {$moduleFile} is abstract and cannot be used for {$id}", 'module');
                 return false;
             }
         }
     }
     Kurogo::log(LOG_ERR, "No valid class found for module {$id}", 'module');
     throw new KurogoModuleNotFound(Kurogo::getLocalizedString('ERROR_MODULE_NOT_FOUND', $id));
 }

 /**
  * Factory method. Used to instantiate a subclass
  * @param string $id, the module id to load
  * @param string $type, the type of module to load (web/api)
  */
 public static function factory($id, $type = null)
 {
     if ($id == 'kurogo') {
         set_exception_handler("exceptionHandlerForError");
     }
     if (!self::isValidModuleName($id)) {
         throw new KurogoException(Kurogo::getLocalizedString('ERROR_INVALID_MODULE'));
     }
     Kurogo::log(LOG_INFO, "Initializing {$type} module {$id}", 'module');
     $configModule = $id;
     $configStore = Kurogo::configStore();
     //attempt to load config/$id/module.ini
     if ($moduleData = $configStore->getOptionalSection('module', 'module', $configModule)) {
         $id = Kurogo::arrayVal($moduleData, 'id', $configModule);
     } else {
         throw new KurogoModuleNotFound(Kurogo::getLocalizedString('ERROR_MODULE_NOT_FOUND', $id));
     }
     // see if the class location has been cached
     if ($moduleFile = Kurogo::getCache(self::cacheKey($id, $type))) {
         $className = basename($moduleFile, '.php');
         include_once $moduleFile;
         $module = new $className();
         if (is_a($module, KurogoWebBridge::STUB_API_CLASS)) {
             $module->setID($id);
         }
         $module->setConfigModule($configModule);
         Kurogo::addModuleLib($id);
         return $module;
     }
     // when run without a type it will find either
     $classNames = array('web' => ucfirst($id) . 'WebModule', 'api' => ucfirst($id) . 'APIModule', 'shell' => ucfirst($id) . 'ShellModule');
     // if we specified a type, include only that type in the array
     if ($type) {
         if (isset($classNames[$type])) {
             $classNames = array($classNames[$type]);
         } else {
             throw new KurogoException("Invalid module type {$type}");
         }
     }
     // possible module paths.
     // 1. Site Folder SiteMODULEIDXXXModule
     // 2. Site Folder MODULEIDXXXModule
     // 3. Project folder MODULEIDXXXModule
     // Note: The PHP class name MUST be the basename of the file path.
     $modulePaths = array(SITE_MODULES_DIR . "/{$id}/Site%s.php", SITE_MODULES_DIR . "/{$id}/%s.php", SHARED_MODULES_DIR . "/{$id}/Site%s.php", SHARED_MODULES_DIR . "/{$id}/%s.php", MODULES_DIR . "/{$id}/%s.php");
     if ($type == 'api' && KurogoWebBridge::moduleHasMediaAssets($configModule)) {
         $modulePaths[] = LIB_DIR . '/' . KurogoWebBridge::STUB_API_CLASS . ".php";
     }
     //cycle module paths
     foreach ($modulePaths as $path) {
         $className = basename($path, '.php');
         //cycle class names to find a valid module
         foreach ($classNames as $class) {
             $className = sprintf($className, $class);
             $path = sprintf($path, $class);
             Kurogo::log(LOG_DEBUG, "Looking for {$path} for {$id}", 'module');
             // see if it exists
             $moduleFile = realpath_exists($path);
             if ($moduleFile && (include_once $moduleFile)) {
                 //found it
                 $info = new ReflectionClass($className);
                 if (!$info->isAbstract()) {
                     Kurogo::log(LOG_INFO, "Found {$moduleFile} for {$id}", 'module');
                     $module = new $className();
                     if (is_a($module, KurogoWebBridge::STUB_API_CLASS)) {
                         $module->setID($id);
                     }
                     $module->setConfigModule($configModule);
                     // cache the location of the class (which also includes the classname)
                     Kurogo::setCache(self::cacheKey($id, $type), $moduleFile);
                     Kurogo::addModuleLib($id);
                     return $module;
                 }
                 Kurogo::log(LOG_NOTICE, "{$class} found at {$moduleFile} is abstract and cannot be used for {$id}", 'module');
                 return false;
             }
         }
     }
     Kurogo::log(LOG_NOTICE, "No valid {$type} class found for module {$id}", 'module');
     throw new KurogoModuleNotFound(Kurogo::getLocalizedString('ERROR_MODULE_NOT_FOUND', $id));
 }

 public function checkCurrentVersion()
 {
     if ($currentVersion = Kurogo::getCache('currentVersion')) {
         return $currentVersion;
     } elseif (!Kurogo::getOptionalSiteVar('KUROGO_VERSION_CHECK', 1)) {
         return null;
     }
     try {
         $cache = new DiskCache(CACHE_DIR . DIRECTORY_SEPARATOR . '/kurogo', 3600, TRUE);
     } catch (KurogoDataException $e) {
         $cache = null;
     }
     $cacheFilename = 'currentVersion';
     if ($cache && $cache->isFresh($cacheFilename)) {
         $currentVersion = $cache->read($cacheFilename);
     } else {
         $url = "http://kurogo.org/checkversion.php?" . http_build_query(array('version' => KUROGO_VERSION, 'base' => FULL_URL_BASE, 'site' => SITE_KEY, 'php' => phpversion(), 'uname' => php_uname("a")));
         $context = stream_context_create(array('http' => array('timeout' => 5, 'user_agent' => self::KurogoUserAgent())));
         if ($currentVersion = trim(@file_get_contents($url, false, $context))) {
             if ($cache) {
                 $cache->write($currentVersion, $cacheFilename);
             }
         }
     }
     if ($currentVersion) {
         Kurogo::setCache('currentVersion', $currentVersion);
     }
     return $currentVersion;
 }

 protected function detectDevice($userAgent)
 {
     $classification = $this->unknownClassification();
     if ($cachedClassificationString = Kurogo::getCache($this->cacheKey($userAgent))) {
         // Kurogo cache has device string
         $classification = $this->classificationForString($cachedClassificationString);
     } else {
         if ($data = Kurogo::getSiteVar('MOBI_SERVICE_USE_EXTERNAL') ? $this->detectDeviceExternal($userAgent) : $this->detectDeviceInternal($userAgent)) {
             // Looked up device data with configured device detection method
             $classification['pagetype'] = $data['pagetype'];
             $classification['platform'] = $data['platform'];
             Kurogo::setCache($this->cacheKey($userAgent), $this->stringForClassification($classification));
         }
     }
     return $classification;
 }

 public static function getAvailableMediaInfoForModule($id)
 {
     $cacheKey = "webbridge-mediainfo-{$id}";
     // use memory cache to make this more efficient
     $info = Kurogo::getCache($cacheKey);
     if ($info === false) {
         $files = array_merge((array) glob(WEB_BRIDGE_DIR . "/*/{$id}.zip"), (array) glob(WEB_BRIDGE_DIR . "/*/{$id}-tablet.zip"));
         $info = array();
         foreach ($files as $file) {
             $name = basename($file, '.zip');
             $dir = realpath(dirname($file));
             $parts = explode(DIRECTORY_SEPARATOR, $dir);
             if (!$parts) {
                 continue;
             }
             $platform = end($parts);
             if (!$platform) {
                 continue;
             }
             $key = $platform;
             if ($name == "{$id}-tablet") {
                 $key .= "-tablet";
             }
             $file = realpath_exists($file);
             if (!$file) {
                 continue;
             }
             $info[$key] = array('url' => FULL_URL_PREFIX . "media/web_bridge/{$platform}/{$name}.zip", 'file' => $file, 'mtime' => filemtime($file), 'md5' => md5_file($file));
         }
         Kurogo::setCache($cacheKey, $info);
     }
     return $info ? $info : array();
 }

 private function initSite(&$path)
 {
     includePackage('Cache');
     includePackage('Config');
     $siteConfig = new ConfigGroup();
     $saveCache = true;
     // Load main configuration file
     $kurogoConfig = ConfigFile::factory('kurogo', 'project', ConfigFile::OPTION_IGNORE_MODE | ConfigFile::OPTION_IGNORE_LOCAL);
     $siteConfig->addConfig($kurogoConfig);
     define('CONFIG_MODE', $siteConfig->getVar('CONFIG_MODE', 'kurogo'));
     Kurogo::log(LOG_DEBUG, "Setting config mode to " . (CONFIG_MODE ? CONFIG_MODE : '<empty>'), 'config');
     define('CONFIG_IGNORE_LOCAL', $siteConfig->getVar('CONFIG_IGNORE_LOCAL', 'kurogo'));
     if ($cacheClass = $siteConfig->getOptionalVar('CACHE_CLASS', '', 'cache')) {
         $this->cacher = KurogoMemoryCache::factory($cacheClass, $siteConfig->getOptionalSection('cache'));
     }
     //multi site currently only works with a url base of root "/"
     if ($siteConfig->getOptionalVar('MULTI_SITE', false, 'kurogo')) {
         // in scripts you can pass the site name to Kurogo::initialize()
         if (PHP_SAPI == 'cli') {
             $site = strlen($path) > 0 ? $path : $siteConfig->getVar('DEFAULT_SITE');
             $siteDir = implode(DIRECTORY_SEPARATOR, array(ROOT_DIR, 'site', $site));
             if (!file_exists(realpath($siteDir))) {
                 die("FATAL ERROR: Site Directory {$siteDir} not found for site {$path}");
             }
         } else {
             $paths = explode("/", $path);
             // this is url
             $sites = array();
             $siteDir = '';
             if (count($paths) > 1) {
                 $site = $paths[1];
                 if ($sites = $siteConfig->getOptionalVar('ACTIVE_SITES', array(), 'kurogo')) {
                     //see if the site is in the list of available sites
                     if (in_array($site, $sites)) {
                         $testPath = implode(DIRECTORY_SEPARATOR, array(ROOT_DIR, 'site', $site));
                         if (($siteDir = realpath($testPath)) && file_exists($siteDir)) {
                             $urlBase = '/' . $site . '/';
                             // this is a url
                         }
                     }
                 } elseif (self::isValidSiteName($site)) {
                     $testPath = implode(DIRECTORY_SEPARATOR, array(ROOT_DIR, 'site', $site));
                     if (($siteDir = realpath($testPath)) && file_exists($siteDir)) {
                         $urlBase = '/' . $site . '/';
                         // this is a url
                     }
                 }
             }
             if (!$siteDir) {
                 $site = $siteConfig->getVar('DEFAULT_SITE');
                 array_splice($paths, 1, 1, array($site, $paths[1]));
                 $url = implode("/", $paths);
                 Kurogo::redirectToURL($url, Kurogo::REDIRECT_PERMANENT);
             }
         }
         define('SITE_NAME', $site);
     } else {
         //make sure active site is set
         if (!($site = $siteConfig->getVar('ACTIVE_SITE'))) {
             die("FATAL ERROR: ACTIVE_SITE not set");
         }
         // make sure site_dir is set and is a valid path
         // Do not call realpath_exists here because until SITE_DIR define is set
         // it will not allow files and directories outside ROOT_DIR
         if (!($siteDir = $siteConfig->getVar('SITE_DIR')) || !(($siteDir = realpath($siteDir)) && file_exists($siteDir))) {
             die("FATAL ERROR: Site Directory " . $siteConfig->getVar('SITE_DIR') . " not found for site " . $site);
         }
         define('SITE_NAME', $site);
         if (PHP_SAPI != 'cli') {
             //
             // Get URL base
             //
             if ($urlBase = $siteConfig->getOptionalVar('URL_BASE', '', 'kurogo')) {
                 $urlBase = rtrim($urlBase, '/') . '/';
             } elseif ($urlBase = Kurogo::getCache('URL_BASE')) {
                 //@TODO this won't work yet because the cache hasn't initialized
                 $urlBase = rtrim($urlBase, '/') . '/';
                 $saveCache = false;
             } else {
                 //extract the path parts from the url
                 $pathParts = array_values(array_filter(explode("/", $_SERVER['REQUEST_URI'])));
                 $testPath = $_SERVER['DOCUMENT_ROOT'] . DIRECTORY_SEPARATOR;
                 $urlBase = '/';
                 //once the path equals the WEBROOT_DIR we've found the base. This only works with symlinks
                 if (realpath($testPath) != WEBROOT_DIR) {
                     foreach ($pathParts as $dir) {
                         $test = $testPath . $dir . DIRECTORY_SEPARATOR;
                         if (file_exists(realpath($test))) {
                             $testPath = $test;
                             $urlBase .= $dir . '/';
                             if (realpath($test) == WEBROOT_DIR) {
                                 break;
                             }
                         }
                     }
                 }
             }
         }
     }
     if (PHP_SAPI == 'cli') {
//.........这里部分代码省略.........