--- projects/cms/source/host/ihost-perl/ihost.pl	2001/01/29 16:51:50	1.9
+++ projects/cms/source/host/ihost-perl/ihost.pl	2001/03/12 23:20:43	1.25
@@ -2,14 +2,15 @@
 
 # -----------------------------------------------------------
 # Perl i-scream Host.
+# http://www.i-scream.org.uk
 #
 # An all-in-one script to act as an i-scream host on
 # a typical Unix/Linux box.  You may adapt the data-gathering
 # methods as you see fit.
 #  - pjm2@ukc.ac.uk
 #
-# $Author: pjm2 $
-# $Id: ihost.pl,v 1.9 2001/01/29 16:51:50 pjm2 Exp $
+# $Author: tdb $
+# $Id: ihost.pl,v 1.25 2001/03/12 23:20:43 tdb Exp $
 #------------------------------------------------------------
 
 $| = 1;
@@ -31,6 +32,8 @@ use vars qw (
              $tcp_port
              $filter_addr
              $file_list
+             $fqdn
+             $pidfile
             );
 
 if (@ARGV != 2) {
@@ -42,6 +45,10 @@ $filter_manager_port = $ARGV[1];
 
 $seq_no = 1;
 
+# write our PID to a file
+$pidfile = "ihost.pid";
+&write_pid();
+
 &tcp_configure();
 &send_udp_packet();
 
@@ -69,19 +76,32 @@ while (1) {
     `sleep $delay`;
 }
 
+# we'll probably never get here...
+`rm -f $pidfile`;
 exit(0);
 
+
+#-----------------------------------------------------------------------
+# tcp_configure
+# Establishes a TCP connection to the specified i-scream filter manager.
+# The host then requests details from the server, such as the intervals
+# at which to send UDP packets.
+#-----------------------------------------------------------------------
 sub tcp_configure() {
     
     my($sock) = new IO::Socket::INET(
                                      PeerAddr => $filter_manager_addr,
                                      PeerPort => $filter_manager_port,
                                      Proto => 'tcp'
-                                    ) or die "Could not perform configuration via TCP: $!\n";
+                                    ) or die "Cannot connect!";
+    if (!defined $sock) {
+        print "IHOST ERROR: Could not connect to $filter_manager_addr:$filter_manager_port.\n";
+        print "Please check that there is an i-scream server at this address.\n";
+        print "Program ended.\n";
+        exit(1);
+    }
 
-    die "Could not connect to the i-scream filter manager: $!\n" unless $sock;
-
-    # Now run through the configuration process.
+    # Now run through the configuration process...
     my($response);
     
     print $sock "STARTCONFIG\n";
@@ -107,6 +127,13 @@ sub tcp_configure() {
 
     print "File list obtained: $file_list\n";
 
+    print $sock "FQDN\n";
+    $response = <$sock>;
+    chop $response;
+    $fqdn = $response;
+
+    print "FQDN returned: $fqdn\n";
+
     print $sock "UDPUpdateTime\n";
     $response = <$sock>;
     chop $response;
@@ -131,9 +158,17 @@ sub tcp_configure() {
     
     print $sock "FILTER\n";
     $response = <$sock>;
+    unless (defined($response)) {
+        print "Failed: Could not get a filter address from the filter manager.\n";
+        exit(1);
+    }
     chop $response;
     $response =~ /(.*);(.*);(.*)/;
     ($filter_addr, $udp_port, $tcp_port) = ($1, $2, $3);
+    unless (defined($filter_addr) && defined($udp_port) && defined($tcp_port)) {
+        print "Failed: Filter address response from server did not make sense: $response\n";
+        exit(1);
+    }
     
     print "Got filter data ($filter_addr, $udp_port, $tcp_port)\n";
 
@@ -151,13 +186,24 @@ sub tcp_configure() {
     close($sock);
 
     print "Configuration finished sucessfully!\n";
+    
+    return;
 }
 
+
+
+
+#-----------------------------------------------------------------------
+# send_udp_packet
+# Sends a UDP packet to an i-scream filter.
+# The packet contains XML markup describing some of the machine's state.
+# Receipt of UDP packets is not guaranteed.
+#-----------------------------------------------------------------------
 sub send_udp_packet() {
 
     my(@statgrab) = `./statgrab.pl`;
     my(%packet);
-    for (my($i) = 0; $i < $#statgrab; $i++) {
+    for (my($i) = 0; $i <= $#statgrab; $i++) {
         $statgrab[$i] =~ /^([^\s]*) (.*)$/;
         $packet{$1} = $2;
     }
@@ -167,29 +213,26 @@ sub send_udp_packet() {
     my($disk_info) = "<disk>";
     my($i) = 0;
     while (defined $packet{"packet.disk.p$i.attributes.mount"}) {
-        $disk_info .= "<p$i>";
-        $disk_info .= qq/<name>$packet{"packet.disk.p$i.attributes.name"}<\/name>/;
-        $disk_info .= qq/<kbytes>$packet{"packet.disk.p$i.attributes.kbytes"}<\/kbytes>/;
-        $disk_info .= qq/<used>$packet{"packet.disk.p$i.attributes.used"}<\/used>/;
-        $disk_info .= qq/<avail>$packet{"packet.disk.p$i.attributes.avail"}<\/avail>/;
-        $disk_info .= qq/<mount>$packet{"packet.disk.p$i.attributes.mount"}<\/mount>/;
-        $disk_info .= "</p$i>";
+        $disk_info .= "<p$i";
+        $disk_info .= " name=\"" . $packet{"packet.disk.p$i.attributes.name"} . "\"";
+        $disk_info .= " kbytes=\"" . $packet{"packet.disk.p$i.attributes.kbytes"} . "\"";
+        $disk_info .= " used=\"" . $packet{"packet.disk.p$i.attributes.used"} . "\"";
+        $disk_info .= " avail=\"" . $packet{"packet.disk.p$i.attributes.avail"} . "\"";
+        $disk_info .= " mount=\"" . $packet{"packet.disk.p$i.attributes.mount"} . "\"";
+        $disk_info .= "></p$i>";
         ++$i;
     }
     $disk_info .= "</disk>";
 
-    my($hostname) = hostname();
-    $hostname =~ s/\..*$//g;
-    `cat /etc/resolv.conf` =~ /domain\s+([^\s]+)/;
-    my($domainname) = $1;
-    my($machine_name) = "$hostname.$domainname";
-    my($ip) = inet_ntoa(scalar(gethostbyname($hostname)) || 'localhost');
+    my($ip) = inet_ntoa(scalar(gethostbyname(hostname())) || 'localhost');
 
     # Build the XML packet this way, as we can clearly
     # see the structure and contents... I like this ;-)
+    # [Note that the server rejects UDP packets that are
+    # larger than 8196 bytes]
     my($xml) = <<EOF;
     
-<packet seq_no="$seq_no" machine_name="$machine_name" date="$date" type="data" ip="$ip">
+<packet seq_no="$seq_no" machine_name="$fqdn" date="$date" type="data" ip="$ip">
     <load>
         <load1>$packet{"packet.load.load1"}</load1>
         <load5>$packet{"packet.load.load5"}</load5>
@@ -201,6 +244,7 @@ sub send_udp_packet() {
         <platform>$packet{"packet.os.platform"}</platform>
         <sysname>$packet{"packet.os.sysname"}</sysname>
         <version>$packet{"packet.os.version"}</version>
+        <uptime>$packet{"packet.os.uptime"}</uptime>
     </os>
     <users>
         <count>$packet{"packet.users.count"}</count>
@@ -221,47 +265,61 @@ sub send_udp_packet() {
         <swap>$packet{"packet.cpu.swap"}</swap>
     </cpu>
     <memory>
-        <total>$packet{"packet.memory.real"}</total>
+        <total>$packet{"packet.memory.total"}</total>
         <free>$packet{"packet.memory.free"}</free>
     </memory>
     <swap>
-        <total>$packet{"packet.memory.swap_total"}</total>
-        <free>$packet{"packet.memory.swap_free"}</free>
+        <total>$packet{"packet.swap.total"}</total>
+        <free>$packet{"packet.swap.free"}</free>
     </swap>
     $disk_info
 </packet>
 
 EOF
 
+    # Make the packet smaller by stripping out newlines and leading spaces.
     $xml =~ s/\n\s*//g;
-    
+
     my($sock) = new IO::Socket::INET (
                                       PeerPort => $udp_port,
                                       PeerAddr => $filter_addr,
                                       Proto => 'udp'
-                                     ) or die "Socket: $!\n";
+                                     ) or die "Could not send UDP: $!\n";
 
     print $sock $xml or die "Could not send UDP packet: $!\n";
     close($sock);
     $seq_no++;
     print "-";
+    
+    return;
 }
 
+
+
+
+#-----------------------------------------------------------------------
+# send_tcp_heartbeat
+# Establishes a TCP connection to an i-scream filter.
+# The heartbeat is used as a guaranteed "I'm alive" delivery mechanism.
+#-----------------------------------------------------------------------
 sub send_tcp_heartbeat() {
 
     my($sock) = new IO::Socket::INET(
                                      PeerAddr => $filter_addr,
                                      PeerPort => $tcp_port,
                                      Proto => 'tcp'
-                                    ) or die "Could not perform heartbeat via TCP: $!\n";
+                                    ) or return;
+    if (!defined $sock) {
+        print "IHOST WARNING: Failed to deliver a heartbeat to the i-scream filter.\n";
+        return;
+    }
 
-    die "Could not connect to the i-scream filter: $!\n" unless $sock;
-
     # Now run through the configuration process.
     my($response);
 
     print $sock "HEARTBEAT\n";
     $response = <$sock>;
+    return if (!defined $response);
     chop $response;
     if (!$response eq "OK") {
         close($sock);
@@ -271,6 +329,7 @@ sub send_tcp_heartbeat() {
     
     print $sock "CONFIG\n";
     $response = <$sock>;
+    return if (!defined $response);
     chop $response;
     if (!$response eq "OK") {
         close($sock);
@@ -280,6 +339,7 @@ sub send_tcp_heartbeat() {
 
     print $sock "$file_list\n";
     $response = <$sock>;
+    return if (!defined $response);
     chop $response;
     if (!$response eq "OK") {
         close($sock);
@@ -289,6 +349,7 @@ sub send_tcp_heartbeat() {
     
     print $sock "$last_modified\n";
     $response = <$sock>;
+    return if (!defined $response);
     chop $response;
     if ($response eq "ERROR") {
         close($sock);
@@ -303,6 +364,7 @@ sub send_tcp_heartbeat() {
     
     print $sock "ENDHEARTBEAT\n";
     $response = <$sock>;
+    return if (!defined $response);
     chop $response;
     if (!$response eq "OK") {
         close($sock);
@@ -312,4 +374,19 @@ sub send_tcp_heartbeat() {
     
     close($sock);
     print "^";
+    
+    return;
+}
+
+#-----------------------------------------------------------------------
+# write_pid
+# Writes the PID (process ID) of this instance to $pidfile.
+# This is then used by a seperate script to check (and restart) ihost.
+#-----------------------------------------------------------------------
+sub write_pid() {
+    open PID, ">$pidfile";
+    print PID $$;
+    close PID;
+    
+    return;
 }