|
version 1.239, 2002/06/15 20:06:21
|
version 1.250, 2002/07/04 15:47:18
|
|
Line 80 use vars
|
Line 80 use vars
|
| qw(%perlvar %hostname %homecache %badServerCache %hostip %spareid %hostdom |
qw(%perlvar %hostname %homecache %badServerCache %hostip %spareid %hostdom |
| %libserv %pr %prp %metacache %packagetab |
%libserv %pr %prp %metacache %packagetab |
| %courselogs %accesshash $processmarker $dumpcount |
%courselogs %accesshash $processmarker $dumpcount |
| %coursedombuf %coursehombuf %courseresdatacache); |
%coursedombuf %coursehombuf %courseresdatacache %domaindescription); |
| 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 1737 sub allowed {
|
Line 1737 sub allowed {
|
| } |
} |
| } |
} |
| |
|
| # Restricted by state? |
# Restricted by state or randomout? |
| |
|
| if ($thisallowed=~/X/) { |
if ($thisallowed=~/X/) { |
| |
if ($ENV{'acc.randomout'}) { |
| |
my $symb=&symbread($uri,1); |
| |
if (($symb) && ($ENV{'acc.randomout'}=~/\&$symb\&/)) { |
| |
return ''; |
| |
} |
| |
} |
| if (&condval($statecond)) { |
if (&condval($statecond)) { |
| return '2'; |
return '2'; |
| } else { |
} else { |
|
Line 1812 sub definerole {
|
Line 1818 sub definerole {
|
| # ---------------- Make a metadata query against the network of library servers |
# ---------------- Make a metadata query against the network of library servers |
| |
|
| sub metadata_query { |
sub metadata_query { |
| my ($query,$custom,$customshow)=@_; |
my ($query,$custom,$customshow,$server_array)=@_; |
| my %rhash; |
my %rhash; |
| for my $server (keys %libserv) { |
my @server_list = (defined($server_array) ? @$server_array |
| |
: keys(%libserv) ); |
| |
for my $server (@server_list) { |
| unless ($custom or $customshow) { |
unless ($custom or $customshow) { |
| my $reply=&reply("querysend:".&escape($query),$server); |
my $reply=&reply("querysend:".&escape($query),$server); |
| $rhash{$server}=$reply; |
$rhash{$server}=$reply; |
|
Line 1829 sub metadata_query {
|
Line 1837 sub metadata_query {
|
| return \%rhash; |
return \%rhash; |
| } |
} |
| |
|
| |
# ----------------------------------------- Send log queries and wait for reply |
| |
|
| |
sub log_query { |
| |
my ($uname,$udom,$query,%filters)=@_; |
| |
my $uhome=&homeserver($uname,$udom); |
| |
if ($uhome eq 'no_host') { return 'error: no_host'; } |
| |
my $uhost=$hostname{$uhome}; |
| |
my $command=&escape(join(':',map{$_.'='.$filters{$_}} keys %filters)); |
| |
my $queryid=&reply("querysend:".$query.':'.$udom.':'.$uname.':'.$command, |
| |
$uhome); |
| |
unless ($queryid=~/^$uhost\_/) { return 'error: '.$queryid; } |
| |
return get_query_reply($queryid); |
| |
} |
| |
|
| |
sub get_query_reply { |
| |
my $queryid=shift; |
| |
my $replyfile=$perlvar{'lonDaemons'}.'/tmp/'.$queryid; |
| |
my $reply=''; |
| |
for (1..100) { |
| |
sleep 2; |
| |
if (-e $replyfile.'.end') { |
| |
if (my $fh=Apache::File->new($replyfile)) { |
| |
$reply.=<$fh>; |
| |
$fh->close; |
| |
} else { return 'error: reply_file_error'; } |
| |
return &unescape($reply); |
| |
} |
| |
} |
| |
return 'timeout:'.$queryid; |
| |
} |
| |
|
| |
sub courselog_query { |
| |
# |
| |
# possible filters: |
| |
# url: url or symb |
| |
# username |
| |
# domain |
| |
# action: view, submit, grade |
| |
# start: timestamp |
| |
# end: timestamp |
| |
# |
| |
my (%filters)=@_; |
| |
unless ($ENV{'request.course.id'}) { return 'no_course'; } |
| |
if ($filters{'url'}) { |
| |
$filters{'url'}=&symbclean(&declutter($filters{'url'})); |
| |
$filters{'url'}=~s/\.(\w+)$/(\\.\\d+)*\\.$1/; |
| |
$filters{'url'}=~s/\.(\w+)\_\_\_/(\\.\\d+)*\\.$1/; |
| |
} |
| |
my $cname=$ENV{'course.'.$ENV{'request.course.id'}.'.num'}; |
| |
my $cdom=$ENV{'course.'.$ENV{'request.course.id'}.'.domain'}; |
| |
return &log_query($cname,$cdom,'courselog',%filters); |
| |
} |
| |
|
| |
sub userlog_query { |
| |
my ($uname,$udom,%filters)=@_; |
| |
return &log_query($uname,$udom,'userlog',%filters); |
| |
} |
| |
|
| # ------------------------------------------------------------------ Plain Text |
# ------------------------------------------------------------------ Plain Text |
| |
|
| sub plaintext { |
sub plaintext { |
|
Line 2205 sub courseresdata {
|
Line 2271 sub courseresdata {
|
| my ($coursenum,$coursedomain,@which)=@_; |
my ($coursenum,$coursedomain,@which)=@_; |
| my $coursehom=&homeserver($coursenum,$coursedomain); |
my $coursehom=&homeserver($coursenum,$coursedomain); |
| my $hashid=$coursenum.':'.$coursedomain; |
my $hashid=$coursenum.':'.$coursedomain; |
| unless (defined($courseresdatacache{$hashid.'.time'})) { |
my $dodump=0; |
| unless (time-$courseresdatacache{$hashid.'.time'}<300) { |
if (!defined($courseresdatacache{$hashid.'.time'})) { |
| my $coursehom=&homeserver($coursenum,$coursedomain); |
$dodump=1; |
| if ($coursehom) { |
} else { |
| my $dumpreply=&reply('dump:'.$coursedomain.':'.$coursenum. |
if (time-$courseresdatacache{$hashid.'.time'}>300) { $dodump=1; } |
| ':resourcedata:.',$coursehom); |
} |
| unless ($dumpreply=~/^error\:/) { |
if ($dodump) { |
| $courseresdatacache{$hashid.'.time'}=time; |
my $coursehom=&homeserver($coursenum,$coursedomain); |
| $courseresdatacache{$hashid}=$dumpreply; |
if ($coursehom) { |
| } |
my $dumpreply=&reply('dump:'.$coursedomain.':'.$coursenum. |
| } |
':resourcedata:.',$coursehom); |
| } |
if ($dumpreply!~/^error\:/) { |
| |
$courseresdatacache{$hashid.'.time'}=time; |
| |
$courseresdatacache{$hashid}=$dumpreply; |
| |
} |
| |
} |
| |
} |
| |
my @pairs=split(/\&/,$courseresdatacache{$hashid}); |
| |
my %returnhash=(); |
| |
foreach (@pairs) { |
| |
my ($key,$value)=split(/=/,$_); |
| |
$returnhash{unescape($key)}=unescape($value); |
| } |
} |
| my @pairs=split(/\&/,$courseresdatacache{$hashid}); |
|
| my %returnhash=(); |
|
| foreach (@pairs) { |
|
| my ($key,$value)=split(/=/,$_); |
|
| $returnhash{unescape($key)}=unescape($value); |
|
| } |
|
| my $item; |
my $item; |
| foreach $item (@which) { |
foreach $item (@which) { |
| if ($returnhash{$item}) { return $returnhash{$item}; } |
if ($returnhash{$item}) { return $returnhash{$item}; } |
| } |
} |
| return ''; |
return ''; |
| } |
} |
| |
|
| # --------------------------------------------------------- Value of a Variable |
# --------------------------------------------------------- Value of a Variable |
|
Line 2635 sub symbclean {
|
Line 2705 sub symbclean {
|
| # ------------------------------------------------------ Return symb list entry |
# ------------------------------------------------------ Return symb list entry |
| |
|
| sub symbread { |
sub symbread { |
| my $thisfn=shift; |
my ($thisfn,$donotrecurse)=@_; |
| |
# no filename provided? try from environment |
| unless ($thisfn) { |
unless ($thisfn) { |
| if ($ENV{'request.symb'}) { return &symbclean($ENV{'request.symb'}); } |
if ($ENV{'request.symb'}) { return &symbclean($ENV{'request.symb'}); } |
| $thisfn=$ENV{'request.filename'}; |
$thisfn=$ENV{'request.filename'}; |
| } |
} |
| |
# is that filename actually a symb? Verify, clean, and return |
| |
if ($thisfn=~/\_\_\_\d+\_\_\_(.*)$/) { |
| |
if (&symbverify($thisfn,$1)) { return &symbclean($thisfn); } |
| |
} |
| $thisfn=declutter($thisfn); |
$thisfn=declutter($thisfn); |
| my %hash; |
my %hash; |
| my %bighash; |
my %bighash; |
|
Line 2668 sub symbread {
|
Line 2743 sub symbread {
|
| unless ($ids) { |
unless ($ids) { |
| $ids=$bighash{'ids_/'.$thisfn}; |
$ids=$bighash{'ids_/'.$thisfn}; |
| } |
} |
| |
unless ($ids) { |
| |
# alias? |
| |
$ids=$bighash{'mapalias_'.$thisfn}; |
| |
} |
| if ($ids) { |
if ($ids) { |
| # ------------------------------------------------------------------- Has ID(s) |
# ------------------------------------------------------------------- Has ID(s) |
| my @possibilities=split(/\,/,$ids); |
my @possibilities=split(/\,/,$ids); |
|
Line 2675 sub symbread {
|
Line 2754 sub symbread {
|
| # ----------------------------------------------- There is only one possibility |
# ----------------------------------------------- There is only one possibility |
| my ($mapid,$resid)=split(/\./,$ids); |
my ($mapid,$resid)=split(/\./,$ids); |
| $syval=declutter($bighash{'map_id_'.$mapid}).'___'.$resid; |
$syval=declutter($bighash{'map_id_'.$mapid}).'___'.$resid; |
| } else { |
} elsif (!$donotrecurse) { |
| # ------------------------------------------ There is more than one possibility |
# ------------------------------------------ There is more than one possibility |
| my $realpossible=0; |
my $realpossible=0; |
| foreach (@possibilities) { |
foreach (@possibilities) { |
|
Line 2690 sub symbread {
|
Line 2769 sub symbread {
|
| } |
} |
| } |
} |
| if ($realpossible!=1) { $syval=''; } |
if ($realpossible!=1) { $syval=''; } |
| |
} else { |
| |
$syval=''; |
| } |
} |
| } |
} |
| untie(%bighash) |
untie(%bighash) |
|
Line 2874 BEGIN {
|
Line 2955 BEGIN {
|
| |
|
| while (my $configline=<$config>) { |
while (my $configline=<$config>) { |
| chomp($configline); |
chomp($configline); |
| my ($id,$domain,$role,$name,$ip)=split(/:/,$configline); |
my ($id,$domain,$role,$name,$ip,$domdescr)=split(/:/,$configline); |
| $hostname{$id}=$name; |
$hostname{$id}=$name; |
| $hostdom{$id}=$domain; |
$hostdom{$id}=$domain; |
| $hostip{$id}=$ip; |
$hostip{$id}=$ip; |
| |
if ($domdescr) { |
| |
$domaindescription{$domain}=$domdescr; |
| |
} |
| if ($role eq 'library') { $libserv{$id}=$name; } |
if ($role eq 'library') { $libserv{$id}=$name; } |
| } |
} |
| } |
} |
|
Line 2948 $readit=1;
|
Line 3032 $readit=1;
|
| 1; |
1; |
| __END__ |
__END__ |
| |
|
| |
=pod |
| |
|
| =head1 NAME |
=head1 NAME |
| |
|
| Apache::lonnet - TCP networking package |
Apache::lonnet - Subroutines to ask questions about things in the network. |
| |
|
| =head1 SYNOPSIS |
=head1 SYNOPSIS |
| |
|
| Invoked by other LON-CAPA modules. |
Invoked by other LON-CAPA modules, when they need to talk to or about objects in the network. |
| |
|
| &Apache::lonnet::SUBROUTINENAME(ARGUMENTS); |
&Apache::lonnet::SUBROUTINENAME(ARGUMENTS); |
| |
|
| |
Common parameters: |
| |
|
| |
=over 4 |
| |
|
| |
=item * |
| |
|
| |
$uname : an internal username (if $cname expecting a course Id specifically) |
| |
|
| |
=item * |
| |
|
| |
$udom : a domain (if $cdom expecting a course's domain specifically) |
| |
|
| |
=item * |
| |
|
| |
$symb : a resource instance identifier |
| |
|
| |
=item * |
| |
|
| |
$namespace : the name of a .db file that contains the data needed or |
| |
being set. |
| |
|
| |
=back |
| |
|
| =head1 INTRODUCTION |
=head1 INTRODUCTION |
| |
|
| This module provides subroutines which interact with the |
This module provides subroutines which interact with the |
| lonc/lond (TCP) network layer of LON-CAPA. |
lonc/lond (TCP) network layer of LON-CAPA. And Can be used to ask about |
| |
- classes |
| |
- users |
| |
- resources |
| |
|
| |
For many of these objects you can also use this to store data about |
| |
them or modify them in various ways. |
| |
|
| 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 RETURN MESSAGES |
| |
|
| There is no handler routine for this module. |
|
| |
|
| =head1 OTHER SUBROUTINES |
|
| |
|
| =over 4 |
=over 4 |
| |
|
| =item * |
=item * |
| |
|
| logtouch() : make sure the logfile, lonnet.log, exists |
con_lost : unable to contact remote host |
| |
|
| =item * |
=item * |
| |
|
| logthis() : append message to lonnet.log |
con_delayed : unable to contact remote host, message will be delivered |
| |
when the connection is brought back up |
| |
|
| =item * |
=item * |
| |
|
| logperm() : append a permanent message to lonnet.perm.log |
con_failed : unable to contact remote host and unable to save message |
| |
for later delivery |
| |
|
| =item * |
=item * |
| |
|
| subreply() : non-critical communication, called by &reply |
error: : an error a occured, a description of the error follows the : |
| |
|
| =item * |
=item * |
| |
|
| reply() : makes two attempts to pass message; logs refusals and rejections |
no_such_host : unable to fund a host associated with the user/domain |
| |
that was requested |
| |
|
| =item * |
=back |
| |
|
| reconlonc() : tries to reconnect lonc client processes. |
=head1 PUBLIC SUBROUTINES |
| |
|
| =item * |
=head2 Session Environment Functions |
| |
|
| critical() : passes a critical message to another server; if cannot get |
=over 4 |
| through then place message in connection buffer |
|
| |
|
| =item * |
=item * |
| |
|
| appenv(%hash) : read in current user environment, append new environment |
appenv(%hash) : the value of %hash is written to the user envirnoment |
| values to make new user environment |
file, and will be restored for each access this user makes during this |
| |
session, also modifies the %ENV for the current process |
| |
|
| =item * |
=item * |
| |
|
| delenv($varname) : read in current user environment, remove all values |
delenv($regexp) : removes all items from the session environment file that matches the regular expression in $regexp. The values are also delted from the current processes %ENV. |
| beginning with $varname, write new user environment (note: flock is used |
|
| to prevent conflicting shared read/writes with file) |
|
| |
|
| =item * |
=back |
| |
|
| spareserver() : find server with least workload from spare.tab |
=head2 User Information |
| |
|
| |
=over 4 |
| |
|
| =item * |
=item * |
| |
|
|
Line 3026 authentication scheme
|
Line 3140 authentication scheme
|
| =item * |
=item * |
| |
|
| authenticate($uname,$upass,$udom) : try to authenticate user from domain's lib |
authenticate($uname,$upass,$udom) : try to authenticate user from domain's lib |
| servers (first use the current one) |
servers (first use the current one), $upass should be the users password |
| |
|
| =item * |
=item * |
| |
|
| homeserver($uname,$udom) : find the homebase for a user from domain's lib |
homeserver($uname,$udom) : find the server which has the user's |
| servers |
directory and files (there must be only one), this caches the answer, |
| |
and also caches if there is a borken connection. |
| |
|
| =item * |
=item * |
| |
|
| idget($udom,@ids) : find the usernames behind a list of IDs (returns hash: |
idget($udom,@ids) : find the usernames behind a list of IDs (IDs are a |
| |
unique resource in a domain, there must be only 1 ID per username, and |
| |
only 1 username per ID in a specific domain) (returns hash: |
| id=>name,id=>name) |
id=>name,id=>name) |
| |
|
| =item * |
=item * |
|
Line 3049 idput($udom,%ids) : store away a list of
|
Line 3166 idput($udom,%ids) : store away a list of
|
| |
|
| =item * |
=item * |
| |
|
| usection($domain,$user,$courseid) : output of section name/number or '' for |
rolesinit($udom,$username,$authhost) : get user privileges |
| "not in course" and '-1' for "no section" |
|
| |
|
| =item * |
=item * |
| |
|
| userenvironment($domain,$user,$what) : puts out any environment parameter |
usection($udom,$uname,$cname) : finds the section of student in the |
| for a user |
course $cname, return section name/number or '' for "not in course" |
| |
and '-1' for "no section" |
| |
|
| =item * |
=item * |
| |
|
| subscribe($fname) : subscribe to a resource, return URL if possible |
userenvironment($udom,$uname,@what) : gets the values of the keys |
| |
passed in @what from the requested user's environment, returns a hash |
| |
|
| |
=back |
| |
|
| |
=head2 User Roles |
| |
|
| |
=over 4 |
| |
|
| =item * |
=item * |
| |
|
| repcopy($filename) : replicate file |
allowed($priv,$uri) : check for a user privilege; returns codes for allowed |
| |
actions |
| |
F: full access |
| |
U,I,K: authentication modes (cxx only) |
| |
'': forbidden |
| |
1: user needs to choose course |
| |
2: browse allowed |
| |
|
| =item * |
=item * |
| |
|
| ssi($url,%hash) : server side include, does a complete request cycle on url to |
definerole($rolename,$sysrole,$domrole,$courole) : define role; define a custom |
| localhost, posts hash |
role rolename set privileges in format of lonTabs/roles.tab for system, domain, |
| |
and course level |
| |
|
| =item * |
=item * |
| |
|
| log($domain,$name,$home,$message) : write to permanent log for user; use |
plaintext($short) : return value in %prp hash (rolesplain.tab); plain text |
| critical subroutine |
explanation of a user role term |
| |
|
| |
=back |
| |
|
| |
=head2 User Modification |
| |
|
| |
=over 4 |
| |
|
| =item * |
=item * |
| |
|
| flushcourselogs() : flush (save) buffer logs and access logs |
assignrole($udom,$uname,$url,$role,$end,$start) : assign role; give a role to a |
| |
user for the level given by URL. Optional start and end dates (leave empty |
| |
string or zero for "no date") |
| |
|
| =item * |
=item * |
| |
|
| courselog($what) : save message for course in hash |
changepass($uname,$udom,$currentpass,$newpass,$server) : attempts to |
| |
change a users, password, possible return values are: ok, |
| |
pwchange_failure, non_authorized, auth_mode_error, unknown_user, |
| |
refused |
| |
|
| =item * |
=item * |
| |
|
| courseacclog($what) : save message for course using &courselog(). Perform |
modifyuserauth($udom,$uname,$umode,$upass) : modify user authentication |
| special processing for specific resource types (problems, exams, quizzes, etc). |
|
| |
|
| =item * |
=item * |
| |
|
| countacc($url) : count the number of accesses to a given URL |
modifyuser($udom,$uname,$uid,$umode,$upass,$first,$middle,$last,$gene) : |
| |
modify user |
| |
|
| =item * |
=item * |
| |
|
| sub checkout($symb,$tuname,$tudom,$tcrsid) : check out an item |
modifystudent($udom,$uname,$uid,$umode,$upass,$first,$middle,$last,$gene,$usec,$end,$start) : modify student |
| |
|
| =item * |
=item * |
| |
|
| sub checkin($token) : check in an item |
assigncustomrole($udom,$uname,$url,$rdom,$rnam,$rolename,$end,$start) : assign |
| |
custom role; give a custom role to a user for the level given by URL. Specify |
| |
name and domain of role author, and role name |
| |
|
| =item * |
=item * |
| |
|
| sub expirespread($uname,$udom,$stype,$usymb) : set expire date for spreadsheet |
revokerole($udom,$uname,$url,$role) : revoke a role for url |
| |
|
| =item * |
=item * |
| |
|
| devalidate($symb) : devalidate spreadsheets |
revokecustomrole($udom,$uname,$url,$role) : revoke a custom role |
| |
|
| |
=back |
| |
|
| |
=head2 Course Infomation |
| |
|
| |
=over 4 |
| |
|
| =item * |
=item * |
| |
|
| hash2str(%hash) : convert a hash into a string complete with escaping and '=' |
coursedescription($courseid) : course description |
| and '&' separators, supports elements that are arrayrefs and hashrefs |
|
| |
|
| =item * |
=item * |
| |
|
| hashref2str($hashref) : convert a hashref into a string complete with |
courseresdata($coursenum,$coursedomain,@which) : request for current |
| escaping and '=' and '&' separators, supports elements that are |
parameter setting for a specific course, @what should be a list of |
| arrayrefs and hashrefs |
parameters to ask about. This routine caches answers for 5 minutes. |
| |
|
| |
=back |
| |
|
| |
=head2 Course Modification |
| |
|
| |
=over 4 |
| |
|
| =item * |
=item * |
| |
|
| arrayref2str($arrayref) : convert an arrayref into a string complete |
writecoursepref($courseid,%prefs) : write preferences (environment |
| with escaping and '&' separators, supports elements that are arrayrefs |
database) for a course |
| and hashrefs |
|
| |
|
| =item * |
=item * |
| |
|
| str2hash($string) : convert string to hash using unescaping and |
createcourse($udom,$description,$url) : make/modify course |
| splitting on '=' and '&', supports elements that are arrayrefs and |
|
| hashrefs |
=back |
| |
|
| |
=head2 Resource Subroutines |
| |
|
| |
=over 4 |
| |
|
| =item * |
=item * |
| |
|
| str2array($string) : convert string to hash using unescaping and |
subscribe($fname) : subscribe to a resource, returns URL if possible (probably should use repcopy instead) |
| splitting on '&', supports elements that are arrayrefs and hashrefs |
|
| |
|
| =item * |
=item * |
| |
|
| tmpreset($symb,$namespace,$domain,$stuname) : temporary storage |
repcopy($filename) : subscribes to the requested file, and attempts to |
| |
replicate from the owning library server, Might return |
| |
HTTP_SERVICE_UNAVAILABLE, HTTP_NOT_FOUND, FORBIDDEN, OK, or |
| |
HTTP_BAD_REQUEST, also attempts to grab the metadata for the |
| |
resource. Expects the local filesystem pathname |
| |
(/home/httpd/html/res/....) |
| |
|
| |
=back |
| |
|
| |
=head2 Resource Information |
| |
|
| |
=over 4 |
| |
|
| =item * |
=item * |
| |
|
| tmprestore($symb,$namespace,$domain,$stuname) : temporary restore |
EXT($varname,$symb,$udom,$uname) : evaluates and returns the value of |
| |
a vairety of different possible values, $varname should be a request |
| |
string, and the other parameters can be used to specify who and what |
| |
one is asking about. |
| |
|
| |
Possible values for $varname are environment.lastname (or other item |
| |
from the envirnment hash), user.name (or someother aspect about the |
| |
user), resource.0.maxtries (or some other part and parameter of a |
| |
resource) |
| |
|
| =item * |
=item * |
| |
|
| store($storehash,$symb,$namespace,$domain,$stuname) : stores hash permanently |
directcondval($number) : get current value of a condition; reads from a state |
| for this url; hashref needs to be given and should be a \%hashname; the |
string |
| remaining args aren't required and if they aren't passed or are '' they will |
|
| be derived from the ENV |
|
| |
|
| =item * |
=item * |
| |
|
| cstore($storehash,$symb,$namespace,$domain,$stuname) : same as store but |
condval($condidx) : value of condition index based on state |
| uses critical subroutine |
|
| |
|
| =item * |
=item * |
| |
|
| restore($symb,$namespace,$domain,$stuname) : returns hash for this symb; |
metadata($uri,$what,$liburi,$prefix,$depthcount) : request a |
| all args are optional |
resource's metadata, $what should be either a specific key, or either |
| |
'keys' (to get a list of possible keys) or 'packages' to get a list of |
| |
packages that this resource currently uses, the last 3 arguments are only used internally for recursive metadata. |
| |
|
| |
this function automatically caches all requests |
| |
|
| =item * |
=item * |
| |
|
| coursedescription($courseid) : course description |
metadata_query($query,$custom,$customshow) : make a metadata query against the |
| |
network of library servers; returns file handle of where SQL and regex results |
| |
will be stored for query |
| |
|
| =item * |
=item * |
| |
|
| rolesinit($domain,$username,$authhost) : get user privileges |
symbread($filename) : return symbolic list entry (filename argument optional); |
| |
returns the data handle |
| |
|
| =item * |
=item * |
| |
|
| get($namespace,$storearr,$udomain,$uname) : returns hash with keys from array |
symbverify($symb,$thisfn) : verifies that $symb actually exists and is |
| reference filled in from namesp ($udomain and $uname are optional) |
a possible symb for the URL in $thisfn, returns a 1 on success, 0 on |
| |
failure, user must be in a course, as it assumes the existance of the |
| |
course initi hash, and uses $ENV('request.course.id'} |
| |
|
| |
|
| =item * |
=item * |
| |
|
| del($namespace,$storearr,$udomain,$uname) : deletes keys out of array from |
symbclean($symb) : removes versions numbers from a symb, returns the |
| namesp ($udomain and $uname are optional) |
cleaned symb |
| |
|
| =item * |
=item * |
| |
|
| dump($namespace,$udomain,$uname,$regexp) : |
is_on_map($uri) : checks if the $uri is somewhere on the current |
| dumps the complete (or key matching regexp) namespace into a hash |
course map, user must be in a course for it to work. |
| ($udomain, $uname and $regexp are optional) |
|
| |
|
| =item * |
=item * |
| |
|
| put($namespace,$storehash,$udomain,$uname) : stores hash in namesp |
numval($salt) : return random seed value (addend for rndseed) |
| ($udomain and $uname are optional) |
|
| |
|
| =item * |
=item * |
| |
|
| cput($namespace,$storehash,$udomain,$uname) : critical put |
rndseed($symb,$courseid,$udom,$uname) : create a random sum; returns |
| ($udomain and $uname are optional) |
a random seed, all arguments are optional, if they aren't sent it uses the |
| |
environment to derive them. Note: if symb isn't sent and it can't get one |
| |
from &symbread it will use the current time as its return value |
| |
|
| =item * |
=item * |
| |
|
| eget($namespace,$storearr,$udomain,$uname) : returns hash with keys from array |
ireceipt($funame,$fudom,$fucourseid,$fusymb) : return unique, |
| reference filled in from namesp (encrypts the return communication) |
unfakeable, receipt |
| ($udomain and $uname are optional) |
|
| |
|
| =item * |
=item * |
| |
|
| allowed($priv,$uri) : check for a user privilege; returns codes for allowed |
receipt() : API to ireceipt working off of ENV values; given out to users |
| actions |
|
| F: full access |
|
| U,I,K: authentication modes (cxx only) |
|
| '': forbidden |
|
| 1: user needs to choose course |
|
| 2: browse allowed |
|
| |
|
| =item * |
=item * |
| |
|
| definerole($rolename,$sysrole,$domrole,$courole) : define role; define a custom |
countacc($url) : count the number of accesses to a given URL |
| role rolename set privileges in format of lonTabs/roles.tab for system, domain, |
|
| and course level |
|
| |
|
| =item * |
=item * |
| |
|
| metadata_query($query,$custom,$customshow) : make a metadata query against the |
checkout($symb,$tuname,$tudom,$tcrsid) : creates a record of a user having looked at an item, most likely printed out or otherwise using a resource |
| network of library servers; returns file handle of where SQL and regex results |
|
| will be stored for query |
|
| |
|
| =item * |
=item * |
| |
|
| plaintext($short) : return value in %prp hash (rolesplain.tab); plain text |
checkin($token) : updates that a resource has beeen returned (a hard copy version for instance) and returns the data that $token was Checkout with ($symb, $tuname, $tudom, and $tcrsid) |
| explanation of a user role term |
|
| |
|
| =item * |
=item * |
| |
|
| assignrole($udom,$uname,$url,$role,$end,$start) : assign role; give a role to a |
expirespread($uname,$udom,$stype,$usymb) : set expire date for spreadsheet |
| user for the level given by URL. Optional start and end dates (leave empty |
|
| string or zero for "no date") |
|
| |
|
| =item * |
=item * |
| |
|
| modifyuserauth($udom,$uname,$umode,$upass) : modify user authentication |
devalidate($symb) : devalidate temporary spreadsheet calculations, |
| |
forcing spreadsheet to reevaluate the resource scores next time. |
| |
|
| |
=back |
| |
|
| |
=head2 Storing/Retreiving Data |
| |
|
| |
=over 4 |
| |
|
| =item * |
=item * |
| |
|
| modifyuser($udom,$uname,$uid,$umode,$upass,$first,$middle,$last,$gene) : |
store($storehash,$symb,$namespace,$udom,$uname) : stores hash permanently |
| modify user |
for this url; hashref needs to be given and should be a \%hashname; the |
| |
remaining args aren't required and if they aren't passed or are '' they will |
| |
be derived from the ENV |
| |
|
| =item * |
=item * |
| |
|
| modifystudent($udom,$uname,$uid,$umode,$upass,$first,$middle,$last,$gene,$usec, |
cstore($storehash,$symb,$namespace,$udom,$uname) : same as store but |
| $end,$start) : modify student |
uses critical subroutine |
| |
|
| =item * |
=item * |
| |
|
| writecoursepref($courseid,%prefs) : write preferences for a course |
restore($symb,$namespace,$udom,$uname) : returns hash for this symb; |
| |
all args are optional |
| |
|
| =item * |
=item * |
| |
|
| createcourse($udom,$description,$url) : make/modify course |
tmpstore($storehash,$symb,$namespace,$udom,$uname) : storage that |
| |
works very similar to store/cstore, but all data is stored in a |
| |
temporary location and can be reset using tmpreset, $storehash should |
| |
be a hash reference, returns nothing on success |
| |
|
| =item * |
=item * |
| |
|
| assigncustomrole($udom,$uname,$url,$rdom,$rnam,$rolename,$end,$start) : assign |
tmprestore($symb,$namespace,$udom,$uname) : storage that works very |
| custom role; give a custom role to a user for the level given by URL. Specify |
similar to restore, but all data is stored in a temporary location and |
| name and domain of role author, and role name |
can be reset using tmpreset. Returns a hash of values on success, |
| |
error string otherwise. |
| |
|
| =item * |
=item * |
| |
|
| revokerole($udom,$uname,$url,$role) : revoke a role for url |
tmpreset($symb,$namespace,$udom,$uname) : temporary storage reset, |
| |
deltes all keys for $symb form the temporary storage hash. |
| |
|
| =item * |
=item * |
| |
|
| revokecustomrole($udom,$uname,$url,$role) : revoke a custom role |
get($namespace,$storearr,$udom,$uname) : returns hash with keys from array |
| |
reference filled in from namesp ($udom and $uname are optional) |
| |
|
| |
=item * |
| |
|
| |
del($namespace,$storearr,$udom,$uname) : deletes keys out of array from |
| |
namesp ($udom and $uname are optional) |
| |
|
| |
=item * |
| |
|
| |
dump($namespace,$udom,$uname,$regexp) : |
| |
dumps the complete (or key matching regexp) namespace into a hash |
| |
($udom, $uname and $regexp are optional) |
| |
|
| |
=item * |
| |
|
| |
put($namespace,$storehash,$udom,$uname) : stores hash in namesp |
| |
($udom and $uname are optional) |
| |
|
| |
=item * |
| |
|
| |
cput($namespace,$storehash,$udom,$uname) : critical put |
| |
($udom and $uname are optional) |
| |
|
| |
=item * |
| |
|
| |
eget($namespace,$storearr,$udom,$uname) : returns hash with keys from array |
| |
reference filled in from namesp (encrypts the return communication) |
| |
($udom and $uname are optional) |
| |
|
| |
=item * |
| |
|
| |
log($udom,$name,$home,$message) : write to permanent log for user; use |
| |
critical subroutine |
| |
|
| |
=back |
| |
|
| |
=head2 Network Status Functions |
| |
|
| |
=over 4 |
| |
|
| =item * |
=item * |
| |
|
|
Line 3276 dirlist($uri) : return directory list ba
|
Line 3499 dirlist($uri) : return directory list ba
|
| |
|
| =item * |
=item * |
| |
|
| directcondval($number) : get current value of a condition; reads from a state |
spareserver() : find server with least workload from spare.tab |
| string |
|
| |
=back |
| |
|
| |
=head2 Apache Request |
| |
|
| |
=over 4 |
| |
|
| =item * |
=item * |
| |
|
| condval($condidx) : value of condition index based on state |
ssi($url,%hash) : server side include, does a complete request cycle on url to |
| |
localhost, posts hash |
| |
|
| |
=back |
| |
|
| |
=head2 Data to String to Data |
| |
|
| |
=over 4 |
| |
|
| =item * |
=item * |
| |
|
| EXT($varname,$symbparm) : value of a variable |
hash2str(%hash) : convert a hash into a string complete with escaping and '=' |
| |
and '&' separators, supports elements that are arrayrefs and hashrefs |
| |
|
| =item * |
=item * |
| |
|
| metadata($uri,$what,$liburi,$prefix,$depthcount) : get metadata; returns the |
hashref2str($hashref) : convert a hashref into a string complete with |
| metadata entry for a file; entry='keys', returns a comma separated list of keys |
escaping and '=' and '&' separators, supports elements that are |
| |
arrayrefs and hashrefs |
| |
|
| =item * |
=item * |
| |
|
| symblist($mapname,%newhash) : update symbolic storage links |
arrayref2str($arrayref) : convert an arrayref into a string complete |
| |
with escaping and '&' separators, supports elements that are arrayrefs |
| |
and hashrefs |
| |
|
| =item * |
=item * |
| |
|
| symbread($filename) : return symbolic list entry (filename argument optional); |
str2hash($string) : convert string to hash using unescaping and |
| returns the data handle |
splitting on '=' and '&', supports elements that are arrayrefs and |
| |
hashrefs |
| |
|
| =item * |
=item * |
| |
|
| numval($salt) : return random seed value (addend for rndseed) |
str2array($string) : convert string to hash using unescaping and |
| |
splitting on '&', supports elements that are arrayrefs and hashrefs |
| |
|
| |
=back |
| |
|
| |
=head2 Logging Routines |
| |
|
| |
=over 4 |
| |
|
| |
These routines allow one to make log messages in the lonnet.log and |
| |
lonnet.perm logfiles. |
| |
|
| =item * |
=item * |
| |
|
| rndseed($symb,$courseid,$domain,$username) : create a random sum; returns |
logtouch() : make sure the logfile, lonnet.log, exists |
| a random seed, all arguments are optional, if they aren't sent it uses the |
|
| environment to derive them. Note: if symb isn't sent and it can't get one |
|
| from &symbread it will use the current time as its return value |
|
| |
|
| =item * |
=item * |
| |
|
| ireceipt($funame,$fudom,$fucourseid,$fusymb) : return unique, |
logthis() : append message to the normal lonnet.log file, it gets |
| unfakeable, receipt |
preiodically rolled over and deleted. |
| |
|
| =item * |
=item * |
| |
|
| receipt() : API to ireceipt working off of ENV values; given out to users |
logperm() : append a permanent message to lonnet.perm.log, this log |
| |
file never gets deleted by any automated portion of the system, only |
| |
messages of critical importance should go in here. |
| |
|
| |
=back |
| |
|
| |
=head2 General File Helper Routines |
| |
|
| |
=over 4 |
| |
|
| =item * |
=item * |
| |
|
| getfile($file) : serves up a file, returns the contents of a file or -1; |
getfile($file) : returns the entire contents of a file or -1; it |
| replicates and subscribes to the file |
properly subscribes to and replicates the file if neccessary. |
| |
|
| =item * |
=item * |
| |
|
| filelocation($dir,$file) : returns file system location of a file based on URI; |
filelocation($dir,$file) : returns file system location of a file |
| meant to be "fairly clean" absolute reference, $dir is a directory that relative $file lookups are to looked in ($dir of /a/dir and a file of ../bob will become /a/bob) |
based on URI; meant to be "fairly clean" absolute reference, $dir is a |
| |
directory that relative $file lookups are to looked in ($dir of /a/dir |
| |
and a file of ../bob will become /a/bob) |
| |
|
| =item * |
=item * |
| |
|
|
Line 3340 filelocation except for hrefs
|
Line 3597 filelocation except for hrefs
|
| |
|
| declutter() : declutters URLs (remove docroot, beginning slashes, 'res' etc) |
declutter() : declutters URLs (remove docroot, beginning slashes, 'res' etc) |
| |
|
| |
=back |
| |
|
| |
=head2 HTTP Helper Routines |
| |
|
| |
=over 4 |
| |
|
| =item * |
=item * |
| |
|
| escape() : unpack non-word characters into CGI-compatible hex codes |
escape() : unpack non-word characters into CGI-compatible hex codes |
|
Line 3348 escape() : unpack non-word characters in
|
Line 3611 escape() : unpack non-word characters in
|
| |
|
| unescape() : pack CGI-compatible hex codes into actual non-word ASCII character |
unescape() : pack CGI-compatible hex codes into actual non-word ASCII character |
| |
|
| |
=back |
| |
|
| |
=head1 PRIVATE SUBROUTINES |
| |
|
| |
=head2 Underlying communication routines (Shouldn't call) |
| |
|
| |
=over 4 |
| |
|
| |
=item * |
| |
|
| |
subreply() : tries to pass a message to lonc, returns con_lost if incapable |
| |
|
| |
=item * |
| |
|
| |
reply() : uses subreply to send a message to remote machine, logs all failures |
| |
|
| |
=item * |
| |
|
| |
critical() : passes a critical message to another server; if cannot |
| |
get through then place message in connection buffer directory and |
| |
returns con_delayed, if incapable of saving message, returns |
| |
con_failed |
| |
|
| |
=item * |
| |
|
| |
reconlonc() : tries to reconnect lonc client processes. |
| |
|
| |
=back |
| |
|
| |
=head2 Resource Access Logging |
| |
|
| |
=over 4 |
| |
|
| |
=item * |
| |
|
| |
flushcourselogs() : flush (save) buffer logs and access logs |
| |
|
| |
=item * |
| |
|
| |
courselog($what) : save message for course in hash |
| |
|
| |
=item * |
| |
|
| |
courseacclog($what) : save message for course using &courselog(). Perform |
| |
special processing for specific resource types (problems, exams, quizzes, etc). |
| |
|
| =item * |
=item * |
| |
|
| goodbye() : flush course logs and log shutting down; it is called in srm.conf |
goodbye() : flush course logs and log shutting down; it is called in srm.conf |
|
Line 3355 as a PerlChildExitHandler
|
Line 3664 as a PerlChildExitHandler
|
| |
|
| =back |
=back |
| |
|
| |
=head2 Other |
| |
|
| |
=over 4 |
| |
|
| |
=item * |
| |
|
| |
symblist($mapname,%newhash) : update symbolic storage links |
| |
|
| |
=back |
| |
|
| =cut |
=cut |
![[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