Gecko [ www.finalhopeacademy.com ]

Name	Size	Permission
db	[ DIR ]	drwxr-xr-x
cache.pm	6.5 KB	-rw-r--r--
netip.pm	11.03 KB	-rw-r--r--

Code Editor : cache.pm

# Caching engine
# Copyright (C) 2009-2011, AllWorldIT
# Copyright (C) 2008, LinuxRulz
# Copyright (C) 2007 Nigel Kukard  <nkukard@lbsd.net>
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License along
# with this program; if not, write to the Free Software Foundation, Inc.,
# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

package awitpt::cache;

use strict;
use warnings;

require Exporter;
our (@ISA,@EXPORT,@EXPORT_OK);
@ISA = qw(Exporter);
@EXPORT = qw(
	cacheStoreKeyPair
	cacheStoreComplexKeyPair
	cacheGetKeyPair
	cacheGetComplexKeyPair
);
@EXPORT_OK = qw(
	getCacheHits
	getCacheMisses
);

use Cache::FastMmap;
use Storable;

# Cache stuff
my $cache_type = "FastMmap";
my $cache;

# Our current error message
my $error = "";

## @internal
# @fn setError($err)
# This function is used to set the last error for this class
#
# @param err Error message
sub setError
{
	my $err = shift;
	my ($package,$filename,$line) = caller;
	my (undef,undef,undef,$subroutine) = caller(1);

# Set error
	$error = "$subroutine($line): $err";
}

## @internal
# @fn Error
# Return current error message
#
# @return Last error message
sub Error
{
	my $err = $error;

# Reset error
	$error = "";

# Return error
	return $err;
}

## @fn Init($server)
# Initialize cache
#
# @param server Server object
# @param params Parameters for the cache
# @li cache_file Filename of the cache file
# @li cache_file_user Owner of the cache file
# @li cache_file_group Group of the cache file
sub Init
{
	my ($server,$params) = @_;
	my $ch;

# We going to pass these options to new()
	my %opt = (
		'page_size' => 2048,
		'num_pages' => 1000,
		'expire_time' => 300,
		'raw_values' => 1,
		'unlink_on_exit' => 1,
	);

# Check if we have the optional $params
	if (defined($params)) {
		# If we have a special cache file, use it and init it too
		if (defined($params->{'cache_file'})) {
			$opt{'share_file'} = $params->{'cache_file'};
			$opt{'init_file'} = 1;
		}
	}

# Create Cache
	$ch = Cache::FastMmap->new(%opt);

# Check if we have the optional $params
	if (defined($params)) {
		# If we have an explicit owner set, use it
		if (defined($params->{'cache_file_user'})) {
			# Check all is ok...
			my ($chown_user,$chown_group);
			if (!($chown_user = getpwnam($params->{'cache_file_user'}))) {
				setError("User '$chown_user' appears to be invalid: $?");
				return(-1);
			}
			if (!($chown_group = getgrnam($params->{'cache_file_group'}))) {
				setError("Group '$chown_group' appears to be invalid: $?");
				return(-1);
			}
			# Go in and chown it
			if (!chown($chown_user,$chown_group,$opt{'share_file'})) {
				setError("Failed to chown cache file '".$opt{'share_file'}."': $!");
				return(-1);
			}
		}
	}

# Stats
	$ch->set('Cache/Stats/Hit',0);
	$ch->set('Cache/Stats/Miss',0);

# Set server vars
	$server->{'cache_engine'}{'handle'} = $ch;
};

## @fn Destroy()
# Destroy cache
#
# @param server Server object
sub Destroy
{
};

## @fn connect($server)
# Connect server with the cache
#
# @param server Server object
sub connect
{
	my $server = shift;

$cache = $server->{'cache_engine'}{'handle'};
}

## @fn disconnect()
# Disconnect cache from server
#
# @param server Server object
sub disconnect
{
}

## @fn cacheStoreKeyPair($cacheName,$key,$value)
# Store keypair in cache
#
# @param cacheName Cache name to use
# @param key Item key
# @param value Item value
sub cacheStoreKeyPair
{
	my ($cacheName,$key,$value) = @_;

if (!defined($cacheName)) {
		setError("Cache name not defined in store");
		return -1;
	}

if ($cacheName eq "") {
		setError("Cache name not set in store");
		return -1;
	}

if (!defined($key)) {
		setError("Key not defined for cache '$cacheName' store");
		return -1;
	}

if (!defined($value)) {
		setError("Value not defined for cache '$cacheName' key '$key' store");
		return -1;
	}

# If we're not caching just return
	return 0 if ($cache_type eq 'none');

# Store
	$cache->set("$cacheName/$key",$value);

return 0;
}

## @fn cacheGetKeyPair($cacheName,$key)
# Get value from cache
#
# @param cacheName Cache name to use
# @param key Item key
sub cacheGetKeyPair
{
	my ($cacheName,$key) = @_;

if (!defined($cacheName)) {
		setError("Cache name not defined in get");
		return (-1);
	}

if ($cacheName eq "") {
		setError("Cache name not set in get");
		return (-1);
	}

if (!defined($key)) {
		setError("Key not defined for cache '$cacheName' get");
		return (-1);
	}

# If we're not caching just return
	if ($cache_type eq 'none') {
		return (0,undef);
	}

# Check and count
	my $res = $cache->get("$cacheName/$key");
	if ($res) {
		$cache->get_and_set('Cache/Stats/Hit',sub { return ++$_[1]; });
	} else {
		$cache->get_and_set('Cache/Stats/Miss',sub { return ++$_[1]; });
	}

return (0,$res);
}

## @fn cacheStoreComplexKeyPair($cacheName,$key,$value)
# Store a complex keypair in cache, this would be an object and
# not a number or text
#
# @param cacheName Cache name to use
# @param key Item key
# @param value Item value
sub cacheStoreComplexKeyPair
{
	my ($cacheName,$key,$value) = @_;

my $rawValue = Storable::freeze($value);
	if (!defined($rawValue)) {
		setError("Unable to freeze cache value in '$cacheName'");
		return -1;
	}

return cacheStoreKeyPair($cacheName,$key,$rawValue);
}

## @fn cacheGetComplexKeyPair($cacheName,$key)
# Get value from cache
#
# @param cacheName Cache name to use
# @param key Item key
sub cacheGetComplexKeyPair
{
	my ($cacheName,$key) = @_;

my ($res,$rawValue) = cacheGetKeyPair($cacheName,$key);
	# Thaw out item, if there is no error and we are defined
	if (!$res && defined($rawValue)) {
		$rawValue = Storable::thaw($rawValue);
	}

return ($res,$rawValue);
}

## @fn getCacheHits
# Return cache hits
#
# @return Cache hits
sub getCacheHits
{
	my $res;

# Get counter
	$res = defined($cache->get('Cache/Stats/Hit')) ? $cache->get('Cache/Stats/Hit') : 0;

return $res;
}

## @fn getCacheMisses
# Return cache misses
#
# @return Cache misses
sub getCacheMisses
{
	my $res;

# Get counter
	$res = defined($cache->get('Cache/Stats/Miss')) ? $cache->get('Cache/Stats/Miss') : 0;

return $res;
}

1;
# vim: ts=4

${this.title}

Code Editor : cache.pm