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

Diff for /loncom/Attic/lonc between versions 1.10 and 1.20

version 1.10, 2000/12/05 19:03:55 version 1.20, 2001/11/27 23:11:42
Line 15 Line 15
 # 2/8,7/25 Gerd Kortemeyer  # 2/8,7/25 Gerd Kortemeyer
 # 12/05 Scott Harrison  # 12/05 Scott Harrison
 # 12/05 Gerd Kortemeyer  # 12/05 Gerd Kortemeyer
   # 01/10/01 Scott Harrison
   # 03/14/01,03/15,06/12,11/26,11/27 Gerd Kortemeyer
 #   # 
 # based on nonforker from Perl Cookbook  # based on nonforker from Perl Cookbook
 # - server who multiplexes without forking  # - server who multiplexes without forking
Line 28  use Fcntl; Line 30  use Fcntl;
 use Tie::RefHash;  use Tie::RefHash;
 use Crypt::IDEA;  use Crypt::IDEA;
   
   my $status='';
   my $lastlog='';
   
 # grabs exception and records it to log before exiting  # grabs exception and records it to log before exiting
 sub catchexception {  sub catchexception {
     my ($signal)=@_;      my ($signal)=@_;
Line 35  sub catchexception { Line 40  sub catchexception {
     $SIG{__DIE__}='DEFAULT';      $SIG{__DIE__}='DEFAULT';
     &logthis("<font color=red>CRITICAL: "      &logthis("<font color=red>CRITICAL: "
      ."ABNORMAL EXIT. Child $$ for server $wasserver died through "       ."ABNORMAL EXIT. Child $$ for server $wasserver died through "
      ."$signal with this parameter->[$@]</font>");       ."\"$signal\" with this parameter->[$@]</font>");
     die($@);      die($@);
 }  }
   
 # grabs exception and records it to log before exiting  $childmaxattempts=5;
 # NOTE: we must NOT use the regular (non-overrided) die function in  
 # the code because a handler CANNOT be attached to it  
 # (despite what some of the documentation says about SIG{__DIE__}.  
 sub catchdie {  
     my ($message)=@_;  
     $SIG{'QUIT'}='DEFAULT';  
     $SIG{__DIE__}='DEFAULT';  
     &logthis("<font color=red>CRITICAL: "  
      ."ABNORMAL EXIT. Child $$ for server $wasserver died through "  
      ."\_\_DIE\_\_ with this parameter->[$message]</font>");  
     die($message);  
 }  
   
 $childmaxattempts=10;  
   
 # -------------------------------- Set signal handlers to record abnormal exits  # -------------------------------- Set signal handlers to record abnormal exits
   
Line 62  $SIG{__DIE__}=\&catchexception; Line 53  $SIG{__DIE__}=\&catchexception;
   
 # ------------------------------------ Read httpd access.conf and get variables  # ------------------------------------ Read httpd access.conf and get variables
   
 open (CONFIG,"/etc/httpd/conf/access.conf")   open (CONFIG,"/etc/httpd/conf/access.conf") || die "Can't read access.conf";
     || catchdie "Can't read access.conf";  
   
 while ($configline=<CONFIG>) {  while ($configline=<CONFIG>) {
     if ($configline =~ /PerlSetVar/) {      if ($configline =~ /PerlSetVar/) {
Line 74  while ($configline=<CONFIG>) { Line 64  while ($configline=<CONFIG>) {
 }  }
 close(CONFIG);  close(CONFIG);
   
   # ----------------------------- Make sure this process is running from user=www
   my $wwwid=getpwnam('www');
   if ($wwwid!=$<) {
      $emailto="$perlvar{'lonAdmEMail'},$perlvar{'lonSysEMail'}";
      $subj="LON: $perlvar{'lonHostID'} User ID mismatch";
      system("echo 'User ID mismatch.  lonc must be run as user www.' |\
    mailto $emailto -s '$subj' > /dev/null");
      exit 1;
   }
   
 # --------------------------------------------- Check if other instance running  # --------------------------------------------- Check if other instance running
   
 my $pidfile="$perlvar{'lonDaemons'}/logs/lonc.pid";  my $pidfile="$perlvar{'lonDaemons'}/logs/lonc.pid";
Line 82  if (-e $pidfile) { Line 82  if (-e $pidfile) {
    my $lfh=IO::File->new("$pidfile");     my $lfh=IO::File->new("$pidfile");
    my $pide=<$lfh>;     my $pide=<$lfh>;
    chomp($pide);     chomp($pide);
    if (kill 0 => $pide) { catchdie "already running"; }     if (kill 0 => $pide) { die "already running"; }
 }  }
   
 # ------------------------------------------------------------- Read hosts file  # ------------------------------------------------------------- Read hosts file
   
 open (CONFIG,"$perlvar{'lonTabDir'}/hosts.tab")   open (CONFIG,"$perlvar{'lonTabDir'}/hosts.tab") || die "Can't read host file";
     || catchdie "Can't read host file";  
   
 while ($configline=<CONFIG>) {  while ($configline=<CONFIG>) {
     my ($id,$domain,$role,$name,$ip)=split(/:/,$configline);      my ($id,$domain,$role,$name,$ip)=split(/:/,$configline);
Line 120  sub REAPER {                        # ta Line 119  sub REAPER {                        # ta
   
 sub HUNTSMAN {                      # signal handler for SIGINT  sub HUNTSMAN {                      # signal handler for SIGINT
     local($SIG{CHLD}) = 'IGNORE';   # we're going to kill our children      local($SIG{CHLD}) = 'IGNORE';   # we're going to kill our children
     kill 'INT' => keys %children;      map {
           $wasserver=$children{$_};
           &status("Closing $wasserver");
           &logthis('Closing '.$wasserver.': '.&subreply('exit',$wasserver));
           &status("Kill PID $_ for $wasserver");
    kill ('INT',$_);
       } keys %children;
     my $execdir=$perlvar{'lonDaemons'};      my $execdir=$perlvar{'lonDaemons'};
     unlink("$execdir/logs/lonc.pid");      unlink("$execdir/logs/lonc.pid");
     &logthis("<font color=red>CRITICAL: Shutting down</font>");      &logthis("<font color=red>CRITICAL: Shutting down</font>");
Line 129  sub HUNTSMAN {                      # si Line 134  sub HUNTSMAN {                      # si
   
 sub HUPSMAN {                      # signal handler for SIGHUP  sub HUPSMAN {                      # signal handler for SIGHUP
     local($SIG{CHLD}) = 'IGNORE';  # we're going to kill our children      local($SIG{CHLD}) = 'IGNORE';  # we're going to kill our children
     kill 'INT' => keys %children;      map {
           $wasserver=$children{$_};
           &status("Closing $wasserver");
           &logthis('Closing '.$wasserver.': '.&subreply('exit',$wasserver));
           &status("Kill PID $_ for $wasserver");
    kill ('INT',$_);
       } keys %children;
     &logthis("<font color=red>CRITICAL: Restarting</font>");      &logthis("<font color=red>CRITICAL: Restarting</font>");
       unlink("$execdir/logs/lonc.pid");
     my $execdir=$perlvar{'lonDaemons'};      my $execdir=$perlvar{'lonDaemons'};
     exec("$execdir/lonc");         # here we go again      exec("$execdir/lonc");         # here we go again
 }  }
   
   sub checkchildren {
       &initnewstatus();
       &logstatus();
       &logthis('Going to check on the children');
       map {
    sleep 1;
           unless (kill 'USR1' => $_) {
       &logthis ('Child '.$_.' is dead');
               &logstatus($$.' is dead');
           } 
       } sort keys %children;
   }
   
 sub USRMAN {  sub USRMAN {
     &logthis("USR1: Trying to establish connections again");      &logthis("USR1: Trying to establish connections again");
     foreach $thisserver (keys %hostip) {      foreach $thisserver (keys %hostip) {
Line 144  sub USRMAN { Line 169  sub USRMAN {
         ." >$answer<");          ." >$answer<");
     }      }
     %childatt=();      %childatt=();
       &checkchildren();
 }  }
   
 # -------------------------------------------------- Non-critical communication  # -------------------------------------------------- Non-critical communication
Line 156  sub subreply { Line 182  sub subreply {
                                       Type    => SOCK_STREAM,                                        Type    => SOCK_STREAM,
                                       Timeout => 10)                                        Timeout => 10)
        or return "con_lost";         or return "con_lost";
     print $sclient "$cmd\n";      $SIG{ALRM}=sub { die "timeout" };
     my $answer=<$sclient>;      $SIG{__DIE__}='DEFAULT';
     chomp($answer);      eval {
     if (!$answer) { $answer="con_lost"; }       alarm(10);
        print $sclient "$cmd\n";
        my $answer=<$sclient>;
        chomp($answer);
        alarm(0);
       };
       if ((!$answer) || ($@=~/timeout/)) { $answer="con_lost"; }
       $SIG{ALRM}='DEFAULT';
       $SIG{__DIE__}=\&catchexception;
  } else { $answer='self_reply'; }   } else { $answer='self_reply'; }
  return $answer;   return $answer;
 }  }
Line 172  sub logthis { Line 206  sub logthis {
     my $fh=IO::File->new(">>$execdir/logs/lonc.log");      my $fh=IO::File->new(">>$execdir/logs/lonc.log");
     my $now=time;      my $now=time;
     my $local=localtime($now);      my $local=localtime($now);
       $lastlog=$local.': '.$message;
     print $fh "$local ($$): $message\n";      print $fh "$local ($$): $message\n";
 }  }
   
Line 184  sub logperm { Line 219  sub logperm {
     my $fh=IO::File->new(">>$execdir/logs/lonnet.perm.log");      my $fh=IO::File->new(">>$execdir/logs/lonnet.perm.log");
     print $fh "$now:$message:$local\n";      print $fh "$now:$message:$local\n";
 }  }
   # ------------------------------------------------------------------ Log status
   
   sub logstatus {
       my $docdir=$perlvar{'lonDocRoot'};
       my $fh=IO::File->new(">>$docdir/lon-status/loncstatus.txt");
       print $fh $$."\t".$status."\t".$lastlog."\n";
   }
   
   sub initnewstatus {
       my $docdir=$perlvar{'lonDocRoot'};
       my $fh=IO::File->new(">$docdir/lon-status/loncstatus.txt");
       my $now=time;
       my $local=localtime($now);
       print $fh "LONC status $local - parent $$\n\n";
   }
   
   # -------------------------------------------------------------- Status setting
   
   sub status {
       my $what=shift;
       my $now=time;
       my $local=localtime($now);
       $status=$local.': '.$what;
   }
   
   
 # ---------------------------------------------------- Fork once and dissociate  # ---------------------------------------------------- Fork once and dissociate
   
 $fpid=fork;  $fpid=fork;
 exit if $fpid;  exit if $fpid;
 catchdie "Couldn't fork: $!" unless defined ($fpid);  die "Couldn't fork: $!" unless defined ($fpid);
   
 POSIX::setsid() or catchdie "Can't start new session: $!";  POSIX::setsid() or die "Can't start new session: $!";
   
 # ------------------------------------------------------- Write our PID on disk  # ------------------------------------------------------- Write our PID on disk
   
Line 207  $SIG{HUP}=$SIG{USR1}='IGNORE'; Line 267  $SIG{HUP}=$SIG{USR1}='IGNORE';
           
 # Fork off our children, one for every server  # Fork off our children, one for every server
   
   &status("Forking ...");
   
 foreach $thisserver (keys %hostip) {  foreach $thisserver (keys %hostip) {
     make_new_child($thisserver);      make_new_child($thisserver);
 }  }
Line 221  $SIG{USR1} = \&USRMAN; Line 283  $SIG{USR1} = \&USRMAN;
   
 # And maintain the population.  # And maintain the population.
 while (1) {  while (1) {
       &status("Sleeping");
     sleep;                          # wait for a signal (i.e., child's death)      sleep;                          # wait for a signal (i.e., child's death)
                                     # See who died and start new one                                      # See who died and start new one
       &status("Woke up");
     foreach $thisserver (keys %hostip) {      foreach $thisserver (keys %hostip) {
         if (!$childpid{$thisserver}) {          if (!$childpid{$thisserver}) {
     if ($childatt{$thisserver}<=$childmaxattempts) {      if ($childatt{$thisserver}<$childmaxattempts) {
        $childatt{$thisserver}++;         $childatt{$thisserver}++;
                &logthis(                 &logthis(
    "<font color=yellow>INFO: Trying to reconnect for $thisserver "     "<font color=yellow>INFO: Trying to reconnect for $thisserver "
Line 246  sub make_new_child { Line 310  sub make_new_child {
     # block signal for fork      # block signal for fork
     $sigset = POSIX::SigSet->new(SIGINT);      $sigset = POSIX::SigSet->new(SIGINT);
     sigprocmask(SIG_BLOCK, $sigset)      sigprocmask(SIG_BLOCK, $sigset)
         or catchdie "Can't block SIGINT for fork: $!\n";          or die "Can't block SIGINT for fork: $!\n";
           
     catchdie "fork: $!" unless defined ($pid = fork);      die "fork: $!" unless defined ($pid = fork);
           
     if ($pid) {      if ($pid) {
         # Parent records the child's birth and returns.          # Parent records the child's birth and returns.
         sigprocmask(SIG_UNBLOCK, $sigset)          sigprocmask(SIG_UNBLOCK, $sigset)
             or catchdie "Can't unblock SIGINT for fork: $!\n";              or die "Can't unblock SIGINT for fork: $!\n";
         $children{$pid} = $conserver;          $children{$pid} = $conserver;
         $childpid{$conserver} = $pid;          $childpid{$conserver} = $pid;
         return;          return;
     } else {      } else {
         # Child can *not* return from this subroutine.          # Child can *not* return from this subroutine.
         $SIG{INT} = 'DEFAULT';      # make SIGINT kill us as it did before          $SIG{INT} = 'DEFAULT';      # make SIGINT kill us as it did before
               $SIG{USR1}= \&logstatus;
      
         # unblock signals          # unblock signals
         sigprocmask(SIG_UNBLOCK, $sigset)          sigprocmask(SIG_UNBLOCK, $sigset)
             or catchdie "Can't unblock SIGINT for fork: $!\n";              or die "Can't unblock SIGINT for fork: $!\n";
   
 # ----------------------------- This is the modified main program of non-forker  # ----------------------------- This is the modified main program of non-forker
   
 $port = "$perlvar{'lonSockDir'}/$conserver";  $port = "$perlvar{'lonSockDir'}/$conserver";
   
 unlink($port);  unlink($port);
   
 # ---------------------------------------------------- Client to network server  # ---------------------------------------------------- Client to network server
   
   &status("Opening TCP: $conserver");
   
 unless (  unless (
   $remotesock = IO::Socket::INET->new(PeerAddr => $hostip{$conserver},    $remotesock = IO::Socket::INET->new(PeerAddr => $hostip{$conserver},
                                       PeerPort => $perlvar{'londPort'},                                        PeerPort => $perlvar{'londPort'},
Line 283  unless ( Line 352  unless (
        sleep($st);         sleep($st);
        exit;          exit; 
      };       };
 # --------------------------------------- Send a ping to make other end do USR1  # ----------------------------------------------------------------- Init dialog
   
   &status("Init dialogue: $conserver");
   
        $SIG{ALRM}=sub { die "timeout" };
        $SIG{__DIE__}='DEFAULT';
        eval {
            alarm(60);
 print $remotesock "init\n";  print $remotesock "init\n";
 $answer=<$remotesock>;  $answer=<$remotesock>;
 print $remotesock "$answer";  print $remotesock "$answer";
 $answer=<$remotesock>;  $answer=<$remotesock>;
 chomp($answer);  chomp($answer);
             alarm(0);
        };
        $SIG{ALRM}='DEFAULT';
        $SIG{__DIE__}=\&catchexception;
    
        if ($@=~/timeout/) {
    &logthis("Timed out during init: $conserver");
            exit;
        }
   
   
 &logthis("Init reply for $conserver: >$answer<");  &logthis("Init reply for $conserver: >$answer<");
   if ($answer ne 'ok') {
          my $st=120+int(rand(240));
          &logthis(
   "<font color=blue>WARNING: Init failed $conserver ($st secs)</font>");
          sleep($st);
          exit; 
   }
 sleep 5;  sleep 5;
   &status("Ponging $conserver");
 print $remotesock "pong\n";  print $remotesock "pong\n";
 $answer=<$remotesock>;  $answer=<$remotesock>;
 chomp($answer);  chomp($answer);
 &logthis("Pong reply for $conserver: >$answer<");  &logthis("Pong reply for $conserver: >$answer<");
 # ----------------------------------------------------------- Initialize cipher  # ----------------------------------------------------------- Initialize cipher
   
   &status("Initialize cipher: $conserver");
 print $remotesock "ekey\n";  print $remotesock "ekey\n";
 my $buildkey=<$remotesock>;  my $buildkey=<$remotesock>;
 my $key=$conserver.$perlvar{'lonHostID'};  my $key=$conserver.$perlvar{'lonHostID'};
Line 307  $key=$key.$buildkey.$key.$buildkey.$key. Line 403  $key=$key.$buildkey.$key.$buildkey.$key.
 $key=substr($key,0,32);  $key=substr($key,0,32);
 my $cipherkey=pack("H32",$key);  my $cipherkey=pack("H32",$key);
 if ($cipher=new IDEA $cipherkey) {  if ($cipher=new IDEA $cipherkey) {
    &logthis("Secure connection inititalized: $conserver");     &logthis("Secure connection initialized: $conserver");
 } else {  } else {
    my $st=120+int(rand(240));     my $st=120+int(rand(240));
    &logthis(     &logthis(
Line 318  if ($cipher=new IDEA $cipherkey) { Line 414  if ($cipher=new IDEA $cipherkey) {
 }  }
   
 # ----------------------------------------- We're online, send delayed messages  # ----------------------------------------- We're online, send delayed messages
       &status("Checking for delayed messages");
     my @allbuffered;      my @allbuffered;
     my $path="$perlvar{'lonSockDir'}/delayed";      my $path="$perlvar{'lonSockDir'}/delayed";
     opendir(DIRHANDLE,$path);      opendir(DIRHANDLE,$path);
Line 326  if ($cipher=new IDEA $cipherkey) { Line 422  if ($cipher=new IDEA $cipherkey) {
     closedir(DIRHANDLE);      closedir(DIRHANDLE);
     my $dfname;      my $dfname;
     map {      map {
           &status("Sending delayed $conserver $_");
         $dfname="$path/$_";          $dfname="$path/$_";
         &logthis($dfname);          &logthis($dfname);
         my $wcmd;          my $wcmd;
Line 348  if ($cipher=new IDEA $cipherkey) { Line 445  if ($cipher=new IDEA $cipherkey) {
             }              }
             $cmd="enc:$cmdlength:$encrequest\n";              $cmd="enc:$cmdlength:$encrequest\n";
         }          }
       $SIG{ALRM}=sub { die "timeout" };
       $SIG{__DIE__}='DEFAULT';
       eval {
           alarm(60);
         print $remotesock "$cmd\n";          print $remotesock "$cmd\n";
         $answer=<$remotesock>;          $answer=<$remotesock>;
  chomp($answer);   chomp($answer);
         if ($answer ne '') {          alarm(0);
       };
       $SIG{ALRM}='DEFAULT';
       $SIG{__DIE__}=\&catchexception;
   
           if (($answer ne '') && ($@!~/timeout/)) {
     unlink("$dfname");      unlink("$dfname");
             &logthis("Delayed $cmd to $conserver: >$answer<");              &logthis("Delayed $cmd to $conserver: >$answer<");
             &logperm("S:$conserver:$bcmd");              &logperm("S:$conserver:$bcmd");
Line 360  if ($cipher=new IDEA $cipherkey) { Line 465  if ($cipher=new IDEA $cipherkey) {
     } @allbuffered;      } @allbuffered;
   
 # ------------------------------------------------------- Listen to UNIX socket  # ------------------------------------------------------- Listen to UNIX socket
   &status("Opening socket $conserver");
 unless (  unless (
   $server = IO::Socket::UNIX->new(Local  => $port,    $server = IO::Socket::UNIX->new(Local  => $port,
                                   Type   => SOCK_STREAM,                                    Type   => SOCK_STREAM,
Line 397  while (1) { Line 503  while (1) {
     # check for new information on the connections we have      # check for new information on the connections we have
   
     # anything to read or accept?      # anything to read or accept?
     foreach $client ($select->can_read(1)) {      foreach $client ($select->can_read(0.1)) {
   
         if ($client == $server) {          if ($client == $server) {
             # accept a new connection              # accept a new connection
               &status("Accept new connection: $conserver");
             $client = $server->accept();              $client = $server->accept();
             $select->add($client);              $select->add($client);
             nonblock($client);              nonblock($client);
Line 416  while (1) { Line 522  while (1) {
                 delete $outbuffer{$client};                  delete $outbuffer{$client};
                 delete $ready{$client};                  delete $ready{$client};
   
                   &status("Idle $conserver");
                 $select->remove($client);                  $select->remove($client);
                 close $client;                  close $client;
                 next;                  next;
Line 446  while (1) { Line 553  while (1) {
         $rv = $client->send($outbuffer{$client}, 0);          $rv = $client->send($outbuffer{$client}, 0);
         unless (defined $rv) {          unless (defined $rv) {
             # Whine, but move on.              # Whine, but move on.
             warn "I was told I could write, but I can't.\n";              &logthis("I was told I could write, but I can't.\n");
             next;              next;
         }          }
           $errno=$!;
         if (($rv == length $outbuffer{$client}) ||          if (($rv == length $outbuffer{$client}) ||
             ($! == POSIX::EWOULDBLOCK)) {              ($errno == POSIX::EWOULDBLOCK) || ($errno == 0)) {
             substr($outbuffer{$client}, 0, $rv) = '';              substr($outbuffer{$client}, 0, $rv) = '';
             delete $outbuffer{$client} unless length $outbuffer{$client};              delete $outbuffer{$client} unless length $outbuffer{$client};
         } else {          } else {
             # Couldn't write all the data, and it wasn't because              # Couldn't write all the data, and it wasn't because
             # it would have blocked.  Shutdown and move on.              # it would have blocked.  Shutdown and move on.
   
       &logthis("Dropping data with ".$errno.": ".
                        length($outbuffer{$client}).", $rv");
   
             delete $inbuffer{$client};              delete $inbuffer{$client};
             delete $outbuffer{$client};              delete $outbuffer{$client};
             delete $ready{$client};              delete $ready{$client};
Line 495  sub handle { Line 607  sub handle {
             }              }
             $request="enc:$cmdlength:$encrequest\n";              $request="enc:$cmdlength:$encrequest\n";
         }          }
   # --------------------------------------------------------------- Main exchange
       $SIG{ALRM}=sub { die "timeout" };
       $SIG{__DIE__}='DEFAULT';
       eval {
           alarm(300);
           &status("Sending $conserver: $request");
         print $remotesock "$request";          print $remotesock "$request";
           &status("Waiting for reply from $conserver: $request");
         $answer=<$remotesock>;          $answer=<$remotesock>;
           &status("Received reply: $request");
           alarm(0);
       };
       if ($@=~/timeout/) { 
          $answer='';
          &logthis(
           "<font color=red>CRITICAL: Timeout $conserver: $request</font>");
       }  
       $SIG{ALRM}='DEFAULT';
       $SIG{__DIE__}=\&catchexception;
   
   
         if ($answer) {          if ($answer) {
    if ($answer =~ /^enc/) {     if ($answer =~ /^enc/) {
                my ($cmd,$cmdlength,$encinput)=split(/:/,$answer);                 my ($cmd,$cmdlength,$encinput)=split(/:/,$answer);
Line 518  sub handle { Line 649  sub handle {
 # ===================================================== Done processing request  # ===================================================== Done processing request
     }      }
     delete $ready{$client};      delete $ready{$client};
       &status("Completed $conserver: $request");
 # -------------------------------------------------------------- End non-forker  # -------------------------------------------------------------- End non-forker
 }  }
 # ---------------------------------------------------------- End make_new_child  # ---------------------------------------------------------- End make_new_child
Line 530  sub nonblock { Line 662  sub nonblock {
   
           
     $flags = fcntl($socket, F_GETFL, 0)      $flags = fcntl($socket, F_GETFL, 0)
             or catchdie "Can't get flags for socket: $!\n";              or die "Can't get flags for socket: $!\n";
     fcntl($socket, F_SETFL, $flags | O_NONBLOCK)      fcntl($socket, F_SETFL, $flags | O_NONBLOCK)
             or catchdie "Can't make socket nonblocking: $!\n";              or die "Can't make socket nonblocking: $!\n";
 }  }
   
Removed from v.1.10  
changed lines
  Added in v.1.20

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