[BACK]Return to lonnet.pm CVS log [TXT] [DIR] Up to [LON-CAPA] / loncom / lonnet / perl

Diff for /loncom/lonnet/perl/lonnet.pm between versions 1.130 and 1.147

version 1.130, 2001/07/26 18:15:39 version 1.147, 2001/08/09 19:28:47
Line 40 Line 40
 #                    : returns hash for this symb, all args are optional  #                    : returns hash for this symb, all args are optional
 #                      if they aren't given they will be derived from the   #                      if they aren't given they will be derived from the 
 #                      current enviroment  #                      current enviroment
 # eget(namesp,array) : returns hash with keys from array filled in from namesp  #
 # get(namesp,array)  : returns hash with keys from array filled in from namesp  #
 # del(namesp,array)  : deletes keys out of array from namesp  # for the next 6 functions udom and uname are optional
 # put(namesp,hash)   : stores hash in namesp  #         if supplied they use udom as the domain and uname
 # cput(namesp,hash)  : critical put  #         as the username for the function (supply a courseid
   #         for the uname if you want a course database)
   #         if not supplied it uses %ENV and looks at 
   #         user. attribute for the values
   #
   # eget(namesp,arrayref,udom,uname)
   #                    : returns hash with keys from array  reference filled
   #                      in from namesp (encrypts the return communication)
   # get(namesp,arrayref,udom,uname)
   #                    : returns hash with keys from array  reference filled
   #                      in from namesp
 # dump(namesp,udom,uname) : dumps the complete namespace into a hash  # dump(namesp,udom,uname) : dumps the complete namespace into a hash
 #                           if supplied uses udom as the domain and uname  # del(namesp,array,udom,uname)  : deletes keys out of array from namesp
 #                           as the username for the dump (supply a courseid  # put(namesp,hash,udom,uname)   : stores hash in namesp
 #                           for the uname if you want a course database)  # cput(namesp,hash,udom,uname)  : critical put
   #
   #
 # ssi(url,hash)      : does a complete request cycle on url to localhost, posts  # ssi(url,hash)      : does a complete request cycle on url to localhost, posts
 #                      hash  #                      hash
 # coursedescription(id) : returns and caches course description for id  # coursedescription(id) : returns and caches course description for id
Line 109 Line 121
 # 5/26,5/28 Gerd Kortemeyer  # 5/26,5/28 Gerd Kortemeyer
 # 5/30 H. K. Ng  # 5/30 H. K. Ng
 # 6/1 Gerd Kortemeyer  # 6/1 Gerd Kortemeyer
 #  # July Guy Albertelli
   # 8/4,8/7,8/8,8/9 Gerd Kortemeyer
   
 package Apache::lonnet;  package Apache::lonnet;
   
Line 118  use Apache::File; Line 131  use Apache::File;
 use LWP::UserAgent();  use LWP::UserAgent();
 use HTTP::Headers;  use HTTP::Headers;
 use vars   use vars 
 qw(%perlvar %hostname %homecache %spareid %hostdom %libserv %pr %prp %fe %fd $readit %metacache);  qw(%perlvar %hostname %homecache %spareid %hostdom %libserv %pr %prp %fe %fd $readit %metacache %packagetab);
 use IO::Socket;  use IO::Socket;
 use GDBM_File;  use GDBM_File;
 use Apache::Constants qw(:common :http);  use Apache::Constants qw(:common :http);
Line 671  sub devalidate { Line 684  sub devalidate {
     if ($cid) {      if ($cid) {
  my $key=$ENV{'user.name'}.':'.$ENV{'user.domain'}.':';   my $key=$ENV{'user.name'}.':'.$ENV{'user.domain'}.':';
         my $status=          my $status=
           &reply('del:'.$ENV{'course.'.$cid.'.domain'}.':'.      &del('nohist_calculatedsheet',
                         $ENV{'course.'.$cid.'.num'}.   [$key.'studentcalc'],
                 ':nohist_calculatedsheets:'.   $ENV{'course.'.$cid.'.domain'},
                         &escape($key.'studentcalc:'),   $ENV{'course.'.$cid.'.num'})
                         $ENV{'course.'.$cid.'.home'})   .' '.
           .' '.      &del('nohist_calculatedsheets_'.$cid,
           &reply('del:'.$ENV{'user.domain'}.':'.   [$key.'assesscalc:'.$symb]);
                         $ENV{'user.name'}.  
         ':nohist_calculatedsheets_'.$cid.':'.  
                         &escape($key.'assesscalc:'.$symb),  
                         $ENV{'user.home'});  
         unless ($status eq 'ok ok') {          unless ($status eq 'ok ok') {
            &logthis('Could not devalidate spreadsheet '.             &logthis('Could not devalidate spreadsheet '.
                     $ENV{'user.name'}.' at '.$ENV{'user.domain'}.' for '.                      $ENV{'user.name'}.' at '.$ENV{'user.domain'}.' for '.
     $symb.': '.$status);      $symb.': '.$status);
         }           }
     }      }
 }  }
   
Line 887  sub rolesinit { Line 896  sub rolesinit {
         my $author=0;          my $author=0;
         map {          map {
             %thesepriv=();              %thesepriv=();
             if ($_!~/^st/) { $adv=1; }              if (($_!~/^st/) && ($_!~/^ta/) && ($_!~/^cm/)) { $adv=1; }
             if (($_=~/^au/) || ($_=~/^ca/)) { $author=1; }              if (($_=~/^au/) || ($_=~/^ca/)) { $author=1; }
             map {              map {
                 if ($_ ne '') {                  if ($_ ne '') {
Line 915  sub rolesinit { Line 924  sub rolesinit {
 # --------------------------------------------------------------- get interface  # --------------------------------------------------------------- get interface
   
 sub get {  sub get {
    my ($namespace,@storearr)=@_;     my ($namespace,$storearr,$udomain,$uname)=@_;
    my $items='';     my $items='';
    map {     map {
        $items.=escape($_).'&';         $items.=escape($_).'&';
    } @storearr;     } @$storearr;
    $items=~s/\&$//;     $items=~s/\&$//;
  my $rep=reply("get:$ENV{'user.domain'}:$ENV{'user.name'}:$namespace:$items",     if (!$udomain) { $udomain=$ENV{'user.domain'}; }
                  $ENV{'user.home'});     if (!$uname) { $uname=$ENV{'user.name'}; }
      my $uhome=&homeserver($uname,$udomain);
   
      my $rep=&reply("get:$udomain:$uname:$namespace:$items",$uhome);
    my @pairs=split(/\&/,$rep);     my @pairs=split(/\&/,$rep);
    my %returnhash=();     my %returnhash=();
    my $i=0;     my $i=0;
    map {     map {
       $returnhash{$_}=unescape($pairs[$i]);        $returnhash{$_}=unescape($pairs[$i]);
       $i++;        $i++;
    } @storearr;     } @$storearr;
    return %returnhash;     return %returnhash;
 }  }
   
 # --------------------------------------------------------------- del interface  # --------------------------------------------------------------- del interface
   
 sub del {  sub del {
    my ($namespace,@storearr)=@_;     my ($namespace,$storearr,$udomain,$uname)=@_;
    my $items='';     my $items='';
    map {     map {
        $items.=escape($_).'&';         $items.=escape($_).'&';
    } @storearr;     } @$storearr;
    $items=~s/\&$//;     $items=~s/\&$//;
    return reply("del:$ENV{'user.domain'}:$ENV{'user.name'}:$namespace:$items",     if (!$udomain) { $udomain=$ENV{'user.domain'}; }
                  $ENV{'user.home'});     if (!$uname) { $uname=$ENV{'user.name'}; }
      my $uhome=&homeserver($uname,$udomain);
   
      return &reply("del:$udomain:$uname:$namespace:$items",$uhome);
 }  }
   
 # -------------------------------------------------------------- dump interface  # -------------------------------------------------------------- dump interface
Line 966  sub dump { Line 981  sub dump {
 # --------------------------------------------------------------- put interface  # --------------------------------------------------------------- put interface
   
 sub put {  sub put {
    my ($namespace,%storehash)=@_;     my ($namespace,$storehash,$udomain,$uname)=@_;
      if (!$udomain) { $udomain=$ENV{'user.domain'}; }
      if (!$uname) { $uname=$ENV{'user.name'}; }
      my $uhome=&homeserver($uname,$udomain);
    my $items='';     my $items='';
    map {     map {
        $items.=escape($_).'='.escape($storehash{$_}).'&';         $items.=&escape($_).'='.&escape($$storehash{$_}).'&';
    } keys %storehash;     } keys %$storehash;
    $items=~s/\&$//;     $items=~s/\&$//;
    return reply("put:$ENV{'user.domain'}:$ENV{'user.name'}:$namespace:$items",     return &reply("put:$udomain:$uname:$namespace:$items",$uhome);
                  $ENV{'user.home'});  
 }  }
   
 # ------------------------------------------------------ critical put interface  # ------------------------------------------------------ critical put interface
   
 sub cput {  sub cput {
    my ($namespace,%storehash)=@_;     my ($namespace,$storehash,$udomain,$uname)=@_;
      if (!$udomain) { $udomain=$ENV{'user.domain'}; }
      if (!$uname) { $uname=$ENV{'user.name'}; }
      my $uhome=&homeserver($uname,$udomain);
    my $items='';     my $items='';
    map {     map {
        $items.=escape($_).'='.escape($storehash{$_}).'&';         $items.=escape($_).'='.escape($$storehash{$_}).'&';
    } keys %storehash;     } keys %$storehash;
    $items=~s/\&$//;     $items=~s/\&$//;
    return critical     return &critical("put:$udomain:$uname:$namespace:$items",$uhome);
            ("put:$ENV{'user.domain'}:$ENV{'user.name'}:$namespace:$items",  
                  $ENV{'user.home'});  
 }  }
   
 # -------------------------------------------------------------- eget interface  # -------------------------------------------------------------- eget interface
   
 sub eget {  sub eget {
    my ($namespace,@storearr)=@_;     my ($namespace,$storearr,$udomain,$uname)=@_;
    my $items='';     my $items='';
    map {     map {
        $items.=escape($_).'&';         $items.=escape($_).'&';
    } @storearr;     } @$storearr;
    $items=~s/\&$//;     $items=~s/\&$//;
  my $rep=reply("eget:$ENV{'user.domain'}:$ENV{'user.name'}:$namespace:$items",     if (!$udomain) { $udomain=$ENV{'user.domain'}; }
                  $ENV{'user.home'});     if (!$uname) { $uname=$ENV{'user.name'}; }
      my $uhome=&homeserver($uname,$udomain);
      my $rep=&reply("eget:$udomain:$uname:$namespace:$items",$uhome);
    my @pairs=split(/\&/,$rep);     my @pairs=split(/\&/,$rep);
    my %returnhash=();     my %returnhash=();
    my $i=0;     my $i=0;
    map {     map {
       $returnhash{$_}=unescape($pairs[$i]);        $returnhash{$_}=unescape($pairs[$i]);
       $i++;        $i++;
    } @storearr;     } @$storearr;
    return %returnhash;     return %returnhash;
 }  }
   
Line 1416  sub modifyuser { Line 1436  sub modifyuser {
        }         }
     }      }
 # -------------------------------------------------------------- Add names, etc  # -------------------------------------------------------------- Add names, etc
     my $names=&reply('get:'.$udom.':'.$uname.      my %names=&get('environment',
                      ':environment:firstname&middlename&lastname&generation',     ['firstname','middlename','lastname','generation'],
                      $uhome);     $udom,$uname);
     my ($efirst,$emiddle,$elast,$egene)=split(/\&/,$names);      if ($first)  { $names{'firstname'}  = $first; }
     if ($first)  { $efirst  = &escape($first); }      if ($middle) { $names{'middlename'} = $middle; }
     if ($middle) { $emiddle = &escape($middle); }      if ($last)   { $names{'lastname'}   = $last; }
     if ($last)   { $elast   = &escape($last); }      if ($gene)   { $names{'generation'} = $gene; }
     if ($gene)   { $egene   = &escape($gene); }      my $reply = &put('environment', \%names, $udom,$uname);
     my $reply=&reply('put:'.$udom.':'.$uname.      if ($reply ne 'ok') { return 'error: '.$reply; }
            ':environment:firstname='.$efirst.  
                       '&middlename='.$emiddle.  
                         '&lastname='.$elast.  
                       '&generation='.$egene,$uhome);  
     if ($reply ne 'ok') {  
  return 'error: '.$reply;  
     }  
     &logthis('Success modifying user '.$udom.', '.$uname.', '.$uid.', '.      &logthis('Success modifying user '.$udom.', '.$uname.', '.$uid.', '.
              $umode.', '.$first.', '.$middle.', '.               $umode.', '.$first.', '.$middle.', '.
      $last.', '.$gene.' by '.       $last.', '.$gene.' by '.
              $ENV{'user.name'}.' at '.$ENV{'user.domain'});               $ENV{'user.name'}.' at '.$ENV{'user.domain'});
     return 'ok';       return 'ok';
 }  }
   
 # -------------------------------------------------------------- Modify student  # -------------------------------------------------------------- Modify student
Line 1661  sub condval { Line 1674  sub condval {
 # --------------------------------------------------------- Value of a Variable  # --------------------------------------------------------- Value of a Variable
   
 sub EXT {  sub EXT {
     my $varname=shift;      my ($varname,$symbparm)=@_;
     unless ($varname) { return ''; }      unless ($varname) { return ''; }
     my ($realm,$space,$qualifier,@therest)=split(/\./,$varname);      my ($realm,$space,$qualifier,@therest)=split(/\./,$varname);
     my $rest;      my $rest;
Line 1705  sub EXT { Line 1718  sub EXT {
 # ---------------------------------------------------- Any other user namespace  # ---------------------------------------------------- Any other user namespace
         } else {          } else {
             my $item=($rest)?$qualifier.'.'.$rest:$qualifier;              my $item=($rest)?$qualifier.'.'.$rest:$qualifier;
             my %reply=&get($space,$item);              my %reply=&get($space,[$item]);
             return $reply{$item};              return $reply{$item};
         }          }
     } elsif ($realm eq 'request') {      } elsif ($realm eq 'request') {
Line 1722  sub EXT { Line 1735  sub EXT {
                               $spacequalifierrest};                                $spacequalifierrest};
     } elsif ($realm eq 'resource') {      } elsif ($realm eq 'resource') {
        if ($ENV{'request.course.id'}) {         if ($ENV{'request.course.id'}) {
   
   #   print '<br>'.$space.' - '.$qualifier.' - '.$spacequalifierrest;
   
   
 # ----------------------------------------------------- Cascading lookup scheme  # ----------------------------------------------------- Cascading lookup scheme
          my $symbp=&symbread();           my $symbp;
            if ($symbparm) {
               $symbp=$symbparm;
    } else {
               $symbp=&symbread();
            }            
          my $mapp=(split(/\_\_\_/,$symbp))[0];           my $mapp=(split(/\_\_\_/,$symbp))[0];
   
          my $symbparm=$symbp.'.'.$spacequalifierrest;           my $symbparm=$symbp.'.'.$spacequalifierrest;
Line 1748  sub EXT { Line 1770  sub EXT {
   
 # ----------------------------------------------------------- first, check user  # ----------------------------------------------------------- first, check user
          my %resourcedata=get('resourcedata',           my %resourcedata=get('resourcedata',
                            ($courselevelr,$courselevelm,$courselevel));                             [$courselevelr,$courselevelm,$courselevel]);
          if (($resourcedata{$courselevelr}!~/^error\:/) &&           if (($resourcedata{$courselevelr}!~/^error\:/) &&
              ($resourcedata{$courselevelr}!~/^con_lost/)) {               ($resourcedata{$courselevelr}!~/^con_lost/)) {
   
Line 1811  sub EXT { Line 1833  sub EXT {
                                          'parameter_'.$spacequalifierrest);                                           'parameter_'.$spacequalifierrest);
       if ($metadata) { return $metadata; }        if ($metadata) { return $metadata; }
   
   # ------------------------------------------------------------------ Cascade up
   
         unless ($space eq '0') {
             my ($part,$id)=split(/\_/,$space);
             if ($id) {
         my $partgeneral=&EXT('resource.'.$part.'.'.$qualifierrest,
                                      $symbparm);
                 if ($partgeneral) { return $partgeneral; }
             } else {
                 my $resourcegeneral=&EXT('resource.0.'.$qualifierrest,
                                          $symbparm);
                 if ($resourcegeneral) { return $resourcegeneral; }
             }
         }
   
 # ---------------------------------------------------- Any other user namespace  # ---------------------------------------------------- Any other user namespace
     } elsif ($realm eq 'environment') {      } elsif ($realm eq 'environment') {
 # ----------------------------------------------------------------- environment  # ----------------------------------------------------------------- environment
Line 1833  sub metadata { Line 1870  sub metadata {
     my $filename=$uri;      my $filename=$uri;
     $uri=~s/\.meta$//;      $uri=~s/\.meta$//;
     unless ($metacache{$uri.':keys'}) {      unless ($metacache{$uri.':keys'}) {
           my %metathesekeys=();
         unless ($filename=~/\.meta$/) { $filename.='.meta'; }          unless ($filename=~/\.meta$/) { $filename.='.meta'; }
  my $metastring=&getfile($perlvar{'lonDocRoot'}.'/res/'.$filename);   my $metastring=&getfile($perlvar{'lonDocRoot'}.'/res/'.$filename);
         my $parser=HTML::TokeParser->new(\$metastring);          my $parser=HTML::TokeParser->new(\$metastring);
         my $token;          my $token;
           undef %metathesekeys;
         while ($token=$parser->get_token) {          while ($token=$parser->get_token) {
            if ($token->[0] eq 'S') {             if ($token->[0] eq 'S') {
        if (defined($token->[2]->{'package'})) {
         my $package=$token->[2]->{'package'};
         my $keyroot='';
                 if (defined($token->[2]->{'part'})) { 
                    $keyroot.='_'.$token->[2]->{'part'}; 
         }
                 if (defined($token->[2]->{'id'})) { 
                    $keyroot.='_'.$token->[2]->{'id'}; 
         }
                 if ($metacache{$uri.':packages'}) {
                    $metacache{$uri.':packages'}.=','.$package.$keyroot;
                 } else {
                    $metacache{$uri.':packages'}=$package.$keyroot;
         }
                 map {
     if ($_=~/^$package\&/) {
         my ($pack,$name,$subp)=split(/\&/,$_);
                         my $value=$packagetab{$_};
         my $part=$keyroot;
                         $part=~s/^\_//;
                         if ($subp eq 'display') {
     $value.=' [Part: '.$part.']';
                         }
                         my $unikey='parameter'.$keyroot.'_'.$name;
                         $metathesekeys{$unikey}=1;
                         $metacache{$uri.':'.$unikey.'.part'}=$part;
                         unless 
                          (defined($metacache{$uri.':'.$unikey.'.'.$subp})) {
                            $metacache{$uri.':'.$unikey.'.'.$subp}=$value;
         }
                     }
                 } keys %packagetab;
                } else {
       my $entry=$token->[1];        my $entry=$token->[1];
               my $unikey=$entry;                my $unikey=$entry;
               if (defined($token->[2]->{'part'})) {                 if (defined($token->[2]->{'part'})) { 
                  $unikey.='_'.$token->[2]->{'part'};                    $unikey.='_'.$token->[2]->{'part'}; 
       }        }
                 if (defined($token->[2]->{'id'})) { 
                    $unikey.='_'.$token->[2]->{'id'}; 
         }
               if (defined($token->[2]->{'name'})) {                 if (defined($token->[2]->{'name'})) { 
                  $unikey.='_'.$token->[2]->{'name'};                    $unikey.='_'.$token->[2]->{'name'}; 
       }        }
               if ($metacache{$uri.':keys'}) {                $metathesekeys{$unikey}=1;
                  $metacache{$uri.':keys'}.=','.$unikey;  
               } else {  
                  $metacache{$uri.':keys'}=$unikey;  
       }  
               map {                map {
   $metacache{$uri.':'.$unikey.'.'.$_}=$token->[2]->{$_};    $metacache{$uri.':'.$unikey.'.'.$_}=$token->[2]->{$_};
               } @{$token->[3]};                } @{$token->[3]};
Line 1860  sub metadata { Line 1931  sub metadata {
       ) { $metacache{$uri.':'.$unikey}=        ) { $metacache{$uri.':'.$unikey}=
       $metacache{$uri.':'.$unikey.'.default'};        $metacache{$uri.':'.$unikey.'.default'};
       }        }
           }      }
    }
        }         }
          $metacache{$uri.':keys'}=join(',',keys %metathesekeys);
     }      }
     return $metacache{$uri.':'.$what};      return $metacache{$uri.':'.$what};
 }  }
Line 2142  if ($readit ne 'done') { Line 2215  if ($readit ne 'done') {
     }      }
 }  }
   
   # ---------------------------------------------------------- Read package table
   {
       my $config=Apache::File->new("$perlvar{'lonTabDir'}/packages.tab");
   
       while (my $configline=<$config>) {
          chomp($configline);
          my ($short,$plain)=split(/:/,$configline);
          my ($pack,$name)=split(/\&/,$short);
          if ($plain ne '') {
             $packagetab{$pack.'&'.$name.'&name'}=$name; 
             $packagetab{$short}=$plain; 
          }
       }
   }
   
 # ------------------------------------------------------------- Read file types  # ------------------------------------------------------------- Read file types
 {  {
     my $config=Apache::File->new("$perlvar{'lonTabDir'}/filetypes.tab");      my $config=Apache::File->new("$perlvar{'lonTabDir'}/filetypes.tab");
Removed from v.1.130  
changed lines
  Added in v.1.147

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