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

Diff for /loncom/Attic/lonManage between versions 1.16 and 1.28

version 1.16, 2003/10/21 09:44:04 version 1.28, 2003/12/30 11:40:09
Line 36 Line 36
 #    lonManage  -push   <tablename>  newfile  [host]  #    lonManage  -push   <tablename>  newfile  [host]
 #        Push <tablename> to the lonTabs directory.  Note that  #        Push <tablename> to the lonTabs directory.  Note that
 #        <tablename> must be one of:  #        <tablename> must be one of:
 #           host  (hosts.tab)  #           hosts  (hosts.tab)
 #           domain (domain.tab)  #           domain (domain.tab)
 #  #
 #    lonManage  -reinit lonc [host]  #    lonManage  -reinit lonc [host]
Line 52 Line 52
 #   If [host] is not supplied, every host in the client's hosts.tab  #   If [host] is not supplied, every host in the client's hosts.tab
 #   table is iterated through and procesed..  #   table is iterated through and procesed..
 #  #
 #  $Log$  
 #  Revision 1.16  2003/10/21 09:44:04  foxr  
 #  Add ability to manage entire cluster in hosts table.  
 #  
 #  Revision 1.15  2003/09/16 09:49:54  foxr  
 #  Adjust the usage message to reflect what actually will happen on  
 #  --reinit={lond|lonc}  
 #  
 #  Revision 1.14  2003/09/08 09:45:20  foxr  
 #  Remove BUGBUG about comment about authentication as we'll be doing  
 #  host based authentication initially (no need for lonManage to do anything),  
 #  and certificate based later (need at that time).  
 #  
 #  Revision 1.13  2003/08/19 10:26:24  foxr  
 #  Initial working version... tested against an unmodified lond this  
 #  produces an unknown_cmd response which is about what I'd expect.  
 #  
 #  Revision 1.12  2003/08/18 11:08:07  foxr  
 #  Debug request building in Transact.  
 #  
 #  Revision 1.11  2003/08/18 10:45:32  foxr  
 #  Felt strongly enough about hoisting ReadConfiguration into a separate sub  
 #  that I did it now before I forgot.  
 #  
 #  Revision 1.10  2003/08/18 10:43:31  foxr  
 #  Code/test ValidHost.  The hosts.tab and the perl variables are read in as  
 #  global hashes as a side effect.  May later want to clean this up by making  
 #  a separate getconfig function and hoisting the config reads into that.  
 #  
 #  Revision 1.9  2003/08/18 10:25:46  foxr  
 #  Write ReinitProcess function in terms of ValidHost and Transact.  
 #  
 #  Revision 1.8  2003/08/18 10:18:21  foxr  
 #  Completed PushFile function in terms of  
 #  - ValidHost - Determines if target host is valid.  
 #  - Transact  - Performs one of the valid transactions with the  
 #                appropriate lonc<-->lond client/server pairs.  
 #  
 #  Revision 1.7  2003/08/18 09:56:01  foxr  
 #  1. Require to be run as root.  
 #  2. Catch case where no operation switch is supplied and put out usage.  
 #  3. skeleton/comments for PushFile function.  
 #  
 #  Revision 1.6  2003/08/12 11:02:59  foxr  
 #  Implement command switch dispatching.  
 #  
 #  Revision 1.5  2003/08/12 10:55:42  foxr  
 #  Complete command line parsing (tested)  
 #  
 #  Revision 1.4  2003/08/12 10:40:44  foxr  
 #  Get switch parsing right.  
 #  
 #  Revision 1.3  2003/08/12 10:22:35  foxr  
 #  Put in parameter parsing infrastructure  
 #  
 #  Revision 1.2  2003/08/12 09:58:49  foxr  
 #  Add usage and skeleton documentation.  
 #  
 #  #
   
   
   
 # Modules required:  # Modules required:
   
   use lib ".";
   
 use strict; # Because it's good practice.  use strict; # Because it's good practice.
 use English; # Cause I like meaningful names.  use English; # Cause I like meaningful names.
 use Getopt::Long;  use Getopt::Long;
 use LONCAPA::Configuration; # To handle configuration I/O.  use LondConnection;
 use IO::Socket::UNIX; # To communicate with lonc.  use IO::Poll qw(POLLRDNORM POLLWRNORM POLLIN POLLHUP POLLOUT);
   use IO::File;
   
 # File scoped variables:  # File scoped variables:
   
 my %perlvar; # Perl variable defs from apache config.  my %perlvar; # Perl variable defs from apache config.
 my %hostshash; # Host table as a host indexed hash.  my %hostshash; # Host table as a host indexed hash.
   
   my $MyHost=""; # Host name to use as me.
   my $ForeignHostTab=""; # Name of foreign hosts table.
   
   my $DefaultServerPort =  5663; # Default server port if standalone.
   my $ServerPort; # Port used to connect to lond.
   
   my $TransitionTimeout = 5; # Poll timeout in seconds.
   
   
   # LondConnection::SetDebug(10);
   
   
 #  #
 #   prints out utility's command usage info.  #   prints out utility's command usage info.
 #  #
 sub Usage  {  sub Usage  {
     print "Usage:";      print "Usage:";
     print <<USAGE;      print <<USAGE;
     lonManage  --push=<tablename>  newfile  [host]   lonManage  [--myname=host --hosts=table] --push=<tablename>  newfile  [host]
         Push <tablename> to the lonTabs directory.  Note that          Push <tablename> to the lonTabs directory.  Note that
         <tablename> must be one of:          <tablename> must be one of:
            host  (hosts.tab)             hosts  (hosts.tab)
            domain (domain.tab)             domain (domain.tab)
   
     lonManage  --reinit=lonc [host]   lonManage [--myname=host --hosts=table] --reinit=lonc [host]
        Causes lonc in the remote system to reread hosts.tab and         Causes lonc in the remote system to reread hosts.tab and
        adjust the set of clients that are being maintained to match         adjust the set of clients that are being maintained to match
        the new file.         the new file.
                 
   
     lonManage  --reinit=lond [host]   lonManage [--myname=host --hosts=table] --reinit=lond [host]
        Causes lond in the remote system to reread the hosts.tab file         Causes lond in the remote system to reread the hosts.tab file
        and adjust the set of servers to match changes in that file.         and adjust the set of servers to match changes in that file.
   
Line 155  sub Usage  { Line 112  sub Usage  {
     If [host] is omitted, all hosts in the hosts.tab file are iterated      If [host] is omitted, all hosts in the hosts.tab file are iterated
     over.      over.
   
   lonManage [--myname=host --hosts=table] --edit=<tablename> editscript [host]
        Requests lond edit the hosts or domain table (selected by
        tablename) with the editing command in editscript.  If
        host is supplied the individual host is operated on,
        otherwise, the entire cluster is operated on.
        The edit file has edit request, one per line of the form:
        append|newline
        replace|key|newline
        delete|key
        The key is a loncapa hostname if editing the host file
        or a domain name if editing the domain table file.
   
    For all of the above syntaxes if --myname=host and --hosts=table are
    supplied (both must be present), the utility runs in standalone mode
    presenting itself to the world as 'host' and using the hosts.tab file
    specified in the --hosts switch.
 USAGE  USAGE
   
   
 }  }
   
   #
   #  Make a direct connection to the lond in 'host'.  The port is 
   #  gotten from the global variable:  ServerPort.
   #  Returns:
   #    The connection or undef if one could not be formed.
   #
   sub MakeLondConnection {
       my $host = shift;
   
       my $Connection = LondConnection->new($host, $ServerPort);
       return return $Connection;
   }
   #
   #   Process the connection state machine until the connection
   #   becomes idle. This is used both to negotiate the initial
   #   connection, during which the LondConnection sequences a rather 
   #   complex state machine and during the transaction itself
   #   for a simpler set of transitions.
   #   All we really need to be concerned with is whether or not
   #   we're readable or writable and the final state:
 #  #
 #   Lifted from lonnet.pm - and we need to figure out a way to get it back in.  #   Parameter:
 #   Performas a transaction with lond via the lonc proxy server.  #       connection   - Represents the LondConnection to be sequenced.
   #       timeout      - Maximum time to wait for readable/writable sockets.
   #                      in seconds. < 0 waits forever.
   #   Return:
   #       'ok'         - We got to idle ok.
   #       'error:msg'  - An error occured. msg describes the error.
   #
   sub SequenceStateMachine {
       my $connection   = shift;
       my $timeout      = shift;
   
       my $Socket       = $connection->GetSocket;
       my $returnstatus = "ok";              # optimist!!!
       my $error        = 0;              # Used to force early loop termination
                                                 # damned perl has no break!!.
       my $state        = $connection->GetState;
   
       while(($connection->GetState ne "Idle") && (!$error)) {
         #
         # Figure out what the connection wants. read/write and wait for it
         # or for the timeout.
         #
    my $wantread = $connection->WantReadable;
    my $poll     = new IO::Poll;
    $poll->mask($Socket, => $wantread ? POLLIN : POLLOUT);
    my $handlecount = $poll->poll($timeout);
    if($handlecount == 0) {            # no handles ready... timeout!!
       $returnstatus  = "error:";
       $returnstatus .= "Timeout in state $state\n";
       $error         = 1;
    } else {
       my $done     = $poll->handles();
       my $status;
       $status        = $wantread ? $connection->Readable :
    $connection->Writable;
       if($status != 0) {
    $returnstatus  =  "error:";
    $returnstatus .=  " I/O failed in state $state\n";
    $error = 1;
       }
    }
    $state = $connection->GetState;
       }
       return $returnstatus;
   }
   
   #
   #    This function runs through the section of the connection
   #   state machine that has to do with negotiating the startup 
   #   sequence with lond.  The general strategy is to loop
   #   until the connection state becomes idle or disconnected.
   #   Disconnected indicates an error or rejection of the
   #   connection at some point in the negotiation.
   #   idle indicates a connection ready for a request.
   #   The main loop consults the object to determine if it
   #   wants to be writeable or readable, waits for that
   #   condition on the socket (with timeout) and  then issues
   #   the appropriate LondConnection call. Note that
   #   LondConnection is capable of doing everything necessary
   #   to get to the initial idle state.
   # 
   #
   #  Parameters:
   #     connection - A connection that has been created with
   #                  the remote lond.  This connection should
   #                  be in the Connected state ready to send
   #                  the init sequence.
   #
   sub NegotiateStartup {
       my $connection = shift;
       my $returnstatus = "ok"; # Optimistic!!.
   
       my $state      = $connection->GetState;
      if($state ne "Connected") {
         print "Error: Initial lond connection state: $state should be Connected\n";
         return "error";
      }
   
      return SequenceStateMachine($connection, $TransitionTimeout);
   }
   #
   #   Perform a transaction with the remote lond.
   #   Paramters:
   #      connection - the connection object that represents
   #                   a LondConnection to the remote lond.
   #      command    - The request to send to the remote system.
   #   Returns:
   #       The 'reaction' of the lond to this command.
   #       However if the connection to lond is lost during the transaction
   #       or some other error occurs, the text "error:con_lost" is returned.
   #    
   sub PerformTransaction {
       my $connection  = shift;
       my $command     = shift;
       my $retval;                          # What we'll returnl.
   
      
       #  Set up the connection to do the transaction then
       #  do the I/O until idle or error.
       #
       $connection->InitiateTransaction($command);
   
       my $status = SequenceStateMachine($connection, $TransitionTimeout);
      if($status eq "ok") {
         $retval = $connection->GetReply;
      } else {
         $retval = $status;
      }
   
       return $retval;
   }
   #
   # Performs a transaction direct to a remote lond.
 #   Parameter:  #   Parameter:
 #      cmd  - The text of the request.  #      cmd  - The text of the request.
 #      host - The host to which the request ultimately goes.  #      host - The host to which the request ultimately goes.
Line 170  USAGE Line 276  USAGE
 #      lond/lonc etc.  #      lond/lonc etc.
 #  #
 sub subreply {  sub subreply {
     my ($cmd,$server)=@_;      my $cmd = shift;
     my $peerfile="$perlvar{'lonSockDir'}/$server";      my $host = shift;
     my $client=IO::Socket::UNIX->new(Peer    =>"$peerfile",  
                                      Type    => SOCK_STREAM,  
                                      Timeout => 10)     my $connection  = MakeLondConnection($host);
        or return "con_lost";     if ($connection eq undef) {
     print $client "$cmd\n";        return "Connect Failed";
     my $answer=<$client>;     }
     if (!$answer) { $answer="con_lost"; }     my $reply = NegotiateStartup($connection);
     chomp($answer);     if($reply ne "ok") {
     return $answer;        return "connection negotiation failed";
      }
      my $reply =  PerformTransaction($connection, $cmd);
      return $reply;
   
   
 }  }
 #   >>> BUGBUG <<<   
 #  #
 #  Use Getopt::Long to parse the parameters of the program.  #  Use Getopt::Long to parse the parameters of the program.
 #  #
Line 206  sub subreply { Line 316  sub subreply {
 #   returns an empty list if the parse fails.  #   returns an empty list if the parse fails.
 #  #
   
   
 sub ParseArgs {  sub ParseArgs {
     my $pushing   = '';      my $pushing    = '';
     my $reinitting = '';      my $reinitting = '';
       my $editing    = '';
     if(!GetOptions('push=s'    => \$pushing,  
            'reinit=s'  => \$reinitting)) {  
  return ();  
     }  
   
     #  Require exactly   one of --push and --reinit  
   
     my $command    = '';  
     my $commandarg = '';  
     my $paramcount = @ARGV; # Number of additional arguments.  
           
       if(!GetOptions('push=s'    => \$pushing,
     if($pushing ne '') {                     'reinit=s'  => \$reinitting,
                      'edit=s'    => \$editing,
         # --push takes in addition a table, and an optional  host:               'myname=s'  => \$MyHost,
         #               'hosts=s'   => \$ForeignHostTab)) {
  if(($paramcount != 2) && ($paramcount != 1)) {        return ();
     return (); # Invalid parameter count.     }
  }      #  The --myname and --hosts switch must have values and
  if($command ne '') {      #  most both appear if either appears:
     return ();  
  } else {     if(($MyHost ne "") && ($ForeignHostTab eq "")) {
         return ();
      }
      if(($ForeignHostTab ne "") && ($MyHost eq "")) {
         return ();
      }
   
       #  Require exactly   one of --push, --reinit, or --edit
   
      my $command    = '';
      my $commandarg = '';
      my $paramcount = @ARGV; # Number of additional arguments.
   
      my $commands = 0;           # Number of commands seen.
   
      if($pushing ne '') {
   
         # --push takes in addition a table, and an optional  host:
         #
           
      if(($paramcount != 2) && ($paramcount != 1)) {
            return (); # Invalid parameter count.
         }
           
     $command    = 'push';        $commands++;              # Count a command seen.
     $commandarg = $pushing;        $command    = 'push';
         $commandarg = $pushing;
  }   }
     }  
   
     if ($reinitting ne '') {     if ($reinitting ne '') {
   
  # --reinit takes in addition just an optional  host name   # --reinit takes in addition just an optional  host name
   
  if($paramcount > 1) {        if($paramcount > 1) {
     return ();           return ();
  }        }
  if($command ne '') {        $commands++;              #  Count a command seen.
     return ();        $command    = 'reinit';
  } else {        $commandarg = $reinitting; 
     $command    = 'reinit';  
     $commandarg = $reinitting;   
  }   }
     }  
      # --edit takes a script file and optional host name.
      #
      if ($editing ne "") {
         if(($paramcount != 2) && ($paramcount != 1)) {
            return ();              # Invalid parameter count.
         }
         
         $commands++;               # Count a command seen.
         $command    = 'edit';
         $commandarg = $editing;
      }
      
      #  At this point, $commands must be 1 or else we've seen
      #  The wrong number of command switches:
      
      if($commands != 1) {
         return ();
      }
   
     #  Build the result list:      #  Build the result list:
   
     my @result = ($command, $commandarg);     my @result = ($command, $commandarg);
     my $i;     my $i;
     for($i = 0; $i < $paramcount; $i++) {     for($i = 0; $i < $paramcount; $i++) {
  push(@result, $ARGV[$i]);        push(@result, $ARGV[$i]);
     }     }
           
     return @result;      return @result;
 }  }
 #  #
 #  Read the loncapa configuration stuff.  #  Build the editor script.  This function:
   #  - Opens the edit script file.
   #  - Reads each line of the edit script file
   #  - Replaces the ending \n with a /
   #  - Appends it to the EditScript variable.
   #  - Returns the contents of the EditScript variable.
   #  Parameters:
   #     tabletype   - The type of table being built:
   #                   hosts or domain
   #     scriptname  - The script input file.
   #
   sub BuildEditScript {
      my $TableType    = shift;
      my $ScriptName   = shift;
      
      my $fh  = new IO::File "< $ScriptName";
      if (! (defined $fh)) {
          print "Unable to open script file: $ScriptName \n";
          Usage;
          exit -1;
      }
      
      my @EditScript;
      my $scriptline = "$TableType\:"; # First leads with e.g. hosts:
      while (! $fh->eof()) {
          my $line = <$fh>;
          chomp $line;
          if($line ne "\n") {
      $scriptline .= "$line\n";
      push(@EditScript, $scriptline);
      $scriptline = "";
          }
      }
   
      return \@EditScript;
   }
   #  Read the loncapa configuration stuff.  If ForeignHostTab is empty,
   #  assume we are part of a loncapa cluster and read the hosts.tab
   #  file from the config directory.  Otherwise, ForeignHossTab
   #  is the name of an alternate configuration file to read in 
   #  standalone mode.
 #  #
 sub ReadConfig {  sub ReadConfig {  
     my $perlvarref = LONCAPA::Configuration::read_conf('loncapa.conf');  
     %perlvar       = %{$perlvarref};  
     my $hoststab   = LONCAPA::Configuration::read_hosts(  
  "$perlvar{'lonTabDir'}/hosts.tab");  
     %hostshash     = %{$hoststab};  
   
      
      if($ForeignHostTab eq "") {
          my $perlvarref = LondConnection::read_conf('loncapa.conf');
          %perlvar    = %{$perlvarref};
          my $hoststab   = LondConnection::read_hosts(
      "$perlvar{lonTabDir}/hosts.tab");
         %hostshash     = %{$hoststab};
         $MyHost        = $perlvar{lonHostID}; # Set hostname from vars.
         $ServerPort    = $perlvar{londPort};
      } else {
   
         LondConnection::ReadForeignConfig($MyHost, 
                                           $ForeignHostTab);
         my $hoststab = LondConnection::read_hosts($ForeignHostTab); #  we need to know too.
      %hostshash   = %{$hoststab};
      $ServerPort    = $DefaultServerPort;
      }
 }  }
 #  #
 #  Determine if the target host is valid.  #  Determine if the target host is valid.
Line 318  sub Transact { Line 510  sub Transact {
     my $body;      my $body;
     my $i;      my $i;
   
     if(scalar @ARG) {     if(scalar @ARG) {
  $body = shift;        $body = shift;
  $haveBody = 1;        $haveBody = 1;
     }     }
     #  Construct the command to send to the server:      #  Construct the command to send to the server:
           
     my $request = "encrypt\:"; # All requests are encrypted.     my $request = "encrypt\:"; # All requests are encrypted.
     $request   .= $command;     $request   .= $command;
     if($haveBody) {     if($haveBody) {
  $request .= "\:";        $request .= "\:";
  my $bodylines = scalar @$body;        my $bodylines = scalar @$body;
  for($i = 0; $i < $bodylines; $i++) {        for($i = 0; $i < $bodylines; $i++) {
     $request .= $$body[$i];           $request .= $$body[$i];
  }        }
     } else {     } else {
  $request .= "\n";        $request .= "\n";
     }     }
     # Body is now built... transact with lond..      # Body is now built... transact with lond..
           
       print "Final command: '$request'\n";
     my $answer = subreply($request, $host);      my $answer = subreply($request, $host);
   
     print "$answer\n";      print "$answer\n";
Line 358  sub Transact { Line 551  sub Transact {
 #     tablefile - name of the file containing the table to push.  #     tablefile - name of the file containing the table to push.
 #     host      - name of the host to push this file to.       #     host      - name of the host to push this file to.     
 #  #
 #    >>>BUGBUG<<< This belongs in lonnet.pm.  #    
 #  #
 sub PushFile {  sub PushFile {
     my $tablename = shift;      my $tablename = shift;
Line 367  sub PushFile { Line 560  sub PushFile {
           
     # Open the table file:      # Open the table file:
   
     if(!open(TABLEFILE, "<$tablefile")) {     if(!open(TABLEFILE, "<$tablefile")) {
  die "ENOENT - No such file or directory $tablefile";        die "ENOENT - No such file or directory $tablefile";
     }     }
       
     # Require that the host be valid:      # Require that the host be valid:
   
     if(!ValidHost($host)) {     if(!ValidHost($host)) {
  die "EHOSTINVAL - Invalid host $host"; # Ok so I invented this 'errno'.        die "EHOSTINVAL - Invalid host $host"; # Ok so I invented this 'errno'.
     }     }
     # Read in the file.  If the table name is valid, push it.      # Read in the file.  If the table name is valid, push it.
   
     my @table = <TABLEFILE>; #  These files are pretty small.     my @table = <TABLEFILE>; #  These files are pretty small.
     close TABLEFILE;     close TABLEFILE;
   
     if( ($tablename eq "host")    ||     if( ($tablename eq "hosts")    ||
  ($tablename eq "domain")) {         ($tablename eq "domain")) {
  print("Pushing $tablename to $host\n");        print("Pushing $tablename to $host\n");
  Transact($host, "pushfile:$tablename",\@table);        Transact($host, "pushfile:$tablename",\@table);
     } else {     } else {
  die "EINVAL - Invalid parameter. tablename: $tablename must be host or domain";        die "EINVAL - Invalid parameter. tablename: $tablename must be host or domain";
     }     }
   }
   #
   #   This function forms and executes an edit file with a
   #   remote lond server.  We build the full transaction string
   #   and use Transact to perform the transaction.
   #   Paramters:
   #      host     - loncapa name of host to operate on.
   #      body     - Body of the command.  We send:
   #                  edit:$body as the command request.
   #
   sub EditFile {
      my $host    = shift;
      my $body    = shift;
      
      if(!ValidHost($host)) {
         die "EHOSTINVAL - Invalid host $host";
      }
      Transact($host, "edit", $body);
 }  }
   
 #  #
 #   This function is called to reinitialize a server in a remote host.  #   This function is called to reinitialize a server in a remote host.
 #   The servers that can be reinitialized are:  #   The servers that can be reinitialized are:
Line 405  sub PushFile { Line 617  sub PushFile {
 #   >>>BUGBUG<<<< This belongs  in lonnet.pm  #   >>>BUGBUG<<<< This belongs  in lonnet.pm
 #  #
 sub ReinitProcess {  sub ReinitProcess {
     my $process = shift;     my $process = shift;
     my $host    = shift;     my $host    = shift;
   
     #  Ensure the host is valid:      #  Ensure the host is valid:
           
     if(!ValidHost($host)) {     if(!ValidHost($host)) {
  die "EHOSTINVAL - Invalid host $host";        die "EHOSTINVAL - Invalid host $host";
     }     }
     # Ensure target process selector is valid:      # Ensure target process selector is valid:
   
     if(($process eq "lonc") ||     if(($process eq "lonc") ||
        ($process eq "lond")) {        ($process eq "lond")) {
  print("Reinitializing $process in $host\n");        print("Reinitializing $process in $host\n");
  Transact($host, "reinit:$process");        Transact($host, "reinit:$process");
     } else {     } else {
  die "EINVAL -Invalid parameter. Process $process must be lonc or lond";        die "EINVAL -Invalid parameter. Process $process must be lonc or lond";
     }     }
 }  }
 #--------------------------- Entry point: --------------------------  #--------------------------- Entry point: --------------------------
   
 ReadConfig; # Read the configuration info (incl.hosts).  
   
   
 #  Parse the parameters  #  Parse the parameters
Line 445  if ($EUID != 0) { Line 656  if ($EUID != 0) {
     die "ENOPRIV - No privilege for requested operation"      die "ENOPRIV - No privilege for requested operation"
 }  }
   
   #
   #   Read the configuration file.
   #   
   
   ReadConfig; # Read the configuration info (incl.hosts).
   
 #   Based on the operation requested invoke the appropriate function:  #   Based on the operation requested invoke the appropriate function:
   
Line 455  if($operation eq "push") {  # push table Line 671  if($operation eq "push") {  # push table
     my $tablefile = shift @params;      my $tablefile = shift @params;
     my $host      = shift @params;      my $host      = shift @params;
     if($host) {      if($host) {
  PushFile($tablename, $tablefile, $host);        PushFile($tablename, $tablefile, $host);
     } else { # Push to whole cluster.      } else { # Push to whole cluster.
  foreach my $host (keys %hostshash) {        foreach my $host (keys %hostshash) {
     PushFile($tablename, $tablefile, $host);           PushFile($tablename, $tablefile, $host);
  }        }
     }      }
   
 } elsif($operation eq "reinit") { # reinit processname host.  } elsif($operation eq "reinit") { # reinit processname host.
Line 472  if($operation eq "push") {  # push table Line 688  if($operation eq "push") {  # push table
     ReinitProcess($process,$host);      ReinitProcess($process,$host);
  }   }
     }      }
 }   } elsif($operation eq "edit") {   # Edit a table.
      my $tablename     = shift @params;
      my $scriptfile    = shift @params;
      my $host          = shift @params;
      my $CommandBody   = BuildEditScript($tablename, $scriptfile);
      if ($host) {
         EditFile($host, $CommandBody);
      } else {
         foreach my $ClusterMember (keys %hostshash) {
            EditFile($ClusterMember, $CommandBody);
         }
      }
   }
 else {  else {
     Usage;     Usage;
 }  }
 exit 0;  exit 0;
   
Line 494  Usage: Line 722  Usage:
     B<lonManage  --reinit=lonc host>      B<lonManage  --reinit=lonc host>
            Sends a HUP signal to the remote systems's lond.             Sends a HUP signal to the remote systems's lond.
   
     B<lonmanage  --reinit=lond host>      B<lonManage  --reinit=lond host>
           Requests the remote system's lond perform the same action as if            Requests the remote system's lond perform the same action as if
           it had received a HUP signal.            it had received a HUP signal.
   
     In the above syntax, the host above is the hosts.tab name of a host,      B<lonManage  --edit=<tablename> editscript host>
     not the IP address of the host.           Requests the remote system's lond perform an edit
            on <tablename>  editscript supplies a set of 
            editing commands.  Each edit command is one of :
            
            append|key|newline
            delete|key|
            replace|key|newline
            
            The key above is the value of the loncapa host name
            in the file.
            
   In the above syntax, the host above is the 
   hosts.tab name of a host,
   not the IP address of the host.
   
   
 =head1 DESCRIPTION  =head1 DESCRIPTION
Line 510  Usage: Line 751  Usage:
 =item Getopt::Long  =item Getopt::Long
 =item English  =item English
 =item IO::Socket::UNIX  =item IO::Socket::UNIX
   =item LONCAPA::LondConnection
   
 =head1 KEY Subroutines.  =head1 KEY Subroutines.
   
Removed from v.1.16  
changed lines
  Added in v.1.28

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