PHP Kurogo::setCache方法代码示例

 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();
 }

//.........这里部分代码省略.........
                 $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') {
         define('URL_BASE', null);
     } else {
         if (!isset($urlBase)) {
             throw new KurogoConfigurationException("URL base not set. Please report the configuration to see why this happened");
         }
         define('URL_BASE', $urlBase);
         if ($saveCache) {
             Kurogo::setCache('URL_BASE', $urlBase);
         }
         Kurogo::log(LOG_DEBUG, "Setting site to {$site} with a base of {$urlBase}", 'kurogo');
         // Strips out the leading part of the url for sites where
         // the base is not located at the document root, ie.. /mobile or /m
         // Also strips off the leading slash (needed by device debug below)
         if (isset($path)) {
             // Strip the URL_BASE off the path
             $baseLen = strlen(URL_BASE);
             if ($baseLen && strpos($path, URL_BASE) === 0) {
                 $path = substr($path, $baseLen);
             }
         }
     }
     // Set up defines relative to SITE_DIR
     define('SITE_DIR', $siteDir);
     //already been realpath'd
     define('SITE_LIB_DIR', SITE_DIR . DIRECTORY_SEPARATOR . 'lib');
     define('SITE_APP_DIR', SITE_DIR . DIRECTORY_SEPARATOR . 'app');
     define('SITE_MODULES_DIR', SITE_DIR . DIRECTORY_SEPARATOR . 'app' . DIRECTORY_SEPARATOR . 'modules');
     define('DATA_DIR', SITE_DIR . DIRECTORY_SEPARATOR . 'data');
     define('CACHE_DIR', SITE_DIR . DIRECTORY_SEPARATOR . 'cache');
     define('LOG_DIR', SITE_DIR . DIRECTORY_SEPARATOR . 'logs');
     define('SITE_CONFIG_DIR', SITE_DIR . DIRECTORY_SEPARATOR . 'config');
     define('SITE_DISABLED_DIR', SITE_DIR . DIRECTORY_SEPARATOR . 'config_disabled');
     //load in the site config file (required);
     $config = ConfigFile::factory('site', 'site');
     $siteConfig->addConfig($config);
     // attempt to load site key
     $siteKey = $siteConfig->getOptionalVar('SITE_KEY', md5($siteDir));
     define('SITE_KEY', $siteKey);
     if ($siteConfig->getOptionalVar('SITE_DISABLED')) {
         die("FATAL ERROR: Site disabled");
     }
     // Set up theme define
     if (!($theme = $siteConfig->getVar('ACTIVE_THEME'))) {
         die("FATAL ERROR: ACTIVE_THEME not set");
     }
     Kurogo::log(LOG_DEBUG, "Setting theme to {$theme}", 'kurogo');
     define('THEME_DIR', SITE_DIR . DIRECTORY_SEPARATOR . 'themes' . DIRECTORY_SEPARATOR . $theme);
     $this->siteConfig = $siteConfig;
 }