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

 # OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 # v0.0.1 20240602 RWR
 # Initial setup
+#
+# v1.2.0 20240826 RWR
+# Added some code to migrate domains if node placed in maintenance mode
+# Added a lot of 'verbose' print lines, and modified for new flag structure
+#
 package havirt;
 use warnings;
 use strict;
 use Data::Dumper qw(Dumper); # Import the Dumper() subroutine
 # define the version number
 # see https://metacpan.org/pod/release/JPEACOCK/version-0.97/lib/version.pod
 use version;
-our $VERSION = version->declare("1.0.0");
+our $VERSION = version->declare("1.2.0");
 use Exporter;
 our @ISA = qw( Exporter );
       $yaml = YAML::Tiny->read( $main::config->{'status db filename'} );
+   }
    $main::statusDB = $yaml->[0];
+}
+# Write the statusDB file out, overwriting the current one
+# remove the lock file, if it exists
 sub writeDB {
    my $yaml = YAML::Tiny->new( $main::statusDB );
    $yaml->write( $main::config->{'status db filename'} );
    unlink "$main::config->{'status db filename'}.lock" if -f "$main::config->{'status db filename'}.lock"; # release any lock we might have on it
+}
+# create a report and send to STDOUT.
 sub report {
    if ( $main::config->{'flags'}->{'format'} eq 'tsv' ) {
       return &report_tsv( @_ );
    } else {
       return &report_screen( @_ );
+   }
+}
+# report as a tab separated values, no encapulation
 sub report_tsv {
    my ( $header, $data ) = @_;
    my @output;
    push @output, join( "\t", @$header );
    for( my $line = 0; $line < @$data; $line++ ) {
       push @output, join( "\t", @{$data->[$line]} );
    } # for
    return join( "\n", @output ) . "\n";
+}
+# report suitable for screen, with fixed width columns
 sub report_screen {
    my ( $header, $data ) = @_;
    my @output;
    my @widths;
    my $column;
    } # for row
    return $output;
+}
 # scans a node to determine which domains are running on it
+# updates each domain to reflect when it was last seen
 sub getDomainsOnNode {
    my $node = shift;
    my $command = &main::makeCommand( $node, 'virsh list' );
    print "havirt.pm:getDomainsOnNode, command is $command\n" if $main::config->{'flags'}->{'debug'} > 2;
    my @nodeList = grep { /^\s*\d/ } `$command`;
    &readDB();
    unless ( @node ) {
       @node = keys %{$main::statusDB->{'node'} };
       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 ) {
+      foreach my $thisNode ( @node ) {
-      my $command = &main::makeCommand( $thisNode, 'virsh list' );
+         my $command = &main::makeCommand( $thisNode, 'virsh list' );
-      my $output = `$command`;
+         my $output = `$command`;
-      print "findDomain, $thisNode list =\n" . $output . "\n" if $main::config->{'flags'}->{'debug'} > 1;;
+         print "findDomain, $thisNode list =\n" . $output . "\n" if $main::config->{'flags'}->{'debug'} > 1;;
-      return $thisNode if ( $output =~ m/$domainName/ );
+         return $thisNode if ( $output =~ m/$domainName/ );
+      }
+   } else { # not paranoid mode, so just look through the status file
+      foreach my $thisNode ( @node ) {
+         if ( $main::statusDB->{'nodePopulation'}->{$thisNode}->{'running'}->{$domainName} ) {
+            return $thisNode;
+         }
+      }
+   }
    return '';
+}
 # check one or more nodes and determine which domains are running on them.
 # defaults to everything in the node database, but the -t can have it run on only one
 # this is the function that should be run every few minutes on one of the servers
 sub scan {
    my @targets = @_;
-   if ( -f $main::config->{'last scan filename'} && ! $main::config->{'flags'}->{'yes'} ) {
+   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->{'minum scan time'};
+      return "Scan was run $lastScan seconds ago\n" unless $lastScan > $main::config->{'min scan time'};
+   }
    `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'};
+   }
    @targets = keys %{$main::statusDB->{'node'}} unless @targets;
    print "Scanning " . join( "\n", @targets ) . "\n" if $main::config->{'flags'}->{'debug'};
    foreach my $node (@targets) {
+      print "Scanning $node\n" if $main::config->{'flags'}->{'verbose'};
       $main::statusDB->{'nodePopulation'}->{$node}->{'running'} = &getDomainsOnNode( $node );
       $main::statusDB->{'nodePopulation'}->{$node}->{'lastchecked'} = time;
+      print "Found " . @{$main::statusDB->{'nodePopulation'}->{$node}->{'running'}} . " domains on node $node\n" if $main::config->{'flags'}->{'verbose'};
       foreach my $domain ( keys %{$main::statusDB->{'nodePopulation'}->{$node}->{'running'}} ) {
          # make sure there is an entry for all of these domains
          $main::statusDB->{'virt'}->{$domain} = {} unless exists( $main::statusDB->{'virt'}->{$domain} );
+      }
       print Dumper( $main::statusDB->{'nodePopulation'}->{$node} ) if $main::config->{'flags'}->{'debug'} > 2;
       return "ssh $node '$command'";
+   }
+}
 # force a node scan, even if time has not expired
+# do this by setting force to 1, calling scan, then resetting
+# it to old value
 sub forceScan {
-   my $save = $main::config->{'flags'}->{'yes'};
+   my $save = $main::config->{'flags'}->{'force'};
-   $main::config->{'flags'}->{'yes'} = 1;
+   $main::config->{'flags'}->{'force'} = 0;
    &main::scan();
-   $main::config->{'flags'}->{'yes'} = $save;
+   $main::config->{'flags'}->{'force'} = $save;
+}
 # executes command $command, then repeatedly runs virsh list
 # on $scanNode, grep'ing for $scanDomain
-# $condition is 1 (true) or 0 (false)
+# $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 $waitSeconds = 5; # number of seconds to wait before checking again
    my $maxIterations = 60 / $waitSeconds; # maximum number of tries
    print "Running [$command], then waiting $waitSeconds to check if complete\n" if $main::config->{'flags'}->{'debug'};
+}
 # 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
 sub diffArray {
    my ( $arr1, $arr2 ) = @_;
    my @result;
    @$arr1 = sort @$arr1;
    $config->{'script name'} = $FindBin::Script;
    $config->{'db dir'} = $config->{'script dir'} . '/var';
    $config->{'conf dir'} = $config->{'script dir'} . '/conf';
    $config->{'status db filename'} = $config->{'db dir'} . '/status.yaml';
    $config->{'last scan filename'} = $config->{'script dir'} . '/var/lastscan';
-   $config->{'minum scan time'} = 5 * 60; # five minutes
+   $config->{'min scan time'} = 5 * 60; # five minutes
    $config->{'node reserved memory'} = 8 * 1024 * 1024; # 8 gigabytes
    $config->{'node reserved vcpu' } = 0; # turn off reserved vcpu
+   $config->{'paranoid'} = 1; # rescan all nodes on any action which will modify it
+   $config->{'flags'}->{'debug'} = 0;
+   $config->{'flags'}->{'dryrun'} = 1;
+   $config->{'flags'}->{'force'} = 0;
    $config->{'flags'}->{'format'} = 'screen';
-   $config->{'flags'}->{'yes'} = 0;
+   #$config->{'flags'}->{'help'} = 0; # used, but don't put in config file
    $config->{'flags'}->{'quiet'} = 0;
    $config->{'flags'}->{'target'} = '';
-   $config->{'flags'}->{'dryrun'} = 1;
+   $config->{'flags'}->{'verbose'} = 1;
-   $config->{'flags'}->{'debug'} = 0;
-   $config->{'flags'}->{'help'} = 0;
-   $config->{'flags'}->{'version'} = 0;
+   #$config->{'flags'}->{'version'} = 0; # used, but don't put in config file
    my $yaml = YAML::Tiny->new( $config );
    $yaml->write( $filename );
+}
 # read the config file and return it
       $yaml = YAML::Tiny->read( $filename );
+   }
    return $yaml->[0];
+}
-# find available resource on a node
+# find available resource on a node, total RAM and threads
 sub resource {
    my $node = shift;
    die "Can not find node $node in havirt.pm:resource\n"
       unless $main::statusDB->{'node'}->{$node};
    my $return = {
          if defined $main::statusDB->{'node'}->{$node}->{$key};
    } # foreach
    return $return;
+}
+# determine resources used on a node, total RAM and VCPU
 sub getAvailableResources {
    my $node = shift;
    &readDB();
-   die "Can not find node $node in havirt.pm:resource\n"
+   die "Can not find node $node in havirt.pm:resource\n" unless $main::statusDB->{'node'}->{$node};
-      unless $main::statusDB->{'node'}->{$node};
    my $totalResources = &resource( $node );
    print Dumper( $totalResources ) if $main::config->{'flags'}->{'debug'};
    foreach my $domain ( keys %{ $main::statusDB->{'nodePopulation'}->{$node}->{'running'} } ) {
       $totalResources->{'memory'} -= $main::statusDB->{'virt'}->{$domain}->{'memory'};
       $totalResources->{'cpu_count'} -= $main::statusDB->{'virt'}->{$domain}->{'vcpu'};
    my $node = shift;
    &readDB();
    my @return;
    my $nodeResources = &getAvailableResources( $node );
    print "In havirt.pm:validateResources, checking if enough room on $node for\n" . join( "\n", @_ ) . "\n"
-      if ( $main::config->{'flags'}->{'debug'} );
+      if $main::config->{'flags'}->{'debug'};
+   print "Checking resources on $node\n" if $main::config->{'flags'}->{'verbose'};
    # subtract the reserved memory from the node
    $nodeResources->{'memory'} -= $main::config->{'node reserved memory'};
    $nodeResources->{'cpu_count'} -= $main::config->{'node reserved vcpu'} if $main::config->{'node reserved vcpu'};
    while ( my $domain = shift ) {
       $nodeResources->{'memory'} -= $main::statusDB->{'virt'}->{$domain}->{'memory'};
 # migrate domain from current node it is on to $target
 sub migrate {
    my ( $virt, $target ) = @_;
    my $return;
-   my $node;
-   # these are replaced by the safer findDomain
-   #&main::forceScan();
-   #&main::readDB();
-   $node = &main::findDomain( $virt );
+   my $node  = &main::findDomain( $virt );
    print Dumper( $main::statusDB->{'nodePopulation'} ) if $main::config->{'flags'}->{'debug'} > 2;
    die "I can not find $virt on any node\n" unless $node;
    die "Domain $virt in maintenance mode, can not migrate it\n" if $main::statusDB->{'virt'}->{$virt}->{'maintenance'};
    die "Node $target in maintenance mode, can not migrate anything to it\n" if $main::statusDB->{'node'}->{$target}->{'maintenance'};
    die "$virt already on $target\n" if $target eq $node;
    my $command = &main::makeCommand( $node, "virsh migrate --live --persistent --verbose  $virt qemu+ssh://$target/system" );
-   if ( $main::config->{'flags'}->{'yes'} ) { # they want us to actually do it
+   if ( $main::config->{'flags'}->{'dryrun'} ) { # they want us to actually do it
+      $return = $command;
+   } else {
       $return = ( &main::executeAndWait( $command, $node, $virt, 0 ) ? 'Success' : 'Time Out waiting for shutdown');
       &main::forceScan();
-   } else {
-      $return = $command;
+   }
    return "$return\n";
+}

Subversion Repositories havirt

(root)/trunk/havirt.pm – Rev 25 → 26