WebSVN – havirt – Diff – /trunk/havirt.pm

 # added source node as a parameter for migrate. If source node is passed in, will not run readDB
+#
 # v1.2.3 20260101 RWR
 # modified executeAndWait to return 0 on timeout, 1 on success
 # bugfix in diffArray to handle case where arr1 is smaller than arr2
+#
+# v1.2.4 20260102 RWR
+# Created centralized execute() function for all command execution
+# Refactored all backtick command executions to use execute() for easier debugging and maintenance
+# All 7 command execution points in havirt.pm now use execute()
 package havirt;
 use warnings;
 use strict;
    use File::Basename;
    use lib dirname( abs_path( __FILE__ ) );
+}
 use Data::Dumper qw(Dumper); # Import the Dumper() subroutine
+use YAML::Tiny;
 # define the version number
 # see https://metacpan.org/pod/release/JPEACOCK/version-0.97/lib/version.pod
 use version;
-our $VERSION = version->declare("1.2.2");
+our $VERSION = version->declare("1.2.4");
 use Exporter;
 our @ISA = qw( Exporter );
                   &readDB
                   &writeDB
                   &report
                   &scan
                   &makeCommand
+                  &execute
                   &forceScan
                   &executeAndWait
                   &findDomain
                   &diffArray
                   &makeConfig
    while ( $lock && -f $lockFileName && $lockTime-- ) {
       sleep 1; # wait one second, then try again
+   }
    if ( $lock ) {
       die "Something has $main::config->{'status db filename'} locked, aborting\n" if -f $lockFileName;
-      `touch $lockFileName`;
+      &execute("touch $lockFileName");
+   }
    my $yaml = YAML::Tiny->new( {} );
    if ( -f $main::config->{'status db filename'} ) {
       $yaml = YAML::Tiny->read( $main::config->{'status db filename'} );
+   }
    return $output;
+}
 # scans a node to determine which domains are running on it
 # updates each domain to reflect when it was last seen
+# if testing flag is set, reads from testing directory file: $node_scan.testing
 sub getDomainsOnNode {
    my $node = shift;
+   my @nodeList;
+   if ( $main::config->{'flags'}->{'testing'} ) {
+      # Testing mode: read from file instead of executing command
+      my $testFile = $main::config->{'script dir'} . "/tests/${node}_scan.testing";
+      print "havirt.pm:getDomainsOnNode, reading from test file: $testFile\n" if $main::config->{'flags'}->{'debug'} > 2;
+      if ( -f $testFile ) {
+         open my $fh, '<', $testFile or die "Could not open test file $testFile: $!\n";
+         @nodeList = grep { /^\s*\d/ } <$fh>;
+         close $fh;
+      } else {
+         print "Warning: Test file $testFile not found, returning empty list\n" if $main::config->{'flags'}->{'verbose'};
+      }
+   } else {
+      # Normal mode: execute virsh command
-   my $command = &main::makeCommand( $node, 'virsh list' );
+      my $command = &main::makeCommand( $node, 'virsh list' );
-   print "havirt.pm:getDomainsOnNode, command is $command\n" if $main::config->{'flags'}->{'debug'} > 2;
+      print "havirt.pm:getDomainsOnNode, command is $command\n" if $main::config->{'flags'}->{'debug'} > 2;
-   my @nodeList = grep { /^\s*\d/ } `$command`;
+      @nodeList = grep { /^\s*\d/ } &main::execute($command);
+   }
    for ( my $i = 0; $i < @nodeList; $i++ ) {
       if ( $nodeList[$i] =~ m/\s*\d+\s*([^ ]+)/ ) {
          $nodeList[$i] = $1;
+      }
+   }
       print "findDomain, nodes = " . join( "\t", @node ) . "\n" if $main::config->{'flags'}->{'debug'} > 1;
+   }
    if ( $main::config->{'flags'}->{'paranoid'} ) { # we will scan all nodes just to make sure
       foreach my $thisNode ( @node ) {
          my $command = &main::makeCommand( $thisNode, 'virsh list' );
-         my $output = `$command`;
+         my $output = &main::execute($command);
          print "findDomain, $thisNode list =\n" . $output . "\n" if $main::config->{'flags'}->{'debug'} > 1;;
          return $thisNode if ( $output =~ m/$domainName/ );
+      }
    } else { # not paranoid mode, so just look through the status file
       foreach my $thisNode ( @node ) {
    my @targets = @_;
    if ( -f $main::config->{'last scan filename'} && ! $main::config->{'flags'}->{'force'} ) {
       my $lastScan = time - ( stat( $main::config->{'last scan filename'} ) ) [9];
       return "Scan was run $lastScan seconds ago\n" unless $lastScan > $main::config->{'min scan time'};
+   }
-   `touch $main::config->{'last scan filename'}`;
+   &main::execute("touch $main::config->{'last scan filename'}");
    &main::readDB(1);
    print Dumper( $main::statusDB->{'nodePopulation'} ) if $main::config->{'flags'}->{'debug'} > 2;
    if ( $main::config->{'flags'}->{'target'} ) {
       push @targets, $main::config->{'flags'}->{'target'};
+   }
 # if node is the node we're on, we don't need to do a remote call
 # if node is null, we'll assume we do the command here
 # otherwise, we'll do an ssh to the node and run the command there
 sub makeCommand {
    my ( $node, $command ) = @_;
-   my $me = `hostname`;
+   my $me = &execute('hostname');
    chomp $me;
    if ( ! $node || $node eq $me ) {
       return $command;
    } else {
       return "ssh $node '$command'";
+   }
+}
+# executes a shell command and returns the output
+# centralizes all command execution for easier debugging and modification
+# usage: execute($command) or @output = execute($command)
+sub execute {
+   my $command = shift;
+   print "havirt.pm:execute running: [$command]\n" if $main::config->{'flags'}->{'debug'} > 2;
+   return `$command`;
+}
 # force a node scan, of all domains, even if time has not expired
 # and/or target is set. do this by setting force to 1 and target to null
 # then calling scan,
 # after run, reset it to old value
 sub forceScan {
 # executes command $command, then repeatedly runs virsh list
 # on $scanNode, grep'ing for $scanDomain
 # $condition is 1, to wait for domain to start
 # or 0 (false) to wait for it to shut down
 sub executeAndWait {
-   my ( $command, $scanNode, $scanDomain, $condition ) = @_;
+   my ( $command, $scanNode, $scanDomain, $condition, $timeOut, $pollEvery ) = @_;
-   my $waitSeconds = 15; # number of seconds to wait before checking again
+   $pollEvery = 15 unless defined $pollEvery; # number of seconds to wait before checking again
-   my $maxIterations = 60 / $waitSeconds; # maximum number of tries
+   $timeOut = 60 unless defined $timeOut; # maximum number of tries
+   $timeOut = int( $timeOut / $pollEvery ) unless $timeOut > $pollEvery;
-   print "Running [$command], then waiting $waitSeconds to check if complete\n" if $main::config->{'flags'}->{'debug'};
+   print "Running [$command], then waiting $pollEvery seconds to check if complete\n" if $main::config->{'flags'}->{'debug'};
-   `$command`;
+   &main::execute($command);
    my $waitCommand = &makeCommand( $scanNode, "virsh list | grep $scanDomain" );
    my $output = '';
    do {
-      return 0 unless ( $maxIterations-- ); # we've waited too long, so probably not working
+      return 0 unless ( $timeOut-- ); # we've waited too long, so probably not working
       print '. ';
-      sleep 1;
+      sleep $pollEvery;
-      $output = `$waitCommand`;
+      $output = &main::execute($waitCommand);
       print "[$waitCommand] returned [$output]\n" if $main::config->{'flags'}->{'debug'} > 1;
    } until ( $condition ? $output : !$output );
    return 1; # made it successful
+}
 # find the differences between two arrays (passed by reference)
 # first sorts the array, then walks through them one by one
 # @$arr1 MUST be larger than @$arr2
 # used by domain.pm:list to find non-running domains for output
+# returns elements in arr1 that are not in arr2
 sub diffArray {
    my ( $arr1, $arr2 ) = @_;
    my @result;
    @$arr1 = sort @$arr1;
    @$arr2 = sort @$arr2;
    my $i=0;
    my $j=0;
-   while ( $i < @$arr1 && $j < @$arr2) {
+   while ( $i < @$arr1 ) {
-      if ( $arr1->[$i] eq $arr2->[$j] ) {
+      if ( $j < @$arr2 && $arr1->[$i] eq $arr2->[$j] ) {
+         # Match found, skip both
          $i++;
          $j++;
-      } elsif ( $arr1->[$i] lt $arr2->[$j] ) {
+      } elsif ( $j >= @$arr2 || $arr1->[$i] lt $arr2->[$j] ) {
+         # arr1[i] not in arr2, or arr2 exhausted
          push @result, $arr1->[$i];
          $i++;
       } else {
-         push @result, $arr2->[$j];
+         # arr1[i] > arr2[j], advance j to keep looking for match
          $j++;
+      }
+   }
    return \@result;
+}
    my $command = &main::makeCommand( $node, "virsh migrate --live --persistent --verbose  $virt qemu+ssh://$target/system" );
    if ( $main::config->{'flags'}->{'dryrun'} ) { # they want us to actually do it
       $return = $command;
    } else {
       print "Migrating $virt to $node\n" if $main::config->{'flags'}->{'verbose'};
-      $return = ( &main::executeAndWait( $command, $node, $virt, 0 ) ? 'Success' : 'Time Out waiting for shutdown');
+      $return = ( &main::executeAndWait( $command, $node, $virt, 0, 60, 15 ) ? 'Success' : 'Time Out waiting for shutdown');
       #&main::forceScan(); Removed since we're doing it at a higher level
+   }
    return "$return\n";
+}

Subversion Repositories havirt

(root)/trunk/havirt.pm – Rev 46 → 47