File Coverage

blib/lib/Cisco/UCS/Blade.pm

Criterion	Covered	Total	%
statement	27	83	32.5
branch	0	22	0.0
condition	0	9	0.0
subroutine	9	21	42.8
pod	9	10	90.0
total	45	145	31.0

package Cisco::UCS::Blade;

use warnings;
use strict;

use Carp 		qw(croak);
use Scalar::Util 	qw(weaken);
use Cisco::UCS::Blade::Adaptor;
use Cisco::UCS::Blade::CPU;
use Cisco::UCS::Blade::PowerBudget;
use Cisco::UCS::Common::PowerStats;

our $VERSION = '0.50';

our @ATTRIBUTES	= qw(association availability discovery dn model name
operability presence revision serial uuid vendor);

our %ATTRIBUTES = (
	admin_state		=> 'adminState',
	assignment		=> 'assignedToDn',
	conn_path		=> 'connPath',
	conn_status		=> 'connStatus',
	cores_enabled		=> 'numOfCoresEnabled',
	chassis			=> 'chassisId',
	checkpoint		=> 'checkPoint',
	description		=> 'descr',
	id			=> 'slotId',
	managing_instance	=> 'managingInst',
	memory_speed		=> 'memorySpeed',
	memory_available	=> 'availableMemory',
	memory_total		=> 'totalMemory',
	num_adaptors		=> 'numOfAdaptors',
	num_cores		=> 'numOfCores',
	num_cpus		=> 'numOfCpus',
	num_eth_ifs		=> 'numOfEthHostIfs',
	num_fc_ifs		=> 'numOfFcHostIfs',
	num_threads		=> 'numOfThreads',
	oper_power		=> 'operPower',
	oper_state		=> 'operState',
	server_id		=> 'serverId',
	slot_id			=> 'slotId',
	user_label		=> 'usrLbl',
	uuid_original		=> 'originalUuid'
);

sub new {
	my ($class, %args) = @_;
	my $self = {};
	bless $self, $class;

	defined $args{dn}
		? $self->{dn} = $args{dn}
		: croak 'dn not defined';

	defined $args{ucs}
		? weaken($self->{ucs} = $args{ucs})
		: croak 'dn not defined';

	my %attr = %{ $self->{ucs}->resolve_dn(
				dn => $self->{dn})->{outConfig}->{computeBlade}
		};

	while ( my ($k, $v) = each %attr ) { $self->{$k} = $v }

	return $self
}

{
        no strict 'refs';

        while ( my ( $pseudo, $attribute ) = each %ATTRIBUTES ) {
                *{ __PACKAGE__ . '::' . $pseudo } = sub {
                        my $self = shift;
                        return $self->{$attribute}
                }
        }

        foreach my $attribute ( @ATTRIBUTES ) {
                *{ __PACKAGE__ . '::' . $attribute } = sub {
                        my $self = shift;
                        return $self->{$attribute}
                }
        }
}

sub led {
	my ( $self, $state ) = @_;

	$state = lc $state;
	$state eq 'on' || $state eq 'off' or return;
	my $req = <




        dn="sys/chassis-$self->{chassisId}/blade-$self->{slotId}/locator-led"
        id="1" name="" >




XML

	my $xml = $self->{ucs}->_ucsm_request( $req );

	if ( defined $xml->{'errorCode'} ) {
		my $self->{error} =
			( defined $xml->{'errorDescr'}
				? $xml->{'errorDescr'}
				: "Unspecified error"
			);

		print "got error: $self->{error}\n";
		return
	}

	return 1
}

sub power_stats {
	my $self = shift;

	return Cisco::UCS::Common::PowerStats->new(
			$self->{ucs}->resolve_dn(
					dn => "$self->{dn}/board/power-stats"
				)->{outConfig}->{computeMbPowerStats}
		)
}

sub power_budget {
	my $self = shift;

	return Cisco::UCS::Blade::PowerBudget->new(
			$self->{ucs}->resolve_dn(
					dn => "$self->{dn}/budget"
				)->{outConfig}->{powerBudget}
	)
}

sub cpu {
	my ( $self, $id ) = @_;

	return (
		defined $self->{cpu}->{$id}
			? $self->{cpu}->{$id}
			: $self->get_cpus( $id )
	)
}

sub get_cpu {
	my ( $self, $id ) = @_;

	return (
		$id 	? $self->get_cpus( $id )
			: undef
	)
}

sub get_cpus {
	my ( $self, $id ) = @_;

	my $cpus = $self->{ucs}->resolve_children(
					dn => "$self->{dn}/board"
				)->{outConfigs}->{processorUnit};
	my @cpus;

	while ( my ( $cid, $cpu ) = each %$cpus ) {
		$cpu->{id} = $cid;
		$cpu = Cisco::UCS::Blade::CPU->new( $self->{ucs}, $cpu );
		push @cpus, $cpu;
		$self->{cpu}->{$cid} = $cpu;
		return $cpu if ( defined $id and $cid == $id )
	}

	return @cpus;
}

sub adaptor {
	my ( $self, $id ) = @_;

	return (
		defined $self->{adaptor}->{$id}
			? $self->{adaptor}->{$id}
			: $self->get_adaptors( $id )
	)
}

sub get_adaptor {
	my ( $self, $id ) = @_;

	return (
		$id ? $self->get_adaptors( $id )
		: undef
	)
}


sub get_adaptors {
	my ( $self, $id ) = @_;

	my $adaptors = $self->{ucs}->resolve_children(
					dn => "$self->{dn}"
				)->{outConfigs}->{adaptorUnit};
	my @adaptors;

	while ( my ( $aid, $adaptor ) = each %$adaptors ) {
		$adaptor->{id} = $aid;
		$adaptor = Cisco::UCS::Blade::Adaptor->new( $self->{ucs}, $adaptor );
		push @adaptors, $adaptor;
		$self->{adaptor}->{$aid} = $adaptor;
		return $adaptor if ( defined $id and $aid == $id )
	}

	return @adaptors;
}

1;
__END__