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

Diff for /loncom/Attic/lonManage between versions 1.7 and 1.19

version 1.7, 2003/08/18 09:56:01 version 1.19, 2003/11/03 10:18:13
Line 33 Line 33
 #   it is a command line tool.  The following command line syntax (usage)  #   it is a command line tool.  The following command line syntax (usage)
 #   is supported:  #   is supported:
 #  #
 #    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:
 #           hosts  (hosts.tab)  #           host  (hosts.tab)
 #           domain (domain.tab)  #           domain (domain.tab)
 #  #
 #    lonManage  -reinit lonc host  #    lonManage  -reinit lonc [host]
 #           Sends a HUP signal to the remote systems's lond.  #           Sends a HUP signal to the remote systems's lond.
 #  #
 #    lonmanage  -reinit lond host  #    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,  #    In the above syntax, the host above is the hosts.tab name of a host,
 #    not the IP address of the host.  #    not the IP address of the host
 #  #  
 #  $Log$  #   If [host] is not supplied, every host in the client's hosts.tab
 #  Revision 1.7  2003/08/18 09:56:01  foxr  #   table is iterated through and procesed..
 #  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:
   
   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 IO::Socket::UNIX; # To communicate with lonc.
   use LondConnection;
   
   # File scoped variables:
   
   my %perlvar; # Perl variable defs from apache config.
   my %hostshash; # Host table as a host indexed hash.
   
   my $MyHost=""; # Host name to use as me.
   my $ForeignHostTab=""; # Name of foreign hosts table.
   
   #
   #   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:
            hosts  (hosts.tab)             host  (hosts.tab)
            domain (domain.tab)             domain (domain.tab)
   
     lonManage  --reinit=lonc host   lonManage [--myname=host --hosts=table] --reinit=lonc [host]
            Sends a HUP signal to the remote systems's lond.         Causes lonc in the remote system to reread hosts.tab and
          adjust the set of clients that are being maintained to match
     lonManage  --reinit=lond host         the new file.
           Requests the remote system's lond perform the same action as if         
           it had received a HUP signal.  
    lonManage [--myname=host --hosts=table] --reinit=lond [host]
          Causes lond in the remote system to reread the hosts.tab file
          and adjust the set of servers to match changes in that file.
   
     In the above syntax, the host above is the hosts.tab name of a host,      In the above syntax, the host above is the hosts.tab name of a host,
     not the IP address of the host.      not the IP address of the host.
   
       If [host] is omitted, all hosts in the hosts.tab file are iterated
       over.
   
    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
   
   
 }  }
   #
   #   Lifted from lonnet.pm - and we need to figure out a way to get it back in.
   #   Performas a transaction with lond via the lonc proxy server.
   #   Parameter:
   #      cmd  - The text of the request.
   #      host - The host to which the request ultimately goes.
   #   Returns:
   #      The text of the reply from the lond or con_lost if not able to contact
   #      lond/lonc etc.
   #
   sub subreply {
       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>;
       if (!$answer) { $answer="con_lost"; }
       chomp($answer);
       return $answer;
   }
   #   >>> BUGBUG <<< 
 #  #
 #  Use Getopt::Long to parse the parameters of the program.  #  Use Getopt::Long to parse the parameters of the program.
 #  #
Line 121  USAGE Line 157  USAGE
 #   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 = '';
   
     if(!GetOptions('push=s'    => \$pushing,      if(!GetOptions('push=s'    => \$pushing,
            'reinit=s'  => \$reinitting)) {             'reinit=s'  => \$reinitting,
      'myname=s' => \$MyHost,
      'hosts=s' => \$ForeignHostTab)) {
    return ();
       }
       #  The --myname and --hosts switch must have values and
       #  most both appear if either appears:
   
       if(($MyHost ne "") && ($ForeignHostTab eq "")) {
    return ();
       }
       if(($ForeignHostTab ne "") && ($MyHost eq "")) {
  return ();   return ();
     }      }
   
Line 139  sub ParseArgs { Line 187  sub ParseArgs {
   
     if($pushing ne '') {      if($pushing ne '') {
   
         # --push takes in addition a table, and a host:          # --push takes in addition a table, and an optional  host:
         #          #
  if($paramcount != 2) {   if(($paramcount != 2) && ($paramcount != 1)) {
     return (); # Invalid parameter count.      return (); # Invalid parameter count.
  }   }
  if($command ne '') {   if($command ne '') {
Line 155  sub ParseArgs { Line 203  sub ParseArgs {
   
     if ($reinitting ne '') {      if ($reinitting ne '') {
   
  # --reinit takes in addition just a host name   # --reinit takes in addition just an optional  host name
   
  if($paramcount != 1) {   if($paramcount > 1) {
     return ();      return ();
  }   }
  if($command ne '') {   if($command ne '') {
Line 179  sub ParseArgs { Line 227  sub ParseArgs {
     return @result;      return @result;
 }  }
 #  #
   #  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 {
   
       if($ForeignHostTab eq "") {
    my $perlvarref = LondConnection::read_conf('loncapa.conf');
    %perlvar       = %{$perlvarref};
    my $hoststab   = LondConnection::read_hosts(
       "$perlvar{'lonTabDir'}/hosts.tab");
    %hostshash     = %{$hoststab};
       } else {
    my $hoststab   = LondConnection::read_hosts($ForeignHostTab);
    %hostshash     = %{$hoststab};
    $perlvar{londPort}   = 5663;
    $perlvar{lonSockDir} = "/home/httpd/sockets";
       }
   
   }
   #
   #  Determine if the target host is valid.
   #  This is done by reading the current hosts.tab file.
   #  For the host to be valid, it must be inthe file.
   #
   #  Parameters:
   #     host   - Name of host to check on.
   #  Returns:
   #     true   if host is valid.
   #     false  if host is invalid.
   #
   sub ValidHost {
       my $host       = shift;
      
   
       return defined $hostshash{$host};
   
   }
   
   
   
   #
   #  Performs a transaction with lonc.
   #  By the time this is called, the transaction has already been
   #  validated by the caller.
   #
   #   Parameters:
   #
   #   host    - hosts.tab name of the host whose lonc we'll be talking to.
   #   command - The base command we'll be asking lond to execute.
   #   body    - [optional] If supplied, this is a command body that is a ref.
   #             to an array of lines that will be appended to the 
   #             command.
   #
   #  NOTE:
   #    The command will be done as an encrypted operation.
   #
   sub Transact {
       my $host    = shift;
       my $command = shift;
       my $haveBody= 0;
       my $body;
       my $i;
   
       if(scalar @ARG) {
    $body = shift;
    $haveBody = 1;
       }
       #  Construct the command to send to the server:
       
       my $request = "encrypt\:"; # All requests are encrypted.
       $request   .= $command;
       if($haveBody) {
    $request .= "\:";
    my $bodylines = scalar @$body;
    for($i = 0; $i < $bodylines; $i++) {
       $request .= $$body[$i];
    }
       } else {
    $request .= "\n";
       }
       # Body is now built... transact with lond..
       
       my $answer = subreply($request, $host);
   
       print "$answer\n";
   
   }
   #
 #   Called to push a file to the remote system.  #   Called to push a file to the remote system.
 #   The only legal files to push are hosts.tab and domain.tab.  #   The only legal files to push are hosts.tab and domain.tab.
 #   Security is somewhat improved by  #   Security is somewhat improved by
Line 194  sub ParseArgs { Line 333  sub ParseArgs {
 #     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;
     my $tablefile = shift;      my $tablefile = shift;
     my $host      = shift;      my $host      = shift;
           
 }      # Open the table file:
   
       if(!open(TABLEFILE, "<$tablefile")) {
    die "ENOENT - No such file or directory $tablefile";
       }
     
       # Require that the host be valid:
   
       if(!ValidHost($host)) {
    die "EHOSTINVAL - Invalid host $host"; # Ok so I invented this 'errno'.
       }
       # Read in the file.  If the table name is valid, push it.
   
       my @table = <TABLEFILE>; #  These files are pretty small.
       close TABLEFILE;
   
       if( ($tablename eq "host")    ||
    ($tablename eq "domain")) {
    print("Pushing $tablename to $host\n");
    Transact($host, "pushfile:$tablename",\@table);
       } else {
    die "EINVAL - Invalid parameter. tablename: $tablename must be host or domain";
       }
   }
   #
   #   This function is called to reinitialize a server in a remote host.
   #   The servers that can be reinitialized are:
   #   - lonc   - The lonc client process.
   #   - lond   - The lond daemon.
   #  NOTE:
   #    Reinitialization in this case means re-scanning the hosts table,
   #    starting new lond/lonc's as approprate and stopping existing lonc/lond's.
   #
   #  Parameters:
   #     process - The name of the process to reinit (lonc or lond).
   #     host    - The host in which this reinit will happen.
   #
   #   >>>BUGBUG<<<< This belongs  in lonnet.pm
   #
 sub ReinitProcess {  sub ReinitProcess {
     print "Reinitializing a process\n";      my $process = shift;
       my $host    = shift;
   
       #  Ensure the host is valid:
       
       if(!ValidHost($host)) {
    die "EHOSTINVAL - Invalid host $host";
       }
       # Ensure target process selector is valid:
   
       if(($process eq "lonc") ||
          ($process eq "lond")) {
    print("Reinitializing $process in $host\n");
    Transact($host, "reinit:$process");
       } else {
    die "EINVAL -Invalid parameter. Process $process must be lonc or lond";
       }
 }  }
 #--------------------------- Entry point: --------------------------  #--------------------------- Entry point: --------------------------
   
   
   
 #  Parse the parameters  #  Parse the parameters
 #  If command parsing failed, then print usage:  #  If command parsing failed, then print usage:
   
Line 223  if ($EUID != 0) { Line 419  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 232  if($operation eq "push") {  # push table Line 433  if($operation eq "push") {  # push table
     my $tablename = shift @params;      my $tablename = shift @params;
     my $tablefile = shift @params;      my $tablefile = shift @params;
     my $host      = shift @params;      my $host      = shift @params;
     PushFile($tablename, $tablefile, $host);      if($host) {
    PushFile($tablename, $tablefile, $host);
       } else { # Push to whole cluster.
    foreach my $host (keys %hostshash) {
       PushFile($tablename, $tablefile, $host);
    }
       }
   
 } elsif($operation eq "reinit") { # reinit processname host.  } elsif($operation eq "reinit") { # reinit processname host.
     my $process   = shift @params;      my $process   = shift @params;
     my $host      = shift @params;      my $host      = shift @params;
     ReinitProcess($process, $host);      if ($host) {
 }   ReinitProcess($process, $host);
       } else { # Reinit whole cluster.
    foreach my $host (keys %hostshash) {
       ReinitProcess($process,$host);
    }
       }
   } 
 else {  else {
     Usage;      Usage;
 }  }
Line 275  Usage: Line 488  Usage:
 =item strict  =item strict
 =item Getopt::Long  =item Getopt::Long
 =item English  =item English
   =item IO::Socket::UNIX
   
   =head1 KEY Subroutines.
   
 =head1  CATEGORIES  =head1  CATEGORIES
     Command line utility      Command line utility
Removed from v.1.7  
changed lines
  Added in v.1.19

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