Diff for /loncom/loncnew between versions 1.8 and 1.10

version 1.8, 2003/06/11 02:04:35 version 1.10, 2003/06/24 02:46:04
Line 41 Line 41
 #    - Add Configuration file I/O                       (done).  #    - Add Configuration file I/O                       (done).
 #    - Add management/status request interface.  #    - Add management/status request interface.
 #    - Add deferred request capability.                  (done)  #    - Add deferred request capability.                  (done)
   #    - Detect transmission timeouts.
 #  #
   
 # Change log:  # Change log:
 #    $Log$  #    $Log$
   #    Revision 1.10  2003/06/24 02:46:04  foxr
   #    Put a limit on  the number of times we'll retry a connection.
   #    Start getting the signal stuff put in as well...note that need to get signals
   #    going or else 6the client will permanently give up on dead servers.
   #
   #    Revision 1.9  2003/06/13 02:38:43  foxr
   #    Add logging in 'expected format'
   #
 #    Revision 1.8  2003/06/11 02:04:35  foxr  #    Revision 1.8  2003/06/11 02:04:35  foxr
 #    Support delayed transactions... this is done uniformly by encapsulating  #    Support delayed transactions... this is done uniformly by encapsulating
 #    transactions in an object ... a LondTransaction that is implemented by  #    transactions in an object ... a LondTransaction that is implemented by
Line 62  use POSIX qw(:signal_h); Line 71  use POSIX qw(:signal_h);
 use IO::Socket;  use IO::Socket;
 use IO::Socket::INET;  use IO::Socket::INET;
 use IO::Socket::UNIX;  use IO::Socket::UNIX;
   use IO::File;
 use IO::Handle;  use IO::Handle;
 use Socket;  use Socket;
 use Crypt::IDEA;  use Crypt::IDEA;
Line 72  use LONCAPA::LondTransaction; Line 82  use LONCAPA::LondTransaction;
 use LONCAPA::Configuration;  use LONCAPA::Configuration;
 use LONCAPA::HashIterator;  use LONCAPA::HashIterator;
   
 print "Loncnew starting\n";  
   
 #  #
 #   Disable all signals we might receive from outside for now.  #   Disable all signals we might receive from outside for now.
Line 97  my %perlvar    = %{$perlvarref}; Line 106  my %perlvar    = %{$perlvarref};
 my %ChildHash; # by pid -> host.  my %ChildHash; # by pid -> host.
   
   
 my $MaxConnectionCount = 5; # Will get from config later.  my $MaxConnectionCount = 10; # Will get from config later.
 my $ClientConnection = 0; # Uniquifier for client events.  my $ClientConnection = 0; # Uniquifier for client events.
   
 my $DebugLevel = 2;  my $DebugLevel = 0;
 my $IdleTimeout= 3600; # Wait an hour before pruning connections.  my $IdleTimeout= 3600; # Wait an hour before pruning connections.
   
 #  #
Line 113  my %ActiveConnections;  # Connections to Line 122  my %ActiveConnections;  # Connections to
 my %ActiveTransactions; # LondTransactions in flight.  my %ActiveTransactions; # LondTransactions in flight.
 my %ActiveClients; # Serial numbers of active clients by socket.  my %ActiveClients; # Serial numbers of active clients by socket.
 my $WorkQueue       = Queue->new(); # Queue of pending transactions.  my $WorkQueue       = Queue->new(); # Queue of pending transactions.
 #  my $ClientQueue     = Queue->new(); # Queue of clients causing xactinos.  
 my $ConnectionCount = 0;  my $ConnectionCount = 0;
 my $IdleSeconds     = 0; # Number of seconds idle.  my $IdleSeconds     = 0; # Number of seconds idle.
   my $Status          = ""; # Current status string.
   my $ConnectionRetries=5; # Number of connection retries allowed.
   my $ConnectionRetriesLeft=5; # Number of connection retries remaining.
   
 #  #
 #   This disconnected socket makes posible a bit more regular  #   The hash below gives the HTML format for log messages
 #   code when processing delayed requests:  #   given a severity.
 #  #    
 my $NullSocket = IO::Socket->new();  my %LogFormats;
   
   $LogFormats{"CRITICAL"} = "<font color=red>CRITICAL: %s</font>";
   $LogFormats{"SUCCESS"}  = "<font color=green>SUCCESS: %s</font>";
   $LogFormats{"INFO"}     = "<font color=yellow>INFO: %s</font>";
   $LogFormats{"WARNING"}  = "<font color=blue>WARNING: %s</font>";
   $LogFormats{"DEFAULT"}  = " %s ";
   
   
   
   =pod
   
   =head2 LogPerm
   
   Makes an entry into the permanent log file.
   
   =cut
   sub LogPerm {
       my $message=shift;
       my $execdir=$perlvar{'lonDaemons'};
       my $now=time;
       my $local=localtime($now);
       my $fh=IO::File->new(">>$execdir/logs/lonnet.perm.log");
       print $fh "$now:$message:$local\n";
   }
   
   =pod
   
   =head2 Log
   
   Logs a message to the log file.
   Parameters:
   
   =item severity
   
   One of CRITICAL, WARNING, INFO, SUCCESS used to select the
   format string used to format the message.  if the severity is
   not a defined severity the Default format string is used.
   
   =item message
   
   The base message.  In addtion to the format string, the message
   will be appended to a string containing the name of our remote
   host and the time will be formatted into the message.
   
   =cut
   
   sub Log {
       my $severity = shift;
       my $message  = shift;
      
       if(!$LogFormats{$severity}) {
    $severity = "DEFAULT";
       }
   
       my $format = $LogFormats{$severity};
       
       #  Put the window dressing in in front of the message format:
   
       my $now   = time;
       my $local = localtime($now);
       my $finalformat = "$local ($$) [$RemoteHost] [$Status] ";
       my $finalformat = $finalformat.$format."\n";
   
       # open the file and put the result.
   
       my $execdir = $perlvar{'lonDaemons'};
       my $fh      = IO::File->new(">>$execdir/logs/lonc.log");
       my $msg = sprintf($finalformat, $message);
       print $fh $msg;
       
       
   }
   
 #  
   
 =pod  =pod
   
Line 179  sub SocketDump { Line 261  sub SocketDump {
 =head2 ShowStatus  =head2 ShowStatus
   
  Place some text as our pid status.   Place some text as our pid status.
    and as what we return in a SIGUSR1
   
 =cut  =cut
 sub ShowStatus {  sub ShowStatus {
     my $status = shift;      my $state = shift;
     $0 =  "lonc: ".$status;      my $now = time;
       my $local = localtime($now);
       $Status   = $local.": ".$state;
       $0='lonc: '.$state.' '.$local;
 }  }
   
 =pod  =pod
Line 222  sub Tick { Line 308  sub Tick {
     #      #
           
     my $Requests = $WorkQueue->Count();      my $Requests = $WorkQueue->Count();
     if (($ConnectionCount == 0)  && ($Requests > 0)) {      if (($ConnectionCount == 0)  && ($Requests > 0)) { 
  my $Connections = ($Requests <= $MaxConnectionCount) ?   if ($ConnectionRetriesLeft > 0) {
                            $Requests : $MaxConnectionCount;      my $Connections = ($Requests <= $MaxConnectionCount) ?
  Debug(1,"Work but no connections, starting ".$Connections." of them");   $Requests : $MaxConnectionCount;
  for ($i =0; $i < $Connections; $i++) {      Debug(1,"Work but no connections, start ".$Connections." of them");
     MakeLondConnection();      for ($i =0; $i < $Connections; $i++) {
    MakeLondConnection();
       }
    } else {
       Debug(1,"Work in queue, but gave up on connections..flushing\n");
       EmptyQueue(); # Connections can't be established.
  }   }
                 
     }      }
Line 404  sub CompleteTransaction { Line 495  sub CompleteTransaction {
  my $data   = $Socket->GetReply(); # Data to send.   my $data   = $Socket->GetReply(); # Data to send.
  StartClientReply($Transaction, $data);   StartClientReply($Transaction, $data);
     } else { # Delete deferred transaction file.      } else { # Delete deferred transaction file.
  &Debug(4, "Deferred transaction complete: ".$Transaction->getFile().   Log("SUCCESS", "A delayed transaction was completed");
        " request: ".$Transaction->getRequest().   LogPerm("S:$Client:".$Transaction->getRequest());
        " answer: ".$Socket->GetReply());  
  unlink $Transaction->getFile();   unlink $Transaction->getFile();
     }      }
 }  }
Line 466  Parameters: Line 556  Parameters:
   
 sub FailTransaction {  sub FailTransaction {
     my $transaction = shift;      my $transaction = shift;
     my $Lond        = $transaction->getServer();      Debug(1, "Failing transaction: ".$transaction->getRequest());
     if (!$client->isDeferred()) { # If the transaction is deferred we'll get to it.      if (!$transaction->isDeferred()) { # If the transaction is deferred we'll get to it.
  my $client  = $transcation->getClient();   my $client  = $transcation->getClient();
  StartClientReply($client, "con_lost");   Debug(1," Replying con_lost to ".$transaction->getRequest());
    StartClientReply($client, "con_lost\n");
     }      }
 # not needed, done elsewhere if active.  
 #    delete $ActiveTransactions{$Lond};  
   
 }  }
   
Line 485  sub FailTransaction { Line 574  sub FailTransaction {
 =cut  =cut
 sub EmptyQueue {  sub EmptyQueue {
     while($WorkQueue->Count()) {      while($WorkQueue->Count()) {
  my $request = $Workqueue->dequeue(); # This is a transaction   my $request = $WorkQueue->dequeue(); # This is a transaction
  FailTransaction($request);   FailTransaction($request);
     }      }
 }  }
   
 =pod  =pod
   
   =head2 CloseAllLondConnections
   
   Close all connections open on lond prior to exit e.g.
   
   =cut
   sub CloseAllLondConnections {
       foreach $Socket (keys %ActiveConnections) {
    KillSocket($Socket);
       }
   }
   =cut
   
   =pod
   
 =head2 KillSocket  =head2 KillSocket
     
 Destroys a socket.  This function can be called either when a socket  Destroys a socket.  This function can be called either when a socket
Line 515  nonzero if we are allowed to create a ne Line 618  nonzero if we are allowed to create a ne
 sub KillSocket {  sub KillSocket {
     my $Socket = shift;      my $Socket = shift;
   
       $Socket->Shutdown();
   
     #  If the socket came from the active connection set,      #  If the socket came from the active connection set,
     #  delete its transaction... note that FailTransaction should      #  delete its transaction... note that FailTransaction should
     #  already have been called!!!      #  already have been called!!!
Line 657  sub LondReadable { Line 762  sub LondReadable {
     Debug(8,"Completing transaction!!");      Debug(8,"Completing transaction!!");
     CompleteTransaction($Socket,       CompleteTransaction($Socket, 
  $ActiveTransactions{$Socket});   $ActiveTransactions{$Socket});
    } else {
       Log("SUCCESS", "Connection ".$ConnectionCount." to "
    .$RemoteHost." now ready for action");
  }   }
  ServerToIdle($Socket); # Next work unit or idle.   ServerToIdle($Socket); # Next work unit or idle.
   
Line 759  sub LondWritable { Line 867  sub LondWritable {
  if ($Socket->Writable() != 0) {   if ($Socket->Writable() != 0) {
     #  The write resulted in an error.      #  The write resulted in an error.
     # We'll treat this as if the socket got disconnected:      # We'll treat this as if the socket got disconnected:
       Log("WARNING", "Connection to ".$RemoteHost.
    " has been disconnected");
     $Watcher->cancel();      $Watcher->cancel();
     KillSocket($Socket);      KillSocket($Socket);
     return;      return;
Line 898  sub MakeLondConnection { Line 1007  sub MakeLondConnection {
  &GetServerPort());   &GetServerPort());
   
     if($Connection == undef) { # Needs to be more robust later.      if($Connection == undef) { # Needs to be more robust later.
  Debug(0,"Failed to make a connection with lond.");   Log("CRITICAL","Failed to make a connection with lond.");
    $ConnectionRetriesLeft--;
    return 0; # Failure.
     }  else {      }  else {
    $ConnectionRetriesLeft = $ConnectionRetries; # success resets the count
  # The connection needs to have writability    # The connection needs to have writability 
  # monitored in order to send the init sequence   # monitored in order to send the init sequence
  # that starts the whole authentication/key   # that starts the whole authentication/key
Line 925  sub MakeLondConnection { Line 1037  sub MakeLondConnection {
  if($ConnectionCount == 1) { # First Connection:   if($ConnectionCount == 1) { # First Connection:
     QueueDelayed;      QueueDelayed;
  }   }
    Log("SUCESS", "Created connection ".$ConnectionCount
       ." to host ".GetServerHost());
    return 1; # Return success.
     }      }
           
 }  }
Line 1022  sub QueueTransaction { Line 1137  sub QueueTransaction {
 =pod  =pod
   
 =head2 ClientRequest  =head2 ClientRequest
   
 Callback that is called when data can be read from the UNIX domain  Callback that is called when data can be read from the UNIX domain
 socket connecting us with an apache server process.  socket connecting us with an apache server process.
   
Line 1047  sub ClientRequest { Line 1161  sub ClientRequest {
  close($socket);   close($socket);
  $watcher->cancel();   $watcher->cancel();
  delete($ActiveClients{$socket});   delete($ActiveClients{$socket});
    return;
     }      }
     Debug(8,"Data: ".$data." this read: ".$thisread);      Debug(8,"Data: ".$data." this read: ".$thisread);
     $data = $data.$thisread; # Append new data.      $data = $data.$thisread; # Append new data.
     $watcher->data($data);      $watcher->data($data);
     if($data =~ /(.*\n)/) { # Request entirely read.      if($data =~ /(.*\n)/) { # Request entirely read.
    if($data eq "close_connection_exit\n") {
       Log("CRITICAL",
    "Request Close Connection ... exiting");
       CloseAllLondConnections();
       exit;
    }
  Debug(8, "Complete transaction received: ".$data);   Debug(8, "Complete transaction received: ".$data);
  my $Transaction = LondTransaction->new($data);   my $Transaction = LondTransaction->new($data);
  $Transaction->SetClient($socket);   $Transaction->SetClient($socket);
Line 1163  sub SetupLoncListener { Line 1284  sub SetupLoncListener {
   
 =pod  =pod
   
   =head2 SignalledToDeath
   
   Called in response to a signal that causes a chid process to die.
   
   =cut
   
   =pod
   
   sub SignalledToDeath {
       my ($signal) = @_;
       chomp($signal);
       Log("CRITICAL", "Abnormal exit.  Child $$ for $RemoteHost "
    ."died through "."\"$signal\"");
       LogPerm("F:lonc: $$ on $RemoteHost signalled to death: "
       ."\"$signal\"");
       die("Signal abnormal end");
   
   }
 =head2 ChildProcess  =head2 ChildProcess
   
 This sub implements a child process for a single lonc daemon.  This sub implements a child process for a single lonc daemon.
Line 1171  This sub implements a child process for Line 1310  This sub implements a child process for
   
 sub ChildProcess {  sub ChildProcess {
   
     print "Loncnew\n";  
   
     # For now turn off signals.      # For now turn off signals.
           
     $SIG{QUIT}  = IGNORE;      $SIG{QUIT}  = \&SignalledToDeath;
     $SIG{HUP}   = IGNORE;      $SIG{HUP}   = IGNORE;
     $SIG{USR1}  = IGNORE;      $SIG{USR1}  = IGNORE;
     $SIG{INT}   = IGNORE;      $SIG{INT}   = IGNORE;
     $SIG{CHLD}  = IGNORE;      $SIG{CHLD}  = IGNORE;
     $SIG{__DIE__}  = IGNORE;      $SIG{__DIE__}  = \&SignalledToDeath;
   
     SetupTimer();      SetupTimer();
           
Line 1192  sub ChildProcess { Line 1330  sub ChildProcess {
   
 # Setup the initial server connection:  # Setup the initial server connection:
           
     &MakeLondConnection();       # &MakeLondConnection(); // let first work requirest do it.
   
   
     if($ConnectionCount == 0) {  
  Debug(1,"Could not make initial connection..\n");  
  Debug(1,"Will retry when there's work to do\n");  
     }  
     Debug(9,"Entering event loop");      Debug(9,"Entering event loop");
     my $ret = Event::loop(); #  Start the main event loop.      my $ret = Event::loop(); #  Start the main event loop.
           
Line 1210  sub ChildProcess { Line 1345  sub ChildProcess {
 sub CreateChild {  sub CreateChild {
     my $host = shift;      my $host = shift;
     $RemoteHost = $host;      $RemoteHost = $host;
     Debug(3, "Forking off child for ".$RemoteHost);      Log("CRITICAL", "Forking server for ".$host);
     sleep(5);  
     $pid          = fork;      $pid          = fork;
     if($pid) { # Parent      if($pid) { # Parent
  $ChildHash{$pid} = $RemoteHost;   $ChildHash{$pid} = $RemoteHost;
Line 1264  if (POSIX::setsid() < 0) { Line 1398  if (POSIX::setsid() < 0) {
   
 ShowStatus("Forking node servers");  ShowStatus("Forking node servers");
   
   Log("CRITICAL", "--------------- Starting children ---------------");
   
 my $HostIterator = LondConnection::GetHostIterator;  my $HostIterator = LondConnection::GetHostIterator;
 while (! $HostIterator->end()) {  while (! $HostIterator->end()) {
   
Line 1276  while (! $HostIterator->end()) { Line 1412  while (! $HostIterator->end()) {
   
 ShowStatus("Parent keeping the flock");  ShowStatus("Parent keeping the flock");
   
   #
   #   Set up parent signals:
   #
   $SIG{INT}  = &KillThemAll;
   $SIG{TERM} = &KillThemAll; 
   
 while(1) {  while(1) {
     $deadchild = wait();      $deadchild = wait();
     if(exists $ChildHash{$deadchild}) { # need to restart.      if(exists $ChildHash{$deadchild}) { # need to restart.
  $deadhost = $ChildHash{$deadchild};   $deadhost = $ChildHash{$deadchild};
  delete($ChildHash{$deadchild});   delete($ChildHash{$deadchild});
  Debug(4,"Lost child pid= ".$deadchild.   Log("WARNING","Lost child pid= ".$deadchild.
       "Connected to host ".$deadhost);        "Connected to host ".$deadhost);
    Log("INFO", "Restarting child procesing ".$deadhost);
  CreateChild($deadhost);   CreateChild($deadhost);
     }      }
 }  }
   sub KillThemAll {
   }
   
 =head1 Theory  =head1 Theory
   

Removed from v.1.8  
changed lines
  Added in v.1.10


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