|
version 1.1288, 2015/06/12 21:11:20
|
version 1.1303, 2016/03/04 21:43:33
|
|
Line 92 use GDBM_File;
|
Line 92 use GDBM_File;
|
| use HTML::LCParser; |
use HTML::LCParser; |
| use Fcntl qw(:flock); |
use Fcntl qw(:flock); |
| use Storable qw(thaw nfreeze); |
use Storable qw(thaw nfreeze); |
| use Time::HiRes qw( gettimeofday tv_interval ); |
use Time::HiRes qw( sleep gettimeofday tv_interval ); |
| use Cache::Memcached; |
use Cache::Memcached; |
| use Digest::MD5; |
use Digest::MD5; |
| use Math::Random; |
use Math::Random; |
|
Line 101 use LONCAPA qw(:DEFAULT :match);
|
Line 101 use LONCAPA qw(:DEFAULT :match);
|
| use LONCAPA::Configuration; |
use LONCAPA::Configuration; |
| use LONCAPA::lonmetadata; |
use LONCAPA::lonmetadata; |
| use LONCAPA::Lond; |
use LONCAPA::Lond; |
| use Time::HiRes qw(sleep); |
|
| |
|
| use File::Copy; |
use File::Copy; |
| |
|
|
Line 376 sub subreply {
|
Line 375 sub subreply {
|
| |
|
| my $lockfile=$peerfile.".lock"; |
my $lockfile=$peerfile.".lock"; |
| while (-e $lockfile) { # Need to wait for the lockfile to disappear. |
while (-e $lockfile) { # Need to wait for the lockfile to disappear. |
| Time::HiRes::sleep(0.1); |
sleep(0.1); |
| } |
} |
| # At this point, either a loncnew parent is listening or an old lonc |
# At this point, either a loncnew parent is listening or an old lonc |
| # or loncnew child is listening so we can connect or everything's dead. |
# or loncnew child is listening so we can connect or everything's dead. |
|
Line 394 sub subreply {
|
Line 393 sub subreply {
|
| } else { |
} else { |
| &create_connection(&hostname($server),$server); |
&create_connection(&hostname($server),$server); |
| } |
} |
| Time::HiRes::sleep(0.1); # Try again later if failed connection. |
sleep(0.1); # Try again later if failed connection. |
| } |
} |
| my $answer; |
my $answer; |
| if ($client) { |
if ($client) { |
|
Line 423 sub reply {
|
Line 422 sub reply {
|
| |
|
| sub reconlonc { |
sub reconlonc { |
| my ($lonid) = @_; |
my ($lonid) = @_; |
| my $hostname = &hostname($lonid); |
|
| if ($lonid) { |
if ($lonid) { |
| |
my $hostname = &hostname($lonid); |
| my $peerfile="$perlvar{'lonSockDir'}/$hostname"; |
my $peerfile="$perlvar{'lonSockDir'}/$hostname"; |
| if ($hostname && -e $peerfile) { |
if ($hostname && -e $peerfile) { |
| &logthis("Trying to reconnect lonc for $lonid ($hostname)"); |
&logthis("Trying to reconnect lonc for $lonid ($hostname)"); |
|
Line 449 sub reconlonc {
|
Line 448 sub reconlonc {
|
| &logthis("lonc at pid $loncpid responding, sending USR1"); |
&logthis("lonc at pid $loncpid responding, sending USR1"); |
| kill USR1 => $loncpid; |
kill USR1 => $loncpid; |
| sleep 1; |
sleep 1; |
| } else { |
} else { |
| &logthis( |
&logthis( |
| "<font color=\"blue\">WARNING:". |
"<font color=\"blue\">WARNING:". |
| " lonc at pid $loncpid not responding, giving up</font>"); |
" lonc at pid $loncpid not responding, giving up</font>"); |
|
Line 470 sub critical {
|
Line 469 sub critical {
|
| } |
} |
| my $answer=reply($cmd,$server); |
my $answer=reply($cmd,$server); |
| if ($answer eq 'con_lost') { |
if ($answer eq 'con_lost') { |
| &reconlonc("$perlvar{'lonSockDir'}/$server"); |
&reconlonc($server); |
| my $answer=reply($cmd,$server); |
my $answer=reply($cmd,$server); |
| if ($answer eq 'con_lost') { |
if ($answer eq 'con_lost') { |
| my $now=time; |
my $now=time; |
|
Line 1552 sub homeserver {
|
Line 1551 sub homeserver {
|
| return 'no_host'; |
return 'no_host'; |
| } |
} |
| |
|
| # ------------------------------------- Find the usernames behind a list of IDs |
# ----- Find the usernames behind a list of student/employee IDs or clicker IDs |
| |
|
| sub idget { |
sub idget { |
| my ($udom,@ids)=@_; |
my ($udom,$idsref,$namespace)=@_; |
| my %returnhash=(); |
my %returnhash=(); |
| |
my @ids=(); |
| |
if (ref($idsref) eq 'ARRAY') { |
| |
@ids = @{$idsref}; |
| |
} else { |
| |
return %returnhash; |
| |
} |
| |
if ($namespace eq '') { |
| |
$namespace = 'ids'; |
| |
} |
| |
|
| my %servers = &get_servers($udom,'library'); |
my %servers = &get_servers($udom,'library'); |
| foreach my $tryserver (keys(%servers)) { |
foreach my $tryserver (keys(%servers)) { |
| my $idlist=join('&',@ids); |
my $idlist=join('&', map { &escape($_); } @ids); |
| $idlist=~tr/A-Z/a-z/; |
if ($namespace eq 'ids') { |
| my $reply=&reply("idget:$udom:".$idlist,$tryserver); |
$idlist=~tr/A-Z/a-z/; |
| |
} |
| |
my $reply; |
| |
if ($namespace eq 'ids') { |
| |
$reply=&reply("idget:$udom:".$idlist,$tryserver); |
| |
} else { |
| |
$reply=&reply("getdom:$udom:$namespace:$idlist",$tryserver); |
| |
} |
| my @answer=(); |
my @answer=(); |
| if (($reply ne 'con_lost') && ($reply!~/^error\:/)) { |
if (($reply ne 'con_lost') && ($reply!~/^error\:/)) { |
| @answer=split(/\&/,$reply); |
@answer=split(/\&/,$reply); |
|
Line 1570 sub idget {
|
Line 1585 sub idget {
|
| my $i; |
my $i; |
| for ($i=0;$i<=$#ids;$i++) { |
for ($i=0;$i<=$#ids;$i++) { |
| if ($answer[$i]) { |
if ($answer[$i]) { |
| $returnhash{$ids[$i]}=$answer[$i]; |
$returnhash{$ids[$i]}=&unescape($answer[$i]); |
| } |
} |
| } |
} |
| } |
} |
| return %returnhash; |
return %returnhash; |
| } |
} |
| |
|
|
Line 1588 sub idrget {
|
Line 1603 sub idrget {
|
| return %returnhash; |
return %returnhash; |
| } |
} |
| |
|
| # ------------------------------- Store away a list of names and associated IDs |
# Store away a list of names and associated student/employee IDs or clicker IDs |
| |
|
| sub idput { |
sub idput { |
| my ($udom,%ids)=@_; |
my ($udom,$idsref,$uhom,$namespace)=@_; |
| my %servers=(); |
my %servers=(); |
| |
my %ids=(); |
| |
my %byid = (); |
| |
if (ref($idsref) eq 'HASH') { |
| |
%ids=%{$idsref}; |
| |
} |
| |
if ($namespace eq '') { |
| |
$namespace = 'ids'; |
| |
} |
| foreach my $uname (keys(%ids)) { |
foreach my $uname (keys(%ids)) { |
| &cput('environment',{'id'=>$ids{$uname}},$udom,$uname); |
&cput('environment',{'id'=>$ids{$uname}},$udom,$uname); |
| my $uhom=&homeserver($uname,$udom); |
if ($uhom eq '') { |
| |
$uhom=&homeserver($uname,$udom); |
| |
} |
| if ($uhom ne 'no_host') { |
if ($uhom ne 'no_host') { |
| my $id=&escape($ids{$uname}); |
|
| $id=~tr/A-Z/a-z/; |
|
| my $esc_unam=&escape($uname); |
my $esc_unam=&escape($uname); |
| if ($servers{$uhom}) { |
if ($namespace eq 'ids') { |
| $servers{$uhom}.='&'.$id.'='.$esc_unam; |
my $id=&escape($ids{$uname}); |
| |
$id=~tr/A-Z/a-z/; |
| |
my $esc_unam=&escape($uname); |
| |
$servers{$uhom}.=$id.'='.$esc_unam.'&'; |
| } else { |
} else { |
| $servers{$uhom}=$id.'='.$esc_unam; |
my @currids = split(/,/,$ids{$uname}); |
| |
foreach my $id (@currids) { |
| |
$byid{$uhom}{$id} .= $uname.','; |
| |
} |
| |
} |
| |
} |
| |
} |
| |
if ($namespace eq 'clickers') { |
| |
foreach my $server (keys(%byid)) { |
| |
if (ref($byid{$server}) eq 'HASH') { |
| |
foreach my $id (keys(%{$byid{$server}})) { |
| |
$byid{$server} =~ s/,$//; |
| |
$servers{$uhom}.=&escape($id).'='.&escape($byid{$server}).'&'; |
| |
} |
| } |
} |
| } |
} |
| } |
} |
| foreach my $server (keys(%servers)) { |
foreach my $server (keys(%servers)) { |
| &critical('idput:'.$udom.':'.$servers{$server},$server); |
$servers{$server} =~ s/\&$//; |
| |
if ($namespace eq 'ids') { |
| |
&critical('idput:'.$udom.':'.$servers{$server},$server); |
| |
} else { |
| |
&critical('updateclickers:'.$udom.':add:'.$servers{$server},$server); |
| |
} |
| } |
} |
| } |
} |
| |
|
| # ---------------------------------------- Delete unwanted IDs from ids.db file |
# ------------- Delete unwanted student/employee IDs or clicker IDs from domain |
| |
|
| sub iddel { |
sub iddel { |
| my ($udom,$idshashref,$uhome)=@_; |
my ($udom,$idshashref,$uhome,$namespace)=@_; |
| my %result=(); |
my %result=(); |
| unless (ref($idshashref) eq 'HASH') { |
my %ids=(); |
| |
my %byid = (); |
| |
if (ref($idshashref) eq 'HASH') { |
| |
%ids=%{$idshashref}; |
| |
} else { |
| return %result; |
return %result; |
| } |
} |
| |
if ($namespace eq '') { |
| |
$namespace = 'ids'; |
| |
} |
| my %servers=(); |
my %servers=(); |
| while (my ($id,$uname) = each(%{$idshashref})) { |
while (my ($id,$unamestr) = each(%ids)) { |
| my $uhom; |
if ($namespace eq 'ids') { |
| if ($uhome) { |
my $uhom = $uhome; |
| $uhom = $uhome; |
if ($uhom eq '') { |
| } else { |
$uhom=&homeserver($unamestr,$udom); |
| $uhom=&homeserver($uname,$udom); |
} |
| } |
if ($uhom ne 'no_host') { |
| if ($uhom ne 'no_host') { |
|
| if ($servers{$uhom}) { |
|
| $servers{$uhom}.='&'.&escape($id); |
$servers{$uhom}.='&'.&escape($id); |
| } else { |
} |
| $servers{$uhom}=&escape($id); |
} else { |
| |
my @curritems = split(/,/,$ids{$id}); |
| |
foreach my $uname (@curritems) { |
| |
my $uhom = $uhome; |
| |
if ($uhom eq '') { |
| |
$uhom=&homeserver($uname,$udom); |
| |
} |
| |
if ($uhom ne 'no_host') { |
| |
$byid{$uhom}{$id} .= $uname.','; |
| |
} |
| |
} |
| |
} |
| |
} |
| |
if ($namespace eq 'clickers') { |
| |
foreach my $server (keys(%byid)) { |
| |
if (ref($byid{$server}) eq 'HASH') { |
| |
foreach my $id (keys(%{$byid{$server}})) { |
| |
$byid{$server}{$id} =~ s/,$//; |
| |
$servers{$server}.=&escape($id).'='.&escape($byid{$server}{$id}).'&'; |
| |
} |
| } |
} |
| } |
} |
| } |
} |
| foreach my $server (keys(%servers)) { |
foreach my $server (keys(%servers)) { |
| $result{$server} = &critical('iddel:'.$udom.':'.$servers{$server},$uhome); |
$servers{$server} =~ s/\&$//; |
| |
if ($namespace eq 'ids') { |
| |
$result{$server} = &critical('iddel:'.$udom.':'.$servers{$server},$uhome); |
| |
} elsif ($namespace eq 'clickers') { |
| |
$result{$server} = &critical('updateclickers:'.$udom.':del:'.$servers{$server},$server); |
| |
} |
| } |
} |
| return %result; |
return %result; |
| } |
} |
| |
|
| |
# ----- Update clicker ID-to-username look-ups in clickers.db on library server |
| |
|
| |
sub updateclickers { |
| |
my ($udom,$action,$idshashref,$uhome,$critical) = @_; |
| |
my %clickers; |
| |
if (ref($idshashref) eq 'HASH') { |
| |
%clickers=%{$idshashref}; |
| |
} else { |
| |
return; |
| |
} |
| |
my $items=''; |
| |
foreach my $item (keys(%clickers)) { |
| |
$items.=&escape($item).'='.&escape($clickers{$item}).'&'; |
| |
} |
| |
$items=~s/\&$//; |
| |
my $request = "updateclickers:$udom:$action:$items"; |
| |
if ($critical) { |
| |
return &critical($request,$uhome); |
| |
} else { |
| |
return &reply($request,$uhome); |
| |
} |
| |
} |
| |
|
| # ------------------------------dump from db file owned by domainconfig user |
# ------------------------------dump from db file owned by domainconfig user |
| sub dump_dom { |
sub dump_dom { |
| my ($namespace, $udom, $regexp) = @_; |
my ($namespace, $udom, $regexp) = @_; |
|
Line 1940 sub get_instuser {
|
Line 2036 sub get_instuser {
|
| return ($outcome,%userinfo); |
return ($outcome,%userinfo); |
| } |
} |
| |
|
| |
sub get_multiple_instusers { |
| |
my ($udom,$users,$caller) = @_; |
| |
my ($outcome,$results); |
| |
if (ref($users) eq 'HASH') { |
| |
my $count = keys(%{$users}); |
| |
my $requested = &freeze_escape($users); |
| |
my $homeserver = &domain($udom,'primary'); |
| |
if ($homeserver ne '') { |
| |
my $queryid=&reply('querysend:getmultinstusers:::'.$caller.'='.$requested,$homeserver); |
| |
my $host=&hostname($homeserver); |
| |
if ($queryid !~/^\Q$host\E\_/) { |
| |
&logthis('get_multiple_instusers invalid queryid: '.$queryid. |
| |
' for host: '.$homeserver.'in domain '.$udom); |
| |
return ($outcome,$results); |
| |
} |
| |
my $response = &get_query_reply($queryid); |
| |
my $maxtries = 5; |
| |
if ($count > 100) { |
| |
$maxtries = 1+int($count/20); |
| |
} |
| |
my $tries = 1; |
| |
while (($response=~/^timeout/) && ($tries <= $maxtries)) { |
| |
$response = &get_query_reply($queryid); |
| |
$tries ++; |
| |
} |
| |
if ($response eq '') { |
| |
$results = {}; |
| |
foreach my $key (keys(%{$users})) { |
| |
my ($uname,$id); |
| |
if ($caller eq 'id') { |
| |
$id = $key; |
| |
} else { |
| |
$uname = $key; |
| |
} |
| |
my ($resp,%info) = &get_instuser($udom,$uname,$id); |
| |
$outcome = $resp; |
| |
if ($resp eq 'ok') { |
| |
%{$results} = (%{$results}, %info); |
| |
} else { |
| |
last; |
| |
} |
| |
} |
| |
} elsif(!&error($response) && ($response ne 'refused')) { |
| |
if (($response eq 'unavailable') || ($response eq 'invalid') || ($response eq 'timeout')) { |
| |
$outcome = $response; |
| |
} else { |
| |
($outcome,my $userdata) = split(/=/,$response,2); |
| |
if ($outcome eq 'ok') { |
| |
$results = &thaw_unescape($userdata); |
| |
} |
| |
} |
| |
} |
| |
} |
| |
} |
| |
return ($outcome,$results); |
| |
} |
| |
|
| sub inst_rulecheck { |
sub inst_rulecheck { |
| my ($udom,$uname,$id,$item,$rules) = @_; |
my ($udom,$uname,$id,$item,$rules) = @_; |
| my %returnhash; |
my %returnhash; |
|
Line 2924 sub can_edit_resource {
|
Line 3077 sub can_edit_resource {
|
| $forceedit = 1; |
$forceedit = 1; |
| } |
} |
| $cfile = $resurl; |
$cfile = $resurl; |
| |
} elsif ($resurl =~ m{^/adm/wrapper/adm/$cdom/$cnum/\d+/exttools?$}) { |
| |
$incourse = 1; |
| |
if ($env{'form.forceedit'}) { |
| |
$forceview = 1; |
| |
} else { |
| |
$forceedit = 1; |
| |
} |
| |
$cfile = $resurl; |
| } elsif ($resurl =~ m{^/?adm/viewclasslist$}) { |
} elsif ($resurl =~ m{^/?adm/viewclasslist$}) { |
| $incourse = 1; |
$incourse = 1; |
| if ($env{'form.forceedit'}) { |
if ($env{'form.forceedit'}) { |
|
Line 2948 sub can_edit_resource {
|
Line 3109 sub can_edit_resource {
|
| $forceedit = 1; |
$forceedit = 1; |
| } |
} |
| $cfile = $resurl; |
$cfile = $resurl; |
| |
} elsif (($resurl =~ m{^/adm/wrapper/adm/$cdom/$cnum/\d+/exttools?$}) && ($env{'form.folderpath'} =~ /^supplemental/)) { |
| |
$incourse = 1; |
| |
if ($env{'form.forceedit'}) { |
| |
$forceview = 1; |
| |
} else { |
| |
$forceedit = 1; |
| |
} |
| |
$cfile = $resurl; |
| } elsif (($resurl eq '/adm/extresedit') && ($symb || $env{'form.folderpath'})) { |
} elsif (($resurl eq '/adm/extresedit') && ($symb || $env{'form.folderpath'})) { |
| $incourse = 1; |
$incourse = 1; |
| $forceview = 1; |
$forceview = 1; |
|
Line 2957 sub can_edit_resource {
|
Line 3126 sub can_edit_resource {
|
| $cfile = &clutter($res); |
$cfile = &clutter($res); |
| } else { |
} else { |
| $cfile = $env{'form.suppurl'}; |
$cfile = $env{'form.suppurl'}; |
| $cfile =~ s{^http://}{}; |
my $escfile = &unescape($cfile); |
| $cfile = '/adm/wrapper/ext/'.$cfile; |
if ($escfile =~ m{^/adm/$cdom/$cnum/\d+/exttools?$}) { |
| |
$cfile = '/adm/wrapper'.$escfile; |
| |
} else { |
| |
$escfile =~ s{^http://}{}; |
| |
$cfile = &escape("/adm/wrapper/ext/$escfile"); |
| |
} |
| } |
} |
| } elsif ($resurl =~ m{^/?adm/viewclasslist$}) { |
} elsif ($resurl =~ m{^/?adm/viewclasslist$}) { |
| if ($env{'form.forceedit'}) { |
if ($env{'form.forceedit'}) { |
|
Line 7157 sub constructaccess {
|
Line 7331 sub constructaccess {
|
| my ($ownername,$ownerdomain,$ownerhome); |
my ($ownername,$ownerdomain,$ownerhome); |
| |
|
| ($ownerdomain,$ownername) = |
($ownerdomain,$ownername) = |
| ($url=~ m{^(?:\Q$perlvar{'lonDocRoot'}\E|)/priv/($match_domain)/($match_username)/}); |
($url=~ m{^(?:\Q$perlvar{'lonDocRoot'}\E|)(?:/daxepage|/daxeopen)?/priv/($match_domain)/($match_username)/}); |
| |
|
| # The URL does not really point to any authorspace, forget it |
# The URL does not really point to any authorspace, forget it |
| unless (($ownername) && ($ownerdomain)) { return ''; } |
unless (($ownername) && ($ownerdomain)) { return ''; } |
|
Line 7330 sub get_commblock_resources {
|
Line 7504 sub get_commblock_resources {
|
| } |
} |
| } |
} |
| } |
} |
| if ($interval[0] =~ /^\d+$/) { |
if ($interval[0] =~ /^\d+/) { |
| |
my ($timelimit) = split(/_/,$interval[0]); |
| my $first_access; |
my $first_access; |
| if ($type eq 'resource') { |
if ($type eq 'resource') { |
| $first_access=&get_first_access($interval[1],$item); |
$first_access=&get_first_access($interval[1],$item); |
|
Line 7340 sub get_commblock_resources {
|
Line 7515 sub get_commblock_resources {
|
| $first_access=&get_first_access($interval[1]); |
$first_access=&get_first_access($interval[1]); |
| } |
} |
| if ($first_access) { |
if ($first_access) { |
| my $timesup = $first_access+$interval[0]; |
my $timesup = $first_access+$timelimit; |
| if ($timesup > $now) { |
if ($timesup > $now) { |
| my $activeblock; |
my $activeblock; |
| foreach my $res (@to_test) { |
foreach my $res (@to_test) { |
|
Line 7679 sub get_query_reply {
|
Line 7854 sub get_query_reply {
|
| my $replyfile=LONCAPA::tempdir().$queryid; |
my $replyfile=LONCAPA::tempdir().$queryid; |
| my $reply=''; |
my $reply=''; |
| for (1..100) { |
for (1..100) { |
| Time::HiRes::sleep(0.2); |
sleep(0.2); |
| if (-e $replyfile.'.end') { |
if (-e $replyfile.'.end') { |
| if (open(my $fh,$replyfile)) { |
if (open(my $fh,$replyfile)) { |
| $reply = join('',<$fh>); |
$reply = join('',<$fh>); |
|
Line 8735 sub modifyuser {
|
Line 8910 sub modifyuser {
|
| 'current user id "'.$uidhash{$uname}.'".'; |
'current user id "'.$uidhash{$uname}.'".'; |
| } |
} |
| } else { |
} else { |
| &idput($udom,($uname => $uid)); |
&idput($udom,{$uname => $uid},$uhome,'ids'); |
| } |
} |
| } |
} |
| # -------------------------------------------------------------- Add names, etc |
# -------------------------------------------------------------- Add names, etc |
|
Line 9524 sub modify_access_controls {
|
Line 9699 sub modify_access_controls {
|
| |
|
| while (($gotlock ne 'ok') && $tries < 10) { |
while (($gotlock ne 'ok') && $tries < 10) { |
| $tries ++; |
$tries ++; |
| Time::HiRes::sleep(0.1); |
sleep(0.1); |
| $gotlock = &newput('file_permissions',$lockhash,$domain,$user); |
$gotlock = &newput('file_permissions',$lockhash,$domain,$user); |
| } |
} |
| if ($gotlock eq 'ok') { |
if ($gotlock eq 'ok') { |
|
Line 10117 sub get_userresdata {
|
Line 10292 sub get_userresdata {
|
| } |
} |
| #error 2 occurs when the .db doesn't exist |
#error 2 occurs when the .db doesn't exist |
| if ($tmp!~/error: 2 /) { |
if ($tmp!~/error: 2 /) { |
| &logthis("<font color=\"blue\">WARNING:". |
if ((!defined($cached)) || ($tmp ne 'con_lost')) { |
| " Trying to get resource data for ". |
&logthis("<font color=\"blue\">WARNING:". |
| $uname." at ".$udom.": ". |
" Trying to get resource data for ". |
| $tmp."</font>"); |
$uname." at ".$udom.": ". |
| |
$tmp."</font>"); |
| |
} |
| } elsif ($tmp=~/error: 2 /) { |
} elsif ($tmp=~/error: 2 /) { |
| #&EXT_cache_set($udom,$uname); |
#&EXT_cache_set($udom,$uname); |
| &do_cache_new('userres',$hashid,undef,600); |
&do_cache_new('userres',$hashid,undef,600); |
|
Line 10135 sub get_userresdata {
|
Line 10312 sub get_userresdata {
|
| # $name - Course/user name. |
# $name - Course/user name. |
| # $domain - Name of the domain the user/course is registered on. |
# $domain - Name of the domain the user/course is registered on. |
| # $type - Type of thing $name is (must be 'course' or 'user' |
# $type - Type of thing $name is (must be 'course' or 'user' |
| |
# $mapp - decluttered URL of enclosing map |
| |
# $recursed - Ref to scalar -- set to 1, if nested maps have been recursed. |
| |
# $recurseup - Ref to array of map URLs, starting with map containing |
| |
# $mapp up through hierarchy of nested maps to top level map. |
| |
# $courseid - CourseID (first part of param identifier). |
| |
# $modifier - Middle part of param identifier. |
| |
# $what - Last part of param identifier. |
| # @which - Array of names of resources desired. |
# @which - Array of names of resources desired. |
| # Returns: |
# Returns: |
| # The value of the first reasource in @which that is found in the |
# The value of the first reasource in @which that is found in the |
|
Line 10144 sub get_userresdata {
|
Line 10328 sub get_userresdata {
|
| # 'user', an undefined reference is returned. |
# 'user', an undefined reference is returned. |
| # If none of the resources are found, an undef is returned |
# If none of the resources are found, an undef is returned |
| sub resdata { |
sub resdata { |
| my ($name,$domain,$type,@which)=@_; |
my ($name,$domain,$type,$mapp,$recursed,$recurseup,$courseid, |
| |
$modifier,$what,@which)=@_; |
| my $result; |
my $result; |
| if ($type eq 'course') { |
if ($type eq 'course') { |
| $result=&get_courseresdata($name,$domain); |
$result=&get_courseresdata($name,$domain); |
|
Line 10153 sub resdata {
|
Line 10338 sub resdata {
|
| } |
} |
| if (!ref($result)) { return $result; } |
if (!ref($result)) { return $result; } |
| foreach my $item (@which) { |
foreach my $item (@which) { |
| if (defined($result->{$item->[0]})) { |
if ($item->[1] eq 'course') { |
| |
if ((ref($recurseup) eq 'ARRAY') && (ref($recursed) eq 'SCALAR')) { |
| |
unless ($$recursed) { |
| |
@{$recurseup} = &get_map_hierarchy($mapp,$courseid); |
| |
$$recursed = 1; |
| |
} |
| |
foreach my $item (@${recurseup}) { |
| |
my $norecursechk=$courseid.$modifier.$item.'___(all).'.$what; |
| |
last if (defined($result->{$norecursechk})); |
| |
my $recursechk=$courseid.$modifier.$item.'___(rec).'.$what; |
| |
if (defined($result->{$recursechk})) { return [$result->{$recursechk},'map']; } |
| |
} |
| |
} |
| |
} |
| |
if (defined($result->{$item->[0]})) { |
| return [$result->{$item->[0]},$item->[1]]; |
return [$result->{$item->[0]},$item->[1]]; |
| } |
} |
| } |
} |
| return undef; |
return undef; |
| } |
} |
| |
|
| |
sub get_domain_ltitools { |
| |
my ($cdom) = @_; |
| |
my %ltitools; |
| |
my ($result,$cached)=&is_cached_new('ltitools',$cdom); |
| |
if (defined($cached)) { |
| |
if (ref($result) eq 'HASH') { |
| |
%ltitools = %{$result}; |
| |
} |
| |
} else { |
| |
my %domconfig = &get_dom('configuration',['ltitools'],$cdom); |
| |
if (ref($domconfig{'ltitools'}) eq 'HASH') { |
| |
%ltitools = %{$domconfig{'ltitools'}}; |
| |
} |
| |
my $cachetime = 24*60*60; |
| |
&do_cache_new('ltitools',$cdom,\%ltitools,$cachetime); |
| |
} |
| |
return %ltitools; |
| |
} |
| |
|
| sub get_numsuppfiles { |
sub get_numsuppfiles { |
| my ($cnum,$cdom,$ignorecache)=@_; |
my ($cnum,$cdom,$ignorecache)=@_; |
| my $hashid=$cnum.':'.$cdom; |
my $hashid=$cnum.':'.$cdom; |
|
Line 10184 sub get_numsuppfiles {
|
Line 10402 sub get_numsuppfiles {
|
| # EXT resource caching routines |
# EXT resource caching routines |
| # |
# |
| |
|
| |
{ |
| |
# Cache (5 seconds) of map hierarchy for speedup of navmaps display |
| |
# |
| |
# The course for which we cache |
| |
my $cachedmapkey=''; |
| |
# The cached recursive maps for this course |
| |
my %cachedmaps=(); |
| |
# When this was last done |
| |
my $cachedmaptime=''; |
| |
|
| sub clear_EXT_cache_status { |
sub clear_EXT_cache_status { |
| &delenv('cache.EXT.'); |
&delenv('cache.EXT.'); |
| } |
} |
|
Line 10361 sub EXT {
|
Line 10589 sub EXT {
|
| } |
} |
| } |
} |
| |
|
| my ($section, $group, @groups); |
my ($section, $group, @groups, @recurseup, $recursed); |
| my ($courselevelm,$courselevel); |
my ($courselevelm,$courseleveli,$courselevel,$mapp); |
| if (($courseid eq '') && ($cid)) { |
if (($courseid eq '') && ($cid)) { |
| $courseid = $cid; |
$courseid = $cid; |
| } |
} |
|
Line 10373 sub EXT {
|
Line 10601 sub EXT {
|
| |
|
| # ----------------------------------------------------- Cascading lookup scheme |
# ----------------------------------------------------- Cascading lookup scheme |
| my $symbp=$symbparm; |
my $symbp=$symbparm; |
| my $mapp=&deversion((&decode_symb($symbp))[0]); |
$mapp=&deversion((&decode_symb($symbp))[0]); |
| |
|
| my $symbparm=$symbp.'.'.$spacequalifierrest; |
my $symbparm=$symbp.'.'.$spacequalifierrest; |
| |
my $recurseparm=$mapp.'___(rec).'.$spacequalifierrest; |
| my $mapparm=$mapp.'___(all).'.$spacequalifierrest; |
my $mapparm=$mapp.'___(all).'.$spacequalifierrest; |
| |
|
| if (($env{'user.name'} eq $uname) && |
if (($env{'user.name'} eq $uname) && |
| ($env{'user.domain'} eq $udom)) { |
($env{'user.domain'} eq $udom)) { |
| $section=$env{'request.course.sec'}; |
$section=$env{'request.course.sec'}; |
|
Line 10394 sub EXT {
|
Line 10621 sub EXT {
|
| |
|
| my $seclevel=$courseid.'.['.$section.'].'.$spacequalifierrest; |
my $seclevel=$courseid.'.['.$section.'].'.$spacequalifierrest; |
| my $seclevelr=$courseid.'.['.$section.'].'.$symbparm; |
my $seclevelr=$courseid.'.['.$section.'].'.$symbparm; |
| |
my $secleveli=$courseid.'.['.$section.'].'.$recurseparm; |
| my $seclevelm=$courseid.'.['.$section.'].'.$mapparm; |
my $seclevelm=$courseid.'.['.$section.'].'.$mapparm; |
| |
|
| $courselevel=$courseid.'.'.$spacequalifierrest; |
$courselevel=$courseid.'.'.$spacequalifierrest; |
| my $courselevelr=$courseid.'.'.$symbparm; |
my $courselevelr=$courseid.'.'.$symbparm; |
| |
$courseleveli=$courseid.'.'.$recurseparm; |
| $courselevelm=$courseid.'.'.$mapparm; |
$courselevelm=$courseid.'.'.$mapparm; |
| |
|
| # ----------------------------------------------------------- first, check user |
# ----------------------------------------------------------- first, check user |
| |
|
| my $userreply=&resdata($uname,$udom,'user', |
my $userreply=&resdata($uname,$udom,'user',$mapp,\$recursed, |
| |
\@recurseup,$courseid,'.',$spacequalifierrest, |
| ([$courselevelr,'resource'], |
([$courselevelr,'resource'], |
| [$courselevelm,'map' ], |
[$courselevelm,'map' ], |
| |
[$courseleveli,'map' ], |
| [$courselevel, 'course' ])); |
[$courselevel, 'course' ])); |
| if (defined($userreply)) { return &get_reply($userreply); } |
if (defined($userreply)) { return &get_reply($userreply); } |
| |
|
|
Line 10412 sub EXT {
|
Line 10643 sub EXT {
|
| my $coursereply; |
my $coursereply; |
| if (@groups > 0) { |
if (@groups > 0) { |
| $coursereply = &check_group_parms($courseid,\@groups,$symbparm, |
$coursereply = &check_group_parms($courseid,\@groups,$symbparm, |
| $mapparm,$spacequalifierrest); |
$recurseparm,$mapparm,$spacequalifierrest, |
| if (defined($coursereply)) { return &get_reply($coursereply); } |
$mapp,\$recursed,\@recurseup); |
| |
if (defined($coursereply)) { return &get_reply($coursereply); } |
| } |
} |
| |
|
| $coursereply=&resdata($env{'course.'.$courseid.'.num'}, |
$coursereply=&resdata($env{'course.'.$courseid.'.num'}, |
| $env{'course.'.$courseid.'.domain'}, |
$env{'course.'.$courseid.'.domain'}, |
| 'course', |
'course',$mapp,\$recursed,\@recurseup, |
| |
$courseid,'.['.$section.'].',$spacequalifierrest, |
| ([$seclevelr, 'resource'], |
([$seclevelr, 'resource'], |
| [$seclevelm, 'map' ], |
[$seclevelm, 'map' ], |
| |
[$secleveli, 'map' ], |
| [$seclevel, 'course' ], |
[$seclevel, 'course' ], |
| [$courselevelr,'resource'])); |
[$courselevelr,'resource'])); |
| if (defined($coursereply)) { return &get_reply($coursereply); } |
if (defined($coursereply)) { return &get_reply($coursereply); } |
|
Line 10437 sub EXT {
|
Line 10671 sub EXT {
|
| if ($thisparm) { return &get_reply([$thisparm,'resource']); } |
if ($thisparm) { return &get_reply([$thisparm,'resource']); } |
| } |
} |
| # ------------------------------------------ fourth, look in resource metadata |
# ------------------------------------------ fourth, look in resource metadata |
| |
|
| $spacequalifierrest=~s/\./\_/; |
my $what = $spacequalifierrest; |
| |
$what=~s/\./\_/; |
| my $filename; |
my $filename; |
| if (!$symbparm) { $symbparm=&symbread(); } |
if (!$symbparm) { $symbparm=&symbread(); } |
| if ($symbparm) { |
if ($symbparm) { |
|
Line 10446 sub EXT {
|
Line 10681 sub EXT {
|
| } else { |
} else { |
| $filename=$env{'request.filename'}; |
$filename=$env{'request.filename'}; |
| } |
} |
| my $metadata=&metadata($filename,$spacequalifierrest); |
my $metadata=&metadata($filename,$what); |
| if (defined($metadata)) { return &get_reply([$metadata,'resource']); } |
if (defined($metadata)) { return &get_reply([$metadata,'resource']); } |
| $metadata=&metadata($filename,'parameter_'.$spacequalifierrest); |
$metadata=&metadata($filename,'parameter_'.$what); |
| if (defined($metadata)) { return &get_reply([$metadata,'resource']); } |
if (defined($metadata)) { return &get_reply([$metadata,'resource']); } |
| |
|
| # ---------------------------------------------- fourth, look in rest of course |
# ----------------------------------------------- fifth, look in rest of course |
| if ($symbparm && defined($courseid) && |
if ($symbparm && defined($courseid) && |
| $courseid eq $env{'request.course.id'}) { |
$courseid eq $env{'request.course.id'}) { |
| my $coursereply=&resdata($env{'course.'.$courseid.'.num'}, |
my $coursereply=&resdata($env{'course.'.$courseid.'.num'}, |
| $env{'course.'.$courseid.'.domain'}, |
$env{'course.'.$courseid.'.domain'}, |
| 'course', |
'course',$mapp,\$recursed,\@recurseup, |
| |
$courseid,'.',$spacequalifierrest, |
| ([$courselevelm,'map' ], |
([$courselevelm,'map' ], |
| |
[$courseleveli,'map' ], |
| [$courselevel, 'course'])); |
[$courselevel, 'course'])); |
| if (defined($coursereply)) { return &get_reply($coursereply); } |
if (defined($coursereply)) { return &get_reply($coursereply); } |
| } |
} |
|
Line 10514 sub get_reply {
|
Line 10751 sub get_reply {
|
| } |
} |
| |
|
| sub check_group_parms { |
sub check_group_parms { |
| my ($courseid,$groups,$symbparm,$mapparm,$what) = @_; |
my ($courseid,$groups,$symbparm,$recurseparm,$mapparm,$what,$mapp, |
| my @groupitems = (); |
$recursed,$recurseupref) = @_; |
| my $resultitem; |
my @levels = ([$symbparm,'resource'],[$mapparm,'map'],[$recurseparm,'map'], |
| my @levels = ([$symbparm,'resource'],[$mapparm,'map'],[$what,'course']); |
[$what,'course']); |
| |
my $coursereply; |
| foreach my $group (@{$groups}) { |
foreach my $group (@{$groups}) { |
| |
my @groupitems = (); |
| foreach my $level (@levels) { |
foreach my $level (@levels) { |
| my $item = $courseid.'.['.$group.'].'.$level->[0]; |
my $item = $courseid.'.['.$group.'].'.$level->[0]; |
| push(@groupitems,[$item,$level->[1]]); |
push(@groupitems,[$item,$level->[1]]); |
| } |
} |
| |
my $coursereply = &resdata($env{'course.'.$courseid.'.num'}, |
| |
$env{'course.'.$courseid.'.domain'}, |
| |
'course',$mapp,$recursed,$recurseupref, |
| |
$courseid,'.['.$group.'].',$what, |
| |
@groupitems); |
| |
last if (defined($coursereply)); |
| } |
} |
| my $coursereply = &resdata($env{'course.'.$courseid.'.num'}, |
|
| $env{'course.'.$courseid.'.domain'}, |
|
| 'course',@groupitems); |
|
| return $coursereply; |
return $coursereply; |
| } |
} |
| |
|
| |
sub get_map_hierarchy { |
| |
my ($mapname,$courseid) = @_; |
| |
my @recurseup = (); |
| |
if ($mapname) { |
| |
if (($cachedmapkey eq $courseid) && |
| |
(abs($cachedmaptime-time)<5)) { |
| |
if (ref($cachedmaps{$mapname}) eq 'ARRAY') { |
| |
return @{$cachedmaps{$mapname}}; |
| |
} |
| |
} |
| |
my $navmap = Apache::lonnavmaps::navmap->new(); |
| |
if (ref($navmap)) { |
| |
@recurseup = $navmap->recurseup_maps($mapname); |
| |
undef($navmap); |
| |
$cachedmaps{$mapname} = \@recurseup; |
| |
$cachedmaptime=time; |
| |
$cachedmapkey=$courseid; |
| |
} |
| |
} |
| |
return @recurseup; |
| |
} |
| |
|
| |
} |
| |
|
| sub sort_course_groups { # Sort groups based on defined rankings. Default is sort(). |
sub sort_course_groups { # Sort groups based on defined rankings. Default is sort(). |
| my ($courseid,@groups) = @_; |
my ($courseid,@groups) = @_; |
| @groups = sort(@groups); |
@groups = sort(@groups); |
|
Line 10614 sub metadata {
|
Line 10880 sub metadata {
|
| # if it is a non metadata possible uri return quickly |
# if it is a non metadata possible uri return quickly |
| if (($uri eq '') || |
if (($uri eq '') || |
| (($uri =~ m|^/*adm/|) && |
(($uri =~ m|^/*adm/|) && |
| ($uri !~ m|^adm/includes|) && ($uri !~ m{/(smppg|bulletinboard)$})) || |
($uri !~ m|^adm/includes|) && ($uri !~ m{/(smppg|bulletinboard|exttools?)$})) || |
| ($uri =~ m|/$|) || ($uri =~ m|/.meta$|) || ($uri =~ m{^/*uploaded/.+\.sequence$})) { |
($uri =~ m|/$|) || ($uri =~ m|/.meta$|) || ($uri =~ m{^/*uploaded/.+\.sequence$})) { |
| return undef; |
return undef; |
| } |
} |
|
Line 12147 sub clutter {
|
Line 12413 sub clutter {
|
| # &logthis("Got a blank emb style"); |
# &logthis("Got a blank emb style"); |
| } |
} |
| } |
} |
| |
} elsif ($thisfn =~ m{^/adm/$match_domain/$match_courseid/\d+/exttools?$}) { |
| |
$thisfn='/adm/wrapper'.$thisfn; |
| } |
} |
| return $thisfn; |
return $thisfn; |
| } |
} |
|
Line 12338 sub fetch_dns_checksums {
|
Line 12606 sub fetch_dns_checksums {
|
| } |
} |
| |
|
| sub load_domain_tab { |
sub load_domain_tab { |
| my ($ignore_cache) = @_; |
my ($ignore_cache,$nocache) = @_; |
| &get_dns('/adm/dns/domain',\&parse_domain_tab,$ignore_cache); |
&get_dns('/adm/dns/domain',\&parse_domain_tab,$ignore_cache,$nocache); |
| my $fh; |
my $fh; |
| if (open($fh,"<".$perlvar{'lonTabDir'}.'/domain.tab')) { |
if (open($fh,"<".$perlvar{'lonTabDir'}.'/domain.tab')) { |
| my @lines = <$fh>; |
my @lines = <$fh>; |
|
Line 12425 sub fetch_dns_checksums {
|
Line 12693 sub fetch_dns_checksums {
|
| } |
} |
| |
|
| sub load_hosts_tab { |
sub load_hosts_tab { |
| my ($ignore_cache) = @_; |
my ($ignore_cache,$nocache) = @_; |
| &get_dns('/adm/dns/hosts',\&parse_hosts_tab,$ignore_cache); |
&get_dns('/adm/dns/hosts',\&parse_hosts_tab,$ignore_cache,$nocache); |
| open(my $config,"<$perlvar{'lonTabDir'}/hosts.tab"); |
open(my $config,"<$perlvar{'lonTabDir'}/hosts.tab"); |
| my @config = <$config>; |
my @config = <$config>; |
| &parse_hosts_tab(\@config); |
&parse_hosts_tab(\@config); |
|
Line 12448 sub fetch_dns_checksums {
|
Line 12716 sub fetch_dns_checksums {
|
| } |
} |
| |
|
| sub all_names { |
sub all_names { |
| &load_hosts_tab() if (!$loaded); |
my ($ignore_cache,$nocache) = @_; |
| |
&load_hosts_tab($ignore_cache,$nocache) if (!$loaded); |
| |
|
| return %name_to_host; |
return %name_to_host; |
| } |
} |
|
Line 12570 sub fetch_dns_checksums {
|
Line 12839 sub fetch_dns_checksums {
|
| } |
} |
| |
|
| sub get_iphost { |
sub get_iphost { |
| my ($ignore_cache) = @_; |
my ($ignore_cache,$nocache) = @_; |
| |
|
| if (!$ignore_cache) { |
if (!$ignore_cache) { |
| if (%iphost) { |
if (%iphost) { |
|
Line 12594 sub fetch_dns_checksums {
|
Line 12863 sub fetch_dns_checksums {
|
| %old_name_to_ip = %{$ip_info->[1]}; |
%old_name_to_ip = %{$ip_info->[1]}; |
| } |
} |
| |
|
| my %name_to_host = &all_names(); |
my %name_to_host = &all_names($ignore_cache,$nocache); |
| foreach my $name (keys(%name_to_host)) { |
foreach my $name (keys(%name_to_host)) { |
| my $ip; |
my $ip; |
| if (!exists($name_to_ip{$name})) { |
if (!exists($name_to_ip{$name})) { |
|
Line 12619 sub fetch_dns_checksums {
|
Line 12888 sub fetch_dns_checksums {
|
| } |
} |
| push(@{$iphost{$ip}},@{$name_to_host{$name}}); |
push(@{$iphost{$ip}},@{$name_to_host{$name}}); |
| } |
} |
| &do_cache_new('iphost','iphost', |
unless ($nocache) { |
| [\%iphost,\%name_to_ip,\%lonid_to_ip], |
&do_cache_new('iphost','iphost', |
| 48*60*60); |
[\%iphost,\%name_to_ip,\%lonid_to_ip], |
| |
48*60*60); |
| |
} |
| |
|
| return %iphost; |
return %iphost; |
| } |
} |
|
Line 12813 BEGIN {
|
Line 13084 BEGIN {
|
| my $name = $token->[2]{'name'}; |
my $name = $token->[2]{'name'}; |
| my $value = $token->[2]{'value'}; |
my $value = $token->[2]{'value'}; |
| my $valuematch = $token->[2]{'valuematch'}; |
my $valuematch = $token->[2]{'valuematch'}; |
| if ($item ne '' && $name ne '' && ($value ne '' || $valuematch ne '')) { |
my $namematch = $token->[2]{'namematch'}; |
| |
if ($item eq 'parameter') { |
| |
if (($namematch ne '') || (($name ne '') && ($value ne '' || $valuematch ne ''))) { |
| |
my $release = $parser->get_text(); |
| |
$release =~ s/(^\s*|\s*$ )//gx; |
| |
$needsrelease{$item.':'.$name.':'.$value.':'.$valuematch.':'.$namematch} = $release; |
| |
} |
| |
} elsif ($item ne '' && $name ne '') { |
| my $release = $parser->get_text(); |
my $release = $parser->get_text(); |
| $release =~ s/(^\s*|\s*$ )//gx; |
$release =~ s/(^\s*|\s*$ )//gx; |
| $needsrelease{$item.':'.$name.':'.$value.':'.$valuematch} = $release; |
$needsrelease{$item.':'.$name.':'.$value} = $release; |
| } |
} |
| } |
} |
| } |
} |
|
Line 13086 the answer, and also caches if there is
|
Line 13364 the answer, and also caches if there is
|
| |
|
| =item * |
=item * |
| X<idget()> |
X<idget()> |
| B<idget($udom,@ids)>: find the usernames behind a list of IDs |
B<idget($udom,$idsref,$namespace)>: find the usernames behind either |
| (IDs are a unique resource in a domain, there must be only 1 ID per |
a list of student/employee IDs or clicker IDs |
| username, and only 1 username per ID in a specific domain) (returns |
(student/employee IDs are a unique resource in a domain, there must be |
| hash: id=>name,id=>name) |
only 1 ID per username, and only 1 username per ID in a specific domain). |
| |
clickerIDs are not necessarily unique, as students might share clickers. |
| |
(returns hash: id=>name,id=>name) |
| |
|
| =item * |
=item * |
| X<idrget()> |
X<idrget()> |
|
Line 13098 usernames (returns hash: name=>id,name=>
|
Line 13378 usernames (returns hash: name=>id,name=>
|
| |
|
| =item * |
=item * |
| X<idput()> |
X<idput()> |
| B<idput($udom,%ids)>: store away a list of names and associated IDs |
B<idput($udom,$idsref,$uhome,$namespace)>: store away a list of |
| |
names and associated student/employee IDs or clicker IDs. |
| |
|
| |
=item * |
| |
X<iddel()> |
| |
B<iddel($udom,$idshashref,$uhome,$namespace)>: delete unwanted |
| |
student/employee ID or clicker ID username look-ups from domain. |
| |
The homeserver ($uhome) and namespace ($namespace) are optional. |
| |
If no $uhome is provided, it will be determined usig &homeserver() |
| |
for each user. If no $namespace is provided, the default is ids. |
| |
|
| |
=item * |
| |
X<updateclickers()> |
| |
B<updateclickers($udom,$action,$idshashref,$uhome,$critical)>: update |
| |
clicker ID-to-username look-ups in clickers.db on library server. |
| |
Permitted actions are add or del (i.e., add or delete). The |
| |
clickers.db contains clickerID as keys (escaped), and each corresponding |
| |
value is an escaped comma-separated list of usernames (for whom the |
| |
library server is the homeserver), who registered that particular ID. |
| |
If $critical is true, the update will be sent via &critical, otherwise |
| |
&reply() will be used. |
| |
|
| =item * |
=item * |
| X<rolesinit()> |
X<rolesinit()> |
![[BACK]](/icons/back.gif){kind=icon}
Return to lonnet.pm CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [LON-CAPA] / loncom / lonnet / perl