You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@vcl.apache.org by jf...@apache.org on 2008/12/12 19:20:18 UTC
svn commit: r726079 [8/32] - in /incubator/vcl/tags/import: ./
managementnode/ managementnode/bin/ managementnode/etc/
managementnode/etc/vcl/ managementnode/legacy_vcl_vbs_scripts/
managementnode/lib/ managementnode/lib/VCL/ managementnode/lib/VCL/Mod...
Added: incubator/vcl/tags/import/managementnode/lib/VCL/Module/Provisioning/xCAT.pm
URL: http://svn.apache.org/viewvc/incubator/vcl/tags/import/managementnode/lib/VCL/Module/Provisioning/xCAT.pm?rev=726079&view=auto
==============================================================================
--- incubator/vcl/tags/import/managementnode/lib/VCL/Module/Provisioning/xCAT.pm (added)
+++ incubator/vcl/tags/import/managementnode/lib/VCL/Module/Provisioning/xCAT.pm Fri Dec 12 10:20:10 2008
@@ -0,0 +1,2830 @@
+#!/usr/bin/perl -w
+
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements. See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License. You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+##############################################################################
+# $Id: xCAT.pm 1953 2008-12-12 14:23:17Z arkurth $
+##############################################################################
+
+=head1 NAME
+
+VCL::Provisioning::xCAT - VCL module to support the xCAT provisioning engine
+
+=head1 SYNOPSIS
+
+ Needs to be written
+
+=head1 DESCRIPTION
+
+ This module provides VCL support for xCAT (Extreme Cluster Administration
+ Toolkit). xCAT is a scalable distributed computing management and
+ provisioning tool that provides a unified interface for hardware control,
+ discovery, and OS diskful/diskfree deployment.
+ http://xcat.sourceforge.net
+
+=cut
+
+##############################################################################
+package VCL::Module::Provisioning::xCAT;
+
+# Specify the lib path using FindBin
+use FindBin;
+use lib "$FindBin::Bin/../../..";
+
+# Configure inheritance
+use base qw(VCL::Module::Provisioning);
+
+# Specify the version of this module
+our $VERSION = '2.00';
+
+# Specify the version of Perl to use
+use 5.008000;
+
+use strict;
+use warnings;
+use diagnostics;
+
+use VCL::utils;
+use Fcntl qw(:DEFAULT :flock);
+use File::Copy;
+
+##############################################################################
+
+=head1 CLASS ATTRIBUTES
+
+=cut
+
+=head2 $XCAT_ROOT
+
+ Data type : scalar
+ Description : $XCAT_ROOT stores the location of the xCAT binary files. xCAT
+ should set the XCATROOT environment variable. This is used if
+ it is set. If XCATROOT is not set, /opt/xcat is used.
+
+=cut
+
+# Class attributes to store xCAT configuration details
+my $XCAT_ROOT;
+
+##############################################################################
+
+=head1 OBJECT METHODS
+
+=cut
+
+#/////////////////////////////////////////////////////////////////////////////
+
+=head2 initialize
+
+ Parameters :
+ Returns :
+ Description :
+
+=cut
+
+sub initialize {
+ my $self = shift;
+
+ # Check the XCAT_ROOT environment variable, it should be defined
+ if (defined($ENV{XCATROOT}) && $ENV{XCATROOT}) {
+ $XCAT_ROOT = $ENV{XCATROOT};
+ }
+ elsif (defined($ENV{XCATROOT})) {
+ notify($ERRORS{'WARNING'}, 0, "XCATROOT environment variable is not defined, using /opt/xcat");
+ $XCAT_ROOT = '/opt/xcat';
+ }
+ else {
+ notify($ERRORS{'WARNING'}, 0, "XCATROOT environment variable is not set, using /opt/xcat");
+ $XCAT_ROOT = '/opt/xcat';
+ }
+
+ # Remove trailing / from $XCAT_ROOT if exists
+ $XCAT_ROOT =~ s/\/$//;
+
+ # Make sure the xCAT root path is valid
+ if (!-d $XCAT_ROOT) {
+ notify($ERRORS{'WARNING'}, 0, "unable to initialize xCAT module, $XCAT_ROOT directory does not exist");
+ return 0;
+ }
+
+ # Check to make sure one of the expected executables is where it should be
+ if (!-x "$XCAT_ROOT/bin/rpower") {
+ notify($ERRORS{'WARNING'}, 0, "unable to initialize xCAT module, expected executable was not found: $XCAT_ROOT/bin/rpower");
+ return 0;
+ }
+ notify($ERRORS{'DEBUG'}, 0, "xCAT root path found: $XCAT_ROOT");
+
+ notify($ERRORS{'DEBUG'}, 0, "xCAT module initialized");
+ return 1;
+} ## end sub initialize
+
+#/////////////////////////////////////////////////////////////////////////////
+
+=head2 load
+
+ Parameters : hash
+ Returns : 1(success) or 0(failure)
+ Description : loads node with provided image
+
+=cut
+
+sub load {
+ my $self = shift;
+ if (ref($self) !~ /xCAT/i) {
+ notify($ERRORS{'CRITICAL'}, 0, "subroutine was called as a function, it must be called as a class method");
+ return 0;
+ }
+
+ # Get the data
+ my $reservation_id = $self->data->get_reservation_id();
+ my $image_name = $self->data->get_image_name();
+ my $image_os_name = $self->data->get_image_os_name();
+ my $image_project = $self->data->get_image_project();
+ my $image_reload_time = $self->data->get_image_reload_time();
+ my $imagemeta_postoption = $self->data->get_imagemeta_postoption();
+ my $image_architecture = $self->data->get_image_architecture();
+ my $computer_id = $self->data->get_computer_id();
+ my $computer_node_name = $self->data->get_computer_node_name();
+ my $computer_ip_address = $self->data->get_computer_ip_address();
+
+ notify($ERRORS{'OK'}, 0, "nodename not set")
+ if (!defined($computer_node_name));
+ notify($ERRORS{'OK'}, 0, "imagename not set")
+ if (!defined($image_name));
+ notify($ERRORS{'OK'}, 0, "project not set")
+ if (!defined($image_project));
+ notify($ERRORS{'OK'}, 0, "estimated reload time not set")
+ if (!defined($image_reload_time));
+ notify($ERRORS{'OK'}, 0, "osname not set")
+ if (!defined($image_os_name));
+ notify($ERRORS{'OK'}, 0, "computerid not set")
+ if (!defined($computer_id));
+ notify($ERRORS{'OK'}, 0, "reservationid not set")
+ if (!defined($reservation_id));
+ notify($ERRORS{'OK'}, 0, "architecture not set")
+ if (!defined($image_architecture));
+
+ # Initialize some timer variables
+ # Do this here in case goto passes over the declaration
+ my $sshd_start_time;
+ my $sshd_end_time;
+
+ insertloadlog($reservation_id, $computer_id, "startload", "$computer_node_name $image_name");
+
+ #make sure the following services are running on management node
+ # dhcpd named xcatd
+ # start them if they are not actively running
+ $image_project = "vcl" if (!defined($image_project));
+
+ $image_architecture = "x86" if (!defined($image_architecture));
+
+ # Run xCAT's assign2project utility
+ if (_assign2project($computer_node_name, $image_project)) {
+ notify($ERRORS{'OK'}, 0, "$computer_node_name _assign2project return successful");
+ }
+ else {
+ notify($ERRORS{'CRITICAL'}, 0, "$computer_node_name could not _assign2project to $image_project");
+ return 0;
+ }
+
+ # Make sure dhcpd is started on management node
+ if (!(_checknstartservice("dhcpd"))) {
+ notify($ERRORS{'CRITICAL'}, 0, "dhcpd is not running or failed to restart");
+ }
+
+ # Make sure named is started on management node
+ if (!(_checknstartservice("named"))) {
+ notify($ERRORS{'CRITICAL'}, 0, "named is not running or failed to restart");
+ }
+
+ # Make sure xcatd is started on management node
+ if (!(_checknstartservice("xcatd"))) {
+ notify($ERRORS{'CRITICAL'}, 0, "xcatd is not running or failed to restart");
+ }
+
+ # Make sure atftpd is started on management node
+ if (!(_checknstartservice("atftpd"))) {
+ notify($ERRORS{'CRITICAL'}, 0, "atftpd is not running or failed to restart");
+ }
+
+ # Insert a computerloadlog record and edit nodetype.tab
+ insertloadlog($reservation_id, $computer_id, "editnodetype", "updating nodetype file");
+ if ($self->_edit_nodetype($computer_node_name, $image_name, $image_os_name, $image_architecture)) {
+ notify($ERRORS{'OK'}, 0, "nodetype updated for $computer_node_name with $image_name");
+ }
+ else {
+ notify($ERRORS{'CRITICAL'}, 0, "could not edit nodetype for $computer_node_name with $image_name");
+ }
+
+ # Begin reinstallation using xCAT's rinstall
+ # Loop and continue checking
+
+ # Set flags and counters
+ my $rinstall_attempts = 0;
+ my $rpower_fixes = 0;
+ my $bootstatus = 0;
+ my $wait_loops = 0;
+ my @status;
+
+ # Check to see if management node throttle is configured
+ if ($THROTTLE) {
+ notify($ERRORS{'DEBUG'}, 0, "throttle is set to $THROTTLE");
+
+ my $lckloadfile = "/tmp/nodeloading.lockfile";
+ notify($ERRORS{'DEBUG'}, 0, "attempting to open node loading lockfile for throttling: $lckloadfile");
+ if (sysopen(SEM, $lckloadfile, O_RDONLY | O_CREAT)) {
+ notify($ERRORS{'DEBUG'}, 0, "opened lockfile, attempting to obtain lock");
+
+ if (flock(SEM, LOCK_EX)) {
+ notify($ERRORS{'DEBUG'}, 0, "obtained exclusive lock on $lckloadfile, checking for concurrent loads");
+ my $maxload = 1;
+ while ($maxload) {
+ notify($ERRORS{'DEBUG'}, 0, "running 'nodeset all stat' to determine number of nodes currently being loaded");
+ if (open(NODESET, "$XCAT_ROOT/bin/nodeset all stat \| grep install 2>&1 | ")) {
+ my @nodesetout = <NODESET>;
+ close(NODESET);
+ my $ld = @nodesetout;
+ notify($ERRORS{'DEBUG'}, 0, "current number of nodes loading: $ld");
+
+ if ($ld < $THROTTLE) {
+ notify($ERRORS{'OK'}, 0, "current nodes loading is less than throttle, ok to proceed");
+ $maxload = 0;
+ }
+ else {
+ notify($ERRORS{'OK'}, 0, "current nodes loading=$ld, throttle=$THROTTLE, must wait, sleeping for 10 seconds");
+ sleep 10;
+ }
+ } ## end if (open(NODESET, "$XCAT_ROOT/bin/nodeset all stat \| grep install 2>&1 | "...
+ else {
+ notify($ERRORS{'WARNING'}, 0, "failed to run 'nodeset all stat' to determine number of nodes currently being loaded");
+ }
+ } ## end while ($maxload)
+ } ## end if (flock(SEM, LOCK_EX))
+ else {
+ notify($ERRORS{'WARNING'}, 0, "failed to obtain exclusive lock on $lckloadfile");
+ }
+
+ notify($ERRORS{'OK'}, 0, "releasing exclusive lock on $lckloadfile, proceeding to install");
+ close(SEM);
+
+ } ## end if (sysopen(SEM, $lckloadfile, O_RDONLY | ...
+ else {
+ notify($ERRORS{'WARNING'}, 0, "failed to open node loading lockfile");
+ }
+
+ } ## end if ($THROTTLE)
+ else {
+ notify($ERRORS{'DEBUG'}, 0, "throttle is NOT set");
+ }
+
+ XCATRINSTALL:
+
+ # Reset sshd wait start time, used only for diagnostic purposes
+ $sshd_start_time = 0;
+
+ # Make use of semaphore files to control the flow
+ # xCAT's rinstall does not handle locking of files
+ my $lckfile = "/tmp/rinstall.lockfile";
+ notify($ERRORS{'DEBUG'}, 0, "attempting to open rinstall lockfile: $lckfile");
+ if (sysopen(SEM, $lckfile, O_RDONLY | O_CREAT)) {
+ notify($ERRORS{'DEBUG'}, 0, "opened lockfile, attempting to obtain lock");
+
+ if (flock(SEM, LOCK_EX)) {
+ notify($ERRORS{'DEBUG'}, 0, "obtained exclusive lock on $lckfile");
+
+ # Safe to run rinstall command
+ insertloadlog($reservation_id, $computer_id, "rinstall", "starting install process");
+ notify($ERRORS{'OK'}, 0, "executing rinstall $computer_node_name");
+ if (open(RINSTALL, "$XCAT_ROOT/bin/rinstall $computer_node_name 2>&1 |")) {
+ $rinstall_attempts++;
+ notify($ERRORS{'OK'}, 0, "beginning rinstall attempt $rinstall_attempts");
+ while (<RINSTALL>) {
+ chomp($_);
+
+ #notify($ERRORS{'OK'},0,"$_");
+ if ($_ =~ /not in bay/) {
+ notify($ERRORS{'WARNING'}, 0, "rpower not in bay issue, will attempt to correct, calling rinv");
+ if (_fix_rpower($computer_node_name)) {
+
+ #try xcatrinstall again
+ close(RINSTALL);
+ close(SEM); # remove lock
+ # loop control
+ if ($rpower_fixes < 10) {
+ $rpower_fixes++;
+ sleep 1;
+ goto XCATRINSTALL;
+ }
+ else {
+ notify($ERRORS{'CRITCAL'}, 0, "rpower failed $rpower_fixes times on $computer_node_name");
+ return 0;
+ }
+ } ## end if (_fix_rpower($computer_node_name))
+ } ## end if ($_ =~ /not in bay/)
+ if ($_ =~ /Invalid login|does not exist/) {
+ notify($ERRORS{'CRITCAL'}, 0, "failed to initate rinstall on $computer_node_name - $_");
+ close(RINSTALL);
+ close(SEM);
+ insertloadlog($reservation_id, $computer_id, "failed", "failed to start load process on $computer_node_name");
+ return 0;
+ }
+
+ } #while RINSTALL
+ close(RINSTALL);
+
+ notify($ERRORS{'OK'}, 0, "releasing exclusive lock on $lckfile");
+ close(SEM);
+ } ## end if (open(RINSTALL, "$XCAT_ROOT/bin/rinstall $computer_node_name 2>&1 |"...
+ else {
+ notify($ERRORS{'CRITICAL'}, 0, "could not execute $XCAT_ROOT/bin/rinstall $computer_node_name $!");
+ close(SEM);
+ return 0;
+ }
+ } ## end if (flock(SEM, LOCK_EX))
+ else {
+ notify($ERRORS{'WARNING'}, 0, "failed to obtain exclusive lock on $lckfile, error: $!, returning");
+ return;
+ }
+ } ## end if (sysopen(SEM, $lckfile, O_RDONLY | O_CREAT...
+ else {
+ notify($ERRORS{'WARNING'}, 0, "failed to open node loading lockfile, error: $!, returning");
+ return;
+ }
+
+# Check progress, locate MAC and IP address for this node, monitor /var/log/messages for communication from node
+# dhcp req/ack, xcat calls, etc
+ my ($eth0MACaddress, $privateIP);
+ if (open(MACTAB, "$XCAT_ROOT/etc/mac.tab")) {
+ my @mactab = <MACTAB>;
+ close(MACTAB);
+ foreach my $line (@mactab) {
+ if ($line =~ /(^$computer_node_name(-eth[0-9])?)(\s+)([:0-9a-f]*)/) {
+ $eth0MACaddress = $4;
+ notify($ERRORS{'OK'}, 0, "MAC address for $computer_node_name collected $eth0MACaddress");
+ }
+ }
+ } ## end if (open(MACTAB, "$XCAT_ROOT/etc/mac.tab"))
+ if (!defined($eth0MACaddress)) {
+ notify($ERRORS{'WARNING'}, 0, "MAC address not found for $computer_node_name , possible issue with regex");
+ }
+
+ #should also store/pull private address from the database
+ if (open(HOSTS, "/etc/hosts")) {
+ my @hosts = <HOSTS>;
+ close(HOSTS);
+ foreach my $line (@hosts) {
+ if ($line =~ /([0-9]*.[0-9]*.[0-9]*.[0-9]*)\s+($computer_node_name)/) {
+ $privateIP = $1;
+ notify($ERRORS{'OK'}, 0, "PrivateIP address for $computer_node_name collected $privateIP");
+ last;
+ }
+ }
+ } ## end if (open(HOSTS, "/etc/hosts"))
+ if (!defined($privateIP)) {
+ notify($ERRORS{'WARNING'}, 0, "private IP address not found for $computer_node_name, possible issue with regex");
+ }
+ my ($s1, $s2, $s3, $s4, $s5) = 0;
+ my $sloop = 0;
+
+ #insertloadlog($reservation_id,$computer_id,"info","SUCCESS initiated install process");
+ #sleep for boot process to happen takes anywhere from 60-90 seconds
+ notify($ERRORS{'OK'}, 0, "sleeping 65 to allow bootstrap of $computer_node_name");
+ sleep 65;
+ my @TAILLOG;
+ my $t;
+
+ if ($eth0MACaddress && $privateIP) {
+ @TAILLOG = 0;
+ $t = 0;
+ if (open(TAIL, "</var/log/messages")) {
+ seek TAIL, -1, 2; #
+ for (;;) {
+ notify($ERRORS{'OK'}, 0, "$computer_node_name ROUND 1 checks loop $sloop of 45");
+ while (<TAIL>) {
+ if (!$s1) {
+ if ($_ =~ /dhcpd: DHCPDISCOVER from $eth0MACaddress/) {
+ $s1 = 1;
+ notify($ERRORS{'OK'}, 0, "$computer_node_name STAGE 1 set DHCPDISCOVER from $eth0MACaddress");
+ insertloadlog($reservation_id, $computer_id, "xcatstage1", "SUCCESS stage1 detected dhcp request for node");
+ }
+ }
+ if (!$s2) {
+ if ($_ =~ /dhcpd: DHCPACK on $privateIP to $eth0MACaddress/) {
+ $s2 = 1;
+ notify($ERRORS{'OK'}, 0, "$computer_node_name STAGE 2 set DHCPACK on $privateIP to $eth0MACaddress");
+ insertloadlog($reservation_id, $computer_id, "xcatstage2", "SUCCESS stage2 detected dhcp ack for node");
+ }
+ }
+ if (!$s3) {
+ if ($_ =~ /Serving \/tftpboot\/pxelinux.0 to $privateIP:/) {
+ $s3 = 1;
+ chomp($_);
+ notify($ERRORS{'OK'}, 0, "$computer_node_name STAGE 3 set $_");
+ insertloadlog($reservation_id, $computer_id, "xcatstage3", "SUCCESS stage3 node received pxe");
+ }
+ }
+ if (!$s4) {
+ if ($_ =~ /Serving \/tftpboot\/xcat\/(rhfc|linux_image|image|rhas.)\/x86\/install.gz to $privateIP:/) {
+ $s4 = 1;
+ chomp($_);
+ notify($ERRORS{'OK'}, 0, "$computer_node_name STAGE 4 set $_");
+ insertloadlog($reservation_id, $computer_id, "xcatstage4", "SUCCESS stage4 node received pxe install instructions");
+ }
+ }
+
+ #stage5 is where images and rhas(KS) are different
+ if (!$s5) {
+
+ #here we look for rpc.mountd
+ if ($_ =~ /authenticated mount request from $computer_node_name:(\d+) for/) {
+ $s5 = 1;
+ chomp($_);
+ notify($ERRORS{'OK'}, 0, "$computer_node_name STAGE 5 set $_");
+ insertloadlog($reservation_id, $computer_id, "xcatstage5", "SUCCESS stage5 node started installing via partimage");
+ }
+
+ #in case we miss the above statement
+ if ($image_os_name =~ /^(rhel|rhfc|fc|esx)/) {
+ if ($_ =~ /xcat: xcatd: $computer_node_name installing/) {
+ $s5 = 1;
+ chomp($_);
+ notify($ERRORS{'OK'}, 0, "$computer_node_name STAGE 5 set $_");
+ insertloadlog($reservation_id, $computer_id, "xcatstage5", "SUCCESS stage5 node started installing via kickstart");
+ }
+ }
+ } ## end if (!$s5)
+ } #while
+ #either stages are set or we loop or we rinstall again
+ #check s5 and counter for loop control
+ if ($s5) {
+ notify($ERRORS{'OK'}, 0, "$computer_node_name ROUND1 stages are set proceeding to next round");
+ close(TAIL);
+ goto ROUND2;
+ }
+ elsif ($sloop > 45) {
+ insertloadlog($reservation_id, $computer_id, "WARNING", "potential problem started $rinstall_attempts install attempt");
+
+ #hrmm this is taking too long
+ #have we been here before? if less than 3 attempts continue on the 3rd try fail
+ #whats the problem, chck known locations
+ # /tftpboot/xcat/image/x86
+ # look for tmpl file (in does_image_exist routine)
+ # does the machine need to reboot, premission to reboot issue
+ if (_check_pxe_grub_files($image_name)) {
+ notify($ERRORS{'OK'}, 0, "checkpxe_grub_file checked");
+ }
+
+ if ($rinstall_attempts < 3) {
+ close(TAIL);
+ insertloadlog($reservation_id, $computer_id, "repeat", "starting install process");
+ goto XCATRINSTALL;
+ }
+ else {
+
+ #fail this one and let whoever called me get another machine
+ notify($ERRORS{'CRITICAL'}, 0, "rinstall made $rinstall_attempts in ROUND1 on $computer_node_name with no success, admin needs to check it out");
+ insertloadlog($reservation_id, $computer_id, "failed", "FAILED problem made $rinstall_attempts install attempts failing reservation");
+ if (_nodeset_option($computer_node_name, "boot")) {
+ notify($ERRORS{'OK'}, 0, "due to failure reseting state of blade to boot");
+ }
+ close(TAIL);
+ return 0;
+ } ## end else [ if ($rinstall_attempts < 3)
+ } ## end elsif ($sloop > 45) [ if ($s5)
+ else {
+
+ #keep checking the messages log
+ $sloop++;
+ sleep 7;
+ seek TAIL, 0, 1;
+ }
+ } #for loop
+ } #if Tail
+ else {
+ notify($ERRORS{'CRITICAL'}, 0, "could open /var/log/messages to $!");
+ }
+ } ## end if ($eth0MACaddress && $privateIP)
+ else {
+ notify($ERRORS{'CRITICAL'}, 0, "eth0MACaddress $eth0MACaddress && privateIP $privateIP are not set not able to use these checks");
+ insertloadlog($reservation_id, $computer_id, "failed", "FAILED could not locate private IP and MAC addresses in XCAT files failing reservation");
+ return 0;
+ }
+
+ ROUND2:
+
+ #begin second round of checks reset $sX
+ ($s1, $s2, $s3, $s4, $s5) = 0;
+ $sloop = 0;
+
+ # start time for loading
+ my $R2starttime = convert_to_epoch_seconds();
+
+ #during loading we need to wait based on some precentage of the estimated reload time (50%?)
+ #times range from 4-10 minutes perhaps longer for a large image
+ my $TM2waittime = int($image_reload_time / 2);
+ insertloadlog($reservation_id, $computer_id, "xcatround2", "starting ROUND2 checks - waiting for boot flag");
+
+ notify($ERRORS{'OK'}, 0, "Round 2 TM2waittime set to $TM2waittime on $computer_node_name");
+ if (open(TAIL, "</var/log/messages")) {
+ seek TAIL, -1, 2;
+ my $gettingclose = 0;
+ for (;;) {
+ notify($ERRORS{'OK'}, 0, "$computer_node_name round2 log checks 30sec loop count is $sloop of $image_reload_time TM2waittime= $TM2waittime");
+ while (<TAIL>) {
+ if (!$s1) {
+ if ($_ =~ /xcat: xcatd: set boot request from $computer_node_name/) {
+
+ insertloadlog($reservation_id, $computer_id, "bootstate", "node in boot state completed imaging process - proceeding to next round");
+ $s1 = 1;
+ notify($ERRORS{'OK'}, 0, "Round 2 STAGE 1 set $computer_node_name in boot state");
+ }
+
+ #is it even near completion only checking rhel installs
+ #not really useful for linux_images
+ if ($image_os_name =~ /^(rhel|rhfc|fc|esx)/) {
+ if (!$gettingclose) {
+ if ($_ =~ /rpc.mountd: authenticated mount request from $computer_node_name:(\d+) for \/install\/post/) {
+ $gettingclose = 1;
+ notify($ERRORS{'OK'}, 0, "Round 2 STAGE 1 install nearing completion on node $computer_node_name");
+ }
+ }
+ else {
+ if (!$s4) {
+ if ($sloop == $image_reload_time) {
+ notify($ERRORS{'OK'}, 0, "$computer_node_name Round 2 getting close, loop eq $image_reload_time, substracting 6 from loop count");
+ $sloop = ($sloop - 8);
+ $s4 = 1; #loop control, don't set this we loop forever
+ notify($ERRORS{'WARNING'}, 0, "ert estimated reload time may be too low\n $computer_node_name\nimagename $image_name\n current ert = $image_reload_time");
+ }
+ }
+ } ## end else [ if (!$gettingclose)
+ } ## end if ($image_os_name =~ /^(rhel|rhfc|fc|esx)/)
+ } ## end if (!$s1)
+ } #while
+ if ($s1) {
+
+ #good, move on
+ close(TAIL);
+ goto ROUND3;
+ }
+ else {
+ if ($sloop > $image_reload_time) {
+ notify($ERRORS{'OK'}, 0, "exceeded TM2waittime of $TM2waittime minutes sloop= $sloop ert= $image_reload_time");
+
+ # check delta from when we started actual loading till now
+ my $rtime = convert_to_epoch_seconds();
+ my $delta = $rtime - $R2starttime;
+ if ($delta < ($image_reload_time * 60)) {
+
+ #ok delta is actually less then ert, we don't need to stop it yet.
+ notify($ERRORS{'OK'}, 0, "loading delta is less than ert, not stopping yet delta is $delta/60 ");
+ sleep 35;
+ $sloop = ($sloop - 8); #decrement loop control
+ seek TAIL, 0, 1;
+
+ }
+ elsif ($rinstall_attempts < 2) {
+ notify($ERRORS{'WARNING'}, 0, "starting rinstall again");
+ insertloadlog($reservation_id, $computer_id, "WARNING", "potential problem restarting rinstall current attemp $rinstall_attempts");
+ close(TAIL);
+ insertloadlog($reservation_id, $computer_id, "repeat", "starting install process");
+ goto XCATRINSTALL;
+ }
+ else {
+
+ #fail this one and let whoever called me get another machine
+ notify($ERRORS{'CRITICAL'}, 0, "rinstall made $rinstall_attempts in ROUND2 on $computer_node_name with no success, admin needs to check it out");
+ insertloadlog($reservation_id, $computer_id, "failed", "rinstall made $rinstall_attempts failing request");
+ close(TAIL);
+ return 0;
+ }
+ } ## end if ($sloop > $image_reload_time)
+ else {
+ sleep 35;
+ $sloop++; #loop control
+ insertloadlog($reservation_id, $computer_id, "info", "node in load process waiting for signal");
+ seek TAIL, 0, 1;
+
+ #goto TAILMESSAGES2;
+ }
+ } ## end else [ if ($s1)
+ } #for
+ } ## end if (open(TAIL, "</var/log/messages"))
+ else {
+ notify($ERRORS{'CRITICAL'}, 0, "could open /var/log/messages to $!");
+ return 0;
+ }
+
+ ROUND3:
+
+ my $nodeset_status;
+
+ # Round 3 checks, machine has been installed we wait here for boot process which could include sysprep
+ # we are checking for the boot state in the OS status
+ insertloadlog($reservation_id, $computer_id, "xcatround3", "starting round 3 checks - finishing post configuration");
+ $wait_loops = 0;
+ while (!$bootstatus) {
+ my $nodeset_status = _nodeset($computer_node_name);
+
+ if ($nodeset_status =~ /boot/) {
+ $bootstatus = 1;
+ notify($ERRORS{'OK'}, 0, "$computer_node_name has been reinstalled with $image_name");
+ notify($ERRORS{'OK'}, 0, "xcat has set the boot flag");
+ if ($image_os_name =~ /win|wxp|2003/) {
+ notify($ERRORS{'OK'}, 0, "waiting 3 minutes to allow OS to reboot and initialize machine");
+ sleep 180;
+ }
+
+ #elsif($osname =~ /^(rhel|rh3image|fc|rhfc|rh4image)/){
+ elsif ($image_os_name =~ /^(rh[0-9]image|rhel[0-9]|fc[0-9]image|rhfc[0-9]|rhas[0-9]|esx[0-9]+)/) {
+ notify($ERRORS{'OK'}, 0, "waiting 65 sec to allow OS to reboot and initialize machine");
+ sleep 65;
+ }
+ else {
+ notify($ERRORS{'OK'}, 0, "waiting 3 minutes to allow OS to reboot and initialize machine");
+ sleep 180;
+ }
+ my ($readycount, $ready) = 0;
+ READYFLAG:
+
+ #check /var/log/messages file for READY
+
+ if (open(TAIL, "</var/log/messages")) {
+ seek TAIL, -1, 2;
+ for (;;) {
+ notify($ERRORS{'OK'}, 0, "$computer_node_name checking for READY FLAG loop count is $readycount of 10");
+ while (<TAIL>) {
+ if ($_ =~ /READY|ready|Starting firstboot: succeeded/) {
+ $ready = 1 if ($_ =~ /$computer_node_name/);
+ }
+ if ($image_os_name =~ /^(rh|fc|esx)/) {
+ if ($_ =~ /$computer_node_name|$computer_node_name kernel/) {
+ notify($ERRORS{'OK'}, 0, "$computer_node_name booting up");
+ sleep 5;
+ $ready = 1;
+ close(TAIL);
+ goto SSHDATTEMPT;
+ }
+ }
+ } #while
+
+ if ($readycount > 10) {
+ notify($ERRORS{'OK'}, 0, "taking longer than expected, readycount==$readycount moving to next set of checks");
+ $ready = 1;
+ close(TAIL);
+ goto SSHDATTEMPT;
+ }
+ if ($readycount > 2) {
+
+ #check ssh status just in case we missed the flag
+ my $sshd = _sshd_status($computer_node_name, $image_name);
+ if ($sshd eq "on") {
+ $ready = 1;
+ notify($ERRORS{'OK'}, 0, "we may have missed start flag going next stage");
+ close(TAIL);
+ goto SSHDATTEMPT;
+ }
+ } ## end if ($readycount > 2)
+ if (!$ready) {
+ notify($ERRORS{'OK'}, 0, "$computer_node_name not ready yet, sleeping for 40 seconds");
+ sleep 40;
+ seek TAIL, 0, 1;
+ }
+ else {
+ notify($ERRORS{'OK'}, 0, "/var/log/messages reports $computer_node_name is ready");
+ insertloadlog($reservation_id, $computer_id, "xcatREADY", "detected ready signal from node - proceeding");
+ close(TAIL);
+ goto SSHDATTEMPT;
+ }
+
+ #placing out side of if statements for loop control
+ $readycount++;
+ } #for
+ } ## end if (open(TAIL, "</var/log/messages"))
+ else {
+ notify($ERRORS{'CRITICAL'}, 0, "could not open messages at READYFLAG $!");
+ }
+ notify($ERRORS{'OK'}, 0, "proceeding for sync sshd active");
+ } ## end if ($nodeset_status =~ /boot/)
+ else {
+
+ # check for strange states
+
+ }
+ } ## end while (!$bootstatus)
+
+ # we need to wait for sshd to become active
+ my $sshd_attempts = 0;
+ SSHDATTEMPT:
+ my $sshdstatus = 0;
+ $wait_loops = 0;
+ $sshd_attempts++;
+ my $sshd_status = "off";
+
+ # Set the sshd start time to now if it hasn't been set already
+ # This is used to report how long sshd took to become active
+ $sshd_start_time = time() if !$sshd_start_time;
+
+ while (!$sshdstatus) {
+ my $sshd_status = _sshd_status($computer_node_name, $image_name);
+ if ($sshd_status eq "on") {
+
+ # Set the sshd end time to now to capture how long it took sshd to become active
+ $sshd_end_time = time();
+ my $sshd_duration = $sshd_end_time - $sshd_start_time;
+
+ $sshdstatus = 1;
+ notify($ERRORS{'OK'}, 0, "$computer_node_name sshd has become active, took $sshd_duration secs, ok to proceed to sync ssh keys");
+ insertloadlog($reservation_id, $computer_id, "info", "synchronizing keys");
+ } ## end if ($sshd_status eq "on")
+ else {
+
+ #either sshd is off or N/A, we wait
+ if ($wait_loops >= 7) {
+ if ($sshd_attempts < 3) {
+ goto SSHDATTEMPT;
+ }
+ else {
+
+ # Waited long enough for sshd to become active
+
+ # Set the sshd end time to now to capture how long process waited for sshd to become active
+ $sshd_end_time = time();
+ my $sshd_duration = $sshd_end_time - $sshd_start_time;
+
+ notify($ERRORS{'WARNING'}, 0, "$computer_node_name waited acceptable amount of time for sshd to become active, $sshd_duration secs");
+
+ #need to check power, maybe reboot it. for now fail it
+ #try to reinstall it once
+ if ($rinstall_attempts < 2) {
+ notify($ERRORS{'WARNING'}, 0, "$computer_node_name starting rinstall again");
+ insertloadlog($reservation_id, $computer_id, "repeat", "starting install process");
+ close(TAIL);
+ goto XCATRINSTALL;
+ }
+ else {
+ notify($ERRORS{'CRITICAL'}, 0, "$computer_node_name: sshd never became active after 2 rinstall attempts");
+ insertloadlog($reservation_id, $computer_id, "failed", "exceeded maximum install attempts");
+ return 0;
+ }
+ } ## end else [ if ($sshd_attempts < 3)
+ } ## end if ($wait_loops >= 7)
+ else {
+ $wait_loops++;
+
+ # to give post config a chance
+ notify($ERRORS{'OK'}, 0, "going to sleep 15 seconds, waiting for post config to finish");
+ sleep 15;
+ }
+ } # else
+ } #while
+
+ # Clear ssh public keys from /root/.ssh/known_hosts
+ my $known_hosts = "/root/.ssh/known_hosts";
+ my @file;
+ if (open(FILE, $known_hosts)) {
+ @file = <FILE>;
+ close FILE;
+
+ foreach my $line (@file) {
+ if ($line =~ s/$computer_node_name.*\n//) {
+ notify($ERRORS{'OK'}, 0, "removing $computer_node_name ssh public key from $known_hosts");
+ }
+ }
+
+ if (open(FILE, ">$known_hosts")) {
+ print FILE @file;
+ close FILE;
+ }
+ } ## end if (open(FILE, $known_hosts))
+ else {
+ notify($ERRORS{'OK'}, 0, "could not open $known_hosts for editing the $computer_node_name public ssh key");
+ }
+
+ # Synchronize ssh keys using xCAT's makesshgkh
+ my $makessygkh_attempts = 0;
+ MAKESSH:
+ notify($ERRORS{'OK'}, 0, " resting 1sec before executing makesshgkh");
+ sleep 1;
+ if (open(MAKESSHGKH, "$XCAT_ROOT/sbin/makesshgkh $computer_node_name |")) {
+ $makessygkh_attempts++;
+ notify($ERRORS{'OK'}, 0, " makesshgkh attempt $makessygkh_attempts ");
+ while (<MAKESSHGKH>) {
+ chomp($_);
+ if ($_ =~ /Scanning keys/) {
+ notify($ERRORS{'OK'}, 0, "$_");
+ }
+ }
+ close MAKESSHGKH;
+ my $keysync = 0;
+ my $keysynccheck = 0;
+
+ while (!$keysync) {
+ $keysynccheck++;
+ my $sshd = _sshd_status($computer_node_name, $image_name);
+ if ($sshd =~ /on/) {
+ $keysync = 1;
+ notify($ERRORS{'OK'}, 0, "keys synced");
+ insertloadlog($reservation_id, $computer_id, "info", "SUCCESS keys synchronized");
+ last;
+ }
+ if ($keysynccheck > 3) {
+ if ($makessygkh_attempts < 1) {
+ notify($ERRORS{'OK'}, 0, "keysynccheck exceeded 5 minutes, there might be a problem running makesshgkh again");
+ goto MAKESSH;
+ }
+ else {
+ notify($ERRORS{'WARNING'}, 0, "makesshgkh exceeded 2 attempts to create new ssh keys there appears to be a problem with $computer_node_name moving on");
+
+ #move on-
+ $keysync = 1;
+ last;
+ }
+ } ## end if ($keysynccheck > 3)
+ notify($ERRORS{'OK'}, 0, "waiting for ssh keys to be updated");
+ sleep 5;
+ } ## end while (!$keysync)
+ } ## end if (open(MAKESSHGKH, "$XCAT_ROOT/sbin/makesshgkh $computer_node_name |"...
+ else {
+ notify($ERRORS{'CRITICAL'}, 0, "could not execute $XCAT_ROOT/sbin/makesshgkh $computer_node_name $!");
+ }
+
+ # Perform post load tasks
+
+ # Windows specific routines
+ if ($image_os_name =~ /winxp|wxp|win2003/) {
+
+ insertloadlog($reservation_id, $computer_id, "info", "randomizing system level passwords");
+
+ #change passwords for root and administrator account
+ #skip changing root password for imageprep loads
+ if (changewindowspasswd($computer_node_name, "root")) {
+ notify($ERRORS{'OK'}, 0, "Successfully changed password, account $computer_node_name,root");
+ }
+
+ if (changewindowspasswd($computer_node_name, "administrator")) {
+ notify($ERRORS{'OK'}, 0, "Successfully changed password, account $computer_node_name,administrator");
+ }
+
+ #disable remote desktop port
+ if (remotedesktopport($computer_node_name, "DISABLE")) {
+ notify($ERRORS{'OK'}, 0, "remote desktop disabled on $computer_node_name");
+ }
+ else {
+ notify($ERRORS{'OK'}, 0, "remote desktop not disable on $computer_node_name");
+ }
+
+ #due to sysprep sshd is set to manual start
+ if (_set_sshd_startmode($computer_node_name, "auto")) {
+ notify($ERRORS{'OK'}, 0, "successfully set sshd service on $computer_node_name to start auto");
+ }
+ else {
+ notify($ERRORS{'WARNING'}, 0, "failed to set sshd service on $computer_node_name to start auto");
+ }
+
+ #check for root logged in on console and then logoff
+ notify($ERRORS{'OK'}, 0, "checking for any console users $computer_node_name");
+
+ my @QA = run_ssh_command($computer_node_name, $IDENTITY_wxp, "cmd /c qwinsta.exe", "root");
+ foreach my $r (@{$QA[1]}) {
+ if ($r =~ /([>]?)([-a-zA-Z0-9]*)\s+([a-zA-Z0-9]*)\s+ ([0-9]*)\s+([a-zA-Z]*)/) {
+ my $state = $5;
+ my $session = $2;
+ my $user = $3;
+ if ($5 =~ /Active/) {
+ notify($ERRORS{'OK'}, 0, "detected $user on $session still logged on $computer_node_name $r, sleeping 7 before logging off");
+ sleep 7;
+ my @LF = run_ssh_command($computer_node_name, $IDENTITY_wxp, "cmd /c logoff.exe $session");
+ foreach my $l (@{$LF[1]}) {
+ notify($ERRORS{'OK'}, 0, "output from attempt to logoff $user on $session");
+ }
+
+ }
+ } ## end if ($r =~ /([>]?)([-a-zA-Z0-9]*)\s+([a-zA-Z0-9]*)\s+ ([0-9]*)\s+([a-zA-Z]*)/)
+ } ## end foreach my $r (@{$QA[1]})
+
+ #reboot the box based on options
+ if ($imagemeta_postoption =~ /reboot/i) {
+ my $rebooted = 1;
+ my $reboot_wait_count = 0;
+ my @retarray;
+ while ($rebooted) {
+ if ($reboot_wait_count > 55) {
+ notify($ERRORS{'CRITICAL'}, 0, "waited $reboot_wait_count on reboot after auto_create_image on $computer_node_name");
+ $retarray[1] = "waited $reboot_wait_count on reboot after netdom on $computer_node_name";
+ return @retarray;
+ }
+ notify($ERRORS{'OK'}, 0, "$computer_node_name not completed reboot sleeping for 25");
+ sleep 25;
+ if (_pping($computer_node_name)) {
+
+ #it pingable check if sshd is open
+ notify($ERRORS{'OK'}, 0, "$computer_node_name is pingable, checking sshd port");
+ my $sshd = _sshd_status($computer_node_name, $image_name);
+ if ($sshd =~ /on/) {
+ $rebooted = 0;
+ notify($ERRORS{'OK'}, 0, "$computer_node_name sshd is open");
+ }
+ else {
+ notify($ERRORS{'OK'}, 0, "$computer_node_name sshd NOT open yet,sleep 5");
+ sleep 5;
+ }
+ } #_pping
+ $reboot_wait_count++;
+
+ } #while
+ } #reboot
+
+#win2003 only - need to set private adapter to static without a gateway
+# win2003 and probably vista zero out one gateway and we only need a gateway on the public adapter
+# so we need to remove the one on the private side
+# downside - we need to reset it to dhcp before making an image.....
+
+ if ($image_os_name =~ /^(win2003)/) {
+ insertloadlog($reservation_id, $computer_id, "info", "detected OS which requires network gateway modification");
+ notify($ERRORS{'OK'}, 0, "detected win2003 OS, proceeding to change private adapter to static from dhcp on $computer_node_name");
+ my %ip;
+ my $myadapter;
+ my @ipconfig = run_ssh_command($computer_node_name, $IDENTITY_wxp, "ipconfig -all", "root");
+
+ # build hash of needed info and set the correct private adapter.
+ foreach my $a (@{$ipconfig[1]}) {
+ $myadapter = $1 if ($a =~ /Ethernet adapter (.*):/);
+ $ip{$myadapter}{"private"} = 1
+ if ($a =~ /IP Address([\s.]*): $privateIP/);
+ $ip{$myadapter}{"subnetmask"} = $2
+ if ($a =~ /Subnet Mask([\s.]*): ([.0-9]*)/);
+ }
+
+ my $privateadapter;
+ my $subnetmask;
+
+ foreach my $key (keys %ip) {
+ if (defined($ip{$key}{private})) {
+ if ($ip{$key}{private}) {
+ $privateadapter = "\"$key\"";
+ $subnetmask = $ip{$key}{subnetmask};
+ }
+ }
+ }
+
+ notify($ERRORS{'OK'}, 0, "attempted to convert private adapter on $computer_node_name to static with no gateway");
+
+ #not using run_ssh_command here
+ if (open(NETSH, "/usr/bin/ssh -x -i $IDENTITY_wxp $computer_node_name \"netsh interface ip set address name=\\\"$privateadapter\\\" source=static addr=$privateIP mask=$subnetmask\" & 2>&1 |")) {
+
+ #losing connection
+ my $go = 1;
+ while ($go) {
+
+ #print "hi\n";
+ sleep 4;
+ if (open(PS, "ps -ef |")) {
+ my @ps = <PS>;
+ close(PS);
+ sleep 4;
+ foreach my $p (@ps) {
+ if ($p =~ /$computer_node_name netsh interface/) {
+ if ($p =~ /(root)\s+([0-9]*)/) {
+ if (open(KILLIT, "kill -9 $2 |")) {
+ close(KILLIT);
+ close(NETSH);
+ notify($ERRORS{'OK'}, 0, "killing ssh $computer_node_name netsh process");
+ }
+ }
+ }
+ } ## end foreach my $p (@ps)
+ } ## end if (open(PS, "ps -ef |"))
+
+ $go = 0;
+ } ## end while ($go)
+ } ## end if (open(NETSH, "/usr/bin/ssh -x -i $IDENTITY_wxp $computer_node_name \"netsh interface ip set address name=\\\"$privateadapter\\\" source=static addr=$privateIP mask=$subnetmask\" & 2>&1 |"...
+
+ #make sure it came back
+ if (_sshd_status($computer_node_name, $image_name)) {
+ notify($ERRORS{'OK'}, 0, "successful $computer_node_name is accessible after static assignment");
+ insertloadlog($reservation_id, $computer_id, "info", "SUCCESS network gateway modification successful");
+ }
+ else {
+
+ }
+
+ #disable NetBios
+ notify($ERRORS{'OK'}, 0, "attempted to convert private adapter on $computer_node_name to static with no gateway");
+ my $path1 = "$TOOLS/disablenetbios.vbs";
+ my $path2 = "$computer_node_name:disablenetbios.vbs";
+ if (run_scp_command($path1, $path2, $IDENTITY_wxp)) {
+ notify($ERRORS{'DEBUG'}, 0, "copied $path1 to $path2");
+ my @DNBIOS = run_ssh_command($computer_node_name, $IDENTITY_wxp, "cscript.exe //Nologo disablenetbios.vbs", "root");
+ foreach my $l (@{$DNBIOS[1]}) {
+ if ($l =~ /denied|socket/) {
+ notify($ERRORS{'WARNING'}, 0, "failed to disablenetbios.vbs @{ $DNBIOS[1] }");
+ }
+ }
+
+ } ## end if (run_scp_command($path1, $path2, $IDENTITY_wxp...
+ else {
+ notify($ERRORS{'WARNING'}, 0, "run_scp_command failed to copy $path1 to $path2");
+ }
+
+ } ## end if ($image_os_name =~ /^(win2003)/)
+ } ## end if ($image_os_name =~ /winxp|wxp|win2003/)
+
+ # Linux post-load tasks
+ elsif ($image_os_name =~ /^(rh[0-9]image|rhel[0-9]|fc[0-9]image|rhfc[0-9]|rhas[0-9]|esx[0-9]+)/) {
+
+ #linux specfic routines
+ #FIXME move to generic post options on per image basis
+ if ($image_os_name =~ /^(esx[0-9]*)/) {
+
+ #esx specific post
+ my $cmdstring = "/usr/sbin/esxcfg-vswitch -a vSwitch1;/usr/sbin/esxcfg-vswitch -L vmnic1 vSwitch1;/usr/sbin/esxcfg-vswitch -A \"Virtual Machine Public Network\" vSwitch1";
+
+ my @sshd = run_ssh_command($computer_node_name, $IDENTITY_bladerhel, $cmdstring, "root");
+ foreach my $l (@{$sshd[1]}) {
+
+ #any response is a potential problem
+ notify($ERRORS{'DEBUG'}, 0, "esxcfg-vswitch output: $l");
+ }
+
+ #restart mgmt-vmware
+ sleep(8); # sleep briefly before attemping to restart
+ # restart needs to include "&" for some reason it doesn't return but completes - dunno?
+ @sshd = run_ssh_command($computer_node_name, $IDENTITY_bladerhel, "/etc/init.d/mgmt-vmware restart &", "root");
+ foreach my $l (@sshd) {
+ if ($l =~ /failed/i) {
+ notify($ERRORS{'WARNING'}, 0, "failed to restart mgmt-vmware @sshd");
+ return 0;
+ }
+ }
+ } ## end if ($image_os_name =~ /^(esx[0-9]*)/)
+ #FIXME - could be an issue for esx servers
+ if (changelinuxpassword($computer_node_name, "root")) {
+ notify($ERRORS{'OK'}, 0, "successfully changed root password on $computer_node_name");
+
+#insertloadlog($reservation_id, $computer_id, "info", "SUCCESS randomized roots password");
+ }
+ else {
+ notify($ERRORS{'OK'}, 0, "failed to edit root password on $computer_node_name");
+ }
+
+ #disable ext_sshd
+ my @stopsshd = run_ssh_command($computer_node_name, $IDENTITY_bladerhel, "/etc/init.d/ext_sshd stop", "root");
+ foreach my $l (@{$stopsshd[1]}) {
+ if ($l =~ /Stopping ext_sshd/) {
+ notify($ERRORS{'OK'}, 0, "ext sshd stopped on $computer_node_name");
+ last;
+ }
+ }
+
+ #if an image, clear wtmp and krb token files
+ # FIXME - move to createimage
+ if ($image_os_name =~ /^(rh[0-9]image|rhel[0-9]|fc[0-9]image|rhfc[0-9]|rhas[0-9]|esx[0-9]+)/) {
+ my @cleartmp = run_ssh_command($computer_node_name, $IDENTITY_bladerhel, "/usr/sbin/tmpwatch -f 0 /tmp; /bin/cp /dev/null /var/log/wtmp", "root");
+ foreach my $l (@{$cleartmp[1]}) {
+ notify($ERRORS{'DEBUG'}, 0, "output from cleartmp post load $computer_node_name $l");
+ }
+ }
+
+ # clear external_sshd file of any AllowUsers string
+ my $path1 = "$computer_node_name:/etc/ssh/external_sshd_config";
+ my $path2 = "/tmp/$computer_node_name.sshd";
+ if (run_scp_command($path1, $path2, $IDENTITY_bladerhel)) {
+ notify($ERRORS{'DEBUG'}, 0, "scp success retrieved $path1");
+ }
+ else {
+ notify($ERRORS{'WARNING'}, 0, "failed to retrieve $path1");
+ }
+ #remove from sshd
+ if (open(SSHDCFG, "/tmp/$computer_node_name.sshd")) {
+ @file = <SSHDCFG>;
+ close SSHDCFG;
+ foreach my $l (@file) {
+ $l = "" if ($l =~ /AllowUsers/);
+ }
+ if (open(SCP, ">/tmp/$computer_node_name.sshd")) {
+ print SCP @file;
+ close SCP;
+ }
+ undef $path1;
+ undef $path2;
+ $path1 = "/tmp/$computer_node_name.sshd";
+ $path2 = "$computer_node_name:/etc/ssh/external_sshd_config";
+ if (run_scp_command($path1, $path2, $IDENTITY_bladerhel)) {
+ notify($ERRORS{'DEBUG'}, 0, "scp success copied $path1 to $path2");
+ unlink $path1;
+ }
+ else {
+ notify($ERRORS{'WARNING'}, 0, "failed to copy $path1 to $path2");
+ }
+ } ## end if (open(SSHDCFG, "/tmp/$computer_node_name.sshd"...
+
+
+ } ## end elsif ($image_os_name =~ /^(rh[0-9]image|rhel[0-9]|fc[0-9]image|rhfc[0-9]|rhas[0-9]|esx[0-9]+)/) [ if ($image_os_name =~ /winxp|wxp|win2003/)
+
+ # IP configuration
+ if ($IPCONFIGURATION ne "manualDHCP") {
+ insertloadlog($reservation_id, $computer_id, "info", "detected change required in IP address configuration on node");
+
+ #not default setting
+ if ($IPCONFIGURATION eq "dynamicDHCP") {
+ my $assignedIPaddress = getdynamicaddress($computer_node_name, $image_os_name);
+ if ($assignedIPaddress) {
+
+ #update computer table
+ if (update_computer_address($computer_id, $assignedIPaddress)) {
+ notify($ERRORS{'OK'}, 0, "dynamic address collected $assignedIPaddress -- updated computer table");
+ insertloadlog($reservation_id, $computer_id, "dynamicDHCPaddress", "SUCCESS collected dynamicDHCP address");
+ }
+ else {
+ notify($ERRORS{'OK'}, 0, "failed to update dynamic address $assignedIPaddress for$computer_id $computer_node_name ");
+ insertloadlog($reservation_id, $computer_id, "dynamicDHCPaddress", "FAILED to update dynamicDHCP address failing reservation");
+ return 0;
+ }
+ } ## end if ($assignedIPaddress)
+ else {
+ notify($ERRORS{'CRITICAL'}, 0, "could not fetch dynamic address from $computer_node_name $image_name");
+ insertloadlog($reservation_id, $computer_id, "dynamicDHCPaddress", "FAILED to collected dynamicDHCP address failing reservation");
+ return 0;
+ }
+ } ## end if ($IPCONFIGURATION eq "dynamicDHCP")
+ elsif ($IPCONFIGURATION eq "static") {
+ insertloadlog($reservation_id, $computer_id, "info", "setting staticIPaddress");
+
+ if (setstaticaddress($computer_node_name, $image_os_name, $computer_ip_address)) {
+ notify($ERRORS{'DEBUG'}, 0, "set static address on $computer_ip_address $computer_node_name ");
+ insertloadlog($reservation_id, $computer_id, "staticIPaddress", "SUCCESS set static IP address on public interface");
+ }
+ else {
+ insertloadlog($reservation_id, $computer_id, "staticIPaddress", "failed to set static IP address on public interface");
+ return 0;
+ }
+ } ## end elsif ($IPCONFIGURATION eq "static") [ if ($IPCONFIGURATION eq "dynamicDHCP")
+ } ## end if ($IPCONFIGURATION ne "manualDHCP")
+
+ return 1;
+} ## end sub load
+
+#/////////////////////////////////////////////////////////////////////////////
+
+=head2 capture_prepare
+
+ Parameters :
+ Returns : 1 if sucessful, 0 if failed
+ Description :
+
+=cut
+
+sub capture_prepare {
+ my $self = shift;
+ if (ref($self) !~ /xCAT/i) {
+ notify($ERRORS{'CRITICAL'}, 0, "subroutine was called as a function, it must be called as a class method");
+ return 0;
+ }
+
+ # Get data
+ my $image_name = $self->data->get_image_name();
+ my $computer_short_name = $self->data->get_computer_short_name();
+ my $computer_node_name = $self->data->get_computer_node_name();
+
+ # Print some preliminary information
+ notify($ERRORS{'OK'}, 0, "image=$image_name, computer=$computer_short_name");
+
+ # Modify currentimage.txt
+ if (write_currentimage_txt($self->data)) {
+ notify($ERRORS{'OK'}, 0, "currentimage.txt updated on $computer_short_name");
+ }
+ else {
+ notify($ERRORS{'WARNING'}, 0, "unable to update currentimage.txt on $computer_short_name");
+ }
+
+ if ($self->_edit_nodetype($computer_node_name, $image_name)) {
+ notify($ERRORS{'OK'}, 0, "nodetype modified, node $computer_node_name, image name $image_name");
+ } # Close if _edit_nodetype
+ else {
+ notify($ERRORS{'CRITICAL'}, 0, "could not edit nodetype, node $computer_node_name, image name $image_name");
+ return 0;
+ } # Close _edit_nodetype failed
+
+ my @Images;
+ my ($i, $imagefile);
+
+ # Get the image repository path
+ my $image_repository_path = $self->_get_image_repository_path();
+ if (!$image_repository_path) {
+ notify($ERRORS{'CRITICAL'}, 0, "xCAT image repository information could not be determined");
+ return 0;
+ }
+
+ # Get the image template repository path
+ my $tmpl_repository_path = $self->_get_image_template_path();
+ if (!$tmpl_repository_path) {
+ notify($ERRORS{'CRITICAL'}, 0, "xCAT template repository information could not be determined");
+ return 0;
+ }
+
+ # Get the image template repository path
+ my $basetmpl = $self->_get_base_template_filename();
+ if (!$basetmpl) {
+ notify($ERRORS{'CRITICAL'}, 0, "xCAT template repository information could not be determined");
+ return 0;
+ }
+
+ notify($ERRORS{'OK'}, 0, "attempting to create $tmpl_repository_path/$image_name.tmpl");
+ if (open(IMAGE, "/bin/cp $tmpl_repository_path/$basetmpl $tmpl_repository_path/$image_name.tmpl |")) {
+ @Images = <IMAGE>;
+ close(IMAGE);
+ foreach $i (@Images) {
+
+ #if anything could mean failure
+ if ($i) {
+ notify($ERRORS{'OK'}, 0, "@Images");
+ }
+ }
+ } # Close if open handle for cp tmpl file command
+
+ #check to see if the new image file is there
+ if (open(IMAGES, "/bin/ls -1 $tmpl_repository_path |")) {
+ @Images = <IMAGES>;
+ close(IMAGES);
+ ($i, $imagefile) = 0;
+ foreach $i (@Images) {
+ if ($i =~ /$image_name.tmpl/) {
+ $imagefile = 1;
+ }
+ }
+ if ($imagefile) {
+ notify($ERRORS{'OK'}, 0, "$tmpl_repository_path/$image_name created");
+ }
+ else {
+ notify($ERRORS{'CRITICAL'}, 0, " $tmpl_repository_path/$image_name NOT created");
+ return 0;
+ }
+ } # Close if tmpl file exists
+ else {
+ notify($ERRORS{'CRITICAL'}, 0, "could not execute /bin/ls -1 $tmpl_repository_path $! ");
+ return 0;
+ } # Close tmpl file does not exist
+
+ # Call xCAT's nodeset, configure xCAT to save image on next reboot
+ if (_nodeset_option($computer_node_name, "image")) {
+ notify($ERRORS{'OK'}, 0, "$computer_node_name set to image state");
+ }
+ else {
+ notify($ERRORS{'CRITICAL'}, 0, "failed $computer_node_name set to image state");
+ return 0;
+ }
+
+ notify($ERRORS{'OK'}, 0, "returning 1");
+ return 1;
+} ## end sub capture_prepare
+
+#/////////////////////////////////////////////////////////////////////////////
+
+=head2 capture_monitor
+
+ Parameters :
+ Returns :
+ Description :
+
+=cut
+
+sub capture_monitor {
+ my $self = shift;
+ if (ref($self) !~ /xCAT/i) {
+ notify($ERRORS{'CRITICAL'}, 0, "subroutine was called as a function, it must be called as a class method");
+ return 0;
+ }
+
+ # Get the required data
+ my $computer_node_name = $self->data->get_computer_node_name();
+ my $image_name = $self->data->get_image_name();
+
+ # Get the image repository path
+ my $image_repository_path = $self->_get_image_repository_path();
+ if (!$image_repository_path) {
+ notify($ERRORS{'CRITICAL'}, 0, "xCAT image repository information could not be determined");
+ return 0;
+ }
+
+ # Wait for node to reboot
+ notify($ERRORS{'OK'}, 0, "sleeping for 120 seconds before beginning to monitor image copy process");
+ sleep 120;
+
+ # Set variables to control how may attempts are made to wait for capture to finish
+ my $capture_loop_attempts = 80;
+ my $capture_loop_wait = 30;
+
+ # Figure out and print how long will wait before timing out
+ my $maximum_wait_minutes = ($capture_loop_attempts * $capture_loop_wait) / 60;
+ notify($ERRORS{'OK'}, 0, "beginning to wait for image capture to complete, maximum wait time: $maximum_wait_minutes minutes");
+
+ my $image_size = 0;
+ my $nodeset_status;
+ CAPTURE_LOOP: for (my $capture_loop_count = 0; $capture_loop_count < $capture_loop_attempts; $capture_loop_count++) {
+ notify($ERRORS{'OK'}, 0, "attempt $capture_loop_count/$capture_loop_attempts: image copy not complete, sleeping for $capture_loop_wait seconds");
+ sleep $capture_loop_wait;
+
+ # Get the nodeset status for the node being captured
+ $nodeset_status = _nodeset_option($computer_node_name, "stat");
+ notify($ERRORS{'DEBUG'}, 0, "nodeset status for $computer_node_name: $nodeset_status");
+
+ # nodeset stat will return 'boot' when image capture (Partimage) is complete
+ if ($nodeset_status eq "boot") {
+ last CAPTURE_LOOP;
+ }
+
+ # Check the image size to see if it's growing
+ notify($ERRORS{'OK'}, 0, "checking size of $image_name");
+ my $current_image_size = $self->get_image_size($image_name);
+
+ # Check if image size is larger than the last time it was checked
+ if ($current_image_size > $image_size) {
+ notify($ERRORS{'OK'}, 0, "image size has increased: $image_size -> $current_image_size, still copying");
+ $image_size = $current_image_size;
+ }
+ else {
+ notify($ERRORS{'OK'}, 0, "image size is the same: $image_size=$current_image_size, copy may be complete");
+ }
+ } ## end for (my $capture_loop_count = 0; $capture_loop_count...
+
+ # Exiting waiting loop, nodeset status should be boot if successful
+ if ($nodeset_status eq "boot") {
+ # Nodeset 'boot' flag has been set, image copy process is complete
+ notify($ERRORS{'OK'}, 0, "image copy complete, nodeset status was set to 'boot' for $computer_node_name");
+ }
+ else {
+ notify($ERRORS{'WARNING'}, 0, "image copy timed out, waited $maximum_wait_minutes minutes, nodeset status for $computer_node_name never changed to boot: $nodeset_status");
+ return 0;
+ }
+
+ # Create mbr and sfdisk files
+ if (open(LS, "/bin/ls -1s $image_repository_path |")) {
+ my @LS = <LS>;
+ close(LS);
+ foreach my $l (@LS) {
+ if ($l =~ /$image_name-hda/) {
+
+ #create hda.mbr and hda.sfdisk
+ if (open(CP, "/bin/cp $image_repository_path/$image_name-hda.mbr $image_repository_path/$image_name-sda.mbr |")) {
+ close(CP);
+ notify($ERRORS{'OK'}, 0, "copied $image_name-hda.mbr to $image_repository_path/$image_name-sda.mbr");
+
+ #create sfdisk modify hardrive type
+ if (open(CP, "/bin/cp $image_repository_path/$image_name-hda.sfdisk $image_repository_path/$image_name-sda.sfdisk |")) {
+ close(CP);
+ notify($ERRORS{'OK'}, 0, "copied $image_name-hda.sfdisk to $image_repository_path/$image_name-sda.sfdisk");
+
+ #read in file
+ if (open(FILE, "$image_repository_path/$image_name-sda.sfdisk")) {
+ my @lines = <FILE>;
+ close(FILE);
+ foreach my $l (@lines) {
+ if ($l =~ s/hda/sda/g) {
+
+ #editing file
+ }
+ }
+
+ #print array to file
+ if (open(OUTFILE, ">$image_repository_path/$image_name-sda.sfdisk")) {
+ print OUTFILE @lines;
+ close(OUTFILE);
+ notify($ERRORS{'OK'}, 0, "modified drivetype of $image_name-sda.sfdisk");
+ }
+ } ## end if (open(FILE, "$image_repository_path/$image_name-sda.sfdisk"...
+ else {
+ notify($ERRORS{'CRITICAL'}, 0, "could not open $image_repository_path/$image_name-sda.mbr for editing $!");
+ }
+ } # Close if copy hda.sfdisk command
+ else {
+ notify($ERRORS{'CRITICAL'}, 0, "could not copy $image_name-hda.sfdisk to $image_repository_path/$image_name-sda.sfdisk $!");
+ }
+ } # Close if copy mbr file command
+ else {
+ notify($ERRORS{'CRITICAL'}, 0, "could not copy $image_name-hda.mbr to $image_repository_path/$image_name-sda.mbr $!");
+ }
+ } # Close if imagename-hda
+
+ elsif ($l =~ /$image_name-sda/) {
+
+ #create sda.mbr and sda.sfdisk
+ if (open(CP, "/bin/cp $image_repository_path/$image_name-sda.mbr $image_repository_path/$image_name-hda.mbr |")) {
+ close(CP);
+ notify($ERRORS{'OK'}, 0, "copied $image_name-sda.mbr to $image_repository_path/$image_name-hda.mbr");
+
+ #create sfdisk
+ if (open(CP, "/bin/cp $image_repository_path/$image_name-sda.sfdisk $image_repository_path/$image_name-hda.sfdisk |")) {
+ close(CP);
+ notify($ERRORS{'OK'}, 0, "copied $image_name-sda.sfdisk to $image_repository_path/$image_name-hda.sfdisk");
+
+ #read in file
+ if (open(FILE, "$image_repository_path/$image_name-hda.sfdisk")) {
+ my @lines = <FILE>;
+ close(FILE);
+ foreach my $l (@lines) {
+ if ($l =~ s/sda/hda/g) {
+
+ #editing file
+ }
+ }
+
+ #print array to file
+ if (open(OUTFILE, ">$image_repository_path/$image_name-hda.sfdisk")) {
+ print OUTFILE @lines;
+ close(OUTFILE);
+ notify($ERRORS{'OK'}, 0, "modified drivetype of $image_name-hda.sfdisk");
+ }
+ } ## end if (open(FILE, "$image_repository_path/$image_name-hda.sfdisk"...
+ else {
+ notify($ERRORS{'CRITICAL'}, 0, "could not open $image_repository_path/$image_name-hda.sfdisk for editing $!");
+ }
+ } ## end if (open(CP, "/bin/cp $image_repository_path/$image_name-sda.sfdisk $image_repository_path/$image_name-hda.sfdisk |"...
+ else {
+ notify($ERRORS{'OK'}, 0, "could not copy $image_repository_path/$image_name-sda.sfdisk to $image_repository_path/$image_name-hda.sfdisk $!");
+ }
+ } ## end if (open(CP, "/bin/cp $image_repository_path/$image_name-sda.mbr $image_repository_path/$image_name-hda.mbr |"...
+ else {
+ notify($ERRORS{'OK'}, 0, "could not copy $image_repository_path/$image_name-sda.mbr to $image_repository_path/$image_name-hda.mbr $!");
+ }
+ } # Close if image_name-sda
+
+ } # Close foreach line returned from the ls imagerepository command
+ } # Close if ls imagerepository
+
+ # Set file premissions on image files to 644
+ # Allows other management nodes to retrieve the image if neccessary
+ if (open(CHMOD, "/bin/chmod -R 644 $image_repository_path/$image_name\* 2>&1 |")) {
+ close(CHMOD);
+ notify($ERRORS{'DEBUG'}, 0, "recursive update file permissions 644 on $image_repository_path/$image_name");
+ }
+
+ # Image capture complete, return 1
+ notify($ERRORS{'OK'}, 0, "image capture complete");
+ return 1;
+
+} ## end sub capture_monitor
+
+#/////////////////////////////////////////////////////////////////////////////
+
+=head2 _edit_template
+
+ Parameters : imagename,drivetype
+ Returns : 0 failed or 1 success
+ Description : general routine to edit /opt/xcat/install/image/x86/imagename.tmpl
+ used in imaging process
+
+=cut
+
+sub _edit_template {
+ my ($imagename, $drivetype) = @_;
+ my ($package, $filename, $line, $sub) = caller(0);
+ notify($ERRORS{'CRITCAL'}, 0, "drivetype is not defined")
+ if (!(defined($drivetype)));
+ notify($ERRORS{'CRITCAL'}, 0, "imagename is not defined")
+ if (!(defined($imagename)));
+
+ my $template = "$XCAT_ROOT/install/image/x86/$imagename.tmpl";
+ my @lines;
+ if (open(FILE, $template)) {
+ @lines = <FILE>;
+ close FILE;
+ my $line;
+ for $line (@lines) {
+ if ($line =~ /^export DISKS=/) {
+ $line = "export DISKS=\"$drivetype\"\n";
+ last;
+ }
+ }
+
+ #dump back to template file
+ if (open(FILE, ">$template")) {
+ print FILE @lines;
+ close FILE;
+ return 1;
+ }
+ else {
+
+ # could not open nodetype file for editing
+ notify($ERRORS{'CRITICAL'}, 0, "could not open $template for writing\nerror message: $!");
+ return 0;
+ }
+ } ## end if (open(FILE, $template))
+ else {
+
+ # could not open nodetype file for editing
+ notify($ERRORS{'CRITICAL'}, 0, "could not open $template for reading\nerror message: $!");
+ return 0;
+ }
+} ## end sub _edit_template
+
+#/////////////////////////////////////////////////////////////////////////////
+
+=head2 _edit_nodetype
+
+ Parameters : node, imagename, osname
+ Returns : 0 failed or 1 success
+ Description : xCAT specific edits xcat's nodetype file with requested image name
+
+=cut
+
+sub _edit_nodetype {
+ my $self = shift;
+ if (ref($self) !~ /xCAT/i) {
+ notify($ERRORS{'CRITICAL'}, 0, "subroutine was called as a function, it must be called as a class method");
+ return 0;
+ }
+
+ # Use arguments for computer and image if they were passed
+ my $computer_node_name = shift;
+ my $image_name = shift;
+
+ # Use the new image name if it is set
+ $image_name = $self->data->get_image_name() if !$image_name;
+
+ # Get the rest of the variables
+ $computer_node_name = $self->data->get_computer_node_name()
+ if !$computer_node_name;
+ my $image_os_name = $self->data->get_image_os_name();
+ my $image_architecture = $self->data->get_image_architecture();
+ my $image_os_source_path = $self->data->get_image_os_source_path();
+
+ # Fix for Linux images on henry4
+ my $management_node_hostname = $self->data->get_management_node_hostname();
+ my $image_os_type = $self->data->get_image_os_type();
+ if ( $management_node_hostname =~ /henry4/i
+ && $image_os_type =~ /linux/i
+ && $image_os_source_path eq 'image')
+ {
+ $image_os_source_path = 'linux_image';
+ notify($ERRORS{'DEBUG'}, 0, "fixed Linux image path for henry4: image --> linux_image");
+ }
+
+ # Check to make sure the variables are populated
+ if (!$computer_node_name) {
+ notify($ERRORS{'CRITICAL'}, 0, "computer node name is not defined");
+ return 0;
+ }
+ if (!$image_name) {
+ notify($ERRORS{'CRITICAL'}, 0, "image name is not defined");
+ return 0;
+ }
+ if (!$image_os_name) {
+ notify($ERRORS{'CRITICAL'}, 0, "image OS name is not defined");
+ return 0;
+ }
+ if (!$image_architecture) {
+ notify($ERRORS{'CRITICAL'}, 0, "image architecture is not defined");
+ return 0;
+ }
+ if (!$image_os_source_path) {
+ notify($ERRORS{'CRITICAL'}, 0, "image OS source path is not defined");
+ return 0;
+ }
+
+ notify($ERRORS{'DEBUG'}, 0, "$computer_node_name, image=$image_name, os=$image_os_name, arch=$image_architecture, path=$image_os_source_path");
+
+ # Assemble the nodetype.tab and lock file paths
+ my $nodetype_file_path = "$XCAT_ROOT/etc/nodetype.tab";
+ my $lock_file_path = "$nodetype_file_path.lockfile";
+
+ # Open the lock file
+ if (sysopen(LOCKFILE, $lock_file_path, O_RDONLY | O_CREAT)) {
+ notify($ERRORS{'DEBUG'}, 0, "opened $lock_file_path");
+
+ # Set exclusive lock on lock file
+ if (flock(LOCKFILE, LOCK_EX)) {
+ notify($ERRORS{'DEBUG'}, 0, "set exclusive lock on $lock_file_path");
+
+ if (open(NODETYPE, $nodetype_file_path)) { #read file
+ notify($ERRORS{'DEBUG'}, 0, "opened $nodetype_file_path");
+
+ # Get the nodetype.tab lines and close the file
+ my @nodetype_lines = <NODETYPE>;
+ notify($ERRORS{'DEBUG'}, 0, "lines found in nodetype.tab: " . scalar @nodetype_lines);
+
+ # Close the nodetype.tab file
+ close(NODETYPE);
+ notify($ERRORS{'DEBUG'}, 0, "closed $nodetype_file_path");
+
+ # Loop through the nodetype.tab lines
+ for my $line (@nodetype_lines) {
+
+ # Skip over non-matching lines
+ next if ($line !~ /^$computer_node_name\s+([,\w]*)/);
+ notify($ERRORS{'OK'}, 0, "matching line found: $line");
+
+ # Replace line matching $computer_node_name
+ $line = "$computer_node_name\t\t$image_os_source_path,$image_architecture,$image_name\n";
+ notify($ERRORS{'OK'}, 0, "line modified: $line");
+ } ## end for my $line (@nodetype_lines)
+
+ # Dump modified array to nodetype.tab file
+ if (open(NODETYPE, ">$nodetype_file_path")) {
+ notify($ERRORS{'OK'}, 0, "nodetype.tab opened");
+ print NODETYPE @nodetype_lines;
+ notify($ERRORS{'OK'}, 0, "nodetype.tab contents replaced");
+ close(NODETYPE);
+ notify($ERRORS{'OK'}, 0, "nodetype.tab saved");
+ close(LOCKFILE);
+ notify($ERRORS{'DEBUG'}, 0, "lock file closed");
+ return 1;
+ } ## end if (open(NODETYPE, ">$nodetype_file_path"))
+ else {
+
+ # Could not open nodetype.tab file for editing
+ notify($ERRORS{'CRITICAL'}, 0, "could not open file for writing: $nodetype_file_path, $!");
+ close(LOCKFILE);
+ notify($ERRORS{'DEBUG'}, 0, "lock file closed");
+ return 0;
+ }
+ } ## end if (open(NODETYPE, $nodetype_file_path))
+ else {
+
+ # could not open nodetype file for reading
+ notify($ERRORS{'CRITICAL'}, 0, "could not open file for reading: $nodetype_file_path, $!");
+ close(LOCKFILE);
+ notify($ERRORS{'DEBUG'}, 0, "lock file closed");
+ return 0;
+ }
+ } ## end if (flock(LOCKFILE, LOCK_EX))
+ else {
+
+ # Could not open lock
+ notify($ERRORS{'CRITICAL'}, 0, "unable to get exclusive lock on $lock_file_path to edit nodetype.tab, $!");
+ close(LOCKFILE);
+ notify($ERRORS{'DEBUG'}, 0, "lock file closed");
+ return 0;
+ }
+ } ## end if (sysopen(LOCKFILE, $lock_file_path, O_RDONLY...
+
+ else {
+
+ # Could not open lock file
+ notify($ERRORS{'CRITICAL'}, 0, "unable to open $lock_file_path to edit nodetype.tab, $!");
+ return 0;
+ }
+
+} ## end sub _edit_nodetype
+
+#/////////////////////////////////////////////////////////////////////////////
+
+=head2 _pping
+
+ Parameters : $node
+ Returns : 1 or 0
+ Description : using xcat pping cmd to ping blade, xcat specific
+
+=cut
+
+sub _pping {
+ my $node = $_[0];
+ my ($package, $filename, $line, $sub) = caller(0);
+ notify($ERRORS{'WARNING'}, 0, "_pping: node is not defined")
+ if (!(defined($node)));
+ if (open(PPING, "$XCAT_ROOT/bin/pping $node 2>&1 |")) {
+ my @file = <PPING>;
+ close(PPING);
+ foreach my $l (@file) {
+ chomp $l;
+ notify($ERRORS{'OK'}, 0, "pinging $l");
+ if ($l =~ /noping/) {
+ return 0;
+ }
+ if ($l =~ /$node: ping/) {
+ return 1;
+ }
+ } ## end foreach my $l (@file)
+ return 1;
+ } ## end if (open(PPING, "$XCAT_ROOT/bin/pping $node 2>&1 |"...
+ else {
+ notify($ERRORS{'WARNING'}, 0, "could not execute $XCAT_ROOT/bin/pping $node");
+ return 0;
+ }
+} ## end sub _pping
+
+#/////////////////////////////////////////////////////////////////////////////
+
+=head2 _nodeset
+
+ Parameters : $node
+ Returns : xcat state of node or 0
+ Description : using xcat nodeset cmd to retrieve state of blade, xcat specific
+
+=cut
+
+sub _nodeset {
+ my $node = $_[0];
+ my ($package, $filename, $line, $sub) = caller(0);
+ notify($ERRORS{'WARNING'}, 0, "_nodeset: node is not defined")
+ if (!(defined($node)));
+ return 0 if (!(defined($node)));
+
+ my ($blah, $case);
+ my @file;
+ my $l;
+ if (open(NODESET, "$XCAT_ROOT/bin/nodeset $node stat |")) {
+
+ #notify($ERRORS{'OK'},0,"executing $XCAT_ROOT/bin/nodeset $node stat ");
+ @file = <NODESET>;
+ close NODESET;
+ foreach $l (@file) {
+ chomp($l);
+ ($blah, $case) = split(/:\s/, $l);
+ }
+ if ($case) {
+
+ #notify($ERRORS{'OK'},0,"$node in $case state ");
+ return $case;
+ }
+ else {
+ notify($ERRORS{'WARNING'}, 0, "case for $node is empty");
+ return 0;
+ }
+ } ## end if (open(NODESET, "$XCAT_ROOT/bin/nodeset $node stat |"...
+ else {
+ notify($ERRORS{'WARNING'}, 0, "failed to execute $XCAT_ROOT/bin/nodeset $node stat");
+ return 0;
+ }
+} ## end sub _nodeset
+
+#/////////////////////////////////////////////////////////////////////////////
+
+=head2 _nodeset
+
+ Parameters : $node $option
+ Returns : xcat state of node or 0
+ Description : using xcat nodeset cmd to use the input option of blade, xcat specific
+
+=cut
+
+sub _nodeset_option {
+ my ($node, $option) = @_;
+ my ($package, $filename, $line, $sub) = caller(0);
+ notify($ERRORS{'WARNING'}, 0, "_nodeset_option: node is not defined")
+ if (!(defined($node)));
+ notify($ERRORS{'WARNING'}, 0, "_nodeset_option: option is not defined")
+ if (!(defined($option)));
+ my ($blah, $case);
+ my @file;
+ my $l;
+ if (open(NODESET, "$XCAT_ROOT/bin/nodeset $node $option |")) {
+
+ #notify($ERRORS{'OK'},0,"executing $XCAT_ROOT/bin/nodeset $node $option");
+ @file = <NODESET>;
+ close NODESET;
+ foreach $l (@file) {
+ chomp($l);
+ ($blah, $case) = split(/:\s/, $l);
+ }
+ if ($case) {
+ notify($ERRORS{'OK'}, 0, "$node in $case state ");
+ return $case;
+ }
+ else {
+ notify($ERRORS{'WARNING'}, 0, "case for $node is empty");
+ return 0;
+ }
+ } ## end if (open(NODESET, "$XCAT_ROOT/bin/nodeset $node $option |"...
+ else {
+ notify($ERRORS{'WARNING'}, 0, "failed to execute $XCAT_ROOT/bin/nodeset $node $option");
+ return 0;
+ }
+
+} ## end sub _nodeset_option
+
+#/////////////////////////////////////////////////////////////////////////////
+
+=head2 makesshgkh
+
+ Parameters : imagename
+ Returns : 0 or 1
+ Description : xCAT specific scans node for public ssh key
+
+=cut
+
+sub makesshgkh {
+ my $node = $_[0];
+ my ($package, $filename, $line, $sub) = caller(0);
+ notify($ERRORS{'WARNING'}, 0, "node is not defined")
+ if (!(defined($node)));
+ if (!(defined($node))) {
+ return 0;
+ }
+ if (open(MAKESSHGKH, "$XCAT_ROOT/sbin/makesshgkh $node 2>&1 |")) {
+ while (<MAKESSHGKH>) {
+ chomp($_);
+ if ($_ =~ /Scanning keys/) {
+
+ #notify($ERRORS{'OK'},0,"$_");
+ }
+ else {
+
+ #possible error
+ #notify($ERRORS{'OK'},0,"possible error in $_ ");
+ }
+ } ## end while (<MAKESSHGKH>)
+ close(MAKESSHGKH);
+ return 1;
+ } ## end if (open(MAKESSHGKH, "$XCAT_ROOT/sbin/makesshgkh $node 2>&1 |"...
+ return 0;
+} ## end sub makesshgkh
+
+#/////////////////////////////////////////////////////////////////////////////
+
+=head2 _rpower
+
+ Parameters : $node, $option
+ Returns : 1 connected 0 not connected
+ Description : xCAT specific command - hard power cycle the blade
+
+=cut
+
+sub _rpower {
+ my ($node, $option) = @_;
+
+ #make sure node and option are defined
+ notify($ERRORS{'WARNING'}, 0, "_rpower: node is not defined")
+ if (!(defined($node)));
+ notify($ERRORS{'WARNING'}, 0, "_rpower: option is not defined setting to cycle")
+ if (!(defined($option)));
+ return 0 if (!(defined($node)));
+
+ $option = "cycle" if (!(defined($option)));
+
+ my $l;
+ my @file;
+ RPOWER:
+ if (open(RPOWER, "$XCAT_ROOT/bin/rpower $node $option |")) {
+ @file = <RPOWER>;
+ close(RPOWER);
+ foreach $l (@file) {
+ if ($l =~ /not in bay/) {
+
+ # not in bay problem
+ if (_fix_rpower($node)) {
+ goto RPOWER; #try again
+ }
+ }
+ if ($l =~ /$node:\s+(on|off)/) {
+ return $1;
+ }
+ } ## end foreach $l (@file)
+ return 0;
+ } ## end if (open(RPOWER, "$XCAT_ROOT/bin/rpower $node $option |"...
+ else {
+ notify($ERRORS{'WARNING'}, 0, "_rpower: could not run $XCAT_ROOT/bin/rpower $node $option $!");
+ return 0;
+ }
+
+} ## end sub _rpower
+
+#/////////////////////////////////////////////////////////////////////////////
+
+=head2 _fix_rpower
+
+ Parameters : nodename
+ Returns : 1(success) or 0(failure)
+ Description : due to a bug in a previous firmware version.
+ it's belived to be fixed in previous versions
+
+=cut
+
+sub _fix_rpower {
+ my $node = $_[0];
+ my ($package, $filename, $line, $sub) = caller(0);
+ notify($ERRORS{'WARNING'}, 0, "node not set") if (!defined($node));
+
+ # this function kicks the management this is a known xcat bug, the
+ # workaround is to run rinv nodename all twice
+ my $notfixed = 1;
+ my $tries = 0;
+ while ($notfixed) {
+ $tries++;
+ if ($tries > 10) {
+ notify($ERRORS{'CRITICAL'}, 0, "_fix_rpower failed $tries on $node");
+ return 0;
+ }
+
+ #notify($ERRORS{'OK'},0,"executing $XCAT_ROOT/bin/rinv $node all");
+ if (open(RINV, "$XCAT_ROOT/bin/rinv $node all |")) {
+ my @rinv = <RINV>;
+ my $line;
+ close RINV;
+ foreach $line (@rinv) {
+ next if ($line =~ /HTTP login failed/); #expected
+ if ($line =~ /Machine Type/) {
+ notify($ERRORS{'OK'}, 0, "rinv succeded for $node");
+ return 1;
+ }
+ }
+ } ## end if (open(RINV, "$XCAT_ROOT/bin/rinv $node all |"...
+ else {
+ notify($ERRORS{'OK'}, 0, "could not execute $XCAT_ROOT/bin/rinv $node all $!");
+ }
+ } ## end while ($notfixed)
+
+} ## end sub _fix_rpower
+
+#/////////////////////////////////////////////////////////////////////////////
+
+=head2 node_status
+
+ Parameters : [0]: computer node name (optional)
+ [1]: log file path (optional)
+ Returns : If called in scalar or boolean context:
+ 1: node is down or needs to be reloaded
+ 0: node is up and does not need to be reloaded
+ undefined: error occurred while checking node status
+
+ hashref: reference to hash with keys/values:
+ {status} => <"READY","FAIL">
+ {ping} => <0,1>
+ {ssh} => <0,1>
+ {rpower} => <0,1>
+ {nodeset} => <"boot", "install", "image", ...>
+ {nodetype} => <image name>
+ {currentimage} => <image name>
+ Description : Checks the status of an xCAT-provisioned machine. If no
+ arguments are supplied, the node and image for the current
+ reservation will be used.
+
+=cut
+
+sub node_status {
+ my $self = shift;
+ my ($computer_node_name, $log);
+
+ my $management_node_os_name = 0;
+ my $management_node_keys = 0;
+ my $computer_host_name = 0;
+ my $computer_short_name = 0;
+ my $computer_ip_address = 0;
+ my $image_os_name = 0;
+ my $image_name = 0;
+
+ # Check if subroutine was called as a class method
+ if (ref($self) !~ /xcat/i) {
+ #$cidhash->{hostname}, $cidhash->{OSname}, $cidhash->{MNos}, $cidhash->{IPaddress}, $LOG
+ $computer_node_name = $self;
+
+ $log = shift;
+ $log = 0 if !$log;
+ $computer_short_name = $computer_node_name;
+ }
+ else {
+
+ # Get the computer name from the DataStructure
+ $computer_node_name = $self->data->get_computer_node_name();
+
+ # Check if this was called as a class method, but a node name was also specified as an argument
+ my $node_name_argument = shift;
+ $computer_node_name = $node_name_argument if $node_name_argument;
+ $computer_host_name = $self->data->get_computer_host_name();
+ $computer_short_name = $self->data->get_computer_short_name();
+ $image_name = $self->data->get_image_name();
+ $log = 0;
+ } ## end else [ if (ref($self) !~ /xcat/i)
+
+ # Check the node name variable
+ if (!defined($computer_node_name) || !$computer_node_name) {
+ notify($ERRORS{'WARNING'}, 0, "node name could not be determined");
+ return;
+ }
+ notify($ERRORS{'DEBUG'}, 0, "checking status of node: $computer_node_name");
+
+
+
+ # Create a hash to store status components
+ my %status;
+
+ # Initialize all hash keys here to make sure they're defined
+ $status{status} = 0;
+ $status{nodetype} = 0;
+ $status{currentimage} = 0;
+ $status{ping} = 0;
+ $status{rpower} = 0;
+ $status{nodeset} = 0;
+ $status{ssh} = 0;
+
+ # Check the nodetype.tab file
+ notify($ERRORS{'DEBUG'}, $log, "checking the current image listed in nodetype.tab for $computer_short_name");
+ my $nodetype_file_path = "$XCAT_ROOT/etc/nodetype.tab";
+ if (open(NODETYPE, $nodetype_file_path)) {
+ notify($ERRORS{'OK'}, 0, "opened $nodetype_file_path for reading");
+
+ # Get all the lines in nodetype.tab
+ my @nodetype_lines = <NODETYPE>;
+
+ # Close the nodetype.tab file
+ close NODETYPE;
+
+ # Find the nodetype.tab line for the computer
+ # Example line: vcln1-1 image,x86,winxp-base1-v21
+ # vclb2-8 rhas5,x86,rhel5-base587-v0
+ my $nodetype_contents = join("\n", @nodetype_lines);
+ if ($nodetype_contents =~ /^$computer_short_name\s+(\w+),(\w+),(.+)$/xm, $nodetype_contents) {
+ my $nodetype_install_path = $1;
+ my $nodetype_image_architecture = $2;
+ my $nodetype_image_name = $3;
+
+ # Remove any spaces from the beginning and end of the $nodetype_image_name string
+ $nodetype_image_name =~ s/^\s+//;
+ $nodetype_image_name =~ s/\s+$//;
+
+ notify($ERRORS{'DEBUG'}, 0, "found nodetype.tab line: path=$nodetype_install_path, arch=$nodetype_image_architecture, image=$nodetype_image_name");
+ $status{nodetype} = $nodetype_image_name;
+ } ## end if ($nodetype_contents =~ /^$computer_short_name\s+(\w+),(\w+),(.+)$/xm...
+ else {
+ notify($ERRORS{'WARNING'}, 0, "unable to find line in nodetype.tab for computer: $computer_short_name");
+ return;
+ }
+ } ## end if (open(NODETYPE, $nodetype_file_path))
+ else {
+ notify($ERRORS{'WARNING'}, $log, "could not open $nodetype_file_path for reading");
+ return;
+ }
+
+ # Check if node is pingable
+ notify($ERRORS{'DEBUG'}, $log, "checking if $computer_host_name is pingable");
+ if (_pingnode($computer_host_name)) {
+ $status{ping} = 1;
+ notify($ERRORS{'OK'}, $log, "$computer_host_name is pingable ($status{ping})");
+ }
+ else {
+ $status{ping} = 0;
+ notify($ERRORS{'OK'}, $log, "$computer_host_name is not pingable ($status{ping})");
+ }
+
+ # Check the rpower status
+ notify($ERRORS{'DEBUG'}, $log, "checking $computer_short_name xCAT rpower status");
+ my $rpower_status = _rpower($computer_short_name, "stat");
+ if ($rpower_status =~ /on/i) {
+ $status{rpower} = 1;
+ }
+ else {
+ $status{rpower} = 0;
+ }
+ notify($ERRORS{'OK'}, $log, "$computer_short_name rpower status: $rpower_status ($status{rpower})");
+
+ # Check the xCAT nodeset status
+ notify($ERRORS{'DEBUG'}, $log, "checking $computer_short_name xCAT nodeset status");
+ my $nodeset_status = _nodeset($computer_short_name);
+ notify($ERRORS{'OK'}, $log, "$computer_short_name nodeset status: $nodeset_status");
+ $status{nodeset} = $nodeset_status;
+
+ # Check the sshd status
+ notify($ERRORS{'DEBUG'}, $log, "checking if $computer_short_name sshd service is accessible");
+ my $sshd_status = _sshd_status($computer_short_name, $status{nodetype}, $log);
+
+ # If sshd is accessible, perform sshd-dependent checks
+ if ($sshd_status =~ /on/) {
+ $status{ssh} = 1;
+ notify($ERRORS{'DEBUG'}, $log, "$computer_short_name sshd service is accessible, performing dependent checks");
+
+ # Check the currentimage.txt file on the node
+ notify($ERRORS{'DEBUG'}, $log, "checking image specified in currentimage.txt file on $computer_short_name");
+ if ($status{nodetype} =~ /win|image/) {
+ my $status_currentimage = _getcurrentimage($computer_short_name);
+ if ($status_currentimage) {
+ notify($ERRORS{'OK'}, $log, "$computer_short_name currentimage.txt has: $status_currentimage");
+ $status{currentimage} = $status_currentimage;
+ }
+ else {
+ notify($ERRORS{'WARNING'}, $log, "$computer_short_name currentimage.txt could not be checked");
+ }
+ } ## end if ($status{nodetype} =~ /win|image/)
+ else {
+ notify($ERRORS{'OK'}, $log, "currentimage.txt can not be checked for image type: $status{nodetype}");
+ }
+ } ## end if ($sshd_status =~ /on/)
+ else {
+ $status{ssh} = 0;
+ }
+ notify($ERRORS{'OK'}, $log, "$computer_short_name sshd status: $sshd_status ($status{ssh})");
+
+ # Check if nodetype.tab matches reservation image name
+ my $nodetype_image_match = 0;
+ if ($status{nodetype} eq $image_name) {
+ notify($ERRORS{'OK'}, $log, "nodetype.tab ($status{nodetype}) matches reservation image ($image_name)");
+ $nodetype_image_match = 1;
+ }
+ else {
+ notify($ERRORS{'OK'}, $log, "nodetype.tab ($status{nodetype}) does not match reservation image ($image_name)");
+ }
+
+ # Check if nodetype.tab matches currentimage.txt
+ my $nodetype_currentimage_match = 0;
+ if ($status{nodetype} eq $status{currentimage}) {
+ notify($ERRORS{'OK'}, $log, "nodetype.tab ($status{nodetype}) matches currentimage.txt ($status{currentimage})");
+ $nodetype_currentimage_match = 1;
+ }
+ else {
+ notify($ERRORS{'OK'}, $log, "nodetype.tab ($status{nodetype}) does not match currentimage.txt ($status{currentimage}), assuming nodetype.tab is correct");
+ }
+
+ # Determine the overall machine status based on the individual status results
+ $status{status} = 'READY';
+ if (!$status{rpower}) {
+ $status{status} = 'RELOAD';
+ notify($ERRORS{'OK'}, $log, "rpower status is not on, node needs to be reloaded");
+ }
+ if (!$status{ssh}) {
+ $status{status} = 'RELOAD';
+ notify($ERRORS{'OK'}, $log, "sshd is not accessible, node needs to be reloaded");
+ }
+ if (!$nodetype_image_match) {
+ $status{status} = 'RELOAD';
+ notify($ERRORS{'OK'}, $log, "nodetype.tab does not match requested image, node needs to be reloaded");
+ }
+
+ # Node is up and doesn't need to be reloaded
+ if ($status{status} =~ /ready/i) {
+ notify($ERRORS{'OK'}, $log, "node is up and does not need to be reloaded");
+ }
+ else {
+ notify($ERRORS{'OK'}, $log, "node is either down or needs to be reloaded");
+ }
+
+ notify($ERRORS{'OK'}, $log, "returning node status hash reference with {status}=$status{status}");
+ return \%status;
+} ## end sub node_status
+
+#/////////////////////////////////////////////////////////////////////////////
+
+=head2 _assign2project
+
+ Parameters : $node, $project
+ Returns : 0 or 1
+ Description : xCAT specific changes the networking to capable switch modules to either vcl,hpc or vclhpc project
+
+=cut
+
+sub _assign2project {
+ my ($node, $project) = @_;
+ my ($package, $filename, $line, $sub) = caller(0);
+
+ notify($ERRORS{'CRITICAL'}, 0, "node is not defined")
+ if (!(defined($node)));
+ notify($ERRORS{'CRITICAL'}, 0, "project is not defined")
+ if (!(defined($project)));
+ my $PROJECTtab = "$XCAT_ROOT/etc/project.tab";
+ my $assign2project = "$XCAT_ROOT/sbin/assign2project";
+ my $LCK = $PROJECTtab . "lockfile";
+
+ #make sure this management node can make assignments
+
+ if (-r $PROJECTtab) { #do we have a project.tab file to work with
+
+ #read project tab
+ if (open(PT, "<$PROJECTtab")) {
+ my @pt = <PT>;
+ close(PT);
+ my $p;
+ foreach $p (@pt) {
+ if ($p =~ /^$node\s+/) {
+ if ($p =~ /^$node\s*$project$/i) {
+ notify($ERRORS{'OK'}, 0, "$node is set correctly to $project");
+ return 1;
+ }
+ else {
+ notify($ERRORS{'OK'}, 0, "starting to set exclusive lock on $LCK");
+ if (sysopen(LF, $LCK, O_RDONLY | O_CREAT)) {
+ if (flock(LF, LOCK_EX)) { #set exclusive lock on LF
+ notify($ERRORS{'OK'}, 0, "setting exclusive lock on $LCK");
+ notify($ERRORS{'OK'}, 0, "$node is set incorrectly changing to $project project");
+ if (open(AP, "$assign2project $node $project 2>&1 |")) {
+ my @file = <AP>;
+ close(AP);
+ foreach my $l (@file) {
+ notify($ERRORS{'OK'}, 0, "output @file");
+ if ($l =~ /configurations are already correct! Nothing done/) {
+ notify($ERRORS{'OK'}, 0, "$node is currently assigned to $project - releasing lock");
+ close(LF);
+ return 1;
+ }
+ if ($l =~ /Done!/) {
+ notify($ERRORS{'OK'}, 0, "$node is successfully assigned to $project - releasing lock");
+ close(LF);
+ return 1;
+ }
+
+ } #foreach
+ notify($ERRORS{'CRITICAL'}, 0, "provided unexpected output $node $project - output= @file");
+ close(LF);
+ return 0;
+
+ } #if AP
+ } #flock
+ } #sysopen
+ } #else
+ } #if node
+ } #foreach
+ } #if open
+ else {
+ notify($ERRORS{'WARNING'}, 0, "could not open $PROJECTtab for reading $!");
+ close(LF);
+ return 0;
+ }
+ } #if tabfile readable
+ else {
+ notify($ERRORS{'OK'}, 0, "project.tab does not exist on this Management node");
+ return 1;
+
+ }
+
+} ## end sub _assign2project
+
+#/////////////////////////////////////////////////////////////////////////////
+
+=head2 does_image_exist
+
+ Parameters : optional: image name
+ Returns : 1 if image exists, 0 if it doesn't
+ Description : Checks the management node's local image repository for the
+ existence of the requested image. This subroutine does not
+ attempt to copy the image from another management node. The
+ retrieve_image() subroutine does this. Callers of
+ does_image_exist must also call retrieve_image if image library
+ retrieval functionality is desired.
+
+=cut
+
+sub does_image_exist {
+ my $self = shift;
+ if (ref($self) !~ /xCAT/i) {
+ notify($ERRORS{'CRITICAL'}, 0, "subroutine was called as a function, it must be called as a class method");
+ return 0;
+ }
+
+ # Get the image name, first try passed argument, then data
+ my $image_name = shift;
+ $image_name = $self->data->get_image_name() if !$image_name;
+ if (!$image_name) {
+ notify($ERRORS{'WARNING'}, 0, "unable to determine image name");
+ return;
+ }
+
+ # Get the image repository path
+ my $image_repository_path = $self->_get_image_repository_path();
+ if (!$image_repository_path) {
+ notify($ERRORS{'WARNING'}, 0, "image repository path could not be determined");
+ return;
+ }
+ else {
+ notify($ERRORS{'DEBUG'}, 0, "image repository path: $image_repository_path");
+ }
+
+ # Get the tmpl repository path
+ my $tmpl_repository_path = $self->_get_image_template_path();
+ if (!$tmpl_repository_path) {
+ notify($ERRORS{'WARNING'}, 0, "image template path could not be determined");
+ return;
+ }
+ else {
+ notify($ERRORS{'DEBUG'}, 0, "template repository path: $tmpl_repository_path");
+ }
+
+ # Check if template file exists for the image
+ # -s File has nonzero size
+ my $tmpl_file_exists;
+ if (-s "$tmpl_repository_path/$image_name.tmpl") {
+ $tmpl_file_exists = 1;
+ notify($ERRORS{'DEBUG'}, 0, "template file exists: $image_name.tmpl");
+ }
+ else {
+ $tmpl_file_exists = 0;
+ notify($ERRORS{'OK'}, 0, "template file does not exist: $tmpl_repository_path/$image_name.tmpl");
+ }
+
+ # Check if image files exist (Partimage files)
+ # Open the repository directory
+ if (!opendir(REPOSITORY, $image_repository_path)) {
+ notify($ERRORS{'WARNING'}, 0, "unable to open the image repository directory: $image_repository_path");
+ return;
+ }
+
+ # Get the list of files in the repository and close the directory
+ my @repository_files = readdir(REPOSITORY);
+ closedir(REPOSITORY);
+
+ # Check if any files exist for the image
+ my $image_files_exist;
+ if (my @image_files = grep(/$image_name/, @repository_files)) {
+ $image_files_exist = 1;
+ my $image_file_list = join(@image_files, "\n");
+ notify($ERRORS{'DEBUG'}, 0, "image files exist in repository:\n$image_file_list");
+ }
+ else {
+ $image_files_exist = 0;
+ notify($ERRORS{'OK'}, 0, "image files do not exist in repository: $image_repository_path/$image_name");
+ }
+
+ # Image files found
+ if ($tmpl_file_exists && $image_files_exist) {
+ notify($ERRORS{'OK'}, 0, "image $image_name exists on this management node, returning 0");
+ return 1;
+ }
+ elsif (!$tmpl_file_exists && !$image_files_exist) {
+ notify($ERRORS{'OK'}, 0, "image $image_name does not exist on this management node, returning 1");
+ return 0;
+ }
+ else {
+ notify($ERRORS{'WARNING'}, 0, "image $image_name partially exists on this management node, tmpl=$tmpl_file_exists, image=$image_files_exist, returning undefined");
+ return;
+ }
+
+} ## end sub does_image_exist
+
+#/////////////////////////////////////////////////////////////////////////////
+
+=head2 retrieve_image
+
+ Parameters :
+ Returns :
+ Description : Attempts to retrieve an image from an image library partner
+
+=cut
+
+sub retrieve_image {
+ my $self = shift;
+ if (ref($self) !~ /xCAT/i) {
+ notify($ERRORS{'CRITICAL'}, 0, "subroutine was called as a function, it must be called as a class method");
+ return;
+ }
+
+ # Make sure imag library functions are enabled
+ my $image_lib_enable = $self->data->get_management_node_image_lib_enable();
+ if (!$image_lib_enable) {
+ notify($ERRORS{'OK'}, 0, "image library functions are disabled");
+ return;
+ }
+
+ # Get the image name
+ my $image_name = shift;
+ $image_name = $self->data->get_image_name() if !$image_name;
+ if (!$image_name) {
+ notify($ERRORS{'WARNING'}, 0, "unable to determine image name");
+ return;
+ }
+
+ # Get the other image library variables
+ my $image_lib_user = $self->data->get_management_node_image_lib_user()
+ || 'undefined';
+ my $image_lib_key = $self->data->get_management_node_image_lib_key()
+ || 'undefined';
+ my $image_lib_partners = $self->data->get_management_node_image_lib_partners() || 'undefined';
+ if ("$image_lib_user $image_lib_key $image_lib_partners" =~ /undefined/) {
+ notify($ERRORS{'WARNING'}, 0, "image library configuration data is missing: user=$image_lib_user, key=$image_lib_key, partners=$image_lib_partners");
+ return;
+ }
+
+ # Get the image repository path
+ my $image_repository_path = $self->_get_image_repository_path();
+ if (!$image_repository_path) {
+ notify($ERRORS{'WARNING'}, 0, "image repository path could not be determined");
+ return;
+ }
+
+ # Get the tmpl repository path
+ my $tmpl_repository_path = $self->_get_image_template_path();
+ if (!$tmpl_repository_path) {
+ notify($ERRORS{'WARNING'}, 0, "image template path could not be determined");
+ return;
+ }
+
+ # Check if template file exists for the image
+ # -s File has nonzero size
+ if (-s "$tmpl_repository_path/$image_name.tmpl") {
+ notify($ERRORS{'OK'}, 0, "template file already exists: $image_name.tmpl");
+ }
+ else {
+
+ # Get the name of the base tmpl file
+ my $basetmpl = $self->_get_base_template_filename();
+
+ # Template file doesn't exist, try to make a copy of the base template file
+ if (copy("$tmpl_repository_path/$basetmpl", "$tmpl_repository_path/$image_name.tmpl")) {
+ notify($ERRORS{'OK'}, 0, "template file copied: $basetmpl --> $image_name.tmpl");
+ }
+ else {
+ notify($ERRORS{'WARNING'}, 0, "template file could not be copied copied: $basetmpl --> $image_name.tmpl, $!");
+ return;
+ }
+ } ## end else [ if (-s "$tmpl_repository_path/$image_name.tmpl")
+
+ # Attempt to copy image from other management nodes
+ notify($ERRORS{'OK'}, 0, "attempting to copy $image_name from other management nodes");
+
+ # Split up the partner list
+ my @partner_list = split(/,/, $image_lib_partners);
+ if ((scalar @partner_list) == 0) {
+ notify($ERRORS{'WARNING'}, 0, "image lib partners variable is not listed correctly or does not contain any information: $image_lib_partners");
+ return;
+ }
+
+ # Loop through the partners, attempt to copy
+ foreach my $partner (@partner_list) {
+ notify($ERRORS{'OK'}, 0, "checking if $partner has $image_name");
+
+ # Use ssh to call ls on the partner management node
+ my ($ls_exit_status, $ls_output_array_ref) = run_ssh_command($partner, $image_lib_key, "ls -1 $image_repository_path", $image_lib_user);
+
+ # Check if the ssh command failed
+ if (!$ls_output_array_ref) {
+ notify($ERRORS{'WARNING'}, 0, "unable to run ls command via ssh on $partner");
+ next;
+ }
+
+ # Convert the output array to a string
+ my $ls_output = join("\n", @{$ls_output_array_ref});
+
+ # Check the ls output for permission denied
+ if ($ls_output =~ /permission denied/i) {
+ notify($ERRORS{'CRITICAL'}, 0, "permission denied when checking if $partner has $image_name, exit status=$ls_exit_status, output:\n$ls_output");
+ next;
+ }
+
+ # Check the ls output for the image name
+ if ($ls_output !~ /$image_name[\.\-]/i) {
+ notify($ERRORS{'OK'}, 0, "$image_name does not exist on $partner");
+ next;
+ }
+
+ # Image exists
+ notify($ERRORS{'OK'}, 0, "$image_name exists on $partner, attempting to copy");
+
+ # Attempt copy
+ if (run_scp_command("$image_lib_user\@$partner:$image_repository_path/$image_name*", $image_repository_path, $image_lib_key)) {
+ notify($ERRORS{'OK'}, 0, "$image_name files copied via SCP");
+ last;
+ }
+ else {
+ notify($ERRORS{'WARNING'}, 0, "unable to copy $image_name files via SCP");
+ next;
+ }
+ } ## end foreach my $partner (@partner_list)
+
+ # Make sure image was copied
+ if ($self->does_image_exist($image_name)) {
[... 349 lines stripped ...]