--- loncom/lonnet/perl/lonnet.pm 2003/09/19 16:53:35 1.417
+++ loncom/lonnet/perl/lonnet.pm 2003/10/12 22:02:44 1.430
@@ -1,7 +1,7 @@
# The LearningOnline Network
# TCP networking package
#
-# $Id: lonnet.pm,v 1.417 2003/09/19 16:53:35 albertel Exp $
+# $Id: lonnet.pm,v 1.430 2003/10/12 22:02:44 www Exp $
#
# Copyright Michigan State University Board of Trustees
#
@@ -76,7 +76,7 @@ qw(%perlvar %hostname %homecache %badSer
%libserv %pr %prp %metacache %packagetab %titlecache
%courselogs %accesshash %userrolehash $processmarker $dumpcount
%coursedombuf %coursenumbuf %coursehombuf %coursedescrbuf %courseresdatacache
- %usectioncache %domaindescription %domain_auth_def %domain_auth_arg_def
+ %userresdatacache %usectioncache %domaindescription %domain_auth_def %domain_auth_arg_def
%domain_lang_def %domain_city %domain_longi %domain_lati $tmpdir);
use IO::Socket;
@@ -86,7 +86,8 @@ use HTML::LCParser;
use Fcntl qw(:flock);
use Apache::loncoursedata;
use Apache::lonlocal;
-
+use Storable qw(lock_store lock_nstore lock_retrieve freeze thaw);
+use Time::HiRes();
my $readit;
# --------------------------------------------------------------------- Logging
@@ -585,9 +586,9 @@ sub authenticate {
sub homeserver {
my ($uname,$udom,$ignoreBadCache)=@_;
my $index="$uname:$udom";
- if ($homecache{$index}) {
- return "$homecache{$index}";
- }
+
+ my ($result,$cached)=&is_cached(\%homecache,$index,'home',86400);
+ if (defined($cached)) { return $result; }
my $tryserver;
foreach $tryserver (keys %libserv) {
next if ($ignoreBadCache ne 'true' &&
@@ -595,8 +596,7 @@ sub homeserver {
if ($hostdom{$tryserver} eq $udom) {
my $answer=reply("home:$udom:$uname",$tryserver);
if ($answer eq 'found') {
- $homecache{$index}=$tryserver;
- return $tryserver;
+ return &do_cache(\%homecache,$index,$tryserver,'home');
} elsif ($answer eq 'no_host') {
$badServerCache{$tryserver}=1;
}
@@ -849,18 +849,37 @@ sub getsection {
}
sub devalidate_cache {
- my ($cache,$id) = @_;
+ my ($cache,$id,$name) = @_;
delete $$cache{$id.'.time'};
delete $$cache{$id};
+ my $filename=$perlvar{'lonDaemons'}.'/tmp/'.$name.".db";
+ open(DB,"$filename.lock");
+ flock(DB,LOCK_EX);
+ my %hash;
+ if (tie(%hash,'GDBM_File',$filename,&GDBM_WRCREAT(),0640)) {
+ delete($hash{$id});
+ delete($hash{$id.'.time'});
+ } else {
+ &logthis("Unable to tie hash");
+ }
+ untie(%hash);
+ flock(DB,LOCK_UN);
+ close(DB);
}
sub is_cached {
- my ($cache,$id,$time) = @_;
+ my ($cache,$id,$name,$time) = @_;
+ if (!$time) { $time=300; }
+ if (!exists($$cache{$id.'.time'})) {
+ &load_cache_item($cache,$name,$id);
+ }
if (!exists($$cache{$id.'.time'})) {
+# &logthis("Didn't find $id");
return (undef,undef);
} else {
- if (time-$$cache{$id.'.time'}>$time) {
- &devalidate_cache($cache,$id);
+ if (time-($$cache{$id.'.time'})>$time) {
+# &logthis("Devailidating $id - ".time-($$cache{$id.'.time'}));
+ &devalidate_cache($cache,$id,$name);
return (undef,undef);
}
}
@@ -868,17 +887,126 @@ sub is_cached {
}
sub do_cache {
- my ($cache,$id,$value) = @_;
+ my ($cache,$id,$value,$name) = @_;
$$cache{$id.'.time'}=time;
- # do_cache implictly return the set value
$$cache{$id}=$value;
+# &logthis("Caching $id as :$value:");
+ &save_cache_item($cache,$name,$id);
+ # do_cache implictly return the set value
+ $$cache{$id};
+}
+
+sub save_cache {
+ my ($cache,$name)=@_;
+ my $starttime=&Time::HiRes::time();
+# &logthis("Saving :$name:");
+ eval lock_store($cache,$perlvar{'lonDaemons'}.'/tmp/'.$name.".storable");
+ if ($@) { &logthis("lock_store threw a die ".$@); }
+# &logthis("save_cache took ".(&Time::HiRes::time()-$starttime));
+}
+
+sub load_cache {
+ my ($cache,$name)=@_;
+ my $starttime=&Time::HiRes::time();
+# &logthis("Before Loading $name size is ".scalar(%$cache));
+ my $tmpcache;
+ eval {
+ $tmpcache=lock_retrieve($perlvar{'lonDaemons'}.'/tmp/'.$name.".storable");
+ };
+ if ($@) { &logthis("lock_retreive threw a die ".$@); return; }
+ if (!%$cache) {
+ my $count;
+ while (my ($key,$value)=each(%$tmpcache)) {
+ $count++;
+ $$cache{$key}=$value;
+ }
+# &logthis("Initial load: $count");
+ } else {
+ my $key;
+ my $count;
+ while ($key=each(%$tmpcache)) {
+ if ($key !~/^(.*)\.time$/) { next; }
+ my $name=$1;
+ if (exists($$cache{$key})) {
+ if ($$tmpcache{$key} >= $$cache{$key}) {
+ $$cache{$key}=$$tmpcache{$key};
+ $$cache{$name}=$$tmpcache{$name};
+ } else {
+# &logthis("Would have overwritten $name with is set to expire at ".$$cache{$key}." with ".$$tmpcache{$key}." Whew!");
+ }
+ } else {
+ $count++;
+ $$cache{$key}=$$tmpcache{$key};
+ $$cache{$name}=$$tmpcache{$name};
+ }
+ }
+# &logthis("Additional load: $count");
+ }
+# &logthis("After Loading $name size is ".scalar(%$cache));
+# &logthis("load_cache took ".(&Time::HiRes::time()-$starttime));
+}
+
+sub save_cache_item {
+ my ($cache,$name,$id)=@_;
+ my $starttime=&Time::HiRes::time();
+ # &logthis("Saving :$name:$id");
+ my %hash;
+ my $filename=$perlvar{'lonDaemons'}.'/tmp/'.$name.".db";
+ open(DB,"$filename.lock");
+ flock(DB,LOCK_EX);
+ if (tie(%hash,'GDBM_File',$filename,&GDBM_WRCREAT(),0640)) {
+ $hash{$id.'.time'}=$$cache{$id.'.time'};
+ $hash{$id}=freeze({'item'=>$$cache{$id}});
+ } else {
+ &logthis("Unable to tie hash");
+ }
+ untie(%hash);
+ flock(DB,LOCK_UN);
+ close(DB);
+# &logthis("save_cache_item $name took ".(&Time::HiRes::time()-$starttime));
+}
+
+sub load_cache_item {
+ my ($cache,$name,$id)=@_;
+ my $starttime=&Time::HiRes::time();
+# &logthis("Before Loading $name for $id size is ".scalar(%$cache));
+ my %hash;
+ my $filename=$perlvar{'lonDaemons'}.'/tmp/'.$name.".db";
+ open(DB,"$filename.lock");
+ flock(DB,LOCK_SH);
+ if (tie(%hash,'GDBM_File',$filename,&GDBM_READER(),0640)) {
+ if (!%$cache) {
+ my $count;
+ while (my ($key,$value)=each(%hash)) {
+ $count++;
+ if ($key =~ /\.time$/) {
+ $$cache{$key}=$value;
+ } else {
+ my $hashref=thaw($value);
+ $$cache{$key}=$hashref->{'item'};
+ }
+ }
+# &logthis("Initial load: $count");
+ } else {
+ my $hashref=thaw($hash{$id});
+ $$cache{$id}=$hashref->{'item'};
+ $$cache{$id.'.time'}=$hash{$id.'.time'};
+ }
+ } else {
+ &logthis("Unable to tie hash");
+ }
+ untie(%hash);
+ flock(DB,LOCK_UN);
+ close(DB);
+# &logthis("After Loading $name size is ".scalar(%$cache));
+# &logthis("load_cache_item $name took ".(&Time::HiRes::time()-$starttime));
}
sub usection {
my ($udom,$unam,$courseid)=@_;
my $hashid="$udom:$unam:$courseid";
- my ($result,$cached)=&is_cached(\%usectioncache,$hashid,300);
+ my ($result,$cached)=&is_cached(\%usectioncache,$hashid,'usection');
if (defined($cached)) { return $result; }
$courseid=~s/\_/\//g;
$courseid=~s/^(\w)/\/$1/;
@@ -899,11 +1027,11 @@ sub usection {
if ($now>$end) { $notactive=1; }
}
unless ($notactive) {
- return &do_cache(\%usectioncache,$hashid,$section);
+ return &do_cache(\%usectioncache,$hashid,$section,'usection');
}
}
}
- return &do_cache(\%usectioncache,$hashid,'-1');
+ return &do_cache(\%usectioncache,$hashid,'-1','usection');
}
# ------------------------------------- Read an entry from a user's environment
@@ -2219,27 +2347,7 @@ sub currentdump {
return if ($tmp[0] =~ /^(error:|no_such_host)/);
my %hash = @tmp;
@tmp=();
- # Code ripped from lond, essentially. The only difference
- # here is the unescaping done by lonnet::dump(). Conceivably
- # we might run in to problems with parameter names =~ /^v\./
- while (my ($key,$value) = each(%hash)) {
- my ($v,$symb,$param) = split(/:/,$key);
- next if ($v eq 'version' || $symb eq 'keys');
- next if (exists($returnhash{$symb}) &&
- exists($returnhash{$symb}->{$param}) &&
- $returnhash{$symb}->{'v.'.$param} > $v);
- $returnhash{$symb}->{$param}=$value;
- $returnhash{$symb}->{'v.'.$param}=$v;
- }
- #
- # Remove all of the keys in the hashes which keep track of
- # the version of the parameter.
- while (my ($symb,$param_hash) = each(%returnhash)) {
- # use a foreach because we are going to delete from the hash.
- foreach my $key (keys(%$param_hash)) {
- delete($param_hash->{$key}) if ($key =~ /^v\./);
- }
- }
+ %returnhash = %{&convert_dump_to_currentdump(\%hash)};
} else {
my @pairs=split(/\&/,$rep);
foreach (@pairs) {
@@ -2252,6 +2360,33 @@ sub currentdump {
return %returnhash;
}
+sub convert_dump_to_currentdump{
+ my %hash = %{shift()};
+ my %returnhash;
+ # Code ripped from lond, essentially. The only difference
+ # here is the unescaping done by lonnet::dump(). Conceivably
+ # we might run in to problems with parameter names =~ /^v\./
+ while (my ($key,$value) = each(%hash)) {
+ my ($v,$symb,$param) = split(/:/,$key);
+ next if ($v eq 'version' || $symb eq 'keys');
+ next if (exists($returnhash{$symb}) &&
+ exists($returnhash{$symb}->{$param}) &&
+ $returnhash{$symb}->{'v.'.$param} > $v);
+ $returnhash{$symb}->{$param}=$value;
+ $returnhash{$symb}->{'v.'.$param}=$v;
+ }
+ #
+ # Remove all of the keys in the hashes which keep track of
+ # the version of the parameter.
+ while (my ($symb,$param_hash) = each(%returnhash)) {
+ # use a foreach because we are going to delete from the hash.
+ foreach my $key (keys(%$param_hash)) {
+ delete($param_hash->{$key}) if ($key =~ /^v\./);
+ }
+ }
+ return \%returnhash;
+}
+
# --------------------------------------------------------------- put interface
sub put {
@@ -2646,6 +2781,29 @@ sub is_on_map {
}
}
+# --------------------------------------------------------- Get symb from alias
+
+sub get_symb_from_alias {
+ my $symb=shift;
+ my ($map,$resid,$url)=&decode_symb($symb);
+# Already is a symb
+ if ($url) { return $symb; }
+# Must be an alias
+ my $aliassymb='';
+ my %bighash;
+ if (tie(%bighash,'GDBM_File',$ENV{'request.course.fn'}.'.db',
+ &GDBM_READER(),0640)) {
+ my $rid=$bighash{'mapalias_'.$symb};
+ if ($rid) {
+ my ($mapid,$resid)=split(/\./,$rid);
+ $aliassymb=&encode_symb($bighash{'map_id_'.$mapid},
+ $resid,$bighash{'src_'.$rid});
+ }
+ untie %bighash;
+ }
+ return $aliassymb;
+}
+
# ----------------------------------------------------------------- Define Role
sub definerole {
@@ -3300,7 +3458,7 @@ sub condval {
sub devalidatecourseresdata {
my ($coursenum,$coursedomain)=@_;
my $hashid=$coursenum.':'.$coursedomain;
- delete $courseresdatacache{$hashid.'.time'};
+ &devalidate_cache(\%courseresdatacache,$hashid,'courseres');
}
# --------------------------------------------------- Course Resourcedata Query
@@ -3309,18 +3467,18 @@ sub courseresdata {
my ($coursenum,$coursedomain,@which)=@_;
my $coursehom=&homeserver($coursenum,$coursedomain);
my $hashid=$coursenum.':'.$coursedomain;
- my ($result,$cached)=&is_cached(\%courseresdatacache,$hashid,300);
+ my ($result,$cached)=&is_cached(\%courseresdatacache,$hashid,'courseres');
unless (defined($cached)) {
my %dumpreply=&dump('resourcedata',$coursedomain,$coursenum);
$result=\%dumpreply;
my ($tmp) = keys(%dumpreply);
if ($tmp !~ /^(con_lost|error|no_such_host)/i) {
- &do_cache(\%courseresdatacache,$hashid,$result);
+ &do_cache(\%courseresdatacache,$hashid,$result,'courseres');
} elsif ($tmp =~ /^(con_lost|no_such_host)/) {
return $tmp;
} elsif ($tmp =~ /^(error)/) {
$result=undef;
- &do_cache(\%courseresdatacache,$hashid,$result);
+ &do_cache(\%courseresdatacache,$hashid,$result,'courseres');
}
}
foreach my $item (@which) {
@@ -3364,6 +3522,9 @@ sub EXT {
#get real user name/domain, courseid and symb
my $courseid;
my $publicuser;
+ if ($symbparm) {
+ $symbparm=&get_symb_from_alias($symbparm);
+ }
if (!($uname && $udom)) {
(my $cursymb,$courseid,$udom,$uname,$publicuser)=
&Apache::lonxml::whichuser($symbparm);
@@ -3449,7 +3610,15 @@ sub EXT {
} elsif ($realm eq 'request') {
# ------------------------------------------------------------- request.browser
if ($space eq 'browser') {
- return $ENV{'browser.'.$qualifier};
+ if ($qualifier eq 'textremote') {
+ if (&mt('textual_remote_display') eq 'on') {
+ return 1;
+ } else {
+ return 0;
+ }
+ } else {
+ return $ENV{'browser.'.$qualifier};
+ }
# ------------------------------------------------------------ request.filename
} else {
return $ENV{'request.'.$spacequalifierrest};
@@ -3493,19 +3662,25 @@ sub EXT {
# ----------------------------------------------------------- first, check user
#most student don\'t have any data set, check if there is some data
- #every thirty minutes
if (! &EXT_cache_status($udom,$uname)) {
- my %resourcedata=&get('resourcedata',
- [$courselevelr,$courselevelm,$courselevel],
- $udom,$uname);
- my ($tmp)=keys(%resourcedata);
+ my $hashid="$udom:$uname";
+ my ($result,$cached)=&is_cached(\%userresdatacache,$hashid,
+ 'userres');
+ if (!defined($cached)) {
+ my %resourcedata=&get('resourcedata',
+ [$courselevelr,$courselevelm,
+ $courselevel],$udom,$uname);
+ $result=\%resourcedata;
+ &do_cache(\%userresdatacache,$hashid,$result,'userres');
+ }
+ my ($tmp)=keys(%$result);
if (($tmp!~/^error\:/) && ($tmp!~/^con_lost/)) {
- if ($resourcedata{$courselevelr}) {
- return $resourcedata{$courselevelr}; }
- if ($resourcedata{$courselevelm}) {
- return $resourcedata{$courselevelm}; }
- if ($resourcedata{$courselevel}) {
- return $resourcedata{$courselevel}; }
+ if ($$result{$courselevelr}) {
+ return $$result{$courselevelr}; }
+ if ($$result{$courselevelm}) {
+ return $$result{$courselevelm}; }
+ if ($$result{$courselevel}) {
+ return $$result{$courselevel}; }
} else {
if ($tmp!~/No such file/) {
&logthis("<font color=blue>WARNING:".
@@ -3621,11 +3796,11 @@ sub add_prefix_and_part {
sub metadata {
my ($uri,$what,$liburi,$prefix,$depthcount)=@_;
-
$uri=&declutter($uri);
# if it is a non metadata possible uri return quickly
if (($uri eq '') || (($uri =~ m|^/*adm/|) && ($uri !~ m|^adm/includes|)) ||
- ($uri =~ m|/$|) || ($uri =~ m|/.meta$|)) {
+ ($uri =~ m|/$|) || ($uri =~ m|/.meta$|) || ($uri =~ /^~/) ||
+ ($uri =~ m|home/[^/]+/public_html/|)) {
return '';
}
my $filename=$uri;
@@ -3635,15 +3810,20 @@ sub metadata {
# Look at timestamp of caching
# Everything is cached by the main uri, libraries are never directly cached
#
- unless (abs($metacache{$uri.':cachedtimestamp'}-time)<600 && !defined($liburi)) {
+ if (!defined($liburi)) {
+ my ($result,$cached)=&is_cached(\%metacache,$uri,'meta');
+ if (defined($cached)) { return $result->{':'.$what}; }
+ }
+ {
#
# Is this a recursive call for a library?
#
+ my %lcmetacache;
if ($liburi) {
$liburi=&declutter($liburi);
$filename=$liburi;
} else {
- delete($metacache{$uri.':packages'});
+ &devalidate_cache(\%metacache,$uri,'meta');
}
my %metathesekeys=();
unless ($filename=~/\.meta$/) { $filename.='.meta'; }
@@ -3662,10 +3842,10 @@ sub metadata {
if (defined($token->[2]->{'id'})) {
$keyroot.='_'.$token->[2]->{'id'};
}
- if ($metacache{$uri.':packages'}) {
- $metacache{$uri.':packages'}.=','.$package.$keyroot;
+ if ($lcmetacache{':packages'}) {
+ $lcmetacache{':packages'}.=','.$package.$keyroot;
} else {
- $metacache{$uri.':packages'}=$package.$keyroot;
+ $lcmetacache{':packages'}=$package.$keyroot;
}
foreach (keys %packagetab) {
if ($_=~/^$package\&/) {
@@ -3680,14 +3860,14 @@ sub metadata {
$value.=' [Part: '.$part.']';
}
my $unikey='parameter'.$keyroot.'_'.$name;
- $metacache{$uri.':'.$unikey.'.part'}=$part;
+ $lcmetacache{':'.$unikey.'.part'}=$part;
$metathesekeys{$unikey}=1;
- unless (defined($metacache{$uri.':'.$unikey.'.'.$subp})) {
- $metacache{$uri.':'.$unikey.'.'.$subp}=$value;
+ unless (defined($lcmetacache{':'.$unikey.'.'.$subp})) {
+ $lcmetacache{':'.$unikey.'.'.$subp}=$value;
}
- if (defined($metacache{$uri.':'.$unikey.'.default'})) {
- $metacache{$uri.':'.$unikey}=
- $metacache{$uri.':'.$unikey.'.default'};
+ if (defined($lcmetacache{':'.$unikey.'.default'})) {
+ $lcmetacache{':'.$unikey}=
+ $lcmetacache{':'.$unikey.'.default'};
}
}
}
@@ -3730,18 +3910,18 @@ sub metadata {
}
$metathesekeys{$unikey}=1;
foreach (@{$token->[3]}) {
- $metacache{$uri.':'.$unikey.'.'.$_}=$token->[2]->{$_};
+ $lcmetacache{':'.$unikey.'.'.$_}=$token->[2]->{$_};
}
my $internaltext=&HTML::Entities::decode($parser->get_text('/'.$entry));
- my $default=$metacache{$uri.':'.$unikey.'.default'};
+ my $default=$lcmetacache{':'.$unikey.'.default'};
if ( $internaltext =~ /^\s*$/ && $default !~ /^\s*$/) {
# only ws inside the tag, and not in default, so use default
# as value
- $metacache{$uri.':'.$unikey}=$default;
+ $lcmetacache{':'.$unikey}=$default;
} else {
# either something interesting inside the tag or default
# uninteresting
- $metacache{$uri.':'.$unikey}=$internaltext;
+ $lcmetacache{':'.$unikey}=$internaltext;
}
# end of not-a-package not-a-library import
}
@@ -3751,13 +3931,13 @@ sub metadata {
}
}
# are there custom rights to evaluate
- if ($metacache{$uri.':copyright'} eq 'custom') {
+ if ($lcmetacache{':copyright'} eq 'custom') {
#
# Importing a rights file here
#
unless ($depthcount) {
- my $location=$metacache{$uri.':customdistributionfile'};
+ my $location=$lcmetacache{':customdistributionfile'};
my $dir=$filename;
$dir=~s|[^/]*$||;
$location=&filelocation($dir,$location);
@@ -3768,13 +3948,13 @@ sub metadata {
}
}
}
- $metacache{$uri.':keys'}=join(',',keys %metathesekeys);
- &metadata_generate_part0(\%metathesekeys,\%metacache,$uri);
- $metacache{$uri.':allpossiblekeys'}=join(',',keys %metathesekeys);
- $metacache{$uri.':cachedtimestamp'}=time;
+ $lcmetacache{':keys'}=join(',',keys %metathesekeys);
+ &metadata_generate_part0(\%metathesekeys,\%lcmetacache,$uri);
+ $lcmetacache{':allpossiblekeys'}=join(',',keys %metathesekeys);
+ &do_cache(\%metacache,$uri,\%lcmetacache,'meta');
# this is the end of "was not already recently cached
}
- return $metacache{$uri.':'.$what};
+ return $metacache{$uri}->{':'.$what};
}
sub metadata_generate_part0 {
@@ -3782,8 +3962,8 @@ sub metadata_generate_part0 {
my %allnames;
foreach my $metakey (sort keys %$metadata) {
if ($metakey=~/^parameter\_(.*)/) {
- my $part=$$metacache{$uri.':'.$metakey.'.part'};
- my $name=$$metacache{$uri.':'.$metakey.'.name'};
+ my $part=$$metacache{':'.$metakey.'.part'};
+ my $name=$$metacache{':'.$metakey.'.name'};
if (! exists($$metadata{'parameter_0_'.$name.'.name'})) {
$allnames{$name}=$part;
}
@@ -3791,13 +3971,13 @@ sub metadata_generate_part0 {
}
foreach my $name (keys(%allnames)) {
$$metadata{"parameter_0_$name"}=1;
- my $key="$uri:parameter_0_$name";
+ my $key=":parameter_0_$name";
$$metacache{"$key.part"}='0';
$$metacache{"$key.name"}=$name;
- $$metacache{"$key.type"}=$$metacache{$uri.':parameter_'.
+ $$metacache{"$key.type"}=$$metacache{':parameter_'.
$allnames{$name}.'_'.$name.
'.type'};
- my $olddis=$$metacache{$uri.':parameter_'.$allnames{$name}.'_'.$name.
+ my $olddis=$$metacache{':parameter_'.$allnames{$name}.'_'.$name.
'.display'};
my $expr='\\[Part: '.$allnames{$name}.'\\]';
$olddis=~s/$expr/\[Part: 0\]/;
@@ -3814,13 +3994,8 @@ sub gettitle {
unless ($urlsymb) { $urlsymb=$ENV{'request.filename'}; }
return &metadata($urlsymb,'title');
}
- if ($titlecache{$symb}) {
- if (time < ($titlecache{$symb}[1] + 600)) {
- return $titlecache{$symb}[0];
- } else {
- delete($titlecache{$symb});
- }
- }
+ my ($result,$cached)=&is_cached(\%titlecache,$symb,'title',600);
+ if (defined($cached)) { return $result; }
my ($map,$resid,$url)=&decode_symb($symb);
my $title='';
my %bighash;
@@ -3832,8 +4007,7 @@ sub gettitle {
}
$title=~s/\&colon\;/\:/gs;
if ($title) {
- $titlecache{$symb}=[$title,time];
- return $title;
+ return &do_cache(\%titlecache,$symb,$title,'title');
} else {
return &metadata($urlsymb,'title');
}
@@ -3912,6 +4086,11 @@ sub symbclean {
# ---------------------------------------------- Split symb to find map and url
+sub encode_symb {
+ my ($map,$resid,$url)=@_;
+ return &symbclean(&declutter($map).'___'.$resid.'___'.&declutter($url));
+}
+
sub decode_symb {
my ($map,$resid,$url)=split(/\_\_\_/,shift);
return (&fixversion($map),$resid,&fixversion($url));
@@ -4236,6 +4415,16 @@ sub mod_perl_version {
sub goodbye {
&logthis("Starting Shut down");
+#not converted to using infrastruture
+ &logthis(sprintf("%-20s is %s",'%homecache',scalar(%homecache)));
+ &logthis(sprintf("%-20s is %s",'%badServerCache',scalar(%badServerCache)));
+ &logthis(sprintf("%-20s is %s",'%metacache',scalar(%metacache)));
+#converted
+ &logthis(sprintf("%-20s is %s",'%titlecache',scalar(%titlecache)));
+ &logthis(sprintf("%-20s is %s",'%courseresdatacache',scalar(%courseresdatacache)));
+#1.1 only
+ &logthis(sprintf("%-20s is %s",'%userresdatacache',scalar(%userresdatacache)));
+ &logthis(sprintf("%-20s is %s",'%usectioncache',scalar(%usectioncache)));
&flushcourselogs();
&logthis("Shutting down");
return DONE;