| #!/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)) { |
| notify($ERRORS{'OK'}, 0, "$image_name was copied to this management node"); |
| return 1; |
| } |
| else { |
| notify($ERRORS{'WARNING'}, 0, "$image_name was not copied to this management node"); |
| return 0; |
| } |
| } ## end sub retrieve_image |
| |
| #///////////////////////////////////////////////////////////////////////////// |
| |
| =head2 _check_pxe_grub_file |
| |
| Parameters : imagename |
| Returns : 0 failed or 1 success |
| Description : checks the pxe and grub files for xCAT management nodes |
| if file size is equal to 0 delete the file and return true |
| return true if file not empty |
| only return false if failure to execute or delete files |
| |
| =cut |
| |
| sub _check_pxe_grub_files { |
| my $imagename = $_[0]; |
| my ($package, $filename, $line, $sub) = caller(0); |
| notify($ERRORS{'WARNING'}, 0, "node is not defined") |
| if (!(defined($imagename))); |
| if (!(defined($imagename))) { |
| return 0; |
| } |
| my $path = "/tftpboot/xcat/image/x86/"; |
| my $ide_grub = "$path" . "$imagename" . "-ide.grub"; |
| my $scsi_grub = "$path" . "$imagename" . "-scsi.grub"; |
| my $ide_pxe = "$path" . "$imagename" . "-ide.pxe"; |
| my $scsi_pxe = "$path" . "$imagename" . "-scsi.pxe"; |
| my @errors; |
| if (-e "$ide_grub") { |
| |
| #file exists |
| my $fs = -s "$ide_grub"; |
| if ($fs == 0) { |
| notify($ERRORS{'CRITICAL'}, 0, "filesize for $ide_grub is zero, deleted "); |
| unlink $ide_grub; |
| } |
| } |
| else { |
| |
| #notify($ERRORS{'OK'},0,"skipping $ide_grub file does not exist"); |
| } |
| if (-e "$scsi_grub") { |
| |
| #file exists |
| my $fs = -s "$scsi_grub"; |
| if ($fs == 0) { |
| notify($ERRORS{'CRITICAL'}, 0, "filesize for $scsi_grub is zero, deleted "); |
| unlink $scsi_grub; |
| } |
| } |
| else { |
| |
| #notify($ERRORS{'OK'},0,"skipping $scsi_grub file does not exist"); |
| } |
| if (-e "$ide_pxe") { |
| |
| #file exists |
| my $fs = -s "$ide_pxe"; |
| if ($fs == 0) { |
| notify($ERRORS{'CRITICAL'}, 0, "filesize for $ide_pxe is zero, deleted "); |
| unlink $ide_pxe; |
| } |
| } |
| else { |
| |
| #notify($ERRORS{'OK'},0,"skipping $ide_pxe file does not exist"); |
| } |
| if (-e "$scsi_pxe") { |
| |
| #file exists |
| my $fs = -s "$scsi_pxe"; |
| if ($fs == 0) { |
| notify($ERRORS{'CRITICAL'}, 0, "filesize for $scsi_grub is zero, deleted "); |
| unlink $scsi_pxe; |
| } |
| } |
| else { |
| |
| #notify($ERRORS{'OK'},0,"skipping file $scsi_pxe does not exist"); |
| } |
| |
| return 1; |
| |
| } ## end sub _check_pxe_grub_files |
| |
| #///////////////////////////////////////////////////////////////////////////// |
| |
| =head2 get_image_size |
| |
| Parameters : $image_name (optional) |
| Returns : 0 failure or size of image |
| Description : in size of Kilobytes |
| |
| =cut |
| |
| sub get_image_size { |
| 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; |
| } |
| |
| # Either use a passed parameter as the image name or use the one stored in this object's DataStructure |
| my $image_name = shift; |
| $image_name = $self->data->get_image_name() if !$image_name; |
| if (!$image_name) { |
| notify($ERRORS{'CRITICAL'}, 0, "image name could not be determined"); |
| return 0; |
| } |
| notify($ERRORS{'DEBUG'}, 0, "getting size of image: $image_name"); |
| |
| my $image_repository_path = $self->_get_image_repository_path(); |
| if (!$image_repository_path) { |
| notify($ERRORS{'CRITICAL'}, 0, "unable to determine image repository location, returning 0"); |
| return 0; |
| } |
| |
| # Execute the command |
| my $du_command = "du -c $image_repository_path/$image_name* 2>&1"; |
| notify($ERRORS{'DEBUG'}, 0, "du command: $du_command"); |
| my $du_output = `$du_command`; |
| |
| # Save the exit status |
| my $du_exit_status = $?; |
| |
| #notify($ERRORS{'DEBUG'}, 0, "du exit staus: $du_exit_status, output:\n$du_output"); |
| |
| # Check the du command output |
| if ($du_exit_status > 0) { |
| notify($ERRORS{'WARNING'}, 0, "du exit status > 0: $du_exit_status, output:\n$du_output"); |
| return 0; |
| } |
| elsif ($du_output !~ /total/s) { |
| notify($ERRORS{'WARNING'}, 0, "du command did not produce expected output, du exit staus: $du_exit_status, output:\n$du_output"); |
| return 0; |
| } |
| |
| # Find the du output line containing 'total' |
| $du_output =~ /(\d+)\s+total/s; |
| my $size_bytes = $1; |
| |
| # Check the du command output |
| if (!$size_bytes) { |
| notify($ERRORS{'WARNING'}, 0, "du produced unexpected output: $du_exit_status, output:\n$du_output"); |
| return 0; |
| } |
| |
| # Calculate the size in MB |
| my $size_mb = int($size_bytes / 1024); |
| notify($ERRORS{'DEBUG'}, 0, "returning image size: $size_mb MB ($size_bytes bytes)"); |
| return $size_mb; |
| |
| } ## end sub get_image_size |
| |
| #///////////////////////////////////////////////////////////////////////////// |
| |
| =head2 _get_image_repository_path |
| |
| Parameters : none, must be called as an xCAT object method |
| Returns : |
| Description : |
| |
| =cut |
| |
| sub _get_image_repository_path { |
| my $self = shift; |
| my $return_template_path = 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 variables from the DataStructure |
| my $management_node_id = $self->data->get_management_node_id(); |
| my $management_node_hostname = $self->data->get_management_node_hostname(); |
| my $install_path = $self->data->get_management_node_install_path(); |
| my $image_os_name = $self->data->get_image_os_name(); |
| my $image_os_type = $self->data->get_image_os_type(); |
| my $image_os_install_type = $self->data->get_image_os_install_type(); |
| my $image_os_source_path = $self->data->get_image_os_source_path(); |
| my $image_architecture = $self->data->get_image_architecture(); |
| |
| if (!(defined($image_os_name) && defined($image_os_type) && defined($image_os_install_type) && defined($image_os_source_path) && defined($image_architecture))) { |
| notify($ERRORS{'CRITICAL'}, 0, "some of the required data could not be retrieved"); |
| return 0; |
| } |
| |
| $return_template_path = 0 if !defined($return_template_path); |
| |
| notify($ERRORS{'DEBUG'}, 0, "OS=$image_os_name, OS type=$image_os_type, OS install type=$image_os_install_type, OS source=$image_os_source_path"); |
| |
| # Fix for Linux images on henry4 |
| 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"); |
| } |
| |
| # Remove trailing / from $image_os_source_path if exists |
| $image_os_source_path =~ s/\/$//; |
| |
| # If image OS source path has a leading /, assume it was meant to be absolute |
| # Otherwise, prepend the install path |
| my $image_install_path; |
| if ($image_os_source_path =~ /^\//) { |
| |
| # If $image_os_source_path = '/centos5', use '/centos5' |
| $image_install_path = $image_os_source_path; |
| } |
| else { |
| |
| # If $image_os_source_path = 'centos5', use '/install/centos5' |
| # Note: $install_path has a leading / |
| $image_install_path = "$install_path/$image_os_source_path"; |
| } |
| |
| # Note: $XCAT_ROOT has a leading / |
| # Note: $image_install_path has a leading / |
| |
| # Check $return_template_path, either return repo path or template directory path |
| # This is done because the code to figure out the paths is mostly the same |
| # _get_image_repository_path calls this subroutine with the $return_template_path flag set |
| my $return_path; |
| if ($return_template_path) { |
| $return_path = "$XCAT_ROOT$image_install_path/$image_architecture"; |
| notify($ERRORS{'DEBUG'}, 0, "template path: $return_path"); |
| return $return_path; |
| } |
| elsif ($image_os_install_type eq 'kickstart') { |
| |
| # Kickstart installs use the xCAT path for both repo and tmpl paths |
| $return_path = "$XCAT_ROOT$image_install_path/$image_architecture"; |
| notify($ERRORS{'DEBUG'}, 0, "kickstart path: $return_path"); |
| return $return_path; |
| } |
| else { |
| |
| # Imaging installs use the xCAT path for the tmpl path, and the install path for the repo path |
| $return_path = "$image_install_path/$image_architecture"; |
| notify($ERRORS{'DEBUG'}, 0, "repository path: $return_path"); |
| return $return_path; |
| } |
| } ## end sub _get_image_repository_path |
| |
| #///////////////////////////////////////////////////////////////////////////// |
| |
| =head2 _get_image_template_path |
| |
| Parameters : none, must be called as an xCAT object method |
| Returns : |
| Description : |
| |
| =cut |
| |
| sub _get_image_template_path { |
| 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; |
| } |
| |
| return $self->_get_image_repository_path(1); |
| } |
| |
| #///////////////////////////////////////////////////////////////////////////// |
| |
| =head2 _get_base_template_filename |
| |
| Parameters : none, must be called as an xCAT object method |
| Returns : |
| Description : |
| |
| =cut |
| |
| sub _get_base_template_filename { |
| 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 some variables |
| my $image_os_name = $self->data->get_image_os_name(); |
| my $image_os_type = $self->data->get_image_os_type(); |
| |
| # Get the image template directory path |
| my $image_template_path = $self->_get_image_template_path(); |
| if (!$image_template_path) { |
| notify($ERRORS{'CRITICAL'}, 0, "image template path could not be determined"); |
| return 0; |
| } |
| |
| # Find the template file to use, from most specific to least |
| # Try OS-specific: <OS name>.tmpl |
| if (-e "$image_template_path/$image_os_name.tmpl") { |
| notify($ERRORS{'DEBUG'}, 0, "OS specific base image template file found: $image_template_path/$image_os_name.tmpl"); |
| return "$image_os_name.tmpl"; |
| } |
| elsif (-e "$image_template_path/$image_os_type.tmpl") { |
| notify($ERRORS{'DEBUG'}, 0, "OS type specific base image template file found: $image_template_path/$image_os_type.tmpl"); |
| return "$image_os_type.tmpl"; |
| } |
| elsif (-e "$image_template_path/default.tmpl") { |
| notify($ERRORS{'DEBUG'}, 0, "default base image template file found: $image_template_path/default.tmpl"); |
| return "default.tmpl"; |
| } |
| else { |
| notify($ERRORS{'CRITICAL'}, 0, "failed to find suitable base image template file in $image_template_path"); |
| return 0; |
| } |
| } ## end sub _get_base_template_filename |
| |
| #///////////////////////////////////////////////////////////////////////////// |
| |
| initialize() if (!$XCAT_ROOT); |
| 1; |
| |
| #///////////////////////////////////////////////////////////////////////////// |
| |
| __END__ |
| |
| =head1 BUGS and LIMITATIONS |
| |
| There are no known bugs in this module. |
| Please report problems to the VCL team (vcl_help@ncsu.edu). |
| |
| =head1 AUTHOR |
| |
| Aaron Peeler, aaron_peeler@ncsu.edu |
| Andy Kurth, andy_kurth@ncsu.edu |
| |
| =head1 SEE ALSO |
| |
| L<http://vcl.ncsu.edu> |
| |
| |
| =cut |
