[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.356 and 1.371

version 1.356, 2003/03/28 21:20:16 version 1.371, 2003/05/08 22:07:28
Line 347  sub delenv { Line 347  sub delenv {
     return 'ok';      return 'ok';
 }  }
   
   # ------------------------------------------ Find out current server userload
   # there is a copy in lond
   sub userload {
       my $numusers=0;
       {
    opendir(LONIDS,$perlvar{'lonIDsDir'});
    my $filename;
    my $curtime=time;
    while ($filename=readdir(LONIDS)) {
       if ($filename eq '.' || $filename eq '..') {next;}
       my ($atime)=(stat($perlvar{'lonIDsDir'}.'/'.$filename))[8];
       if ($curtime-$atime < 3600) { $numusers++; }
    }
    closedir(LONIDS);
       }
       my $userloadpercent=0;
       my $maxuserload=$perlvar{'lonUserLoadLim'};
       if ($maxuserload) {
    $userloadpercent=100*$numusers/$maxuserload;
       }
       return $userloadpercent;
   }
   
 # ------------------------------------------ Fight off request when overloaded  # ------------------------------------------ Fight off request when overloaded
   
 sub overloaderror {  sub overloaderror {
Line 373  sub overloaderror { Line 396  sub overloaderror {
 # ------------------------------ Find server with least workload from spare.tab  # ------------------------------ Find server with least workload from spare.tab
   
 sub spareserver {  sub spareserver {
     my $loadpercent = shift;      my ($loadpercent,$userloadpercent) = @_;
     my $tryserver;      my $tryserver;
     my $spareserver='';      my $spareserver='';
     my $lowestserver=$loadpercent;       if ($userloadpercent !~ /\d/) { $userloadpercent=0; }
       my $lowestserver=$loadpercent > $userloadpercent?
                $loadpercent :  $userloadpercent;
     foreach $tryserver (keys %spareid) {      foreach $tryserver (keys %spareid) {
        my $answer=reply('load',$tryserver);         my $loadans=reply('load',$tryserver);
          my $userloadans=reply('userload',$tryserver);
          if ($userloadans !~ /\d/) { $userloadans=0; }
          my $answer=$loadans > $userloadans?
                     $loadans :  $userloadans;
        if (($answer =~ /\d/) && ($answer<$lowestserver)) {         if (($answer =~ /\d/) && ($answer<$lowestserver)) {
    $spareserver="http://$hostname{$tryserver}";     $spareserver="http://$hostname{$tryserver}";
            $lowestserver=$answer;             $lowestserver=$answer;
        }         }
     }          }
     return $spareserver;      return $spareserver;
 }  }
   
Line 591  sub idput { Line 620  sub idput {
 # --------------------------------------------------- Assign a key to a student  # --------------------------------------------------- Assign a key to a student
   
 sub assign_access_key {  sub assign_access_key {
     my ($ckey,$cdom,$cnum,$udom,$uname)=@_;  #
   # a valid key looks like uname:udom#comments
   # comments are being appended
   #
       my ($ckey,$cdom,$cnum,$udom,$uname,$logentry)=@_;
     $cdom=      $cdom=
    $ENV{'course.'.$ENV{'request.course.id'}.'.domain'} unless (defined($cdom));     $ENV{'course.'.$ENV{'request.course.id'}.'.domain'} unless (defined($cdom));
     $cnum=      $cnum=
Line 599  sub assign_access_key { Line 632  sub assign_access_key {
     $udom=$ENV{'user.name'} unless (defined($udom));      $udom=$ENV{'user.name'} unless (defined($udom));
     $uname=$ENV{'user.domain'} unless (defined($uname));      $uname=$ENV{'user.domain'} unless (defined($uname));
     my %existing=&get('accesskeys',[$ckey],$cdom,$cnum);      my %existing=&get('accesskeys',[$ckey],$cdom,$cnum);
     if (($existing{$ckey}=~/^\d+$/) || # has time - new key      if (($existing{$ckey}=~/^\#(.*)$/) || # - new key
         ($existing{$ckey} eq $uname.':'.$udom)) { # this should not happen,          ($existing{$ckey}=~/^$uname\:$udom\#(.*)$/)) { 
                                                     # assigned to this person
                                                     # - this should not happen,
                                                   # unless something went wrong                                                    # unless something went wrong
                                                   # the first time around                                                    # the first time around
 # ready to assign  # ready to assign
     } elsif (!$existing{$ckey}) {          $logentry=$1.'; '.$logentry;
         if (&put('accesskey',{$ckey=>$uname.':'.$udom},$cdom,$cnum) eq 'ok') {          if (&put('accesskey',{$ckey=>$uname.':'.$udom.'#'.$logentry},
                                                    $cdom,$cnum) eq 'ok') {
 # key now belongs to user  # key now belongs to user
     my $envkey='key.'.$cdom.'_'.$cnum;      my $envkey='key.'.$cdom.'_'.$cnum;
             if (&put('environment',{$envkey => $ckey}) eq 'ok') {              if (&put('environment',{$envkey => $ckey}) eq 'ok') {
Line 618  sub assign_access_key { Line 654  sub assign_access_key {
         } else {          } else {
             return 'error: Could not assign key, try again later.';              return 'error: Could not assign key, try again later.';
         }          }
       } elsif (!$existing{$ckey}) {
 # the key does not exist  # the key does not exist
  return 'error: The key does not exist';   return 'error: The key does not exist';
     } else {      } else {
Line 626  sub assign_access_key { Line 663  sub assign_access_key {
     }      }
 }  }
   
   # ------------------------------------------ put an additional comment on a key
   
   sub comment_access_key {
   #
   # a valid key looks like uname:udom#comments
   # comments are being appended
   #
       my ($ckey,$cdom,$cnum,$logentry)=@_;
       $cdom=
      $ENV{'course.'.$ENV{'request.course.id'}.'.domain'} unless (defined($cdom));
       $cnum=
      $ENV{'course.'.$ENV{'request.course.id'}.'.num'} unless (defined($cnum));
       my %existing=&get('accesskeys',[$ckey],$cdom,$cnum);
       if ($existing{$ckey}) {
           $existing{$ckey}.='; '.$logentry;
   # ready to assign
           if (&put('accesskeys',{$ckey=>$existing{$ckey}},
                                                    $cdom,$cnum) eq 'ok') {
       return 'ok';
           } else {
       return 'error: Count not store comment.';
           }
       } else {
   # the key does not exist
    return 'error: The key does not exist';
       }
   }
   
 # ------------------------------------------------------ Generate a set of keys  # ------------------------------------------------------ Generate a set of keys
   
 sub generate_access_keys {  sub generate_access_keys {
     my ($number,$cdom,$cnum)=@_;      my ($number,$cdom,$cnum,$logentry)=@_;
     $cdom=      $cdom=
    $ENV{'course.'.$ENV{'request.course.id'}.'.domain'} unless (defined($cdom));     $ENV{'course.'.$ENV{'request.course.id'}.'.domain'} unless (defined($cdom));
     $cnum=      $cnum=
    $ENV{'course.'.$ENV{'request.course.id'}.'.num'} unless (defined($cnum));     $ENV{'course.'.$ENV{'request.course.id'}.'.num'} unless (defined($cnum));
     unless (&allowed('ccc',$cdom)) { return 0; }      unless (&allowed('mky',$cdom)) { return 0; }
     unless (($cdom) && ($cnum)) { return 0; }      unless (($cdom) && ($cnum)) { return 0; }
     if ($number>10000) { return 0; }      if ($number>10000) { return 0; }
     sleep(2); # make sure don't get same seed twice      sleep(2); # make sure don't get same seed twice
Line 650  sub generate_access_keys { Line 715  sub generate_access_keys {
        if ($existing{$newkey}) {         if ($existing{$newkey}) {
            $i--;             $i--;
        } else {         } else {
   if (&put('accesskeys',{ $newkey => time() },$cdom,$cnum) eq 'ok') {    if (&put('accesskeys',
                 { $newkey => '# generated '.localtime().
                              ' by '.$ENV{'user.name'}.'@'.$ENV{'user.domain'}.
                              '; '.$logentry },
      $cdom,$cnum) eq 'ok') {
               $total++;                $total++;
   }    }
        }         }
Line 671  sub validate_access_key { Line 740  sub validate_access_key {
     $udom=$ENV{'user.name'} unless (defined($udom));      $udom=$ENV{'user.name'} unless (defined($udom));
     $uname=$ENV{'user.domain'} unless (defined($uname));      $uname=$ENV{'user.domain'} unless (defined($uname));
     my %existing=&get('accesskeys',[$ckey],$cdom,$cnum);      my %existing=&get('accesskeys',[$ckey],$cdom,$cnum);
     return ($existing{$ckey} eq $uname.':'.$udom);      return ($existing{$ckey}=~/^$uname\:$udom\#/);
 }  }
   
 # ------------------------------------- Find the section of student in a course  # ------------------------------------- Find the section of student in a course
Line 1149  sub countacc { Line 1218  sub countacc {
     }      }
 }  }
   
   sub linklog {
       my ($from,$to)=@_;
       $from=&declutter($from);
       $to=&declutter($to);
       $accesshash{$from.'___'.$to.'___comefrom'}=1;
       $accesshash{$to.'___'.$from.'___goto'}=1;
   }
     
 sub userrolelog {  sub userrolelog {
     my ($trole,$username,$domain,$area,$tstart,$tend)=@_;      my ($trole,$username,$domain,$area,$tstart,$tend)=@_;
     if (($trole=~/^ca/) || ($trole=~/^in/) ||       if (($trole=~/^ca/) || ($trole=~/^in/) || 
Line 2550  sub plaintext { Line 2627  sub plaintext {
 # ----------------------------------------------------------------- Assign Role  # ----------------------------------------------------------------- Assign Role
   
 sub assignrole {  sub assignrole {
     my ($udom,$uname,$url,$role,$end,$start)=@_;      my ($udom,$uname,$url,$role,$end,$start,$deleteflag)=@_;
     my $mrole;      my $mrole;
     if ($role =~ /^cr\//) {      if ($role =~ /^cr\//) {
  unless (&allowed('ccr',$url)) {   unless (&allowed('ccr',$url)) {
Line 2581  sub assignrole { Line 2658  sub assignrole {
            $command.='_0_'.$start;             $command.='_0_'.$start;
         }          }
     }      }
   # actually delete
       if ($deleteflag) {
    if (&allowed('dro',$udom)) {
   # modify command to delete the role
              $command="encrypt:rolesdel:$ENV{'user.domain'}:$ENV{'user.name'}:".
                   "$udom:$uname:$url".'_'."$mrole";
   # set start and finish to negative values for userrolelog
              $start=-1;
              $end=-1;
           }
       }
   # send command
     my $answer=&reply($command,&homeserver($uname,$udom));      my $answer=&reply($command,&homeserver($uname,$udom));
   # log new user role if status is ok
     if ($answer eq 'ok') {      if ($answer eq 'ok') {
  &userrolelog($mrole,$uname,$udom,$url,$start,$end);   &userrolelog($mrole,$uname,$udom,$url,$start,$end);
     }      }
Line 2831  sub createcourse { Line 2921  sub createcourse {
  return 'error: no such course';   return 'error: no such course';
     }      }
 # ----------------------------------------------------------------- Course made  # ----------------------------------------------------------------- Course made
   # log existance
       &courseidput($udom,&escape($udom.'_'.$uname).'='.&escape($description),
                    $uhome);
       &flushcourselogs();
   # set toplevel url
     my $topurl=$url;      my $topurl=$url;
     unless ($nonstandard) {      unless ($nonstandard) {
 # ------------------------------------------ For standard courses, make top url  # ------------------------------------------ For standard courses, make top url
Line 2859  ENDINITMAP Line 2954  ENDINITMAP
 # ---------------------------------------------------------- Assign Custom Role  # ---------------------------------------------------------- Assign Custom Role
   
 sub assigncustomrole {  sub assigncustomrole {
     my ($udom,$uname,$url,$rdom,$rnam,$rolename,$end,$start)=@_;      my ($udom,$uname,$url,$rdom,$rnam,$rolename,$end,$start,$deleteflag)=@_;
     return &assignrole($udom,$uname,$url,'cr/'.$rdom.'/'.$rnam.'/'.$rolename,      return &assignrole($udom,$uname,$url,'cr/'.$rdom.'/'.$rnam.'/'.$rolename,
                        $end,$start);                         $end,$start,$deleteflag);
 }  }
   
 # ----------------------------------------------------------------- Revoke Role  # ----------------------------------------------------------------- Revoke Role
   
 sub revokerole {  sub revokerole {
     my ($udom,$uname,$url,$role)=@_;      my ($udom,$uname,$url,$role,$deleteflag)=@_;
     my $now=time;      my $now=time;
     return &assignrole($udom,$uname,$url,$role,$now);      return &assignrole($udom,$uname,$url,$role,$now,$deleteflag);
 }  }
   
 # ---------------------------------------------------------- Revoke Custom Role  # ---------------------------------------------------------- Revoke Custom Role
   
 sub revokecustomrole {  sub revokecustomrole {
     my ($udom,$uname,$url,$rdom,$rnam,$rolename)=@_;      my ($udom,$uname,$url,$rdom,$rnam,$rolename,$deleteflag)=@_;
     my $now=time;      my $now=time;
     return &assigncustomrole($udom,$uname,$url,$rdom,$rnam,$rolename,$now);      return &assigncustomrole($udom,$uname,$url,$rdom,$rnam,$rolename,$now,
              $deleteflag);
 }  }
   
 # ------------------------------------------------------------ Directory lister  # ------------------------------------------------------------ Directory lister
Line 3075  sub EXT { Line 3171  sub EXT {
     unless ($varname) { return ''; }      unless ($varname) { return ''; }
     #get real user name/domain, courseid and symb      #get real user name/domain, courseid and symb
     my $courseid;      my $courseid;
       my $publicuser;
     if (!($uname && $udom)) {      if (!($uname && $udom)) {
       (my $cursymb,$courseid,$udom,$uname)=&Apache::lonxml::whichuser();        (my $cursymb,$courseid,$udom,$uname,$publicuser)=
     &Apache::lonxml::whichuser();
       if (!$symbparm) { $symbparm=$cursymb; }        if (!$symbparm) { $symbparm=$cursymb; }
     } else {      } else {
  $courseid=$ENV{'request.course.id'};   $courseid=$ENV{'request.course.id'};
Line 3099  sub EXT { Line 3197  sub EXT {
     if (defined($Apache::lonhomework::parsing_a_problem)) {      if (defined($Apache::lonhomework::parsing_a_problem)) {
  return $Apache::lonhomework::history{$qualifierrest};   return $Apache::lonhomework::history{$qualifierrest};
     } else {      } else {
  my %restored=&restore($symbparm,$courseid,$udom,$uname);   my %restored;
    if ($publicuser || $ENV{'request.state'} eq 'construct') {
       %restored=&tmprestore($symbparm,$courseid,$udom,$uname);
    } else {
       %restored=&restore($symbparm,$courseid,$udom,$uname);
    }
  return $restored{$qualifierrest};   return $restored{$qualifierrest};
     }      }
 # ----------------------------------------------------------------- user.access  # ----------------------------------------------------------------- user.access
Line 3112  sub EXT { Line 3215  sub EXT {
  ($udom eq $ENV{'user.domain'})) {   ($udom eq $ENV{'user.domain'})) {
  return $ENV{join('.',('environment',$qualifierrest))};   return $ENV{join('.',('environment',$qualifierrest))};
     } else {      } else {
  my %returnhash=&userenvironment($udom,$uname,$qualifierrest);   my %returnhash;
    if (!$publicuser) {
       %returnhash=&userenvironment($udom,$uname,
    $qualifierrest);
    }
  return $returnhash{$qualifierrest};   return $returnhash{$qualifierrest};
     }      }
 # ----------------------------------------------------------------- user.course  # ----------------------------------------------------------------- user.course
Line 3136  sub EXT { Line 3243  sub EXT {
             return $uname;              return $uname;
 # ---------------------------------------------------- Any other user namespace  # ---------------------------------------------------- Any other user namespace
         } else {          } else {
             my %reply=&get($space,[$qualifierrest],$udom,$uname);      my %reply;
             return $reply{$qualifierrest};      if (!$publicuser) {
    %reply=&get($space,[$qualifierrest],$udom,$uname);
       }
       return $reply{$qualifierrest};
         }          }
     } elsif ($realm eq 'query') {      } elsif ($realm eq 'query') {
 # ---------------------------------------------- pull stuff out of query string  # ---------------------------------------------- pull stuff out of query string
Line 3156  sub EXT { Line 3266  sub EXT {
         return $ENV{'course.'.$courseid.'.'.$spacequalifierrest};          return $ENV{'course.'.$courseid.'.'.$spacequalifierrest};
     } elsif ($realm eq 'resource') {      } elsif ($realm eq 'resource') {
   
  if ($courseid eq $ENV{'request.course.id'}) {   if (defined($courseid) && $courseid eq $ENV{'request.course.id'}) {
   
     #print '<br>'.$space.' - '.$qualifier.' - '.$spacequalifierrest;      #print '<br>'.$space.' - '.$qualifier.' - '.$spacequalifierrest;
   
Line 3330  sub metadata { Line 3440  sub metadata {
         my $parser=HTML::LCParser->new(\$metastring);          my $parser=HTML::LCParser->new(\$metastring);
         my $token;          my $token;
         undef %metathesekeys;          undef %metathesekeys;
    delete($metacache{$uri.':packages'});
         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'})) {   if (defined($token->[2]->{'package'})) {
Line 3505  sub gettitle { Line 3616  sub gettitle {
         $title=$bighash{'title_'.$mapid.'.'.$resid};          $title=$bighash{'title_'.$mapid.'.'.$resid};
         untie %bighash;          untie %bighash;
     }      }
       $title=~s/\&colon\;/\:/gs;
     if ($title) {      if ($title) {
         $titlecache{$symb}=$title;          $titlecache{$symb}=$title;
         return $title;          return $title;
Line 3678  sub numval { Line 3790  sub numval {
     $txt=~tr/u-z/0-5/;      $txt=~tr/u-z/0-5/;
     $txt=~s/\D//g;      $txt=~s/\D//g;
     return int($txt);      return int($txt);
 }      }
   
   sub latest_rnd_algorithm_id {
       return '64bit';
   }
   
 sub rndseed {  sub rndseed {
     my ($symb,$courseid,$domain,$username)=@_;      my ($symb,$courseid,$domain,$username)=@_;
   
       my ($wsymb,$wcourseid,$wdomain,$wusername)=&Apache::lonxml::whichuser();
     if (!$symb) {      if (!$symb) {
       unless ($symb=&symbread()) { return time; }   unless ($symb=$wsymb) { return time; }
       }
       if (!$courseid) { $courseid=$wcourseid; }
       if (!$domain) { $domain=$wdomain; }
       if (!$username) { $username=$wusername }
       my $which=$ENV{"course.$courseid.rndseed"};
       my $CODE=$ENV{'scantron.CODE'};
       if (defined($CODE)) {
    &rndseed_CODE_64bit($symb,$courseid,$domain,$username);
       } elsif ($which eq '64bit') {
    return &rndseed_64bit($symb,$courseid,$domain,$username);
       }
       return &rndseed_32bit($symb,$courseid,$domain,$username);
   }
   
   sub rndseed_32bit {
       my ($symb,$courseid,$domain,$username)=@_;
       {
    use integer;
    my $symbchck=unpack("%32C*",$symb) << 27;
    my $symbseed=numval($symb) << 22;
    my $namechck=unpack("%32C*",$username) << 17;
    my $nameseed=numval($username) << 12;
    my $domainseed=unpack("%32C*",$domain) << 7;
    my $courseseed=unpack("%32C*",$courseid);
    my $num=$symbseed+$nameseed+$domainseed+$courseseed+$namechck+$symbchck;
    #&Apache::lonxml::debug("$symbseed:$nameseed;$domainseed|$courseseed;$namechck:$symbchck");
    #&Apache::lonxml::debug("rndseed :$num:$symb");
    return $num;
     }      }
     if (!$courseid) { $courseid=$ENV{'request.course.id'};}  }
     if (!$domain) {$domain=$ENV{'user.domain'};}  
     if (!$username) {$username=$ENV{'user.name'};}  sub rndseed_64bit {
       my ($symb,$courseid,$domain,$username)=@_;
     {      {
       use integer;   use integer;
       my $symbchck=unpack("%32C*",$symb) << 27;   my $symbchck=unpack("%32S*",$symb) << 21;
       my $symbseed=numval($symb) << 22;   my $symbseed=numval($symb) << 10;
       my $namechck=unpack("%32C*",$username) << 17;   my $namechck=unpack("%32S*",$username);
       my $nameseed=numval($username) << 12;  
       my $domainseed=unpack("%32C*",$domain) << 7;   my $nameseed=numval($username) << 21;
       my $courseseed=unpack("%32C*",$courseid);   my $domainseed=unpack("%32S*",$domain) << 10;
       my $num=$symbseed+$nameseed+$domainseed+$courseseed+$namechck+$symbchck;   my $courseseed=unpack("%32S*",$courseid);
       #uncommenting these lines can break things!  
       #&Apache::lonxml::debug("$symbseed:$nameseed;$domainseed|$courseseed;$namechck:$symbchck");   my $num1=$symbchck+$symbseed+$namechck;
       #&Apache::lonxml::debug("rndseed :$num:$symb");   my $num2=$nameseed+$domainseed+$courseseed;
       return $num;   #&Apache::lonxml::debug("$symbseed:$nameseed;$domainseed|$courseseed;$namechck:$symbchck");
    #&Apache::lonxml::debug("rndseed :$num:$symb");
    return "$num1,$num2";
       }
   }
   
   sub rndseed_CODE_64bit {
       my ($symb,$courseid,$domain,$username)=@_;
       {
    use integer;
    my $symbchck=unpack("%32S*",$symb) << 16;
    my $symbseed=numval($symb);
    my $CODEseed=numval($ENV{'scantron.CODE'}) << 16;
    my $courseseed=unpack("%32S*",$courseid);
    my $num1=$symbseed+$CODEseed;
    my $num2=$courseseed+$symbchck;
    #&Apache::lonxml::debug("$symbseed:$CODEseed|$courseseed:$symbchck");
    #&Apache::lonxml::debug("rndseed :$num1:$num2:$symb");
    return "$num1,$num2";
       }
   }
   
   sub setup_random_from_rndseed {
       my ($rndseed)=@_;
       if ($rndseed =~/,/) {
    my ($num1,$num2)=split(/,/,$rndseed);
    &Math::Random::random_set_seed(abs($num1),abs($num2));
       } else {
    &Math::Random::random_set_seed_from_phrase($rndseed);
     }      }
 }  }
   
Line 3826  sub goodbye { Line 4001  sub goodbye {
    &logthis("Starting Shut down");     &logthis("Starting Shut down");
    &flushcourselogs();     &flushcourselogs();
    &logthis("Shutting down");     &logthis("Shutting down");
      return DONE;
 }  }
   
 BEGIN {  BEGIN {
Removed from v.1.356  
changed lines
  Added in v.1.371

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