[BACK]Return to loncron CVS log [TXT] [DIR] Up to [LON-CAPA] / loncom

Diff for /loncom/loncron between versions 1.10 and 1.86

version 1.10, 2000/12/08 23:17:26 version 1.86, 2010/08/17 22:22:00
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)  
 #  #
 # 7/14,7/15,7/19,7/21,7/22,11/18,  # Copyright Michigan State University Board of Trustees
 # 2/8 Gerd Kortemeyer  #
   # 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/
   #
   
   $|=1;
   use strict;
   
   use lib '/home/httpd/lib/perl/';
   use LONCAPA::Configuration;
   use Apache::lonnet;
   use Apache::loncommon;
   
 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  
 sub reply {  
     my ($cmd,$server)=@_;  
     my $peerfile="$perlvar{'lonSockDir'}/$server";  
     my $client=IO::Socket::UNIX->new(Peer    =>"$peerfile",  
                                      Type    => SOCK_STREAM,  
                                      Timeout => 10)  
        or return "con_lost";  
     print $client "$cmd\n";  
     my $answer=<$client>;  
     chomp($answer);  
     if (!$answer) { $answer="con_lost"; }  
     return $answer;  
 }  
   
 # --------------------------------------------------------- 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 rotate_logfile {
       my ($file,$fh,$description) = @_;
       my $size=(stat($file))[7];
       if ($size>40000) {
    &log($fh,"<p>Rotating $description ...</p>");
    rename("$file.2","$file.3");
    rename("$file.1","$file.2");
    rename("$file","$file.1");
       } 
   }
   
 # ------------------------------------------------------------ Read access.conf  sub start_daemon {
 {      my ($fh,$daemon,$pidfile,$args) = @_;
     my $config=IO::File->new("/etc/httpd/conf/access.conf");      my $progname=$daemon;
       if ($daemon eq 'lonc') {
     while (my $configline=<$config>) {   $progname='loncnew'; 
         if ($configline =~ /PerlSetVar/) {  
    my ($dummy,$varname,$varvalue)=split(/\s+/,$configline);  
            $perlvar{$varname}=$varvalue;  
         }  
     }      }
       my $error_fname="$perlvar{'lonDaemons'}/logs/${daemon}_errors";
       &rotate_logfile($error_fname,$fh,'error logs');
       if ($daemon eq 'lonc') {
    &clean_sockets($fh);
       }
       system("$perlvar{'lonDaemons'}/$progname 2>$perlvar{'lonDaemons'}/logs/${daemon}_errors");
       sleep 1;
       if (-e $pidfile) {
    &log($fh,"<p>Seems like it started ...</p>");
    my $lfh=IO::File->new("$pidfile");
    my $daemonpid=<$lfh>;
    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;
 }  }
   
 # ------------------------------------------------------------- Read hosts file  sub checkon_daemon {
 {      my ($fh,$daemon,$maxsize,$send,$args)=@_;
     my $config=IO::File->new("$perlvar{'lonTabDir'}/hosts.tab");  
       my $result;
     while (my $configline=<$config>) {      &log($fh,'<hr /><a name="'.$daemon.'" /><h2>'.$daemon.'</h2><h3>Log</h3><p style="white-space: pre;"><tt>');
        my ($id,$domain,$role,$name,$ip)=split(/:/,$configline);      printf("%-15s ",$daemon);
        $hostname{$id}=$name;      if (-e "$perlvar{'lonDaemons'}/logs/$daemon.log"){
        $hostdom{$id}=$domain;   open (DFH,"tail -n25 $perlvar{'lonDaemons'}/logs/$daemon.log|");
        $hostrole{$id}=$role;   while (my $line=<DFH>) { 
        $hostip{$id}=$ip;      &log($fh,"$line");
        if (($role eq 'library') && ($id ne $perlvar{'lonHostID'})) {      if ($line=~/INFO/) { $notices++; }
    $libserv{$id}=$name;      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>");
       }
    }
   
 # ------------------------------------------------------ Read spare server file   if (-e "$perlvar{'lonDaemons'}/logs/$daemon.log"){
 {      &log($fh,"<p><pre>");
     my $config=IO::File->new("$perlvar{'lonTabDir'}/spare.tab");      open (DFH,"tail -n100 $perlvar{'lonDaemons'}/logs/$daemon.log|");
       while (my $line=<DFH>) { 
     while (my $configline=<$config>) {   &log($fh,"$line");
        chomp($configline);   if ($line=~/WARNING/) { $notices++; }
        if (($configline) && ($configline ne $perlvar{'lonHostID'})) {   if ($line=~/CRITICAL/) { $notices++; }
           $spareid{$configline}=1;      };
        }      close (DFH);
       &log($fh,"</pre></p>");
    }
     }      }
       
       my $fname="$perlvar{'lonDaemons'}/logs/$daemon.log";
       &rotate_logfile($fname,$fh,'logs');
   
       &errout($fh);
       return $result;
 }  }
   
 # ---------------------------------------------------------------- Start report  # --------------------------------------------------------------------- Machine
   sub log_machine_info {
       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++;
       }
   
       &log($fh,"<h3>df</h3>");
       &log($fh,"<pre>");
   
 $statusdir="/home/httpd/html/lon-status";      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>");
   
 $errors=0;  
 $warnings=0;  
 $notices=0;  
   
 $now=time;      &log($fh,"<h3>ps</h3>");
 $date=localtime($now);      &log($fh,"<pre>");
       my $psproc=0;
   
 {      open (PSH,"ps aux --cols 140 |");
 my $fh=IO::File->new(">$statusdir/newstatus.html");      while (my $line=<PSH>) { 
    &log($fh,&encode_entities($line,'<>&"')); 
    $psproc++;
       }
       close (PSH);
       &log($fh,"</pre>");
   
 print $fh (<<ENDHEADERS);      if ($psproc>200) { $notices++; }
       if ($psproc>250) { $notices++; }
   
       &log($fh,"<h3>distprobe</h3>");
       &log($fh,"<pre>");
       open(DSH,"$perlvar{'lonDaemons'}/distprobe |");
       while (my $line=<DSH>) { 
    &log($fh,&encode_entities($line,'<>&"')); 
    $psproc++;
       }
       close(DSH);
       &log($fh,"</pre>");
   
       &errout($fh);
   }
   
   sub start_logging {
       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="#httpd">httpd</a>  <li><a href="#tmp">Temporary Files</a></li>
 <li><a href="#lond">lond</a>  <li><a href="#tokens">Session Tokens</a></li>
 <li><a href="#lonc">lonc</a>  <li><a href="#httpd">httpd</a></li>
 <li><a href="#lonnet">lonnet</a>  <li><a href="#lonsql">lonsql</a></li>
 <li><a href="#connections">Connections</a>  <li><a href="#lond">lond</a></li>
 <li><a href="#delayed">Delayed Messages</a>  <li><a href="#lonc">lonc</a></li>
 <li><a href="#errcount">Error Count</a>  <li><a href="#lonnet">lonnet</a></li>
   <li><a href="#connections">Connections</a></li>
   <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       my %hostname = &Apache::lonnet::all_hostnames();
     "<tr><td>$id</td><td>$hostdom{$id}</td><td>$hostrole{$id}</td>";      foreach my $id (sort(keys(%hostname))) {
 print $fh "<td>$hostname{$id}</td><td>$hostip{$id}</td></tr>\n";   my $role = (&Apache::lonnet::is_library($id) ? 'library'
 }                                       : 'access');
 print $fh "</table><h3>Spare Hosts</h3><ol>";   &log($fh,
 foreach $id (keys %spareid) {      "<tr><td>$id</td><td>".&Apache::lonnet::host_domain($id).
     print $fh "<li>$id\n";      "</td><td>".$role.
       "</td><td>".&Apache::lonnet::hostname($id)."</td></tr>\n");
       }
       &log($fh,"</table><h3>Spare Hosts</h3><ul>");
       foreach my $type (sort(keys(%Apache::lonnet::spareid))) {
    &log($fh,"<li>$type\n<ol>");
    foreach my $id (@{ $Apache::lonnet::spareid{$type} }) {
       &log($fh,"<li>$id</li>\n");
    }
    &log($fh,"</ol>\n</li>\n");
       }
       &log($fh,"</ul>\n");
       return $fh;
 }  }
   
 print $fh "</ol>\n";  # --------------------------------------------------------------- clean out tmp
   sub clean_tmp {
       my ($fh)=@_;
       &log($fh,'<hr /><a name="tmp" /><h2>Temporary Files</h2>');
       my ($cleaned,$old,$removed) = (0,0,0);
       my %errors = (
                        dir       => [],
                        file      => [],
                        failopen  => [],
                    );
       my %error_titles = (
                            dir       => 'failed to remove empty directory:',
                            file      => 'failed to unlike stale file',
                            failopen  => 'failed to open file or directory'
                          );
       ($cleaned,$old,$removed) = &recursive_clean_tmp('',$cleaned,$old,$removed,\%errors);
       &log($fh,"Cleaned up: ".$cleaned." files; removed: $removed empty directories; (found: $old old checkout tokens)");
       foreach my $key (sort(keys(%errors))) {
           if (ref($errors{$key}) eq 'ARRAY') {
               if (@{$errors{$key}} > 0) {
                   &log($fh,"Error during cleanup ($error_titles{$key}):<ul><li>".
                        join('</li><li><tt>',@{$errors{$key}}).'</tt></li></ul><br />');
               }
           }
       }
   }
   
 # --------------------------------------------------------------------- Machine  sub recursive_clean_tmp {
       my ($subdir,$cleaned,$old,$removed,$errors) = @_;
       my $base = "$perlvar{'lonDaemons'}/tmp";
       my $path = $base;
       next if ($subdir =~ m{\.\./});
       next unless (ref($errors) eq 'HASH');
       unless ($subdir eq '') {
           $path .= '/'.$subdir;
       }
       if (opendir(my $dh,"$path")) {
           while (my $file = readdir($dh)) {
               next if ($file =~ /^\.\.?$/);
               my $fname = "$path/$file";
               if (-d $fname) {
                   my $innerdir;
                   if ($subdir eq '') {
                       $innerdir = $file;
                   } else {
                       $innerdir = $subdir.'/'.$file;
                   }
                   ($cleaned,$old,$removed) = 
                        &recursive_clean_tmp($innerdir,$cleaned,$old,$removed,$errors);
                   my @doms = &Apache::lonnet::current_machine_domains();
                   
                   if (open(my $dirhandle,$fname)) {
                       unless (($innerdir eq 'helprequests') ||
                               (($innerdir =~ /^addcourse/) && ($innerdir !~ m{/\d+$}))) {
                           my @contents = grep {!/^\.\.?$/} readdir($dirhandle);
                                         join('&&',@contents)."\n";    
                           if (scalar(grep {!/^\.\.?$/} readdir($dirhandle)) == 0) {
                               closedir($dirhandle);
                               if ($fname =~ m{^\Q$perlvar{'lonDaemons'}\E/tmp/}) {
                                   if (rmdir($fname)) {
                                       $removed ++;
                                   } elsif (ref($errors->{dir}) eq 'ARRAY') {
                                       push(@{$errors->{dir}},$fname);
                                   }
                               }
                           }
                       } else {
                           closedir($dirhandle);
                       }
                   }
               } else {
                   my ($dev,$ino,$mode,$nlink,
                       $uid,$gid,$rdev,$size,
                       $atime,$mtime,$ctime,
                       $blksize,$blocks)=stat($fname);
                   my $now=time;
                   my $since=$now-$mtime;
                   if ($since>$perlvar{'lonExpire'}) {
                       if ($subdir eq '') {
                           my $line='';
                           if ($fname =~ /\.db$/) {
                               if (unlink($fname)) {
                                   $cleaned++;
                               } elsif (ref($errors->{file}) eq 'ARRAY') {
                                   push(@{$errors->{file}},$fname);
                               }
                           } elsif (open(PROBE,$fname)) {
                               my $line='';
                               $line=<PROBE>;
                               close(PROBE);
                               if ($line=~/^CHECKOUTTOKEN\&/) {
                                   if ($since>365*$perlvar{'lonExpire'}) {
                                       if (unlink($fname)) {
                                           $cleaned++; 
                                       } elsif (ref($errors->{file}) eq 'ARRAY') {
                                           push(@{$errors->{file}},$fname);
                                       }
                                   } else {
                                       $old++;
                                   }
                               } else {
                                   if (unlink($fname)) {
                                       $cleaned++;
                                   } elsif (ref($errors->{file}) eq 'ARRAY') {
                                       push(@{$errors->{file}},$fname);
                                   }
                               }
                           } elsif (ref($errors->{failopen}) eq 'ARRAY') {
                               push(@{$errors->{failopen}},$fname); 
                           }
                       } else {
                           if (unlink($fname)) {
                               $cleaned++;
                           } elsif (ref($errors->{file}) eq 'ARRAY') {
                               push(@{$errors->{file}},$fname);
                           }
                       }
                   }
               }
           }
           closedir($dh);
       } elsif (ref($errors->{failopen}) eq 'ARRAY') {
           push(@{$errors->{failopen}},$path);
       }
       return ($cleaned,$old,$removed);
   }
   
 print $fh '<hr><a name="machine"><h2>Machine Information</h2>';  # ------------------------------------------------------------ clean out lonIDs
 print $fh "<h3>loadavg</h3>";  sub clean_lonIDs {
       my ($fh)=@_;
       &log($fh,'<hr /><a name="tokens" /><h2>Session Tokens</h2>');
       my $cleaned=0;
       my $active=0;
       while (my $fname=<$perlvar{'lonIDsDir'}/*>) {
    my ($dev,$ino,$mode,$nlink,
       $uid,$gid,$rdev,$size,
       $atime,$mtime,$ctime,
       $blksize,$blocks)=stat($fname);
    my $now=time;
    my $since=$now-$mtime;
    if ($since>$perlvar{'lonExpire'}) {
       $cleaned++;
       &log($fh,"Unlinking $fname<br>");
       unlink("$fname");
    } else {
       $active++;
    }
       }
       &log($fh,"<p>Cleaned up ".$cleaned." stale session token(s).</p>");
       &log($fh,"<h3>$active open session(s)</h3>");
   }
   
 open (LOADAVGH,"/proc/loadavg");  # ----------------------------------------------------------- clean out sockets
 $loadavg=<LOADAVGH>;  sub clean_sockets {
 close (LOADAVGH);      my ($fh)=@_;
       my $cleaned=0;
       opendir(SOCKETS,$perlvar{'lonSockDir'});
       while (my $fname=readdir(SOCKETS)) {
    next if (-d $fname 
    || $fname=~/(mysqlsock|maximasock|rsock|\Q$perlvar{'lonSockDir'}\E)/);
    $cleaned++;
    &log($fh,"Unlinking $fname<br />");
    unlink("/home/httpd/sockets/$fname");
       }
       &log($fh,"<p>Cleaned up ".$cleaned." stale sockets.</p>");
   }
   
 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++;   
    } elsif ($usage>80) {  
       $warnings++;  
    } elsif ($usage>60) {  
       $notices++;  
    }  
    if ($usage>95) { $warnings++; $warnings++ }  
 }  
 close (DFH);  
 print $fh "</pre>";  
 &errout($fh);  
 # ----------------------------------------------------------------------- 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 -n40 /etc/httpd/logs/access_log|");  
 while ($line=<DFH>) { print $fh "$line" };  
 close (DFH);  
   
 print $fh "</pre><h3>Error Log</h3><pre>";  
   
 open (DFH,"tail -n50 /etc/httpd/logs/error_log|");  
 while ($line=<DFH>) {   
    print $fh "$line";  
    if ($line=~/\[error\]/) { $notices++; }   
 };  
 close (DFH);  
 print $fh "</pre>";  
 &errout($fh);  
   
   sub rotate_lonnet_logs {
       my ($fh)=@_;
       &log($fh,'<hr /><a name="lonnet" /><h2>lonnet</h2><h3>Temp Log</h3><pre>');
       print "checking logs\n";
       if (-e "$perlvar{'lonDaemons'}/logs/lonnet.log"){
    open (DFH,"tail -n50 $perlvar{'lonDaemons'}/logs/lonnet.log|");
    while (my $line=<DFH>) { 
       &log($fh,&encode_entities($line,'<>&"'));
    }
    close (DFH);
       }
       &log($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 (my $line=<DFH>) { 
       &log($fh,&encode_entities($line,'<>&"'));
    }
    close (DFH);
       } else { &log($fh,"No perm log\n") }
   
 # ------------------------------------------------------------------------ lonsql      my $fname="$perlvar{'lonDaemons'}/logs/lonnet.log";
       &rotate_logfile($fname,$fh,'lonnet log');
   
 if ($perlvar{'lonRole'} eq "library" && 1==0) {      &log($fh,"</pre>");
       &errout($fh);
   }
   
     print $fh '<hr><a name="lond"><h2>lonsql</h2><h3>Log</h3><pre>';  sub rotate_other_logs {
           my ($fh) = @_;
     if (-e "$perlvar{'lonDaemons'}/logs/lonsql.log"){      my %logs = (
  open (DFH,"tail -n100 $perlvar{'lonDaemons'}/logs/lonsql.log|");                    autoenroll          => 'Auto Enroll log',
  while ($line=<DFH>) {                     autocreate          => 'Create Course log',
     print $fh "$line";                    searchcat           => 'Search Cataloguing log',
     if ($line=~/INFO/) { $notices++; }                    autoupdate          => 'Auto Update log',
     if ($line=~/WARNING/) { $notices++; }                    refreshcourseids_db => 'Refresh CourseIDs db log',
     if ($line=~/CRITICAL/) { $warnings++; }                 );
  };      foreach my $item (keys(%logs)) {
  close (DFH);          my $fname=$perlvar{'lonDaemons'}.'/logs/'.$item.'.log';
           &rotate_logfile($fname,$fh,$logs{$item});
     }      }
     print $fh "</pre>";  }
       
     my $lonsqlfile="$perlvar{'lonDaemons'}/logs/lonsql.pid";  # ----------------------------------------------------------------- Connections
       sub test_connections {
     if (-e $lonsqlfile) {      my ($fh)=@_;
  my $lfh=IO::File->new("$lonsqlfile");      &log($fh,'<hr /><a name="connections" /><h2>Connections</h2>');
  my $lonsqlpid=<$lfh>;      print "testing connections\n";
  chomp($lonsqlpid);      &log($fh,"<table border='2'>");
  if (kill 0 => $lonsqlpid) {      my ($good,$bad)=(0,0);
     print $fh "<h3>lonsql at pid $lonsqlpid responding</h3>";      my %hostname = &Apache::lonnet::all_hostnames();
       foreach my $tryserver (sort(keys(%hostname))) {
    print(".");
    my $result;
    my $answer=&Apache::lonnet::reply("ping",$tryserver);
    if ($answer eq "$tryserver:$perlvar{'lonHostID'}") {
       $result="<b>ok</b>";
       $good++;
  } else {   } else {
     $errors++; $errors++;      $result=$answer;
     print $fh "<h3>lonsql at pid $lonsqlpid not responding</h3>";      $warnings++;
  }      if ($answer eq 'con_lost') {
     } else {   $bad++;
  $errors++;   $warnings++;
  print $fh "<h3>lonsql not running, trying to start</h3>";  
  system("$perlvar{'lonDaemons'}/lonsql");  
  sleep 120;  
  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 {      } else {
  $errors++; $errors++;   $good++; #self connection
  print $fh "<h3>lonsql at pid $lonsqlpid not responding</h3>";  
  print $fh "Give it one more try ...<p>";  
  system("$perlvar{'lonDaemons'}/lonsql");  
  sleep 120;  
     }      }
  } 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>";  
  }   }
    if ($answer =~ /con_lost/) { print(" $tryserver down\n"); }
    &log($fh,"<tr><td>$tryserver</td><td>$result</td></tr>\n");
     }      }
       &log($fh,"</table>");
       print "\n$good good, $bad bad connections\n";
       &errout($fh);
   }
   
     $fname="$perlvar{'lonDaemons'}/logs/lonsql.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";
       
       &log($fh,'<h3>Scanning Permanent Log</h3>');
   
     if ($size>40000) {      my $unsend=0;
  print $fh "Rotating logs ...<p>";  
  rename("$fname.2","$fname.3");  
  rename("$fname.1","$fname.2");  
  rename("$fname","$fname.1");  
     }  
   
     &errout($fh);      my $dfh=IO::File->new("$perlvar{'lonDaemons'}/logs/lonnet.perm.log");
 }      while (my $line=<$dfh>) {
 # ------------------------------------------------------------------------ lond   my ($time,$sdf,$dserv,$dcmd)=split(/:/,$line);
    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++; }
       }
   
 print $fh '<hr><a name="lond"><h2>lond</h2><h3>Log</h3><pre>';      &log($fh,"<p>Total unsend messages: <b>$unsend</b></p>\n");
       $warnings=$warnings+5*$unsend;
   
 if (-e "$perlvar{'lonDaemons'}/logs/lond.log"){      if ($unsend) { $simplestatus{'unsend'}=$unsend; }
 open (DFH,"tail -n100 $perlvar{'lonDaemons'}/logs/lond.log|");      &log($fh,"<h3>Outgoing Buffer</h3>\n<pre>");
 while ($line=<DFH>) {   # list directory with delayed messages and remember offline servers
    print $fh "$line";      my %servers=();
    if ($line=~/INFO/) { $notices++; }      open (DFH,"ls -lF $perlvar{'lonSockDir'}/delayed|");
    if ($line=~/WARNING/) { $notices++; }      while (my $line=<DFH>) {
    if ($line=~/CRITICAL/) { $warnings++; }          my ($server)=($line=~/\.(\w+)$/);
 };          if ($server) { $servers{$server}=1; }
 close (DFH);   &log($fh,&encode_entities($line,'<>&"'));
 }      }
 print $fh "</pre>";      &log($fh,"</pre>\n");
   
 my $londfile="$perlvar{'lonDaemons'}/logs/lond.pid";  
   
 my $restartflag=1;  
 if (-e $londfile) {      
    my $lfh=IO::File->new("$londfile");  
    my $londpid=<$lfh>;  
    chomp($londpid);  
    if (kill 0 => $londpid) {  
       print $fh "<h3>lond at pid $londpid responding</h3>";  
       $restartflag=0;  
    } else {  
       $errors++;  
       print $fh "<h3>lond at pid $londpid not responding</h3>";  
       # Intelligently handle this.  
       # Possibility #1: there is no process  
       # Solution: remove .pid file and restart  
       if (getpgrp($londpid)==-1) {  
   unlink($londfile);  
   $restartflag=1;  
       }  
       else {  
       # Possibility #2: there is a live process that is not responding  
       #                 for an unknown reason  
       # Solution: kill parent and children processes, remove .pid and restart  
   `killall -9 lond`;  
   unlink($londfile);  
   $restartflag=1;  
       }  
       print $fh   
   "<h3>Deciding to clean up stale .pid file and restart lond</h3>";  
    }  
 }   
 if ($restartflag==1) {  
    $errors++;  
    print $fh "<h3>lond not running, trying to start</h3>";  
    system("$perlvar{'lonDaemons'}/lond");  
    sleep 120;  
    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");  
           sleep 120;  
        }  
    } 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);      close (DFH);
     print $fh "</pre>";  # pong to all servers that have delayed messages
    }  # this will trigger a reverse connection, which should flush the buffers
       foreach my $tryserver (keys %servers) {
    my $answer=&Apache::lonnet::reply("pong",$tryserver);
    &log($fh,"Pong to $tryserver: $answer<br />");
       }
 }  }
   
 $fname="$perlvar{'lonDaemons'}/logs/lond.log";  sub finish_logging {
       my ($fh)=@_;
                           my ($dev,$ino,$mode,$nlink,      &log($fh,"<a name='errcount' />\n");
                               $uid,$gid,$rdev,$size,      $totalcount=$notices+4*$warnings+100*$errors;
                               $atime,$mtime,$ctime,      &errout($fh);
                               $blksize,$blocks)=stat($fname);      &log($fh,"<h1>Total Error Count: $totalcount</h1>");
       my $now=time;
 if ($size>40000) {      my $date=localtime($now);
     print $fh "Rotating logs ...<p>";      &log($fh,"<hr />$date ($now)</body></html>\n");
     rename("$fname.2","$fname.3");      print "lon-status webpage updated\n";
     rename("$fname.1","$fname.2");      $fh->close();
     rename("$fname","$fname.1");  
 }      if ($errors) { $simplestatus{'errors'}=$errors; }
       if ($warnings) { $simplestatus{'warnings'}=$warnings; }
 &errout($fh);      if ($notices) { $simplestatus{'notices'}=$notices; }
 # ------------------------------------------------------------------------ lonc      $simplestatus{'time'}=time;
   
 print $fh '<hr><a name="lonc"><h2>lonc</h2><h3>Log</h3><pre>';  
   
 if (-e "$perlvar{'lonDaemons'}/logs/lonc.log"){  
 open (DFH,"tail -n100 $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>";  
       # Intelligently handle this.  
       # Possibility #1: there is no process  
       # Solution: remove .pid file and restart  
       if (getpgrp($loncpid)==-1) {  
   unlink($loncfile);  
   $restartflag=1;  
       }  
       else {  
       # Possibility #2: there is a live process that is not responding  
       #                 for an unknown reason  
       # Solution: kill parent and children processes, remove .pid and restart  
   `killall -9 lonc`;  
   unlink($loncfile);  
   $restartflag=1;  
       }  
       print $fh   
   "<h3>Deciding to clean up stale .pid file and restart lonc</h3>";  
    }  
 }   
 if ($restartflag==1) {  
    $errors++;  
    print $fh "<h3>lonc not running, trying to start</h3>";  
    system("$perlvar{'lonDaemons'}/lonc");  
    sleep 120;  
    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");  
           sleep 120;  
        }  
    } 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";  sub log_simplestatus {
       rename("$statusdir/newstatus.html","$statusdir/index.html");
                           my ($dev,$ino,$mode,$nlink,      
                               $uid,$gid,$rdev,$size,      my $sfh=IO::File->new(">$statusdir/loncron_simple.txt");
                               $atime,$mtime,$ctime,      foreach (keys %simplestatus) {
                               $blksize,$blocks)=stat($fname);   print $sfh $_.'='.$simplestatus{$_}.'&';
       }
 if ($size>40000) {      print $sfh "\n";
     print $fh "Rotating logs ...<p>";      $sfh->close();
     rename("$fname.2","$fname.3");  
     rename("$fname.1","$fname.2");  
     rename("$fname","$fname.1");  
 }  }
   
      sub write_loncaparevs {
 &errout($fh);      if (open(my $fh,">$perlvar{'lonTabDir'}/loncaparevs.tab")) {
 # ---------------------------------------------------------------------- lonnet          my %hostname = &Apache::lonnet::all_hostnames();
           foreach my $id (sort(keys(%hostname))) {
 print $fh '<hr><a name="lonnet"><h2>lonnet</h2><h3>Temp Log</h3><pre>';              if ($id ne '') {
 if (-e "$perlvar{'lonDaemons'}/logs/lonnet.log"){                  my $loncaparev = &Apache::lonnet::get_server_loncaparev('',$id,1,'loncron');
 open (DFH,"tail -n50 $perlvar{'lonDaemons'}/logs/lonnet.log|");                  if ($loncaparev =~ /^[\w.\-]+$/) {
 while ($line=<DFH>) {                       print $fh $id.':'.$loncaparev."\n";
     print $fh "$line";                  }
 };              }
 close (DFH);          }
 }          close($fh);
 print $fh "</pre><h3>Perm Log</h3>";      }
       return;
 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 write_serverhomeIDs {
 &errout($fh);      if (open(my $fh,">$perlvar{'lonTabDir'}/serverhomeIDs.tab")) {
 # ----------------------------------------------------------------- Connections          my %name_to_host = &Apache::lonnet::all_names();
           foreach my $name (sort(keys(%name_to_host))) {
 print $fh '<hr><a name="connections"><h2>Connections</h2>';              if ($name ne '') {
                   if (ref($name_to_host{$name}) eq 'ARRAY') {
 print $fh "<table border=2>";                      my $serverhomeID = &Apache::lonnet::get_server_homeID($name,1,'loncron');
 foreach $tryserver (keys %hostname) {                      if ($serverhomeID ne '') {
                           print $fh $name.':'.$serverhomeID."\n";
                       } else {
                           print $fh $name.':'.$name_to_host{$name}->[0]."\n";
                       }
                   }
               }
           }
           close($fh);
       }
       return;
   }
   
     $answer=reply("pong",$tryserver);  sub send_mail {
     if ($answer eq "$tryserver:$perlvar{'lonHostID'}") {      print "sending mail\n";
  $result="<b>ok</b>";      my $defdom = $perlvar{'lonDefDomain'};
     } else {      my $origmail = $perlvar{'lonAdmEMail'};
         $result=$answer;      my $emailto = &Apache::loncommon::build_recipient_list(undef,
         $warnings++;                                     'lonstatusmail',$defdom,$origmail);
         if ($answer eq 'con_lost') { $warnings++; }      if ($totalcount>2500) {
    $emailto.=",$perlvar{'lonSysEMail'}";
     }      }
     print $fh "<tr><td>$tryserver</td><td>$result</td></tr>\n";      my $subj="LON: $perlvar{'lonHostID'} E:$errors W:$warnings N:$notices"; 
   
       my $result=system("metasend -b -S 4000000 -t $emailto -s '$subj' -f $statusdir/index.html -m text/html >& /dev/null");
       if ($result != 0) {
    $result=system("mail -s '$subj' $emailto < $statusdir/index.html");
       }
 }  }
 print $fh "</table>";  
   
 &errout($fh);  sub usage {
 # ------------------------------------------------------------ Delayed messages      print(<<USAGE);
   loncron - housekeeping program that checks up on various parts of Lon-CAPA
   
   Options:
      --help     Display 
      --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 '<hr><a name="delayed"><h2>Delayed Messages</h2>';  # ================================================================ Main Program
   sub main () {
       my ($help,$justcheckdaemons,$noemail,$justcheckconnections,
    $justreload);
       &GetOptions("help"                 => \$help,
    "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
       chdir($perlvar{'lonDaemons'});
   # --------------------------------------- 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 '<h3>Scanning Permanent Log</h3>';  # ----------------------------- Make sure this process is running from user=www
       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;
       }
   
 $unsend=0;  # -------------------------------------------- Force reload of host information
 {      &Apache::lonnet::load_hosts_tab(1);
     my $dfh=IO::File->new("$perlvar{'lonDaemons'}/logs/lonnet.perm.log");      &Apache::lonnet::load_domain_tab(1);
     while ($line=<$dfh>) {      &Apache::lonnet::get_iphost(1);
  ($time,$sdf,$dserv,$dcmd)=split(/:/,$line);  
         if ($sdf eq 'F') {   # ----------------------------------------- Force firewall update for lond port  
     $local=localtime($time);  
             print "<b>Failed: $time, $dserv, $dcmd</b><br>";      if ((!$justcheckdaemons) && (!$justreload)) {
             $warnings++;          my $now = time;
           my $tmpfile = $perlvar{'lonDaemons'}.'/tmp/lciptables_iphost_'.
                         $now.$$.int(rand(10000));
           if (open(my $fh,">$tmpfile")) {
               my %iphosts = &Apache::lonnet::get_iphost();
               foreach my $key (keys(%iphosts)) {
                   print $fh "$key\n";
               }
               close($fh);
               my $execpath = $perlvar{'lonDaemons'}.'/lciptables';
               system("$execpath $tmpfile");
               unlink($fh);
         }          }
         if ($sdf eq 'S') { $unsend--; }  
         if ($sdf eq 'D') { $unsend++; }  
     }      }
 }  
 print $fh "Total unsend messages: <b>$unsend</b><p>\n";  
 $warnings=$warnings+5*$unsend;  
   
 print $fh "<h3>Outgoing Buffer</h3>";  
   
 open (DFH,"ls -lF $perlvar{'lonSockDir'}/delayed|");  # ---------------------------------------------------------------- Start report
 while ($line=<DFH>) {   
     print $fh "$line<br>";  
 };  
 close (DFH);  
   
 # ------------------------------------------------------------------------- End  
 print $fh "<a name=errcount>\n";  
 $totalcount=$notices+4*$warnings+100*$errors;  
 &errout($fh);  
 print $fh "<h1>Total Error Count: $totalcount</h1>";  
 $now=time;  
 $date=localtime($now);  
 print $fh "<hr>$date ($now)</body></html>\n";  
   
       $errors=0;
       $warnings=0;
       $notices=0;
   
   
       my $fh;
       if (!$justcheckdaemons && !$justcheckconnections && !$justreload) {
    $fh=&start_logging();
   
    &log_machine_info($fh);
    &clean_tmp($fh);
    &clean_lonIDs($fh);
    &check_httpd_logs($fh);
    &rotate_lonnet_logs($fh);
    &rotate_other_logs($fh);
       }
       if (!$justcheckconnections && !$justreload) {
    &checkon_daemon($fh,'lonmemcached',40000);
    &checkon_daemon($fh,'lonsql',200000);
    if ( &checkon_daemon($fh,'lond',40000,'USR1') eq 'running') {
       &checkon_daemon($fh,'lond',40000,'USR2');
    }
    &checkon_daemon($fh,'lonc',40000,'USR1');
           &checkon_daemon($fh,'lonmaxima',40000);
           &checkon_daemon($fh,'lonr',40000);
       }
       if ($justreload) {
    &checkon_daemon($fh,'lond',40000,'USR2');
    &checkon_daemon($fh,'lonc',40000,'USR2');
       }
       if ($justcheckconnections) {
    &test_connections($fh);
       }
       if (!$justcheckdaemons && !$justcheckconnections && !$justreload) {
    &check_delayed_msg($fh);
    &finish_logging($fh);
    &log_simplestatus();
   
    if ($totalcount>200 && !$noemail) { &send_mail(); }
       }
       if (!$justcheckconnections && !$justreload) {
           &write_loncaparevs();
           &write_serverhomeIDs();
       }
 }  }
   
 rename ("$statusdir/newstatus.html","$statusdir/index.html");  &main();
   
 if ($totalcount>200) {  
    $emailto="$perlvar{'lonAdmEMail'},$perlvar{'lonSysEMail'}";  
    $subj="LON: $perlvar{'lonHostID'} E:$errors W:$warnings N:$notices";   
    system(  
  "metasend -b -t $emailto -s '$subj' -f $statusdir/index.html -m text/html");  
 }  
 1;  1;
   
   
Removed from v.1.10  
changed lines
  Added in v.1.86

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
500 Internal Server Error

Internal Server Error

The server encountered an internal error or misconfiguration and was unable to complete your request.

Please contact the server administrator at root@localhost to inform them of the time this error occurred, and the actions you performed just before this error.

More information about this error may be available in the server error log.