);
}
+eval {
+ if (C4::Context->ismemcached) {
+ require Memoize::Memcached;
+ import Memoize::Memcached qw(memoize_memcached);
+
+ memoize_memcached( 'GetMarcStructure',
+ memcached => C4::Context->memcached);
+ }
+};
+
=head1 NAME
C4::Biblio - cataloging management functions
my ( $forlibrarian, $frameworkcode ) = @_;
my $dbh = C4::Context->dbh;
$frameworkcode = "" unless $frameworkcode;
- my $cache;
if ( defined $marc_structure_cache and exists $marc_structure_cache->{$forlibrarian}->{$frameworkcode} ) {
return $marc_structure_cache->{$forlibrarian}->{$frameworkcode};
}
- if (Koha::Cache->is_cache_active()) {
- $cache = Koha::Cache->new();
- if ($cache) {
- my $cached = $cache->get_from_cache("GetMarcStructure:$frameworkcode:$forlibrarian");
- return $cached if $cached;
- }
- }
+
+ # my $sth = $dbh->prepare(
+ # "SELECT COUNT(*) FROM marc_tag_structure WHERE frameworkcode=?");
+ # $sth->execute($frameworkcode);
+ # my ($total) = $sth->fetchrow;
+ # $frameworkcode = "" unless ( $total > 0 );
my $sth = $dbh->prepare(
"SELECT tagfield,liblibrarian,libopac,mandatory,repeatable
FROM marc_tag_structure
$marc_structure_cache->{$forlibrarian}->{$frameworkcode} = $res;
- if (Koha::Cache->is_cache_active() && defined $cache) {
- $cache->set_in_cache("GetMarcStructure:$frameworkcode:$forlibrarian",$res,10000);
- }
return $res;
}
use strict;
use warnings;
-use vars qw($VERSION $AUTOLOAD $context @context_stack);
-
-use Koha::Cache;
+use vars qw($VERSION $AUTOLOAD $context @context_stack $servers $memcached $ismemcached);
BEGIN {
if ($ENV{'HTTP_USER_AGENT'}) {
}
} # else there is no browser to send fatals to!
+ # Check if there are memcached servers set
+ $servers = $ENV{'MEMCACHED_SERVERS'};
+ if ($servers) {
+ # Load required libraries and create the memcached object
+ require Cache::Memcached;
+ $memcached = Cache::Memcached->new({
+ servers => [ $servers ],
+ debug => 0,
+ compress_threshold => 10_000,
+ expire_time => 600,
+ namespace => $ENV{'MEMCACHED_NAMESPACE'} || 'koha'
+ });
+ # Verify memcached available (set a variable and test the output)
+ $ismemcached = $memcached->set('ismemcached','1');
+ }
+
$VERSION = '3.07.00.049';
}
sub read_config_file { # Pass argument naming config file to read
my $koha = XMLin(shift, keyattr => ['id'], forcearray => ['listen', 'server', 'serverinfo'], suppressempty => '');
- if (Koha::Cache->is_cache_active()) {
- my $cache = Koha::Cache->new();
- $cache->set_in_cache('kohaconf', $koha) if defined $cache;
+ if ($ismemcached) {
+ $memcached->set('kohaconf',$koha);
}
return $koha; # Return value: ref-to-hash holding the configuration
}
+=head2 ismemcached
+
+Returns the value of the $ismemcached variable (0/1)
+
+=cut
+
+sub ismemcached {
+ return $ismemcached;
+}
+
+=head2 memcached
+
+If $ismemcached is true, returns the $memcache variable.
+Returns undef otherwise
+
+=cut
+
+sub memcached {
+ if ($ismemcached) {
+ return $memcached;
+ } else {
+ return undef;
+ }
+}
+
# db_scheme2dbi
# Translates the full text name of a database into de appropiate dbi name
#
file, which defaults to either the file given by the C<$KOHA_CONF>
environment variable, or F</etc/koha/koha-conf.xml>.
-It saves the koha-conf.xml values in the cache (if configured) and uses
-those values until them expire and re-reads them.
+It saves the koha-conf.xml values in the declared memcached server(s)
+if currently available and uses those values until them expire and
+re-reads them.
C<&new> does not set this context as the new default context; for
that, use C<&set_context>.
}
}
- if (Koha::Cache->is_cache_active()) {
- # retrieve from cache
- my $cache = Koha::Cache->new();
- $self = $cache->get_from_cache('kohaconf') if defined $cache;
- $self = { };
- }
- if (!keys %$self) {
- # not cached yet
+ if ($ismemcached) {
+ # retreive from memcached
+ $self = $memcached->get('kohaconf');
+ if (not defined $self) {
+ # not in memcached yet
+ $self = read_config_file($conf_fname);
+ }
+ } else {
+ # non-memcached env, read from file
$self = read_config_file($conf_fname);
}
#use warnings; FIXME - Bug 2505
use Carp;
use C4::Context;
-use Koha::Cache;
use vars qw($VERSION @ISA @EXPORT @EXPORT_OK %EXPORT_TAGS $DEBUG);
+eval {
+ if (C4::Context->ismemcached) {
+ require Memoize::Memcached;
+ import Memoize::Memcached qw(memoize_memcached);
+
+ memoize_memcached('getTranslatedLanguages', memcached => C4::Context->memcached);
+ memoize_memcached('getFrameworkLanguages' , memcached => C4::Context->memcached);
+ memoize_memcached('getAllLanguages', memcached => C4::Context->memcached);
+ }
+};
+
BEGIN {
$VERSION = 3.07.00.049;
require Exporter;
=cut
sub getFrameworkLanguages {
-
- my $cache;
- if (Koha::Cache->is_cache_active()) {
- $cache = Koha::Cache->new();
- if (defined $cache) {
- my $cached = $cache->get_from_cache("getFrameworkLanguages");
- return $cached if $cached;
- }
- }
# get a hash with all language codes, names, and locale names
my $all_languages = getAllLanguages();
my @languages;
}
}
}
- if (Koha::Cache->is_cache_active() && defined $cache) {
- $cache->set_in_cache("getFrameworkLanguages",\@languages,10000)
- }
return \@languages;
}
=cut
sub getAllLanguages {
- # retrieve from cache if applicable
- my $cache;
- if (Koha::Cache->is_cache_active()) {
- $cache = Koha::Cache->new();
- if (defined $cache) {
- my $cached = $cache->get_from_cache("getAllLanguages");
- if ($cached) {
- return $cached;
- }
- }
- }
my @languages_loop;
my $dbh=C4::Context->dbh;
my $current_language = shift || 'en';
}
push @languages_loop, $language_subtag_registry;
}
- if (Koha::Cache->is_cache_active() && defined $cache) {
- $cache->set_in_cache("getAllLanguages",\@languages_loop,1000);
- }
return \@languages_loop;
}
use C4::Context;
use C4::Dates qw(format_date_in_iso);
use C4::Debug;
-use Koha::Cache;
require Exporter;
use vars qw($VERSION @ISA @EXPORT_OK %EXPORT_TAGS);
+eval {
+ my $servers = C4::Context->config('memcached_servers');
+ if ($servers) {
+ require Memoize::Memcached;
+ import Memoize::Memcached qw(memoize_memcached);
+
+ my $memcached = {
+ servers => [$servers],
+ key_prefix => C4::Context->config('memcached_namespace') || 'koha',
+ expire_time => 600
+ }; # cache for 10 mins
+
+ memoize_memcached( '_get_columns', memcached => $memcached );
+ memoize_memcached( 'GetPrimaryKeys', memcached => $memcached );
+ }
+};
+
BEGIN {
# set the version for version checking
$VERSION = 3.07.00.049;
my $result;
eval{$result=$sth->execute(@$values)};
warn $@ if ($@ && $debug);
- return $result;
+ return $result;
}
}
sub GetPrimaryKeys($) {
my $tablename=shift;
- my $result;
- my $cache;
- if (Koha::Cache->is_cache_active()) {
- $cache = Koha::Cache->new();
- if (defined $cache) {
- $result = $cache->get_from_cache("sqlhelper:GetPrimaryKeys:$tablename");
- }
- }
- unless (defined $result) {
- my $hash_columns=_get_columns($tablename);
- $result = grep { $hash_columns->{$_}->{'Key'} =~/PRI/i} keys %$hash_columns;
- if (Koha::Cache->is_cache_active() && defined $cache) {
- $cache->set_in_cache("sqlhelper:GetPrimaryKeys:$tablename", $result);
- }
- }
- return $result;
+ my $hash_columns=_get_columns($tablename);
+ return grep { $hash_columns->{$_}->{'Key'} =~/PRI/i} keys %$hash_columns;
}
sub _get_columns($) {
my ($tablename) = @_;
- my $cache;
- if ( exists( $hashref->{$tablename} ) ) {
- return $hashref->{$tablename};
- }
- if (Koha::Cache->is_cache_active()) {
- $cache = Koha::Cache->new();
- if (defined $cache) {
- $hashref->{$tablename} = $cache->get_from_cache("sqlhelper:_get_columns:$tablename");
- }
- }
- unless ( defined $hashref->{$tablename} ) {
+ unless ( exists( $hashref->{$tablename} ) ) {
my $dbh = C4::Context->dbh;
my $sth = $dbh->prepare_cached(qq{SHOW COLUMNS FROM $tablename });
$sth->execute;
my $columns = $sth->fetchall_hashref(qw(Field));
$hashref->{$tablename} = $columns;
- if (Koha::Cache->is_cache_active() && defined $cache) {
- $cache->set_in_cache("sqlhelper:_get_columns:$tablename", $hashref->{$tablename});
- }
}
return $hashref->{$tablename};
}
}
sub is_cache_active {
- return $ENV{CACHING_SYSTEM} ? '1' : undef;
+ return $ENV{CACHING_SYSTEM} ? '1' : '';
}
sub set_in_cache {
use C4::Dates;
use C4::Debug;
use C4::Branch; # XXX subfield_is_koha_internal_p
-use Koha::Cache;
=head1 NAME
=cut
my $input = new CGI;
-my $usecache = Koha::Cache->is_cache_active();
+my $usecache = C4::Context->ismemcached;
my $phase = $input->param('phase');
my $flagsrequired;
}
SKIP: {
- skip "Memcached not enabled", 7 unless Koha::Cache->is_cache_active();
-
my $cache = Koha::Cache->new ();
+ skip "Cache not enabled", 7 unless (Koha::Cache->is_cache_active() && defined $cache);
+
# test fetching an item that isnt in the cache
is( $cache->get_from_cache("not in here"), undef, "fetching item NOT in cache");