[BACK]Return to lonuserstate.pm CVS log [TXT] [DIR] Up to [LON-CAPA] / rat

Diff for /rat/lonuserstate.pm between versions 1.124 and 1.132

version 1.124, 2007/08/29 00:50:50 version 1.132, 2009/11/15 14:08:53
Line 210  sub loadmap { Line 210  sub loadmap {
  $hash{'type_'.$from_rid}='finish';   $hash{'type_'.$from_rid}='finish';
     }      }
   
     my $parser = HTML::TokeParser->new(\$instr);      $parser = HTML::TokeParser->new(\$instr);
     $parser->attr_encoded(1);      $parser->attr_encoded(1);
     # last parse out the mapalias params so as to ignore anything      # last parse out the mapalias params so as to ignore anything
     # refering to non-existant resources      # refering to non-existant resources
Line 247  sub parse_resource { Line 247  sub parse_resource {
  $turi=~/\.(\w+)$/;   $turi=~/\.(\w+)$/;
  my $embstyle=&Apache::loncommon::fileembstyle($1);   my $embstyle=&Apache::loncommon::fileembstyle($1);
  if ($token->[2]->{'external'} eq 'true') { # external   if ($token->[2]->{'external'} eq 'true') { # external
     $turi=~s/^http\:\/\//\/adm\/wrapper\/ext\//;      $turi=~s/^https?\:\/\//\/adm\/wrapper\/ext\//;
  } elsif ($turi=~/^\/*uploaded\//) { # uploaded   } elsif ($turi=~/^\/*uploaded\//) { # uploaded
     if (($embstyle eq 'img')       if (($embstyle eq 'img') 
  || ($embstyle eq 'emb')   || ($embstyle eq 'emb')
Line 471  sub traceroute { Line 471  sub traceroute {
     if (defined($hash{'map_start_'.$hash{'src_'.$rid}})) {      if (defined($hash{'map_start_'.$hash{'src_'.$rid}})) {
  $sofar=$newsofar=   $sofar=$newsofar=
     &traceroute($sofar,      &traceroute($sofar,
  $hash{'map_start_'.$hash{'src_'.$rid}},'&',   $hash{'map_start_'.$hash{'src_'.$rid}},
    $beenhere,
  $encflag || $encurl{$rid},   $encflag || $encurl{$rid},
  $hdnflag || $hiddenurl{$rid});   $hdnflag || $hiddenurl{$rid});
     }      }
Line 572  sub accinit { Line 573  sub accinit {
     $acchash{'acc.res.'.$short.'.'}='&:0&';      $acchash{'acc.res.'.$short.'.'}='&:0&';
     my $courseuri=$uri;      my $courseuri=$uri;
     $courseuri=~s/^\/res\///;      $courseuri=~s/^\/res\///;
     &Apache::lonnet::delenv('(acc\.|httpref\.)');      my $regexp = 1;
     &Apache::lonnet::appenv(%acchash);      &Apache::lonnet::delenv('(acc\.|httpref\.)',$regexp);
       &Apache::lonnet::appenv(\%acchash);
 }  }
   
 # ---------------- Selectively delete from randompick maps and hidden url parms  # ---------------- Selectively delete from randompick maps and hidden url parms
Line 629  sub hiddenurls { Line 631  sub hiddenurls {
     }      }
 # --------------------------------------- append randomout entry to environment  # --------------------------------------- append randomout entry to environment
     if ($randomoutentry) {      if ($randomoutentry) {
  &Apache::lonnet::appenv('acc.randomout' => $randomoutentry);   &Apache::lonnet::appenv({'acc.randomout' => $randomoutentry});
     }      }
 }  }
   
Line 651  sub readmap { Line 653  sub readmap {
   
     open(LOCKFILE,">$fn.db.lock");      open(LOCKFILE,">$fn.db.lock");
     my $lock=0;      my $lock=0;
       my $gotstate=0;
     if (flock(LOCKFILE,LOCK_EX|LOCK_NB)) {      if (flock(LOCKFILE,LOCK_EX|LOCK_NB)) {
  $lock=1;   $lock=1;
  unlink($fn.'.db');          &unlink_tmpfiles($fn);
  unlink($fn.'_symb.db');  
  unlink($fn.'.state');  
  unlink($fn.'parms.db');  
     }      }
     undef %randompick;      undef %randompick;
     undef %hiddenurl;      undef %hiddenurl;
     undef %encurl;      undef %encurl;
     $retfrid='';      $retfrid='';
     if ($lock && (tie(%hash,'GDBM_File',"$fn.db",&GDBM_WRCREAT(),0640)) &&      my ($untiedhash,$untiedparmhash,$tiedhash,$tiedparmhash);
  (tie(%parmhash,'GDBM_File',$fn.'_parms.db',&GDBM_WRCREAT(),0640))) {      if ($lock) {
  %hash=();          if (tie(%hash,'GDBM_File',"$fn.db",&GDBM_WRCREAT(),0640)) {
  %parmhash=();              $tiedhash = 1;
  $errtext='';              if (tie(%parmhash,'GDBM_File',$fn.'_parms.db',&GDBM_WRCREAT(),0640)) {
  $pc=0;                  $tiedparmhash = 1;
  &clear_mapalias_count();                  $gotstate = &build_tmp_hashes($uri,$fn,$short,\%cenv);
  &processversionfile(%cenv);                  unless ($gotstate) {
  my $furi=&Apache::lonnet::clutter($uri);                      &Apache::lonnet::logthis('Failed to write statemap at first attempt '.$fn.' for '.$uri.'.</font>');
  $hash{'src_0.0'}=&versiontrack($furi);                  }
  $hash{'title_0.0'}=&Apache::lonnet::metadata($uri,'title');                  $untiedparmhash = untie(%parmhash);
  $hash{'ids_'.$furi}='0.0';                  unless ($untiedparmhash) {
  $hash{'is_map_0.0'}=1;                      &Apache::lonnet::logthis('<font color="blue">WARNING: '.
  loadmap($uri,'0.0');                          'Could not untie coursemap parmhash '.$fn.' for '.$uri.'.</font>');
  if (defined($hash{'map_start_'.$uri})) {                  }
     &Apache::lonnet::appenv("request.course.id"  => $short,              }
     "request.course.fn"  => $fn,              $untiedhash = untie(%hash);
     "request.course.uri" => $uri);              unless ($untiedhash) {
     $env{'request.course.id'}=$short;                  &Apache::lonnet::logthis('<font color="blue">WARNING: '.
     &traceroute('0',$hash{'map_start_'.$uri},'&');                      'Could not untie coursemap hash '.$fn.' for '.$uri.'.</font>');
     &accinit($uri,$short,$fn);              }
     &hiddenurls();          }
  }  
  $errtext .= &get_mapalias_errors();  
 # ------------------------------------------------------- Put versions into src  
  foreach my $key (keys(%hash)) {  
     if ($key=~/^src_/) {  
  $hash{$key}=&putinversion($hash{$key});  
     } elsif ($key =~ /^(map_(?:start|finish|pc)_)(.*)/) {  
  my ($type, $url) = ($1,$2);  
  my $value = $hash{$key};  
  $hash{$type.&putinversion($url)}=$value;  
     }  
  }  
 # ---------------------------------------------------------------- Encrypt URLs  
  foreach my $id (keys(%encurl)) {  
 #    $hash{'src_'.$id}=&Apache::lonenc::encrypted($hash{'src_'.$id});  
     $hash{'encrypted_'.$id}=1;  
  }  
 # ----------------------------------------------- Close hashes to finally store  
 # --------------------------------- Routine must pass this point, no early outs  
  $hash{'first_rid'}=$retfrid;  
  my ($mapid,$resid)=split(/\./,$retfrid);  
  $hash{'first_mapurl'}=$hash{'map_id_'.$mapid};  
  my $symb=&Apache::lonnet::encode_symb($hash{'map_id_'.$mapid},$resid,$hash{'src_'.$retfrid});  
  $retfurl=&add_get_param($hash{'src_'.$retfrid},{ 'symb' => $symb });  
  if ($hash{'encrypted_'.$retfrid}) {  
     $retfurl=&Apache::lonenc::encrypted($retfurl,(&Apache::lonnet::allowed('adv') ne 'F'));  
  }  
  $hash{'first_url'}=$retfurl;  
  unless ((untie(%hash)) && (untie(%parmhash))) {  
     &Apache::lonnet::logthis("<font color=blue>WARNING: ".  
      "Could not untie coursemap $fn for $uri.</font>");   
  }  
 # ---------------------------------------------------- Store away initial state  
  {  
     my $cfh;  
     if (open($cfh,">$fn.state")) {  
  print $cfh join("\n",@cond);  
     } else {  
  &Apache::lonnet::logthis("<font color=blue>WARNING: ".  
  "Could not write statemap $fn for $uri.</font>");   
     }  
  }  
  flock(LOCKFILE,LOCK_UN);   flock(LOCKFILE,LOCK_UN);
  close(LOCKFILE);   close(LOCKFILE);
     } else {      }
       unless ($lock && $tiedhash && $tiedparmhash) { 
  # if we are here it is likely because we are already trying to    # if we are here it is likely because we are already trying to 
  # initialize the course in another child, busy wait trying to    # initialize the course in another child, busy wait trying to 
  # tie the hashes for the next 90 seconds, if we succeed forward    # tie the hashes for the next 90 seconds, if we succeed forward 
Line 737  sub readmap { Line 696  sub readmap {
  if ($lock) {   if ($lock) {
     # Got the lock but not the DB files      # Got the lock but not the DB files
     flock(LOCKFILE,LOCK_UN);      flock(LOCKFILE,LOCK_UN);
               $lock = 0;
  }   }
  untie(%hash);          if ($tiedhash) {
  untie(%parmhash);              unless($untiedhash) {
           untie(%hash);
               }
           }
           if ($tiedparmhash) {
               unless($untiedparmhash) {
                   untie(%parmhash);
               }
           }
  &Apache::lonnet::logthis("<font color=blue>WARNING: ".   &Apache::lonnet::logthis("<font color=blue>WARNING: ".
  "Could not tie coursemap $fn for $uri.</font>");    "Could not tie coursemap $fn for $uri.</font>");
           $tiedhash = '';
           $tiedparmhash = '';
  my $i=0;   my $i=0;
  while($i<90) {   while($i<90) {
     $i++;      $i++;
     sleep(1);      sleep(1);
     if (flock(LOCKFILE,LOCK_EX|LOCK_NB) &&      if (flock(LOCKFILE,LOCK_EX|LOCK_NB)) {
  (tie(%hash,'GDBM_File',"$fn.db",&GDBM_READER(),0640))) {                  $lock = 1;
  if (tie(%parmhash,'GDBM_File',$fn.'_parms.db',&GDBM_READER(),0640)) {   if (tie(%hash,'GDBM_File',"$fn.db",&GDBM_READER(),0640)) {
     $retfurl='/adm/navmaps';                      $tiedhash = 1;
     &Apache::lonnet::appenv("request.course.id"  => $short,      if (tie(%parmhash,'GDBM_File',$fn.'_parms.db',&GDBM_READER(),0640)) {
     "request.course.fn"  => $fn,                          $tiedparmhash = 1;
     "request.course.uri" => $uri);                          if (-e "$fn.state") {
     untie(%hash);              $retfurl='/adm/navmaps';
     untie(%parmhash);              &Apache::lonnet::appenv({"request.course.id"  => $short,
     last;                 "request.course.fn"  => $fn,
  }               "request.course.uri" => $uri});
     }              $untiedhash = untie(%hash);
     untie(%hash);              $untiedparmhash = untie(%parmhash);
     untie(%parmhash);                              $gotstate = 1;
               last;
           }
                           $untiedparmhash = untie(%parmhash);
               }
               $untiedhash = untie(%hash);
                   }
               }
  }   }
  flock(LOCKFILE,LOCK_UN);          if ($lock) {
  close(LOCKFILE);              flock(LOCKFILE,LOCK_UN);
               if ($tiedparmhash) {
                   unless ($untiedparmhash) {
                       &Apache::lonnet::logthis('<font color="blue">WARNING: '.
                           'Could not untie coursemap parmhash '.$fn.' for '.$uri.'.</font>');
                   }
               }
               if ($tiedparmhash) {
                   unless ($untiedhash) {
                       &Apache::lonnet::logthis('<font color="blue">WARNING: '.
                           'Could not untie coursemap hash '.$fn.' for '.$uri.'.</font>');
                   }
               }
           }
       }
       unless ($gotstate) {
           &Apache::lonnet::logthis('<font color="blue">WARNING: '.
                        'Could not read statemap '.$fn.' for '.$uri.'.</font>');
           &unlink_tmpfiles($fn);
           if (open(LOCKFILE,">$fn.db.lock")) {
               my $lock=0;
               if (flock(LOCKFILE,LOCK_EX|LOCK_NB)) {
                   $lock=1;
                   &unlink_tmpfiles($fn);
               }
               undef %randompick;
               undef %hiddenurl;
               undef %encurl;
               $retfrid='';
               if ($lock) {
                   if (tie(%hash,'GDBM_File',"$fn.db",&GDBM_WRCREAT(),0640)) {
                       if (tie(%parmhash,'GDBM_File',$fn.'_parms.db',&GDBM_WRCREAT(),0640)) {
                           $gotstate = &build_tmp_hashes($uri,$fn,$short,\%cenv);
                           unless ($gotstate) {
                               &Apache::lonnet::logthis('<font color="blue">WARNING: '.
                                   'Failed to write statemap at second attempt '.$fn.' for '.$uri.'.</font>');
                           }
                           unless (untie(%parmhash)) {
                               &Apache::lonnet::logthis('<font color="blue">WARNING: '.
                                   'Could not untie coursemap parmhash '.$fn.'.db for '.$uri.'.</font>');
                           }
                       } else {
                           &Apache::lonnet::logthis('<font color="blue">WARNING: '.
                               'Could not tie coursemap '.$fn.'__parms.db for '.$uri.'.</font>');
                       }
                       unless (untie(%hash)) {
                           &Apache::lonnet::logthis('<font color="blue">WARNING: '.
                               'Could not untie coursemap hash '.$fn.'.db for '.$uri.'.</font>');
                       }
                  } else {
                      &Apache::lonnet::logthis('<font color="blue">WARNING: '.
                          'Could not tie coursemap '.$fn.'.db for '.$uri.'.</font>');
                  }
                  flock(LOCKFILE,LOCK_UN);
                  close(LOCKFILE);
               } else {
                   &Apache::lonnet::logthis('<font color="blue">WARNING: '.
                   'Could not obtain lock to tie coursemap hash '.$fn.'.db for '.$uri.'.</font>');
               }
       close(LOCKFILE);
           }
       }
       unless (($errtext eq '') || ($env{'request.course.uri'} =~ m{^/uploaded/})) {
           &Apache::lonmsg::author_res_msg($env{'request.course.uri'},
                                           $errtext);
     }      }
     &Apache::lonmsg::author_res_msg($env{'request.course.uri'},$errtext);  
 # ------------------------------------------------- Check for critical messages  # ------------------------------------------------- Check for critical messages
   
     my @what=&Apache::lonnet::dump('critical',$env{'user.domain'},      my @what=&Apache::lonnet::dump('critical',$env{'user.domain'},
Line 777  sub readmap { Line 817  sub readmap {
     return ($retfurl,$errtext);      return ($retfurl,$errtext);
 }  }
   
   sub build_tmp_hashes {
       my ($uri,$fn,$short,$cenvref) = @_;
       unless(ref($cenvref) eq 'HASH') {
           return;
       }
       my %cenv = %{$cenvref};
       my $gotstate = 0;
       %hash=();
       %parmhash=();
       $errtext='';
       $pc=0;
       &clear_mapalias_count();
       &processversionfile(%cenv);
       my $furi=&Apache::lonnet::clutter($uri);
       $hash{'src_0.0'}=&versiontrack($furi);
       $hash{'title_0.0'}=&Apache::lonnet::metadata($uri,'title');
       $hash{'ids_'.$furi}='0.0';
       $hash{'is_map_0.0'}=1;
       &loadmap($uri,'0.0');
       if (defined($hash{'map_start_'.$uri})) {
           &Apache::lonnet::appenv({"request.course.id"  => $short,
                                    "request.course.fn"  => $fn,
                                    "request.course.uri" => $uri});
           $env{'request.course.id'}=$short;
           &traceroute('0',$hash{'map_start_'.$uri},'&');
           &accinit($uri,$short,$fn);
           &hiddenurls();
       }
       $errtext .= &get_mapalias_errors();
   # ------------------------------------------------------- Put versions into src
       foreach my $key (keys(%hash)) {
           if ($key=~/^src_/) {
               $hash{$key}=&putinversion($hash{$key});
           } elsif ($key =~ /^(map_(?:start|finish|pc)_)(.*)/) {
               my ($type, $url) = ($1,$2);
               my $value = $hash{$key};
               $hash{$type.&putinversion($url)}=$value;
           }
       }
   # ---------------------------------------------------------------- Encrypt URLs
       foreach my $id (keys(%encurl)) {
   #           $hash{'src_'.$id}=&Apache::lonenc::encrypted($hash{'src_'.$id});
           $hash{'encrypted_'.$id}=1;
       }
   # ----------------------------------------------- Close hashes to finally store
   # --------------------------------- Routine must pass this point, no early outs
       $hash{'first_rid'}=$retfrid;
       my ($mapid,$resid)=split(/\./,$retfrid);
       $hash{'first_mapurl'}=$hash{'map_id_'.$mapid};
       my $symb=&Apache::lonnet::encode_symb($hash{'map_id_'.$mapid},$resid,$hash{'src_'.$retfrid});
       $retfurl=&add_get_param($hash{'src_'.$retfrid},{ 'symb' => $symb });
       if ($hash{'encrypted_'.$retfrid}) {
           $retfurl=&Apache::lonenc::encrypted($retfurl,(&Apache::lonnet::allowed('adv') ne 'F'));
       }
       $hash{'first_url'}=$retfurl;
   # ---------------------------------------------------- Store away initial state
       {
           my $cfh;
           if (open($cfh,">$fn.state")) {
               print $cfh join("\n",@cond);
               $gotstate = 1;
           } else {
               &Apache::lonnet::logthis("<font color=blue>WARNING: ".
                                        "Could not write statemap $fn for $uri.</font>");
           }
       }
       return $gotstate;
   }
   
   sub unlink_tmpfiles {
       my ($fn) = @_;
       if ($fn =~ m{^\Q$Apache::lonnet::perlvar{'lonUsersDir'}\E/tmp/}) {
           my @files = qw (.db _symb.db .state _parms.db);
           foreach my $file (@files) {
               if (-e $fn.$file) {
                   unless (unlink($fn.$file)) {
                       &Apache::lonnet::logthis("<font color=blue>WARNING: ".
                                    "Could not unlink ".$fn.$file."</font>");
                   }
               }
           }
       }
       return;
   }
   
 # ------------------------------------------------------- Evaluate state string  # ------------------------------------------------------- Evaluate state string
   
 sub evalstate {  sub evalstate {
Line 813  sub evalstate { Line 938  sub evalstate {
     }      }
  }   }
     }      }
     &Apache::lonnet::appenv('user.state.'.$env{'request.course.id'} => $state);      &Apache::lonnet::appenv({'user.state.'.$env{'request.course.id'} => $state});
     return $state;      return $state;
 }  }
   
Line 837  sub evalstate { Line 962  sub evalstate {
      $count++;       $count++;
  }   }
  my ($mapid) = split(/\./,$id);   my ($mapid) = split(/\./,$id);
                          &mt('[_1] in [_2]', $hash{'title_'.$id},                           &mt('Resource "[_1]" <br /> in Map "[_2]"',
        $hash{'title_'.$id},
      $hash{'title_'.$hash{'ids_'.$hash{'map_id_'.$mapid}}});       $hash{'title_'.$hash{'ids_'.$hash{'map_id_'.$mapid}}});
      } (@{ $mapalias_cache{$mapalias} }));       } (@{ $mapalias_cache{$mapalias} }));
     next if ($count < 2);      next if ($count < 2);
Line 876  of course for user. Line 1001  of course for user.
 This is part of the LearningOnline Network with CAPA project  This is part of the LearningOnline Network with CAPA project
 described at http://www.lon-capa.org.  described at http://www.lon-capa.org.
   
 =head1 HANDLER SUBROUTINE  =head1 SUBROUTINES
   
 There is no handler subroutine.  
   
 =head1 OTHER SUBROUTINES  
   
 =over 4  =over
   
 =item *  =item loadmap()
   
 loadmap() : Loads map from disk  Loads map from disk
   
 =item *  =item simplify()
   
 simplify() : Simplify expression  Simplify expression
   
 =item *  =item traceroute()
   
 traceroute() : Build condition hash  Build condition hash
   
 =item *  =item accinit()
   
 accinit() : Cascading conditions, quick access, parameters  Cascading conditions, quick access, parameters
   
 =item *  =item readmap()
   
 readmap() : Read map and all submaps  Read map and all submaps
   
 =item *  =item evalstate()
   
 evalstate() : Evaluate state string  Evaluate state string
   
 =back  =back
   
Removed from v.1.124  
changed lines
  Added in v.1.132

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>