File Coverage

blib/lib/FusionInventory/Agent/Task/Inventory/HPUX/Memory.pm
Criterion Covered Total %
statement 61 99 61.6
branch 24 48 50.0
condition 0 3 0.0
subroutine 8 10 80.0
pod 0 2 0.0
total 93 162 57.4


line stmt bran cond sub pod time code
1             package FusionInventory::Agent::Task::Inventory::HPUX::Memory;
2              
3 2     2   98921365 use strict;
  2         15  
  2         134  
4 2     2   14 use warnings;
  2         5  
  2         151  
5              
6 2     2   1110 use FusionInventory::Agent::Tools;
  2         5  
  2         459  
7 2     2   1176 use FusionInventory::Agent::Tools::HPUX;
  2         6  
  2         117  
8 2     2   11 use English qw(-no_match_vars);
  2         2  
  2         11  
9              
10             sub isEnabled {
11 0     0 0 0 my (%params) = @_;
12 0 0       0 return 0 if $params{no_category}->{memory};
13 0         0 return 1;
14             }
15              
16             sub doInventory {
17 0     0 0 0 my (%params) = @_;
18              
19 0         0 my $inventory = $params{inventory};
20 0         0 my $logger = $params{logger};
21              
22 0         0 my @memories;
23              
24             # http://forge.fusioninventory.org/issues/754
25 0 0 0     0 if (canRun('/opt/propplus/bin/cprop') && !isHPVMGuest()) {
26 0         0 @memories = _parseCprop(
27             command => '/opt/propplus/bin/cprop -summary -c Memory',
28             logger => $logger
29             );
30             } else {
31 0         0 my $arch = getFirstLine(command => 'uname -m');
32              
33 0 0       0 if ($arch =~ /ia64/ ) {
34             # enable infolog
35 0         0 system("echo 'sc product IPF_MEMORY;info' | /usr/sbin/cstm");
36 0         0 @memories = _parseCstm64(
37             command => "echo 'sc product IPF_MEMORY;il' | /usr/sbin/cstm",
38             logger => $logger
39             );
40             } else {
41 0         0 @memories = _parseCstm(
42             command => "echo 'sc product mem;il'| /usr/sbin/cstm",
43             logger => $logger
44             );
45             }
46             }
47              
48 0         0 my $memorySize;
49 0         0 my $swapSize = getFirstMatch(
50             command => 'swapinfo -dt',
51             logger => $logger,
52             pattern => qr/^total\s+(\d+)/
53             );
54              
55 0         0 foreach my $memory (@memories) {
56 0         0 $inventory->addEntry(
57             section => 'MEMORIES',
58             entry => $memory
59             );
60 0         0 $memorySize += $memory->{CAPACITY};
61             }
62              
63             $inventory->setHardware({
64 0         0 SWAP => int($swapSize / 1024),
65             MEMORY => $memorySize
66             });
67             }
68              
69             sub _parseCprop {
70 1     1   284 my $handle = getFileHandle(@_);
71 1 50       5 return unless $handle;
72              
73 1         2 my @memories;
74             my $instance;
75              
76 1         34 while (my $line = <$handle>) {
77 439 100       1020 if ($line =~ /\[Instance\]: \d+/) {
78             # new block
79 48         67 $instance = {};
80 48         207 next;
81             }
82              
83 391 100       1293 if ($line =~ /^ \s+ \[ ([^\]]+) \]: \s (\S+.*)/x) {
84 288         723 $instance->{$1} = $2;
85 288         887 next;
86             }
87              
88 103 100       310 if ($line =~ /^\*+/) {
89 96 100       283 next unless keys %$instance;
90 48 100       138 next unless $instance->{Size};
91             push @memories, {
92             CAPACITY => getCanonicalSize($instance->{Size}),
93             DESCRIPTION => $instance->{'Part Number'},
94             SERIALNUMBER => $instance->{'Serial Number'},
95 24         72 TYPE => $instance->{'Module Type'},
96             };
97             }
98             }
99 1         38 close $handle;
100              
101 1         11 return @memories;
102             }
103              
104             sub _parseCstm {
105 1     1   18 my $handle = getFileHandle(@_);
106 1 50       5 return unless $handle;
107              
108 1         3 my @memories;
109              
110             my %capacities;
111 1         2 my $capacity = 0;
112 1         2 my $description;
113 1         1 my $numslot = 1;
114 1         2 my $subnumslot;
115 1         32 my $serialnumber = 'No Serial Number available!';
116 1         3 my $type;
117 1         2 my $ok = 0;
118              
119 1         13 while (my $line = <$handle>) {
120              
121 76 50       133 if ($line =~ /FRU\sSource\s+=\s+\S+\s+\(memory/ ) {
122 0         0 $ok = 0;
123             }
124 76 50       201 if ($line =~ /Source\s+Detail\s+=\s4/ ) {
125 0         0 $ok = 1;
126             }
127 76 100       242 if ($line =~ /\s+(\d+)\s+(\d+)/ ) {
128 11         31 $capacities{$1} = $2;
129             }
130 76 50       149 if ($line =~ /Extender\s+Location\s+=\s+(\S+)/ ) {
131 0         0 $subnumslot = $1;
132             };
133 76 50       135 if ($line =~ /DIMMS\s+Rank\s+=\s+(\S+)/ ) {
134 0         0 $numslot = sprintf("%02x",$1);
135             }
136              
137 76 50       138 if ($line =~ /FRU\s+Name\.*:\s+(\S+)/ ) {
138 0 0       0 if ($line =~ /(\S+)_(\S+)/ ) {
    0          
139 0         0 $type = $1;
140 0         0 $capacity = $2;
141             } elsif ($line =~ /(\wIMM)(\S+)/ ) {
142 0         0 $ok = 1;
143 0         0 $type = $1;
144 0         0 $numslot = $2;
145             }
146             }
147 76 50       140 if ($line =~ /Part\s+Number\.*:\s*(\S+)\s+/ ) {
148 0         0 $description = $1;
149             }
150 76 50       276 if ($line =~ /Serial\s+Number\.*:\s*(\S+)\s+/ ) {
151 0         0 $serialnumber = $1;
152 0 0       0 if ( $ok eq 1 ) {
153 0 0       0 if ( $capacity eq 0 ) {
154 0         0 $capacity = $capacities{$numslot};
155             }
156 0         0 push @memories, {
157             CAPACITY => $capacity,
158             DESCRIPTION => "Part Number $description",
159             CAPTION => "Ext $subnumslot Slot $numslot",
160             TYPE => $type,
161             NUMSLOTS => '1',
162             SERIALNUMBER => $serialnumber,
163             };
164 0         0 $ok = 0;
165 0         0 $capacity = 0;
166             } # $ok eq 1
167             } # /Serial\s+Number\.*:\s*(\S+)\s+/
168              
169             }
170 1         8 close $handle;
171              
172 1         8 return @memories;
173             }
174              
175             sub _parseCstm64 {
176 2     2   11731 my $handle = getFileHandle(@_);
177 2 50       6 return unless $handle;
178              
179 2         4 my @memories;
180              
181 2         49 while (my $line = <$handle>) {
182              
183             # this pattern assumes memory slots are correctly
184             # balanced (slot A and slot B are occuped)
185 151 100       600 next unless $line =~ /
186             (\w+IMM)\s+(\w+)\s+(\d+) # first column
187             \s+
188             (\w+IMM)\s+(\w+)\s+(\d+) # second column
189             /x;
190              
191 6         96 push @memories, {
192             CAPACITY => $3,
193             DESCRIPTION => $1,
194             CAPTION => $1 . ' ' . $2,
195             TYPE => $1,
196             NUMSLOTS => $2,
197             }, {
198             CAPACITY => $6,
199             DESCRIPTION => $4,
200             CAPTION => $4 . ' ' . $5,
201             TYPE => $4,
202             NUMSLOTS => $5,
203             };
204             }
205 2         17 close $handle;
206              
207 2         12 return @memories;
208             }
209              
210             1;