{

const DEBUG = false;

const VERSION = 0.3;

const API_VERSION = 004;

const GZ_COMPRESSION = 4;

const EXPIRE = 86400;

const EXPIRE_STATS = 604800;

const GROUP_NAME = 'staticcache';

const STATS_GROUP_NAME = 'staticcache_stats';

/**

* Set a priority of 1 on action_init so we run first

*

* @return array the priorities for our hooks

*/

public function set_priorities()

{

return array(

'action_init' => 1

);

}

/**

* Create aliases to additional hooks

*

* @return array aliased hooks

*/

public function alias()

{

return array(

'action_post_update_after' => array(

'action_post_insert_after',

'action_post_delete_after'

),

'action_comment_update_after' => array(

'action_comment_insert_after',

'action_comment_delete_after'

)

);

}

/**

* Serves the cache page or starts the output buffer. Ignore URLs matching

* the ignore list, and ignores if there are session messages.

*

* @see StaticCache_ob_end_flush()

*/

public function action_init()

{

/**

* Allows plugins to add to the ignore list. An array of all URLs to ignore

* is passed to the filter.

*

* @filter staticcache_ignore an array of URLs to ignore

*/

$ignore_array = Plugins::filter(

'staticcache_ignore',

explode(',', Options::get('staticcache__ignore_list'))

);

// sanitize the ignore list for preg_match

$ignore_list = implode(

'|',

array_map(

create_function('$a', 'return preg_quote(trim($a), "@");'),

$ignore_array

)

);

$request = Site::get_url('host') . $_SERVER['REQUEST_URI'];

$request_method = $_SERVER['REQUEST_METHOD'];

/* don't cache PUT or POST requests, pages matching ignore list keywords,

* nor pages with session messages, nor loggedin users

*/

if ($request_method == 'PUT' || $request_method == 'POST'

|| preg_match("@.*($ignore_list).*@i", $request) || Session::has_messages() || User::identify()->loggedin

) {

return;

}

$request_id = self::get_request_id();

$query_id = self::get_query_id();

if (Cache::has(array(self::GROUP_NAME, $request_id))) {

$cache = Cache::get(array(self::GROUP_NAME, $request_id));

if (isset($cache[$query_id])) {

global $profile_start;

// send the cached headers

foreach ($cache[$query_id]['headers'] as $header) {

header($header);

}

// check for compression

// @todo directly send compressed data to browser if webserver is not compressing.

if (isset($cache[$query_id]['compressed']) && $cache[$query_id]['compressed'] == true) {

echo gzuncompress($cache[$query_id]['body']);

}

else {

echo $cache[$query_id]['body'];

}

// record hit and profile data

$this->record_stats('hit', $profile_start);

exit;

}

}

// record miss

$this->record_stats('miss');

// register hook

Plugins::register(array('StaticCache', 'store_final_output'), 'filter', 'final_output', 16);

}

/**

* Record StaticCaches stats in the cache itself to avoid DB writes.

* Data includes hits, misses, and avg.

*

* @param string $type type of record, either hit or miss

* @param double $profile_start start of the profiling

*/

protected function record_stats($type, $profile_start = null)

{

switch ($type) {

case 'hit':

// do stats and output profiling

$pagetime = microtime(true) - $profile_start;

$hits = (int)Cache::get(array(self::STATS_GROUP_NAME, 'hits'));

$profile = (double)Cache::get(array(self::STATS_GROUP_NAME, 'avg'));

$avg = ($profile * $hits + $pagetime) / ($hits + 1);

Cache::set(array(self::STATS_GROUP_NAME, 'avg'), $avg, self::EXPIRE_STATS);

Cache::set(array(self::STATS_GROUP_NAME, 'hits'), $hits + 1, self::EXPIRE_STATS);

header('X-StaticCache-Stats: ' . $pagetime);

break;

case 'miss':

Cache::set(array(self::STATS_GROUP_NAME, 'misses'), Cache::get(array(self::STATS_GROUP_NAME, 'misses')) + 1, self::EXPIRE_STATS);

break;

}

}

/**

* Add the Static Cache dashboard module

*

* @param array $modules Available dash modules

* @return array modules array

*/

public function filter_dashboard_block_list($block_list)

{

$block_list['staticcache'] = 'Static Cache';

$this->add_template('dashboard.block.staticcache', dirname(__FILE__) . '/dashboard.block.staticcache.php');

return $block_list;

}

/**

* Filters the static cache dash module to add the theme template output.

*

* @param Block $block the dashboard block

* @param Theme the current theme from the handler

* @return array the modified module structure

*/

public function action_block_content_staticcache(Block $block, Theme $theme)

{

$block->static_cache_average = sprintf('%.4f', Cache::get(array(self::STATS_GROUP_NAME, 'avg')));

$block->static_cache_pages = count(Cache::get_group(self::GROUP_NAME));

$hits = Cache::get(array(self::STATS_GROUP_NAME, 'hits'));

$misses = Cache::get(array(self::STATS_GROUP_NAME, 'misses'));

$total = $hits + $misses;

$block->static_cache_misses_pct = sprintf('%.0f', $total > 0 ? ($misses / $total) * 100 : 0);

$block->static_cache_hits = $hits;

$block->static_cache_misses = $misses;

$block->static_cache_expire = $this->secs_to_human(Options::get('staticcache__expire', StaticCache::EXPIRE));

}

/**

* Convert seconds to human readable text.

*

* @param int the number of seconds to convert

* @return string a human readable time period

*/

public function secs_to_human($secs)

{

$units = array(

"week" => 7 * 24 * 3600,

"day" => 24 * 3600,

"hour" => 3600,

"minute" => 60,

"second" => 1,

);

// specifically handle zero

if ($secs == 0) return "0 seconds";

$s = "";

foreach ($units as $name => $divisor) {

if ($quot = intval($secs / $divisor)) {

$s .= "$quot $name";

$s .= (abs($quot) > 1 ? "s" : "") . ", ";

$secs -= $quot * $divisor;

}

}

return substr($s, 0, -2);

}

/**

* Ajax entry point for the 'clear cache data' action. Clears all stats and cache data

* and outputs a JSON encoded string message.

*/

public function action_auth_ajax_clear_staticcache()

{

foreach (Cache::get_group(self::GROUP_NAME) as $name => $data) {

Cache::expire(array(self::GROUP_NAME, $name));

}

foreach (Cache::get_group(self::STATS_GROUP_NAME) as $name => $data) {

Cache::expire(array(self::STATS_GROUP_NAME, $name));

}

echo json_encode(_t("Cleared Static Cache's cache"));

}

/**

* Invalidates (expires) the cache entries for the give list of URLs.

*

* @param array $urls An array of urls to clear

*/

public function cache_invalidate(array $urls)

{

// account for annonymous user (id=0)

$user_ids = array_map(create_function('$a', 'return $a->id;'), Users::get_all()->getArrayCopy());

array_push($user_ids, "0");

// expire the urls for each user id

foreach ($user_ids as $user_id) {

foreach ($urls as $url) {

$request_id = self::get_request_id($user_id, $url);

if (Cache::has(array(self::GROUP_NAME, $request_id))) {

Cache::expire(array(self::GROUP_NAME, $request_id));

EventLog::log('Clearing request ID: ' . $request_id, 'info', 'plugin', 'StaticCache');

}

}

}

}

/**

* Clears cache for the given post after it's updated. includes all CRUD operations.

*

* @param Post the post object to clear cache for

* @see StaticCache::cache_invalidate()

*/

public function action_post_update_after(Post $post)

{

$urls = array(

$post->comment_feed_link,

$post->permalink,

URL::get('atom_feed', 'index=1'),

Site::get_url('habari')

);

$this->cache_invalidate($urls);

}

/**

* Clears cache for the given comments parent post after it's updated. includes all

* CRUD operations.

*

* @param Comment the comment object to clear cache for it's parent post

* @see StaticCache::cache_invalidate()

*/

public function action_comment_update_after(Comment $comment)

{

$urls = array(

$comment->post->comment_feed_link,

$comment->post->permalink,

URL::get('atom_feed', 'index=1'),

Site::get_url('habari')

);

$this->cache_invalidate($urls);

}

/**

* Setup the initial ignore list on activation. Ignores URLs matching the following:

* /admin, /feedback, /user, /ajax, /auth_ajax, and ?nocache

*/

public function action_plugin_activation()

{

Options::set('staticcache__ignore_list', '/cron,/admin,/feedback,/auth,/ajax,/auth_ajax,?nocache');

}

/**

* Adds a 'configure' action to the pllugin page.

*

* @param array $actions the default plugin actions

* @param strinf $plugin_id the plugins id

* @return array the actions to add

*/

public function filter_plugin_config(array $actions, $plugin_id)

{

if ($plugin_id == $this->plugin_id()) {

$actions[] = _t('Configure', 'staticcache');

}

return $actions;

}

/**

* Adds the configure UI

*

* @todo add invalidate cache button

* @param string $plugin_id the plugins id

* @param string $action the action being performed

*/

public function action_plugin_ui($plugin_id, $action)

{

if ($plugin_id == $this->plugin_id()) {

switch ($action) {

case _t('Configure', 'staticcache') :

$ui = new FormUI('staticcache');

$ignore = $ui->append('textarea', 'ignore', 'staticcache__ignore_list', _t('Do not cache any URI\'s matching these keywords (comma seperated): ', 'staticcache'));

$ignore->add_validator('validate_required');

$expire = $ui->append('text', 'expire', 'staticcache__expire', _t('Cache expiry (in seconds): ', 'staticcache'));

$expire->add_validator('validate_required');

if (extension_loaded('zlib')) {

$compress = $ui->append('checkbox', 'compress', 'staticcache__compress', _t('Compress Cache To Save Space: ', 'staticcache'));

}

$ui->append('submit', 'save', _t('Save', 'staticcache'));

$ui->on_success(array($this, 'save_config_msg'));

$ui->out();

break;

}

}

}

public static function save_config_msg($ui)

{

$ui->save();

Session::notice(_t('Options saved'));

return false;

}

/**

* Adds the plugin to the update check routine.

*/

public function action_update_check()

{

Update::add('StaticCache', '340fb135-e1a1-4351-a81c-dac2f1795169', self::VERSION);

}

/**

* gets a unique id for the current query string requested.

*

* @return string Query ID

*/

public static function get_query_id()

{

return crc32(parse_url(Site::get_url('host') . $_SERVER['REQUEST_URI'], PHP_URL_QUERY));

}

/**

* Gets a unique id for the given request URL and user id.

*

* @param int the users id. Defaults to current users id or 0 for anonymous

* @param string The URL. Defaults to the current REQUEST_URI

* @return string Request ID

*/

public static function get_request_id($user_id = null, $url = null)

{

if (!$user_id) {

$user = User::identify();

$user_id = $user instanceof User ? $user->id : 0;

}

if (!$url) {

$url = Site::get_url('host') . rtrim(parse_url(Site::get_url('host') . $_SERVER['REQUEST_URI'], PHP_URL_PATH), '/');

}

return crc32($user_id . $url);

}

/**

* The output buffer callback used to capture the output and cache it.

*

* @see StaticCache::init()

* @param string $buffer The output buffer contents

* @return string $buffer unchanged

*/

public static function store_final_output($buffer)

{

// prevent caching of 404 responses

if (!URL::get_matched_rule() || URL::get_matched_rule()->name == 'display_404') {

return $buffer;

}

$request_id = StaticCache::get_request_id();

$query_id = StaticCache::get_query_id();

$expire = Options::get('staticcache__expire', StaticCache::EXPIRE);

// get cache if exists

if (Cache::has(array(StaticCache::GROUP_NAME, $request_id))) {

$cache = Cache::get(array(StaticCache::GROUP_NAME, $request_id));

}

else {

$cache = array();

}

// don't cache cookie headers (ie. session cookies)

$headers = headers_list();

foreach ($headers as $i => $head) {

if (stripos($head, 'cookie') !== false) {

unset($headers[$i]);

}

}

// see if we want compression and store cache

$cache[$query_id] = array(

'headers' => $headers,

'request_uri' => Site::get_url('host') . $_SERVER['REQUEST_URI']

);

if (Options::get('staticcache__compress') && extension_loaded('zlib')) {

$cache[$query_id]['body'] = gzcompress($buffer, StaticCache::GZ_COMPRESSION);

$cache[$query_id]['compressed'] = true;

}

else {

$cache[$query_id]['body'] = $buffer;

$cache[$query_id]['compressed'] = false;

}

Cache::set(array(StaticCache::GROUP_NAME, $request_id), $cache, $expire);

return $buffer;

}