File Coverage

blib/lib/Lustre/Info/OST.pm

Criterion	Covered	Total	%
statement	9	79	11.3
branch	0	28	0.0
condition	0	9	0.0
subroutine	3	17	17.6
pod	11	13	84.6
total	23	146	15.7

#
# Lustre OST/OSS subclass
#
# (C) 2010 Adrian Ulrich -
#
# This program is free software; you can redistribute it and/or
# modify it under the same terms as Perl itself.
#
#
package Lustre::Info::OST;
use strict;
use warnings;
use constant PROCFS_OBDFILTER => '/proc/fs/lustre/obdfilter';

my @TRACK_FIELDS = qw(write_bytes read_bytes create destroy setattr ping preprw);

sub new {
	my($classname, %args) = @_;
	my $self = { super=>$args{super}, ostname=>$args{ostname}, procpath=>PROCFS_OBDFILTER."/$args{ostname}", ost_stats=> [ {}, {} ], client_stats=>{} };
	bless($self,$classname);
	return ( -d $self->{procpath} ? $self : undef );
}


##########################################################################
# Return name of OST
sub get_name {
	my($self) = @_;
	return $self->{ostname};
}

##########################################################################
# Return the size of this OST
sub get_kbytes_total { return $_[0]->_rint('kbytestotal'); }

##########################################################################
# Return how much space is free
sub get_kbytes_free { return $_[0]->_rint('kbytesfree'); }

##########################################################################
# # of pre-allocated inodes (at mkfs.lustre runtime)
sub get_files_total { return $_[0]->_rint('filestotal'); }

##########################################################################
# How many files/inodes are free
sub get_files_free { return $_[0]->_rint('filesfree'); }

##########################################################################
# Returns the name of the hosting blockdevice
sub get_blockdevice { return $_[0]->_rint('mntdev'); }

##########################################################################
# Parse and return information about the last recovery procedure
sub get_recovery_info {
	my($self) = @_;
	return $self->{super}->_parse_generic_file($self->{procpath}."/recovery_status");
}

##########################################################################
# Update stats of this OST
sub collect_ost_stats {
	my($self) = @_;
	my $data  = $self->{super}->_parse_stats_file($self->{procpath}."/stats");
	my $stats = $self->{ost_stats};
	shift(@$stats);
	push(@{$stats}, $data);
	return $stats;
}

##########################################################################
# Return stats for this OST
sub get_ost_stats {
	my($self) = @_;

	my $a = $self->{ost_stats}->[0];
	my $b = $self->{ost_stats}->[1];
	my $r = {};
	return undef if !exists($a->{data}); # not enough data
	return undef if !exists($b->{data});

	$r->{_slice} = $b->{timestamp} - $a->{timestamp};
	foreach my $k (@TRACK_FIELDS) {
		$r->{$k} = $b->{data}->{$k}->{count} - $a->{data}->{$k}->{count} if
		    exists($a->{data}->{$k}) && exists($b->{data}->{$k});
	}
	return $r;
}


##########################################################################
# Collect statistics for ALL connected clients of this OST. This is expensive!
sub collect_client_stats {
	my($self, $clist) = @_;

	$clist = $self->get_exports if !$clist;

	foreach my $eid (@$clist) {
		my $data = $self->{super}->_parse_stats_file($self->{procpath}."/exports/$eid/stats") or next;
		if(!exists($self->{client_stats}->{$eid})) {
			$self->{client_stats}->{$eid} = [ {}, {} ]; # init empty struct on first run
		}

		my $ref = $self->{client_stats}->{$eid};
		shift(@$ref);
		push(@$ref, $data);
	}
	return $self->{client_stats}; # return most recent entry.
}

##########################################################################
# Returns statistics for all clients on this OST
sub get_client_stats {
	my($self) = @_;

	my $r = {};
	foreach my $eid (keys(%{$self->{client_stats}})) {
		my $this_ref = $self->{client_stats}->{$eid};  # holds: [ {timestamp=>0, data=>{}}, {timestamp=>0, data=>{}} ]
		my $a        = $this_ref->[0];
		my $b        = $this_ref->[1];
		next if !exists($a->{data}) or !exists($b->{data}); # all zero or not enough data;

		$r->{$eid}->{_slice} = $b->{timestamp} - $a->{timestamp};
		map { $r->{$eid}->{$_} = 0 } @TRACK_FIELDS;

		foreach my $k (@TRACK_FIELDS) {
			$r->{$eid}->{$k} = $b->{data}->{$k}->{count} - $a->{data}->{$k}->{count} if
			   exists($a->{data}->{$k}) && exists($b->{data}->{$k});
		}
	}
	return $r;
}

##########################################################################
# Returns a list to all 'known' exports of this OST
sub get_exports {
	my($self) = @_;

	my @list = ();
	opendir(PD, $self->{procpath}."/exports/") or return \@list;
	while(defined(my $dirent = readdir(PD))) {
		next if $dirent eq '.';
		next if $dirent eq '..';
		next unless -d $self->{procpath}."/exports/$dirent";
		push(@list,$dirent);
	}
	closedir(PD);
	return \@list;
}



##########################################################################
# Return an integer
sub _rint {
	my($self,$procfile) = @_;
	open(PF, $self->{procpath}."/$procfile") or return -1;
	my $num = ; chomp($num);
	close(PF);
	return $num;
}


1;
__END__