Subversion Repositories havirt

# v1.3.0 20250511 RWR

# Added balance function. If called, will attempt to balance a cluster so that the variance is lower than balance_max_variance 

# (new entry in config file). --dryrun will simply display the commands sent, and --nodryrun will execute them.

   push @return, 'cluster balance';

   push @return, "\tAttempts to balance node memory usage by migrating domains to less used";

   push @return, "\tnodes. If a node is in maintenance mode, will attempt to move all domains";

   push @return, "\toff of it and balance them on the other nodes";

# calculate stats about the cluster, including the amount of memory/cpu used, the standard deviation

# and variance. Used mainly to balance cluster

sub getClusterStats {

   my $return = {};

   $return->{'cluster'}->{'memory'} = 0;

   $return->{'cluster'}->{'used_memory'} = 0;

   $return->{'cluster'}->{'count'} = 0;

   $return->{'cluster'}->{'used_vcpu'} = 0;

   $return->{'cluster'}->{'domain_count'} = 0;

   foreach my $node (sort keys %{ $main::statusDB->{'node'} } ) {

      # only count nodes which are not in maintenance as part of the cluster towards total memory available

      if ( ! $main::statusDB->{'node'}->{$node}->{'maintenance'} ) {

         $return->{'cluster'}->{'memory'} += $main::statusDB->{'node'}->{$node}->{'memory'};

         $return->{'cluster'}->{'vcpu'} += $main::statusDB->{'node'}->{$node}->{'cpu_count'};

         $return->{'cluster'}->{'count'}++;

      } else {

         $return->{'node'}->{$node}->{'maintenance'} = 1;

      }

      $return->{'node'}->{$node}->{'memory'} = $main::statusDB->{'node'}->{$node}->{'memory'};

      $return->{'node'}->{$node}->{'vcpu'} = $main::statusDB->{'node'}->{$node}->{'cpu_count'};

      $return->{'node'}->{$node}->{'used_memory'} = 0;

      $return->{'node'}->{$node}->{'count'} = 0;

      $return->{'node'}->{$node}->{'used_vcpu'} = 0;

      # get individual stats for every domain on the node

      foreach my $domain ( keys %{ $main::statusDB->{'nodePopulation'}->{$node}->{'running'} } ) {

         # track used memory, and count

         $return->{'node'}->{$node}->{'used_memory'} += $main::statusDB->{'virt'}->{$domain}->{'memory'};

         $return->{'node'}->{$node}->{'used_vcpu'} += $main::statusDB->{'virt'}->{$domain}->{'vcpu'};

         $return->{'node'}->{$node}->{'count'}++;

      }

      # calculate the average memory used in the node

      $return->{'node'}->{$node}->{'average_memory'} = $return->{'node'}->{$node}->{'used_memory'} / 

         (

            $main::statusDB->{'node'}->{$node}->{'maintenance'} ? 0.0001 : $main::statusDB->{'node'}->{$node}->{'memory'}

         );

      # add the used memory to the cluster

      $return->{'cluster'}->{'used_memory'} += $return->{'node'}->{$node}->{'used_memory'};

      $return->{'cluster'}->{'used_vcpu'} += $return->{'node'}->{$node}->{'used_vcpu'};

      $return->{'cluster'}->{'domain_count'} += $return->{'node'}->{$node}->{'count'};

   }

   # calculate the deviation for each active node in the cluster

   $return->{'cluster'}->{'average_memory'} = $return->{'cluster'}->{'used_memory'} / $return->{'cluster'}->{'memory'};

   # get the deviation for each node

   # variance in the cluster is simply the average of all deviations

   $return->{'cluster'}->{'variance'} = 0;

   foreach my $node (sort keys %{ $main::statusDB->{'node'} } ) {

      # deviation is the square of the difference between this node and the cluster overall

      $return->{'node'}->{$node}->{'deviation'} = (

         $return->{'node'}->{$node}->{'average_memory'} / $return->{'cluster'}->{'average_memory'} 

         ) ** 2;

      # we'll divide by number of active nodes after the loop

      $return->{'cluster'}->{'variance'} += $return->{'node'}->{$node}->{'deviation'};

   }

   $return->{'cluster'}->{'variance'} /= $return->{'cluster'}->{'count'};

   # now, determine how much memory needs to be added (plus) or removed (minus) for each node

   # memory_needed is calculated by taking the total amount of memory and multiplying it by the cluster average memory

   # then subtracting whatever is already used

   foreach my $node (sort keys %{ $main::statusDB->{'node'} } ) {

      if ( $main::statusDB->{'node'}->{$node}->{'maintenance'} ) {

         $return->{'node'}->{$node}->{'memory_needed'} = -1 * $return->{'node'}->{$node}->{'used_memory'};

      } else {

         $return->{'node'}->{$node}->{'memory_needed'} = int (

            ( $return->{'node'}->{$node}->{'memory'} * $return->{'cluster'}->{'average_memory'} ) -

            $return->{'node'}->{$node}->{'used_memory'} 

            );

      }

   }

   return $return;

}

sub humanReadable {

   my ( $value, $preferredUnits ) = @_;

   $value *= 1024;

   my @units =  ( '', 'k', 'M', 'G', 'T' );

   $preferredUnits = $units[-1] unless $preferredUnits;

   my $unit = 0;

   while ( $unit < @units && abs($value) > 1023 && lc $units[$unit] ne lc $preferredUnits ) {

      $unit++;

      $value /= 1024;

   }

   return sprintf( '%d%s', $value+0.5, $units[$unit] );

}

sub percent {

   my ($value, $accuracy) = @_;

   $accuracy = 0 unless $accuracy;

   return sprintf( '%2.' . $accuracy . 'f%%', $value * 100)

}

         &humanReadable( $stats->{'node'}->{$node}->{'memory_needed'} ),

         '',

      ( $stats->{'cluster'}->{'variance'} < 100 ? sprintf( "%2.2f", $stats->{'cluster'}->{'variance'} + .005 ) : "undef" ) . "\n\n";

}

# simulates performing migrations. Simply moves entries from $from to $to in $main::statusDB->{'nodePopulation'}

sub doActions {

   my $actions = shift;

   my $return;

   for ( my $i = 0; $i < @$actions; $i++ ) {

      my ($domain, $source, $target, $size ) = split( "\t", $actions->[$i] );

      $return .= &main::migrate( $domain, $target, $source );

      delete $main::statusDB->{'nodePopulation'}->{$source}->{'running'}->{$domain};

      $main::statusDB->{'nodePopulation'}->{$target}->{'running'}->{$domain} = time;

   }

   &main::forceScan() unless $main::config->{'flags'}->{'dryrun'} || $main::config->{'flags'}->{'testing'};

   return $return;

   my $return;

   print "=== Starting Status ===\n\n" . &showBalanceReport( $cluster) unless $main::config->{'flags'}->{'quiet'};

   # we will do a loop to get the variance within our preferred range ($main::config->{ 'balance variance'})

   # however, we will only do a maximum number of iterations ($main::config->{ 'balance maxiterations'})

   my $iterations = defined $main::config->{ 'balance_max_iterations'} && $main::config->{ 'balance_max_iterations'} ? $main::config->{ 'balance_max_iterations'} : 10;

   $main::config->{ 'balance_max_variance'} = 1.1 unless defined $main::config->{ 'balance_max_variance'};

   # continue until our variance is where we want it, or we have tried too many times.

   while ( $iterations-- && $cluster->{'cluster'}->{'variance'} > $main::config->{ 'balance_max_variance'} ) {

      print &showBalanceReport( $cluster) if $main::config->{'flags'}->{'verbose'} > 1;

   print "=== Ending Status ===\n\n" . &showBalanceReport( $cluster) unless $main::config->{'flags'}->{'quiet'};

   return $return;

} # balance

# finds node which needs to lose ($from) and gain ($to) the most. Then, goes through $from and finds the largest

# domain which will fit on $to until exhausted.

# as each domain is found, appends to $actions (array pointer). The format of each entry is a tab separated

# list of domain name, node from, node to, domain size

# returns the modified $actions

sub moveThings {

   my $stats = shift;

   my $actions = [];

   # find largest and smallest node differences

   my $transfer;

   my $from = '';

   my $to = '';

   # find smallest and largest "memory needed" in group. Note that if a node has too much, the number is negative and

   # for too little (ie, needs additional), the number is positive

   foreach my $node (keys %{$stats->{'node'} } ) {

      #print "Checking $node\n";

      if ( $from ) {

         $from = $node if $stats->{'node'}->{$from}->{'memory_needed'} > $stats->{'node'}->{$node}->{'memory_needed'};

         $to = $node if $stats->{'node'}->{$to}->{'memory_needed'} < $stats->{'node'}->{$node}->{'memory_needed'};

      } else { # just initialize everything to this node

         $from = $to = $node;

      } #if .. else

   } # foreach

   # this is a poor mans min. we want to transfer the least number of bytes, ie what $from can spare, or what $to can accept

   # we need the smallest of what $from can give and $to can accept

   $transfer = abs( abs( $stats->{'node'}->{$from}->{'memory_needed'} ) > abs( $stats->{'node'}->{$to}->{'memory_needed'} ) ?

               $stats->{'node'}->{$to}->{'memory_needed'} : $stats->{'node'}->{$from}->{'memory_needed'} );

   # die "Transfer " . &humanReadable($transfer) ." bytes from $from to $to\n";

   # get array of domains running on $from, sorted by the size of the domain (descending, ie largest on top )

   # basically, get all keys from $main::statusDB->{'nodePopulation'}->{$from}->{'running'}, then sort them by looking them

   # up in $main::statusDB->{'virt'} and retrieving the amount of RAM

   my @sortedDomains = sort

         $main::statusDB->{'virt'}->{$b}->{'memory'} <=> $main::statusDB->{'virt'}->{$a}->{'memory'}

      } keys %{ $main::statusDB->{'nodePopulation'}->{$from}->{'running'} };

   # now, "move" (fake move) largest domain that will fit into $to, and repeat until we can not do it anymore

      last unless $thisDomain; # we ran out of domains

      next unless $main::statusDB->{'virt'}->{$thisDomain}->{'memory'} <= $transfer;

      push @$actions, join( "\t", ( $thisDomain, $from, $to, $main::statusDB->{'virt'}->{$thisDomain}->{'memory'} ) );

      $transfer -= $main::statusDB->{'virt'}->{$thisDomain}->{'memory'};

   }

   return $actions;