get-admin

#!/usr/bin/perl -w
#
# na-aggrSpaceCheck.pl - written by Andrew Sullivan, 2009-06-26
#
# Please report bugs and request improvements at http://get-admin.com/blog/?p=773
#
# My intrepretation of NetApp's aggrSpaceCheck.pl.  This script will
# determine if an aggregate has enough free space to hold the metadata
# for the volumes contained in it when migrating to OnTAP 7.3.
#
# The original script: http://now.netapp.com/NOW/download/tools/aggrSpaceCheck/
#
# I apologize in advance is my refactor of the above script offends anyone
# at NetApp :)
#
# This script uses the OnTAP SDK, available here: 
#   http://communities.netapp.com/docs/DOC-1110
#
 
# I placed the NetApp perl modules into my perl lib directory, however,
# if you haven't done this, you will probably need to specify where they
# are using a lib declaration
#use lib "./NetApp";
 
use NaServer;
use NaElement;
 
use Data::Dumper;
use Getopt::Long qw(:config no_ignore_case);
 
main( );
 
sub main {
	my $opts = parse_options();
	my $server = get_filer( $opts->{ 'hostname' }, $opts->{ 'username' }, $opts->{ 'password' } );
 
	my $aggregates = get_aggregates( $server );
 
	print "found the following aggregates: " . "\n" if $opts->{'verbose'};
	print Dumper($aggregates) if $opts->{'verbose'};
 
	foreach my $key (keys %$aggregates) {
		my $aggr = $aggregates->{ $key };
		my $tax = 0;
 
		# metadata is already in the aggregate if it's a trad vol, so we don't
		# need to check them
		if ($aggr->{'type'} ne "trad") {
 
			foreach my $vol ( @{ $aggr->{'volumes'} } ) {
				if ($vol->{'online'}) {
					if ($vol->{'flexcache'}) {
						# .2%
						$tax += $vol->{'size'} * .002;
					} else {
						# .5%
						$tax += $vol->{'size'} * .005;
					}
				} else {
					print "FlexVol " . $vol->{'name'} . " is not online! \n";
				}
			}
 
			print $key . " needs " . get_printable_size($tax) . ". \n";
 
			if ($tax > $aggr->{'size-available'}) {
				print "The aggregate does not have enough available space! You need \n";
				print get_printable_size($tax - $aggr->{'size-available'}) . " additional capacity in the aggregate.";
			} else {
				print "The aggregate has " . get_printable_size($aggr->{'size-available'}) . " free.";
			}
 
			print "\n\n";
 
		}
	}
}
 
#
# Collect aggregate information for $server
#
sub get_aggregates {
	my $server = shift;
 
	my $request = NaElement->new('aggr-list-info');
	my $result = $server->invoke_elem($request);
 
	my $return = {};
 
	foreach ( $result->child_get('aggregates')->children_get() ) {
		my $name = $_->child_get_string('name');
 
		print "parsing aggregate " . $name . "\n" if $opts->{'verbose'};
 
		my $aggregate = {};
 
		# either trad or aggr: trad = traditional volume, aggr = contains flexvols
		$aggregate->{'type'} = $_->child_get_string('type');
 
		# the size reported as available, duh...
		$aggregate->{'size-available'} = $_->child_get_int('size-available');
 
		# the name is the only thing returned, so we must do another query
		my @volumes = ();
 
		foreach my $volume ($_->child_get('volumes')->children_get()) {
			push(@volumes, get_volume( $server, $volume->child_get_string('name')));
		}
 
		$aggregate->{'volumes'} = \@volumes;
 
		$return->{$name} = $aggregate;
 
	}
 
	return $return;
 
}
 
#
# gets the relavent volume information
#
sub get_volume {
	my ($server, $volume_name) = @_;
 
	print "\tparsing volume " . $volume_name . "\n" if $opts->{'verbose'};
 
	my $return = {};
 
	my $request = NaElement->new('volume-list-info');
	$request->child_add_string('volume', $volume_name);
 
	my $result = $server->invoke_elem($request);
 
	my $vol = $result->child_get('volumes')->child_get('volume-info');
 
	# some basic info about the volume
	$return->{'name'} = $vol->child_get_string('name');
 
	# is the volume online?  There are several other values possible, none of them
	# has the same meaning as online, so they are ignored
	$return->{'online'} = ( $vol->child_get_string('state') eq "online" ? 1 : 0 );
 
	print "\t\tvolume is " . ($return->{'online'} ? "online" : "offline") . "\n" if $opts->{'verbose'};
 
	# if the volume isn't online, we don't need to do any other work
	if ( $return->{'online'} ) {
		# if this is a flexcache volume, this object will exist in the returned
		# values.  Otherwise, it does not exist.
		$return->{'flexcache'} = ( $vol->child_get_string('remote-location') ? 1 : 0 );
 
		print "\t\tvolume " . ($return->{'flexcache'} ? "is" : "is not") . " flexcache\n" if $opts->{'verbose'};
 
		# in order to determine how much metadata the volume could/will have we need
		# to get the container size as reported by wv_fsinfo_blks_total, and we need
		# to calculate an adjusted container size based on the nominal size and a 
		# multiplier based on the type of volume it is.  The larger of those two 
		# values is then taken and used to determine the amount of metadata
 
		# nominal size is simply the size in bytes reported by the volume itself
		$return->{'nominalsize'} = $vol->child_get_int('size-total');
 
		print "\t\tvolume nominal size is " . $return->{'nominalsize'} . "\n" if $opts->{'verbose'};
 
		# blocks is the number of blocks that is reported from the perf object 
		# wv_fsinfo_blks_total counter.  that number is then multiplied by 4096 to
		# determine the number of bytes in the volume
		$return->{'containersize'} = get_vol_containersize( $server, $volume_name );
 
		print "\t\tvolume container size is " . $return->{'containersize'} . "\n" if $opts->{'verbose'};
 
		# we need to query the volume-size object to determine if it's a fixed size.  
		# to determine if it's a snapmirror, use the snapmirror-get-volume-status object.  
		my $is_fixedsize = get_vol_fixedsize( $server, $volume_name );
		my $is_snapmirror = get_vol_snapmirror( $server, $volume_name );
 
		print "\t\tvolume " . ($is_fixedsize ? "is" : "is not") . " fixed size\n" if $opts->{'verbose'};
		print "\t\tvolume " . ($is_snapmirror ? "is" : "is not") . " a snapmirror\n" if $opts->{'verbose'};
 
		if ($is_fixedsize || $is_snapmirror) {
			# this comes directly from the source script
			# four gibibytes...
			my $max_nvram_size_bytes = 1024 * 1024 * 1024 * 4;
 
			if ( 2 * $return->{'nominalsize'} < $max_nvram_size_bytes ) {
				$return->{'adjcontainersize'} = 2 * $return->{'nominalsize'};
			} elsif ( 1.1 * $return->{'nominalsize'} < $max_nvram_size_bytes ) {
				$return->{'adjcontainersize'} = $max_nvram_size_bytes;
			} else {
				$return->{'adjcontainersize'} = 1.1 * $return->{'nominalsize'};
			}
 
			print "\t\tvolume adj container size is " . $return->{'adjcontainersize'} . "\n" if $opts->{'verbose'};
 
			# if the adjusted size is greater than then reported size, then we use the
			# adjusted size for the volume
			if ( $return->{'adjcontainersize'} > $return->{'containersize'} ) {
				print "\t\tvolume adj size is larger than contsize: setting to adj size\n" if $opts->{'verbose'};
				$return->{'size'} = $return->{'adjcontainersize'};
			} else {
				print "\t\tvolume adj size is NOT larger than contsize: setting to adj size\n" if $opts->{'verbose'};
				$return->{'size'} = $return->{'containersize'};
			}
		} else {
			print "\t\tNot snapmirror or fixed, size is containersize\n" if $opts->{'verbose'};
			$return->{'size'} = $return->{'containersize'};
		}
	}
 
	return $return;
}
 
#
# Returns the number of bytes reported by WAFL that the continer occupies
#
sub get_vol_containersize {
	my ($server, $volume_name) = @_;
 
	# since the source script uses the number of blocks reported by wv_fsinfo_blks_total, we have to 
	# query the perf object to get that value
	my $request = NaElement->new('perf-object-get-instances');
	$request->child_add_string('objectname', 'volume');
 
	my $counters = NaElement->new('counters');
	$counters->child_add_string('counter', 'wv_fsinfo_blks_total');
	$request->child_add($counters);
 
	my $instances = NaElement->new('instances');
	$instances->child_add_string('instance', $volume_name);
	$request->child_add($instances);
 
	my $result = $server->invoke_elem($request);
	my $blks_total = $result->child_get('instances')->child_get('instance-data')->child_get('counters')->child_get('counter-data')->child_get_int('value');
 
	return $blks_total * 4096;
 
}
 
#
# Returns true if fixed size volume, false if not
# 
sub get_vol_fixedsize {
	my ($server, $volume_name) = @_;
 
	my $request = NaElement->new('volume-size');
	$request->child_add_string('volume', $volume_name);
 
	my $result = $server->invoke_elem($request);
 
	return ( $result->child_get_string('is-fixed-size-flex-volume') eq "false" ? 0 : 1 );
}
 
#
# Returns true if snapmirror volume, false if not
#
sub get_vol_snapmirror {
	my ($server, $volume_name) = @_;
 
	my $request = NaElement->new('snapmirror-get-volume-status');
	$request->child_add_string('volume', $volume_name);
 
	my $result = $server->invoke_elem($request);
 
	# if the filer is not licensed for snapmirror, this request will fail
	if ($result->results_status() eq "failed" && $result->results_reason() =~ /requires license/) {
		return 0;
	} else {
		return ( $result->child_get_string('is-destination') eq "false" ? 0 : 1 );
	}
 
}
 
#
# Defines and parses the options from the command line, also
# checks to make sure that options are valid.  Will prompt for
# a password if one is not provided.
#
sub parse_options {
 
	my %options = (
		'hostname' => '',
		'username' => '',
		'password' => '',
		'help'     => 0,
		'verbose'  => 0
	);
 
	GetOptions( \%options,
		'hostname|H=s',
		'username|u=s',
		'password|p:s',
		'help|h',
		'verbose+'
	);
 
	if (! $options{ 'hostname' } || ! $options{ 'username' } || $options{ 'help' }) {
		print_usage();
		exit(1);
	}
 
	if (! $options{ 'password' }) {
		print "Enter password: ";
		if ( $^O eq "MSWin32" ) {
			require Term::ReadKey;
 
			Term::ReadKey->import( qw(ReadMode) );
			Term::ReadKey->import( qw(ReadLine) );
			ReadMode('noecho');
 
			chomp( $options{ 'password' } = ReadLine(0) );
 
			ReadMode('normal');
 
		} else {
			system("stty -echo") and die "ERROR: stty failed\n";
 
			chomp ( $options{ 'password' } = <STDIN> );
 
			system("stty echo") and die "ERROR: stty failed\n";
 
		}
 
		print "\n";
	}
 
	return \%options;
}
 
sub print_usage {
	print <<EOU
  Missing or incorrect arguments!
 
  na-aggrSpaceCheck.pl --hostname|-H <hostname> 
            --username|-u <username> 
            --password|-p <password> 
 
EOU
 
}
 
#
# Creates the NaServer object
#
sub get_filer {
	my ($hostname, $username, $password) = @_;
 
	my $s = NaServer->new($hostname, 1, 7);
	$s->set_style(LOGIN_PASSWORD);
	$s->set_admin_user($username, $password);
	$s->set_transport_type(NA_SERVER_TRANSPORT_HTTP);
 
	return $s;
}
 
#
# Taken from the source script, this prints the size of the volume
# is a human readable format
#
sub get_printable_size {
	my $size = shift;
	my $size_string;
 
    # Bytes
    if ($size / 1024 < 1 ) {
		$size_string = sprintf("%d bytes", $size);
    }
 
    # Kilo bytes
    elsif ($size / (1024**2) < 1 ) {
		$size_string = sprintf("%4.2fKB", $size / 1024);
    }
 
    # Mega bytes
    elsif ($size / (1024**3) < 1 ) {
		$size_string = sprintf("%4.2fMB", $size / (1024**2));
    }
 
    # Giga bytes
    elsif ($size / (1024**4) < 1 ) {
		$size_string = sprintf("%4.2fGB", $size / (1024**3));
    }
 
    # Tera bytes
    elsif ($size / (1024**5) < 1 ) {
		$size_string = sprintf("%4.2fTB", $size / (1024**4));
    }
 
    # Peta bytes
    elsif ($size / (1024**6) < 1 ) {
		$size_string = sprintf("%4.2fPB", $size / (1024**5));
    }
 
    else {
		$size_string = sprintf("%d bytes", $size);
    }
 
    return $size_string;
}