version 1.29, 2002/05/27 19:21:59
|
version 1.63, 2006/01/27 21:27:15
|
Line 1
|
Line 1
|
#!/usr/bin/perl |
#!/usr/bin/perl |
|
|
# The LearningOnline Network |
# Housekeeping program, started by cron, loncontrol and loncron.pl |
# Housekeeping program, started by cron |
|
# |
# |
# (TCP networking package |
# $Id$ |
# 6/1/99,6/2,6/10,6/11,6/12,6/14,6/26,6/28,6/29,6/30, |
# |
# 7/1,7/2,7/9,7/10,7/12 Gerd Kortemeyer) |
# Copyright Michigan State University Board of Trustees |
|
# |
|
# This file is part of the LearningOnline Network with CAPA (LON-CAPA). |
|
# |
|
# LON-CAPA is free software; you can redistribute it and/or modify |
|
# it under the terms of the GNU General Public License as published by |
|
# the Free Software Foundation; either version 2 of the License, or |
|
# (at your option) any later version. |
|
# |
|
# LON-CAPA is distributed in the hope that it will be useful, |
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of |
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
|
# GNU General Public License for more details. |
|
# |
|
# You should have received a copy of the GNU General Public License |
|
# along with LON-CAPA; if not, write to the Free Software |
|
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
|
# |
|
# /home/httpd/html/adm/gpl.txt |
|
# |
|
# http://www.lon-capa.org/ |
# |
# |
# 7/14,7/15,7/19,7/21,7/22,11/18, |
|
# 2/8 Gerd Kortemeyer |
|
# 12/6/2000,12/8 Scott Harrison |
|
# 12/23 Gerd Kortemeyer |
|
# YEAR=2001 |
|
# 1/10/2001, 2/12/, 2/26, 3/15, 04/11, 04/21,8/27 Scott Harrison |
|
# 09/04,09/06,11/26 Gerd Kortemeyer |
|
# YEAR=2002 |
|
# 5/11/2002 Scott Harrison |
|
|
|
$|=1; |
$|=1; |
|
use strict; |
|
|
use lib '/home/httpd/lib/perl/'; |
use lib '/home/httpd/lib/perl/'; |
use LONCAPA::Configuration; |
use LONCAPA::Configuration; |
|
|
use IO::File; |
use IO::File; |
use IO::Socket; |
use IO::Socket; |
|
use HTML::Entities; |
|
use Getopt::Long; |
|
#globals |
|
use vars qw (%perlvar %simplestatus $errors $warnings $notices $totalcount); |
|
|
|
my $statusdir="/home/httpd/html/lon-status"; |
|
|
|
|
# -------------------------------------------------- Non-critical communication |
# -------------------------------------------------- Non-critical communication |
sub reply { |
sub reply { |
Line 42 sub reply {
|
Line 60 sub reply {
|
|
|
# --------------------------------------------------------- Output error status |
# --------------------------------------------------------- Output error status |
|
|
|
sub log { |
|
my $fh=shift; |
|
if ($fh) { print $fh @_ } |
|
} |
|
|
sub errout { |
sub errout { |
my $fh=shift; |
my $fh=shift; |
print $fh (<<ENDERROUT); |
&log($fh,(<<ENDERROUT)); |
<p><table border=2 bgcolor="#CCCCCC"> |
<table border="2" bgcolor="#CCCCCC"> |
<tr><td>Notices</td><td>$notices</td></tr> |
<tr><td>Notices</td><td>$notices</td></tr> |
<tr><td>Warnings</td><td>$warnings</td></tr> |
<tr><td>Warnings</td><td>$warnings</td></tr> |
<tr><td>Errors</td><td>$errors</td></tr> |
<tr><td>Errors</td><td>$errors</td></tr> |
</table><p><a href="#top">Top</a><p> |
</table><p><a href="#top">Top</a></p> |
ENDERROUT |
ENDERROUT |
} |
} |
|
|
# ================================================================ Main Program |
sub start_daemon { |
|
my ($fh,$daemon,$pidfile,$args) = @_; |
# --------------------------------- Read loncapa_apache.conf and loncapa.conf |
my $progname=$daemon; |
my $perlvarref=LONCAPA::Configuration::read_conf('loncapa_apache.conf', |
if ($daemon eq 'lonc' && $args eq 'new') { |
'loncapa.conf'); |
$progname='loncnew'; |
%perlvar=%{$perlvarref}; |
print "new "; |
undef $perlvarref; |
} |
delete $perlvar{'lonReceipt'}; # remove since sensitive and not needed |
my $error_fname="$perlvar{'lonDaemons'}/logs/${daemon}_errors"; |
delete $perlvar{'lonSqlAccess'}; # remove since sensitive and not needed |
my $size=(stat($error_fname))[7]; |
|
if ($size>40000) { |
# --------------------------------------- Make sure that LON-CAPA is configured |
&log($fh,"<p>Rotating error logs ...</p>"); |
# I only test for one thing here (lonHostID). This is just a safeguard. |
rename("$error_fname.2","$error_fname.3"); |
if ('{[[[[lonHostID]]]]}' eq $perlvar{'lonHostID'}) { |
rename("$error_fname.1","$error_fname.2"); |
print("Unconfigured machine.\n"); |
rename("$error_fname","$error_fname.1"); |
$emailto=$perlvar{'lonSysEMail'}; |
} |
$hostname=`/bin/hostname`; |
system("$perlvar{'lonDaemons'}/$progname 2>$perlvar{'lonDaemons'}/logs/${daemon}_errors"); |
chop $hostname; |
sleep 1; |
$hostname=~s/[^\w\.]//g; # make sure is safe to pass through shell |
if (-e $pidfile) { |
$subj="LON: Unconfigured machine $hostname"; |
&log($fh,"<p>Seems like it started ...</p>"); |
system("echo 'Unconfigured machine $hostname.' |\ |
my $lfh=IO::File->new("$pidfile"); |
mailto $emailto -s '$subj' > /dev/null"); |
my $daemonpid=<$lfh>; |
exit 1; |
chomp($daemonpid); |
|
if ($daemonpid =~ /^\d+$/ && kill 0 => $daemonpid) { |
|
return 1; |
|
} else { |
|
return 0; |
|
} |
|
} |
|
&log($fh,"<p>Seems like that did not work!</p>"); |
|
$errors++; |
|
return 0; |
} |
} |
|
|
# ----------------------------- Make sure this process is running from user=www |
sub checkon_daemon { |
my $wwwid=getpwnam('www'); |
my ($fh,$daemon,$maxsize,$send,$args)=@_; |
if ($wwwid!=$<) { |
|
print("User ID mismatch. This program must be run as user 'www'\n"); |
|
$emailto="$perlvar{'lonAdmEMail'},$perlvar{'lonSysEMail'}"; |
|
$subj="LON: $perlvar{'lonHostID'} User ID mismatch"; |
|
system("echo 'User ID mismatch. loncron must be run as user www.' |\ |
|
mailto $emailto -s '$subj' > /dev/null"); |
|
exit 1; |
|
} |
|
|
|
# ------------------------------------------------------------- Read hosts file |
my $result; |
{ |
&log($fh,'<hr /><a name="'.$daemon.'" /><h2>'.$daemon.'</h2><h3>Log</h3><p style="white-space: pre;"><tt>'); |
my $config=IO::File->new("$perlvar{'lonTabDir'}/hosts.tab"); |
printf("%-15s ",$daemon); |
|
if (-e "$perlvar{'lonDaemons'}/logs/$daemon.log"){ |
|
open (DFH,"tail -n25 $perlvar{'lonDaemons'}/logs/$daemon.log|"); |
|
while (my $line=<DFH>) { |
|
&log($fh,"$line"); |
|
if ($line=~/INFO/) { $notices++; } |
|
if ($line=~/WARNING/) { $notices++; } |
|
if ($line=~/CRITICAL/) { $warnings++; } |
|
}; |
|
close (DFH); |
|
} |
|
&log($fh,"</tt></p>"); |
|
|
|
my $pidfile="$perlvar{'lonDaemons'}/logs/$daemon.pid"; |
|
|
|
my $restartflag=1; |
|
my $daemonpid; |
|
if (-e $pidfile) { |
|
my $lfh=IO::File->new("$pidfile"); |
|
$daemonpid=<$lfh>; |
|
chomp($daemonpid); |
|
if ($daemonpid =~ /^\d+$/ && kill 0 => $daemonpid) { |
|
&log($fh,"<h3>$daemon at pid $daemonpid responding"); |
|
if ($send) { &log($fh,", sending $send"); } |
|
&log($fh,"</h3>"); |
|
if ($send eq 'USR1') { kill USR1 => $daemonpid; } |
|
if ($send eq 'USR2') { kill USR2 => $daemonpid; } |
|
$restartflag=0; |
|
if ($send eq 'USR2') { |
|
$result = 'reloaded'; |
|
print "reloaded\n"; |
|
} else { |
|
$result = 'running'; |
|
print "running\n"; |
|
} |
|
} else { |
|
$errors++; |
|
&log($fh,"<h3>$daemon at pid $daemonpid not responding</h3>"); |
|
$restartflag=1; |
|
&log($fh,"<h3>Decided to clean up stale .pid file and restart $daemon</h3>"); |
|
} |
|
} |
|
if ($restartflag==1) { |
|
$simplestatus{$daemon}='off'; |
|
$errors++; |
|
my $kadaemon=$daemon; |
|
if ($kadaemon eq 'lonmemcached') { $kadaemon='memcached'; } |
|
&log($fh,'<br><font color="red">Killall '.$daemon.': '. |
|
`killall $kadaemon 2>&1`.' - '); |
|
sleep 1; |
|
&log($fh,unlink($pidfile).' - '. |
|
`killall -9 $kadaemon 2>&1`. |
|
'</font><br>'); |
|
&log($fh,"<h3>$daemon not running, trying to start</h3>"); |
|
|
|
if (&start_daemon($fh,$daemon,$pidfile,$args)) { |
|
&log($fh,"<h3>$daemon at pid $daemonpid responding</h3>"); |
|
$simplestatus{$daemon}='restarted'; |
|
$result = 'started'; |
|
print "started\n"; |
|
} else { |
|
$errors++; |
|
&log($fh,"<h3>$daemon at pid $daemonpid not responding</h3>"); |
|
&log($fh,"<p>Give it one more try ...</p>"); |
|
print " "; |
|
if (&start_daemon($fh,$daemon,$pidfile,$args)) { |
|
&log($fh,"<h3>$daemon at pid $daemonpid responding</h3>"); |
|
$simplestatus{$daemon}='restarted'; |
|
$result = 'started'; |
|
print "started\n"; |
|
} else { |
|
$result = 'failed'; |
|
print " failed\n"; |
|
$simplestatus{$daemon}='failed'; |
|
$errors++; $errors++; |
|
&log($fh,"<h3>$daemon at pid $daemonpid not responding</h3>"); |
|
&log($fh,"<p>Unable to start $daemon</p>"); |
|
} |
|
} |
|
|
while (my $configline=<$config>) { |
if (-e "$perlvar{'lonDaemons'}/logs/$daemon.log"){ |
my ($id,$domain,$role,$name,$ip)=split(/:/,$configline); |
&log($fh,"<p><pre>"); |
$hostname{$id}=$name; |
open (DFH,"tail -n100 $perlvar{'lonDaemons'}/logs/$daemon.log|"); |
$hostdom{$id}=$domain; |
while (my $line=<DFH>) { |
$hostrole{$id}=$role; |
&log($fh,"$line"); |
$hostip{$id}=$ip; |
if ($line=~/WARNING/) { $notices++; } |
if (($role eq 'library') && ($id ne $perlvar{'lonHostID'})) { |
if ($line=~/CRITICAL/) { $notices++; } |
$libserv{$id}=$name; |
}; |
} |
close (DFH); |
|
&log($fh,"</pre></p>"); |
|
} |
|
} |
|
|
|
my $fname="$perlvar{'lonDaemons'}/logs/$daemon.log"; |
|
|
|
my ($dev,$ino,$mode,$nlink, |
|
$uid,$gid,$rdev,$size, |
|
$atime,$mtime,$ctime, |
|
$blksize,$blocks)=stat($fname); |
|
|
|
if ($size>$maxsize) { |
|
&log($fh,"<p>Rotating logs ...</p>"); |
|
rename("$fname.2","$fname.3"); |
|
rename("$fname.1","$fname.2"); |
|
rename("$fname","$fname.1"); |
} |
} |
|
|
|
&errout($fh); |
|
return $result; |
} |
} |
|
|
# ------------------------------------------------------ Read spare server file |
# --------------------------------------------------------------------- Machine |
{ |
sub log_machine_info { |
my $config=IO::File->new("$perlvar{'lonTabDir'}/spare.tab"); |
my ($fh)=@_; |
|
&log($fh,'<hr /><a name="machine" /><h2>Machine Information</h2>'); |
|
&log($fh,"<h3>loadavg</h3>"); |
|
|
|
open (LOADAVGH,"/proc/loadavg"); |
|
my $loadavg=<LOADAVGH>; |
|
close (LOADAVGH); |
|
|
|
&log($fh,"<tt>$loadavg</tt>"); |
|
|
|
my @parts=split(/\s+/,$loadavg); |
|
if ($parts[1]>4.0) { |
|
$errors++; |
|
} elsif ($parts[1]>2.0) { |
|
$warnings++; |
|
} elsif ($parts[1]>1.0) { |
|
$notices++; |
|
} |
|
|
while (my $configline=<$config>) { |
&log($fh,"<h3>df</h3>"); |
chomp($configline); |
&log($fh,"<pre>"); |
if (($configline) && ($configline ne $perlvar{'lonHostID'})) { |
|
$spareid{$configline}=1; |
open (DFH,"df|"); |
} |
while (my $line=<DFH>) { |
|
&log($fh,&encode_entities($line,'<>&"')); |
|
@parts=split(/\s+/,$line); |
|
my $usage=$parts[4]; |
|
$usage=~s/\W//g; |
|
if ($usage>90) { |
|
$warnings++; |
|
$notices++; |
|
} elsif ($usage>80) { |
|
$warnings++; |
|
} elsif ($usage>60) { |
|
$notices++; |
|
} |
|
if ($usage>95) { $warnings++; $warnings++; $simplestatus{'diskfull'}++; } |
} |
} |
} |
close (DFH); |
|
&log($fh,"</pre>"); |
|
|
# ---------------------------------------------------------------- Start report |
|
|
|
$statusdir="/home/httpd/html/lon-status"; |
&log($fh,"<h3>ps</h3>"); |
|
&log($fh,"<pre>"); |
|
my $psproc=0; |
|
|
$errors=0; |
open (PSH,"ps aux --cols 140 |"); |
$warnings=0; |
while (my $line=<PSH>) { |
$notices=0; |
&log($fh,&encode_entities($line,'<>&"')); |
|
$psproc++; |
|
} |
|
close (PSH); |
|
&log($fh,"</pre>"); |
|
|
$now=time; |
if ($psproc>200) { $notices++; } |
$date=localtime($now); |
if ($psproc>250) { $notices++; } |
|
|
{ |
&log($fh,"<h3>distprobe</h3>"); |
my $fh=IO::File->new(">$statusdir/newstatus.html"); |
&log($fh,"<pre>"); |
|
open(DSH,"$perlvar{'lonDaemons'}/distprobe |"); |
|
while (my $line=<DSH>) { |
|
&log($fh,&encode_entities($line,'<>&"')); |
|
$psproc++; |
|
} |
|
close(DSH); |
|
&log($fh,"</pre>"); |
|
|
print $fh (<<ENDHEADERS); |
&errout($fh); |
|
} |
|
|
|
sub start_logging { |
|
my ($hostdom,$hostrole,$hostname,$spareid)=@_; |
|
my $fh=IO::File->new(">$statusdir/newstatus.html"); |
|
my %simplestatus=(); |
|
my $now=time; |
|
my $date=localtime($now); |
|
|
|
|
|
&log($fh,(<<ENDHEADERS)); |
<html> |
<html> |
<head> |
<head> |
<title>LON Status Report $perlvar{'lonHostID'}</title> |
<title>LON Status Report $perlvar{'lonHostID'}</title> |
</head> |
</head> |
<body bgcolor="#AAAAAA"> |
<body bgcolor="#AAAAAA"> |
<a name="top"> |
<a name="top" /> |
<h1>LON Status Report $perlvar{'lonHostID'}</h1> |
<h1>LON Status Report $perlvar{'lonHostID'}</h1> |
<h2>$date ($now)</h2> |
<h2>$date ($now)</h2> |
<ol> |
<ol> |
<li><a href="#configuration">Configuration</a> |
<li><a href="#configuration">Configuration</a></li> |
<li><a href="#machine">Machine Information</a> |
<li><a href="#machine">Machine Information</a></li> |
<li><a href="#tmp">Temporary Files</a> |
<li><a href="#tmp">Temporary Files</a></li> |
<li><a href="#tokens">Session Tokens</a> |
<li><a href="#tokens">Session Tokens</a></li> |
<li><a href="#httpd">httpd</a> |
<li><a href="#httpd">httpd</a></li> |
<li><a href="#lonsql">lonsql</a> |
<li><a href="#lonsql">lonsql</a></li> |
<li><a href="#lond">lond</a> |
<li><a href="#lond">lond</a></li> |
<li><a href="#lonc">lonc</a> |
<li><a href="#lonc">lonc</a></li> |
<li><a href="#lonnet">lonnet</a> |
<li><a href="#lonhttpd">lonhttpd</a></li> |
<li><a href="#connections">Connections</a> |
<li><a href="#lonnet">lonnet</a></li> |
<li><a href="#delayed">Delayed Messages</a> |
<li><a href="#connections">Connections</a></li> |
<li><a href="#errcount">Error Count</a> |
<li><a href="#delayed">Delayed Messages</a></li> |
|
<li><a href="#errcount">Error Count</a></li> |
</ol> |
</ol> |
<hr> |
<hr /> |
<a name="configuration"> |
<a name="configuration" /> |
<h2>Configuration</h2> |
<h2>Configuration</h2> |
<h3>PerlVars</h3> |
<h3>PerlVars</h3> |
<table border=2> |
<table border="2"> |
ENDHEADERS |
ENDHEADERS |
|
|
foreach $varname (keys %perlvar) { |
foreach my $varname (sort(keys(%perlvar))) { |
print $fh "<tr><td>$varname</td><td>$perlvar{$varname}</td></tr>\n"; |
&log($fh,"<tr><td>$varname</td><td>". |
} |
&encode_entities($perlvar{$varname},'<>&"')."</td></tr>\n"); |
print $fh "</table><h3>Hosts</h3><table border=2>"; |
} |
foreach $id (keys %hostname) { |
&log($fh,"</table><h3>Hosts</h3><table border='2'>"); |
print $fh |
foreach my $id (sort(keys(%{$hostname}))) { |
"<tr><td>$id</td><td>$hostdom{$id}</td><td>$hostrole{$id}</td>"; |
&log($fh, |
print $fh "<td>$hostname{$id}</td><td>$hostip{$id}</td></tr>\n"; |
"<tr><td>$id</td><td>".$hostdom->{$id}. |
} |
"</td><td>".$hostrole->{$id}. |
print $fh "</table><h3>Spare Hosts</h3><ol>"; |
"</td><td>".$hostname->{$id}."</td></tr>\n"); |
foreach $id (keys %spareid) { |
} |
print $fh "<li>$id\n"; |
&log($fh,"</table><h3>Spare Hosts</h3><ol>"); |
} |
foreach my $id (sort(keys(%{$spareid}))) { |
|
&log($fh,"<li>$id\n</li>"); |
print $fh "</ol>\n"; |
} |
|
&log($fh,"</ol>\n"); |
# --------------------------------------------------------------------- Machine |
return $fh; |
|
|
print $fh '<hr><a name="machine"><h2>Machine Information</h2>'; |
|
print $fh "<h3>loadavg</h3>"; |
|
|
|
open (LOADAVGH,"/proc/loadavg"); |
|
$loadavg=<LOADAVGH>; |
|
close (LOADAVGH); |
|
|
|
print $fh "<tt>$loadavg</tt>"; |
|
|
|
@parts=split(/\s+/,$loadavg); |
|
if ($parts[1]>4.0) { |
|
$errors++; |
|
} elsif ($parts[1]>2.0) { |
|
$warnings++; |
|
} elsif ($parts[1]>1.0) { |
|
$notices++; |
|
} |
|
|
|
print $fh "<h3>df</h3>"; |
|
print $fh "<pre>"; |
|
|
|
open (DFH,"df|"); |
|
while ($line=<DFH>) { |
|
print $fh "$line"; |
|
@parts=split(/\s+/,$line); |
|
$usage=$parts[4]; |
|
$usage=~s/\W//g; |
|
if ($usage>90) { |
|
$warnings++; |
|
$notices++; |
|
} elsif ($usage>80) { |
|
$warnings++; |
|
} elsif ($usage>60) { |
|
$notices++; |
|
} |
|
if ($usage>95) { $warnings++; $warnings++ } |
|
} |
|
close (DFH); |
|
print $fh "</pre>"; |
|
|
|
|
|
print $fh "<h3>ps</h3>"; |
|
print $fh "<pre>"; |
|
$psproc=0; |
|
|
|
open (PSH,"ps -aux|"); |
|
while ($line=<PSH>) { |
|
print $fh "$line"; |
|
$psproc++; |
|
} |
} |
close (PSH); |
|
print $fh "</pre>"; |
|
|
|
if ($psproc>200) { $notices++; } |
|
if ($psproc>250) { $notices++; } |
|
|
|
&errout($fh); |
|
|
|
# --------------------------------------------------------------- clean out tmp |
# --------------------------------------------------------------- clean out tmp |
print $fh '<hr><a name="tmp"><h2>Temporary Files</h2>'; |
sub clean_tmp { |
$cleaned=0; |
my ($fh)=@_; |
$old=0; |
&log($fh,'<hr /><a name="tmp" /><h2>Temporary Files</h2>'); |
while ($fname=<$perlvar{'lonDaemons'}/tmp/*>) { |
my $cleaned=0; |
my ($dev,$ino,$mode,$nlink, |
my $old=0; |
$uid,$gid,$rdev,$size, |
while (my $fname=<$perlvar{'lonDaemons'}/tmp/*>) { |
$atime,$mtime,$ctime, |
my ($dev,$ino,$mode,$nlink, |
$blksize,$blocks)=stat($fname); |
$uid,$gid,$rdev,$size, |
$now=time; |
$atime,$mtime,$ctime, |
$since=$now-$mtime; |
$blksize,$blocks)=stat($fname); |
if ($since>$perlvar{'lonExpire'}) { |
my $now=time; |
$line=''; |
my $since=$now-$mtime; |
if (open(PROBE,$fname)) { |
if ($since>$perlvar{'lonExpire'}) { |
$line=<PROBE>; |
my $line=''; |
close(PROBE); |
if (open(PROBE,$fname)) { |
} |
$line=<PROBE>; |
unless ($line=~/^CHECKOUTTOKEN\&/) { |
close(PROBE); |
$cleaned++; |
} |
unlink("$fname"); |
unless ($line=~/^CHECKOUTTOKEN\&/) { |
} else { |
$cleaned++; |
if ($since>100*$perlvar{'lonExpire'}) { |
unlink("$fname"); |
$cleaned++; |
} else { |
unlink("$fname"); |
if ($since>365*$perlvar{'lonExpire'}) { |
} else { $old++; } |
$cleaned++; |
} |
unlink("$fname"); |
} |
} else { $old++; } |
|
} |
|
} |
|
} |
|
&log($fh,"Cleaned up ".$cleaned." files (".$old." old checkout tokens)."); |
} |
} |
print $fh "Cleaned up ".$cleaned." files (".$old." old checkout tokens)."; |
|
|
|
# ------------------------------------------------------------ clean out lonIDs |
# ------------------------------------------------------------ clean out lonIDs |
print $fh '<hr><a name="tokens"><h2>Session Tokens</h2>'; |
sub clean_lonIDs { |
$cleaned=0; |
my ($fh)=@_; |
$active=0; |
&log($fh,'<hr /><a name="tokens" /><h2>Session Tokens</h2>'); |
while ($fname=<$perlvar{'lonIDsDir'}/*>) { |
my $cleaned=0; |
my ($dev,$ino,$mode,$nlink, |
my $active=0; |
$uid,$gid,$rdev,$size, |
while (my $fname=<$perlvar{'lonIDsDir'}/*>) { |
$atime,$mtime,$ctime, |
my ($dev,$ino,$mode,$nlink, |
$blksize,$blocks)=stat($fname); |
$uid,$gid,$rdev,$size, |
$now=time; |
$atime,$mtime,$ctime, |
$since=$now-$mtime; |
$blksize,$blocks)=stat($fname); |
if ($since>$perlvar{'lonExpire'}) { |
my $now=time; |
$cleaned++; |
my $since=$now-$mtime; |
print $fh "Unlinking $fname<br>"; |
if ($since>$perlvar{'lonExpire'}) { |
unlink("$fname"); |
$cleaned++; |
} else { |
&log($fh,"Unlinking $fname<br>"); |
$active++; |
unlink("$fname"); |
} |
} else { |
|
$active++; |
|
} |
|
} |
|
&log($fh,"<p>Cleaned up ".$cleaned." stale session token(s).</p>"); |
|
&log($fh,"<h3>$active open session(s)</h3>"); |
} |
} |
print $fh "<p>Cleaned up ".$cleaned." stale session token(s)."; |
|
print $fh "<h3>$active open session(s)</h3>"; |
|
|
|
# ----------------------------------------------------------------------- httpd |
# ----------------------------------------------------------------------- httpd |
|
sub check_httpd_logs { |
|
my ($fh)=@_; |
|
&log($fh,'<hr /><a name="httpd" /><h2>httpd</h2><h3>Access Log</h3><pre>'); |
|
|
|
open (DFH,"tail -n25 /etc/httpd/logs/access_log|"); |
|
while (my $line=<DFH>) { &log($fh,&encode_entities($line,'<>&"')) }; |
|
close (DFH); |
|
|
|
&log($fh,"</pre><h3>Error Log</h3><pre>"); |
|
|
|
open (DFH,"tail -n25 /etc/httpd/logs/error_log|"); |
|
while (my $line=<DFH>) { |
|
&log($fh,"$line"); |
|
if ($line=~/\[error\]/) { $notices++; } |
|
} |
|
close (DFH); |
|
&log($fh,"</pre>"); |
|
&errout($fh); |
|
} |
|
|
print $fh '<hr><a name="httpd"><h2>httpd</h2><h3>Access Log</h3><pre>'; |
# ---------------------------------------------------------------------- lonnet |
|
|
open (DFH,"tail -n25 /etc/httpd/logs/access_log|"); |
sub rotate_lonnet_logs { |
while ($line=<DFH>) { print $fh "$line" }; |
my ($fh)=@_; |
close (DFH); |
&log($fh,'<hr /><a name="lonnet" /><h2>lonnet</h2><h3>Temp Log</h3><pre>'); |
|
print "checking logs\n"; |
print $fh "</pre><h3>Error Log</h3><pre>"; |
if (-e "$perlvar{'lonDaemons'}/logs/lonnet.log"){ |
|
open (DFH,"tail -n50 $perlvar{'lonDaemons'}/logs/lonnet.log|"); |
open (DFH,"tail -n25 /etc/httpd/logs/error_log|"); |
while (my $line=<DFH>) { |
while ($line=<DFH>) { |
&log($fh,&encode_entities($line,'<>&"')); |
print $fh "$line"; |
} |
if ($line=~/\[error\]/) { $notices++; } |
|
}; |
|
close (DFH); |
|
print $fh "</pre>"; |
|
&errout($fh); |
|
|
|
|
|
# ---------------------------------------------------------------------- lonsql |
|
|
|
my $restartflag=1; |
|
if ($perlvar{'lonRole'} eq "library") { |
|
|
|
print $fh '<hr><a name="lonsql"><h2>lonsql</h2><h3>Log</h3><pre>'; |
|
print "lonsql\n"; |
|
if (-e "$perlvar{'lonDaemons'}/logs/lonsql.log"){ |
|
open (DFH,"tail -n100 $perlvar{'lonDaemons'}/logs/lonsql.log|"); |
|
while ($line=<DFH>) { |
|
print $fh "$line"; |
|
if ($line=~/INFO/) { $notices++; } |
|
if ($line=~/WARNING/) { $notices++; } |
|
if ($line=~/CRITICAL/) { $warnings++; } |
|
}; |
|
close (DFH); |
close (DFH); |
} |
} |
print $fh "</pre>"; |
&log($fh,"</pre><h3>Perm Log</h3><pre>"); |
|
|
my $lonsqlfile="$perlvar{'lonDaemons'}/logs/lonsql.pid"; |
if (-e "$perlvar{'lonDaemons'}/logs/lonnet.perm.log") { |
|
open(DFH,"tail -n10 $perlvar{'lonDaemons'}/logs/lonnet.perm.log|"); |
$restartflag=1; |
while (my $line=<DFH>) { |
|
&log($fh,&encode_entities($line,'<>&"')); |
if (-e $lonsqlfile) { |
|
my $lfh=IO::File->new("$lonsqlfile"); |
|
my $lonsqlpid=<$lfh>; |
|
chomp($lonsqlpid); |
|
if (kill 0 => $lonsqlpid) { |
|
print $fh "<h3>lonsql at pid $lonsqlpid responding</h3>"; |
|
$restartflag=0; |
|
} else { |
|
$errors++; $errors++; |
|
print $fh "<h3>lonsql at pid $lonsqlpid not responding</h3>"; |
|
$restartflag=1; |
|
print $fh |
|
"<h3>Decided to clean up stale .pid file and restart lonsql</h3>"; |
|
} |
} |
} |
close (DFH); |
if ($restartflag==1) { |
} else { &log($fh,"No perm log\n") } |
$errors++; |
|
print $fh '<br><font color="red">Killall lonsql: '. |
|
system('killall lonsql').' - '; |
|
sleep 60; |
|
print $fh unlink($lonsqlfile).' - '. |
|
system('killall -9 lonsql'). |
|
'</font><br>'; |
|
print $fh "<h3>lonsql not running, trying to start</h3>"; |
|
system( |
|
"$perlvar{'lonDaemons'}/lonsql 2>>$perlvar{'lonDaemons'}/logs/lonsql_errors"); |
|
sleep 10; |
|
if (-e $lonsqlfile) { |
|
print $fh "Seems like it started ...<p>"; |
|
my $lfh=IO::File->new("$lonsqlfile"); |
|
my $lonsqlpid=<$lfh>; |
|
chomp($lonsqlpid); |
|
sleep 30; |
|
if (kill 0 => $lonsqlpid) { |
|
print $fh "<h3>lonsql at pid $lonsqlpid responding</h3>"; |
|
} else { |
|
$errors++; $errors++; |
|
print $fh "<h3>lonsql at pid $lonsqlpid not responding</h3>"; |
|
print $fh "Give it one more try ...<p>"; |
|
system( |
|
"$perlvar{'lonDaemons'}/lonsql 2>>$perlvar{'lonDaemons'}/logs/lonsql_errors"); |
|
sleep 10; |
|
} |
|
} else { |
|
print $fh "Seems like that did not work!<p>"; |
|
$errors++; |
|
} |
|
if (-e "$perlvar{'lonDaemons'}/logs/lonsql.log"){ |
|
print $fh "<p><pre>"; |
|
open (DFH,"tail -n100 $perlvar{'lonDaemons'}/logs/lonsql.log|"); |
|
while ($line=<DFH>) { |
|
print $fh "$line"; |
|
if ($line=~/WARNING/) { $notices++; } |
|
if ($line=~/CRITICAL/) { $notices++; } |
|
}; |
|
close (DFH); |
|
print $fh "</pre>"; |
|
} |
|
} |
|
|
|
$fname="$perlvar{'lonDaemons'}/logs/lonsql.log"; |
my $fname="$perlvar{'lonDaemons'}/logs/lonnet.log"; |
|
|
my ($dev,$ino,$mode,$nlink, |
my ($dev,$ino,$mode,$nlink, |
$uid,$gid,$rdev,$size, |
$uid,$gid,$rdev,$size, |
Line 401 if ($perlvar{'lonRole'} eq "library") {
|
Line 466 if ($perlvar{'lonRole'} eq "library") {
|
$blksize,$blocks)=stat($fname); |
$blksize,$blocks)=stat($fname); |
|
|
if ($size>40000) { |
if ($size>40000) { |
print $fh "Rotating logs ...<p>"; |
&log($fh,"<p>Rotating logs ...</p>"); |
rename("$fname.2","$fname.3"); |
rename("$fname.2","$fname.3"); |
rename("$fname.1","$fname.2"); |
rename("$fname.1","$fname.2"); |
rename("$fname","$fname.1"); |
rename("$fname","$fname.1"); |
} |
} |
|
|
|
&log($fh,"</pre>"); |
&errout($fh); |
&errout($fh); |
} |
} |
# ------------------------------------------------------------------------ lond |
|
|
|
print $fh '<hr><a name="lond"><h2>lond</h2><h3>Log</h3><pre>'; |
|
print "lond\n"; |
|
|
|
if (-e "$perlvar{'lonDaemons'}/logs/lond.log"){ |
# ----------------------------------------------------------------- Connections |
open (DFH,"tail -n25 $perlvar{'lonDaemons'}/logs/lond.log|"); |
sub test_connections { |
while ($line=<DFH>) { |
my ($fh,$hostname)=@_; |
print $fh "$line"; |
&log($fh,'<hr /><a name="connections" /><h2>Connections</h2>'); |
if ($line=~/INFO/) { $notices++; } |
print "testing connections\n"; |
if ($line=~/WARNING/) { $notices++; } |
&log($fh,"<table border='2'>"); |
if ($line=~/CRITICAL/) { $warnings++; } |
my ($good,$bad)=(0,0); |
}; |
foreach my $tryserver (sort(keys(%{$hostname}))) { |
close (DFH); |
print("."); |
} |
my $result; |
print $fh "</pre>"; |
my $answer=reply("ping",$tryserver); |
|
if ($answer eq "$tryserver:$perlvar{'lonHostID'}") { |
my $londfile="$perlvar{'lonDaemons'}/logs/lond.pid"; |
$result="<b>ok</b>"; |
|
$good++; |
$restartflag=1; |
} else { |
if (-e $londfile) { |
$result=$answer; |
my $lfh=IO::File->new("$londfile"); |
$warnings++; |
my $londpid=<$lfh>; |
if ($answer eq 'con_lost') { |
chomp($londpid); |
$bad++; |
if (kill 0 => $londpid) { |
$warnings++; |
print $fh "<h3>lond at pid $londpid responding, sending USR1</h3>"; |
} else { |
kill USR1 => $londpid; |
$good++; #self connection |
$restartflag=0; |
} |
} else { |
} |
$errors++; |
if ($answer =~ /con_lost/) { print(" $tryserver down\n"); } |
print $fh "<h3>lond at pid $londpid not responding</h3>"; |
&log($fh,"<tr><td>$tryserver</td><td>$result</td></tr>\n"); |
$restartflag=1; |
} |
print $fh |
&log($fh,"</table>"); |
"<h3>Decided to clean up stale .pid file and restart lond</h3>"; |
print "\n$good good, $bad bad connections\n"; |
} |
&errout($fh); |
} |
|
if ($restartflag==1) { |
|
$errors++; |
|
print $fh '<br><font color="red">Killall lond: '. |
|
system('killall lond').' - '; |
|
sleep 60; |
|
print $fh unlink($londfile).' - '.system('killall -9 lond'). |
|
'</font><br>'; |
|
print $fh "<h3>lond not running, trying to start</h3>"; |
|
system( |
|
"$perlvar{'lonDaemons'}/lond 2>>$perlvar{'lonDaemons'}/logs/lond_errors"); |
|
sleep 10; |
|
if (-e $londfile) { |
|
print $fh "Seems like it started ...<p>"; |
|
my $lfh=IO::File->new("$londfile"); |
|
my $londpid=<$lfh>; |
|
chomp($londpid); |
|
sleep 30; |
|
if (kill 0 => $londpid) { |
|
print $fh "<h3>lond at pid $londpid responding</h3>"; |
|
} else { |
|
$errors++; $errors++; |
|
print $fh "<h3>lond at pid $londpid not responding</h3>"; |
|
print $fh "Give it one more try ...<p>"; |
|
system( |
|
"$perlvar{'lonDaemons'}/lond 2>>$perlvar{'lonDaemons'}/logs/lond_errors"); |
|
sleep 10; |
|
} |
|
} else { |
|
print $fh "Seems like that did not work!<p>"; |
|
$errors++; |
|
} |
|
if (-e "$perlvar{'lonDaemons'}/logs/lond.log"){ |
|
print $fh "<p><pre>"; |
|
open (DFH,"tail -n100 $perlvar{'lonDaemons'}/logs/lond.log|"); |
|
while ($line=<DFH>) { |
|
print $fh "$line"; |
|
if ($line=~/WARNING/) { $notices++; } |
|
if ($line=~/CRITICAL/) { $notices++; } |
|
}; |
|
close (DFH); |
|
print $fh "</pre>"; |
|
} |
|
} |
} |
|
|
$fname="$perlvar{'lonDaemons'}/logs/lond.log"; |
|
|
|
my ($dev,$ino,$mode,$nlink, |
# ------------------------------------------------------------ Delayed messages |
$uid,$gid,$rdev,$size, |
sub check_delayed_msg { |
$atime,$mtime,$ctime, |
my ($fh)=@_; |
$blksize,$blocks)=stat($fname); |
&log($fh,'<hr /><a name="delayed" /><h2>Delayed Messages</h2>'); |
|
print "checking buffers\n"; |
if ($size>40000) { |
|
print $fh "Rotating logs ...<p>"; |
&log($fh,'<h3>Scanning Permanent Log</h3>'); |
rename("$fname.2","$fname.3"); |
|
rename("$fname.1","$fname.2"); |
|
rename("$fname","$fname.1"); |
|
} |
|
|
|
&errout($fh); |
|
# ------------------------------------------------------------------------ lonc |
|
|
|
print $fh '<hr><a name="lonc"><h2>lonc</h2><h3>Log</h3><pre>'; |
|
print "lonc\n"; |
|
|
|
if (-e "$perlvar{'lonDaemons'}/logs/lonc.log"){ |
|
open (DFH,"tail -n25 $perlvar{'lonDaemons'}/logs/lonc.log|"); |
|
while ($line=<DFH>) { |
|
print $fh "$line"; |
|
if ($line=~/INFO/) { $notices++; } |
|
if ($line=~/WARNING/) { $notices++; } |
|
if ($line=~/CRITICAL/) { $warnings++; } |
|
}; |
|
close (DFH); |
|
} |
|
print $fh "</pre>"; |
|
|
|
my $loncfile="$perlvar{'lonDaemons'}/logs/lonc.pid"; |
|
|
|
$restartflag=1; |
|
if (-e $loncfile) { |
|
my $lfh=IO::File->new("$loncfile"); |
|
my $loncpid=<$lfh>; |
|
chomp($loncpid); |
|
if (kill 0 => $loncpid) { |
|
print $fh "<h3>lonc at pid $loncpid responding, sending USR1</h3>"; |
|
kill USR1 => $loncpid; |
|
$restartflag=0; |
|
} else { |
|
$errors++; |
|
print $fh "<h3>lonc at pid $loncpid not responding</h3>"; |
|
# Solution: kill parent and children processes, remove .pid and restart |
|
$restartflag=1; |
|
print $fh |
|
"<h3>Decided to clean up stale .pid file and restart lonc</h3>"; |
|
} |
|
} |
|
if ($restartflag==1) { |
|
$errors++; |
|
print $fh '<br><font color="red">Killall lonc: '. |
|
system('killall lonc').' - '; |
|
sleep 60; |
|
print $fh unlink($loncfile).' - '.system('killall -9 lonc'). |
|
'</font><br>'; |
|
print $fh "<h3>lonc not running, trying to start</h3>"; |
|
system( |
|
"$perlvar{'lonDaemons'}/lonc 2>>$perlvar{'lonDaemons'}/logs/lonc_errors"); |
|
sleep 10; |
|
if (-e $loncfile) { |
|
print $fh "Seems like it started ...<p>"; |
|
my $lfh=IO::File->new("$loncfile"); |
|
my $loncpid=<$lfh>; |
|
chomp($loncpid); |
|
sleep 30; |
|
if (kill 0 => $loncpid) { |
|
print $fh "<h3>lonc at pid $loncpid responding</h3>"; |
|
} else { |
|
$errors++; $errors++; |
|
print $fh "<h3>lonc at pid $loncpid not responding</h3>"; |
|
print $fh "Give it one more try ...<p>"; |
|
system( |
|
"$perlvar{'lonDaemons'}/lonc 2>>$perlvar{'lonDaemons'}/logs/lonc_errors"); |
|
sleep 10; |
|
} |
|
} else { |
|
print $fh "Seems like that did not work!<p>"; |
|
$errors++; |
|
} |
|
if (-e "$perlvar{'lonDaemons'}/logs/lonc.log") { |
|
print $fh "<p><pre>"; |
|
open (DFH,"tail -n100 $perlvar{'lonDaemons'}/logs/lonc.log|"); |
|
while ($line=<DFH>) { |
|
print $fh "$line"; |
|
if ($line=~/WARNING/) { $notices++; } |
|
if ($line=~/CRITICAL/) { $notices++; } |
|
}; |
|
close (DFH); |
|
print $fh "</pre>"; |
|
} |
|
} |
|
|
|
$fname="$perlvar{'lonDaemons'}/logs/lonc.log"; |
my $unsend=0; |
|
|
my ($dev,$ino,$mode,$nlink, |
my $dfh=IO::File->new("$perlvar{'lonDaemons'}/logs/lonnet.perm.log"); |
$uid,$gid,$rdev,$size, |
while (my $line=<$dfh>) { |
$atime,$mtime,$ctime, |
my ($time,$sdf,$dserv,$dcmd)=split(/:/,$line); |
$blksize,$blocks)=stat($fname); |
if ($sdf eq 'F') { |
|
my $local=localtime($time); |
|
&log($fh,"<b>Failed: $time, $dserv, $dcmd</b><br>"); |
|
$warnings++; |
|
} |
|
if ($sdf eq 'S') { $unsend--; } |
|
if ($sdf eq 'D') { $unsend++; } |
|
} |
|
|
if ($size>40000) { |
&log($fh,"<p>Total unsend messages: <b>$unsend</b></p>\n"); |
print $fh "Rotating logs ...<p>"; |
$warnings=$warnings+5*$unsend; |
rename("$fname.2","$fname.3"); |
|
rename("$fname.1","$fname.2"); |
|
rename("$fname","$fname.1"); |
|
} |
|
|
|
|
if ($unsend) { $simplestatus{'unsend'}=$unsend; } |
&errout($fh); |
&log($fh,"<h3>Outgoing Buffer</h3>\n<pre>"); |
# ---------------------------------------------------------------------- lonnet |
|
|
|
print $fh '<hr><a name="lonnet"><h2>lonnet</h2><h3>Temp Log</h3><pre>'; |
open (DFH,"ls -lF $perlvar{'lonSockDir'}/delayed|"); |
print "lonnet\n"; |
while (my $line=<DFH>) { |
if (-e "$perlvar{'lonDaemons'}/logs/lonnet.log"){ |
&log($fh,&encode_entities($line,'<>&"')); |
open (DFH,"tail -n50 $perlvar{'lonDaemons'}/logs/lonnet.log|"); |
} |
while ($line=<DFH>) { |
&log($fh,"</pre>\n"); |
print $fh "$line"; |
close (DFH); |
}; |
|
close (DFH); |
|
} |
|
print $fh "</pre><h3>Perm Log</h3><pre>"; |
|
|
|
if (-e "$perlvar{'lonDaemons'}/logs/lonnet.perm.log") { |
|
open(DFH,"tail -n10 $perlvar{'lonDaemons'}/logs/lonnet.perm.log|"); |
|
while ($line=<DFH>) { |
|
print $fh "$line"; |
|
}; |
|
close (DFH); |
|
} else { print $fh "No perm log\n" } |
|
|
|
$fname="$perlvar{'lonDaemons'}/logs/lonnet.log"; |
|
|
|
my ($dev,$ino,$mode,$nlink, |
|
$uid,$gid,$rdev,$size, |
|
$atime,$mtime,$ctime, |
|
$blksize,$blocks)=stat($fname); |
|
|
|
if ($size>40000) { |
|
print $fh "Rotating logs ...<p>"; |
|
rename("$fname.2","$fname.3"); |
|
rename("$fname.1","$fname.2"); |
|
rename("$fname","$fname.1"); |
|
} |
} |
|
|
print $fh "</pre>"; |
sub finish_logging { |
&errout($fh); |
my ($fh)=@_; |
# ----------------------------------------------------------------- Connections |
&log($fh,"<a name='errcount' />\n"); |
|
$totalcount=$notices+4*$warnings+100*$errors; |
|
&errout($fh); |
|
&log($fh,"<h1>Total Error Count: $totalcount</h1>"); |
|
my $now=time; |
|
my $date=localtime($now); |
|
&log($fh,"<hr />$date ($now)</body></html>\n"); |
|
print "lon-status webpage updated\n"; |
|
$fh->close(); |
|
|
|
if ($errors) { $simplestatus{'errors'}=$errors; } |
|
if ($warnings) { $simplestatus{'warnings'}=$warnings; } |
|
if ($notices) { $simplestatus{'notices'}=$notices; } |
|
$simplestatus{'time'}=time; |
|
} |
|
|
print $fh '<hr><a name="connections"><h2>Connections</h2>'; |
sub log_simplestatus { |
|
rename ("$statusdir/newstatus.html","$statusdir/index.html"); |
|
|
|
my $sfh=IO::File->new(">$statusdir/loncron_simple.txt"); |
|
foreach (keys %simplestatus) { |
|
print $sfh $_.'='.$simplestatus{$_}.'&'; |
|
} |
|
print $sfh "\n"; |
|
$sfh->close(); |
|
} |
|
|
print $fh "<table border=2>"; |
sub send_mail { |
foreach $tryserver (keys %hostname) { |
print "sending mail\n"; |
|
my $emailto="$perlvar{'lonAdmEMail'}"; |
|
if ($totalcount>2500) { |
|
$emailto.=",$perlvar{'lonSysEMail'}"; |
|
} |
|
my $subj="LON: $perlvar{'lonHostID'} E:$errors W:$warnings N:$notices"; |
|
|
$answer=reply("pong",$tryserver); |
my $result=system("metasend -b -S 4000000 -t $emailto -s '$subj' -f $statusdir/index.html -m text/html >& /dev/null"); |
if ($answer eq "$tryserver:$perlvar{'lonHostID'}") { |
if ($result != 0) { |
$result="<b>ok</b>"; |
$result=system("mail -s '$subj' $emailto < $statusdir/index.html"); |
} else { |
|
$result=$answer; |
|
$warnings++; |
|
if ($answer eq 'con_lost') { $warnings++; } |
|
} |
} |
print $fh "<tr><td>$tryserver</td><td>$result</td></tr>\n"; |
} |
|
|
|
sub usage { |
|
print(<<USAGE); |
|
loncron - housekeeping program that checks up on various parts of Lon-CAPA |
|
|
|
Options: |
|
--help Display help |
|
--oldlonc When starting the lonc daemon use 'lonc' not 'loncnew' |
|
--noemail Do not send the status email |
|
--justcheckconnections Only check the current status of the lonc/d |
|
connections, do not send emails do not |
|
check if the daemons are running, do not |
|
generate lon-status |
|
--justcheckdaemons Only check that all of the Lon-CAPA daemons are |
|
running, do not send emails do not |
|
check the lonc/d connections, do not |
|
generate lon-status |
|
--justreload Only tell the daemons to reload the config files, |
|
do not send emails do not |
|
check if the daemons are running, do not |
|
generate lon-status |
|
|
|
USAGE |
} |
} |
print $fh "</table>"; |
|
|
|
&errout($fh); |
# ================================================================ Main Program |
# ------------------------------------------------------------ Delayed messages |
sub main () { |
|
my ($oldlonc,$help,$justcheckdaemons,$noemail,$justcheckconnections, |
|
$justreload); |
|
&GetOptions("help" => \$help, |
|
"oldlonc" => \$oldlonc, |
|
"justcheckdaemons" => \$justcheckdaemons, |
|
"noemail" => \$noemail, |
|
"justcheckconnections" => \$justcheckconnections, |
|
"justreload" => \$justreload |
|
); |
|
if ($help) { &usage(); return; } |
|
# --------------------------------- Read loncapa_apache.conf and loncapa.conf |
|
my $perlvarref=LONCAPA::Configuration::read_conf('loncapa.conf'); |
|
%perlvar=%{$perlvarref}; |
|
undef $perlvarref; |
|
delete $perlvar{'lonReceipt'}; # remove since sensitive and not needed |
|
delete $perlvar{'lonSqlAccess'}; # remove since sensitive and not needed |
|
|
|
# --------------------------------------- Make sure that LON-CAPA is configured |
|
# I only test for one thing here (lonHostID). This is just a safeguard. |
|
if ('{[[[[lonHostID]]]]}' eq $perlvar{'lonHostID'}) { |
|
print("Unconfigured machine.\n"); |
|
my $emailto=$perlvar{'lonSysEMail'}; |
|
my $hostname=`/bin/hostname`; |
|
chop $hostname; |
|
$hostname=~s/[^\w\.]//g; # make sure is safe to pass through shell |
|
my $subj="LON: Unconfigured machine $hostname"; |
|
system("echo 'Unconfigured machine $hostname.' |\ |
|
mailto $emailto -s '$subj' > /dev/null"); |
|
exit 1; |
|
} |
|
|
print $fh '<hr><a name="delayed"><h2>Delayed Messages</h2>'; |
# ----------------------------- Make sure this process is running from user=www |
print "buffers\n"; |
my $wwwid=getpwnam('www'); |
|
if ($wwwid!=$<) { |
|
print("User ID mismatch. This program must be run as user 'www'\n"); |
|
my $emailto="$perlvar{'lonAdmEMail'},$perlvar{'lonSysEMail'}"; |
|
my $subj="LON: $perlvar{'lonHostID'} User ID mismatch"; |
|
system("echo 'User ID mismatch. loncron must be run as user www.' |\ |
|
mailto $emailto -s '$subj' > /dev/null"); |
|
exit 1; |
|
} |
|
|
print $fh '<h3>Scanning Permanent Log</h3>'; |
# ------------------------------------------------------------- Read hosts file |
|
my $config=IO::File->new("$perlvar{'lonTabDir'}/hosts.tab"); |
|
|
|
my (%hostname,%hostdom,%hostrole,%spareid); |
|
while (my $configline=<$config>) { |
|
next if ($configline =~ /^(\#|\s*\$)/); |
|
my ($id,$domain,$role,$name)=split(/:/,$configline); |
|
if ($id && $domain && $role && $name) { |
|
$name=~s/\s//g; |
|
$hostname{$id}=$name; |
|
$hostdom{$id}=$domain; |
|
$hostrole{$id}=$role; |
|
} |
|
} |
|
undef $config; |
|
|
$unsend=0; |
# ------------------------------------------------------ Read spare server file |
{ |
$config=IO::File->new("$perlvar{'lonTabDir'}/spare.tab"); |
my $dfh=IO::File->new("$perlvar{'lonDaemons'}/logs/lonnet.perm.log"); |
|
while ($line=<$dfh>) { |
while (my $configline=<$config>) { |
($time,$sdf,$dserv,$dcmd)=split(/:/,$line); |
chomp($configline); |
if ($sdf eq 'F') { |
if (($configline) && ($configline ne $perlvar{'lonHostID'})) { |
$local=localtime($time); |
$spareid{$configline}=1; |
print "<b>Failed: $time, $dserv, $dcmd</b><br>"; |
} |
$warnings++; |
} |
} |
undef $config; |
if ($sdf eq 'S') { $unsend--; } |
|
if ($sdf eq 'D') { $unsend++; } |
# ---------------------------------------------------------------- Start report |
} |
|
} |
$errors=0; |
print $fh "Total unsend messages: <b>$unsend</b><p>\n"; |
$warnings=0; |
$warnings=$warnings+5*$unsend; |
$notices=0; |
|
|
print $fh "<h3>Outgoing Buffer</h3>"; |
|
|
my $fh; |
open (DFH,"ls -lF $perlvar{'lonSockDir'}/delayed|"); |
if (!$justcheckdaemons && !$justcheckconnections && !$justreload) { |
while ($line=<DFH>) { |
$fh=&start_logging(\%hostdom,\%hostrole,\%hostname,\%spareid); |
print $fh "$line<br>"; |
|
}; |
&log_machine_info($fh); |
close (DFH); |
&clean_tmp($fh); |
|
&clean_lonIDs($fh); |
# ------------------------------------------------------------------------- End |
&check_httpd_logs($fh); |
print $fh "<a name=errcount>\n"; |
&rotate_lonnet_logs($fh); |
$totalcount=$notices+4*$warnings+100*$errors; |
} |
&errout($fh); |
if (!$justcheckconnections && !$justreload) { |
print $fh "<h1>Total Error Count: $totalcount</h1>"; |
&checkon_daemon($fh,'lonsql',200000); |
$now=time; |
if ( &checkon_daemon($fh,'lond',40000,'USR1') eq 'running') { |
$date=localtime($now); |
&checkon_daemon($fh,'lond',40000,'USR2'); |
print $fh "<hr>$date ($now)</body></html>\n"; |
} |
print "writing done\n"; |
my $args='new'; |
} |
if ($oldlonc) { $args = ''; } |
|
if ( &checkon_daemon($fh,'lonc',40000,'USR1',$args) eq 'running') { |
rename ("$statusdir/newstatus.html","$statusdir/index.html"); |
&checkon_daemon($fh,'lond',40000,'USR2',$args); |
|
} |
if ($totalcount>200) { |
&checkon_daemon($fh,'lonhttpd',40000); |
print "mailing\n"; |
&checkon_daemon($fh,'lonmemcached',40000); |
$emailto="$perlvar{'lonAdmEMail'},$perlvar{'lonSysEMail'}"; |
} |
$subj="LON: $perlvar{'lonHostID'} E:$errors W:$warnings N:$notices"; |
if ($justreload) { |
system( |
&checkon_daemon($fh,'lond',40000,'USR2'); |
"metasend -b -t $emailto -s '$subj' -f $statusdir/index.html -m text/html"); |
my $args='new'; |
|
if ($oldlonc) { $args = ''; } |
|
&checkon_daemon($fh,'lonc',40000,'USR2',$args); |
|
} |
|
if ($justcheckconnections) { |
|
&test_connections($fh,\%hostname); |
|
} |
|
if (!$justcheckdaemons && !$justcheckconnections && !$justreload) { |
|
&check_delayed_msg($fh); |
|
&finish_logging($fh); |
|
&log_simplestatus(); |
|
|
|
if ($totalcount>200 && !$noemail) { &send_mail(); } |
|
} |
} |
} |
|
|
|
&main(); |
1; |
1; |
|
|
|
|