Subversion Repositories sysadmin_scripts

#! /usr/bin/env perl

use strict;

use warnings;

#use experimental "switch";

# requires File::Slurp. 

# In Debian derivatives

# apt install libfile-slurp-perl

# apt install libxml-libxml-perl libyaml-tiny-perl

BEGIN {

   use FindBin;

   use File::Spec;

   # use libraries from the directory this script is in

   use lib File::Spec->catdir($FindBin::Bin);

}

use Data::Dumper;

use YAML::Tiny;

# global variables

my $scriptDir = $FindBin::RealBin;

my $scriptName = $FindBin::Script;

my $confDir = "$scriptDir/conf";

my $dbDir = "$scriptDir/var";

my $nodeDBName = "$dbDir/node.yaml";

my $virtualDBName = "$dbDir/virtuals.yaml";

my $nodePopulationDBName = "$dbDir/node_population.yaml";

# these contain the values from the databases

# loaded on demand

my $nodeDB;

my $virtDB;

my $nodePopulations;

my $dryRun = 1;

my $DEBUG = 0;

sub help {

   print "$0 command [argument]\n";

   print "where command is one of\n";

   print "\tnode update [node] [node]... # update a given node (or ALL)\n";

   print "\tnode list # display tab delimited list of node specs\n";

   print "\tnode scan # find virtuals on all nodes\n ";

   print "\tvirtual update ALL|RUNNING|[virtual] [virtual]... # update virtuals\n";

}

sub readDB {

   my ($filename) = @_;

   my $yaml = YAML::Tiny->new( {} );

   if ( -f $filename ) {

      $yaml = YAML::Tiny->read( $filename );

   }

   return $yaml->[0];

}

sub writeDB {

   my ($filename,$data) = @_;

   my $yaml = YAML::Tiny->new( $data );

   $yaml->write( $filename );

}

sub loadVirtDB {

   return if $virtDB;

   $virtDB = &readDB( $virtualDBName );

}

sub loadNodePopulations {

   return if $nodePopulations;

   $nodePopulations = &readDB( $nodePopulationDBName );

}

sub loadNodeDB {

   return if $nodeDB;

   $nodeDB = &readDB( $nodeDBName );

}

sub virtual {

   my $action = lc shift;

   my $return = '';

   &loadVirtDB();

   &loadNodePopulations();

   @_ = keys( %$virtDB ) if ( $_[0] && $_[0] eq 'ALL' );

   if ( $_[0] && $_[0] eq 'RUNNING' ) {

      my @running;

      foreach my $node ( keys %$nodePopulations ) {

         push @running, keys %{ $nodePopulations->{$node}->{'running'} };

      }

      @_ = @running;

   }

   if ( $action eq 'update' ) { # download xml to var and update database

      while ( my $virt = shift ) {

         &parseVirtual( $virt );

      } # while

      &writeDB( $virtualDBName, $virtDB );

   } elsif ( $action eq 'list' ) { # dump virtual as a tab separated data file

      my @return;

      foreach my $node ( keys %$nodePopulations ) {

         foreach my $virt (keys %{$nodePopulations->{$node}->{'running'}} ) {

            push @return, &listVirtual( $virt, $node );

         }

      }

      $return = join( "\n", sort @return ) . "\n";;

   }

   return $return;;

} # sub virtual

sub listVirtual {

   my ($virt,$node) = @_;

   my @return;

   push @return, $virt;

   push @return, $node;

   foreach my $column ( sort keys %{ $virtDB->{$virt} } ) {

      push @return, $virtDB->{$virt}->{$column};

   }

   return join( "\t", @return);

}

# get the XML definition file of a running virtual off of whatever

# node it is running on, and save it to disk

sub getVirtConfig {

   my ($virt,$filename) = @_;

   my $return;

   print "In getVirtConfig looking for $virt with file $filename\n" if $DEBUG;

   if ( -f $filename ) {

      open XML, "<$filename" or die "Could not read from $filename: $!\n";

      $return = join( '', <XML> );

      close XML;

   } else {

      &loadNodePopulations();

      #die Dumper( $nodePopulations );

      foreach my $node ( keys %$nodePopulations ) {

         print "getVirtConfig Looking on $node for $virt\n";

         if ( exists( $nodePopulations->{$node}->{'running'}->{$virt} ) ) { # we found it

            print "Found $virt on node $node\n";

            $return = `ssh $node 'virsh dumpxml $virt'`;

            open XML,">$filename" or die "Could not write to $filename: $!\n";

            print XML $return;

            close XML;

         } # if

      } # foreach

   } # if..else

   return $return;

} # sub getVirtConfig

sub getXMLValue {

   my ( $key, $string ) = @_;

   my $start = "<$key";

   my $end = "</$key>";

   $string =~ m/$start([^>]*)>([^<]+)$end/;

   return ($1,$2);

}

sub parseVirtual {

   my ($virt, $nodePopulations ) = @_;

   my @keysToSave = ( 'uuid', 'memory', 'vcpu' );

   my $filename = "$confDir/$virt.xml";

   my $xml = &getVirtConfig( $virt, $filename );

   my ($param,$value) = &getXMLValue( 'uuid', $xml );

   $virtDB->{$virt}->{'uuid'} = $value;

   ($param,$value) = &getXMLValue( 'memory', $xml );

   $virtDB->{$virt}->{'memory'} = $value;

   ($param,$value) = &getXMLValue( 'vcpu', $xml );

   $virtDB->{$virt}->{'vcpu'} = $value;

   $xml =~ m/type='vnc' port='(\d+)'/;

   $virtDB->{$virt}->{'vnc'} = $1;

}

sub getVirtualsOnNode {

   my $node = shift;

   my @nodeList = grep { /^\s*\d/ } `ssh $node 'virsh list'`;

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

      if ( $nodeList[$i] =~ m/\s*\d+\s*([^ ]+)/ ) {

         $nodeList[$i] = $1;

      }

   }

   my %hash = map{ $_ => time } @nodeList;

   return \%hash;

}

sub node {

   my $action = lc shift;

   my %conversion = ( 

     'CPU frequency' => 'clock',

     'CPU model' => 'cpu_model',

     'CPU socket(s)' => 'cpu_socket',

     'CPU(s)' => 'cpu_count',

     'Core(s) per socket' => 'cpu_cores',

     'Memory size' => 'memory',

     'NUMA cell(s)' => 'numa_cells',

     'Thread(s) per core' => 'threads_per_core'

   );

   print "In node, action is $action\n" if $DEBUG;

   my $return = '';

   &loadNodeDB();

   if ( $action eq 'update' ) { # read information for nodes and update database

      @_ = keys %$nodeDB if ( $_[0] eq 'ALL' );

      while ( my $nodename = shift ) {

         print "Updating $nodename\n" if $DEBUG;

         $return = `ssh $nodename 'virsh nodeinfo'`;

         print "Output of ssh $nodename 'virsh nodeinfo' is\n" . $return if $DEBUG;

         my @nodeinfo = split( "\n", $return );

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

            my ($key, $value) = split( /:\s+/, $nodeinfo[$i] );

            if ( $value =~ m/^(\d+)\s+[a-z]+$/i ) {

               $value = $1;

            }

            $key = $conversion{$key} if exists( $conversion{$key} );

            $nodeDB->{$nodename}->{$key} = $value;

         } # for

      } # while

      print "nodeDB state after update\n" . Dumper( $nodeDB ) if $DEBUG;

      &writeDB( $nodeDBName, $nodeDB );

   } elsif ( $action eq 'list' ) { # dump database as a tab separated file with headers

      my @return;

      foreach my $node ( sort keys %$nodeDB ) {

         @return[0] = "Node\t" . join( "\t", sort keys %{ $nodeDB->{$node} } ) unless @return;

         my @line;

         push @line, $node;

         foreach my $column (sort keys %{ $nodeDB->{$node} }) {

            push @line, $nodeDB->{$node}->{$column};

         }

         push @return, join( "\t", @line );

      }

      $return = join( "\n", @return ) . "\n";

   } elsif ( $action eq 'scan' ) {

      foreach my $node ( keys %$nodeDB ) {

         $nodePopulations->{$node}->{'running'} = &getVirtualsOnNode( $node );

         $nodePopulations->{$node}->{'lastchecked'} = time;

      }

      &writeDB( $nodePopulationDBName,$nodePopulations );

   } # if..elsif

   return $return;

}

#my $config = &readConf( $confFile );

my $command = shift; # the first one is the actual subsection

my $action = shift; # second is action to run

if ( $command eq 'node' ) {

   print &node( $action, @ARGV );

} elsif ( $command eq 'virtual' ) {

   print &virtual( $action, @ARGV );

} else {

   &help();

}

1;