Merge remote-tracking branch 'upstream/master' into CloudAmazon

centreon-plugins/README.md

@@ -1,4 +1,5 @@
 # centreon-plugins
+
 “centreon-plugins” is a free and open source project to monitor systems. The project can be used with Centreon and all monitoring softwares compatible with Nagios plugins.
 
 You can monitor many systems:
@@ -8,7 +9,7 @@ You can monitor many systems:
 * hardware: printers (rfc3805), UPS (Powerware, Mge, Standard), Sun Hardware, Cisco UCS, SensorIP, HP Proliant, HP Bladechassis, Dell Openmanage, Dell CMC, Raritan,...
 * network: Aruba, Brocade, Bluecoat, Brocade, Checkpoint, Cisco AP/IronPort/ASA/Standard, Extreme, Fortigate, H3C, Hirschmann, HP Procurve, F5 BIG-IP, Juniper, PaloAlto, Redback, Riverbed, Ruggedcom, Stonesoft,...
 * os: Linux (SNMP, NRPE), Freebsd (SNMP), AIX (SNMP), Solaris (SNMP)...
-* storage: EMC Clariion, Netapp, HP MSA p2000, Dell EqualLogic, Qnap, Panzura, Synology...
+* storage: EMC Clariion, Netapp, Nimble, HP MSA p2000, Dell EqualLogic, Qnap, Panzura, Synology...
 
 ## Basic Usage
 

centreon-plugins/apps/elasticsearch/mode/cluster.pm

@@ -44,9 +44,9 @@ sub new {
     $options{options}->add_options(arguments =>
         {
             "hostname:s"              => { name => 'hostname' },
-            "port:s"                  => { name => 'port', default => '9200'},
+            "port:s"                  => { name => 'port', default => 9200 },
             "proto:s"                 => { name => 'proto' },
-            "urlpath:s"               => { name => 'url_path' },
+            "urlpath:s"               => { name => 'url_path', default => '/_cluster/health' },
             "credentials"             => { name => 'credentials' },
             "username:s"              => { name => 'username' },
             "password:s"              => { name => 'password' },
@@ -77,7 +77,6 @@ sub check_options {
         push @{$self->{overload_th}->{$section}}, {filter => $filter, status => $status};
     }
     
-    $self->{option_results}->{url_path} = $self->{option_results}->{url_path} . "_cluster/health/";
     $self->{http}->set_options(%{$self->{option_results}});
 }
 
@@ -176,7 +175,7 @@ Specify https if needed (Default: 'http')
 
 =item B<--urlpath>
 
-Set path to get Elasticsearch information (Default: '/')
+Set path to get Elasticsearch information (Default: '/_cluster/health')
 
 =item B<--credentials>
 

centreon-plugins/apps/elasticsearch/mode/indices.pm

@@ -51,9 +51,9 @@ sub new {
     $options{options}->add_options(arguments =>
         {
             "hostname:s"              => { name => 'hostname' },
-            "port:s"                  => { name => 'port', default => '9200'},
+            "port:s"                  => { name => 'port', default => 9200 },
             "proto:s"                 => { name => 'proto' },
-            "urlpath:s"               => { name => 'url_path' },
+            "urlpath:s"               => { name => 'url_path', default => '/_cluster/health' },
             "credentials"             => { name => 'credentials' },
             "username:s"              => { name => 'username' },
             "password:s"              => { name => 'password' },
@@ -84,8 +84,7 @@ sub check_options {
         push @{$self->{overload_th}->{$section}}, {filter => $filter, status => $status};
     }
 
-    $self->{option_results}->{url_path} = $self->{option_results}->{url_path} . "_cluster/health";
+    $self->{option_results}->{get_param} = [ 'level=indices' ];
-    $self->{option_results}->{get_param} = ['level=indices'];
     $self->{http}->set_options(%{$self->{option_results}});
 }
 
@@ -172,7 +171,7 @@ Specify https if needed (Default: 'http')
 
 =item B<--urlpath>
 
-Set path to get Elasticsearch information (Default: '/')
+Set path to get Elasticsearch information (Default: '/_cluster/health')
 
 =item B<--credentials>
 

centreon-plugins/apps/elasticsearch/mode/nodescount.pm

@@ -36,9 +36,9 @@ sub new {
     $options{options}->add_options(arguments =>
         {
             "hostname:s"        => { name => 'hostname' },
-            "port:s"            => { name => 'port', default => '9200'},
+            "port:s"            => { name => 'port', default => 9200 },
             "proto:s"           => { name => 'proto' },
-            "urlpath:s"         => { name => 'url_path' },
+            "urlpath:s"         => { name => 'url_path', default => '/_cluster/stats' },
             "credentials"       => { name => 'credentials' },
             "username:s"        => { name => 'username' },
             "password:s"        => { name => 'password' },
@@ -64,7 +64,6 @@ sub check_options {
        $self->{output}->option_exit();
     }
 
-    $self->{option_results}->{url_path} = $self->{option_results}->{url_path} . "_cluster/stats/";
     $self->{http}->set_options(%{$self->{option_results}});
 }
 
@@ -141,7 +140,7 @@ Specify https if needed (Default: 'http')
 
 =item B<--urlpath>
 
-Set path to get Elasticsearch information (Default: '/')
+Set path to get Elasticsearch information (Default: '_cluster/stats')
 
 =item B<--credentials>
 

centreon-plugins/apps/kayako/api/mode/ticketcount.pm

@@ -140,7 +140,7 @@ sub reload_cache {
 	my $salt = '';
     $salt .= int(rand(10)) for 1..10;
     my $digest = hmac_sha256_base64 ($salt, $self->{option_results}->{kayako_secret_key});
-	my $webcontent = $self->{http}->request(url_path => $url_original_path . "/Base/Department&apikey=" . $self->{option_results}->{kayako_api_key} . "&salt=" . $salt . "&signature=" . $digest . "=";);
+	my $webcontent = $self->{http}->request(url_path => $url_original_path . "/Base/Department&apikey=" . $self->{option_results}->{kayako_api_key} . "&salt=" . $salt . "&signature=" . $digest . "=");
     
     my $xp = XML::XPath->new($webcontent);
     my $nodes = $xp->find('departments/department');

centreon-plugins/apps/protocols/http/mode/jsoncontent.pm

@@ -343,11 +343,11 @@ Threshold critical if the string match
 
 =item B<--warning-time>
 
-Threshold warning in ms of webservice response time
+Threshold warning in seconds of webservice response time
 
 =item B<--critical-time>
 
-Threshold critical in ms of webservice response time
+Threshold critical in seconds of webservice response time
 
 =back
 

centreon-plugins/apps/protocols/http/mode/soapcontent.pm

@@ -356,11 +356,11 @@ Threshold critical if the string match
 
 =item B<--warning-time>
 
-Threshold warning in ms of webservice response time
+Threshold warning in seconds of webservice response time
 
 =item B<--critical-time>
 
-Threshold critical in ms of webservice response time
+Threshold critical in seconds of webservice response time
 
 =back
 

centreon-plugins/apps/protocols/x509/mode/validity.pm

@@ -37,7 +37,7 @@ sub new {
     $options{options}->add_options(arguments =>
          {
          "hostname:s"        => { name => 'hostname' },
-         "port:s"            => { name => 'port' },
+         "port:s"            => { name => 'port', default => 443 },
          "validity-mode:s"   => { name => 'validity_mode' },
          "warning-date:s"    => { name => 'warning' },
          "critical-date:s"   => { name => 'critical' },

centreon-plugins/apps/selenium/mode/scenario.pm

@@ -94,7 +94,6 @@ sub check_options {
         $self->{output}->add_option_msg(short_msg => "Please specify a scenario name" . $self->{option_results}->{scenario} . ".");
         $self->{output}->option_exit();
     }
-
 }
 
 sub run {

centreon-plugins/apps/vmware/connector/mode/servicehost.pm

@@ -0,0 +1,102 @@
+#
+# Copyright 2015 Centreon (http://www.centreon.com/)
+#
+# Centreon is a full-fledged industry-strength solution that meets
+# the needs in IT infrastructure and application monitoring for
+# service performance.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+package apps::vmware::connector::mode::servicehost;
+
+use base qw(centreon::plugins::mode);
+
+use strict;
+use warnings;
+
+sub new {
+    my ($class, %options) = @_;
+    my $self = $class->SUPER::new(package => __PACKAGE__, %options);
+    bless $self, $class;
+    
+    $self->{version} = '1.0';
+    $options{options}->add_options(arguments =>
+                                { 
+                                  "esx-hostname:s"          => { name => 'esx_hostname' },
+                                  "filter"                  => { name => 'filter' },
+                                  "scope-datacenter:s"      => { name => 'scope_datacenter' },
+                                  "scope-cluster:s"         => { name => 'scope_cluster' },
+                                  "disconnect-status:s"     => { name => 'disconnect_status', default => 'unknown' },
+                                  "filter-services:s"       => { name => 'filter_services' },
+                                });
+    return $self;
+}
+
+sub check_options {
+    my ($self, %options) = @_;
+    $self->SUPER::init(%options);
+
+    if ($self->{output}->is_litteral_status(status => $self->{option_results}->{disconnect_status}) == 0) {
+        $self->{output}->add_option_msg(short_msg => "Wrong disconnect-status status option '" . $self->{option_results}->{disconnect_status} . "'.");
+        $self->{output}->option_exit();
+    }
+}
+
+sub run {
+    my ($self, %options) = @_;
+    $self->{connector} = $options{custom};
+
+    $self->{connector}->add_params(params => $self->{option_results},
+                                   command => 'servicehost');
+    $self->{connector}->run();
+}
+
+1;
+
+__END__
+
+=head1 MODE
+
+Check ESX services.
+
+=over 8
+
+=item B<--esx-hostname>
+
+ESX hostname to check.
+If not set, we check all ESX.
+
+=item B<--filter>
+
+ESX hostname is a regexp.
+
+=item B<--scope-datacenter>
+
+Search in following datacenter(s) (can be a regexp).
+
+=item B<--scope-cluster>
+
+Search in following cluster(s) (can be a regexp).
+
+=item B<--disconnect-status>
+
+Status if ESX host disconnected (default: 'unknown').
+
+=item B<--filter-services>
+
+Filter services you want to check (can be a regexp).
+
+=back
+
+=cut

centreon-plugins/apps/vmware/connector/plugin.pm

@@ -54,6 +54,7 @@ sub new {
                          'memory-host'          => 'apps::vmware::connector::mode::memoryhost',
                          'memory-vm'            => 'apps::vmware::connector::mode::memoryvm',
                          'net-host'             => 'apps::vmware::connector::mode::nethost',
+                         'service-host'         => 'apps::vmware::connector::mode::servicehost',
                          'snapshot-vm'          => 'apps::vmware::connector::mode::snapshotvm',
                          'stat-connectors'      => 'apps::vmware::connector::mode::statconnectors',
                          'status-host'          => 'apps::vmware::connector::mode::statushost',

centreon-plugins/apps/vmware/wsman/mode/components/cim_card.pm

@@ -0,0 +1,60 @@
+#
+# Copyright 2015 Centreon (http://www.centreon.com/)
+#
+# Centreon is a full-fledged industry-strength solution that meets
+# the needs in IT infrastructure and application monitoring for
+# service performance.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+package apps::vmware::wsman::mode::components::cim_card;
+
+use strict;
+use warnings;
+
+sub check {
+    my ($self) = @_;
+    
+    my $result = $self->{wsman}->request(uri => 'http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_Card');
+    
+    $self->{output}->output_add(long_msg => "Checking cim cards");
+    $self->{components}->{cim_card} = {name => 'cards', total => 0, skip => 0};
+    return if ($self->check_filter(section => 'cim_card'));
+
+    foreach (@{$result}) {
+        my $instance = defined($_->{Name}) && $_->{Name} ne '' ? $_->{Name} : $_->{ElementName};
+        
+        next if ($self->check_filter(section => 'cim_card', instance => $instance));
+        my $status = $self->get_status(entry => $_);
+        if (!defined($status)) {
+            $self->{output}->output_add(long_msg => sprintf("skipping card '%s' : no status", $_->{ElementName}), debug => 1);
+            next;
+        }
+        
+        $self->{components}->{cim_card}->{total}++;
+
+        $self->{output}->output_add(long_msg => sprintf("Card '%s' status is '%s' [instance: %s].",
+                                    $_->{ElementName}, $status,
+                                    $instance
+                                    ));
+        my $exit = $self->get_severity(section => 'cim_card', label => 'default', value => $status);
+        if (!$self->{output}->is_status(value => $exit, compare => 'ok', litteral => 1)) {
+            $self->{output}->output_add(severity =>  $exit,
+                                        short_msg => sprintf("Card '%s' status is '%s'",
+                                                             $_->{ElementName}, $status));
+        }
+    }
+}
+
+1;

centreon-plugins/apps/vmware/wsman/mode/components/cim_computersystem.pm

@@ -0,0 +1,60 @@
+#
+# Copyright 2015 Centreon (http://www.centreon.com/)
+#
+# Centreon is a full-fledged industry-strength solution that meets
+# the needs in IT infrastructure and application monitoring for
+# service performance.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+package apps::vmware::wsman::mode::components::cim_computersystem;
+
+use strict;
+use warnings;
+
+sub check {
+    my ($self) = @_;
+    
+    my $result = $self->{wsman}->request(uri => 'http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_ComputerSystem');
+    
+    $self->{output}->output_add(long_msg => "Checking cim computer systems");
+    $self->{components}->{cim_computersystem} = {name => 'computer systems', total => 0, skip => 0};
+    return if ($self->check_filter(section => 'cim_computersystem'));
+
+    foreach (@{$result}) {
+        my $instance = defined($_->{Name}) && $_->{Name} ne '' ? $_->{Name} : $_->{ElementName};
+        
+        next if ($self->check_filter(section => 'cim_computersystem', instance => $instance));
+        my $status = $self->get_status(entry => $_);
+        if (!defined($status)) {
+            $self->{output}->output_add(long_msg => sprintf("skipping computer system '%s' : no status", $_->{ElementName}), debug => 1);
+            next;
+        }
+        
+        $self->{components}->{cim_computersystem}->{total}++;
+
+        $self->{output}->output_add(long_msg => sprintf("Computer system '%s' status is '%s' [instance: %s].",
+                                    $_->{ElementName}, $status,
+                                    $instance
+                                    ));
+        my $exit = $self->get_severity(section => 'cim_computersystem', label => 'default', value => $status);
+        if (!$self->{output}->is_status(value => $exit, compare => 'ok', litteral => 1)) {
+            $self->{output}->output_add(severity =>  $exit,
+                                        short_msg => sprintf("Computer system '%s' status is '%s'",
+                                                             $_->{ElementName}, $status));
+        }
+    }
+}
+
+1;

centreon-plugins/apps/vmware/wsman/mode/components/cim_memory.pm

@@ -0,0 +1,60 @@
+#
+# Copyright 2015 Centreon (http://www.centreon.com/)
+#
+# Centreon is a full-fledged industry-strength solution that meets
+# the needs in IT infrastructure and application monitoring for
+# service performance.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+package apps::vmware::wsman::mode::components::cim_memory;
+
+use strict;
+use warnings;
+
+sub check {
+    my ($self) = @_;
+    
+    my $result = $self->{wsman}->request(uri => 'http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_Memory');
+    
+    $self->{output}->output_add(long_msg => "Checking cim memories");
+    $self->{components}->{cim_memory} = {name => 'memories', total => 0, skip => 0};
+    return if ($self->check_filter(section => 'cim_memory'));
+
+    foreach (@{$result}) {
+        my $instance = defined($_->{Name}) && $_->{Name} ne '' ? $_->{Name} : $_->{ElementName};
+        
+        next if ($self->check_filter(section => 'cim_memory', instance => $instance));
+        my $status = $self->get_status(entry => $_);
+        if (!defined($status)) {
+            $self->{output}->output_add(long_msg => sprintf("skipping memory '%s' : no status", $_->{ElementName}), debug => 1);
+            next;
+        }
+        
+        $self->{components}->{cim_memory}->{total}++;
+
+        $self->{output}->output_add(long_msg => sprintf("Memory '%s' status is '%s' [instance: %s].",
+                                    $_->{ElementName}, $status,
+                                    $instance
+                                    ));
+        my $exit = $self->get_severity(section => 'cim_memory', label => 'default', value => $status);
+        if (!$self->{output}->is_status(value => $exit, compare => 'ok', litteral => 1)) {
+            $self->{output}->output_add(severity =>  $exit,
+                                        short_msg => sprintf("Memory '%s' status is '%s'",
+                                                             $_->{ElementName}, $status));
+        }
+    }
+}
+
+1;

centreon-plugins/apps/vmware/wsman/mode/components/cim_numericsensor.pm

@@ -0,0 +1,111 @@
+#
+# Copyright 2015 Centreon (http://www.centreon.com/)
+#
+# Centreon is a full-fledged industry-strength solution that meets
+# the needs in IT infrastructure and application monitoring for
+# service performance.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+package apps::vmware::wsman::mode::components::cim_numericsensor;
+
+use strict;
+use warnings;
+use apps::vmware::wsman::mode::components::resources qw($mapping_units $mapping_sensortype);
+
+sub check {
+    my ($self) = @_;
+    
+    my $result = $self->{wsman}->request(uri => 'http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_NumericSensor');
+    
+    $self->{output}->output_add(long_msg => "Checking cim numeric sensors");
+    $self->{components}->{cim_numericsensor} = {name => 'numeric sensors', total => 0, skip => 0};
+    return if ($self->check_filter(section => 'cim_numericsensor'));
+
+    foreach (@{$result}) {
+        my $sensor_type = defined($mapping_sensortype->{$_->{SensorType}}) ? $mapping_sensortype->{$_->{SensorType}} : 'unknown';
+        my $name = defined($_->{Name}) && $_->{Name} ne '' ? $_->{Name} : $_->{ElementName};
+        my $instance = $sensor_type . '_' . $name;
+        
+        next if ($self->check_filter(section => 'cim_numericsensor', instance => $instance));
+        my $status = $self->get_status(entry => $_);
+        if (!defined($status)) {
+            $self->{output}->output_add(long_msg => sprintf("skipping numeric sensor '%s' : no status", $_->{ElementName}), debug => 1);
+            next;
+        }
+        
+        $self->{components}->{cim_numericsensor}->{total}++;
+        my $value = $_->{CurrentReading};
+        
+        $value = $value * 10 ** int($_->{UnitModifier}) if (defined($value) && $value =~ /\d/);
+
+        $self->{output}->output_add(long_msg => sprintf("Numeric sensor '%s' status is '%s' [instance: %s, current value: %s].",
+                                    $_->{ElementName}, $status,
+                                    $instance, defined($value) ? $value : '-'
+                                    ));
+        my $exit = $self->get_severity(section => 'cim_numericsensor', label => 'default', value => $status);
+        if (!$self->{output}->is_status(value => $exit, compare => 'ok', litteral => 1)) {
+            $self->{output}->output_add(severity =>  $exit,
+                                        short_msg => sprintf("Numeric sensor '%s' status is '%s'",
+                                                             $_->{ElementName}, $status));
+        }
+        
+        
+        next if (!defined($value) || $value !~ /\d/);
+        
+        my ($exit2, $warn, $crit, $checked) = $self->get_severity_numeric(section => 'cim_numericsensor', instance => $instance, value => $value);
+        if ($checked == 0) {
+            my ($warn_th, $crit_th);
+            
+            $warn_th = $_->{LowerThresholdNonCritical} * 10 ** int($_->{UnitModifier}) . ':' if (defined($_->{LowerThresholdNonCritical}) &&
+                $_->{LowerThresholdNonCritical} =~ /\d/);
+            if (defined($warn_th)) {
+                $warn_th .= ($_->{UpperThresholdNonCritical} * 10 ** int($_->{UnitModifier})) if (defined($_->{UpperThresholdNonCritical}) &&
+                $_->{UpperThresholdNonCritical} =~ /\d/);
+            } else {
+                $warn_th = '~:' . ($_->{UpperThresholdNonCritical} * 10 ** int($_->{UnitModifier})) if (defined($_->{UpperThresholdNonCritical}) &&
+                $_->{UpperThresholdNonCritical} =~ /\d/);
+            }
+            $crit_th = $_->{LowerThresholdCritical} * 10 ** int($_->{UnitModifier}) . ':' if (defined($_->{LowerThresholdCritical}) &&
+                $_->{LowerThresholdCritical} =~ /\d/);
+            if (defined($crit_th)) {
+                $crit_th .= ($_->{UpperThresholdCritical} * 10 ** int($_->{UnitModifier})) if (defined($_->{UpperThresholdCritical}) &&
+                $_->{UpperThresholdCritical} =~ /\d/);
+            } else {
+                $crit_th = '~:' . ($_->{UpperThresholdCritical} * 10 ** int($_->{UnitModifier})) if (defined($_->{UpperThresholdCritical}) &&
+                $_->{UpperThresholdCritical} =~ /\d/);
+            }
+            $self->{perfdata}->threshold_validate(label => 'warning-cim_numericsensor-instance-' . $instance, value => $warn_th);
+            $self->{perfdata}->threshold_validate(label => 'critical-cim_numericsensor-instance-' . $instance, value => $crit_th);
+            $warn = $self->{perfdata}->get_perfdata_for_output(label => 'warning-cim_numericsensor-instance-' . $instance);
+            $crit = $self->{perfdata}->get_perfdata_for_output(label => 'critical-cim_numericsensor-instance-' . $instance);
+        }
+        if (!$self->{output}->is_status(value => $exit2, compare => 'ok', litteral => 1)) {
+            $self->{output}->output_add(severity => $exit2,
+                                        short_msg => sprintf("Numeric sensor '%s' value is %s %s", 
+                                                             $_->{ElementName}, $value, 
+                                                             defined($mapping_units->{$_->{BaseUnits}}) ? $mapping_units->{$_->{BaseUnits}} : '-'));
+        }
+        
+        my $min = defined($_->{MinReadable}) && $_->{MinReadable} =~ /\d/ ? $_->{MinReadable} * 10 ** int($_->{UnitModifier}) : undef;
+        my $max = defined($_->{MaxReadable}) && $_->{MaxReadable} =~ /\d/ ? $_->{MaxReadable} * 10 ** int($_->{UnitModifier}) : undef;
+        $self->{output}->perfdata_add(label => $instance, unit => $mapping_units->{$_->{BaseUnits}},
+                                      value => $value,
+                                      warning => $warn,
+                                      critical => $crit,
+                                      min => $min, max => $max);
+    }
+}
+
+1;

centreon-plugins/apps/vmware/wsman/mode/components/cim_processor.pm

@@ -0,0 +1,62 @@
+#
+# Copyright 2015 Centreon (http://www.centreon.com/)
+#
+# Centreon is a full-fledged industry-strength solution that meets
+# the needs in IT infrastructure and application monitoring for
+# service performance.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+package apps::vmware::wsman::mode::components::cim_processor;
+
+use strict;
+use warnings;
+
+sub check {
+    my ($self) = @_;
+    
+    my $result = $self->{wsman}->request(uri => 'http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_Processor');
+    
+    $self->{output}->output_add(long_msg => "Checking cim processors");
+    $self->{components}->{cim_processor} = {name => 'processors', total => 0, skip => 0};
+    return if ($self->check_filter(section => 'cim_processor'));
+
+    foreach (@{$result}) {
+        my $instance = defined($_->{Name}) && $_->{Name} ne '' ? $_->{Name} : $_->{ElementName};
+        
+        next if ($self->check_filter(section => 'cim_processor', instance => $instance));
+        my $status = $self->get_status(entry => $_);
+        if (!defined($status)) {
+            $self->{output}->output_add(long_msg => sprintf("skipping processor '%s' : no status", $_->{ElementName}), debug => 1);
+            next;
+        }
+        
+        $self->{components}->{cim_processor}->{total}++;
+        my $model_name = defined($_->{ModelName}) && $_->{ModelName} ne '' ? $_->{ModelName} : 'unknown';
+        $model_name =~ s/\s+/ /g;
+        
+        $self->{output}->output_add(long_msg => sprintf("Processor '%s' status is '%s' [instance: %s, Model: %s].",
+                                    $_->{ElementName}, $status,
+                                    $instance, $model_name
+                                    ));
+        my $exit = $self->get_severity(section => 'cim_processor', label => 'default', value => $status);
+        if (!$self->{output}->is_status(value => $exit, compare => 'ok', litteral => 1)) {
+            $self->{output}->output_add(severity =>  $exit,
+                                        short_msg => sprintf("Processor '%s' status is '%s'",
+                                                             $_->{ElementName}, $status));
+        }
+    }
+}
+
+1;

centreon-plugins/apps/vmware/wsman/mode/components/cim_recordlog.pm

@@ -0,0 +1,60 @@
+#
+# Copyright 2015 Centreon (http://www.centreon.com/)
+#
+# Centreon is a full-fledged industry-strength solution that meets
+# the needs in IT infrastructure and application monitoring for
+# service performance.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+package apps::vmware::wsman::mode::components::cim_recordlog;
+
+use strict;
+use warnings;
+
+sub check {
+    my ($self) = @_;
+    
+    my $result = $self->{wsman}->request(uri => 'http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_RecordLog');
+    
+    $self->{output}->output_add(long_msg => "Checking cim recordlog");
+    $self->{components}->{cim_recordlog} = {name => 'recordlog', total => 0, skip => 0};
+    return if ($self->check_filter(section => 'cim_recordlog'));
+
+    foreach (@{$result}) {
+        my $instance = defined($_->{Name}) && $_->{Name} ne '' ? $_->{Name} : $_->{ElementName};
+        
+        next if ($self->check_filter(section => 'cim_recordlog', instance => $instance));
+        my $status = $self->get_status(entry => $_);
+        if (!defined($status)) {
+            $self->{output}->output_add(long_msg => sprintf("skipping record log '%s' : no status", $_->{ElementName}), debug => 1);
+            next;
+        }
+        
+        $self->{components}->{cim_recordlog}->{total}++;
+        
+        $self->{output}->output_add(long_msg => sprintf("Record log '%s' status is '%s' [instance: %s].",
+                                    $_->{ElementName}, $status,
+                                    $instance
+                                    ));
+        my $exit = $self->get_severity(section => 'cim_recordlog', label => 'default', value => $status);
+        if (!$self->{output}->is_status(value => $exit, compare => 'ok', litteral => 1)) {
+            $self->{output}->output_add(severity =>  $exit,
+                                        short_msg => sprintf("Record log '%s' status is '%s'",
+                                                             $_->{ElementName}, $status));
+        }
+    }
+}
+
+1;

centreon-plugins/apps/vmware/wsman/mode/components/omc_discretesensor.pm

@@ -0,0 +1,65 @@
+#
+# Copyright 2015 Centreon (http://www.centreon.com/)
+#
+# Centreon is a full-fledged industry-strength solution that meets
+# the needs in IT infrastructure and application monitoring for
+# service performance.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+package apps::vmware::wsman::mode::components::omc_discretesensor;
+
+use strict;
+use warnings;
+use apps::vmware::wsman::mode::components::resources qw($mapping_EnableState);
+
+sub check {
+    my ($self) = @_;
+    
+    my $result = $self->{wsman}->request(uri => 'http://schema.omc-project.org/wbem/wscim/1/cim-schema/2/OMC_DiscreteSensor');
+    
+    $self->{output}->output_add(long_msg => "Checking OMC discrete sensors");
+    $self->{components}->{omc_discretesensor} = {name => 'omc discrete sensors', total => 0, skip => 0};
+    return if ($self->check_filter(section => 'omc_discretesensor'));
+
+    foreach (@{$result}) {
+        my $instance = $_->{Name};
+        
+        next if ($self->check_filter(section => 'omc_discretesensor', instance => $instance));
+        if (defined($mapping_EnableState->{$_->{EnabledState}}) && $mapping_EnableState->{$_->{EnabledState}} !~ /enabled/i) {
+            $self->{output}->output_add(long_msg => sprintf("skipping discrete sensor '%s' : not enabled", $_->{Name}), debug => 1);
+            next;
+        }
+        my $status = $self->get_status(entry => $_);
+        if (!defined($status)) {
+            $self->{output}->output_add(long_msg => sprintf("skipping discrete sensor '%s' : no status", $_->{Name}), debug => 1);
+            next;
+        }
+        
+        $self->{components}->{omc_discretesensor}->{total}++;
+
+        $self->{output}->output_add(long_msg => sprintf("Discrete sensor '%s' status is '%s' [instance: %s].",
+                                    $_->{Name}, $status,
+                                    $instance
+                                    ));
+        my $exit = $self->get_severity(section => 'omc_discretesensor', label => 'default', value => $status);
+        if (!$self->{output}->is_status(value => $exit, compare => 'ok', litteral => 1)) {
+            $self->{output}->output_add(severity =>  $exit,
+                                        short_msg => sprintf("Discrete sensor '%s' status is '%s'",
+                                                             $_->{Name}, $status));
+        }
+    }
+}
+
+1;

centreon-plugins/apps/vmware/wsman/mode/components/omc_fan.pm

@@ -0,0 +1,60 @@
+#
+# Copyright 2015 Centreon (http://www.centreon.com/)
+#
+# Centreon is a full-fledged industry-strength solution that meets
+# the needs in IT infrastructure and application monitoring for
+# service performance.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+package apps::vmware::wsman::mode::components::omc_fan;
+
+use strict;
+use warnings;
+
+sub check {
+    my ($self) = @_;
+    
+    my $result = $self->{wsman}->request(uri => 'http://schema.omc-project.org/wbem/wscim/1/cim-schema/2/OMC_Fan');
+    
+    $self->{output}->output_add(long_msg => "Checking OMC fans");
+    $self->{components}->{omc_fan} = {name => 'omc fans', total => 0, skip => 0};
+    return if ($self->check_filter(section => 'omc_fan'));
+
+    foreach (@{$result}) {
+        my $instance = $_->{Name};
+        
+        next if ($self->check_filter(section => 'omc_fan', instance => $instance));
+        my $status = $self->get_status(entry => $_);
+        if (!defined($status)) {
+            $self->{output}->output_add(long_msg => sprintf("skipping fan '%s' : no status", $_->{Name}), debug => 1);
+            next;
+        }
+        
+        $self->{components}->{omc_fan}->{total}++;
+
+        $self->{output}->output_add(long_msg => sprintf("Fan '%s' status is '%s' [instance: %s].",
+                                    $_->{Name}, $status,
+                                    $instance
+                                    ));
+        my $exit = $self->get_severity(section => 'omc_fan', label => 'default', value => $status);
+        if (!$self->{output}->is_status(value => $exit, compare => 'ok', litteral => 1)) {
+            $self->{output}->output_add(severity =>  $exit,
+                                        short_msg => sprintf("Fan '%s' status is '%s'",
+                                                             $_->{Name}, $status));
+        }
+    }
+}
+
+1;

centreon-plugins/apps/vmware/wsman/mode/components/omc_psu.pm

@@ -0,0 +1,60 @@
+#
+# Copyright 2015 Centreon (http://www.centreon.com/)
+#
+# Centreon is a full-fledged industry-strength solution that meets
+# the needs in IT infrastructure and application monitoring for
+# service performance.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+package apps::vmware::wsman::mode::components::omc_psu;
+
+use strict;
+use warnings;
+
+sub check {
+    my ($self) = @_;
+    
+    my $result = $self->{wsman}->request(uri => 'http://schema.omc-project.org/wbem/wscim/1/cim-schema/2/OMC_PowerSupply');
+    
+    $self->{output}->output_add(long_msg => "Checking OMC power supplies");
+    $self->{components}->{omc_psu} = {name => 'omc psus', total => 0, skip => 0};
+    return if ($self->check_filter(section => 'omc_psu'));
+
+    foreach (@{$result}) {
+        my $instance = $_->{Name};
+        
+        next if ($self->check_filter(section => 'omc_psu', instance => $instance));
+        my $status = $self->get_status(entry => $_);
+        if (!defined($status)) {
+            $self->{output}->output_add(long_msg => sprintf("skipping power supply '%s' : no status", $_->{Name}), debug => 1);
+            next;
+        }
+        
+        $self->{components}->{omc_psu}->{total}++;
+
+        $self->{output}->output_add(long_msg => sprintf("Power supply '%s' status is '%s' [instance: %s].",
+                                    $_->{Name}, $status,
+                                    $instance
+                                    ));
+        my $exit = $self->get_severity(section => 'omc_psu', label => 'default', value => $status);
+        if (!$self->{output}->is_status(value => $exit, compare => 'ok', litteral => 1)) {
+            $self->{output}->output_add(severity =>  $exit,
+                                        short_msg => sprintf("Power supply '%s' status is '%s'",
+                                                             $_->{Name}, $status));
+        }
+    }
+}
+
+1;

centreon-plugins/apps/vmware/wsman/mode/components/resources.pm

@@ -0,0 +1,173 @@
+#
+# Copyright 2015 Centreon (http://www.centreon.com/)
+#
+# Centreon is a full-fledged industry-strength solution that meets
+# the needs in IT infrastructure and application monitoring for
+# service performance.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+package apps::vmware::wsman::mode::components::resources;
+
+use strict;
+use warnings;
+use Exporter;
+
+our $mapping_HealthState;
+our $mapping_OperationalStatus;
+our $mapping_EnableState;
+our $mapping_units;
+our $mapping_sensortype;
+
+our @ISA = qw(Exporter);
+our @EXPORT_OK = qw($mapping_HealthState $mapping_OperationalStatus $mapping_EnableState $mapping_units $mapping_sensortype);
+
+$mapping_EnableState = {
+    0 => 'Unknown',
+    1 => 'Other',
+    2 => 'Enabled',
+    3 => 'Disabled',
+    4 => 'Shutting Down',
+    5 => 'Not Applicable',
+    6 => 'Enabled but Offline',
+    7 => 'In Test',
+    8 => 'Deferred',
+    9 => 'Quiesce',
+    10 => 'Starting',
+};
+
+$mapping_HealthState = {
+    0 => 'Unknown',
+    5 => 'OK',
+    10 => 'Degraded',
+    15 => 'Minor failure',
+    20 => 'Major failure',
+    25 => 'Critical failure',
+    30 => 'Non-recoverable error',
+};
+
+$mapping_OperationalStatus = {
+    0 => 'Unknown', 
+    1 => 'Other',
+    2 => 'OK',
+    3 => 'Degraded',
+    4 => 'Stressed',
+    5 => 'Predictive Failure',
+    6 => 'Error',
+    7 => 'Non-Recoverable Error',
+    8 => 'Starting',
+    9 => 'Stopping',
+    10 => 'Stopped',
+    11 => 'In Service',
+    12 => 'No Contact',
+    13 => 'Lost Communication',
+    14 => 'Aborted',
+    15 => 'Dormant',
+    16 => 'Supporting Entity in Error',
+    17 => 'Completed',
+    18 => 'Power Mode',
+    19 => 'Relocating',
+};
+
+$mapping_sensortype = {
+    0 => 'unknown',
+    1 => 'other',
+    2 => 'temp', # Temperature
+    3 => 'volt', # Voltage
+    4 => 'current', # Current
+    5 => 'tachometer',
+    6 => 'counter',
+    7 => 'switch',
+    8 => 'lock',
+    9 => 'hum', # Humidity
+    10 => 'smoke_detection', # Smoke Detection
+    11 => 'presence',
+    12 => 'air_flow', # Air Flow
+    13 => 'power_consumption', # Power Consumption
+    14 => 'power_production', # Power Production
+    15 => 'pressure_intrusion', # PressureIntrusion
+    16 => 'intrusion',
+};
+
+$mapping_units = {
+    0 => '',
+    1 => '', 
+    2 => 'C', # Degrees C 
+    3 => 'F', # Degrees F
+    4 => 'K', # Degrees K
+    5 => 'V', # Volts 
+    6 => 'A', # Amps, 
+    7 => 'W', # Watts
+    8 => 'Joules',
+    9 => 'Coulombs', 
+    10 => 'VA', 
+    11 => 'Nits', 
+    12 => 'Lumens',
+    13 => 'Lux',
+    14 => 'Candelas',
+    15 => 'kPa',
+    16 => 'PSI',
+    17 => 'Newtons',
+    18 => 'CFM',
+    19 => 'rpm',
+    20 => 'Hz', # Hertz
+    21 => 'Seconds',
+    22 => 'Minutes',
+    23 => 'Hours',
+    24 => 'Days',
+    25 => 'Weeks',
+    26 => 'Mils',
+    27 => 'Inches',
+    28 => 'Feet',
+    29 => 'Cubic_Inches',
+    30 => 'Cubic_Feet',
+    31 => 'Meters',
+    32 => 'Cubic_Centimeters',
+    33 => 'Cubic_Meters',
+    34 => 'Liters',
+    35 => 'Fluid_Ounces',
+    36 => 'Radians',
+    37 => 'Steradians',
+    38 => 'Revolutions',
+    39 => 'Cycles',
+    40 => 'Gravities',
+    41 => 'Ounces',
+    42 => 'Pounds',
+    43 => 'Foot_Pounds',
+    44 => 'Ounce_Inches',
+    45 => 'Gauss',
+    46 => 'Gilberts',
+    47 => 'Henries',
+    48 => 'Farads',
+    49 => 'Ohms',
+    50 => 'Siemens',
+    51 => 'Moles',
+    52 => 'Becquerels',
+    53 => 'PPM',
+    54 => 'Decibels',
+    55 => 'DbA',
+    56 => 'DbC',
+    57 => 'Grays',
+    58 => 'Sieverts',
+    59 => 'Color_Temperature_Degrees_K',
+    60 => 'b', # bits
+    61 => 'B', # Bytes
+    62 => 'Words',
+    63 => 'DoubleWords',
+    64 => 'QuadWords',
+    65 => '%', # Percentage,
+    66 => 'Pascals',
+};
+
+1;

centreon-plugins/apps/vmware/wsman/mode/components/vmware_battery.pm

@@ -0,0 +1,60 @@
+#
+# Copyright 2015 Centreon (http://www.centreon.com/)
+#
+# Centreon is a full-fledged industry-strength solution that meets
+# the needs in IT infrastructure and application monitoring for
+# service performance.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+package apps::vmware::wsman::mode::components::vmware_battery;
+
+use strict;
+use warnings;
+
+sub check {
+    my ($self) = @_;
+    
+    my $result = $self->{wsman}->request(uri => 'http://schemas.vmware.com/wbem/wscim/1/cim-schema/2/VMware_Battery');
+    
+    $self->{output}->output_add(long_msg => "Checking vmware batteries");
+    $self->{components}->{vmware_battery} = {name => 'batteries', total => 0, skip => 0};
+    return if ($self->check_filter(section => 'vmware_battery'));
+
+    foreach (@{$result}) {
+        my $instance = defined($_->{Name}) && $_->{Name} ne '' ? $_->{Name} : $_->{ElementName};
+        
+        next if ($self->check_filter(section => 'vmware_battery', instance => $instance));
+        my $status = $self->get_status(entry => $_);
+        if (!defined($status)) {
+            $self->{output}->output_add(long_msg => sprintf("skipping battery '%s' : no status", $_->{ElementName}), debug => 1);
+            next;
+        }
+        
+        $self->{components}->{vmware_battery}->{total}++;
+
+        $self->{output}->output_add(long_msg => sprintf("Battery '%s' status is '%s' [instance: %s].",
+                                    $_->{ElementName}, $status,
+                                    $instance
+                                    ));
+        my $exit = $self->get_severity(section => 'vmware_battery', label => 'default', value => $status);
+        if (!$self->{output}->is_status(value => $exit, compare => 'ok', litteral => 1)) {
+            $self->{output}->output_add(severity =>  $exit,
+                                        short_msg => sprintf("Battery '%s' status is '%s'",
+                                                             $_->{ElementName}, $status));
+        }
+    }
+}
+
+1;

centreon-plugins/apps/vmware/wsman/mode/components/vmware_controller.pm

@@ -0,0 +1,60 @@
+#
+# Copyright 2015 Centreon (http://www.centreon.com/)
+#
+# Centreon is a full-fledged industry-strength solution that meets
+# the needs in IT infrastructure and application monitoring for
+# service performance.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+package apps::vmware::wsman::mode::components::vmware_controller;
+
+use strict;
+use warnings;
+
+sub check {
+    my ($self) = @_;
+    
+    my $result = $self->{wsman}->request(uri => 'http://schemas.vmware.com/wbem/wscim/1/cim-schema/2/VMware_Controller');
+    
+    $self->{output}->output_add(long_msg => "Checking vmware controller");
+    $self->{components}->{vmware_controller} = {name => 'controller', total => 0, skip => 0};
+    return if ($self->check_filter(section => 'vmware_controller'));
+
+    foreach (@{$result}) {
+        my $instance = defined($_->{Name}) && $_->{Name} ne '' ? $_->{Name} : $_->{ElementName};
+        
+        next if ($self->check_filter(section => 'vmware_controller', instance => $instance));
+        my $status = $self->get_status(entry => $_);
+        if (!defined($status)) {
+            $self->{output}->output_add(long_msg => sprintf("skipping controller '%s' : no status", $_->{ElementName}), debug => 1);
+            next;
+        }
+        
+        $self->{components}->{vmware_controller}->{total}++;
+
+        $self->{output}->output_add(long_msg => sprintf("Controller '%s' status is '%s' [instance: %s].",
+                                    $_->{ElementName}, $status,
+                                    $instance
+                                    ));
+        my $exit = $self->get_severity(section => 'vmware_controller', label => 'default', value => $status);
+        if (!$self->{output}->is_status(value => $exit, compare => 'ok', litteral => 1)) {
+            $self->{output}->output_add(severity =>  $exit,
+                                        short_msg => sprintf("Controller '%s' status is '%s'",
+                                                             $_->{ElementName}, $status));
+        }
+    }
+}
+
+1;

centreon-plugins/apps/vmware/wsman/mode/components/vmware_sassataport.pm

@@ -0,0 +1,60 @@
+#
+# Copyright 2015 Centreon (http://www.centreon.com/)
+#
+# Centreon is a full-fledged industry-strength solution that meets
+# the needs in IT infrastructure and application monitoring for
+# service performance.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+package apps::vmware::wsman::mode::components::vmware_sassataport;
+
+use strict;
+use warnings;
+
+sub check {
+    my ($self) = @_;
+    
+    my $result = $self->{wsman}->request(uri => 'http://schemas.vmware.com/wbem/wscim/1/cim-schema/2/VMware_SASSATAPort');
+    
+    $self->{output}->output_add(long_msg => "Checking vmware sas/sata ports");
+    $self->{components}->{vmware_sassataport} = {name => 'sas/sata ports', total => 0, skip => 0};
+    return if ($self->check_filter(section => 'vmware_sassataport'));
+
+    foreach (@{$result}) {
+        my $instance = defined($_->{Name}) && $_->{Name} ne '' ? $_->{Name} : $_->{ElementName};
+        
+        next if ($self->check_filter(section => 'vmware_sassataport', instance => $instance));
+        my $status = $self->get_status(entry => $_);
+        if (!defined($status)) {
+            $self->{output}->output_add(long_msg => sprintf("skipping sas/sata port '%s' : no status", $_->{ElementName}), debug => 1);
+            next;
+        }
+        
+        $self->{components}->{vmware_sassataport}->{total}++;
+
+        $self->{output}->output_add(long_msg => sprintf("Sas/Sata port '%s' status is '%s' [instance: %s].",
+                                    $_->{ElementName}, $status,
+                                    $instance
+                                    ));
+        my $exit = $self->get_severity(section => 'vmware_sassataport', label => 'default', value => $status);
+        if (!$self->{output}->is_status(value => $exit, compare => 'ok', litteral => 1)) {
+            $self->{output}->output_add(severity =>  $exit,
+                                        short_msg => sprintf("Sas/Sata port '%s' status is '%s'",
+                                                             $_->{ElementName}, $status));
+        }
+    }
+}
+
+1;

centreon-plugins/apps/vmware/wsman/mode/components/vmware_storageextent.pm

@@ -0,0 +1,60 @@
+#
+# Copyright 2015 Centreon (http://www.centreon.com/)
+#
+# Centreon is a full-fledged industry-strength solution that meets
+# the needs in IT infrastructure and application monitoring for
+# service performance.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+package apps::vmware::wsman::mode::components::vmware_storageextent;
+
+use strict;
+use warnings;
+
+sub check {
+    my ($self) = @_;
+    
+    my $result = $self->{wsman}->request(uri => 'http://schemas.vmware.com/wbem/wscim/1/cim-schema/2/VMware_StorageExtent');
+    
+    $self->{output}->output_add(long_msg => "Checking vmware storage extent");
+    $self->{components}->{vmware_storageextent} = {name => 'storage extent', total => 0, skip => 0};
+    return if ($self->check_filter(section => 'vmware_storageextent'));
+
+    foreach (@{$result}) {
+        my $instance = defined($_->{Name}) && $_->{Name} ne '' ? $_->{Name} : $_->{ElementName};
+        
+        next if ($self->check_filter(section => 'vmware_storageextent', instance => $instance));
+        my $status = $self->get_status(entry => $_);
+        if (!defined($status)) {
+            $self->{output}->output_add(long_msg => sprintf("skipping storage extent '%s' : no status", $_->{ElementName}), debug => 1);
+            next;
+        }
+        
+        $self->{components}->{vmware_storageextent}->{total}++;
+
+        $self->{output}->output_add(long_msg => sprintf("Storage extent '%s' status is '%s' [instance: %s].",
+                                    $_->{ElementName}, $status,
+                                    $instance
+                                    ));
+        my $exit = $self->get_severity(section => 'vmware_storageextent', label => 'default', value => $status);
+        if (!$self->{output}->is_status(value => $exit, compare => 'ok', litteral => 1)) {
+            $self->{output}->output_add(severity =>  $exit,
+                                        short_msg => sprintf("Storage extent '%s' status is '%s'",
+                                                             $_->{ElementName}, $status));
+        }
+    }
+}
+
+1;

centreon-plugins/apps/vmware/wsman/mode/components/vmware_storagevolume.pm

@@ -0,0 +1,60 @@
+#
+# Copyright 2015 Centreon (http://www.centreon.com/)
+#
+# Centreon is a full-fledged industry-strength solution that meets
+# the needs in IT infrastructure and application monitoring for
+# service performance.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+package apps::vmware::wsman::mode::components::vmware_storagevolume;
+
+use strict;
+use warnings;
+
+sub check {
+    my ($self) = @_;
+    
+    my $result = $self->{wsman}->request(uri => 'http://schemas.vmware.com/wbem/wscim/1/cim-schema/2/VMware_StorageVolume');
+    
+    $self->{output}->output_add(long_msg => "Checking vmware storage volumes");
+    $self->{components}->{vmware_storagevolume} = {name => 'storage volumes', total => 0, skip => 0};
+    return if ($self->check_filter(section => 'vmware_storagevolume'));
+
+    foreach (@{$result}) {
+        my $instance = defined($_->{Name}) && $_->{Name} ne '' ? $_->{Name} : $_->{ElementName};
+        
+        next if ($self->check_filter(section => 'vmware_storagevolume', instance => $instance));
+        my $status = $self->get_status(entry => $_);
+        if (!defined($status)) {
+            $self->{output}->output_add(long_msg => sprintf("skipping storage volume '%s' : no status", $_->{ElementName}), debug => 1);
+            next;
+        }
+        
+        $self->{components}->{vmware_storagevolume}->{total}++;
+
+        $self->{output}->output_add(long_msg => sprintf("Storage volume '%s' status is '%s' [instance: %s].",
+                                    $_->{ElementName}, $status,
+                                    $instance
+                                    ));
+        my $exit = $self->get_severity(section => 'vmware_storagevolume', label => 'default', value => $status);
+        if (!$self->{output}->is_status(value => $exit, compare => 'ok', litteral => 1)) {
+            $self->{output}->output_add(severity =>  $exit,
+                                        short_msg => sprintf("Storage volume '%s' status is '%s'",
+                                                             $_->{ElementName}, $status));
+        }
+    }
+}
+
+1;

centreon-plugins/apps/vmware/wsman/mode/hardware.pm

@@ -0,0 +1,338 @@
+#
+# Copyright 2015 Centreon (http://www.centreon.com/)
+#
+# Centreon is a full-fledged industry-strength solution that meets
+# the needs in IT infrastructure and application monitoring for
+# service performance.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+package apps::vmware::wsman::mode::hardware;
+
+use base qw(centreon::plugins::mode);
+
+use strict;
+use warnings;
+use apps::vmware::wsman::mode::components::resources qw($mapping_HealthState $mapping_OperationalStatus);
+
+my %type = ('cim_numericsensor' => 1);
+
+my $thresholds = {
+    default => [    
+        ['Unknown', 'OK'],
+        ['OK', 'OK'],
+        ['Degraded', 'WARNING'],
+        ['Minor failure', 'WARNING'],
+        ['Major failure', 'CRITICAL'],
+        ['Critical failure', 'CRITICAL'],
+        ['Non-recoverable error', 'CRITICAL'],
+        
+        ['Other', 'UNKNOWN'],
+        ['Stressed', 'WARNING'],
+        ['Predictive Failure', 'WARNING'],
+        ['Error', 'CRITICAL'],
+        ['Starting', 'OK'],
+        ['Stopping', 'WARNING'],
+        ['In Service', 'OK'],
+        ['No Contact', 'CRITICAL'],
+        ['Lost Communication', 'CRITICAL'],
+        ['Aborted', 'CRITICAL'],
+        ['Dormant', 'OK'],
+        ['Supporting Entity in Error', 'CRITICAL'],
+        ['Completed', 'OK'],
+        ['Power Mode', 'OK'],
+        ['Relocating', 'WARNING'],
+    ],
+};
+
+sub new {
+    my ($class, %options) = @_;
+    my $self = $class->SUPER::new(package => __PACKAGE__, %options);
+    bless $self, $class;
+    
+    $self->{version} = '1.0';
+    $options{options}->add_options(arguments =>
+                                { 
+                                  "filter:s@"               => { name => 'filter' },
+                                  "component:s"             => { name => 'component', default => '.*' },
+                                  "no-component:s"          => { name => 'no_component' },
+                                  "threshold-overload:s@"   => { name => 'threshold_overload' },
+                                  "warning:s@"              => { name => 'warning' },
+                                  "critical:s@"             => { name => 'critical' },
+                                });
+
+    $self->{components} = {};
+    $self->{no_components} = undef;
+    
+    return $self;
+}
+
+sub check_options {
+    my ($self, %options) = @_;
+    $self->SUPER::init(%options);
+    
+    if (defined($self->{option_results}->{no_component})) {
+        if ($self->{option_results}->{no_component} ne '') {
+            $self->{no_components} = $self->{option_results}->{no_component};
+        } else {
+            $self->{no_components} = 'critical';
+        }
+    }
+    
+    $self->{filter} = [];
+    foreach my $val (@{$self->{option_results}->{filter}}) {
+        next if (!defined($val) || $val eq '');
+        my @values = split (/,/, $val);
+        push @{$self->{filter}}, { filter => $values[0], instance => $values[1] }; 
+    }
+    
+    $self->{overload_th} = {};
+    foreach my $val (@{$self->{option_results}->{threshold_overload}}) {
+        next if (!defined($val) || $val eq '');
+        my @values = split (/,/, $val);
+        if (scalar(@values) < 3) {
+            $self->{output}->add_option_msg(short_msg => "Wrong threshold-overload option '" . $val . "'.");
+            $self->{output}->option_exit();
+        }
+        my ($section, $instance, $status, $filter);
+        if (scalar(@values) == 3) {
+            ($section, $status, $filter) = @values;
+            $instance = '.*';
+        } else {
+             ($section, $instance, $status, $filter) = @values;
+        }
+        if ($self->{output}->is_litteral_status(status => $status) == 0) {
+            $self->{output}->add_option_msg(short_msg => "Wrong threshold-overload status '" . $val . "'.");
+            $self->{output}->option_exit();
+        }
+        $self->{overload_th}->{$section} = [] if (!defined($self->{overload_th}->{$section}));
+        push @{$self->{overload_th}->{$section}}, {filter => $filter, status => $status, instance => $instance };
+    }
+    
+    $self->{numeric_threshold} = {};
+    foreach my $option (('warning', 'critical')) {
+        foreach my $val (@{$self->{option_results}->{$option}}) {
+            next if (!defined($val) || $val eq '');
+            if ($val !~ /^(.*?),(.*?),(.*)$/) {
+                $self->{output}->add_option_msg(short_msg => "Wrong $option option '" . $val . "'.");
+                $self->{output}->option_exit();
+            }
+            my ($section, $instance, $value) = ($1, $2, $3);
+            if (!defined($type{$section})) {
+                $self->{output}->add_option_msg(short_msg => "Wrong $option option '" . $val . "'.");
+                $self->{output}->option_exit();
+            }
+            my $position = 0;
+            if (defined($self->{numeric_threshold}->{$section})) {
+                $position = scalar(@{$self->{numeric_threshold}->{$section}});
+            }
+            if (($self->{perfdata}->threshold_validate(label => $option . '-' . $section . '-' . $position, value => $value)) == 0) {
+                $self->{output}->add_option_msg(short_msg => "Wrong $option threshold '" . $value . "'.");
+                $self->{output}->option_exit();
+            }
+            $self->{numeric_threshold}->{$section} = [] if (!defined($self->{numeric_threshold}->{$section}));
+            push @{$self->{numeric_threshold}->{$section}}, { label => $option . '-' . $section . '-' . $position, threshold => $option, instance => $instance };
+        }
+    }
+}
+
+
+sub get_type {
+    my ($self, %options) = @_;
+    
+    my $result = $self->{wsman}->request(uri => 'http://schema.omc-project.org/wbem/wscim/1/cim-schema/2/OMC_SMASHFirmwareIdentity');
+    $result = pop(@$result);
+    $self->{manufacturer} = 'unknown';
+    if (defined($result->{Manufacturer}) && $result->{Manufacturer} ne '') {
+        $self->{manufacturer} = $result->{Manufacturer};
+    }
+    
+    $result = $self->{wsman}->request(uri => 'http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_Chassis');
+    $result = pop(@$result);
+    my $model = defined($result->{Model}) && $result->{Model} ne '' ? $result->{Model} : 'unknown';
+    
+    $self->{output}->output_add(long_msg => sprintf("Manufacturer : %s, Model : %s", $self->{manufacturer}, $model));
+}
+
+sub get_status {
+    my ($self, %options) = @_;
+    
+    my $status;
+    if ($self->{manufacturer} =~ /HP/i) {
+        $status = $mapping_HealthState->{$options{entry}->{HealthState}} if (defined($options{entry}->{HealthState}) &&
+            defined($mapping_HealthState->{$options{entry}->{HealthState}}));
+    } else {
+        $status = $mapping_OperationalStatus->{$options{entry}->{OperationalStatus}} if (defined($options{entry}->{OperationalStatus}) && 
+            defined($mapping_OperationalStatus->{$options{entry}->{OperationalStatus}}));
+    }
+    return $status;
+}
+
+sub run {
+    my ($self, %options) = @_;
+    $self->{wsman} = $options{wsman};
+
+    $self->get_type();
+    
+    my @components = ('omc_discretesensor', 'omc_fan', 'omc_psu', 'vmware_storageextent', 'vmware_controller',
+                      'vmware_storagevolume', 'vmware_battery', 'vmware_sassataport', 'cim_card',
+                      'cim_computersystem', 'cim_numericsensor', 'cim_memory', 'cim_processor', 'cim_recordlog');
+    foreach (@components) {
+        if (/$self->{option_results}->{component}/) {
+            my $mod_name = "apps::vmware::wsman::mode::components::$_";
+            centreon::plugins::misc::mymodule_load(output => $self->{output}, module => $mod_name,
+                                                   error_msg => "Cannot load module '$mod_name'.");
+            my $func = $mod_name->can('check');
+            $func->($self); 
+        }
+    }
+
+    my $total_components = 0;
+    my $display_by_component = '';
+    my $display_by_component_append = '';
+    foreach my $comp (sort(keys %{$self->{components}})) {
+        # Skipping short msg when no components
+        next if ($self->{components}->{$comp}->{total} == 0 && $self->{components}->{$comp}->{skip} == 0);
+        $total_components += $self->{components}->{$comp}->{total} + $self->{components}->{$comp}->{skip};
+        my $count_by_components = $self->{components}->{$comp}->{total} + $self->{components}->{$comp}->{skip}; 
+        $display_by_component .= $display_by_component_append . $self->{components}->{$comp}->{total} . '/' . $count_by_components . ' ' . $self->{components}->{$comp}->{name};
+        $display_by_component_append = ', ';
+    }
+    
+    $self->{output}->output_add(severity => 'OK',
+                                short_msg => sprintf("All %s sensors are ok [%s].", 
+                                                     $total_components,
+                                                     $display_by_component)
+                                );
+
+    if (defined($self->{option_results}->{no_component}) && $total_components == 0) {
+        $self->{output}->output_add(severity => $self->{no_components},
+                                    short_msg => 'No sensors are checked.');
+    }
+
+    $self->{output}->display();
+    $self->{output}->exit();
+}
+
+sub check_filter {
+    my ($self, %options) = @_;
+
+    foreach (@{$self->{filter}}) {
+        if ($options{section} =~ /$_->{filter}/) {
+            if (!defined($options{instance}) && !defined($_->{instance})) {
+                $self->{output}->output_add(long_msg => sprintf("Skipping $options{section} section."));
+                return 1;
+            } elsif (defined($options{instance}) && $options{instance} =~ /$_->{instance}/) {
+                $self->{output}->output_add(long_msg => sprintf("Skipping $options{section} section $options{instance} instance."));
+                return 1;
+            }
+        }
+    }
+    
+    return 0;
+}
+
+sub get_severity_numeric {
+    my ($self, %options) = @_;
+    my $status = 'OK'; # default
+    my $thresholds = { warning => undef, critical => undef };
+    my $checked = 0;
+    
+    if (defined($self->{numeric_threshold}->{$options{section}})) {
+        my $exits = [];
+        foreach (@{$self->{numeric_threshold}->{$options{section}}}) {
+            if ($options{instance} =~ /$_->{instance}/) {
+                push @{$exits}, $self->{perfdata}->threshold_check(value => $options{value}, threshold => [ { label => $_->{label}, exit_litteral => $_->{threshold} } ]);
+                $thresholds->{$_->{threshold}} = $self->{perfdata}->get_perfdata_for_output(label => $_->{label});
+                $checked = 1;
+            }
+        }
+        $status = $self->{output}->get_most_critical(status => $exits) if (scalar(@{$exits}) > 0);
+    }
+    
+    return ($status, $thresholds->{warning}, $thresholds->{critical}, $checked);
+}
+
+sub get_severity {
+    my ($self, %options) = @_;
+    my $status = 'UNKNOWN'; # default 
+    
+    if (defined($self->{overload_th}->{$options{section}})) {
+        foreach (@{$self->{overload_th}->{$options{section}}}) {            
+            if ($options{value} =~ /$_->{filter}/i && 
+                (!defined($options{instance}) || $options{instance} =~ /$_->{instance}/)) {
+                $status = $_->{status};
+                return $status;
+            }
+        }
+    }
+    my $label = defined($options{label}) ? $options{label} : $options{section};
+    foreach (@{$thresholds->{$label}}) {
+        if ($options{value} =~ /$$_[0]/i) {
+            $status = $$_[1];
+            return $status;
+        }
+    }
+    
+    return $status;
+}
+
+1;
+
+__END__
+
+=head1 MODE
+
+Check ESXi Hardware.
+Example: centreon_plugins.pl --plugin=apps::vmware::wsman::plugin --mode=hardware --hostname='XXX.XXX.XXX.XXX' 
+--wsman-username='XXXX' --wsman-password='XXXX'  --wsman-scheme=https --wsman-port=443 --verbose
+
+=over 8
+
+=item B<--component>
+
+Which component to check (Default: '.*').
+Can be: 'omc_discretesensor', 'omc_fan', 'omc_psu', 'vmware_storageextent', 'vmware_controller',
+'vmware_storagevolume', 'vmware_battery', 'vmware_sassataport', 'cim_card',
+'cim_computersystem', 'cim_numericsensor', 'cim_memory', 'cim_processor', 'cim_recordlog'.
+
+=item B<--filter>
+
+Exclude some parts (comma seperated list) (Example: --filter=cim_card --filter=cim_recordlog)
+Can also exclude specific instance: --filter='omc_psu,Power Supply 1'
+
+=item B<--no-component>
+
+Return an error if no compenents are checked.
+If total (with skipped) is 0. (Default: 'critical' returns).
+
+=item B<--threshold-overload>
+
+Set to overload default threshold values (syntax: section,[instance,]status,regexp)
+It used before default thresholds (order stays).
+Example: --threshold-overload='cim_card,CRITICAL,^(?!(OK)$)'
+
+=item B<--warning>
+
+Set warning threshold for temperatures (syntax: type,instance,threshold)
+Example: --warning='cim_numericsensor,.*,30'
+
+=item B<--critical>
+
+Set critical threshold for temperatures (syntax: type,instance,threshold)
+Example: --critical='cim_numericsensor,.*,40'
+
+=back
+
+=cut

centreon-plugins/apps/vmware/wsman/plugin.pm

@@ -0,0 +1,49 @@
+#
+# Copyright 2015 Centreon (http://www.centreon.com/)
+#
+# Centreon is a full-fledged industry-strength solution that meets
+# the needs in IT infrastructure and application monitoring for
+# service performance.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+package apps::vmware::wsman::plugin;
+
+use strict;
+use warnings;
+use base qw(centreon::plugins::script_wsman);
+
+sub new {
+    my ($class, %options) = @_;
+    my $self = $class->SUPER::new(package => __PACKAGE__, %options);
+    bless $self, $class;
+    # $options->{options} = options object
+
+    $self->{version} = '0.1';
+    %{$self->{modes}} = (
+                         'hardware'    => 'apps::vmware::wsman::mode::hardware',
+                         );
+
+    return $self;
+}
+
+1;
+
+__END__
+
+=head1 PLUGIN DESCRIPTION
+
+Check VMWare ESXi Hardware (ws-management protocol).
+
+=cut

centreon-plugins/centreon/common/airespace/snmp/mode/apstatus.pm

@@ -26,58 +26,74 @@ use strict;
 use warnings;
 use centreon::plugins::values;
 
-my $maps_counters = {
+my $instance_mode;
-    '0_status' => { class => 'centreon::plugins::values', obj => undef,
-                 set => {
-                        key_values => [
-                                       { name => 'opstatus' }, { name => 'admstatus' },
-                                      ],
-                        threshold => 0,
-                        closure_custom_calc => \&custom_status_calc,
-                        closure_custom_output => \&custom_status_output,
-                        closure_custom_perfdata => sub { return 0; },
-                        closure_custom_threshold_check => \&custom_threshold_output,
-                    }
-               },
-};
-my $thresholds = {
-    ap => [
-        ['associated', 'OK'],
-        ['disassociating', 'CRITICAL'],
-        ['downloading', 'WARNING'],
-    ],
-};
-my $overload_th;
 
-sub get_severity {
+my $maps_counters = {
-    my (%options) = @_;
+    ap => {
-    my $status = 'UNKNOWN'; # default 
+        '000_status' => { threshold => 0, 
-    
+            set => {
-    if (defined($overload_th->{$options{section}})) {
+                key_values => [ { name => 'opstatus' }, { name => 'admstatus' }, { name => 'display' } ],
-        foreach (@{$overload_th->{$options{section}}}) {            
+                threshold => 0,
-            if ($options{value} =~ /$_->{filter}/i) {
+                closure_custom_calc => \&custom_status_calc,
-                $status = $_->{status};
+                closure_custom_output => \&custom_status_output,
-                return $status;
+                closure_custom_perfdata => sub { return 0; },
+                closure_custom_threshold_check => \&custom_threshold_output,
             }
-        }
+        },
+    },
+    global => {
+        '000_total'   => { set => {
+                key_values => [ { name => 'total' } ],
+                output_template => 'Total ap : %s',
+                perfdatas => [
+                    { label => 'total', value => 'total_absolute', template => '%s', 
+                      min => 0 },
+                ],
+            }
+        },
+        '001_total-associated'   => { set => {
+                key_values => [ { name => 'associated' } ],
+                output_template => 'Total ap associated : %s',
+                perfdatas => [
+                    { label => 'total_associated', value => 'associated_absolute', template => '%s', 
+                      min => 0 },
+                ],
+            }
+        },
+        '002_total-disassociating'   => { set => {
+                key_values => [ { name => 'disassociating' } ],
+                output_template => 'Total ap disassociating : %s',
+                perfdatas => [
+                    { label => 'total_disassociating', value => 'disassociating_absolute', template => '%s', 
+                      min => 0 },
+                ],
+            }
+        },
     }
-    foreach (@{$thresholds->{$options{section}}}) {           
+};
-        if ($options{value} =~ /$$_[0]/i) {
-            $status = $$_[1];
-            return $status;
-        }
-    }
-    
-    return $status;
-}
 
 sub custom_threshold_output {
-    my ($self, %options) = @_;
+    my ($self, %options) = @_; 
+    my $status = 'ok';
+    my $message;
     
-    if ($self->{result_values}->{admstatus} eq 'disabled') {
+    eval {
-        return 'ok';
+        local $SIG{__WARN__} = sub { $message = $_[0]; };
+        local $SIG{__DIE__} = sub { $message = $_[0]; };
+        
+        if (defined($instance_mode->{option_results}->{critical_status}) && $instance_mode->{option_results}->{critical_status} ne '' &&
+            eval "$instance_mode->{option_results}->{critical_status}") {
+            $status = 'critical';
+        } elsif (defined($instance_mode->{option_results}->{warning_status}) && $instance_mode->{option_results}->{warning_status} ne '' &&
+                 eval "$instance_mode->{option_results}->{warning_status}") {
+            $status = 'warning';
+        }
+    };
+    if (defined($message)) {
+        $self->{output}->output_add(long_msg => 'filter status issue: ' . $message);
     }
-    return get_severity(section => 'ap', value => $self->{result_values}->{opstatus});
+
+    return $status;
 }
 
 sub custom_status_output {
@@ -98,6 +114,7 @@ sub custom_status_calc {
     
     $self->{result_values}->{opstatus} = $options{new_datas}->{$self->{instance} . '_opstatus'};
     $self->{result_values}->{admstatus} = $options{new_datas}->{$self->{instance} . '_admstatus'};
+    $self->{result_values}->{display} = $options{new_datas}->{$self->{instance} . '_display'};
     return 0;
 }
 
@@ -110,21 +127,23 @@ sub new {
     $options{options}->add_options(arguments =>
                                 { 
                                   "filter-name:s"           => { name => 'filter_name' },
-                                  "threshold-overload:s@"   => { name => 'threshold_overload' },
+                                  "warning-status:s"        => { name => 'warning_status', default => '' },
+                                  "critical-status:s"       => { name => 'critical_status', default => '%{admstatus} eq "enable" and %{opstatus} !~ /associated|downloading/' },
                                 });                         
      
-    foreach (keys %{$maps_counters}) {
+    foreach my $key (('global', 'ap')) {
-        my ($id, $name) = split /_/;
+        foreach (keys %{$maps_counters->{$key}}) {
-        if (!defined($maps_counters->{$_}->{threshold}) || $maps_counters->{$_}->{threshold} != 0) {
+            my ($id, $name) = split /_/;
-            $options{options}->add_options(arguments => {
+            if (!defined($maps_counters->{$key}->{$_}->{threshold}) || $maps_counters->{$key}->{$_}->{threshold} != 0) {
-                                                        'warning-' . $name . ':s'    => { name => 'warning-' . $name },
+                $options{options}->add_options(arguments => {
-                                                        'critical-' . $name . ':s'    => { name => 'critical-' . $name },
+                                                            'warning-' . $name . ':s'    => { name => 'warning-' . $name },
-                                           });
+                                                            'critical-' . $name . ':s'    => { name => 'critical-' . $name },
+                                               });
+            }
+            $maps_counters->{$key}->{$_}->{obj} = centreon::plugins::values->new(output => $self->{output}, perfdata => $self->{perfdata},
+                                                      label => $name);
+            $maps_counters->{$key}->{$_}->{obj}->set(%{$maps_counters->{$key}->{$_}->{set}});
         }
-        my $class = $maps_counters->{$_}->{class};
-        $maps_counters->{$_}->{obj} = $class->new(output => $self->{output}, perfdata => $self->{perfdata},
-                                                  label => $name);
-        $maps_counters->{$_}->{obj}->set(%{$maps_counters->{$_}->{set}});
     }
     
     return $self;
@@ -134,59 +153,42 @@ sub check_options {
     my ($self, %options) = @_;
     $self->SUPER::init(%options);
     
-    foreach (keys %{$maps_counters}) {
+    foreach my $key (('global', 'ap')) {
-        $maps_counters->{$_}->{obj}->init(option_results => $self->{option_results});
+        foreach (keys %{$maps_counters->{$key}}) {
-    }
+            $maps_counters->{$key}->{$_}->{obj}->init(option_results => $self->{option_results});
-    $overload_th = {};
-    foreach my $val (@{$self->{option_results}->{threshold_overload}}) {
-        if ($val !~ /^(.*?),(.*)$/) {
-            $self->{output}->add_option_msg(short_msg => "Wrong threshold-overload option '" . $val . "'.");
-            $self->{output}->option_exit();
         }
-        my ($section, $status, $filter) = ('ap', $1, $2);
-        if ($self->{output}->is_litteral_status(status => $status) == 0) {
-            $self->{output}->add_option_msg(short_msg => "Wrong threshold-overload status '" . $val . "'.");
-            $self->{output}->option_exit();
-        }
-        $overload_th->{$section} = [] if (!defined($overload_th->{$section}));
-        push @{$overload_th->{$section}}, {filter => $filter, status => $status};
     }
+
+    $instance_mode = $self;
+    $self->change_macros();
 }
 
-sub run {
+sub run_instance {
     my ($self, %options) = @_;
-    # $options{snmp} = snmp object
-    $self->{snmp} = $options{snmp};
-
-    $self->manage_selection();
     
-    my $multiple = 1;
+    if ($self->{multiple} == 1) {
-    if (scalar(keys %{$self->{ap_selected}}) <= 1) {
-        $multiple = 0;
-    }
-    
-    if ($multiple == 1) {
         $self->{output}->output_add(severity => 'OK',
                                     short_msg => 'All AP status are ok');
     }
     
-    foreach my $id ($self->{snmp}->oid_lex_sort(keys %{$self->{ap_selected}})) {     
+    foreach my $id (sort keys %{$self->{ap_selected}}) {     
         my ($short_msg, $short_msg_append, $long_msg, $long_msg_append) = ('', '', '', '');
-        my @exits;
+        my @exits = ();
-        foreach (sort keys %{$maps_counters}) {
+        foreach (sort keys %{$maps_counters->{ap}}) {
-            $maps_counters->{$_}->{obj}->set(instance => $id);
+            my $obj = $maps_counters->{ap}->{$_}->{obj};
+            $obj->set(instance => $id);
         
-            my ($value_check) = $maps_counters->{$_}->{obj}->execute(values => $self->{ap_selected}->{$id});
+            my ($value_check) = $obj->execute(values => $self->{ap_selected}->{$id});
 
             if ($value_check != 0) {
-                $long_msg .= $long_msg_append . $maps_counters->{$_}->{obj}->output_error();
+                $long_msg .= $long_msg_append . $obj->output_error();
                 $long_msg_append = ', ';
                 next;
             }
-            my $exit2 = $maps_counters->{$_}->{obj}->threshold_check();
+            my $exit2 = $obj->threshold_check();
             push @exits, $exit2;
 
-            my $output = $maps_counters->{$_}->{obj}->output();
+            my $output = $obj->output();
             $long_msg .= $long_msg_append . $output;
             $long_msg_append = ', ';
             
@@ -195,7 +197,7 @@ sub run {
                 $short_msg_append = ', ';
             }
             
-            $maps_counters->{$_}->{obj}->perfdata(extra_instance => $multiple);
+            $obj->perfdata(extra_instance => $self->{multiple});
         }
 
         $self->{output}->output_add(long_msg => "AP '" . $self->{ap_selected}->{$id}->{display} . "' $long_msg");
@@ -206,15 +208,80 @@ sub run {
                                         );
         }
         
-        if ($multiple == 0) {
+        if ($self->{multiple} == 0) {
             $self->{output}->output_add(short_msg => "AP '" . $self->{ap_selected}->{$id}->{display} . "' $long_msg");
         }
     }
+}
+
+sub run_global {
+    my ($self, %options) = @_;
+    
+    my ($short_msg, $short_msg_append, $long_msg, $long_msg_append) = ('', '', '', '');
+    my @exits;
+    foreach (sort keys %{$maps_counters->{global}}) {
+        my $obj = $maps_counters->{global}->{$_}->{obj};
+                
+        $obj->set(instance => 'global');
+    
+        my ($value_check) = $obj->execute(values => $self->{global});
+
+        if ($value_check != 0) {
+            $long_msg .= $long_msg_append . $obj->output_error();
+            $long_msg_append = ', ';
+            next;
+        }
+        my $exit2 = $obj->threshold_check();
+        push @exits, $exit2;
+
+        my $output = $obj->output();
+        $long_msg .= $long_msg_append . $output;
+        $long_msg_append = ', ';
+        
+        if (!$self->{output}->is_status(litteral => 1, value => $exit2, compare => 'ok')) {
+            $short_msg .= $short_msg_append . $output;
+            $short_msg_append = ', ';
+        }
+        
+        $obj->perfdata();
+    }
+
+    my $exit = $self->{output}->get_most_critical(status => [ @exits ]);
+    if (!$self->{output}->is_status(litteral => 1, value => $exit, compare => 'ok')) {
+        $self->{output}->output_add(severity => $exit,
+                                    short_msg => "$short_msg"
+                                    );
+    } else {
+        $self->{output}->output_add(short_msg => "$long_msg");
+    }
+}
+
+sub run {
+    my ($self, %options) = @_;
+    $self->{snmp} = $options{snmp};
+
+    $self->manage_selection();
+    
+    if ($self->{multiple} == 1) {
+        $self->run_global();
+    }
+    
+    $self->run_instance();
     
     $self->{output}->display();
     $self->{output}->exit();
 }
 
+sub change_macros {
+    my ($self, %options) = @_;
+    
+    foreach (('warning_status', 'critical_status')) {
+        if (defined($self->{option_results}->{$_})) {
+            $self->{option_results}->{$_} =~ s/%\{(.*?)\}/\$self->{result_values}->{$1}/g;
+        }
+    }
+}
+
 my %map_admin_status = (
     1 => 'enable',
     2 => 'disable',
@@ -233,13 +300,13 @@ my $mapping2 = {
 my $mapping3 = {
     bsnAPAdminStatus        => { oid => '.1.3.6.1.4.1.14179.2.2.1.1.37', map => \%map_admin_status },
 };
-
 my $oid_agentInventoryMachineModel = '.1.3.6.1.4.1.14179.1.1.1.3';
 
 sub manage_selection {
     my ($self, %options) = @_;
 
     $self->{ap_selected} = {};
+    $self->{global} = { total => 0, associated => 0, disassociating => 0, downloading => 0 };
     $self->{results} = $self->{snmp}->get_multiple_table(oids => [ { oid => $oid_agentInventoryMachineModel },
                                                                    { oid => $mapping->{bsnAPName}->{oid} },
                                                                    { oid => $mapping2->{bsnAPOperationStatus}->{oid} },
@@ -259,6 +326,9 @@ sub manage_selection {
             next;
         }
         
+        $self->{global}->{total}++;
+        $self->{global}->{$result2->{bsnAPOperationStatus}}++;
+        
         $self->{ap_selected}->{$instance} = { display => $result->{bsnAPName}, 
                                               opstatus => $result2->{bsnAPOperationStatus}, admstatus => $result3->{bsnAPAdminStatus}};
     }
@@ -267,6 +337,11 @@ sub manage_selection {
         $self->{output}->output_add(severity => 'OK',
                                     short_msg => 'No AP associated (can be: slave wireless controller or your filter)');
     }
+    
+    $self->{multiple} = 1;
+    if (scalar(keys %{$self->{ap_selected}}) <= 1) {
+        $self->{multiple} = 0;
+    }
 }
 
 1;
@@ -283,11 +358,25 @@ Check AP status.
 
 Filter AP name (can be a regexp).
 
-=item B<--threshold-overload>
+=item B<--warning-status>
 
-Set to overload default ap threshold values (syntax: status,regexp)
+Set warning threshold for status.
-It used before default thresholds (order stays).
+Can used special variables like: %{admstatus}, %{opstatus}, %{display}
-Example: --threshold-overload='CRITICAL,^(?!(associated)$)'
+
+=item B<--critical-status>
+
+Set critical threshold for status (Default: '%{admstatus} eq "enable" and %{opstatus} !~ /associated|downloading/').
+Can used special variables like: %{admstatus}, %{opstatus}, %{display}
+
+=item B<--warning-*>
+
+Threshold warning.
+Can be: 'total', 'total-associated', 'total-disassociating'.
+
+=item B<--critical-*>
+
+Threshold critical.
+Can be: 'total', 'total-associated', 'total-disassociating'.
 
 =back
 

centreon-plugins/centreon/common/cisco/standard/snmp/mode/components/module.pm

@@ -53,7 +53,7 @@ my %map_module_state = (
     27 => 'fwDownloadFailure',
 );
 
-# In MIB 'CISCO-ENTITY-SENSOR-MIB'
+# In MIB 'CISCO-ENTITY-FRU-CONTROL-MIB'
 my $mapping = {
     cefcModuleOperStatus => { oid => '.1.3.6.1.4.1.9.9.117.1.2.1.1.2', map => \%map_module_state },
 };

centreon-plugins/centreon/common/cisco/standard/snmp/mode/components/physical.pm

@@ -56,6 +56,11 @@ sub check {
         my $result = $self->{snmp}->map_instance(mapping => $mapping, results => $self->{results}->{$oid_cefcPhysicalStatus}, instance => $instance);
         my $physical_descr = $self->{results}->{$oid_entPhysicalDescr}->{$oid_entPhysicalDescr . '.' . $instance};
         
+        if (!defined($physical_descr)) {
+            $self->{output}->output_add(long_msg => sprintf("skipped instance '%s': no description", $instance));
+            next;
+        }
+        
         next if ($self->check_exclude(section => 'physical', instance => $instance));
         
         $self->{components}->{physical}->{total}++;

centreon-plugins/centreon/common/cisco/standard/snmp/mode/components/sensor.pm

@@ -0,0 +1,152 @@
+#
+# Copyright 2015 Centreon (http://www.centreon.com/)
+#
+# Centreon is a full-fledged industry-strength solution that meets
+# the needs in IT infrastructure and application monitoring for
+# service performance.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+package centreon::common::cisco::standard::snmp::mode::components::sensor;
+
+use strict;
+use warnings;
+
+my %map_sensor_status = (
+    1 => 'ok',
+    2 => 'unavailable',
+    3 => 'nonoperational',
+);
+my %map_sensor_type = (
+    1 => 'other',
+    2 => 'unknown',
+    3 => 'voltsAC',
+    4 => 'voltsDC',
+    5 => 'amperes',
+    6 => 'watts',
+    7 => 'hertz',
+    8 => 'celsius',
+    9 => 'percentRH',
+    10 => 'rpm',
+    11 => 'cmm',
+    12 => 'truthvalue',
+    13 => 'specialEnum',
+    14 => 'dBm',
+);
+my %map_severity = (
+    1 => 'other',
+    10 => 'minor',
+    20 => 'major',
+    30 => 'critical',
+);
+my %map_relation = (
+    1 => 'lessThan',
+    2 => 'lessOrEqual',
+    3 => 'greaterThan',
+    4 => 'greaterOrEqual',
+    5 => 'equalTo',
+    6 => 'notEqualTo',
+);
+
+# In MIB 'CISCO-ENTITY-SENSOR-MIB'
+my $mapping = {
+    entSensorType => { oid => '.1.3.6.1.4.1.9.9.91.1.1.1.1.1', map => \%map_sensor_type },
+    entSensorPrecision => { oid => '.1.3.6.1.4.1.9.9.91.1.1.1.1.3' },
+    entSensorValue => { oid => '.1.3.6.1.4.1.9.9.91.1.1.1.1.4' },
+    entSensorStatus => { oid => '.1.3.6.1.4.1.9.9.91.1.1.1.1.5', map => \%map_sensor_status },
+};
+my $mapping2 = {
+    entSensorThresholdSeverity => { oid => '.1.3.6.1.4.1.9.9.91.1.2.1.1.2', map => \%map_severity },
+    entSensorThresholdRelation => { oid => '.1.3.6.1.4.1.9.9.91.1.2.1.1.3', map => \%map_relation },
+    entSensorThresholdValue => { oid => '.1.3.6.1.4.1.9.9.91.1.2.1.1.4' },
+};
+my $oid_entSensorValueEntry = '.1.3.6.1.4.1.9.9.91.1.1.1.1';
+my $oid_entSensorThresholdEntry = '.1.3.6.1.4.1.9.9.91.1.2.1.1';
+
+sub load {
+    my (%options) = @_;
+    
+    push @{$options{request}}, { oid => $oid_entSensorValueEntry }, { oid => $oid_entSensorThresholdEntry };
+}
+
+sub get_default_warning_threshold {
+    my ($self, %options) = @_;
+    my $th = '';
+
+    return $th;
+}
+
+sub get_default_critical_threshold {
+    my ($self, %options) = @_;
+    my $th = '';
+
+    return $th;
+}
+
+
+sub check {
+    my ($self) = @_;
+    
+    $self->{output}->output_add(long_msg => "Checking sensors");
+    $self->{components}->{sensor} = {name => 'sensors', total => 0, skip => 0};
+    return if ($self->check_exclude(section => 'sensor'));
+    
+    foreach my $oid ($self->{snmp}->oid_lex_sort(keys %{$self->{results}->{$oid_entSensorValueEntry}})) {
+        next if ($oid !~ /^$mapping->{entSensorStatus}->{oid}\.(.*)$/);
+        my $instance = $1;
+        my $result = $self->{snmp}->map_instance(mapping => $mapping, results => $self->{results}->{$oid_entSensorValueEntry}, instance => $instance);
+        my $sensor_descr = $self->{results}->{$oid_entPhysicalDescr}->{$oid_entPhysicalDescr . '.' . $instance};
+        
+        next if ($self->check_exclude(section => 'sensor', instance => $instance));
+        $self->{components}->{sensor}->{total}++;
+
+        $result->{entSensorValue} = defined($result->{entSensorValue}) ? 
+           $result->{entSensorValue} * 10 ** -($result->{entSensorPrecision}) : undef;
+        
+        $self->{output}->output_add(long_msg => sprintf("Sensor '%s' status is '%s' [instance: %s] [value: %s %s]", 
+                                    $sensor_descr, $result->{entSensorStatus},
+                                    $instance, 
+                                    defined($result->{entSensorValue}) ? $result->{entSensorValue} : '-'),
+                                    $result->{entSensorType});
+        my $exit = $self->get_severity(section => $result->{entSensorType}, label => 'sensor', value => $result->{entSensorStatus});
+        if (!$self->{output}->is_status(value => $exit, compare => 'ok', litteral => 1)) {
+            $self->{output}->output_add(severity => $exit,
+                                        short_msg => sprintf("Sensor '%s' status is '%s'", 
+                                                             $sensor_descr, $result->{entSensorStatus}));
+        }
+     
+        next if (!defined($result->{entSensorValue}) || $result->{entSensorValue} !~ /[0-9]/);
+        
+        my $component = 'sensor.' . $result->{entSensorType};
+        my ($exit2, $warn, $crit, $checked) = $self->get_severity_numeric(section => $component, instance => $instance, value => $result->{entSensorValue});
+        if ($checked == 0) {
+            my $warn_th = get_default_warning_threshold($self);
+            my $crit_th = get_default_critical_threshold($self);
+            $self->{perfdata}->threshold_validate(label => 'warning-' . $component . '-instance-' . $instance, value => $warn_th);
+            $self->{perfdata}->threshold_validate(label => 'critical-' . $component . '-instance-' . $instance, value => $crit_th);
+            $warn = $self->{perfdata}->get_perfdata_for_output(label => 'warning-' . $component . '-instance-' . $instance);
+            $crit = $self->{perfdata}->get_perfdata_for_output(label => 'critical-' . $component  . '-instance-' . $instance);
+        }
+        if (!$self->{output}->is_status(value => $exit2, compare => 'ok', litteral => 1)) {
+            $self->{output}->output_add(severity => $exit2,
+                                        short_msg => sprintf("Sensor '%s' is %s %s", $sensor_descr, $result->{entSensorStatus}, $result->{entSensorType}));
+        }
+        $self->{output}->perfdata_add(label => $component . '_' . $sensor_descr,
+                                      value => $result->{entSensorValue},
+                                      warning => $warn,
+                                      critical => $crit);
+    }
+}
+
+1;

centreon-plugins/centreon/common/cisco/standard/snmp/mode/components/temperature.pm

@@ -64,7 +64,7 @@ sub check {
 
         $self->{output}->output_add(long_msg => sprintf("Temperature '%s' status is %s [instance: %s] [value: %s C]", 
                                     $result->{ciscoEnvMonTemperatureStatusDescr}, $result->{ciscoEnvMonTemperatureState},
-                                    $instance, $result->{ciscoEnvMonTemperatureStatusValue}));
+                                    $instance, defined($result->{ciscoEnvMonTemperatureStatusValue}) ? $result->{ciscoEnvMonTemperatureStatusValue} : '-'));
         my $exit = $self->get_severity(section => 'temperature', value => $result->{ciscoEnvMonTemperatureState});
         if (!$self->{output}->is_status(value => $exit, compare => 'ok', litteral => 1)) {
             $self->{output}->output_add(severity => $exit,
@@ -72,6 +72,8 @@ sub check {
                                                              $result->{ciscoEnvMonTemperatureStatusDescr}, $result->{ciscoEnvMonTemperatureState}));
         }
      
+        next if (!defined($result->{ciscoEnvMonTemperatureStatusValue}));
+        
         my ($exit2, $warn, $crit, $checked) = $self->get_severity_numeric(section => 'temperature', instance => $instance, value => $result->{ciscoEnvMonTemperatureStatusValue});
         if ($checked == 0) {
             my $warn_th = undef;

centreon-plugins/centreon/common/cisco/standard/snmp/mode/components/voltage.pm

@@ -77,8 +77,8 @@ sub check {
         my ($exit2, $warn, $crit, $checked) = $self->get_severity_numeric(section => 'voltage', instance => $instance, value => $result->{ciscoEnvMonVoltageStatusValue});
         if ($checked == 0) {
             my $warn_th = undef;
-            my $crit_th = (defined($result->{ciscoEnvMonVoltageThresholdLow}) ? sprintf("%.3f", $result->{ciscoEnvMonVoltageThresholdLow}) : 0) . ':' . 
+            my $crit_th = ((defined($result->{ciscoEnvMonVoltageThresholdLow}) && $result->{ciscoEnvMonVoltageThresholdLow} =~ /\d/) ? sprintf("%.3f", $result->{ciscoEnvMonVoltageThresholdLow} / 1000) : 0) . ':' . 
-                (defined($result->{ciscoEnvMonVoltageThresholdHigh}) ? sprintf("%.3f", $result->{ciscoEnvMonVoltageThresholdHigh}) : '');
+                ((defined($result->{ciscoEnvMonVoltageThresholdHigh}) && $result->{ciscoEnvMonVoltageThresholdHigh} =~ /\d/) ? sprintf("%.3f", $result->{ciscoEnvMonVoltageThresholdHigh} / 1000) : '');
             $self->{perfdata}->threshold_validate(label => 'warning-voltage-instance-' . $instance, value => $warn_th);
             $self->{perfdata}->threshold_validate(label => 'critical-voltage-instance-' . $instance, value => $crit_th);
             $warn = $self->{perfdata}->get_perfdata_for_output(label => 'warning-voltage-instance-' . $instance);

centreon-plugins/centreon/common/cisco/standard/snmp/mode/environment.pm

@@ -94,6 +94,11 @@ my $thresholds = {
         ['incompatible|unsupported', 'CRITICAL'],
         ['supported', 'OK'],
     ],
+    sensor => [
+        ['ok', 'OK'],
+        ['unavailable', 'OK'],
+        ['nonoperational', 'CRITICAL'],
+    ],
 };
 
 sub new {
@@ -133,17 +138,29 @@ sub check_options {
     
     $self->{overload_th} = {};
     foreach my $val (@{$self->{option_results}->{threshold_overload}}) {
-        if ($val !~ /^(.*?),(.*?),(.*)$/) {
+        next if (!defined($val) || $val eq '');
+        my @values = split (/,/, $val);
+        if (scalar(@values) < 3) {
             $self->{output}->add_option_msg(short_msg => "Wrong threshold-overload option '" . $val . "'.");
             $self->{output}->option_exit();
         }
-        my ($section, $status, $filter) = ($1, $2, $3);
+        my ($section, $instance, $status, $filter);
+        if (scalar(@values) == 3) {
+            ($section, $status, $filter) = @values;
+            $instance = '.*';
+        } else {
+             ($section, $instance, $status, $filter) = @values;
+        }
+        if ($section !~ /^(temperature|fan|psu)$/) {
+            $self->{output}->add_option_msg(short_msg => "Wrong threshold-overload section '" . $val . "'.");
+            $self->{output}->option_exit();
+        }
         if ($self->{output}->is_litteral_status(status => $status) == 0) {
             $self->{output}->add_option_msg(short_msg => "Wrong threshold-overload status '" . $val . "'.");
             $self->{output}->option_exit();
         }
         $self->{overload_th}->{$section} = [] if (!defined($self->{overload_th}->{$section}));
-        push @{$self->{overload_th}->{$section}}, {filter => $filter, status => $status};
+        push @{$self->{overload_th}->{$section}}, {filter => $filter, status => $status, instance => $instance };
     }
     
     $self->{numeric_threshold} = {};
@@ -154,8 +171,8 @@ sub check_options {
                 $self->{output}->option_exit();
             }
             my ($section, $regexp, $value) = ($1, $2, $3);
-            if ($section !~ /(temperature|voltage)/) {
+            if ($section !~ /(temperature|voltage|sensor)/i) {
-                $self->{output}->add_option_msg(short_msg => "Wrong $option option '" . $val . "' (type must be: temperature or voltage).");
+                $self->{output}->add_option_msg(short_msg => "Wrong $option option '" . $val . "' (type must be: temperature, voltage or sensor).");
                 $self->{output}->option_exit();
             }
             my $position = 0;
@@ -181,7 +198,7 @@ sub run {
     my $oid_ciscoEnvMonPresent = ".1.3.6.1.4.1.9.9.13.1.1";
     my $snmp_request = [ { oid => $oid_entPhysicalDescr }, { oid => $oid_ciscoEnvMonPresent } ];
     
-    my @components = ('fan', 'psu', 'temperature', 'voltage', 'module', 'physical');
+    my @components = ('fan', 'psu', 'temperature', 'voltage', 'module', 'physical', 'sensor');
     foreach (@components) {
         if (/$self->{option_results}->{component}/) {
             my $mod_name = "centreon::common::cisco::standard::snmp::mode::components::$_";
@@ -278,7 +295,7 @@ sub get_severity_numeric {
     if (defined($self->{numeric_threshold}->{$options{section}})) {
         my $exits = [];
         foreach (@{$self->{numeric_threshold}->{$options{section}}}) {
-            if ($options{instance} =~ /$_->{regexp}/) {
+            if ($options{instance} =~ /$_->{regexp}/i) {
                 push @{$exits}, $self->{perfdata}->threshold_check(value => $options{value}, threshold => [ { label => $_->{label}, exit_litteral => $_->{threshold} } ]);
                 $thresholds->{$_->{threshold}} = $self->{perfdata}->get_perfdata_for_output(label => $_->{label});
                 $checked = 1;
@@ -296,13 +313,15 @@ sub get_severity {
     
     if (defined($self->{overload_th}->{$options{section}})) {
         foreach (@{$self->{overload_th}->{$options{section}}}) {            
-            if ($options{value} =~ /$_->{filter}/i) {
+            if ($options{value} =~ /$_->{filter}/i && 
+                (!defined($options{instance}) || $options{instance} =~ /$_->{instance}/)) {
                 $status = $_->{status};
                 return $status;
             }
         }
     }
-    foreach (@{$thresholds->{$options{section}}}) {           
+    my $label = defined($options{label}) ? $options{label} : $options{section};
+    foreach (@{$thresholds->{$label}}) {
         if ($options{value} =~ /$$_[0]/i) {
             $status = $$_[1];
             return $status;
@@ -325,7 +344,7 @@ Check environment (Power Supplies, Fans, Temperatures, Voltages, Modules, Physic
 =item B<--component>
 
 Which component to check (Default: '.*').
-Can be: 'fan', 'psu', 'temperature', 'voltage', 'module', 'physical'.
+Can be: 'fan', 'psu', 'temperature', 'voltage', 'module', 'physical', 'sensor'.
 
 =item B<--exclude>
 
@@ -350,12 +369,12 @@ Example: --threshold-overload='fan,CRITICAL,^(?!(up|normal)$)'
 
 =item B<--warning>
 
-Set warning threshold for temperatures, voltages (syntax: type,regexp,treshold)
+Set warning threshold for temperatures, voltages, sensors (syntax: type,regexp,treshold)
 Example: --warning='temperature,.*,30'
 
 =item B<--critical>
 
-Set critical threshold for temperatures, voltages (syntax: type,regexp,treshold)
+Set critical threshold for temperatures, voltages, sensors (syntax: type,regexp,treshold)
 Example: --critical='temperature,.*,40'
 
 =back

centreon-plugins/centreon/common/cisco/standard/snmp/mode/ipsla.pm

@@ -319,7 +319,7 @@ sub get_my_delta {
     my $value;
     my ($old_time1, $old_time2) = split /_/, $options{old_datas}->{$self->{instance} . '_' . $options{name} . '_times'};
     my ($new_time1, $new_time2) = split /_/, $options{new_datas}->{$self->{instance} . '_' . $options{name} . '_times'};
-    if ($old_time1 == $new_time1) {
+    if (defined($old_time1) && defined($new_time1) && $old_time1 == $new_time1) {
         $value = $options{new_datas}->{$self->{instance} . '_' . $options{name} . '_1'} - $options{old_datas}->{$self->{instance} . '_' . $options{name} . '_1'} +
                  $options{new_datas}->{$self->{instance} . '_' . $options{name} . '_2'} - $options{old_datas}->{$self->{instance} . '_' . $options{name} . '_2'};
     } else {
@@ -944,13 +944,17 @@ sub manage_selection {
         my $instance = $1;
         my $result = $self->{snmp}->map_instance(mapping => $mapping, results => $self->{results}->{$oid_rttMonCtrlAdminEntry}, instance => $instance);
         my $tag_name = $result->{rttMonCtrlAdminTag};
+        if (!defined($tag_name) || $tag_name eq '') {
+            $self->{output}->output_add(long_msg => "skipping: please set a tag name");
+            next;
+        }
         if (defined($self->{datas}->{$tag_name})) {
-            $self->{output}->output_add(long_msg => "Skipping  '" . $tag_name . "': duplicate (please change the tag name).");
+            $self->{output}->output_add(long_msg => "skipping  '" . $tag_name . "': duplicate (please change the tag name).");
             next;
         }
         if (defined($self->{option_results}->{filter_tag}) && $self->{option_results}->{filter_tag} ne '' &&
             $tag_name !~ /$self->{option_results}->{filter_tag}/) {
-            $self->{output}->output_add(long_msg => "Skipping  '" . $tag_name . "': no matching filter.");
+            $self->{output}->output_add(long_msg => "skipping  '" . $tag_name . "': no matching filter.");
             next;
         }
         $self->{datas}->{$tag_name} = { %{$result} };

centreon-plugins/centreon/common/force10/snmp/mode/components/fan.pm

@@ -0,0 +1,82 @@
+#
+# Copyright 2015 Centreon (http://www.centreon.com/)
+#
+# Centreon is a full-fledged industry-strength solution that meets
+# the needs in IT infrastructure and application monitoring for
+# service performance.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+package centreon::common::force10::snmp::mode::components::fan;
+
+use strict;
+use warnings;
+
+my %map_status = (
+    1 => 'up',
+    2 => 'down',
+    3 => 'absent',
+);
+
+my $mapping = {
+    sseries => {
+        OperStatus => { oid => '.1.3.6.1.4.1.6027.3.10.1.2.4.1.2', map => \%map_status },
+    },
+    mseries => {
+        OperStatus => { oid => '.1.3.6.1.4.1.6027.3.19.1.2.3.1.2', map => \%map_status },
+    },
+    zseries => {
+        OperStatus => { oid => '.1.3.6.1.4.1.6027.3.25.1.2.7.1.2', map => \%map_status },
+    },
+};
+
+sub load {
+    my (%options) = @_;
+    
+    push @{$options{request}}, { oid => $mapping->{sseries}->{OperStatus}->{oid} },
+        { oid => $mapping->{mseries}->{OperStatus}->{oid} }, { oid => $mapping->{zseries}->{OperStatus}->{oid} };
+}
+
+sub check {
+    my ($self) = @_;
+    
+    $self->{output}->output_add(long_msg => "Checking fans");
+    $self->{components}->{fan} = {name => 'fans', total => 0, skip => 0};
+    return if ($self->check_filter(section => 'fan'));
+    
+    foreach my $name (keys %{$mapping}) {
+        foreach my $oid ($self->{snmp}->oid_lex_sort(keys %{$self->{results}->{$mapping->{$name}->{OperStatus}->{oid}}})) {
+            next if ($oid !~ /^$mapping->{$name}->{OperStatus}->{oid}\.(.*)$/);
+            my $instance = $1;
+            my $result = $self->{snmp}->map_instance(mapping => $mapping->{$name}, results => $self->{results}->{$mapping->{$name}->{OperStatus}->{oid}}, instance => $instance);
+            
+            next if ($result->{OperStatus} =~ /absent/i && 
+                     $self->absent_problem(section => 'fan', instance => $instance));
+            next if ($self->check_filter(section => 'fan', instance => $instance));
+            $self->{components}->{fan}->{total}++;
+
+            $self->{output}->output_add(long_msg => sprintf("Fan '%s' status is '%s' [instance: %s]", 
+                                        $instance, $result->{OperStatus}, 
+                                        $instance));
+            my $exit = $self->get_severity(section => 'fan', value => $result->{OperStatus});
+            if (!$self->{output}->is_status(value => $exit, compare => 'ok', litteral => 1)) {
+                $self->{output}->output_add(severity => $exit,
+                                            short_msg => sprintf("Fan '%s' status is %s", 
+                                                                $instance, $result->{OperStatus}));
+            }
+        }
+    }
+}
+
+1;

centreon-plugins/centreon/common/force10/snmp/mode/components/psu.pm

@@ -0,0 +1,90 @@
+#
+# Copyright 2015 Centreon (http://www.centreon.com/)
+#
+# Centreon is a full-fledged industry-strength solution that meets
+# the needs in IT infrastructure and application monitoring for
+# service performance.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+package centreon::common::force10::snmp::mode::components::psu;
+
+use strict;
+use warnings;
+
+my %map_status = (
+    1 => 'up',
+    2 => 'down',
+    3 => 'absent',
+);
+my %map_mstatus = (
+    1 => 'normal',
+    2 => 'warning',
+    3 => 'critical',
+    4 => 'shutdown',
+    5 => 'notPresent',
+    6 => 'notFunctioning',
+);
+
+my $mapping = {
+    sseries => {
+        OperStatus => { oid => '.1.3.6.1.4.1.6027.3.10.1.2.3.1.2', map => \%map_status },
+    },
+    mseries => {
+        OperStatus => { oid => '.1.3.6.1.4.1.6027.3.19.1.2.2.1.2', map => \%map_mstatus },
+    },
+    zseries => {
+        OperStatus => { oid => '.1.3.6.1.4.1.6027.3.25.1.2.6.1.2', map => \%map_status },
+    },
+};
+
+sub load {
+    my (%options) = @_;
+    
+    push @{$options{request}}, { oid => $mapping->{sseries}->{OperStatus}->{oid} },
+        { oid => $mapping->{mseries}->{OperStatus}->{oid} }, { oid => $mapping->{zseries}->{OperStatus}->{oid} };
+}
+
+sub check {
+    my ($self) = @_;
+    
+    $self->{output}->output_add(long_msg => "Checking power supplies");
+    $self->{components}->{psu} = {name => 'power supplies', total => 0, skip => 0};
+    return if ($self->check_filter(section => 'psu'));
+    
+    foreach my $name (keys %{$mapping}) {
+        foreach my $oid ($self->{snmp}->oid_lex_sort(keys %{$self->{results}->{$mapping->{$name}->{OperStatus}->{oid}}})) {
+            next if ($oid !~ /^$mapping->{$name}->{OperStatus}->{oid}\.(.*)$/);
+            my $instance = $1;
+            my $result = $self->{snmp}->map_instance(mapping => $mapping->{$name}, results => $self->{results}->{$mapping->{$name}->{OperStatus}->{oid}}, instance => $instance);
+            
+            next if ($result->{OperStatus} =~ /absent|notPresent/i && 
+                     $self->absent_problem(section => 'psu', instance => $instance));
+            next if ($self->check_filter(section => 'psu', instance => $instance));
+            $self->{components}->{psu}->{total}++;
+
+            $self->{output}->output_add(long_msg => sprintf("Power supply '%s' status is '%s' [instance: %s]", 
+                                        $instance, $result->{OperStatus}, 
+                                        $instance));
+            my $exit = $self->get_severity(section => 'psu', value => $result->{OperStatus});
+            if (!$self->{output}->is_status(value => $exit, compare => 'ok', litteral => 1)) {
+                $self->{output}->output_add(severity => $exit,
+                                            short_msg => sprintf("Power supply '%s' status is %s", 
+                                                                $instance, $result->{OperStatus}));
+            }
+        }
+    }
+}
+
+1;

centreon-plugins/centreon/common/force10/snmp/mode/components/temperature.pm

@@ -0,0 +1,76 @@
+#
+# Copyright 2015 Centreon (http://www.centreon.com/)
+#
+# Centreon is a full-fledged industry-strength solution that meets
+# the needs in IT infrastructure and application monitoring for
+# service performance.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+package centreon::common::force10::snmp::mode::components::temperature;
+
+use strict;
+use warnings;
+
+my $mapping = {
+    sseries => {
+        Temp => { oid => '.1.3.6.1.4.1.6027.3.10.1.2.2.1.14' },
+    },
+    mseries => {
+        Temp => { oid => '.1.3.6.1.4.1.6027.3.19.1.2.1.1.14' },
+    },
+};
+my $oid_deviceSensorValueEntry = '.1.3.6.1.4.1.3417.2.1.1.1.1.1';
+
+sub load {
+    my (%options) = @_;
+    
+    push @{$options{request}}, { oid => $mapping->{sseries}->{Temp}->{oid} },
+        { oid => $mapping->{mseries}->{Temp}->{oid} };
+}
+
+sub check {
+    my ($self) = @_;
+    
+    $self->{output}->output_add(long_msg => "Checking temperatures");
+    $self->{components}->{temperature} = {name => 'temperatures', total => 0, skip => 0};
+    return if ($self->check_filter(section => 'temperature'));
+    
+    foreach my $name (keys %{$mapping}) {
+        foreach my $oid ($self->{snmp}->oid_lex_sort(keys %{$self->{results}->{$mapping->{$name}->{Temp}->{oid}}})) {
+            next if ($oid !~ /^$mapping->{$name}->{Temp}->{oid}\.(.*)$/);
+            my $instance = $1;
+            my $result = $self->{snmp}->map_instance(mapping => $mapping->{$name}, results => $self->{results}->{$mapping->{$name}->{Temp}->{oid}}, instance => $instance);
+            
+            next if ($self->check_filter(section => 'temperature', instance => $instance));
+            $self->{components}->{temperature}->{total}++;
+
+            $self->{output}->output_add(long_msg => sprintf("Temperature '%s' is %s C [instance: %s]", 
+                                        $instance, $result->{Temp}, 
+                                        $instance));
+            
+            my ($exit, $warn, $crit, $checked) = $self->get_severity_numeric(section => 'temperature', instance => $instance, value => $result->{Temp});
+            if (!$self->{output}->is_status(value => $exit, compare => 'ok', litteral => 1)) {
+                $self->{output}->output_add(severity => $exit,
+                                            short_msg => sprintf("Temperature '%s' is %s C", $instance, $result->{Temp}));
+            }
+            $self->{output}->perfdata_add(label => 'temp_' . $instance, unit => 'C',
+                                          value => $result->{Temp},
+                                          warning => $warn,
+                                          critical => $crit);
+        }
+    }
+}
+
+1;

centreon-plugins/centreon/common/force10/snmp/mode/cpu.pm

@@ -0,0 +1,243 @@
+#
+# Copyright 2015 Centreon (http://www.centreon.com/)
+#
+# Centreon is a full-fledged industry-strength solution that meets
+# the needs in IT infrastructure and application monitoring for
+# service performance.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+package centreon::common::force10::snmp::mode::cpu;
+
+use base qw(centreon::plugins::mode);
+
+use strict;
+use warnings;
+use centreon::plugins::values;
+
+my $instance_mode;
+
+my $maps_counters = {
+    cpu => {
+        '000_5s'   => {
+            set => {
+                key_values => [ { name => 'usage_5s' }, { name => 'display' } ],
+                output_template => '%s %% (5sec)', output_error_template => "%s (5sec)",
+                perfdatas => [
+                    { label => 'cpu_5s', value => 'usage_5s_absolute', template => '%d',
+                      unit => '%', min => 0, max => 100, label_extra_instance => 1, instance_use => 'display_absolute' },
+                ],
+            },
+        },
+        '001_1m'   => {
+            set => {
+                key_values => [ { name => 'usage_1m' }, { name => 'display' } ],
+                output_template => '%s %% (1m)', output_error_template => "%s (1min)",
+                perfdatas => [
+                    { label => 'cpu_1m', value => 'usage_1m_absolute', template => '%d',
+                      unit => '%', min => 0, max => 100, label_extra_instance => 1, instance_use => 'display_absolute' },
+                ],
+            },
+        },
+        '002_5m'   => {
+            set => {
+                key_values => [ { name => 'usage_5m' }, { name => 'display' } ],
+                output_template => '%s %% (5min)', output_error_template => "%s (5min)",
+                perfdatas => [
+                    { label => 'cpu_5m', value => 'usage_5m_absolute', template => '%d',
+                      unit => '%', min => 0, max => 100, label_extra_instance => 1, instance_use => 'display_absolute' },
+                ],
+            },
+        },
+    }
+};
+
+sub new {
+    my ($class, %options) = @_;
+    my $self = $class->SUPER::new(package => __PACKAGE__, %options);
+    bless $self, $class;
+    
+    $self->{version} = '1.0';
+    $options{options}->add_options(arguments =>
+                                { 
+                                });
+                                
+    foreach my $key (('cpu')) {
+        foreach (keys %{$maps_counters->{$key}}) {
+            my ($id, $name) = split /_/;
+            if (!defined($maps_counters->{$key}->{$_}->{threshold}) || $maps_counters->{$key}->{$_}->{threshold} != 0) {
+                $options{options}->add_options(arguments => {
+                                                            'warning-' . $name . ':s'    => { name => 'warning-' . $name },
+                                                            'critical-' . $name . ':s'    => { name => 'critical-' . $name },
+                                               });
+            }
+            $maps_counters->{$key}->{$_}->{obj} = centreon::plugins::values->new(output => $self->{output}, perfdata => $self->{perfdata},
+                                                      label => $name);
+            $maps_counters->{$key}->{$_}->{obj}->set(%{$maps_counters->{$key}->{$_}->{set}});
+        }
+    }
+    
+    return $self;
+}
+
+sub check_options {
+    my ($self, %options) = @_;
+    $self->SUPER::init(%options);
+    
+    foreach my $key (('cpu')) {
+        foreach (keys %{$maps_counters->{$key}}) {
+            $maps_counters->{$key}->{$_}->{obj}->init(option_results => $self->{option_results});
+        }
+    }
+    $instance_mode = $self;
+}
+
+sub run_instances {
+    my ($self, %options) = @_;
+    
+    my $multiple = 1;
+    if (scalar(keys %{$self->{cpu}}) == 1) {
+        $multiple = 0;
+    }
+    
+    if ($multiple == 1) {
+        $self->{output}->output_add(severity => 'OK',
+                                    short_msg => 'All CPU usages are ok');
+    }
+    
+    foreach my $id (sort keys %{$self->{cpu}}) {     
+        my ($short_msg, $short_msg_append, $long_msg, $long_msg_append) = ('', '', '', '');
+        my @exits = ();
+        foreach (sort keys %{$maps_counters->{cpu}}) {
+            my $obj = $maps_counters->{cpu}->{$_}->{obj};
+            $obj->set(instance => $id);
+        
+            my ($value_check) = $obj->execute(values => $self->{cpu}->{$id});
+
+            if ($value_check != 0) {
+                $long_msg .= $long_msg_append . $obj->output_error();
+                $long_msg_append = ', ';
+                next;
+            }
+            my $exit2 = $obj->threshold_check();
+            push @exits, $exit2;
+
+            my $output = $obj->output();
+            $long_msg .= $long_msg_append . $output;
+            $long_msg_append = ', ';
+            
+            if (!$self->{output}->is_status(litteral => 1, value => $exit2, compare => 'ok')) {
+                $short_msg .= $short_msg_append . $output;
+                $short_msg_append = ', ';
+            }
+            
+            $obj->perfdata(extra_instance => $multiple);
+        }
+
+        my $prefix = "CPU Usage ";
+        if ($multiple == 1) {
+            $prefix = sprintf("CPU '%s' Usage ", $self->{cpu}->{$id}->{display});
+        }
+        $self->{output}->output_add(long_msg => "${prefix}$long_msg");
+        my $exit = $self->{output}->get_most_critical(status => [ @exits ]);
+        if (!$self->{output}->is_status(litteral => 1, value => $exit, compare => 'ok')) {
+            $self->{output}->output_add(severity => $exit,
+                                        short_msg => "${prefix}$short_msg"
+                                        );
+        }
+        
+        if ($multiple == 0) {
+            $self->{output}->output_add(short_msg => "${prefix}$long_msg");
+        }
+    }
+}
+
+sub run {
+    my ($self, %options) = @_;
+
+    $self->manage_selection(%options);
+    $self->run_instances();
+     
+    $self->{output}->display();
+    $self->{output}->exit();
+}
+
+my $mapping = {
+    sseries => {
+        Util5Sec    => { oid => '.1.3.6.1.4.1.6027.3.10.1.2.9.1.2' },
+        Util1Min    => { oid => '.1.3.6.1.4.1.6027.3.10.1.2.9.1.3' },
+        Util5Min    => { oid => '.1.3.6.1.4.1.6027.3.10.1.2.9.1.4' },
+    },
+    mseries => {
+        Util5Sec    => { oid => '.1.3.6.1.4.1.6027.3.19.1.2.8.1.2' },
+        Util1Min    => { oid => '.1.3.6.1.4.1.6027.3.19.1.2.8.1.3' },
+        Util5Min    => { oid => '.1.3.6.1.4.1.6027.3.19.1.2.8.1.4' },
+    },
+    zseries => {
+        Util5Sec    => { oid => '.1.3.6.1.4.1.6027.3.25.1.2.3.1.1' },
+        Util1Min    => { oid => '.1.3.6.1.4.1.6027.3.25.1.2.3.1.2' },
+        Util5Min    => { oid => '.1.3.6.1.4.1.6027.3.25.1.2.3.1.3' },
+    },
+};
+
+sub manage_selection {
+    my ($self, %options) = @_;
+    
+    my $oids = { sseries => '.1.3.6.1.4.1.6027.3.10.1.2.9.1', mseries => '.1.3.6.1.4.1.6027.3.19.1.2.8.1', zseries => '.1.3.6.1.4.1.6027.3.25.1.2.3.1' };
+    my $results = $options{snmp}->get_multiple_table(oids => [ { oid => $oids->{sseries} }, { oid => $oids->{mseries} }, { oid => $oids->{zseries} } ], 
+                                                    nothing_quit => 1);
+    $self->{cpu} = {};
+    foreach my $name (keys %{$oids}) {
+        foreach my $oid (keys %{$results->{$oids->{$name}}}) {
+            next if ($oid !~ /^$mapping->{$name}->{Util5Min}->{oid}\.(.*)/);
+            my $instance = $1;
+            my $result = $options{snmp}->map_instance(mapping => $mapping->{$name}, results => $results->{$oids->{$name}}, instance => $instance);
+        
+            $self->{cpu}->{$instance} = { display => $instance, 
+                                          usage_5s => $result->{Util5Sec},
+                                          usage_1m => $result->{Util1Min},
+                                          usage_5m => $result->{Util5Min},
+                                        };
+        }
+    }
+    
+    if (scalar(keys %{$self->{cpu}}) <= 0) {
+        $self->{output}->add_option_msg(short_msg => "No entry found.");
+        $self->{output}->option_exit();
+    }
+}
+
+1;
+
+__END__
+
+=head1 MODE
+
+Check cpu usages.
+
+=over 8
+
+=item B<--warning-*>
+
+Threshold warning.
+Can be: '5s', '1m', '5m'.
+
+=item B<--critical-*>
+
+Threshold critical.
+Can be: '5s', '1m', '5m'.
+
+=back
+
+=cut

centreon-plugins/centreon/common/force10/snmp/mode/hardware.pm

@@ -0,0 +1,338 @@
+#
+# Copyright 2015 Centreon (http://www.centreon.com/)
+#
+# Centreon is a full-fledged industry-strength solution that meets
+# the needs in IT infrastructure and application monitoring for
+# service performance.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+package centreon::common::force10::snmp::mode::hardware;
+
+use base qw(centreon::plugins::mode);
+
+use strict;
+use warnings;
+use centreon::plugins::misc;
+
+my $thresholds = {
+    fan => [
+        ['up', 'OK'],
+        ['absent', 'OK'],
+        ['down', 'CRITICAL'],
+    ],
+    psu => [    
+        ['up', 'OK'],
+        ['absent', 'OK'],
+        ['down', 'CRITICAL'],
+        
+        ['normal', 'OK'],
+        ['warning', 'WARNING'],
+        ['critical', 'CRITICAL'],
+        ['shutdown', 'CRITICAL'],
+        ['notPresent', 'OK'],
+        ['notFunctioning', 'CRITICAL'],
+    ],
+};
+
+sub new {
+    my ($class, %options) = @_;
+    my $self = $class->SUPER::new(package => __PACKAGE__, %options);
+    bless $self, $class;
+    
+    $self->{version} = '1.0';
+    $options{options}->add_options(arguments =>
+                                { 
+                                  "filter:s@"               => { name => 'filter' },
+                                  "absent-problem:s@"       => { name => 'absent_problem' },
+                                  "component:s"             => { name => 'component', default => '.*' },
+                                  "no-component:s"          => { name => 'no_component' },
+                                  "threshold-overload:s@"   => { name => 'threshold_overload' },
+                                  "warning:s@"              => { name => 'warning' },
+                                  "critical:s@"             => { name => 'critical' },
+                                });
+
+    $self->{components} = {};
+    $self->{no_components} = undef;
+    
+    return $self;
+}
+
+sub check_options {
+    my ($self, %options) = @_;
+    $self->SUPER::init(%options);
+    
+    if (defined($self->{option_results}->{no_component})) {
+        if ($self->{option_results}->{no_component} ne '') {
+            $self->{no_components} = $self->{option_results}->{no_component};
+        } else {
+            $self->{no_components} = 'critical';
+        }
+    }
+    
+    $self->{filter} = [];
+    foreach my $val (@{$self->{option_results}->{filter}}) {
+        next if (!defined($val) || $val eq '');
+        my @values = split (/,/, $val);
+        push @{$self->{filter}}, { filter => $values[0], instance => $values[1] }; 
+    }
+    
+    $self->{absent_problem} = [];
+    foreach my $val (@{$self->{option_results}->{absent_problem}}) {
+        next if (!defined($val) || $val eq '');
+        my @values = split (/,/, $val);
+        push @{$self->{absent_problem}}, { filter => $values[0], instance => $values[1] }; 
+    }
+    
+    $self->{overload_th} = {};
+    foreach my $val (@{$self->{option_results}->{threshold_overload}}) {
+        next if (!defined($val) || $val eq '');
+        my @values = split (/,/, $val);
+        if (scalar(@values) < 3) {
+            $self->{output}->add_option_msg(short_msg => "Wrong threshold-overload option '" . $val . "'.");
+            $self->{output}->option_exit();
+        }
+        my ($section, $instance, $status, $filter);
+        if (scalar(@values) == 3) {
+            ($section, $status, $filter) = @values;
+            $instance = '.*';
+        } else {
+             ($section, $instance, $status, $filter) = @values;
+        }
+        if ($section !~ /^psu|fan$/) {
+            $self->{output}->add_option_msg(short_msg => "Wrong threshold-overload section '" . $val . "'.");
+            $self->{output}->option_exit();
+        }
+        if ($self->{output}->is_litteral_status(status => $status) == 0) {
+            $self->{output}->add_option_msg(short_msg => "Wrong threshold-overload status '" . $val . "'.");
+            $self->{output}->option_exit();
+        }
+        $self->{overload_th}->{$section} = [] if (!defined($self->{overload_th}->{$section}));
+        push @{$self->{overload_th}->{$section}}, {filter => $filter, status => $status, instance => $instance };
+    }
+    
+    $self->{numeric_threshold} = {};
+    foreach my $option (('warning', 'critical')) {
+        foreach my $val (@{$self->{option_results}->{$option}}) {
+            next if (!defined($val) || $val eq '');
+            if ($val !~ /^(.*?),(.*?),(.*)$/) {
+                $self->{output}->add_option_msg(short_msg => "Wrong $option option '" . $val . "'.");
+                $self->{output}->option_exit();
+            }
+            my ($section, $instance, $value) = ($1, $2, $3);
+            if ($section !~ /^temperature$/) {
+                $self->{output}->add_option_msg(short_msg => "Wrong $option option '" . $val . "'.");
+                $self->{output}->option_exit();
+            }
+            my $position = 0;
+            if (defined($self->{numeric_threshold}->{$section})) {
+                $position = scalar(@{$self->{numeric_threshold}->{$section}});
+            }
+            if (($self->{perfdata}->threshold_validate(label => $option . '-' . $section . '-' . $position, value => $value)) == 0) {
+                $self->{output}->add_option_msg(short_msg => "Wrong $option threshold '" . $value . "'.");
+                $self->{output}->option_exit();
+            }
+            $self->{numeric_threshold}->{$section} = [] if (!defined($self->{numeric_threshold}->{$section}));
+            push @{$self->{numeric_threshold}->{$section}}, { label => $option . '-' . $section . '-' . $position, threshold => $option, instance => $instance };
+        }
+    }
+}
+
+sub run {
+    my ($self, %options) = @_;
+    $self->{snmp} = $options{snmp};
+
+    my $snmp_request = [];
+    my @components = ('fan', 'psu', 'temperature');
+    foreach (@components) {
+        if (/$self->{option_results}->{component}/) {
+            my $mod_name = "centreon::common::force10::snmp::mode::components::$_";
+            centreon::plugins::misc::mymodule_load(output => $self->{output}, module => $mod_name,
+                                                   error_msg => "Cannot load module '$mod_name'.");
+            my $func = $mod_name->can('load');
+            $func->(request => $snmp_request);
+        }
+    }
+    
+    if (scalar(@{$snmp_request}) == 0) {
+        $self->{output}->add_option_msg(short_msg => "Wrong option. Cannot find component '" . $self->{option_results}->{component} . "'.");
+        $self->{output}->option_exit();
+    }
+    $self->{results} = $self->{snmp}->get_multiple_table(oids => $snmp_request);
+    
+    foreach (@components) {
+        if (/$self->{option_results}->{component}/) {
+            my $mod_name = "centreon::common::force10::snmp::mode::components::$_";
+            my $func = $mod_name->can('check');
+            $func->($self); 
+        }
+    }
+    
+    my $total_components = 0;
+    my $display_by_component = '';
+    my $display_by_component_append = '';
+    foreach my $comp (sort(keys %{$self->{components}})) {
+        # Skipping short msg when no components
+        next if ($self->{components}->{$comp}->{total} == 0 && $self->{components}->{$comp}->{skip} == 0);
+        $total_components += $self->{components}->{$comp}->{total} + $self->{components}->{$comp}->{skip};
+        my $count_by_components = $self->{components}->{$comp}->{total} + $self->{components}->{$comp}->{skip}; 
+        $display_by_component .= $display_by_component_append . $self->{components}->{$comp}->{total} . '/' . $count_by_components . ' ' . $self->{components}->{$comp}->{name};
+        $display_by_component_append = ', ';
+    }
+    
+    $self->{output}->output_add(severity => 'OK',
+                                short_msg => sprintf("All %s components are ok [%s].", 
+                                                     $total_components,
+                                                     $display_by_component)
+                                );
+
+    if (defined($self->{option_results}->{no_component}) && $total_components == 0) {
+        $self->{output}->output_add(severity => $self->{no_components},
+                                    short_msg => 'No components are checked.');
+    }
+
+    $self->{output}->display();
+    $self->{output}->exit();
+}
+
+sub absent_problem {
+    my ($self, %options) = @_;
+    
+    foreach (@{$self->{absent_problem}}) {
+        if ($options{section} =~ /$_->{filter}/) {
+            if (!defined($_->{instance}) || $options{instance} =~ /$_->{instance}/) {
+                $self->{output}->output_add(severity => 'CRITICAL',
+                                            short_msg => sprintf("Component '%s' instance '%s' is not present", 
+                                                                 $options{section}, $options{instance}));
+                $self->{output}->output_add(long_msg => sprintf("Skipping $options{section} section $options{instance} instance (not present)"));
+                $self->{components}->{$options{section}}->{skip}++;
+                return 1;
+            }
+        }
+    }
+    
+    return 0;
+}
+
+sub check_filter {
+    my ($self, %options) = @_;
+
+    foreach (@{$self->{filter}}) {
+        if ($options{section} =~ /$_->{filter}/) {
+            if (!defined($options{instance}) && !defined($_->{instance})) {
+                $self->{output}->output_add(long_msg => sprintf("Skipping $options{section} section."));
+                return 1;
+            } elsif (defined($options{instance}) && $options{instance} =~ /$_->{instance}/) {
+                $self->{output}->output_add(long_msg => sprintf("Skipping $options{section} section $options{instance} instance."));
+                return 1;
+            }
+        }
+    }
+    
+    return 0;
+}
+
+sub get_severity_numeric {
+    my ($self, %options) = @_;
+    my $status = 'OK'; # default
+    my $thresholds = { warning => undef, critical => undef };
+    my $checked = 0;
+    
+    if (defined($self->{numeric_threshold}->{$options{section}})) {
+        my $exits = [];
+        foreach (@{$self->{numeric_threshold}->{$options{section}}}) {
+            if ($options{instance} =~ /$_->{instance}/) {
+                push @{$exits}, $self->{perfdata}->threshold_check(value => $options{value}, threshold => [ { label => $_->{label}, exit_litteral => $_->{threshold} } ]);
+                $thresholds->{$_->{threshold}} = $self->{perfdata}->get_perfdata_for_output(label => $_->{label});
+                $checked = 1;
+            }
+        }
+        $status = $self->{output}->get_most_critical(status => $exits) if (scalar(@{$exits}) > 0);
+    }
+    
+    return ($status, $thresholds->{warning}, $thresholds->{critical}, $checked);
+}
+
+sub get_severity {
+    my ($self, %options) = @_;
+    my $status = 'UNKNOWN'; # default 
+    
+    if (defined($self->{overload_th}->{$options{section}})) {
+        foreach (@{$self->{overload_th}->{$options{section}}}) {            
+            if ($options{value} =~ /$_->{filter}/i && 
+                (!defined($options{instance}) || $options{instance} =~ /$_->{instance}/)) {
+                $status = $_->{status};
+                return $status;
+            }
+        }
+    }
+    my $label = defined($options{label}) ? $options{label} : $options{section};
+    foreach (@{$thresholds->{$label}}) {
+        if ($options{value} =~ /$$_[0]/i) {
+            $status = $$_[1];
+            return $status;
+        }
+    }
+    
+    return $status;
+}
+
+1;
+
+__END__
+
+=head1 MODE
+
+Check Hardware (Fan, Power Supply, Temperature).
+
+=over 8
+
+=item B<--component>
+
+Which component to check (Default: '.*').
+Can be: 'temperature', 'fan', 'psu'.
+
+=item B<--filter>
+
+Exclude some parts (comma seperated list) (Example: --filter=temperature --filter=psu)
+Can also exclude specific instance: --filter=fan,1
+
+=item B<--absent-problem>
+
+Return an error if an entity is not 'present' (default is skipping) (comma seperated list)
+Can be specific or global: --absent-problem=fan,1
+
+=item B<--no-component>
+
+Return an error if no compenents are checked.
+If total (with skipped) is 0. (Default: 'critical' returns).
+
+=item B<--threshold-overload>
+
+Set to overload default threshold values (syntax: section,[instance,]status,regexp)
+It used before default thresholds (order stays).
+Example: --threshold-overload='psu,WARNING,^(?!(up)$)'
+
+=item B<--warning>
+
+Set warning threshold for temperatures (syntax: type,instance,threshold)
+Example: --warning='temperature,.*,30'
+
+=item B<--critical>
+
+Set critical threshold for temperatures (syntax: type,instance,threshold)
+Example: --critical='temperature,.*,40'
+=back
+
+=cut

centreon-plugins/centreon/common/force10/snmp/mode/memory.pm

@@ -0,0 +1,213 @@
+#
+# Copyright 2015 Centreon (http://www.centreon.com/)
+#
+# Centreon is a full-fledged industry-strength solution that meets
+# the needs in IT infrastructure and application monitoring for
+# service performance.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+package centreon::common::force10::snmp::mode::memory;
+
+use base qw(centreon::plugins::mode);
+
+use strict;
+use warnings;
+use centreon::plugins::values;
+
+my $instance_mode;
+
+my $maps_counters = {
+    mem => {
+        '000_usage'   => {
+            set => {
+                key_values => [ { name => 'usage' }, { name => 'display' } ],
+                output_template => '%s %%', output_error_template => "%s",
+                perfdatas => [
+                    { label => 'used', value => 'usage_absolute', template => '%d',
+                      unit => '%', min => 0, max => 100, label_extra_instance => 1, instance_use => 'display_absolute' },
+                ],
+            },
+        },
+    }
+};
+
+sub new {
+    my ($class, %options) = @_;
+    my $self = $class->SUPER::new(package => __PACKAGE__, %options);
+    bless $self, $class;
+    
+    $self->{version} = '1.0';
+    $options{options}->add_options(arguments =>
+                                { 
+                                });
+                                
+    foreach my $key (('mem')) {
+        foreach (keys %{$maps_counters->{$key}}) {
+            my ($id, $name) = split /_/;
+            if (!defined($maps_counters->{$key}->{$_}->{threshold}) || $maps_counters->{$key}->{$_}->{threshold} != 0) {
+                $options{options}->add_options(arguments => {
+                                                            'warning-' . $name . ':s'    => { name => 'warning-' . $name },
+                                                            'critical-' . $name . ':s'    => { name => 'critical-' . $name },
+                                               });
+            }
+            $maps_counters->{$key}->{$_}->{obj} = centreon::plugins::values->new(output => $self->{output}, perfdata => $self->{perfdata},
+                                                      label => $name);
+            $maps_counters->{$key}->{$_}->{obj}->set(%{$maps_counters->{$key}->{$_}->{set}});
+        }
+    }
+    
+    return $self;
+}
+
+sub check_options {
+    my ($self, %options) = @_;
+    $self->SUPER::init(%options);
+    
+    foreach my $key (('mem')) {
+        foreach (keys %{$maps_counters->{$key}}) {
+            $maps_counters->{$key}->{$_}->{obj}->init(option_results => $self->{option_results});
+        }
+    }
+    $instance_mode = $self;
+}
+
+sub run_instances {
+    my ($self, %options) = @_;
+    
+    my $multiple = 1;
+    if (scalar(keys %{$self->{mem}}) == 1) {
+        $multiple = 0;
+    }
+    
+    if ($multiple == 1) {
+        $self->{output}->output_add(severity => 'OK',
+                                    short_msg => 'All memory usages are ok');
+    }
+    
+    foreach my $id (sort keys %{$self->{mem}}) {     
+        my ($short_msg, $short_msg_append, $long_msg, $long_msg_append) = ('', '', '', '');
+        my @exits = ();
+        foreach (sort keys %{$maps_counters->{mem}}) {
+            my $obj = $maps_counters->{mem}->{$_}->{obj};
+            $obj->set(instance => $id);
+        
+            my ($value_check) = $obj->execute(values => $self->{mem}->{$id});
+
+            if ($value_check != 0) {
+                $long_msg .= $long_msg_append . $obj->output_error();
+                $long_msg_append = ', ';
+                next;
+            }
+            my $exit2 = $obj->threshold_check();
+            push @exits, $exit2;
+
+            my $output = $obj->output();
+            $long_msg .= $long_msg_append . $output;
+            $long_msg_append = ', ';
+            
+            if (!$self->{output}->is_status(litteral => 1, value => $exit2, compare => 'ok')) {
+                $short_msg .= $short_msg_append . $output;
+                $short_msg_append = ', ';
+            }
+            
+            $obj->perfdata(extra_instance => $multiple);
+        }
+
+        my $prefix = "Memory Usage ";
+        if ($multiple == 1) {
+            $prefix = sprintf("Memory '%s' Usage ", $self->{mem}->{$id}->{display});
+        }
+        $self->{output}->output_add(long_msg => "${prefix}$long_msg");
+        my $exit = $self->{output}->get_most_critical(status => [ @exits ]);
+        if (!$self->{output}->is_status(litteral => 1, value => $exit, compare => 'ok')) {
+            $self->{output}->output_add(severity => $exit,
+                                        short_msg => "${prefix}$short_msg"
+                                        );
+        }
+        
+        if ($multiple == 0) {
+            $self->{output}->output_add(short_msg => "${prefix}$long_msg");
+        }
+    }
+}
+
+sub run {
+    my ($self, %options) = @_;
+
+    $self->manage_selection(%options);
+    $self->run_instances();
+     
+    $self->{output}->display();
+    $self->{output}->exit();
+}
+
+my $mapping = {
+    sseries => {
+        MemUsageUtil    => { oid => '.1.3.6.1.4.1.6027.3.10.1.2.9.1.5' },
+    },
+    mseries => {
+        MemUsageUtil    => { oid => '.1.3.6.1.4.1.6027.3.19.1.2.8.1.5' },
+    },
+    zseries => {
+        MemUsageUtil    => { oid => '.1.3.6.1.4.1.6027.3.25.1.2.3.1.4' },
+    },
+};
+
+sub manage_selection {
+    my ($self, %options) = @_;
+    
+    my $oids = { sseries => '.1.3.6.1.4.1.6027.3.10.1.2.9.1', mseries => '.1.3.6.1.4.1.6027.3.19.1.2.8.1', zseries => '.1.3.6.1.4.1.6027.3.25.1.2.3.1' };
+    my $results = $options{snmp}->get_multiple_table(oids => [ { oid => $oids->{sseries} }, { oid => $oids->{mseries} }, { oid => $oids->{zseries} } ], 
+                                                     nothing_quit => 1);
+    $self->{mem} = {};
+    foreach my $name (keys %{$oids}) {
+        foreach my $oid (keys %{$results->{$oids->{$name}}}) {
+            next if ($oid !~ /^$mapping->{$name}->{MemUsageUtil}->{oid}\.(.*)/);
+            my $instance = $1;
+            my $result = $options{snmp}->map_instance(mapping => $mapping->{$name}, results => $results->{$oids->{$name}}, instance => $instance);
+        
+            $self->{mem}->{$instance} = { display => $instance, 
+                                          usage => $result->{MemUsageUtil},
+                                        };
+        }
+    }
+    
+    if (scalar(keys %{$self->{mem}}) <= 0) {
+        $self->{output}->add_option_msg(short_msg => "No entry found.");
+        $self->{output}->option_exit();
+    }
+}
+
+1;
+
+__END__
+
+=head1 MODE
+
+Check memory usages.
+
+=over 8
+
+=item B<--warning-usage>
+
+Threshold warning (in percent).
+
+=item B<--critical-usage>
+
+Threshold critical (in percent).
+
+=back
+
+=cut

centreon-plugins/centreon/plugins/alternative/Getopt.pm

@@ -58,7 +58,7 @@ sub GetOptions {
     my $search_str = ',' . join(',', keys %opts) . ',';
     my $num_args = scalar(@ARGV);
     for (my $i = 0; $i < $num_args;) {
-        if ($ARGV[$i] =~ /^--(.*?)(?:=|$)(.*)/) {
+        if (defined($ARGV[$i]) && $ARGV[$i] =~ /^--(.*?)(?:=|$)(.*)/) {
             my ($option, $value) = ($1, $2);
             
             # find type of option
@@ -89,7 +89,7 @@ sub GetOptions {
             splice @ARGV, $i, 1;
             $num_args--;
         } else {
-            warn "argument $ARGV[$i] alone" if ($warn_message == 1);
+            warn "argument $ARGV[$i] alone" if ($warn_message == 1 && $i != 0 && defined($ARGV[$i]));
             $i++;
         }
     }

centreon-plugins/centreon/plugins/dbi.pm

@@ -25,6 +25,8 @@ use warnings;
 use DBI;
 use Digest::MD5 qw(md5_hex);
 
+my %handlers = ( ALRM => {} );
+
 sub new {
     my ($class, %options) = @_;
     my $self  = {};
@@ -50,6 +52,7 @@ sub new {
                       "password:s@"        => { name => 'password' },
                       "connect-options:s@" => { name => 'connect_options' },
                       "sql-errors-exit:s"  => { name => 'sql_errors_exit', default => 'unknown' },
+                      "timeout:i"          => { name => 'timeout' },
         });
     }
     $options{options}->add_help(package => __PACKAGE__, sections => 'DBI OPTIONS', once => 1);
@@ -69,9 +72,33 @@ sub new {
     # Sometimes, we need to set ENV
     $self->{env} = undef;
     
+    $self->set_signal_handlers();
+    
     return $self;
 }
 
+sub set_signal_handlers {
+    my $self = shift;
+
+    $SIG{ALRM} = \&class_handle_ALRM;
+    $handlers{ALRM}->{$self} = sub { $self->handle_ALRM() };
+}
+
+sub class_handle_ALRM {
+    foreach (keys %{$handlers{ALRM}}) {
+        &{$handlers{ALRM}->{$_}}();
+    }
+}
+
+sub handle_ALRM {
+    my $self = shift;
+    
+    $self->{output}->output_add(severity => $self->{sql_errors_exit},
+                                short_msg => "Timeout");
+    $self->{output}->display();
+    $self->{output}->exit();
+}
+
 # Method to manage multiples
 sub set_options {
     my ($self, %options) = @_;
@@ -111,6 +138,12 @@ sub check_options {
     $self->{env} = (defined($self->{option_results}->{env})) ? shift(@{$self->{option_results}->{env}}) : undef;
     $self->{sql_errors_exit} = $self->{option_results}->{sql_errors_exit};
     
+    $self->{timeout} = 10;
+    if (defined($self->{option_results}->{timeout}) && $self->{option_results}->{timeout} =~ /^\d+$/ &&
+        $self->{option_results}->{timeout} > 0) {
+        $self->{timeout} = $self->{option_results}->{timeout};
+    }
+    
     if (!defined($self->{data_source}) || $self->{data_source} eq '') {
         $self->{output}->add_option_msg(short_msg => "Need to specify data_source arguments.");
         $self->{output}->option_exit(exit_litteral => $self->{sql_errors_exit});
@@ -169,12 +202,14 @@ sub connect {
         }
     }
     
+    alarm($self->{timeout}) if (defined($self->{timeout}));
     $self->{instance} = DBI->connect(
         "DBI:". $self->{data_source},
         $self->{username},
         $self->{password},
         { "RaiseError" => 0, "PrintError" => 0, "AutoCommit" => 1, %{$self->{connect_options_hash}} }
     );
+    alarm(0) if (defined($self->{timeout}));
 
     if (!defined($self->{instance})) {
         my $err_msg = sprintf("Cannot connect: %s", defined($DBI::errstr) ? $DBI::errstr : "(no error string)");
@@ -272,6 +307,10 @@ Format: name=value,name2=value2,...
 
 Exit code for DB Errors (default: unknown)
 
+=item B<--timeout>
+
+Timeout in seconds for connection
+
 =back
 
 =head1 DESCRIPTION

centreon-plugins/centreon/plugins/options.pm

@@ -25,7 +25,7 @@ use Pod::Find qw(pod_where);
 use strict;
 use warnings;
 
-my $alternative = 0;
+my $alternative = 1;
 
 sub new {
     my $class = shift;

centreon-plugins/centreon/plugins/script.pm

@@ -31,7 +31,7 @@ use Pod::Find qw(pod_where);
 
 my %handlers = (DIE => {});
 
-my $global_version = 20151110;
+my $global_version = 20151126;
 
 sub new {
     my $class = shift;

centreon-plugins/centreon/plugins/snmp.pm

@@ -52,6 +52,7 @@ sub new {
                   "snmp-retries:s"            => { name => 'snmp_retries', default => 5 },
                   "maxrepetitions:s"          => { name => 'maxrepetitions', default => 50 },
                   "subsetleef:s"              => { name => 'subsetleef', default => 50 },
+                  "snmp-force-getnext"        => { name => 'snmp_force_getnext' },
                   "snmp-username:s"           => { name => 'snmp_security_name' },
                   "authpassphrase:s"          => { name => 'snmp_auth_passphrase' },
                   "authprotocol:s"            => { name => 'snmp_auth_protocol' },
@@ -354,7 +355,7 @@ sub get_multiple_table {
         
         my $vb = new SNMP::VarList(@bindings);
         
-        if ($self->is_snmpv1()) {
+        if ($self->is_snmpv1() || defined($self->{snmp_force_getnext})) {
             $self->{session}->getnext($vb);
         } else {
             my $current_repeat_count = floor($repeat_count / (scalar(keys %{$working_oids})));
@@ -420,6 +421,12 @@ sub get_multiple_table {
 
             $working_oids->{ $bases[$pos % $current_oids] }->{start} = $complete_oid;
         }
+        
+        # infinite loop. Some equipments it returns nothing!!??
+        if ($pos == -1) {
+            $self->{output}->add_option_msg(short_msg => "SNMP Table Request: problem to get values (try --snmp-force-getnext option)");
+            $self->{output}->option_exit(exit_litteral => $self->{snmp_errors_exit});
+        }
     }
     
     my $total = 0;
@@ -495,7 +502,7 @@ sub get_table {
         $last_oid =~ /(.*)\.(\d+)([\.\s]*)$/;
         my $vb = new SNMP::VarList([$1, $2]);
     
-        if ($self->is_snmpv1()) {
+        if ($self->is_snmpv1() || defined($self->{snmp_force_getnext})) {
             $self->{session}->getnext($vb);
         } else {
             $self->{session}->getbulk(0, $repeat_count, $vb);
@@ -636,6 +643,7 @@ sub check_options {
         $self->{output}->option_exit();
     }
 
+    $self->{snmp_force_getnext} = $options{option_results}->{snmp_force_getnext};
     $self->{maxrepetitions} = $options{option_results}->{maxrepetitions};
     $self->{subsetleef} = (defined($options{option_results}->{subsetleef}) && $options{option_results}->{subsetleef} =~ /^[0-9]+$/) ? $options{option_results}->{subsetleef} : 50;
     $self->{snmp_errors_exit} = $options{option_results}->{snmp_errors_exit};
@@ -842,6 +850,10 @@ Max repetitions value (default: 50) (only for SNMP v2 and v3).
 
 How many oid values per SNMP request (default: 50) (for get_leef method. Be cautious whe you set it. Prefer to let the default value).
 
+=item B<--snmp-force-getnext>
+
+Use snmp getnext function (even in snmp v2c and v3).
+
 =item B<--snmp-username>
 
 Security name (only for SNMP v3).

centreon-plugins/centreon/plugins/wsman.pm

@@ -312,8 +312,8 @@ sub request {
     
     ######
     # Check options
-    if (!defined($options{uri}) || !defined($options{wql_filter})) {
+    if (!defined($options{uri})) {
-        $self->{output}->add_option_msg(short_msg => 'Need to specify wql_filter and uri options');
+        $self->{output}->add_option_msg(short_msg => 'Need to specify uri option');
         $self->{output}->option_exit(exit_litteral => $self->{wsman_errors_exit});
     }
     
@@ -328,10 +328,13 @@ sub request {
     
     ######
     # Filter/Enumerate
-    my $filter = new openwsman::Filter::()
+    my $filter;
+    if (defined($options{wql_filter})) {
+        $filter = new openwsman::Filter::()
                                         or $self->internal_exit(msg => 'Could not create filter');
-    $filter->wql($options{wql_filter});
+        $filter->wql($options{wql_filter});
-    
+    }
+
     my $result = $self->{client}->enumerate($client_options, $filter, $options{uri});
     return undef if ($self->handle_dialog_fault(result => $result, msg => 'Could not enumerate instances: ', dont_quit => $dont_quit));
 

centreon-plugins/changelog

@@ -0,0 +1,2 @@
+2015-11-26 Quentin Garnier
+ * initial release

centreon-plugins/cloud/aws/mode/cloudwatch.pm

@@ -27,7 +27,6 @@ use warnings;
 use centreon::plugins::misc;
 use POSIX;
 use JSON;
-use Module::Load;
 
 my $CloudwatchMetrics = {
     cpu              => "cloud::aws::mode::metrics::ec2instancecpu",
@@ -199,14 +198,13 @@ sub run
 
     my ($msg, $exit_code, $awsapi);
 
-    if (defined($CloudwatchMetrics->{$self->{option_results}->{metric}}))
+    if ( defined( $CloudwatchMetrics->{ $self->{option_results}->{metric} } ) ) {
-    {
+        centreon::plugins::misc::mymodule_load(output => $options{output}, module => $CloudwatchMetrics->{$self->{option_results}->{metric}},
-        load $CloudwatchMetrics->{$self->{option_results}->{metric}}, qw/cloudwatchCheck/;
+                                               error_msg => "Cannot load module '" . $CloudwatchMetrics->{$self->{option_results}->{metric}} . "'.");
-        cloudwatchCheck($self);
+        my $func = $CloudwatchMetrics->{$self->{option_results}->{metric}}->can('cloudwatchCheck');
-    }
+        $func->($self);
-    else
+    } else {
-    {
+        $self->{output}->add_option_msg( short_msg => "Wrong option. Cannot find metric '" . $self->{option_results}->{metric} . "'." );
-        $self->{output}->add_option_msg(short_msg => "Wrong option. Cannot find metric '" . $self->{option_results}->{metric} . "'.");
         $self->{output}->option_exit();
     }
 

centreon-plugins/database/oracle/mode/tablespaceusage.pm

@@ -113,6 +113,9 @@ sub run {
                 a.tablespace_name = c.tablespace_name (+)
                 AND a.tablespace_name = b.tablespace_name
                 AND a.tablespace_name = d.tablespace_name (+)
+                AND (b.contents = 'PERMANENT'
+                OR (b.contents <> 'PERMANENT'
+                AND a.tablespace_name=(select value from v$parameter where name='undo_tablespace')))
             UNION ALL
             SELECT
                 d.tablespace_name "Tablespace",
@@ -180,6 +183,9 @@ sub run {
             WHERE
                 a.tablespace_name = c.tablespace_name (+)
                 AND a.tablespace_name = b.tablespace_name
+                AND (b.contents = 'PERMANENT'
+                OR (b.contents <> 'PERMANENT'
+                AND a.tablespace_name=(select value from v$parameter where name='undo_tablespace')))
             UNION ALL
             SELECT
                 a.tablespace_name "Tablespace",

centreon-plugins/hardware/server/cisco/ucs/mode/components/blade.pm

@@ -22,59 +22,62 @@ package hardware::server::cisco::ucs::mode::components::blade;
 
 use strict;
 use warnings;
-use hardware::server::cisco::ucs::mode::components::resources qw($thresholds);
+use hardware::server::cisco::ucs::mode::components::resources qw(%mapping_presence %mapping_overall_status);
+
+# In MIB 'CISCO-UNIFIED-COMPUTING-EQUIPMENT-MIB'
+my $mapping1 = {
+    cucsComputeBladePresence => { oid => '.1.3.6.1.4.1.9.9.719.1.9.2.1.45', map => \%mapping_presence },
+};
+my $mapping2 = {
+    cucsComputeBladeOperState => { oid => '.1.3.6.1.4.1.9.9.719.1.9.2.1.42', map => \%mapping_overall_status },
+};
+my $oid_cucsComputeBladeDn = '.1.3.6.1.4.1.9.9.719.1.9.2.1.2';
+
+sub load {
+    my (%options) = @_;
+    
+    push @{$options{request}}, { oid => $mapping1->{cucsComputeBladePresence}->{oid} },
+        { oid => $mapping2->{cucsComputeBladeOperState}->{oid} }, { oid => $oid_cucsComputeBladeDn };
+}
 
 sub check {
     my ($self) = @_;
 
-    # In MIB 'CISCO-UNIFIED-COMPUTING-EQUIPMENT-MIB'
     $self->{output}->output_add(long_msg => "Checking blades");
     $self->{components}->{blade} = {name => 'blades', total => 0, skip => 0};
     return if ($self->check_exclude(section => 'blade'));
-    
-    my $oid_cucsComputeBladePresence = '.1.3.6.1.4.1.9.9.719.1.9.2.1.45';
-    my $oid_cucsComputeBladeOperState = '.1.3.6.1.4.1.9.9.719.1.9.2.1.42';
-    my $oid_cucsComputeBladeDn = '.1.3.6.1.4.1.9.9.719.1.9.2.1.2';
 
-    my $result = $self->{snmp}->get_multiple_table(oids => [ 
+    foreach my $oid ($self->{snmp}->oid_lex_sort(keys %{$self->{results}->{$oid_cucsComputeBladeDn}})) {
-                                                            { oid => $oid_cucsComputeBladePresence },
+        $oid =~ /\.(\d+)$/;
-                                                            { oid => $oid_cucsComputeBladeOperState },
+        my $instance = $1;
-                                                            { oid => $oid_cucsComputeBladeDn },
+        my $blade_dn = $self->{results}->{$oid_cucsComputeBladeDn}->{$oid};
-                                                            ]
+        my $result = $self->{snmp}->map_instance(mapping => $mapping1, results => $self->{results}->{$mapping1->{cucsComputeBladePresence}->{oid}}, instance => $instance);
-                                                   );
+        my $result2 = $self->{snmp}->map_instance(mapping => $mapping2, results => $self->{results}->{$mapping2->{cucsComputeBladeOperState}->{oid}}, instance => $instance);
-    foreach my $key ($self->{snmp}->oid_lex_sort(keys %{$result->{$oid_cucsComputeBladePresence}})) {
+
-        # index
-        $key =~ /\.(\d+)$/;
-        my $blade_index = $1;        
-        my $blade_dn = $result->{$oid_cucsComputeBladeDn}->{$oid_cucsComputeBladeDn . '.' . $blade_index};
-        my $blade_operstate = defined($result->{$oid_cucsComputeBladeOperState}->{$oid_cucsComputeBladeOperState . '.' . $blade_index}) ?
-                                $result->{$oid_cucsComputeBladeOperState}->{$oid_cucsComputeBladeOperState . '.' . $blade_index} : 0; # unknown
-        my $blade_presence = defined($result->{$oid_cucsComputeBladePresence}->{$oid_cucsComputeBladePresence . '.' . $blade_index}) ? 
-                                $result->{$oid_cucsComputeBladePresence}->{$oid_cucsComputeBladePresence . '.' . $blade_index} : 0;
-        
         next if ($self->absent_problem(section => 'blade', instance => $blade_dn));
         next if ($self->check_exclude(section => 'blade', instance => $blade_dn));
 
-        my $exit = $self->get_severity(section => 'blade', threshold => 'presence', value => $blade_presence);
+        $self->{output}->output_add(long_msg => sprintf("blade '%s' state is '%s' [presence: %s].",
+                                                        $blade_dn, $result2->{cucsComputeBladeOperState},
+                                                        $result->{cucsComputeBladePresence})
+                                    );
+        
+        my $exit = $self->get_severity(section => 'blade.presence', label => 'default.presence', value => $result->{cucsComputeBladePresence});
         if (!$self->{output}->is_status(value => $exit, compare => 'ok', litteral => 1)) {
             $self->{output}->output_add(severity => $exit,
                                         short_msg => sprintf("blade '%s' presence is: '%s'",
-                                                             $blade_dn, ${$thresholds->{presence}{$blade_presence}}[0])
+                                                             $blade_dn, $result->{cucsComputeBladePresence})
                                         );
             next;
         }
         
         $self->{components}->{blade}->{total}++;
-        
+
-        $self->{output}->output_add(long_msg => sprintf("blade '%s' state is '%s' [presence: %s].",
+        $exit = $self->get_severity(section => 'blade.overall_status', label => 'default.overall_status', value => $result2->{cucsComputeBladeOperState});
-                                                        $blade_dn, ${$thresholds->{overall_status}->{$blade_operstate}}[0],
-                                                        ${$thresholds->{presence}->{$blade_presence}}[0]
-                                    ));
-        $exit = $self->get_severity(section => 'blade', threshold => 'overall_status', value => $blade_operstate);
         if (!$self->{output}->is_status(value => $exit, compare => 'ok', litteral => 1)) {
             $self->{output}->output_add(severity => $exit,
-                                        short_msg => sprintf("blade '%s' state is '%s'.",
+                                        short_msg => sprintf("blade '%s' state is '%s'",
-                                                             $blade_dn, ${$thresholds->{overall_status}->{$blade_operstate}}[0]
+                                                             $blade_dn, $result2->{cucsComputeBladeOperState}
                                                              )
                                         );
         }

centreon-plugins/hardware/server/cisco/ucs/mode/components/chassis.pm

@@ -22,32 +22,34 @@ package hardware::server::cisco::ucs::mode::components::chassis;
 
 use strict;
 use warnings;
-use hardware::server::cisco::ucs::mode::components::resources qw($thresholds);
+use hardware::server::cisco::ucs::mode::components::resources qw(%mapping_operability);
+
+# In MIB 'CISCO-UNIFIED-COMPUTING-EQUIPMENT-MIB'
+# Don't do the 'presence'. Is 'unknown' ??!!!
+my $mapping1 = {
+    cucsEquipmentChassisOperState => { oid => '.1.3.6.1.4.1.9.9.719.1.15.7.1.27', map => \%mapping_operability },
+};
+my $oid_cucsEquipmentChassisDn = '.1.3.6.1.4.1.9.9.719.1.15.7.1.2';
+
+sub load {
+    my (%options) = @_;
+    
+    push @{$options{request}}, { oid => $mapping1->{cucsEquipmentChassisOperState}->{oid} },
+        { oid => $oid_cucsEquipmentChassisDn };
+}
 
 sub check {
     my ($self) = @_;
 
-    # In MIB 'CISCO-UNIFIED-COMPUTING-EQUIPMENT-MIB'
     $self->{output}->output_add(long_msg => "Checking chassis");
     $self->{components}->{chassis} = {name => 'chassis', total => 0, skip => 0};
     return if ($self->check_exclude(section => 'chassis'));
-    
-    # Don't do the 'presence'. Is 'unknown' ??!!!
-    my $oid_cucsEquipmentChassisOperState = '.1.3.6.1.4.1.9.9.719.1.15.7.1.27';
-    my $oid_cucsEquipmentChassisDn = '.1.3.6.1.4.1.9.9.719.1.15.7.1.2';
 
-    my $result = $self->{snmp}->get_multiple_table(oids => [ 
+    foreach my $oid ($self->{snmp}->oid_lex_sort(keys %{$self->{results}->{$oid_cucsEquipmentChassisDn}})) {
-                                                            { oid => $oid_cucsEquipmentChassisOperState },
+        $oid =~ /\.(\d+)$/;
-                                                            { oid => $oid_cucsEquipmentChassisDn },
+        my $instance = $1;
-                                                            ]
+        my $chassis_dn = $self->{results}->{$oid_cucsEquipmentChassisDn}->{$oid};
-                                                   );
+        my $result = $self->{snmp}->map_instance(mapping => $mapping1, results => $self->{results}->{$mapping1->{cucsEquipmentChassisOperState}->{oid}}, instance => $instance);
-    foreach my $key ($self->{snmp}->oid_lex_sort(keys %{$result->{$oid_cucsEquipmentChassisOperState}})) {
-        # index
-        $key =~ /\.(\d+)$/;
-        my $chassis_index = $1;        
-        my $chassis_dn = $result->{$oid_cucsEquipmentChassisDn}->{$oid_cucsEquipmentChassisDn . '.' . $chassis_index};
-        my $chassis_operstate = defined($result->{$oid_cucsEquipmentChassisOperState}->{$oid_cucsEquipmentChassisOperState . '.' . $chassis_index}) ?
-                                $result->{$oid_cucsEquipmentChassisOperState}->{$oid_cucsEquipmentChassisOperState . '.' . $chassis_index} : 0; # unknown
 
         next if ($self->absent_problem(section => 'chassis', instance => $chassis_dn));
         next if ($self->check_exclude(section => 'chassis', instance => $chassis_dn));
@@ -55,13 +57,13 @@ sub check {
         $self->{components}->{chassis}->{total}++;
         
         $self->{output}->output_add(long_msg => sprintf("chassis '%s' state is '%s'.",
-                                                        $chassis_dn, ${$thresholds->{operability}->{$chassis_operstate}}[0]
+                                                        $chassis_dn, $result->{cucsEquipmentChassisOperState})
-                                    ));
+                                    );
-        my $exit = $self->get_severity(section => 'chassis', threshold => 'operability', value => $chassis_operstate);
+        my $exit = $self->get_severity(section => 'chassis.operability', label => 'default.operability', value => $result->{cucsEquipmentChassisOperState});
         if (!$self->{output}->is_status(value => $exit, compare => 'ok', litteral => 1)) {
             $self->{output}->output_add(severity => $exit,
-                                        short_msg => sprintf("chassis '%s' state is '%s'.",
+                                        short_msg => sprintf("chassis '%s' state is '%s'",
-                                                             $chassis_dn, ${$thresholds->{operability}->{$chassis_operstate}}[0]
+                                                             $chassis_dn, $result->{cucsEquipmentChassisOperState}
                                                              )
                                         );
         }

centreon-plugins/hardware/server/cisco/ucs/mode/components/cpu.pm

@@ -0,0 +1,87 @@
+#
+# Copyright 2015 Centreon (http://www.centreon.com/)
+#
+# Centreon is a full-fledged industry-strength solution that meets
+# the needs in IT infrastructure and application monitoring for
+# service performance.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+package hardware::server::cisco::ucs::mode::components::cpu;
+
+use strict;
+use warnings;
+use hardware::server::cisco::ucs::mode::components::resources qw(%mapping_presence %mapping_operability);
+
+# In MIB 'CISCO-UNIFIED-COMPUTING-PROCESSOR-MIB'
+my $mapping1 = {
+    cucsProcessorUnitPresence => { oid => '.1.3.6.1.4.1.9.9.719.1.41.9.1.13', map => \%mapping_presence },
+};
+my $mapping2 = {
+    cucsProcessorUnitOperState => { oid => '.1.3.6.1.4.1.9.9.719.1.41.9.1.9', map => \%mapping_operability },
+};
+my $oid_cucsProcessorUnitDn = '.1.3.6.1.4.1.9.9.719.1.41.9.1.2';
+
+sub load {
+    my (%options) = @_;
+    
+    push @{$options{request}}, { oid => $mapping1->{cucsProcessorUnitPresence}->{oid} },
+        { oid => $mapping2->{cucsProcessorUnitOperState}->{oid} }, { oid => $oid_cucsProcessorUnitDn };
+}
+
+sub check {
+    my ($self) = @_;
+
+    $self->{output}->output_add(long_msg => "Checking cpus");
+    $self->{components}->{cpu} = {name => 'cpus', total => 0, skip => 0};
+    return if ($self->check_exclude(section => 'cpu'));
+
+    foreach my $oid ($self->{snmp}->oid_lex_sort(keys %{$self->{results}->{$oid_cucsProcessorUnitDn}})) {
+        $oid =~ /\.(\d+)$/;
+        my $instance = $1;
+        my $cpu_dn = $self->{results}->{$oid_cucsProcessorUnitDn}->{$oid};
+        my $result = $self->{snmp}->map_instance(mapping => $mapping1, results => $self->{results}->{$mapping1->{cucsProcessorUnitPresence}->{oid}}, instance => $instance);
+        my $result2 = $self->{snmp}->map_instance(mapping => $mapping2, results => $self->{results}->{$mapping2->{cucsProcessorUnitOperState}->{oid}}, instance => $instance);
+        
+        next if ($self->absent_problem(section => 'cpu', instance => $cpu_dn));
+        next if ($self->check_exclude(section => 'cpu', instance => $cpu_dn));
+
+        $self->{output}->output_add(long_msg => sprintf("cpu '%s' state is '%s' [presence: %s].",
+                                                        $cpu_dn, $result2->{cucsProcessorUnitOperState},
+                                                        $result->{cucsProcessorUnitPresence})
+                                    );
+
+        my $exit = $self->get_severity(section => 'cpu.presence', label => 'default.presence', value => $result->{cucsProcessorUnitPresence});
+        if (!$self->{output}->is_status(value => $exit, compare => 'ok', litteral => 1)) {
+            $self->{output}->output_add(severity => $exit,
+                                        short_msg => sprintf("cpu '%s' presence is: '%s'",
+                                                             $cpu_dn, $result->{cucsProcessorUnitPresence})
+                                        );
+            next;
+        }
+        
+        $self->{components}->{cpu}->{total}++;
+
+        $exit = $self->get_severity(section => 'cpu.operability', label => 'default.operability', value => $result2->{cucsProcessorUnitOperState});
+        if (!$self->{output}->is_status(value => $exit, compare => 'ok', litteral => 1)) {
+            $self->{output}->output_add(severity => $exit,
+                                        short_msg => sprintf("cpu '%s' state is '%s'",
+                                                             $cpu_dn, $result2->{cucsProcessorUnitOperState}
+                                                             )
+                                        );
+        }
+    }
+}
+
+1;

centreon-plugins/hardware/server/cisco/ucs/mode/components/fan.pm

@@ -22,58 +22,62 @@ package hardware::server::cisco::ucs::mode::components::fan;
 
 use strict;
 use warnings;
-use hardware::server::cisco::ucs::mode::components::resources qw($thresholds);
+use hardware::server::cisco::ucs::mode::components::resources qw(%mapping_presence %mapping_operability);
+
+# In MIB 'CISCO-UNIFIED-COMPUTING-EQUIPMENT-MIB'
+my $mapping1 = {
+    cucsEquipmentFanPresence => { oid => '.1.3.6.1.4.1.9.9.719.1.15.12.1.13', map => \%mapping_presence },
+};
+my $mapping2 = {
+    cucsEquipmentFanOperState => { oid => '.1.3.6.1.4.1.9.9.719.1.15.12.1.9', map => \%mapping_operability },
+};
+my $oid_cucsEquipmentFanDn = '.1.3.6.1.4.1.9.9.719.1.15.12.1.2';
+
+sub load {
+    my (%options) = @_;
+    
+    push @{$options{request}}, { oid => $mapping1->{cucsEquipmentFanPresence}->{oid} },
+        { oid => $mapping2->{cucsEquipmentFanOperState}->{oid} }, { oid => $oid_cucsEquipmentFanDn };
+}
 
 sub check {
     my ($self) = @_;
 
-    # In MIB 'CISCO-UNIFIED-COMPUTING-EQUIPMENT-MIB'
     $self->{output}->output_add(long_msg => "Checking fans");
     $self->{components}->{fan} = {name => 'fans', total => 0, skip => 0};
     return if ($self->check_exclude(section => 'fan'));
-    
-    my $oid_cucsEquipmentFanPresence = '.1.3.6.1.4.1.9.9.719.1.15.12.1.13';
-    my $oid_cucsEquipmentFanOperState = '.1.3.6.1.4.1.9.9.719.1.15.12.1.9';
-    my $oid_cucsEquipmentFanDn = '.1.3.6.1.4.1.9.9.719.1.15.12.1.2';
 
-    my $result = $self->{snmp}->get_multiple_table(oids => [ 
+    foreach my $oid ($self->{snmp}->oid_lex_sort(keys %{$self->{results}->{$oid_cucsEquipmentFanDn}})) {
-                                                            { oid => $oid_cucsEquipmentFanPresence },
+        $oid =~ /\.(\d+)$/;
-                                                            { oid => $oid_cucsEquipmentFanOperState },
+        my $instance = $1;
-                                                            { oid => $oid_cucsEquipmentFanDn },
+        my $fan_dn = $self->{results}->{$oid_cucsEquipmentFanDn}->{$oid};
-                                                            ]
+        my $result = $self->{snmp}->map_instance(mapping => $mapping1, results => $self->{results}->{$mapping1->{cucsEquipmentFanPresence}->{oid}}, instance => $instance);
-                                                   );
+        my $result2 = $self->{snmp}->map_instance(mapping => $mapping2, results => $self->{results}->{$mapping2->{cucsEquipmentFanOperState}->{oid}}, instance => $instance);
-    foreach my $key ($self->{snmp}->oid_lex_sort(keys %{$result->{$oid_cucsEquipmentFanPresence}})) {
-        # index
-        $key =~ /\.(\d+)$/;
-        my $fan_index = $1;        
-        my $fan_dn = $result->{$oid_cucsEquipmentFanDn}->{$oid_cucsEquipmentFanDn . '.' . $fan_index};
-        my $fan_operstate = defined($result->{$oid_cucsEquipmentFanOperState}->{$oid_cucsEquipmentFanOperState . '.' . $fan_index}) ?
-                                $result->{$oid_cucsEquipmentFanOperState}->{$oid_cucsEquipmentFanOperState . '.' . $fan_index} : 0; # unknown
-        my $fan_presence = defined($result->{$oid_cucsEquipmentFanPresence}->{$oid_cucsEquipmentFanPresence . '.' . $fan_index}) ? 
-                                $result->{$oid_cucsEquipmentFanPresence}->{$oid_cucsEquipmentFanPresence . '.' . $fan_index} : 0;
         
         next if ($self->absent_problem(section => 'fan', instance => $fan_dn));
         next if ($self->check_exclude(section => 'fan', instance => $fan_dn));
 
-        my $exit = $self->get_severity(section => 'fan', threshold => 'presence', value => $fan_presence);
+        $self->{output}->output_add(long_msg => sprintf("fan '%s' state is '%s' [presence: %s].",
+                                                        $fan_dn, $result2->{cucsEquipmentFanOperState},
+                                                        $result->{cucsEquipmentFanPresence})
+                                    );
+
+        my $exit = $self->get_severity(section => 'fan.presence', label => 'default.presence', value => $result->{cucsEquipmentFanPresence});
         if (!$self->{output}->is_status(value => $exit, compare => 'ok', litteral => 1)) {
             $self->{output}->output_add(severity => $exit,
                                         short_msg => sprintf("fan '%s' presence is: '%s'",
-                                                             $fan_dn, ${$thresholds->{presence}->{$fan_presence}}[0])
+                                                             $fan_dn, $result->{cucsEquipmentFanPresence})
                                         );
             next;
         }
         
-        $self->{components}->{fan}->{total}++;      
+        $self->{components}->{fan}->{total}++;
-        $self->{output}->output_add(long_msg => sprintf("fan '%s' state is '%s' [presence: %s].",
+
-                                                        $fan_dn, ${$thresholds->{operability}->{$fan_operstate}}[0],
+        $exit = $self->get_severity(section => 'fan.operability', label => 'default.operability', value => $result2->{cucsEquipmentFanOperState});
-                                                        ${$thresholds->{presence}->{$fan_presence}}[0]
-                                    ));
-        $exit = $self->get_severity(section => 'fan', threshold => 'operability', value => $fan_operstate);
         if (!$self->{output}->is_status(value => $exit, compare => 'ok', litteral => 1)) {
             $self->{output}->output_add(severity => $exit,
-                                        short_msg => sprintf("fan '%s' state is '%s'.",
+                                        short_msg => sprintf("fan '%s' state is '%s'",
-                                                             $fan_dn, ${$thresholds->{operability}->{$fan_operstate}}[0]
+                                                             $fan_dn, $result2->{cucsEquipmentFanOperState}
                                                              )
                                         );
         }

centreon-plugins/hardware/server/cisco/ucs/mode/components/fex.pm

@@ -22,59 +22,62 @@ package hardware::server::cisco::ucs::mode::components::fex;
 
 use strict;
 use warnings;
-use hardware::server::cisco::ucs::mode::components::resources qw($thresholds);
+use hardware::server::cisco::ucs::mode::components::resources qw(%mapping_presence %mapping_operability);
+
+# In MIB 'CISCO-UNIFIED-COMPUTING-EQUIPMENT-MIB'
+my $mapping1 = {
+    cucsEquipmentFexPresence => { oid => '.1.3.6.1.4.1.9.9.719.1.15.19.1.24', map => \%mapping_presence },
+};
+my $mapping2 = {
+    cucsEquipmentFexOperState => { oid => '.1.3.6.1.4.1.9.9.719.1.15.19.1.21', map => \%mapping_operability },
+};
+my $oid_cucsEquipmentFexDn = '.1.3.6.1.4.1.9.9.719.1.15.19.1.2';
+
+sub load {
+    my (%options) = @_;
+    
+    push @{$options{request}}, { oid => $mapping1->{cucsEquipmentFexPresence}->{oid} },
+        { oid => $mapping2->{cucsEquipmentFexOperState}->{oid} }, { oid => $oid_cucsEquipmentFexDn };
+}
 
 sub check {
     my ($self) = @_;
 
-    # In MIB 'CISCO-UNIFIED-COMPUTING-EQUIPMENT-MIB'
     $self->{output}->output_add(long_msg => "Checking fabric extenders");
     $self->{components}->{fex} = {name => 'fabric extenders', total => 0, skip => 0};
     return if ($self->check_exclude(section => 'fex'));
-    
-    my $oid_cucsEquipmentFexDn = '.1.3.6.1.4.1.9.9.719.1.15.19.1.2';
-    my $oid_cucsEquipmentFexOperState = '.1.3.6.1.4.1.9.9.719.1.15.19.1.21';
-    my $oid_cucsEquipmentFexPresence = '.1.3.6.1.4.1.9.9.719.1.15.19.1.24';
 
-    my $result = $self->{snmp}->get_multiple_table(oids => [ 
+    foreach my $oid ($self->{snmp}->oid_lex_sort(keys %{$self->{results}->{$oid_cucsEquipmentFexDn}})) {
-                                                            { oid => $oid_cucsEquipmentFexDn },
+        $oid =~ /\.(\d+)$/;
-                                                            { oid => $oid_cucsEquipmentFexOperState },
+        my $instance = $1;
-                                                            { oid => $oid_cucsEquipmentFexPresence },
+        my $fex_dn = $self->{results}->{$oid_cucsEquipmentFexDn}->{$oid};
-                                                            ]
+        my $result = $self->{snmp}->map_instance(mapping => $mapping1, results => $self->{results}->{$mapping1->{cucsEquipmentFexPresence}->{oid}}, instance => $instance);
-                                                   );
+        my $result2 = $self->{snmp}->map_instance(mapping => $mapping2, results => $self->{results}->{$mapping2->{cucsEquipmentFexOperState}->{oid}}, instance => $instance);
-    foreach my $key ($self->{snmp}->oid_lex_sort(keys %{$result->{$oid_cucsEquipmentFexDn}})) {
-        # index
-        $key =~ /\.(\d+)$/;
-        my $fex_index = $1;
-        my $fex_dn = $result->{$oid_cucsEquipmentFexDn}->{$oid_cucsEquipmentFexDn . '.' . $fex_index};
-        my $fex_operstate = defined($result->{$oid_cucsEquipmentFexOperState}->{$oid_cucsEquipmentFexOperState . '.' . $fex_index}) ?
-                                $result->{$oid_cucsEquipmentFexOperState}->{$oid_cucsEquipmentFexOperState . '.' . $fex_index} : 0; # unknown
-        my $fex_presence = defined($result->{$oid_cucsEquipmentFexPresence}->{$oid_cucsEquipmentFexPresence . '.' . $fex_index}) ? 
-                                $result->{$oid_cucsEquipmentFexPresence}->{$oid_cucsEquipmentFexPresence . '.' . $fex_index} : 0;
         
         next if ($self->absent_problem(section => 'fex', instance => $fex_dn));
         next if ($self->check_exclude(section => 'fex', instance => $fex_dn));
 
-        my $exit = $self->get_severity(section => 'fex', threshold => 'presence', value => $fex_presence);
+        $self->{output}->output_add(long_msg => sprintf("Fabric extender '%s' state is '%s' [presence: %s].",
+                                                        $fex_dn, $result2->{cucsEquipmentFexOperState},
+                                                        $result->{cucsEquipmentFexPresence})
+                                    );
+        
+        my $exit = $self->get_severity(section => 'fex.presence', label => 'default.presence', value => $result->{cucsEquipmentFexPresence});
         if (!$self->{output}->is_status(value => $exit, compare => 'ok', litteral => 1)) {
             $self->{output}->output_add(severity => $exit,
                                         short_msg => sprintf("Fabric extender '%s' presence is: '%s'",
-                                                             $fex_dn, ${$thresholds->{presence}->{$fex_presence}}[0])
+                                                             $fex_dn, $result->{cucsEquipmentFexPresence})
                                         );
             next;
         }
         
         $self->{components}->{fex}->{total}++;
-        
+
-        $self->{output}->output_add(long_msg => sprintf("Fabric extender '%s' state is '%s' [presence: %s].",
+        $exit = $self->get_severity(section => 'fex.presence', label => 'default.operability', value => $result2->{cucsEquipmentFexOperState});
-                                                        $fex_dn, ${$thresholds->{operability}->{$fex_operstate}}[0],
-                                                        ${$thresholds->{presence}->{$fex_presence}}[0]
-                                    ));
-        $exit = $self->get_severity(section => 'fex', threshold => 'operability', value => $fex_operstate);
         if (!$self->{output}->is_status(value => $exit, compare => 'ok', litteral => 1)) {
             $self->{output}->output_add(severity => $exit,
                                         short_msg => sprintf("Fabric extender '%s' state is '%s'.",
-                                                             $fex_dn, ${$thresholds->{operability}->{$fex_operstate}}[0]
+                                                             $fex_dn, $result2->{cucsEquipmentFexOperState}
                                                              )
                                         );
         }

centreon-plugins/hardware/server/cisco/ucs/mode/components/iocard.pm

@@ -22,7 +22,23 @@ package hardware::server::cisco::ucs::mode::components::iocard;
 
 use strict;
 use warnings;
-use hardware::server::cisco::ucs::mode::components::resources qw($thresholds);
+use hardware::server::cisco::ucs::mode::components::resources qw(%mapping_presence %mapping_operability);
+
+# In MIB 'CISCO-UNIFIED-COMPUTING-EQUIPMENT-MIB'
+my $mapping1 = {
+    cucsEquipmentIOCardPresence => { oid => '.1.3.6.1.4.1.9.9.719.1.15.30.1.31', map => \%mapping_presence },
+};
+my $mapping2 = {
+    cucsEquipmentIOCardOperState => { oid => '.1.3.6.1.4.1.9.9.719.1.15.30.1.25', map => \%mapping_operability },
+};
+my $oid_cucsEquipmentIOCardDn = '.1.3.6.1.4.1.9.9.719.1.15.30.1.2';
+
+sub load {
+    my (%options) = @_;
+    
+    push @{$options{request}}, { oid => $mapping1->{cucsEquipmentIOCardPresence}->{oid} },
+        { oid => $mapping2->{cucsEquipmentIOCardOperState}->{oid} }, { oid => $oid_cucsEquipmentIOCardDn };
+}
 
 sub check {
     my ($self) = @_;
@@ -31,50 +47,38 @@ sub check {
     $self->{output}->output_add(long_msg => "Checking io cards");
     $self->{components}->{iocard} = {name => 'io cards', total => 0, skip => 0};
     return if ($self->check_exclude(section => 'iocard'));
-    
-    my $oid_cucsEquipmentIOCardPresence = '.1.3.6.1.4.1.9.9.719.1.15.30.1.31';
-    my $oid_cucsEquipmentIOCardOperState = '.1.3.6.1.4.1.9.9.719.1.15.30.1.25';
-    my $oid_cucsEquipmentIOCardDn = '.1.3.6.1.4.1.9.9.719.1.15.30.1.2';
 
-    my $result = $self->{snmp}->get_multiple_table(oids => [ 
+    foreach my $oid ($self->{snmp}->oid_lex_sort(keys %{$self->{results}->{$oid_cucsEquipmentIOCardDn}})) {
-                                                            { oid => $oid_cucsEquipmentIOCardPresence },
+        $oid =~ /\.(\d+)$/;
-                                                            { oid => $oid_cucsEquipmentIOCardOperState },
+        my $instance = $1;
-                                                            { oid => $oid_cucsEquipmentIOCardDn },
+        my $iocard_dn = $self->{results}->{$oid_cucsEquipmentIOCardDn}->{$oid};
-                                                            ]
+        my $result = $self->{snmp}->map_instance(mapping => $mapping1, results => $self->{results}->{$mapping1->{cucsEquipmentIOCardPresence}->{oid}}, instance => $instance);
-                                                   );
+        my $result2 = $self->{snmp}->map_instance(mapping => $mapping2, results => $self->{results}->{$mapping2->{cucsEquipmentIOCardOperState}->{oid}}, instance => $instance);
-    foreach my $key ($self->{snmp}->oid_lex_sort(keys %{$result->{$oid_cucsEquipmentIOCardPresence}})) {
-        # index
-        $key =~ /\.(\d+)$/;
-        my $iocard_index = $1;        
-        my $iocard_dn = $result->{$oid_cucsEquipmentIOCardDn}->{$oid_cucsEquipmentIOCardDn . '.' . $iocard_index};
-        my $iocard_operstate = defined($result->{$oid_cucsEquipmentIOCardOperState}->{$oid_cucsEquipmentIOCardOperState . '.' . $iocard_index}) ?
-                                $result->{$oid_cucsEquipmentIOCardOperState}->{$oid_cucsEquipmentIOCardOperState . '.' . $iocard_index} : 0; # unknown
-        my $iocard_presence = defined($result->{$oid_cucsEquipmentIOCardPresence}->{$oid_cucsEquipmentIOCardPresence . '.' . $iocard_index}) ? 
-                                $result->{$oid_cucsEquipmentIOCardPresence}->{$oid_cucsEquipmentIOCardPresence . '.' . $iocard_index} : 0;
         
         next if ($self->absent_problem(section => 'iocard', instance => $iocard_dn));
         next if ($self->check_exclude(section => 'iocard', instance => $iocard_dn));
 
-        my $exit = $self->get_severity(section => 'iocard', threshold => 'presence', value => $iocard_presence);
+        $self->{output}->output_add(long_msg => sprintf("IO cards '%s' state is '%s' [presence: %s].",
+                                                        $iocard_dn, $result2->{cucsEquipmentIOCardOperState},
+                                                        $result->{cucsEquipmentIOCardPresence})
+                                    );
+        
+        my $exit = $self->get_severity(section => 'iocard.presence', label => 'default.presence', value => $result->{cucsEquipmentIOCardPresence});
         if (!$self->{output}->is_status(value => $exit, compare => 'ok', litteral => 1)) {
             $self->{output}->output_add(severity => $exit,
                                         short_msg => sprintf("IO cards '%s' presence is: '%s'",
-                                                             $iocard_dn, ${$thresholds->{presence}->{$iocard_presence}}[0])
+                                                             $iocard_dn, $result->{cucsEquipmentIOCardPresence})
                                         );
             next;
         }
         
         $self->{components}->{iocard}->{total}++;
         
-        $self->{output}->output_add(long_msg => sprintf("IO cards '%s' state is '%s' [presence: %s].",
+        $exit = $self->get_severity(section => 'default.operability', label => 'iocard.operability', value => $result2->{cucsEquipmentIOCardOperState});
-                                                        $iocard_dn, ${$thresholds->{operability}->{$iocard_operstate}}[0],
-                                                        ${$thresholds->{presence}->{$iocard_presence}}[0]
-                                    ));
-        $exit = $self->get_severity(section => 'iocard', threshold => 'operability', value => $iocard_operstate);
         if (!$self->{output}->is_status(value => $exit, compare => 'ok', litteral => 1)) {
             $self->{output}->output_add(severity => $exit,
                                         short_msg => sprintf("IO cards '%s' state is '%s'.",
-                                                             $iocard_dn, ${$thresholds->{operability}->{$iocard_operstate}}[0]
+                                                             $iocard_dn, $result2->{cucsEquipmentIOCardOperState}
                                                              )
                                         );
         }

centreon-plugins/hardware/server/cisco/ucs/mode/components/localdisk.pm

@@ -0,0 +1,87 @@
+#
+# Copyright 2015 Centreon (http://www.centreon.com/)
+#
+# Centreon is a full-fledged industry-strength solution that meets
+# the needs in IT infrastructure and application monitoring for
+# service performance.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+package hardware::server::cisco::ucs::mode::components::localdisk;
+
+use strict;
+use warnings;
+use hardware::server::cisco::ucs::mode::components::resources qw(%mapping_presence %mapping_operability);
+
+# In MIB 'CISCO-UNIFIED-COMPUTING-STORAGE-MIB'
+my $mapping1 = {
+    cucsStorageLocalDiskPresence => { oid => '.1.3.6.1.4.1.9.9.719.1.45.4.1.10', map => \%mapping_presence },
+};
+my $mapping2 = {
+    cucsStorageLocalDiskOperability => { oid => '.1.3.6.1.4.1.9.9.719.1.45.4.1.9', map => \%mapping_operability },
+};
+my $oid_cucsStorageLocalDiskDn = '.1.3.6.1.4.1.9.9.719.1.45.4.1.2';
+
+sub load {
+    my (%options) = @_;
+    
+    push @{$options{request}}, { oid => $mapping1->{cucsStorageLocalDiskPresence}->{oid} },
+        { oid => $mapping2->{cucsStorageLocalDiskOperability}->{oid} }, { oid => $oid_cucsStorageLocalDiskDn };
+}
+
+sub check {
+    my ($self) = @_;
+
+    $self->{output}->output_add(long_msg => "Checking local disks");
+    $self->{components}->{localdisk} = {name => 'local disks', total => 0, skip => 0};
+    return if ($self->check_exclude(section => 'localdisk'));
+
+    foreach my $oid ($self->{snmp}->oid_lex_sort(keys %{$self->{results}->{$oid_cucsStorageLocalDiskDn}})) {
+        $oid =~ /\.(\d+)$/;
+        my $instance = $1;
+        my $localdisk_dn = $self->{results}->{$oid_cucsStorageLocalDiskDn}->{$oid};
+        my $result = $self->{snmp}->map_instance(mapping => $mapping1, results => $self->{results}->{$mapping1->{cucsStorageLocalDiskPresence}->{oid}}, instance => $instance);
+        my $result2 = $self->{snmp}->map_instance(mapping => $mapping2, results => $self->{results}->{$mapping2->{cucsStorageLocalDiskOperability}->{oid}}, instance => $instance);
+        
+        next if ($self->absent_problem(section => 'localdisk', instance => $localdisk_dn));
+        next if ($self->check_exclude(section => 'localdisk', instance => $localdisk_dn));
+
+        $self->{output}->output_add(long_msg => sprintf("local disk '%s' state is '%s' [presence: %s].",
+                                                        $localdisk_dn, $result2->{cucsStorageLocalDiskOperability},
+                                                        $result->{cucsStorageLocalDiskPresence})
+                                    );
+
+        my $exit = $self->get_severity(section => 'localdisk.presence', label => 'default.presence', value => $result->{cucsStorageLocalDiskPresence});
+        if (!$self->{output}->is_status(value => $exit, compare => 'ok', litteral => 1)) {
+            $self->{output}->output_add(severity => $exit,
+                                        short_msg => sprintf("local disk '%s' presence is: '%s'",
+                                                             $localdisk_dn, $result->{cucsStorageLocalDiskPresence})
+                                        );
+            next;
+        }
+        
+        $self->{components}->{localdisk}->{total}++;
+
+        $exit = $self->get_severity(section => 'localdisk.operability', label => 'default.operability', value => $result2->{cucsStorageLocalDiskOperability});
+        if (!$self->{output}->is_status(value => $exit, compare => 'ok', litteral => 1)) {
+            $self->{output}->output_add(severity => $exit,
+                                        short_msg => sprintf("local disk '%s' state is '%s'",
+                                                             $localdisk_dn, $result2->{cucsStorageLocalDiskOperability}
+                                                             )
+                                        );
+        }
+    }
+}
+
+1;

centreon-plugins/hardware/server/cisco/ucs/mode/components/memory.pm

@@ -0,0 +1,88 @@
+#
+# Copyright 2015 Centreon (http://www.centreon.com/)
+#
+# Centreon is a full-fledged industry-strength solution that meets
+# the needs in IT infrastructure and application monitoring for
+# service performance.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+package hardware::server::cisco::ucs::mode::components::memory;
+
+use strict;
+use warnings;
+use hardware::server::cisco::ucs::mode::components::resources qw(%mapping_presence %mapping_operability);
+
+# In MIB 'CISCO-UNIFIED-COMPUTING-MEMORY-MIB'
+my $mapping1 = {
+    cucsMemoryUnitPresence => { oid => '.1.3.6.1.4.1.9.9.719.1.30.11.1.17', map => \%mapping_presence },
+};
+my $mapping2 = {
+    cucsMemoryUnitOperState => { oid => '.1.3.6.1.4.1.9.9.719.1.30.11.1.13', map => \%mapping_operability },
+};
+my $oid_cucsMemoryUnitDn = '.1.3.6.1.4.1.9.9.719.1.30.11.1.2';
+
+sub load {
+    my (%options) = @_;
+    
+    push @{$options{request}}, { oid => $mapping1->{cucsMemoryUnitPresence}->{oid} },
+        { oid => $mapping2->{cucsMemoryUnitOperState}->{oid} }, { oid => $oid_cucsMemoryUnitDn };
+}
+
+sub check {
+    my ($self) = @_;
+
+    $self->{output}->output_add(long_msg => "Checking memories");
+    $self->{components}->{memory} = {name => 'memories', total => 0, skip => 0};
+    return if ($self->check_exclude(section => 'memory'));
+
+    foreach my $oid ($self->{snmp}->oid_lex_sort(keys %{$self->{results}->{$oid_cucsMemoryUnitDn}})) {
+        $oid =~ /\.(\d+)$/;
+        my $instance = $1;
+        my $memory_dn = $self->{results}->{$oid_cucsMemoryUnitDn}->{$oid};
+        $memory_dn =~ s/\n$//ms;
+        my $result = $self->{snmp}->map_instance(mapping => $mapping1, results => $self->{results}->{$mapping1->{cucsMemoryUnitPresence}->{oid}}, instance => $instance);
+        my $result2 = $self->{snmp}->map_instance(mapping => $mapping2, results => $self->{results}->{$mapping2->{cucsMemoryUnitOperState}->{oid}}, instance => $instance);
+        
+        next if ($self->absent_problem(section => 'memory', instance => $memory_dn));
+        next if ($self->check_exclude(section => 'memory', instance => $memory_dn));
+
+        $self->{output}->output_add(long_msg => sprintf("memory '%s' state is '%s' [presence: %s].",
+                                                        $memory_dn, $result2->{cucsMemoryUnitOperState},
+                                                        $result->{cucsMemoryUnitPresence})
+                                    );
+
+        my $exit = $self->get_severity(section => 'memory.presence', label => 'default.presence', value => $result->{cucsMemoryUnitPresence});
+        if (!$self->{output}->is_status(value => $exit, compare => 'ok', litteral => 1)) {
+            $self->{output}->output_add(severity => $exit,
+                                        short_msg => sprintf("memory '%s' presence is: '%s'",
+                                                             $memory_dn, $result->{cucsMemoryUnitPresence})
+                                        );
+            next;
+        }
+        
+        $self->{components}->{memory}->{total}++;
+
+        $exit = $self->get_severity(section => 'memory.operability', label => 'default.operability', value => $result2->{cucsMemoryUnitOperState});
+        if (!$self->{output}->is_status(value => $exit, compare => 'ok', litteral => 1)) {
+            $self->{output}->output_add(severity => $exit,
+                                        short_msg => sprintf("memory '%s' state is '%s'",
+                                                             $memory_dn, $result2->{cucsMemoryUnitOperState}
+                                                             )
+                                        );
+        }
+    }
+}
+
+1;

centreon-plugins/hardware/server/cisco/ucs/mode/components/psu.pm

@@ -22,7 +22,23 @@ package hardware::server::cisco::ucs::mode::components::psu;
 
 use strict;
 use warnings;
-use hardware::server::cisco::ucs::mode::components::resources qw($thresholds);
+use hardware::server::cisco::ucs::mode::components::resources qw(%mapping_presence %mapping_operability);
+
+# In MIB 'CISCO-UNIFIED-COMPUTING-EQUIPMENT-MIB'
+my $mapping1 = {
+    cucsEquipmentPsuPresence => { oid => '.1.3.6.1.4.1.9.9.719.1.15.56.1.11', map => \%mapping_presence },
+};
+my $mapping2 = {
+    cucsEquipmentPsuOperState => { oid => '.1.3.6.1.4.1.9.9.719.1.15.56.1.7', map => \%mapping_operability },
+};
+my $oid_cucsEquipmentPsuDn = '.1.3.6.1.4.1.9.9.719.1.15.56.1.2';
+
+sub load {
+    my (%options) = @_;
+    
+    push @{$options{request}}, { oid => $mapping1->{cucsEquipmentPsuPresence}->{oid} },
+        { oid => $mapping2->{cucsEquipmentPsuOperState}->{oid} }, { oid => $oid_cucsEquipmentPsuDn };
+}
 
 sub check {
     my ($self) = @_;
@@ -32,49 +48,37 @@ sub check {
     $self->{components}->{psu} = {name => 'psus', total => 0, skip => 0};
     return if ($self->check_exclude(section => 'psu'));
     
-    my $oid_cucsEquipmentPsuPresence = '.1.3.6.1.4.1.9.9.719.1.15.56.1.11';
+    foreach my $oid ($self->{snmp}->oid_lex_sort(keys %{$self->{results}->{$oid_cucsEquipmentPsuDn}})) {
-    my $oid_cucsEquipmentPsuOperState = '.1.3.6.1.4.1.9.9.719.1.15.56.1.7';
+        $oid =~ /\.(\d+)$/;
-    my $oid_cucsEquipmentPsuDn = '.1.3.6.1.4.1.9.9.719.1.15.56.1.2';
+        my $instance = $1;
-
+        my $psu_dn = $self->{results}->{$oid_cucsEquipmentPsuDn}->{$oid};
-    my $result = $self->{snmp}->get_multiple_table(oids => [ 
+        my $result = $self->{snmp}->map_instance(mapping => $mapping1, results => $self->{results}->{$mapping1->{cucsEquipmentPsuPresence}->{oid}}, instance => $instance);
-                                                            { oid => $oid_cucsEquipmentPsuPresence },
+        my $result2 = $self->{snmp}->map_instance(mapping => $mapping2, results => $self->{results}->{$mapping2->{cucsEquipmentPsuOperState}->{oid}}, instance => $instance);
-                                                            { oid => $oid_cucsEquipmentPsuOperState },
-                                                            { oid => $oid_cucsEquipmentPsuDn },
-                                                            ]
-                                                   );
-    foreach my $key ($self->{snmp}->oid_lex_sort(keys %{$result->{$oid_cucsEquipmentPsuPresence}})) {
-        # index
-        $key =~ /\.(\d+)$/;
-        my $psu_index = $1;        
-        my $psu_dn = $result->{$oid_cucsEquipmentPsuDn}->{$oid_cucsEquipmentPsuDn . '.' . $psu_index};
-        my $psu_operstate = defined($result->{$oid_cucsEquipmentPsuOperState}->{$oid_cucsEquipmentPsuOperState . '.' . $psu_index}) ?
-                                $result->{$oid_cucsEquipmentPsuOperState}->{$oid_cucsEquipmentPsuOperState . '.' . $psu_index} : 0; # unknown
-        my $psu_presence = defined($result->{$oid_cucsEquipmentPsuPresence}->{$oid_cucsEquipmentPsuPresence . '.' . $psu_index}) ? 
-                                $result->{$oid_cucsEquipmentPsuPresence}->{$oid_cucsEquipmentPsuPresence . '.' . $psu_index} : 0;
         
         next if ($self->absent_problem(section => 'psu', instance => $psu_dn));
         next if ($self->check_exclude(section => 'psu', instance => $psu_dn));
 
-         my $exit = $self->get_severity(section => 'psu', threshold => 'presence', value => $psu_presence);
+        $self->{output}->output_add(long_msg => sprintf("power supply '%s' state is '%s' [presence: %s].",
+                                                        $psu_dn, $result2->{cucsEquipmentPsuOperState},
+                                                        $result->{cucsEquipmentPsuPresence})
+                                    );
+        
+        my $exit = $self->get_severity(section => 'psu.presence', label => 'default.presence', value => $result->{cucsEquipmentPsuPresence});
         if (!$self->{output}->is_status(value => $exit, compare => 'ok', litteral => 1)) {
             $self->{output}->output_add(severity => $exit,
                                         short_msg => sprintf("power supply '%s' presence is: '%s'",
-                                                             $psu_dn, ${$thresholds->{presence}->{$psu_presence}}[0])
+                                                             $psu_dn, $result->{cucsEquipmentPsuPresence})
                                         );
             next;
         }
         
         $self->{components}->{psu}->{total}++;
         
-        $self->{output}->output_add(long_msg => sprintf("power supply '%s' state is '%s' [presence: %s].",
+        $exit = $self->get_severity(section => 'psu.operability', label => 'default.operability', value => $result2->{cucsEquipmentPsuOperState});
-                                                        $psu_dn, ${$thresholds->{operability}->{$psu_operstate}}[0],
-                                                        ${$thresholds->{presence}->{$psu_presence}}[0]
-                                    ));
-        $exit = $self->get_severity(section => 'psu', threshold => 'operability', value => $psu_operstate);
         if (!$self->{output}->is_status(value => $exit, compare => 'ok', litteral => 1)) {
             $self->{output}->output_add(severity => $exit,
                                         short_msg => sprintf("power supply '%s' state is '%s'.",
-                                                             $psu_dn, ${$thresholds->{operability}->{$psu_operstate}}[0]
+                                                             $psu_dn, $result2->{cucsEquipmentPsuOperState}
                                                              )
                                         );
         }

centreon-plugins/hardware/server/cisco/ucs/mode/components/resources.pm

@@ -25,85 +25,197 @@ use warnings;
 use Exporter;
 
 our $thresholds;
+our %mapping_presence;
+our %mapping_operability;
+our %mapping_overall_status;
+our %mapping_drive_status;
 
 our @ISA = qw(Exporter);
-our @EXPORT_OK = qw($thresholds);
+our @EXPORT_OK = qw($thresholds %mapping_presence %mapping_operability %mapping_overall_status %mapping_drive_status);
+
+%mapping_drive_status = (
+    0 => 'unknown',
+    1 => 'online',
+    2 => 'unconfiguredGood',
+    3 => 'globalHotSpare',
+    4 => 'dedicatedHotSpare',
+    5 => 'jbod',
+    6 => 'offline',
+    7 => 'rebuilding',
+    8 => 'copyback',
+    9 => 'failed',
+    10 => 'unconfiguredBad',
+    11 => 'predictiveFailure',
+    12 => 'disabledForRemoval',
+    13 => 'foreignConfiguration',
+);
+%mapping_presence = (
+    0 => 'unknown', 
+    1 => 'empty', 
+    10 => 'equipped', 
+    11 => 'missing',
+    12 => 'mismatch',
+    13 => 'equippedNotPrimary',
+    20 => 'equippedIdentityUnestablishable',
+    21 => 'mismatchIdentityUnestablishable',
+    30 => 'inaccessible',
+    40 => 'unauthorized',
+    100 => 'notSupported',
+);
+%mapping_operability = (
+    0 => 'unknown',
+    1 => 'operable',
+    2 => 'inoperable',
+    3 => 'degraded',
+    4 => 'poweredOff',
+    5 => 'powerProblem',
+    6 => 'removed',
+    7 => 'voltageProblem',
+    8 => 'thermalProblem',
+    9 => 'performanceProblem',
+    10 => 'accessibilityProblem',
+    11 => 'identityUnestablishable',
+    12 => 'biosPostTimeout',
+    13 => 'disabled',
+    51 => 'fabricConnProblem',
+    52 => 'fabricUnsupportedConn',
+    81 => 'config',
+    82 => 'equipmentProblem',
+    83 => 'decomissioning',
+    84 => 'chassisLimitExceeded',
+    100 => 'notSupported',
+    101 => 'discovery',
+    102 => 'discoveryFailed',
+    104 => 'postFailure',
+    105 => 'upgradeProblem',
+    106 => 'peerCommProblem',
+    107 => 'autoUpgrade',
+    108 => 'linkActivateBlocked',
+);
+%mapping_overall_status = (
+    0 => 'indeterminate',
+    1 => 'unassociated',
+    10 => 'ok',
+    11 => 'discovery',
+    12 => 'config',
+    13 => 'unconfig',
+    14 => 'power-off',
+    15 => 'restart',
+    20 => 'maintenance',
+    21 => 'test',
+    29 => 'compute-mismatch',
+    30 => 'compute-failed',
+    31 => 'degraded',
+    32 => 'discovery-failed',
+    33 => 'config-failure',
+    34 => 'unconfig-failed',
+    35 => 'test-failed',
+    36 => 'maintenance-failed',
+    40 => 'removed',
+    41 => 'disabled',
+    50 => 'inaccessible',
+    60 => 'thermal-problem',
+    61 => 'power-problem',
+    62 => 'voltage-problem',
+    63 => 'inoperable',
+    101 => 'decommissioning',
+    201 => 'bios-restore',
+    202 => 'cmos-reset',
+    203 => 'diagnostics',
+    204 => 'diagnostic-failed',
+);
 
 $thresholds = {
-    presence => {
+    'default.drivestatus' => [
-        0 => ['unknown', 'UNKNOWN'], 
+        ['unknown', 'UNKNOWN'], 
-        1 => ['empty', 'OK'], 
+        ['online', 'OK'],
-        10 => ['equipped', 'OK'], 
+        ['unconfiguredGood', 'OK'], 
-        11 => ['missing', 'WARNING'],
+        ['globalHotSpare', 'OK'], 
-        12 => ['mismatch', 'WARNING'],
+        ['dedicatedHotSpare', 'OK'], 
-        13 => ['equippedNotPrimary', 'OK'],
+        ['jbod', 'OK'], 
-        20 => ['equippedIdentityUnestablishable', 'WARNING'],
+        ['offline', 'OK'], 
-        21 => ['mismatchIdentityUnestablishable', 'WARNING'],
+        ['rebuilding', 'WARNING'], 
-        30 => ['inaccessible', 'UNKNOWN'],
+        ['copyback', 'OK'], 
-        40 => ['unauthorized', 'UNKNOWN'],
+        ['failed', 'CRITICAL'], 
-        100 => ['notSupported', 'WARNING'],
+        ['unconfiguredBad', 'CRITICAL'], 
-    },
+        ['predictiveFailure', 'WARNING'], 
-    operability => {
+        ['disabledForRemoval', 'OK'],
-        0 => ['unknown', 'UNKNOWN'], 
+        ['foreignConfiguration', 'OK'], 
-        1 => ['operable', 'OK'], 
+    ],
-        2 => ['inoperable', 'CRITICAL'], 
+    'default.presence' => [
-        3 => ['degraded', 'WARNING'],
+        ['unknown', 'UNKNOWN'], 
-        4 => ['poweredOff', 'WARNING'],
+        ['empty', 'OK'], 
-        5 => ['powerProblem', 'CRITICAL'],
+        ['equipped', 'OK'], 
-        6 => ['removed', 'WARNING'],
+        ['missing', 'WARNING'],
-        7 => ['voltageProblem', 'CRITICAL'],
+        ['mismatch', 'WARNING'],
-        8 => ['thermalProblem', 'CRITICAL'],
+        ['equippedNotPrimary', 'OK'],
-        9 => ['performanceProblem', 'CRITICAL'],
+        ['equippedIdentityUnestablishable', 'WARNING'],
-        10 => ['accessibilityProblem', 'WARNING'],
+        ['mismatchIdentityUnestablishable', 'WARNING'],
-        11 => ['identityUnestablishable', 'WARNING'],
+        ['inaccessible', 'UNKNOWN'],
-        12 => ['biosPostTimeout', 'WARNING'],
+        ['unauthorized', 'UNKNOWN'],
-        13 => ['disabled', 'OK'],
+        ['notSupported', 'WARNING'],
-        51 => ['fabricConnProblem', 'WARNING'],
+    ],
-        52 => ['fabricUnsupportedConn', 'WARNING'],
+    'default.operability' => [
-        81 => ['config', 'OK'],
+        ['unknown', 'UNKNOWN'], 
-        82 => ['equipmentProblem', 'CRITICAL'],
+        ['operable', 'OK'], 
-        83 => ['decomissioning', 'WARNING'],
+        ['inoperable', 'CRITICAL'], 
-        84 => ['chassisLimitExceeded', 'WARNING'],
+        ['degraded', 'WARNING'],
-        100 => ['notSupported', 'WARNING'],
+        ['poweredOff', 'WARNING'],
-        101 => ['discovery', 'OK'],
+        ['powerProblem', 'CRITICAL'],
-        102 => ['discoveryFailed', 'WARNING'],
+        ['removed', 'WARNING'],
-        104 => ['postFailure', 'WARNING'],
+        ['voltageProblem', 'CRITICAL'],
-        105 => ['upgradeProblem', 'WARNING'],
+        ['thermalProblem', 'CRITICAL'],
-        106 => ['peerCommProblem', 'WARNING'],
+        ['performanceProblem', 'CRITICAL'],
-        107 => ['autoUpgrade', 'OK'],
+        ['accessibilityProblem', 'WARNING'],
-    },
+        ['identityUnestablishable', 'WARNING'],
-    overall_status => {
+        ['biosPostTimeout', 'WARNING'],
-        0 => ['indeterminate', 'UNKNOWN'],
+        ['disabled', 'OK'],
-        1 => ['unassociated', 'OK'],
+        ['fabricConnProblem', 'WARNING'],
-        10 => ['ok', 'OK'],
+        ['fabricUnsupportedConn', 'WARNING'],
-        11 => ['discovery', 'OK'],
+        ['config', 'OK'],
-        12 => ['config', 'OK'],
+        ['equipmentProblem', 'CRITICAL'],
-        13 => ['unconfig', 'OK'],
+        ['decomissioning', 'WARNING'],
-        14 => ['power-off', 'WARNING'],
+        ['chassisLimitExceeded', 'WARNING'],
-        15 => ['restart', 'WARNING'],
+        ['notSupported', 'WARNING'],
-        20 => ['maintenance', 'OK'],
+        ['discovery', 'OK'],
-        21 => ['test', 'OK'],
+        ['discoveryFailed', 'WARNING'],
-        29 => ['compute-mismatch', 'WARNING'],
+        ['postFailure', 'WARNING'],
-        30 => ['compute-failed', 'WARNING'],
+        ['upgradeProblem', 'WARNING'],
-        31 => ['degraded', 'WARNING'],
+        ['peerCommProblem', 'WARNING'],
-        32 => ['discovery-failed', 'WARNING'],
+        ['autoUpgrade', 'OK'],
-        33 => ['config-failure', 'WARNING'],
+    ],
-        34 => ['unconfig-failed', 'WARNING'],
+    'default.overall_status' => [
-        35 => ['test-failed', 'WARNING'],
+        ['indeterminate', 'UNKNOWN'],
-        36 => ['maintenance-failed', 'WARNING'],
+        ['unassociated', 'OK'],
-        40 => ['removed', 'WARNING'],
+        ['ok', 'OK'],
-        41 => ['disabled', 'OK'],
+        ['discovery', 'OK'],
-        50 => ['inaccessible', 'WARNING'],
+        ['config', 'OK'],
-        60 => ['thermal-problem', 'CRITICAL'],
+        ['unconfig', 'OK'],
-        61 => ['power-problem', 'CRITICAL'],
+        ['power-off', 'WARNING'],
-        62 => ['voltage-problem', 'CRITICAL'],
+        ['restart', 'WARNING'],
-        63 => ['inoperable', 'CRITICAL'],
+        ['maintenance', 'OK'],
-        101 => ['decommissioning', 'WARNING'],
+        ['test', 'OK'],
-        201 => ['bios-restore', 'WARNING'],
+        ['compute-mismatch', 'WARNING'],
-        202 => ['cmos-reset', 'WARNING'],
+        ['compute-failed', 'WARNING'],
-        203 => ['diagnostics', 'OK'],
+        ['degraded', 'WARNING'],
-        204 => ['diagnostic-failed', 'WARNING'],
+        ['discovery-failed', 'WARNING'],
-    },
+        ['config-failure', 'WARNING'],
+        ['unconfig-failed', 'WARNING'],
+        ['test-failed', 'WARNING'],
+        ['maintenance-failed', 'WARNING'],
+        ['removed', 'WARNING'],
+        ['disabled', 'OK'],
+        ['inaccessible', 'WARNING'],
+        ['thermal-problem', 'CRITICAL'],
+        ['power-problem', 'CRITICAL'],
+        ['voltage-problem', 'CRITICAL'],
+        ['inoperable', 'CRITICAL'],
+        ['decommissioning', 'WARNING'],
+        ['bios-restore', 'WARNING'],
+        ['cmos-reset', 'WARNING'],
+        ['diagnostics', 'OK'],
+        ['diagnostic-failed', 'WARNING'],
+    ],
 };
 
 1;

centreon-plugins/hardware/server/cisco/ucs/mode/equipment.pm

@@ -25,12 +25,6 @@ use base qw(centreon::plugins::mode);
 use strict;
 use warnings;
 use hardware::server::cisco::ucs::mode::components::resources qw($thresholds);
-use hardware::server::cisco::ucs::mode::components::fan;
-use hardware::server::cisco::ucs::mode::components::psu;
-use hardware::server::cisco::ucs::mode::components::iocard;
-use hardware::server::cisco::ucs::mode::components::chassis;
-use hardware::server::cisco::ucs::mode::components::blade;
-use hardware::server::cisco::ucs::mode::components::fex;
 
 sub new {
     my ($class, %options) = @_;
@@ -41,8 +35,8 @@ sub new {
     $options{options}->add_options(arguments =>
                                 { 
                                   "exclude:s"        => { name => 'exclude' },
-                                  "absent-problem:s" => { name => 'absent' },
+                                  "absent-problem:s@"       => { name => 'absent_problem' },
-                                  "component:s"             => { name => 'component', default => 'all' },
+                                  "component:s"             => { name => 'component', default => '.*' },
                                   "no-component:s"          => { name => 'no_component' },
                                   "threshold-overload:s@"   => { name => 'threshold_overload' },
                                 });
@@ -63,64 +57,69 @@ sub check_options {
         }
     }
     
+    $self->{absent_problem} = [];
+    foreach my $val (@{$self->{option_results}->{absent_problem}}) {
+        next if (!defined($val) || $val eq '');
+        my @values = split (/,/, $val);
+        push @{$self->{absent_problem}}, { filter => $values[0], instance => $values[1] }; 
+    }
+    
     $self->{overload_th} = {};
     foreach my $val (@{$self->{option_results}->{threshold_overload}}) {
-        if ($val !~ /^(.*?),(.*?),(.*?),(.*)$/) {
+        next if (!defined($val) || $val eq '');
-            $self->{output}->add_option_msg(short_msg => "Wrong treshold-overload option '" . $val . "'.");
+        my @values = split (/,/, $val);
+        if (scalar(@values) < 3) {
+            $self->{output}->add_option_msg(short_msg => "Wrong threshold-overload option '" . $val . "'.");
+            $self->{output}->option_exit();
+        }
+        my ($section, $instance, $status, $filter);
+        if (scalar(@values) == 3) {
+            ($section, $status, $filter) = @values;
+            $instance = '.*';
+        } else {
+             ($section, $instance, $status, $filter) = @values;
+        }
+        if ($section !~ /^(fan|psu|chassis|iocard|blade|fex|cpu|memory|localdisk)\.(presence|operability|overall_status)$/) {
+            $self->{output}->add_option_msg(short_msg => "Wrong threshold-overload section '" . $val . "'.");
             $self->{output}->option_exit();
         }
-        my ($section, $type, $status, $filter) = ($1, $2, $3, $4);
         if ($self->{output}->is_litteral_status(status => $status) == 0) {
-            $self->{output}->add_option_msg(short_msg => "Wrong treshold-overload status '" . $val . "'.");
+            $self->{output}->add_option_msg(short_msg => "Wrong threshold-overload status '" . $val . "'.");
             $self->{output}->option_exit();
         }
-        $self->{overload_th}->{$section} = { } if (!defined($self->{overload_th}->{$section}));
+        $self->{overload_th}->{$section} = [] if (!defined($self->{overload_th}->{$section}));
-        $self->{overload_th}->{$section}->{$type} = { } if (!defined($self->{overload_th}->{$section}->{$type}));
+        push @{$self->{overload_th}->{$section}}, {filter => $filter, status => $status, instance => $instance };
-        $self->{overload_th}->{$section}->{$type}->{$filter} = $status;
-    }
-}
-
-sub global {
-    my ($self, %options) = @_;
- 
-    hardware::server::cisco::ucs::mode::components::fan::check($self);
-    hardware::server::cisco::ucs::mode::components::psu::check($self);
-    hardware::server::cisco::ucs::mode::components::iocard::check($self);
-    hardware::server::cisco::ucs::mode::components::chassis::check($self);
-    hardware::server::cisco::ucs::mode::components::blade::check($self);
-    hardware::server::cisco::ucs::mode::components::fex::check($self);
-}
-
-sub component {
-    my ($self, %options) = @_;
-    
-    if ($self->{option_results}->{component} eq 'fan') {
-        hardware::server::cisco::ucs::mode::components::fan::check($self);
-    } elsif ($self->{option_results}->{component} eq 'psu') {
-        hardware::server::cisco::ucs::mode::components::psu::check($self);
-    } elsif ($self->{option_results}->{component} eq 'iocard') {
-        hardware::server::cisco::ucs::mode::components::iocard::check($self);
-    } elsif ($self->{option_results}->{component} eq 'chassis') {
-        hardware::server::cisco::ucs::mode::components::chassis::check($self);
-    } elsif ($self->{option_results}->{component} eq 'blade') {
-        hardware::server::cisco::ucs::mode::components::blade::check($self);
-    } elsif ($self->{option_results}->{component} eq 'fex') {
-        hardware::server::cisco::ucs::mode::components::fex::check($self);
-    } else {
-        $self->{output}->add_option_msg(short_msg => "Wrong option. Cannot find component '" . $self->{option_results}->{component} . "'.");
-        $self->{output}->option_exit();
     }
 }
 
 sub run {
     my ($self, %options) = @_;
-    # $options{snmp} = snmp object
     $self->{snmp} = $options{snmp};
 
-    if ($self->{option_results}->{component} eq 'all') {
+    my $snmp_request = [];
-        $self->global();
+    my @components = ('fan', 'psu', 'chassis', 'iocard', 'blade', 'fex', 'cpu', 'memory', 'localdisk');
-    } else {
+    foreach (@components) {
-        $self->component();
+        if (/$self->{option_results}->{component}/) {
+            my $mod_name = "hardware::server::cisco::ucs::mode::components::$_";
+            centreon::plugins::misc::mymodule_load(output => $self->{output}, module => $mod_name,
+                                                   error_msg => "Cannot load module '$mod_name'.");
+            my $func = $mod_name->can('load');
+            $func->(request => $snmp_request);
+        }
+    }
+    
+    if (scalar(@{$snmp_request}) == 0) {
+        $self->{output}->add_option_msg(short_msg => "Wrong option. Cannot find component '" . $self->{option_results}->{component} . "'.");
+        $self->{output}->option_exit();
+    }
+    $self->{results} = $self->{snmp}->get_multiple_table(oids => $snmp_request);
+    
+    foreach (@components) {
+        if (/$self->{option_results}->{component}/) {
+            my $mod_name = "hardware::server::cisco::ucs::mode::components::$_";
+            my $func = $mod_name->can('check');
+            $func->($self); 
+        }
     }
     
     my $total_components = 0;
@@ -130,12 +129,13 @@ sub run {
         # Skipping short msg when no components
         next if ($self->{components}->{$comp}->{total} == 0 && $self->{components}->{$comp}->{skip} == 0);
         $total_components += $self->{components}->{$comp}->{total} + $self->{components}->{$comp}->{skip};
-        $display_by_component .= $display_by_component_append . $self->{components}->{$comp}->{total} . '/' . $self->{components}->{$comp}->{skip} . ' ' . $self->{components}->{$comp}->{name};
+        my $count_by_components = $self->{components}->{$comp}->{total} + $self->{components}->{$comp}->{skip}; 
+        $display_by_component .= $display_by_component_append . $self->{components}->{$comp}->{total} . '/' . $count_by_components . ' ' . $self->{components}->{$comp}->{name};
         $display_by_component_append = ', ';
     }
     
     $self->{output}->output_add(severity => 'OK',
-                                short_msg => sprintf("All %s components [%s] are ok.", 
+                                short_msg => sprintf("All %s components are ok [%s].", 
                                                      $total_components,
                                                      $display_by_component)
                                 );
@@ -144,11 +144,30 @@ sub run {
         $self->{output}->output_add(severity => $self->{no_components},
                                     short_msg => 'No components are checked.');
     }
-                           
+
     $self->{output}->display();
     $self->{output}->exit();
 }
 
+sub absent_problem {
+    my ($self, %options) = @_;
+    
+    foreach (@{$self->{absent_problem}}) {
+        if ($options{section} =~ /$_->{filter}/) {
+            if (!defined($_->{instance}) || $options{instance} =~ /$_->{instance}/) {
+                $self->{output}->output_add(severity => 'CRITICAL',
+                                            short_msg => sprintf("Component '%s' instance '%s' is not present", 
+                                                                 $options{section}, $options{instance}));
+                $self->{output}->output_add(long_msg => sprintf("Skipping $options{section} section $options{instance} instance (not present)"));
+                $self->{components}->{$options{section}}->{skip}++;
+                return 1;
+            }
+        }
+    }
+    
+    return 0;
+}
+
 sub check_exclude {
     my ($self, %options) = @_;
 
@@ -167,31 +186,26 @@ sub check_exclude {
 
 sub get_severity {
     my ($self, %options) = @_;
+    my $status = 'UNKNOWN'; # default 
     
-    my $status = ${$thresholds->{$options{threshold}}->{$options{value}}}[1];
+    if (defined($self->{overload_th}->{$options{section}})) {
-    if (defined($self->{overload_th}->{$options{section}}->{$options{threshold}})) {
+        foreach (@{$self->{overload_th}->{$options{section}}}) {            
-        foreach (keys %{$self->{overload_th}->{$options{section}}->{$options{threshold}}}) {            
+            if ($options{value} =~ /$_->{filter}/i && 
-            if (${$thresholds->{$options{threshold}}->{$options{value}}}[0] =~ /$_/i) {
+                (!defined($options{instance}) || $options{instance} =~ /$_->{instance}/)) {
-                $status = $self->{overload_th}->{$options{section}}->{$options{threshold}}->{$_};
+                $status = $_->{status};
-                last;
+                return $status;
             }
         }
     }
-    return $status;
+    my $label = defined($options{label}) ? $options{label} : $options{section};
-}
+    foreach (@{$thresholds->{$label}}) {
-
+        if ($options{value} =~ /$$_[0]/i) {
-sub absent_problem {
+            $status = $$_[1];
-    my ($self, %options) = @_;
+            return $status;
-    
+        }
-    if (defined($self->{option_results}->{absent}) && 
-        $self->{option_results}->{absent} =~ /(^|\s|,)($options{section}(\s*,|$)|${options{section}}[^,]*#\Q$options{instance}\E#)/) {
-        $self->{output}->output_add(severity => 'CRITICAL',
-                                    short_msg => sprintf("Component '%s' instance '%s' is not present", 
-                                                         $options{section}, $options{instance}));
-        return 1;
     }
     
-    return 0;
+    return $status;
 }
 
 1;
@@ -206,18 +220,18 @@ Check Hardware (Fans, Power supplies, chassis, io cards, blades, fabric extender
 
 =item B<--component>
 
-Which component to check (Default: 'all').
+Which component to check (Default: '.*').
-Can be: 'fan', 'psu', 'chassis', 'iocard', 'blade', 'fex'
+Can be: 'fan', 'psu', 'chassis', 'iocard', 'blade', 'fex', 'cpu', 'memory', 'localdisk'.
 
 =item B<--exclude>
 
 Exclude some parts (comma seperated list) (Example: --exclude=fan)
-Can also exclude specific instance: --exclude=fan#/sys/chassis-7/fan-module-1-7/fan-1#
+Can be specific or global: --exclude=fan#/sys/chassis-7/fan-module-1-7/fan-1#
 
 =item B<--absent-problem>
 
 Return an error if an entity is not 'present' (default is skipping) (comma seperated list)
-Can be specific or global: --exclude=fan#/sys/chassis-7/fan-module-1-7/fan-1#
+Can be specific or global: --absent-problem=fan,/sys/chassis-7/fan-module-1-7/fan-1
 
 =item B<--no-component>
 
@@ -226,8 +240,9 @@ If total (with skipped) is 0. (Default: 'critical' returns).
 
 =item B<--threshold-overload>
 
-Set to overload default threshold values (syntax: section,threshold,status,regexp)
+Set to overload default threshold values (syntax: section,[instance,]status,regexp)
-Example: --threshold-overload='fan,operability,OK,poweredOff|removed'
+It used before default thresholds (order stays).
+Example: --threshold-overload='fan.operability,OK,poweredOff|removed'
 
 =back
 

centreon-plugins/hardware/ups/standard/rfc1628/snmp/mode/batterystatus.pm

@@ -76,11 +76,15 @@ sub run {
     
     my $result = $self->{snmp}->get_table(oid => $oid_upsBattery, nothing_quit => 1);
 
-    my $current = defined($result->{$oid_upsBatteryCurrent}) ? $result->{$oid_upsBatteryCurrent} * 0.1 : 0;
+    my $current = (defined($result->{$oid_upsBatteryCurrent}) && $result->{$oid_upsBatteryCurrent} =~ /\d/) ? 
-    my $voltage = defined($result->{$oid_upsBatteryVoltage}) ? $result->{$oid_upsBatteryVoltage} * 0.1 : 0;
+        $result->{$oid_upsBatteryCurrent} * 0.1 : 0;
+    my $voltage = (defined($result->{$oid_upsBatteryVoltage}) && $result->{$oid_upsBatteryVoltage} =~ /\d/) ? 
+        $result->{$oid_upsBatteryVoltage} * 0.1 : 0;
     my $temp = defined($result->{$oid_upsBatteryTemperature}) ? $result->{$oid_upsBatteryTemperature} : 0;
-    my $min_remain = defined($result->{$oid_upsEstimatedMinutesRemaining}) ? $result->{$oid_upsEstimatedMinutesRemaining} : 'unknown';
+    my $min_remain = (defined($result->{$oid_upsEstimatedMinutesRemaining}) && $result->{$oid_upsEstimatedMinutesRemaining} =~ /\d/) ? 
-    my $charge_remain = defined($result->{$oid_upsEstimatedChargeRemaining}) ? $result->{$oid_upsEstimatedChargeRemaining} : 'unknown';
+        $result->{$oid_upsEstimatedMinutesRemaining} : 'unknown';
+    my $charge_remain = (defined($result->{$oid_upsEstimatedChargeRemaining}) && $result->{$oid_upsEstimatedChargeRemaining} =~ /\d/) ? 
+        $result->{$oid_upsEstimatedChargeRemaining} : 'unknown';
     my $status = defined($result->{$oid_upsBatteryStatus}) ? $result->{$oid_upsBatteryStatus} : 1; # we put unknown ???
   
     $self->{output}->output_add(severity => ${$battery_status{$status}}[1],

centreon-plugins/hardware/ups/standard/rfc1628/snmp/mode/inputlines.pm

@@ -142,7 +142,7 @@ sub run {
         my @exits;
         foreach (keys %{$maps_counters}) {
             foreach my $name (keys %{$maps_counters->{$_}->{thresholds}}) {
-                if (defined($self->{counters_value}->{$instance}->{$_}) && $self->{counters_value}->{$instance}->{$_} != 0) {
+                if (defined($self->{counters_value}->{$instance}->{$_}) && $self->{counters_value}->{$instance}->{$_} =~ /\d/ && $self->{counters_value}->{$instance}->{$_} != 0) {
                     push @exits, $self->{perfdata}->threshold_check(value => $self->{counters_value}->{$instance}->{$_} * $maps_counters->{$_}->{factor}, threshold => [ { label => $maps_counters->{$_}->{thresholds}->{$name}->{label}, 'exit_litteral' => $maps_counters->{$_}->{thresholds}->{$name}->{exit_value} }]);
                 }
             }
@@ -155,7 +155,7 @@ sub run {
         my $str_output = "Input Line '$instance_output' ";
         my $str_append = '';
         foreach (keys %{$maps_counters}) {
-            next if (!defined($self->{counters_value}->{$instance}->{$_}) || $self->{counters_value}->{$instance}->{$_} == 0);
+            next if (!defined($self->{counters_value}->{$instance}->{$_}) || $self->{counters_value}->{$instance}->{$_} !~ /\d/ || $self->{counters_value}->{$instance}->{$_} == 0);
             
             $str_output .= $str_append . sprintf($maps_counters->{$_}->{output_msg}, $self->{counters_value}->{$instance}->{$_} * $maps_counters->{$_}->{factor});
             $str_append = ', ';

centreon-plugins/hardware/ups/standard/rfc1628/snmp/mode/outputlines.pm

@@ -182,7 +182,7 @@ sub run {
         my @exits;
         foreach (keys %{$maps_counters}) {
             foreach my $name (keys %{$maps_counters->{$_}->{thresholds}}) {
-                if (defined($self->{counters_value}->{$instance}->{$_}) && $self->{counters_value}->{$instance}->{$_} == $maps_counters->{$_}->{no_present}) {
+                if (defined($self->{counters_value}->{$instance}->{$_}) && $self->{counters_value}->{$instance}->{$_} =~ /\d/ && $self->{counters_value}->{$instance}->{$_} != $maps_counters->{$_}->{no_present}) {
                     push @exits, $self->{perfdata}->threshold_check(value => $self->{counters_value}->{$instance}->{$_} * $maps_counters->{$_}->{factor}, threshold => [ { label => $maps_counters->{$_}->{thresholds}->{$name}->{label}, 'exit_litteral' => $maps_counters->{$_}->{thresholds}->{$name}->{exit_value} }]);
                 }
             }
@@ -195,7 +195,7 @@ sub run {
         my $str_output = "Output Line '$instance_output' ";
         my $str_append = '';
         foreach (keys %{$maps_counters}) {
-            next if (!defined($self->{counters_value}->{$instance}->{$_}) || $self->{counters_value}->{$instance}->{$_} == $maps_counters->{$_}->{no_present});
+            next if (!defined($self->{counters_value}->{$instance}->{$_}) || $self->{counters_value}->{$instance}->{$_} !~ /\d/ || $self->{counters_value}->{$instance}->{$_} == $maps_counters->{$_}->{no_present});
             
             $str_output .= $str_append . sprintf($maps_counters->{$_}->{output_msg}, $self->{counters_value}->{$instance}->{$_} * $maps_counters->{$_}->{factor});
             $str_append = ', ';

centreon-plugins/network/dell/sseries/snmp/plugin.pm

@@ -0,0 +1,53 @@
+#
+# Copyright 2015 Centreon (http://www.centreon.com/)
+#
+# Centreon is a full-fledged industry-strength solution that meets
+# the needs in IT infrastructure and application monitoring for
+# service performance.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+package network::dell::sseries::snmp::plugin;
+
+use strict;
+use warnings;
+use base qw(centreon::plugins::script_snmp);
+
+sub new {
+    my ($class, %options) = @_;
+    my $self = $class->SUPER::new(package => __PACKAGE__, %options);
+    bless $self, $class;
+    # $options->{options} = options object
+
+    $self->{version} = '1.0';
+    %{$self->{modes}} = (
+                          'cpu'             => 'centreon::common::force10::snmp::mode::cpu',
+                          'hardware'        => 'centreon::common::force10::snmp::mode::hardware',
+                          'interfaces'      => 'snmp_standard::mode::interfaces',
+                          'list-interfaces' => 'snmp_standard::mode::listinterfaces',
+                          'memory'          => 'centreon::common::force10::snmp::mode::memory',
+                         );
+
+    return $self;
+}
+
+1;
+
+__END__
+
+=head1 PLUGIN DESCRIPTION
+
+Check Dell S-Series in SNMP.
+
+=cut

centreon-plugins/network/extreme/snmp/mode/cpu.pm

@@ -260,6 +260,10 @@ sub manage_selection {
         my $instance = $1;
         my $result = $self->{snmp}->map_instance(mapping => $mapping, results => $self->{results}->{$oid_extremeCpuMonitorSystemEntry}, instance => $instance);
         
+        foreach (keys %{$mapping}) {
+            $result->{$_} = undef if (defined($result->{$_}) && $result->{$_} =~ /n\/a/i);
+        }
+        
         $self->{cpu}->{$instance} = {num => $instance, %$result};
     }
 

centreon-plugins/network/f5/bigip/mode/components/fan.pm

@@ -29,43 +29,59 @@ my %map_status = (
     2 => 'notPresent',
 );
 
+my $mapping = {
+    sysChassisFanStatus => { oid => '.1.3.6.1.4.1.3375.2.1.3.2.1.2.1.2', map => \%map_status },
+    sysChassisFanSpeed => { oid => '.1.3.6.1.4.1.3375.2.1.3.2.1.2.1.3' },
+};
+my $oid_sysChassisFanEntry = '.1.3.6.1.4.1.3375.2.1.3.2.1.2.1';
+
+sub load {
+    my (%options) = @_;
+    
+    push @{$options{request}}, { oid => $oid_sysChassisFanEntry };
+}
+
 sub check {
     my ($self) = @_;
 
-    $self->{components}->{fan} = {name => 'fans', total => 0, skip => 0};
     $self->{output}->output_add(long_msg => "Checking fans");
+    $self->{components}->{fan} = {name => 'fans', total => 0, skip => 0};
     return if ($self->check_exclude(section => 'fan'));
-    
-    my $oid_sysChassisFanEntry = '.1.3.6.1.4.1.3375.2.1.3.2.1.2.1';
-    my $oid_sysChassisFanStatus = '.1.3.6.1.4.1.3375.2.1.3.2.1.2.1.2';
-    my $oid_sysChassisFanSpeed = '.1.3.6.1.4.1.3375.2.1.3.2.1.2.1.3';
-    
-    my $result = $self->{snmp}->get_table(oid => $oid_sysChassisFanEntry);
-    return if (scalar(keys %$result) <= 0);
 
-    foreach my $key ($self->{snmp}->oid_lex_sort(keys %$result)) {
+    foreach my $oid ($self->{snmp}->oid_lex_sort(keys %{$self->{results}->{$oid_sysChassisFanEntry}})) {
-        next if ($key !~ /^$oid_sysChassisFanStatus\.(\d+)$/);
+        next if ($oid !~ /^$mapping->{sysChassisFanStatus}->{oid}\.(.*)$/);
         my $instance = $1;
+        my $result = $self->{snmp}->map_instance(mapping => $mapping, results => $self->{results}->{$oid_sysChassisFanEntry}, instance => $instance);
     
+        next if ($result->{sysChassisFanStatus} =~ /notPresent/i && 
+                 $self->absent_problem(section => 'fan', instance => $instance));
         next if ($self->check_exclude(section => 'fan', instance => $instance));
-    
+        
-        my $status = $result->{$oid_sysChassisFanStatus . '.' . $instance};
-        my $speed = $result->{$oid_sysChassisFanSpeed . '.' . $instance};
-
         $self->{components}->{fan}->{total}++;
-        $self->{output}->output_add(long_msg => sprintf("Fan '%s' status is %s.", 
+        
-                                                        $instance, $map_status{$status}));
+        $self->{output}->output_add(long_msg => sprintf("fan '%s' status is '%s' [instance: %s, speed: %s].", 
-        if ($status < 1) {
+                                    $instance, $result->{sysChassisFanStatus}, $instance,
-            $self->{output}->output_add(severity =>  'CRITICAL',
+                                    defined($result->{sysChassisFanSpeed}) ? $result->{sysChassisFanSpeed} : '-'));
-                                        short_msg => sprintf("Fan '%s' status is %s", 
+        my $exit = $self->get_severity(section => 'fan', value => $result->{sysChassisFanStatus});
-                                                             $instance, $map_status{$status}));
+        if (!$self->{output}->is_status(value => $exit, compare => 'ok', litteral => 1)) {
+            $self->{output}->output_add(severity => $exit,
+                                        short_msg => sprintf("Fan '%s' status is '%s'", 
+                                            $instance, $result->{sysChassisFanStatus}));
         }
-
+        
-        $self->{output}->perfdata_add(label => "fan_" . $instance,
+        if (defined($result->{sysChassisFanSpeed}) && $result->{sysChassisFanSpeed} =~ /[0-9]/) {
-                                      value => $speed,
+            my ($exit2, $warn, $crit, $checked) = $self->get_severity_numeric(section => 'fan', instance => $instance, value => $result->{sysChassisFanSpeed});
-                                      );
+            if (!$self->{output}->is_status(value => $exit2, compare => 'ok', litteral => 1)) {
-    }   
+                $self->{output}->output_add(severity => $exit2,
-
+                                            short_msg => sprintf("fan speed '%s' is %s rpm", $instance, $result->{sysChassisFanSpeed}));
+            }
+            $self->{output}->perfdata_add(label => "fan_" . $instance, unit => 'rpm',
+                                          value => $result->{sysChassisFanSpeed},
+                                          warning => $warn,
+                                          critical => $crit,
+                                          min => 0);
+        }
+    }
 }
 
 1;

centreon-plugins/network/f5/bigip/mode/components/psu.pm

@@ -29,33 +29,42 @@ my %map_status = (
     2 => 'notPresent',
 );
 
+my $mapping = {
+    sysChassisPowerSupplyStatus => { oid => '.1.3.6.1.4.1.3375.2.1.3.2.2.2.1.2', map => \%map_status },
+};
+
+sub load {
+    my (%options) = @_;
+    
+    push @{$options{request}}, { oid => $mapping->{sysChassisPowerSupplyStatus}->{oid} };
+}
+
 sub check {
     my ($self) = @_;
 
-    $self->{components}->{psu} = {name => 'psus', total => 0, skip => 0};
     $self->{output}->output_add(long_msg => "Checking power supplies");
+    $self->{components}->{psu} = {name => 'psus', total => 0, skip => 0};
     return if ($self->check_exclude(section => 'psu'));
-    
-    my $oid_sysChassisPowerSupplyEntry = '.1.3.6.1.4.1.3375.2.1.3.2.2.2.1';
-    my $oid_sysChassisPowerSupplyStatus = '.1.3.6.1.4.1.3375.2.1.3.2.2.2.1.2';
-    
-    my $result = $self->{snmp}->get_table(oid => $oid_sysChassisPowerSupplyEntry);
-    return if (scalar(keys %$result) <= 0);
 
-    foreach my $key ($self->{snmp}->oid_lex_sort(keys %$result)) {
+    foreach my $oid ($self->{snmp}->oid_lex_sort(keys %{$self->{results}->{$mapping->{sysChassisPowerSupplyStatus}->{oid}}})) {
-        next if ($key !~ /^$oid_sysChassisPowerSupplyStatus\.(\d+)$/);
+        $oid =~ /^$mapping->{sysChassisPowerSupplyStatus}->{oid}\.(.*)$/;
         my $instance = $1;
-        next if ($self->check_exclude(section => 'psu', instance => $instance));
+        my $result = $self->{snmp}->map_instance(mapping => $mapping, results => $self->{results}->{$mapping->{sysChassisPowerSupplyStatus}->{oid}}, instance => $instance);
     
-        my $status = $result->{$oid_sysChassisPowerSupplyStatus . '.' . $instance};
+        next if ($result->{sysChassisPowerSupplyStatus} =~ /notPresent/i && 
-     
+                 $self->absent_problem(section => 'psu', instance => $instance));
+        next if ($self->check_exclude(section => 'psu', instance => $instance));
+        
         $self->{components}->{psu}->{total}++;
-        $self->{output}->output_add(long_msg => sprintf("Power Supply '%s' status is %s.", 
+        
-                                                        $instance, $map_status{$status}));
+        $self->{output}->output_add(long_msg => sprintf("power supply '%s' status is '%s' [instance: %s].", 
-        if ($status < 1) {
+                                    $instance, $result->{sysChassisPowerSupplyStatus}, $instance
-            $self->{output}->output_add(severity =>  'CRITICAL',
+                                    ));
-                                        short_msg => sprintf("Power Supply '%s' status is %s", 
+        my $exit = $self->get_severity(section => 'psu', value => $result->{sysChassisPowerSupplyStatus});
-                                                             $instance, $map_status{$status}));
+        if (!$self->{output}->is_status(value => $exit, compare => 'ok', litteral => 1)) {
+            $self->{output}->output_add(severity => $exit,
+                                        short_msg => sprintf("Power supply '%s' status is '%s'", 
+                                            $instance, $result->{sysChassisPowerSupplyStatus}));
         }
     }
 }

centreon-plugins/network/f5/bigip/mode/components/temperature.pm

@@ -23,37 +23,46 @@ package network::f5::bigip::mode::components::temperature;
 use strict;
 use warnings;
 
+my $mapping = {
+    sysChassisTempTemperature => { oid => '.1.3.6.1.4.1.3375.2.1.3.2.3.2.1.2' },
+};
+
+sub load {
+    my (%options) = @_;
+    
+    push @{$options{request}}, { oid => $mapping->{sysChassisTempTemperature}->{oid} };
+}
+
 sub check {
     my ($self) = @_;
-    
+
     $self->{output}->output_add(long_msg => "Checking temperatures");
     $self->{components}->{temperature} = {name => 'temperatures', total => 0, skip => 0};
     return if ($self->check_exclude(section => 'temperature'));
 
-    my $oid_sysChassisTempEntry = '.1.3.6.1.4.1.3375.2.1.3.2.3.2.1';
+    foreach my $oid ($self->{snmp}->oid_lex_sort(keys %{$self->{results}->{$mapping->{sysChassisTempTemperature}->{oid}}})) {
-    my $oid_sysChassisTempTemperature = '.1.3.6.1.4.1.3375.2.1.3.2.3.2.1.2';
+        $oid =~ /^$mapping->{sysChassisTempTemperature}->{oid}\.(.*)$/;
-   
-    my $result = $self->{snmp}->get_table(oid => $oid_sysChassisTempEntry);
-    return if (scalar(keys %$result) <= 0); 
-
-    foreach my $key ($self->{snmp}->oid_lex_sort(keys %$result)) {
-        next if ($key !~ /^$oid_sysChassisTempTemperature\.(\d+)$/);
         my $instance = $1;
+        my $result = $self->{snmp}->map_instance(mapping => $mapping, results => $self->{results}->{$mapping->{sysChassisTempTemperature}->{oid}}, instance => $instance);
+    
         next if ($self->check_exclude(section => 'temperature', instance => $instance));
 	
-        my $exit_code = $self->{perfdata}->threshold_check(value => $result->{$oid_sysChassisTempTemperature . '.' . $instance},
+        $self->{components}->{temperature}->{total}++;
-                                                           threshold => [ { label => 'critical', 'exit_litteral' => 'critical' }, { label => 'warning', exit_litteral => 'warning' } ]);
+        $self->{output}->output_add(long_msg => sprintf("temperature '%s' is %.2f C [instance: %s].", 
-
+                                    $instance, $result->{sysChassisTempTemperature}, $instance
-    	$self->{components}->{temperature}->{total}++;
+                                    ));
-    	$self->{output}->output_add(severity => $exit_code,long_msg => sprintf("temp_" . $instance . " is %.2f C", $result->{$oid_sysChassisTempTemperature . '.' . $instance}));
+                                    
-        if (!$self->{output}->is_status(value => $exit_code, compare => 'ok', litteral => 1)) {
+        if (defined($result->{sysChassisTempTemperature}) && $result->{sysChassisTempTemperature} =~ /[0-9]/) {
-            $self->{output}->output_add(severity => $exit_code,short_msg => sprintf("temp_" . $instance . " is %.2f C", $result->{$oid_sysChassisTempTemperature . '.' . $instance}));
+            my ($exit, $warn, $crit, $checked) = $self->get_severity_numeric(section => 'temperature', instance => $instance, value => $result->{sysChassisTempTemperature});
+            if (!$self->{output}->is_status(value => $exit, compare => 'ok', litteral => 1)) {
+                $self->{output}->output_add(severity => $exit,
+                                            short_msg => sprintf("Temperature '%s' is %.2f C", $instance, $result->{sysChassisTempTemperature}));
+            }
+            $self->{output}->perfdata_add(label => "temp_" . $instance, unit => 'C',
+                                          value => sprintf("%.2f", $result->{sysChassisTempTemperature}),
+                                          warning => $warn,
+                                          critical => $crit);
         }
-
-    	$self->{output}->perfdata_add(label => "temp_" . $instance , unit => 'C', 
-                                      value => sprintf("%.2f", $result->{$oid_sysChassisTempTemperature . '.' . $instance}),
-                                      warning => $self->{perfdata}->get_perfdata_for_output(label => 'warning'),
-                                      critical => $self->{perfdata}->get_perfdata_for_output(label => 'critical'));
     }
 }
 

centreon-plugins/network/f5/bigip/mode/connections.pm

@@ -24,6 +24,71 @@ use base qw(centreon::plugins::mode);
 
 use strict;
 use warnings;
+use centreon::plugins::values;
+use centreon::plugins::statefile;
+use Digest::MD5 qw(md5_hex);
+
+my $maps_counters = {
+    global => [
+        { label => 'client', set => {
+                key_values => [ { name => 'client' } ],
+                output_template => 'Current client connections : %s',
+                perfdatas => [
+                    { label => 'Client', value => 'client_absolute', template => '%s', 
+                      min => 0, unit => 'con' },
+                ],
+            }
+        },
+        { label => 'client-ssl', set => {
+                key_values => [ { name => 'client_ssl' } ],
+                output_template => 'Current client SSL connections : %s',
+                perfdatas => [
+                    { label => 'ClientSSL', value => 'client_ssl_absolute', template => '%s', 
+                      min => 0, unit => 'con' },
+                ],
+            }
+        },
+        { label => 'client-ssl-tps', set => {        
+                key_values => [ { name => 'client_ssl_tot_native', diff => 1 }, { name => 'client_ssl_tot_compat', diff => 1 } ],
+                output_template => 'TPS client SSL connections : %.2f', threshold_use => 'client_ssl_tps', output_use => 'client_ssl_tps',
+                closure_custom_calc => \&custom_client_tps_calc,
+                per_second => 1,
+                perfdatas => [
+                    { label => 'ClientSSL_Tps', value => 'client_ssl_tps', template => '%.2f',
+                      unit => 'tps', min => 0 },
+                ],
+            }
+        },
+        { label => 'server', set => { 
+                key_values => [ { name => 'server' } ],
+                output_template => 'Current server connections: %s',
+                perfdatas => [
+                    { label => 'Server', value => 'server_absolute', template => '%s', 
+                      min => 0, unit => 'con' },
+                ],
+            }
+        },
+        { label => 'server-ssl', set => {
+                key_values => [ { name => 'server_ssl' } ],
+                output_template => 'Current server SSL connections : %s',
+                perfdatas => [
+                    { label => 'ServerSSL', value => 'server_ssl_absolute', template => '%s', 
+                      min => 0, unit => 'con' },
+                ],
+            }
+        },
+    ]
+};
+
+sub custom_client_tps_calc {
+    my ($self, %options) = @_;
+
+    my $diff_native = $options{new_datas}->{$self->{instance} . '_client_ssl_tot_native'} - $options{old_datas}->{$self->{instance} . '_client_ssl_tot_native'};
+    my $diff_compat = $options{new_datas}->{$self->{instance} . '_client_ssl_tot_compat'} - $options{old_datas}->{$self->{instance} . '_client_ssl_tot_compat'};
+    $self->{result_values}->{client_ssl_tps} = ($diff_native + $diff_compat) / $options{delta_time};
+    
+    return 0;
+}
 
 sub new {
     my ($class, %options) = @_;
@@ -33,12 +98,25 @@ sub new {
     $self->{version} = '1.0';
     $options{options}->add_options(arguments =>
                                 {
-                                  "warning-client:s"    => { name => 'warning_client' },
+                                "filter-counters:s" => { name => 'filter_counters' },
-                                  "critical-client:s"   => { name => 'critical_client' },
-                                  "warning-server:s"    => { name => 'warning_server' },
-                                  "critical-server:s"   => { name => 'critical_server' },
                                 });
+    $self->{statefile_value} = centreon::plugins::statefile->new(%options);
 
+    foreach my $key (('global')) {
+        foreach (@{$maps_counters->{$key}}) {
+            if (!defined($_->{threshold}) || $_->{threshold} != 0) {
+                $options{options}->add_options(arguments => {
+                                                            'warning-' . $_->{label} . ':s'    => { name => 'warning-' . $_->{label} },
+                                                            'critical-' . $_->{label} . ':s'    => { name => 'critical-' . $_->{label} },
+                                               });
+            }
+            $_->{obj} = centreon::plugins::values->new(statefile => $self->{statefile_value},
+                                                       output => $self->{output}, perfdata => $self->{perfdata},
+                                                       label => $_->{label});
+            $_->{obj}->set(%{$_->{set}});
+        }
+    }
+                                
     return $self;
 }
 
@@ -46,71 +124,106 @@ sub check_options {
     my ($self, %options) = @_;
     $self->SUPER::init(%options);
     
-    if (($self->{perfdata}->threshold_validate(label => 'warning-client', value => $self->{option_results}->{warning_client})) == 0) {
+     foreach my $key (('global')) {
-       $self->{output}->add_option_msg(short_msg => "Wrong warning-client threshold '" . $self->{option_results}->{option_results}->{warning_client} . "'.");
+        foreach (@{$maps_counters->{$key}}) {
-       $self->{output}->option_exit();
+            $_->{obj}->init(option_results => $self->{option_results});
+        }
     }
-    if (($self->{perfdata}->threshold_validate(label => 'critical-client', value => $self->{option_results}->{critical_client})) == 0) {
+    
-       $self->{output}->add_option_msg(short_msg => "Wrong critical-client threshold '" . $self->{option_results}->{critical_client} . "'.");
+    $self->{statefile_value}->check_options(%options);
-       $self->{output}->option_exit();
+}
+
+sub run_global {
+    my ($self, %options) = @_;
+    
+    my ($short_msg, $short_msg_append, $long_msg, $long_msg_append) = ('', '', '', '');
+    my @exits;
+    foreach (@{$maps_counters->{global}}) {
+        my $obj = $_->{obj};
+
+        next if (defined($self->{option_results}->{filter_counters}) && $self->{option_results}->{filter_counters} ne '' &&
+            $_->{name} !~ /$self->{option_results}->{filter_counters}/);
+        
+        $obj->set(instance => 'global');
+    
+        my ($value_check) = $obj->execute(new_datas => $self->{new_datas}, values => $self->{global});
+
+        if ($value_check != 0) {
+            $long_msg .= $long_msg_append . $obj->output_error();
+            $long_msg_append = ', ';
+            next;
+        }
+        my $exit2 = $obj->threshold_check();
+        push @exits, $exit2;
+
+        my $output = $obj->output();
+        $long_msg .= $long_msg_append . $output;
+        $long_msg_append = ', ';
+        
+        if (!$self->{output}->is_status(litteral => 1, value => $exit2, compare => 'ok')) {
+            $short_msg .= $short_msg_append . $output;
+            $short_msg_append = ', ';
+        }
+        
+        $obj->perfdata();
     }
-    if (($self->{perfdata}->threshold_validate(label => 'warning-server', value => $self->{option_results}->{warning_server})) == 0) {
+
-       $self->{output}->add_option_msg(short_msg => "Wrong warning-server threshold '" . $self->{option_results}->{warning_client} . "'.");
+    my $exit = $self->{output}->get_most_critical(status => [ @exits ]);
-       $self->{output}->option_exit();
+    if (!$self->{output}->is_status(litteral => 1, value => $exit, compare => 'ok')) {
-    }
+        $self->{output}->output_add(severity => $exit,
-    if (($self->{perfdata}->threshold_validate(label => 'critical-server', value => $self->{option_results}->{critical_server})) == 0) {
+                                    short_msg => "$short_msg"
-       $self->{output}->add_option_msg(short_msg => "Wrong critical-server threshold '" . $self->{option_results}->{critical_client} . "'.");
+                                    );
-       $self->{output}->option_exit();
+    } else {
+        $self->{output}->output_add(short_msg => "$long_msg");
     }
 }
 
 sub run {
     my ($self, %options) = @_;
-    # $options{snmp} = snmp object
-    $self->{snmp} = $options{snmp};
     
-    if ($self->{snmp}->is_snmpv1()) {
+    $self->manage_selection(%options);
-        $self->{output}->add_option_msg(short_msg => "Need to use SNMP v2c or v3.");
+    
-        $self->{output}->option_exit();
+    $self->{new_datas} = {};
-    }
+    $self->{statefile_value}->read(statefile => $self->{cache_name});
+    $self->{new_datas}->{last_timestamp} = time();
+    
+    $self->run_global();
 
+    $self->{statefile_value}->write(data => $self->{new_datas});
+    $self->{output}->display();
+    $self->{output}->exit();
+}
+
+sub manage_selection {
+    my ($self, %options) = @_;
+
+    $self->{cache_name} = "f5_bipgip_" . $options{snmp}->get_hostname()  . '_' . $options{snmp}->get_port() . '_' . $self->{mode} . '_' . 
+        (defined($self->{option_results}->{filter_counters}) ? md5_hex($self->{option_results}->{filter_counters}) : md5_hex('all'));
+    
     my $oid_sysStatClientCurConns = '.1.3.6.1.4.1.3375.2.1.1.2.1.8.0';
     my $oid_sysStatServerCurConns = '.1.3.6.1.4.1.3375.2.1.1.2.1.15.0';
     my $oid_sysClientsslStatCurConns = '.1.3.6.1.4.1.3375.2.1.1.2.9.2.0';
     my $oid_sysServersslStatCurConns = '.1.3.6.1.4.1.3375.2.1.1.2.10.2.0';
-      
+    my $oid_sysClientsslStatTotNativeConns = '.1.3.6.1.4.1.3375.2.1.1.2.9.6.0';
-    my $result = $self->{snmp}->get_leef(oids => [$oid_sysStatClientCurConns, $oid_sysStatServerCurConns, $oid_sysClientsslStatCurConns, $oid_sysServersslStatCurConns], nothing_quit => 1);
+    my $oid_sysClientsslStatTotCompatConns = '.1.3.6.1.4.1.3375.2.1.1.2.9.9.0';
     
-    my $sysStatClientCurConns = $result->{$oid_sysStatClientCurConns};
+    if ($options{snmp}->is_snmpv1()) {
-    my $sysStatServerCurConns = $result->{$oid_sysStatServerCurConns};
+        $self->{output}->add_option_msg(short_msg => "Need to use SNMP v2c or v3.");
-    my $sysClientsslStatCurConns = $result->{$oid_sysClientsslStatCurConns};
+        $self->{output}->option_exit();
-    my $sysServersslStatCurConns = $result->{$oid_sysServersslStatCurConns};
+    }
     
-    my $exit1 = $self->{perfdata}->threshold_check(value => $sysStatClientCurConns, threshold => [ { label => 'critical-client', 'exit_litteral' => 'critical' }, { label => 'warning-client', exit_litteral => 'warning' } ]);
+    my $result = $options{snmp}->get_leef(oids => [$oid_sysStatClientCurConns, $oid_sysStatServerCurConns, 
-    my $exit2 = $self->{perfdata}->threshold_check(value => $sysStatServerCurConns, threshold => [ { label => 'critical-server', 'exit_litteral' => 'critical' }, { label => 'warning-server', exit_litteral => 'warning' } ]);
+                                                   $oid_sysClientsslStatCurConns, $oid_sysServersslStatCurConns,
-    my $exit = $self->{output}->get_most_critical(status => [ $exit1, $exit2 ]);
+                                                   $oid_sysClientsslStatTotNativeConns, $oid_sysClientsslStatTotCompatConns],
-    
+                                         nothing_quit => 1);
-    $self->{output}->output_add(severity => $exit,
+    $self->{global} = { 
-                                short_msg => sprintf("Current connections : Client = %d (SSL: %d) , Server = %d (SSL: %d)",
+        client => $result->{$oid_sysStatClientCurConns},
-                                                     $sysStatClientCurConns, $sysClientsslStatCurConns, 
+        client_ssl => $result->{$oid_sysClientsslStatCurConns},
-                                                     $sysStatServerCurConns, $sysServersslStatCurConns));
+        client_ssl_tot_native => $result->{$oid_sysClientsslStatTotNativeConns},
-    $self->{output}->perfdata_add(label => "Client", unit => 'con',
+        client_ssl_tot_compat => $result->{$oid_sysClientsslStatTotCompatConns},
-                                  value => $sysStatClientCurConns,
+        server => $result->{$oid_sysStatServerCurConns},
-                                  warning => $self->{perfdata}->get_perfdata_for_output(label => 'warning-client'),
+        server_ssl => $result->{$oid_sysServersslStatCurConns},
-                                  critical => $self->{perfdata}->get_perfdata_for_output(label => 'critical-client'),
+    };
-                                  );
-    $self->{output}->perfdata_add(label => "Server", unit => 'con',
-                                  value => $sysStatServerCurConns,
-                                  warning => $self->{perfdata}->get_perfdata_for_output(label => 'warning-server'),
-                                  critical => $self->{perfdata}->get_perfdata_for_output(label => 'critical-server'),
-                                  );
-    $self->{output}->perfdata_add(label => "ClientSSL", unit => 'con',
-                                  value => $sysClientsslStatCurConns);
-    $self->{output}->perfdata_add(label => "ServerSSL", unit => 'con',
-                                  value => $sysServersslStatCurConns);
-
-    $self->{output}->display();
-    $self->{output}->exit();
 }
     
 1;
@@ -123,23 +236,21 @@ Check current connections on F5 BIG IP device.
 
 =over 8
 
-=item B<--warning-client>
+=item B<--filter-counters>
 
-Threshold warning (current client connection number)
+Only display some counters (regexp can be used).
+Example to check SSL connections only : --filter-counters='^client-ssl|server-ssl$'
 
-=item B<--critical-client>
+=item B<--warning-*>
 
-Threshold critical (current client connection number)
+Threshold warning.
+Can be: 'client', 'server', 'client-ssl', 'server-ssl', 'client-ssl-tps'.
 
-=item B<--warning-server>
+=item B<--critical-*>
 
-Threshold warning (current server connection number)
+Threshold critical.
-
+Can be: 'client', 'server', 'client-ssl', 'server-ssl', 'client-ssl-tps'.
-=item B<--critical-server>
-
-Threshold critical (current server connection number)
 
 =back
 
-=cut
+=cut
-    

centreon-plugins/network/f5/bigip/mode/failover.pm

@@ -0,0 +1,337 @@
+#
+# Copyright 2015 Centreon (http://www.centreon.com/)
+#
+# Centreon is a full-fledged industry-strength solution that meets
+# the needs in IT infrastructure and application monitoring for
+# service performance.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+package network::f5::bigip::mode::failover;
+
+use base qw(centreon::plugins::mode);
+
+use strict;
+use warnings;
+use centreon::plugins::values;
+
+my $instance_mode;
+
+my $maps_counters = {
+    global => [
+        { label => 'sync-status', threshold => 0, set => {
+                key_values => [ { name => 'syncstatus' } ],
+                closure_custom_calc => \&custom_syncstatus_calc,
+                closure_custom_output => \&custom_syncstatus_output,
+                closure_custom_perfdata => sub { return 0; },
+                closure_custom_threshold_check => \&custom_syncstatus_threshold,
+            }
+        },
+        { label => 'failover-status', threshold => 0, set => {
+                key_values => [ { name => 'failoverstatus' } ],
+                closure_custom_calc => \&custom_failoverstatus_calc,
+                closure_custom_output => \&custom_failoverstatus_output,
+                closure_custom_perfdata => sub { return 0; },
+                closure_custom_threshold_check => \&custom_failoverstatus_threshold,
+            }
+        },
+    ]
+};
+
+sub custom_syncstatus_threshold {
+    my ($self, %options) = @_; 
+    my $status = 'ok';
+    my $message;
+    
+    eval {
+        local $SIG{__WARN__} = sub { $message = $_[0]; };
+        local $SIG{__DIE__} = sub { $message = $_[0]; };
+        
+        if (defined($instance_mode->{option_results}->{critical_sync_status}) && $instance_mode->{option_results}->{critical_sync_status} ne '' &&
+            eval "$instance_mode->{option_results}->{critical_sync_status}") {
+            $status = 'critical';
+        } elsif (defined($instance_mode->{option_results}->{critical_sync_status}) && $instance_mode->{option_results}->{critical_sync_status} ne '' &&
+                 eval "$instance_mode->{option_results}->{critical_sync_status}") {
+            $status = 'warning';
+        }
+    };
+    if (defined($message)) {
+        $self->{output}->output_add(long_msg => 'filter status issue: ' . $message);
+    }
+
+    return $status;
+}
+
+sub custom_syncstatus_output {
+    my ($self, %options) = @_;
+    my $msg = "Sync status is '" . $self->{result_values}->{syncstatus} . "'";
+
+    return $msg;
+}
+
+sub custom_syncstatus_calc {
+    my ($self, %options) = @_;
+    
+    $self->{result_values}->{syncstatus} = $options{new_datas}->{$self->{instance} . '_syncstatus'};
+    return 0;
+}
+
+sub custom_failoverstatus_threshold {
+    my ($self, %options) = @_; 
+    my $status = 'ok';
+    my $message;
+    
+    eval {
+        local $SIG{__WARN__} = sub { $message = $_[0]; };
+        local $SIG{__DIE__} = sub { $message = $_[0]; };
+        
+        if (defined($instance_mode->{option_results}->{critical_failover_status}) && $instance_mode->{option_results}->{critical_failover_status} ne '' &&
+            eval "$instance_mode->{option_results}->{critical_failover_status}") {
+            $status = 'critical';
+        } elsif (defined($instance_mode->{option_results}->{critical_failover_status}) && $instance_mode->{option_results}->{critical_failover_status} ne '' &&
+                 eval "$instance_mode->{option_results}->{critical_failover_status}") {
+            $status = 'warning';
+        }
+    };
+    if (defined($message)) {
+        $self->{output}->output_add(long_msg => 'filter status issue: ' . $message);
+    }
+
+    return $status;
+}
+
+sub custom_failoverstatus_output {
+    my ($self, %options) = @_;
+    my $msg = "Failover status is '" . $self->{result_values}->{failoverstatus} . "'";
+
+    return $msg;
+}
+
+sub custom_failoverstatus_calc {
+    my ($self, %options) = @_;
+    
+    $self->{result_values}->{failoverstatus} = $options{new_datas}->{$self->{instance} . '_failoverstatus'};
+    return 0;
+}
+
+sub new {
+    my ($class, %options) = @_;
+    my $self = $class->SUPER::new(package => __PACKAGE__, %options);
+    bless $self, $class;
+    
+    $self->{version} = '1.0';
+    $options{options}->add_options(arguments =>
+                                {
+                                "filter-counters:s" => { name => 'filter_counters' },
+                                "warning-sync-status:s"        => { name => 'warning_sync_status', default => '' },
+                                "critical-sync-status:s"       => { name => 'critical_sync_status', default => '%{syncstatus} =~ /unknown|syncFailed|syncDisconnected|incompatibleVersion/' },
+                                "warning-failover-status:s"        => { name => 'warning_failover_status', default => '' },
+                                "critical-failover-status:s"       => { name => 'critical_failover_status', default => '%{failoverstatus} =~ /unknown/' },
+                                });
+
+    foreach my $key (('global')) {
+        foreach (@{$maps_counters->{$key}}) {
+            if (!defined($_->{threshold}) || $_->{threshold} != 0) {
+                $options{options}->add_options(arguments => {
+                                                            'warning-' . $_->{label} . ':s'    => { name => 'warning-' . $_->{label} },
+                                                            'critical-' . $_->{label} . ':s'    => { name => 'critical-' . $_->{label} },
+                                               });
+            }
+            $_->{obj} = centreon::plugins::values->new(statefile => $self->{statefile_value},
+                                                       output => $self->{output}, perfdata => $self->{perfdata},
+                                                       label => $_->{label});
+            $_->{obj}->set(%{$_->{set}});
+        }
+    }
+                                
+    return $self;
+}
+
+sub check_options {
+    my ($self, %options) = @_;
+    $self->SUPER::init(%options);
+    
+    foreach my $key (('global')) {
+        foreach (@{$maps_counters->{$key}}) {
+            $_->{obj}->init(option_results => $self->{option_results});
+        }
+    }
+    
+    $instance_mode = $self;
+    $self->change_macros();
+}
+
+sub run_global {
+    my ($self, %options) = @_;
+    
+    my ($short_msg, $short_msg_append, $long_msg, $long_msg_append) = ('', '', '', '');
+    my @exits;
+    foreach (@{$maps_counters->{global}}) {
+        my $obj = $_->{obj};
+
+        next if (defined($self->{option_results}->{filter_counters}) && $self->{option_results}->{filter_counters} ne '' &&
+            $_->{name} !~ /$self->{option_results}->{filter_counters}/);
+        
+        $obj->set(instance => 'global');
+    
+        my ($value_check) = $obj->execute(values => $self->{global});
+
+        if ($value_check != 0) {
+            $long_msg .= $long_msg_append . $obj->output_error();
+            $long_msg_append = ' - ';
+            next;
+        }
+        my $exit2 = $obj->threshold_check();
+        push @exits, $exit2;
+
+        my $output = $obj->output();
+        $long_msg .= $long_msg_append . $output;
+        $long_msg_append = ' - ';
+        
+        if (!$self->{output}->is_status(litteral => 1, value => $exit2, compare => 'ok')) {
+            $short_msg .= $short_msg_append . $output;
+            $short_msg_append = ' - ';
+        }
+        
+        $obj->perfdata();
+    }
+
+    my $exit = $self->{output}->get_most_critical(status => [ @exits ]);
+    if (!$self->{output}->is_status(litteral => 1, value => $exit, compare => 'ok')) {
+        $self->{output}->output_add(severity => $exit,
+                                    short_msg => "$short_msg"
+                                    );
+    } else {
+        $self->{output}->output_add(short_msg => "$long_msg");
+    }
+}
+
+sub run {
+    my ($self, %options) = @_;
+    
+    $self->manage_selection(%options);
+    
+    $self->run_global();
+
+    $self->{output}->display();
+    $self->{output}->exit();
+}
+
+sub change_macros {
+    my ($self, %options) = @_;
+    
+    foreach (('warning_sync_status', 'critical_sync_status', 'warning_failover_status', 'critical_failover_status')) {
+        if (defined($self->{option_results}->{$_})) {
+            $self->{option_results}->{$_} =~ s/%\{(.*?)\}/\$self->{result_values}->{$1}/g;
+        }
+    }
+}
+
+my %map_boolean = (
+    0 => 'false',
+    1 => 'true',
+);
+my %map_sync_status = (
+    0 => 'unknown',
+    1 => 'syncing',
+    2 => 'needManualSync',
+    3 => 'inSync',
+    4 => 'syncFailed',
+    5 => 'syncDisconnected',
+    6 => 'standalone',
+    7 => 'awaitingInitialSync',
+    8 => 'incompatibleVersion',
+    9 => 'partialSync',
+);
+my %map_failover_status = (
+    0 => 'unknown',
+    1 => 'offline',
+    2 => 'forcedOffline',
+    3 => 'standby',
+    4 => 'active',
+);
+
+my $mapping = {
+    sysAttrFailoverIsRedundant  => { oid => '.1.3.6.1.4.1.3375.2.1.1.1.1.13', map => \%map_boolean },
+    sysAttrModeMaint            => { oid => '.1.3.6.1.4.1.3375.2.1.1.1.1.21', map => \%map_boolean },
+    sysCmSyncStatusId           => { oid => '.1.3.6.1.4.1.3375.2.1.14.1.1', map => \%map_sync_status },
+    sysCmFailoverStatusId       => { oid => '.1.3.6.1.4.1.3375.2.1.14.3.1', map => \%map_failover_status },
+};
+
+sub manage_selection {
+    my ($self, %options) = @_;
+
+    my $result = $options{snmp}->get_leef(oids => [$mapping->{sysAttrFailoverIsRedundant}->{oid} . '.0',
+                                                   $mapping->{sysAttrModeMaint}->{oid} . '.0',
+                                                   $mapping->{sysCmSyncStatusId}->{oid} . '.0',
+                                                   $mapping->{sysCmFailoverStatusId}->{oid} . '.0'],
+                                         nothing_quit => 1);
+    my $result2 = $options{snmp}->map_instance(mapping => $mapping, results => $result, instance => '0');
+    
+    if ($result2->{sysAttrModeMaint} eq 'true') {
+        $self->{output}->output_add(severity => 'OK',
+                                    short_msg => 'maintenance mode is active');
+        $self->{output}->display();
+        $self->{output}->exit();
+    }
+    if ($result2->{sysAttrFailoverIsRedundant} eq 'false') {
+        $self->{output}->output_add(severity => 'OK',
+                                    short_msg => 'failover mode is disable');
+        $self->{output}->display();
+        $self->{output}->exit();
+    }
+    
+    $self->{global} = { 
+        syncstatus => $result2->{sysCmSyncStatusId},
+        failoverstatus => $result2->{sysCmFailoverStatusId},
+    };
+}
+    
+1;
+
+__END__
+
+=head1 MODE
+
+Check failover status.
+
+=over 8
+
+=item B<--filter-counters>
+
+Only display some counters (regexp can be used).
+
+=item B<--warning-sync-status>
+
+Set warning threshold for sync status
+Can used special variables like: %{syncstatus}
+
+=item B<--critical-sync-status>
+
+Set critical threshold for sync status (Default: '%{syncstatus} =~ /unknown|syncFailed|syncDisconnected|incompatibleVersion/').
+Can used special variables like: %{syncstatus}
+
+=item B<--warning-failover-status>
+
+Set warning threshold for failover status
+Can used special variables like: %{failoverstatus}
+
+=item B<--critical-failover-status>
+
+Set critical threshold for failover status (Default: '%{failoverstatus} =~ /unknown/').
+Can used special variables like: %{failoverstatus}
+
+=back
+
+=cut

centreon-plugins/network/f5/bigip/mode/hardware.pm

@@ -24,10 +24,20 @@ use base qw(centreon::plugins::mode);
 
 use strict;
 use warnings;
+use centreon::plugins::misc;
 
-use network::f5::bigip::mode::components::fan;
+my $thresholds = {
-use network::f5::bigip::mode::components::psu;
+    fan => [
-use network::f5::bigip::mode::components::temperature;
+        ['bad', 'CRITICAL'],
+        ['good', 'OK'],
+        ['notPresent', 'OK'],
+    ],
+    psu => [
+        ['bad', 'CRITICAL'],
+        ['good', 'OK'],
+        ['notPresent', 'OK'],
+    ],
+};
 
 sub new {
     my ($class, %options) = @_;
@@ -37,12 +47,16 @@ sub new {
     $self->{version} = '1.0';
     $options{options}->add_options(arguments =>
                                 { 
-                                  "exclude:s"        => { name => 'exclude' },
+                                  "exclude:s"               => { name => 'exclude' },
-                                  "component:s"      => { name => 'component', default => 'all' },
+                                  "absent-problem:s@"       => { name => 'absent_problem' },
-                                  "warning:s"        => { name => 'warning'  },
+                                  "component:s"             => { name => 'component', default => '.*' },
-                                  "critical:s"       => { name => 'critical' },
+                                  "no-component:s"          => { name => 'no_component' },
+                                  "threshold-overload:s@"   => { name => 'threshold_overload' },
+                                  "warning:s@"              => { name => 'warning' },
+                                  "critical:s@"             => { name => 'critical' },
                                 });
     $self->{components} = {};
+    $self->{no_components} = undef;
     return $self;
 }
 
@@ -50,43 +64,105 @@ sub check_options {
     my ($self, %options) = @_;
     $self->SUPER::init(%options);
 
-    if (($self->{perfdata}->threshold_validate(label => 'warning', value => $self->{option_results}->{warning})) == 0) {
+    if (defined($self->{option_results}->{no_component})) {
-        $self->{output}->add_option_msg(short_msg => "Wrong warning threshold '" . $self->{option_results}->{warning} . "'.");
+        if ($self->{option_results}->{no_component} ne '') {
-        $self->{output}->option_exit();
+            $self->{no_components} = $self->{option_results}->{no_component};
+        } else {
+            $self->{no_components} = 'critical';
+        }
     }
-    if (($self->{perfdata}->threshold_validate(label => 'critical', value => $self->{option_results}->{critical})) == 0) {
+    
-        $self->{output}->add_option_msg(short_msg => "Wrong critical threshold '" . $self->{option_results}->{critical} . "'.");
+    $self->{absent_problem} = [];
-        $self->{output}->option_exit();
+    foreach my $val (@{$self->{option_results}->{absent_problem}}) {
+        next if (!defined($val) || $val eq '');
+        my @values = split (/,/, $val);
+        push @{$self->{absent_problem}}, { filter => $values[0], instance => $values[1] }; 
+    }
+    
+    $self->{overload_th} = {};
+    foreach my $val (@{$self->{option_results}->{threshold_overload}}) {
+        next if (!defined($val) || $val eq '');
+        my @values = split (/,/, $val);
+        if (scalar(@values) < 3) {
+            $self->{output}->add_option_msg(short_msg => "Wrong threshold-overload option '" . $val . "'.");
+            $self->{output}->option_exit();
+        }
+        my ($section, $instance, $status, $filter);
+        if (scalar(@values) == 3) {
+            ($section, $status, $filter) = @values;
+            $instance = '.*';
+        } else {
+             ($section, $instance, $status, $filter) = @values;
+        }
+        if ($section !~ /^(temperature|fan|psu)$/) {
+            $self->{output}->add_option_msg(short_msg => "Wrong threshold-overload section '" . $val . "'.");
+            $self->{output}->option_exit();
+        }
+        if ($self->{output}->is_litteral_status(status => $status) == 0) {
+            $self->{output}->add_option_msg(short_msg => "Wrong threshold-overload status '" . $val . "'.");
+            $self->{output}->option_exit();
+        }
+        $self->{overload_th}->{$section} = [] if (!defined($self->{overload_th}->{$section}));
+        push @{$self->{overload_th}->{$section}}, {filter => $filter, status => $status, instance => $instance };
+    }
+    
+    $self->{numeric_threshold} = {};
+    foreach my $option (('warning', 'critical')) {
+        foreach my $val (@{$self->{option_results}->{$option}}) {
+            next if (!defined($val) || $val eq '');
+            if ($val !~ /^(.*?),(.*?),(.*)$/) {
+                $self->{output}->add_option_msg(short_msg => "Wrong $option option '" . $val . "'.");
+                $self->{output}->option_exit();
+            }
+            my ($section, $instance, $value) = ($1, $2, $3);
+            if ($section !~ /^(temperature|fan)$/) {
+                $self->{output}->add_option_msg(short_msg => "Wrong $option option '" . $val . "'.");
+                $self->{output}->option_exit();
+            }
+            my $position = 0;
+            if (defined($self->{numeric_threshold}->{$section})) {
+                $position = scalar(@{$self->{numeric_threshold}->{$section}});
+            }
+            if (($self->{perfdata}->threshold_validate(label => $option . '-' . $section . '-' . $position, value => $value)) == 0) {
+                $self->{output}->add_option_msg(short_msg => "Wrong $option threshold '" . $value . "'.");
+                $self->{output}->option_exit();
+            }
+            $self->{numeric_threshold}->{$section} = [] if (!defined($self->{numeric_threshold}->{$section}));
+            push @{$self->{numeric_threshold}->{$section}}, { label => $option . '-' . $section . '-' . $position, threshold => $option, instance => $instance };
+        }
     }
-
-}
-
-sub global {
-    my ($self, %options) = @_;
-
-    network::f5::bigip::mode::components::temperature::check($self);
-    network::f5::bigip::mode::components::fan::check($self);
-    network::f5::bigip::mode::components::psu::check($self);
 }
 
 sub run {
     my ($self, %options) = @_;
-    # $options{snmp} = snmp object
     $self->{snmp} = $options{snmp};
+
+    my $snmp_request = [];
+    my @components = ('fan', 'psu', 'temperature');
+    foreach (@components) {
+        if (/$self->{option_results}->{component}/) {
+            my $mod_name = "network::f5::bigip::mode::components::$_";
+            centreon::plugins::misc::mymodule_load(output => $self->{output}, module => $mod_name,
+                                                   error_msg => "Cannot load module '$mod_name'.");
+            my $func = $mod_name->can('load');
+            $func->(request => $snmp_request);
+        }
+    }
     
-    if ($self->{option_results}->{component} eq 'all') {
+    if (scalar(@{$snmp_request}) == 0) {
-        $self->global();
-    } elsif ($self->{option_results}->{component} eq 'fan') {
-        network::f5::bigip::mode::components::fan::check($self);
-    } elsif ($self->{option_results}->{component} eq 'psu') {
-        network::f5::bigip::mode::components::psu::check($self);
-    } elsif ($self->{option_results}->{component} eq 'temperature') {
-        network::f5::bigip::mode::components::temperature::check($self);
-    } else {
         $self->{output}->add_option_msg(short_msg => "Wrong option. Cannot find component '" . $self->{option_results}->{component} . "'.");
         $self->{output}->option_exit();
     }
-
+    $self->{results} = $self->{snmp}->get_multiple_table(oids => $snmp_request);
+    
+    foreach (@components) {
+        if (/$self->{option_results}->{component}/) {
+            my $mod_name = "network::f5::bigip::mode::components::$_";
+            my $func = $mod_name->can('check');
+            $func->($self); 
+        }
+    }
+    
     my $total_components = 0;
     my $display_by_component = '';
     my $display_by_component_append = '';
@@ -94,17 +170,22 @@ sub run {
         # Skipping short msg when no components
         next if ($self->{components}->{$comp}->{total} == 0 && $self->{components}->{$comp}->{skip} == 0);
         $total_components += $self->{components}->{$comp}->{total} + $self->{components}->{$comp}->{skip};
-        $display_by_component .= $display_by_component_append . $self->{components}->{$comp}->{total} . '/' . $self->{components}->{$comp}->{skip} . ' ' . $self->{components}->{$comp}->{name};
+        my $count_by_components = $self->{components}->{$comp}->{total} + $self->{components}->{$comp}->{skip}; 
+        $display_by_component .= $display_by_component_append . $self->{components}->{$comp}->{total} . '/' . $count_by_components . ' ' . $self->{components}->{$comp}->{name};
         $display_by_component_append = ', ';
     }
     
     $self->{output}->output_add(severity => 'OK',
-                                short_msg => sprintf("All %s components [%s] are ok.", 
+                                short_msg => sprintf("All %s components are ok [%s].", 
                                                      $total_components,
-                                                     $display_by_component
+                                                     $display_by_component)
-                                                    )
                                 );
-    
+
+    if (defined($self->{option_results}->{no_component}) && $total_components == 0) {
+        $self->{output}->output_add(severity => $self->{no_components},
+                                    short_msg => 'No components are checked.');
+    }
+
     $self->{output}->display();
     $self->{output}->exit();
 }
@@ -125,6 +206,70 @@ sub check_exclude {
     return 0;
 }
 
+sub absent_problem {
+    my ($self, %options) = @_;
+    
+    foreach (@{$self->{absent_problem}}) {
+        if ($options{section} =~ /$_->{filter}/) {
+            if (!defined($_->{instance}) || $options{instance} =~ /$_->{instance}/) {
+                $self->{output}->output_add(severity => 'CRITICAL',
+                                            short_msg => sprintf("Component '%s' instance '%s' is not present", 
+                                                                 $options{section}, $options{instance}));
+                $self->{output}->output_add(long_msg => sprintf("Skipping $options{section} section $options{instance} instance (not present)"));
+                $self->{components}->{$options{section}}->{skip}++;
+                return 1;
+            }
+        }
+    }
+    
+    return 0;
+}
+
+sub get_severity {
+    my ($self, %options) = @_;
+    my $status = 'UNKNOWN'; # default 
+    
+    if (defined($self->{overload_th}->{$options{section}})) {
+        foreach (@{$self->{overload_th}->{$options{section}}}) {            
+            if ($options{value} =~ /$_->{filter}/i && 
+                (!defined($options{instance}) || $options{instance} =~ /$_->{instance}/)) {
+                $status = $_->{status};
+                return $status;
+            }
+        }
+    }
+    my $label = defined($options{label}) ? $options{label} : $options{section};
+    foreach (@{$thresholds->{$label}}) {
+        if ($options{value} =~ /$$_[0]/i) {
+            $status = $$_[1];
+            return $status;
+        }
+    }
+    
+    return $status;
+}
+
+sub get_severity_numeric {
+    my ($self, %options) = @_;
+    my $status = 'OK'; # default
+    my $thresholds = { warning => undef, critical => undef };
+    my $checked = 0;
+    
+    if (defined($self->{numeric_threshold}->{$options{section}})) {
+        my $exits = [];
+        foreach (@{$self->{numeric_threshold}->{$options{section}}}) {
+            if ($options{instance} =~ /$_->{instance}/) {
+                push @{$exits}, $self->{perfdata}->threshold_check(value => $options{value}, threshold => [ { label => $_->{label}, exit_litteral => $_->{threshold} } ]);
+                $thresholds->{$_->{threshold}} = $self->{perfdata}->get_perfdata_for_output(label => $_->{label});
+                $checked = 1;
+            }
+        }
+        $status = $self->{output}->get_most_critical(status => $exits) if (scalar(@{$exits}) > 0);
+    }
+    
+    return ($status, $thresholds->{warning}, $thresholds->{critical}, $checked);
+}
+
 1;
 
 __END__
@@ -137,21 +282,34 @@ Check hardware (fans, temperatures, power supplies).
 
 =item B<--component>
 
-Which component to check (Default: 'all').
+Which component to check (Default: '.*').
 Can be: 'fan', 'psu', 'temperature'.
 
 =item B<--exclude>
 
 Exclude some parts (comma seperated list) (Example: --exclude=fan,psu)
-Can also exclude specific instance: --exclude=fan#1#2#,psu
+Can be specific or global: --exclude=fan#1#2#,psu
+
+=item B<--no-component>
+
+Return an error if no compenents are checked.
+If total (with skipped) is 0. (Default: 'critical' returns).
+
+=item B<--threshold-overload>
+
+Set to overload default threshold values (syntax: section,[instance,]status,regexp)
+It used before default thresholds (order stays).
+Example: --threshold-overload='powerQuality,CRITICAL,^(?!(normal)$)'
 
 =item B<--warning>
 
-Threshold warning in degree celsius.
+Set warning threshold for temperatures, fan speed (syntax: type,instance,threshold)
+Example: --warning='temperature,.*,30'
 
 =item B<--critical>
 
-Threshold critical in degree celsius.
+Set critical threshold for temperatures, fan speed (syntax: type,instance,threshold)
+Example: --critical='temperature,.*,40'
 
 =back
 

centreon-plugins/network/f5/bigip/plugin.pm

@@ -32,14 +32,15 @@ sub new {
 
     $self->{version} = '1.0';
     %{$self->{modes}} = (
-                         'node-status'          => 'network::f5::bigip::mode::nodestatus',
+                         'connections'          => 'network::f5::bigip::mode::connections',
-                         'pool-status'          => 'network::f5::bigip::mode::poolstatus',
+                         'failover'             => 'network::f5::bigip::mode::failover',
-                         'virtualserver-status' => 'network::f5::bigip::mode::virtualserverstatus',
+                         'hardware'             => 'network::f5::bigip::mode::hardware',
                          'list-nodes'           => 'network::f5::bigip::mode::listnodes',
                          'list-pools'           => 'network::f5::bigip::mode::listpools',
                          'list-virtualservers'  => 'network::f5::bigip::mode::listvirtualservers',
-                         'hardware'             => 'network::f5::bigip::mode::hardware',
+                         'node-status'          => 'network::f5::bigip::mode::nodestatus',
-                         'connections'          => 'network::f5::bigip::mode::connections',
+                         'pool-status'          => 'network::f5::bigip::mode::poolstatus',
+                         'virtualserver-status' => 'network::f5::bigip::mode::virtualserverstatus',
                          );
 
     return $self;

centreon-plugins/os/linux/local/mode/cmdreturn.pm

@@ -99,6 +99,11 @@ sub run {
                                     short_msg => 'Exit code from command');
     }
     
+    if (defined($exit_code)) {
+        $self->{output}->perfdata_add(label => "code",
+                                      value => $exit_code);
+    }
+    
     $self->{output}->display();
     $self->{output}->exit();
 }

centreon-plugins/snmp_standard/mode/inodes.pm

@@ -24,10 +24,22 @@ use base qw(centreon::plugins::mode);
 
 use strict;
 use warnings;
-use centreon::plugins::statefile;
+use centreon::plugins::values;
 
-my $oid_dskPath = '.1.3.6.1.4.1.2021.9.1.2';
+my $maps_counters = {
-my $oid_dskPercentNode = '.1.3.6.1.4.1.2021.9.1.10';
+    disk => {
+        '000_usage'   => {
+            set => {
+                key_values => [ { name => 'usage' }, { name => 'display' } ],
+                output_template => 'Used: %s %%', output_error_template => "%s",
+                perfdatas => [
+                    { label => 'used', value => 'usage_absolute', template => '%d',
+                      unit => '%', min => 0, max => 100, label_extra_instance => 1, instance_use => 'display_absolute' },
+                ],
+            },
+        },
+    }
+};
 
 sub new {
     my ($class, %options) = @_;
@@ -36,21 +48,30 @@ sub new {
     
     $self->{version} = '1.0';
     $options{options}->add_options(arguments =>
-                                { 
+                                {
-                                  "warning:s"               => { name => 'warning' },
-                                  "critical:s"              => { name => 'critical' },
-                                  "reload-cache-time:s"     => { name => 'reload_cache_time', default => 180 },
                                   "name"                    => { name => 'use_name' },
                                   "diskpath:s"              => { name => 'diskpath' },
                                   "regexp"                  => { name => 'use_regexp' },
                                   "regexp-isensitive"       => { name => 'use_regexpi' },
+                                  "filter-device:s"         => { name => 'filter_device' },
                                   "display-transform-src:s" => { name => 'display_transform_src' },
                                   "display-transform-dst:s" => { name => 'display_transform_dst' },
-                                  "show-cache"              => { name => 'show_cache' },
                                 });
 
-    $self->{diskpath_id_selected} = [];
+    foreach my $key (('disk')) {
-    $self->{statefile_cache} = centreon::plugins::statefile->new(%options);
+        foreach (keys %{$maps_counters->{$key}}) {
+            my ($id, $name) = split /_/;
+            if (!defined($maps_counters->{$key}->{$_}->{threshold}) || $maps_counters->{$key}->{$_}->{threshold} != 0) {
+                $options{options}->add_options(arguments => {
+                                                            'warning-' . $name . ':s'    => { name => 'warning-' . $name },
+                                                            'critical-' . $name . ':s'    => { name => 'critical-' . $name },
+                                               });
+            }
+            $maps_counters->{$key}->{$_}->{obj} = centreon::plugins::values->new(output => $self->{output}, perfdata => $self->{perfdata},
+                                                      label => $name);
+            $maps_counters->{$key}->{$_}->{obj}->set(%{$maps_counters->{$key}->{$_}->{set}});
+        }
+    }
     
     return $self;
 }
@@ -58,146 +79,142 @@ sub new {
 sub check_options {
     my ($self, %options) = @_;
     $self->SUPER::init(%options);
-
-    if (($self->{perfdata}->threshold_validate(label => 'warning', value => $self->{option_results}->{warning})) == 0) {
-       $self->{output}->add_option_msg(short_msg => "Wrong warning threshold '" . $self->{option_results}->{warning} . "'.");
-       $self->{output}->option_exit();
-    }
-    if (($self->{perfdata}->threshold_validate(label => 'critical', value => $self->{option_results}->{critical})) == 0) {
-       $self->{output}->add_option_msg(short_msg => "Wrong critical threshold '" . $self->{option_results}->{critical} . "'.");
-       $self->{output}->option_exit();
-    }
     
-    $self->{statefile_cache}->check_options(%options);
+    foreach my $key (('disk')) {
+        foreach (keys %{$maps_counters->{$key}}) {
+            $maps_counters->{$key}->{$_}->{obj}->init(option_results => $self->{option_results});
+        }
+    }
 }
 
 sub run {
     my ($self, %options) = @_;
-    # $options{snmp} = snmp object
     $self->{snmp} = $options{snmp};
-    $self->{hostname} = $self->{snmp}->get_hostname();
-    $self->{snmp_port} = $self->{snmp}->get_port();
 
     $self->manage_selection();
-
+    
-    $self->{snmp}->load(oids => [$oid_dskPercentNode], instances => $self->{diskpath_id_selected});
+    my $multiple = 1;
-    my $result = $self->{snmp}->get_leef(nothing_quit => 1);
+    if (scalar(keys %{$self->{disk_selected}}) == 1) {
-
+        $multiple = 0;
-    if (!defined($self->{option_results}->{diskpath}) || defined($self->{option_results}->{use_regexp})) {
+    }
+    
+    if ($multiple == 1) {
         $self->{output}->output_add(severity => 'OK',
-                                    short_msg => 'All inode partitions are ok.');
+                                    short_msg => 'All inode partitions are ok');
     }
+    
+    foreach my $id (sort keys %{$self->{disk_selected}}) {     
+        my ($short_msg, $short_msg_append, $long_msg, $long_msg_append) = ('', '', '', '');
+        my @exits;
+        foreach (sort keys %{$maps_counters->{disk}}) {
+            my $obj = $maps_counters->{disk}->{$_}->{obj};
+            $obj->set(instance => $id);
+        
+            my ($value_check) = $obj->execute(values => $self->{disk_selected}->{$id});
 
-    foreach (sort @{$self->{diskpath_id_selected}}) {
+            if ($value_check != 0) {
-        my $name_diskpath = $self->get_display_value(id => $_);
+                $long_msg .= $long_msg_append . $obj->output_error();
+                $long_msg_append = ', ';
+                next;
+            }
+            my $exit2 = $obj->threshold_check();
+            push @exits, $exit2;
 
-        my $prct_used = $result->{$oid_dskPercentNode . '.' . $_};
+            my $output = $obj->output();
-        my $prct_free = 100 - $prct_used;
+            $long_msg .= $long_msg_append . $output;
+            $long_msg_append = ', ';
+            
+            if (!$self->{output}->is_status(litteral => 1, value => $exit2, compare => 'ok')) {
+                $short_msg .= $short_msg_append . $output;
+                $short_msg_append = ', ';
+            }
+            
+            $obj->perfdata(extra_instance => $multiple);
+        }
 
-        my $exit = $self->{perfdata}->threshold_check(value => $prct_used, threshold => [ { label => 'critical', 'exit_litteral' => 'critical' }, { label => 'warning', exit_litteral => 'warning' } ]);
+        $self->{output}->output_add(long_msg => "Inode partition '" . $self->{disk_selected}->{$id}->{display} . "' $long_msg");
-
+        my $exit = $self->{output}->get_most_critical(status => [ @exits ]);
-        $self->{output}->output_add(long_msg => sprintf("Inodes partition '%s' Used: %s %%  Free: %s %%", 
+        if (!$self->{output}->is_status(litteral => 1, value => $exit, compare => 'ok')) {
-                                            $name_diskpath, $prct_used, $prct_free));
-        if (!$self->{output}->is_status(value => $exit, compare => 'ok', litteral => 1) || (defined($self->{option_results}->{diskpath}) && !defined($self->{option_results}->{use_regexp}))) {
             $self->{output}->output_add(severity => $exit,
-                                        short_msg => sprintf("Inodes partition '%s' Used: %s %%  Free: %s %%", 
+                                        short_msg => "Inode partition '" . $self->{disk_selected}->{$id}->{display} . "' $short_msg"
-                                            $name_diskpath, $prct_used, $prct_free));
+                                        );
-        }    
+        }
-
+        
-        my $label = 'used';
+        if ($multiple == 0) {
-        my $extra_label = '';
+            $self->{output}->output_add(short_msg => "Inode partition '" . $self->{disk_selected}->{$id}->{display} . "' $long_msg");
-        $extra_label = '_' . $name_diskpath if (!defined($self->{option_results}->{diskpath}) || defined($self->{option_results}->{use_regexp}));
+        }
-        $self->{output}->perfdata_add(label => $label . $extra_label, unit => '%',
-                                      value => $prct_used,
-                                      warning => $self->{perfdata}->get_perfdata_for_output(label => 'warning'),
-                                      critical => $self->{perfdata}->get_perfdata_for_output(label => 'critical'),
-                                      min => 0, max => 100);
     }
-
+    
     $self->{output}->display();
     $self->{output}->exit();
 }
 
-sub reload_cache {
+my $mapping = {
-    my ($self) = @_;
+    dskPath => { oid => '.1.3.6.1.4.1.2021.9.1.2' },
-    my $datas = {};
+    dskDevice => { oid => '.1.3.6.1.4.1.2021.9.1.3' },
-
+    dskPercentNode => { oid => '.1.3.6.1.4.1.2021.9.1.10' },
-    my $result = $self->{snmp}->get_table(oid => $oid_dskPath);
+};
-    $datas->{last_timestamp} = time();
-    $datas->{all_ids} = [];
-    foreach my $key ($self->{snmp}->oid_lex_sort(keys %$result)) {
-        next if ($key !~ /\.([0-9]+)$/);
-        push @{$datas->{all_ids}}, $1;
-        $datas->{'dskPath_' . $1} = $self->{output}->to_utf8($result->{$key});
-    }
-    
-    if (scalar(@{$datas->{all_ids}}) <= 0) {
-        $self->{output}->add_option_msg(short_msg => "Can't construct cache...");
-        $self->{output}->option_exit();
-    }
-
-    $self->{statefile_cache}->write(data => $datas);
-}
 
 sub manage_selection {
     my ($self, %options) = @_;
-
+    
-    # init cache file
+    my $results = $self->{snmp}->get_multiple_table(oids => [ { oid => $mapping->{dskPath}->{oid} }, 
-    my $has_cache_file = $self->{statefile_cache}->read(statefile => 'cache_snmpstandard_' . $self->{hostname}  . '_' . $self->{snmp_port} . '_' . $self->{mode});
+                                                              { oid => $mapping->{dskDevice}->{oid} }, 
-    if (defined($self->{option_results}->{show_cache})) {
+                                                              { oid => $mapping->{dskPercentNode}->{oid} } ],
-        $self->{output}->add_option_msg(long_msg => $self->{statefile_cache}->get_string_content());
+                                                    return_type => 1, nothing_quit => 1);
-        $self->{output}->option_exit();
+    $self->{disk_selected} = {};
-    }
+    foreach my $oid ($self->{snmp}->oid_lex_sort(keys %{$results})) {
-
+        next if ($oid !~ /^$mapping->{dskPath}->{oid}\.(.*)/);
-    my $timestamp_cache = $self->{statefile_cache}->get(name => 'last_timestamp');
+        my $instance = $1;
-    if ($has_cache_file == 0 || !defined($timestamp_cache) || 
+        
-        ((time() - $timestamp_cache) > (($self->{option_results}->{reload_cache_time}) * 60))) {
+        my $result = $self->{snmp}->map_instance(mapping => $mapping, results => $results, instance => $instance);
-            $self->reload_cache();
+        $result->{dskPath} = $self->get_display_value(value => $result->{dskPath});
-            $self->{statefile_cache}->read();
+        
-    }
+        $self->{output}->output_add(long_msg => sprintf("disk path : '%s', device : '%s'", $result->{dskPath}, $result->{dskDevice}), debug => 1);
-
+        
-    my $all_ids = $self->{statefile_cache}->get(name => 'all_ids');
+        if (!defined($result->{dskPercentNode})) {
-    if (!defined($self->{option_results}->{use_name}) && defined($self->{option_results}->{diskpath})) {
+            $self->{output}->output_add(long_msg => sprintf("skipping '%s' : no inode usage value", $result->{dskPath}), debug => 1);
-        # get by ID
+            next;
-        push @{$self->{diskpath_id_selected}}, $self->{option_results}->{diskpath}; 
-        my $name = $self->{statefile_cache}->get(name => 'dskPath_' . $self->{option_results}->{diskpath});
-        if (!defined($name)) {
-            $self->{output}->add_option_msg(short_msg => "No disk path found for id '" . $self->{option_results}->{diskpath} . "'.");
-            $self->{output}->option_exit();
         }
-    } else {
+        if (defined($result->{dskDevice}) && defined($self->{option_results}->{filter_device}) && 
-        foreach my $i (@{$all_ids}) {
+            $self->{option_results}->{filter_device} ne '' && $result->{dskDevice} !~ /$self->{option_results}->{filter_device}/) {
-            my $filter_name = $self->{statefile_cache}->get(name => 'dskPath_' . $i);
+            $self->{output}->output_add(long_msg => sprintf("skipping '%s' : filter disk device", $result->{dskPath}), debug => 1);
-            next if (!defined($filter_name));
+            next;
-            if (!defined($self->{option_results}->{diskpath})) {
+        }   
-                push @{$self->{diskpath_id_selected}}, $i; 
+        
+        if (!defined($self->{option_results}->{use_name}) && defined($self->{option_results}->{diskpath})) {
+            if ($self->{option_results}->{diskpath} !~ /(^|\s|,)$instance(\s*,|$)/) {
+                $self->{output}->output_add(long_msg => sprintf("skipping '%s' : filter id disk path", $result->{dskPath}), debug => 1);
                 next;
             }
-            if (defined($self->{option_results}->{use_regexp}) && defined($self->{option_results}->{use_regexpi}) && $filter_name =~ /$self->{option_results}->{diskpath}/i) {
+        } elsif (defined($self->{option_results}->{diskpath}) && $self->{option_results}->{diskpath} ne '') {
-                push @{$self->{diskpath_id_selected}}, $i; 
+            if (defined($self->{option_results}->{use_regexp}) && defined($self->{option_results}->{use_regexpi}) && $result->{dskPath} !~ /$self->{option_results}->{diskpath}/i) {
+                $self->{output}->output_add(long_msg => sprintf("skipping '%s' : filter disk path", $result->{dskPath}), debug => 1);
+                next;
             }
-            if (defined($self->{option_results}->{use_regexp}) && !defined($self->{option_results}->{use_regexpi}) && $filter_name =~ /$self->{option_results}->{diskpath}/) {
+            if (defined($self->{option_results}->{use_regexp}) && !defined($self->{option_results}->{use_regexpi}) && $result->{dskPath} !~ /$self->{option_results}->{diskpath}/) {
-                push @{$self->{diskpath_id_selected}}, $i; 
+                $self->{output}->output_add(long_msg => sprintf("skipping '%s' : filter disk path", $result->{dskPath}), debug => 1);
+                next;
             }
-            if (!defined($self->{option_results}->{use_regexp}) && !defined($self->{option_results}->{use_regexpi}) && $filter_name eq $self->{option_results}->{diskpath}) {
+            if (!defined($self->{option_results}->{use_regexp}) && !defined($self->{option_results}->{use_regexpi}) && $result->{dskPath} ne $self->{option_results}->{diskpath}) {
-                push @{$self->{diskpath_id_selected}}, $i; 
+                $self->{output}->output_add(long_msg => sprintf("skipping '%s' : filter disk path", $result->{dskPath}), debug => 1);
+                next;
             }
         }
         
-        if (scalar(@{$self->{diskpath_id_selected}}) <= 0) {
+        $self->{disk_selected}->{$instance} = { display => $result->{dskPath}, 
-            if (defined($self->{option_results}->{diskpath})) {
+                                                usage => $result->{dskPercentNode} };
-                $self->{output}->add_option_msg(short_msg => "No disk path found for name '" . $self->{option_results}->{diskpath} . "' (maybe you should reload cache file).");
+    }
-            } else {
+    
-                $self->{output}->add_option_msg(short_msg => "No disk path found (maybe you should reload cache file).");
+    if (scalar(keys %{$self->{disk_selected}}) <= 0) {
-            }
+        $self->{output}->add_option_msg(short_msg => "No entry found.");
-            $self->{output}->option_exit();
+        $self->{output}->option_exit();
-        }
     }
 }
 
 sub get_display_value {
     my ($self, %options) = @_;
-    my $value = $self->{statefile_cache}->get(name => 'dskPath_' . $options{id});
+    my $value = $options{value};
 
     if (defined($self->{option_results}->{display_transform_src})) {
         $self->{option_results}->{display_transform_dst} = '' if (!defined($self->{option_results}->{display_transform_dst}));
@@ -217,11 +234,11 @@ Need to enable "includeAllDisks 10%" on snmpd.conf.
 
 =over 8
 
-=item B<--warning>
+=item B<--warning-usage>
 
 Threshold warning in percent.
 
-=item B<--critical>
+=item B<--critical-usage>
 
 Threshold critical in percent.
 
@@ -241,10 +258,6 @@ Allows to use regexp to filter diskpath (with option --name).
 
 Allows to use regexp non case-sensitive (with --regexp).
 
-=item B<--reload-cache-time>
-
-Time in seconds before reloading cache file (default: 180).
-
 =item B<--display-transform-src>
 
 Regexp src to transform display value. (security risk!!!)
@@ -253,9 +266,9 @@ Regexp src to transform display value. (security risk!!!)
 
 Regexp dst to transform display value. (security risk!!!)
 
-=item B<--show-cache>
+=item B<--filter-device>
 
-Display cache storage datas.
+Filter device name (Can be a regexp).
 
 =back
 

centreon-plugins/snmp_standard/mode/interfaces.pm

@@ -1217,6 +1217,10 @@ sub add_result_cast {
         }
     }
     
+    foreach (('iucast', 'imcast', 'ibcast', 'oucast', 'omcast', 'omcast')) {
+        $self->{interface_selected}->{$options{instance}}->{$_} = 0 if (!defined($self->{interface_selected}->{$options{instance}}->{$_}));
+    }
+    
     $self->{interface_selected}->{$options{instance}}->{total_in_packets} = $self->{interface_selected}->{$options{instance}}->{iucast} + $self->{interface_selected}->{$options{instance}}->{imcast} + $self->{interface_selected}->{$options{instance}}->{ibcast};
     $self->{interface_selected}->{$options{instance}}->{total_out_packets} = $self->{interface_selected}->{$options{instance}}->{oucast} + $self->{interface_selected}->{$options{instance}}->{omcast} + $self->{interface_selected}->{$options{instance}}->{obcast};
 }

centreon-plugins/snmp_standard/mode/loadaverage.pm

@@ -87,6 +87,9 @@ sub run {
     my $result = $self->{snmp}->get_leef(oids => [$oid_CpuLoad1m, $oid_CpuLoad5m, $oid_CpuLoad15m], nothing_quit => 1);
     
     my ($msg, $cpu_load1, $cpu_load5, $cpu_load15);
+    $result->{$oid_CpuLoad1m} =~ s/,/\./g;
+    $result->{$oid_CpuLoad5m} =~ s/,/\./g;
+    $result->{$oid_CpuLoad15m} =~ s/,/\./g;
 
     if (defined($self->{option_results}->{average})) {    
         my $result2 = $self->{snmp}->get_table(oid => $oid_CountCpu);

centreon-plugins/snmp_standard/mode/ntp.pm

@@ -114,11 +114,13 @@ sub run {
     $distant_time = $dt->epoch;
     
     my $diff = $distant_time - $ref_time;
+    my $remote_date_formated = sprintf("%02d-%02d-%02dT%02d:%02d:%02d (%s)", $remote_date[0], $remote_date[1], $remote_date[2],
+                                       $remote_date[3], $remote_date[4], $remote_date[5], $timezone);
     
     my $exit = $self->{perfdata}->threshold_check(value => $diff, 
-                               threshold => [ { label => 'critical', 'exit_litteral' => 'critical' }, { label => 'warning', exit_litteral => 'warning' } ]);
+                               threshold => [ { label => 'critical', exit_litteral => 'critical' }, { label => 'warning', exit_litteral => 'warning' } ]);
     $self->{output}->output_add(severity => $exit,
-                                short_msg => sprintf("Time offset %d second(s)", $diff));
+                                short_msg => sprintf("Time offset %d second(s) : %s", $diff, $remote_date_formated));
 
     $self->{output}->perfdata_add(label => 'offset', unit => 's',
                                   value => sprintf("%d", $diff),

centreon-plugins/snmp_standard/mode/processcount.pm

@@ -157,10 +157,10 @@ sub run {
     # $options{snmp} = snmp object
     $self->{snmp} = $options{snmp};
 
-    my $oid2check_filter;
+    my $oid2check_filter = 'status';
     # To have a better order
     foreach (('name', 'path', 'args', 'status')) {
-        if (defined($self->{option_results}->{'process_' . $_})) {
+        if (defined($self->{option_results}->{'process_' . $_}) && $self->{option_results}->{'process_' . $_} ne '') {
             $oid2check_filter = $_;
             last;
         }
@@ -175,7 +175,7 @@ sub run {
         push @{$more_oids}, $oid_hrSWRunPerfCPU;
     }
     foreach (keys %$oids) {
-        if ($_ ne $oid2check_filter && defined($self->{option_results}->{'process_' . $_})) {
+        if ($_ ne $oid2check_filter && defined($self->{option_results}->{'process_' . $_}) && $self->{option_results}->{'process_' . $_} ne '') {
             push @{$more_oids}, $oids->{$_};
             $mores_filters->{$_} = 1;
         }

centreon-plugins/storage/netapp/snmp/mode/filesys.pm

@@ -28,14 +28,23 @@ use centreon::plugins::values;
 
 my $maps_counters = {
     '000_usage' => { set => {
-                        key_values => [ { name => 'name' }, { name => 'used' }, { name => 'total' }, 
+            key_values => [ { name => 'name' }, { name => 'used' }, { name => 'total' }, 
-                                        { name => 'dfCompressSavedPercent' }, { name => 'dfDedupeSavedPercent' } ],
+                            { name => 'dfCompressSavedPercent' }, { name => 'dfDedupeSavedPercent' } ],
-                        closure_custom_calc => \&custom_usage_calc,
+            closure_custom_calc => \&custom_usage_calc,
-                        closure_custom_output => \&custom_usage_output,
+            closure_custom_output => \&custom_usage_output,
-                        closure_custom_perfdata => \&custom_usage_perfdata,
+            closure_custom_perfdata => \&custom_usage_perfdata,
-                        closure_custom_threshold_check => \&custom_usage_threshold,
+            closure_custom_threshold_check => \&custom_usage_threshold,
-                    }
+        }
-               },
+    },
+    '001_inodes' => { set => {
+            key_values => [ { name => 'dfPerCentInodeCapacity' }, { name => 'name' } ],
+            output_template => 'Inodes Used : %s %%', output_error_template => "Inodes : %s",
+            perfdatas => [
+                { label => 'inodes', value => 'dfPerCentInodeCapacity_absolute', template => '%d',
+                  unit => '%', min => 0, max => 100, label_extra_instance => 1, instance_use => 'name_absolute' },
+            ],
+        }
+    },
 };
 
 my $instance_mode;
@@ -178,7 +187,6 @@ sub check_options {
 
 sub run {
     my ($self, %options) = @_;
-    # $options{snmp} = snmp object
     $self->{snmp} = $options{snmp};
 
     $self->manage_selection();
@@ -249,29 +257,41 @@ my $mapping = {
     dfType      => { oid => '.1.3.6.1.4.1.789.1.5.4.1.23', map => \%map_types },
 };
 my $mapping2 = {
-    dfKBytesTotal   => { oid => '.1.3.6.1.4.1.789.1.5.4.1.3' },
+    dfFileSys               => { oid => '.1.3.6.1.4.1.789.1.5.4.1.2' },
-    dfKBytesUsed    => { oid => '.1.3.6.1.4.1.789.1.5.4.1.4' },
+    dfKBytesTotal           => { oid => '.1.3.6.1.4.1.789.1.5.4.1.3' },
-    df64TotalKBytes => { oid => '.1.3.6.1.4.1.789.1.5.4.1.29' },
+    dfKBytesUsed            => { oid => '.1.3.6.1.4.1.789.1.5.4.1.4' },
-    df64UsedKBytes  => { oid => '.1.3.6.1.4.1.789.1.5.4.1.30' },
+    dfPerCentInodeCapacity  => { oid => '.1.3.6.1.4.1.789.1.5.4.1.9' },
+    df64TotalKBytes         => { oid => '.1.3.6.1.4.1.789.1.5.4.1.29' },
+    df64UsedKBytes          => { oid => '.1.3.6.1.4.1.789.1.5.4.1.30' },
     dfCompressSavedPercent  => { oid => '.1.3.6.1.4.1.789.1.5.4.1.38' },
     dfDedupeSavedPercent    => { oid => '.1.3.6.1.4.1.789.1.5.4.1.40' },
 };
 
 sub manage_selection {
     my ($self, %options) = @_;
-
-    my $oid_dfFileSys = '.1.3.6.1.4.1.789.1.5.4.1.2';
     
-    my $results = $self->{snmp}->get_multiple_table(oids => [
+    my $oids = [
-                                                       { oid => $oid_dfFileSys },
+        { oid => $mapping->{dfType}->{oid} },
-                                                       { oid => $mapping->{dfType}->{oid} },
+        { oid => $mapping2->{dfFileSys}->{oid} },
-                                                    ], nothing_quit => 1);
+        { oid => $mapping2->{dfKBytesTotal}->{oid} },
+        { oid => $mapping2->{dfKBytesUsed}->{oid} },
+        { oid => $mapping2->{dfPerCentInodeCapacity}->{oid} },
+        { oid => $mapping2->{dfCompressSavedPercent}->{oid} },
+        { oid => $mapping2->{dfDedupeSavedPercent}->{oid} },
+    ];
+    if (!$self->{snmp}->is_snmpv1()) {
+        push @{$oids}, { oid => $mapping2->{df64TotalKBytes}->{oid} }, { oid => $mapping2->{df64UsedKBytes}->{oid} };
+    }
+    
+    my $results = $self->{snmp}->get_multiple_table(oids => $oids, return_type => 1, nothing_quit => 1);
     $self->{filesys_selected} = {};
-    foreach my $oid (keys %{$results->{$oid_dfFileSys}}) {
+    foreach my $oid (keys %{$results}) {
-        $oid =~ /^$oid_dfFileSys\.(\d+)/;
+        next if ($oid !~ /^$mapping2->{dfFileSys}->{oid}\.(\d+)/);
         my $instance = $1;
-        my $name = $results->{$oid_dfFileSys}->{$oid};
+        my $result = $self->{snmp}->map_instance(mapping => $mapping, results => $results, instance => $instance);
-        my $result = $self->{snmp}->map_instance(mapping => $mapping, results => $results->{$mapping->{dfType}->{oid}}, instance => $instance);
+        my $result2 = $self->{snmp}->map_instance(mapping => $mapping2, results => $results, instance => $instance);
+        
+        my $name = $result2->{dfFileSys};
         if (defined($self->{option_results}->{filter_name}) && $self->{option_results}->{filter_name} ne '' &&
             $name !~ /$self->{option_results}->{filter_name}/) {
             $self->{output}->output_add(long_msg => "Skipping  '" . $name . "': no matching filter name.");
@@ -283,32 +303,24 @@ sub manage_selection {
             next;
         }
     
-        $self->{filesys_selected}->{$instance} = { name => $name }; 
+        $self->{filesys_selected}->{$instance} = { name => $name };
+        $self->{filesys_selected}->{$instance}->{total} = $result2->{dfKBytesTotal} * 1024;
+        $self->{filesys_selected}->{$instance}->{used} = $result2->{dfKBytesUsed} * 1024;
+        if (defined($result2->{df64TotalKBytes}) && $result2->{df64TotalKBytes} > 0) {
+            $self->{filesys_selected}->{$instance}->{total} = $result2->{df64TotalKBytes} * 1024;
+            $self->{filesys_selected}->{$instance}->{used} = $result2->{df64UsedKBytes} * 1024;
+        }
+        $self->{filesys_selected}->{$instance}->{dfCompressSavedPercent} = $result2->{dfCompressSavedPercent};
+        $self->{filesys_selected}->{$instance}->{dfDedupeSavedPercent} = $result2->{dfDedupeSavedPercent};
+        if ($self->{filesys_selected}->{$instance}->{total} > 0) {
+            $self->{filesys_selected}->{$instance}->{dfPerCentInodeCapacity} = $result2->{dfPerCentInodeCapacity};
+        }
     }
     
     if (scalar(keys %{$self->{filesys_selected}}) <= 0) {
         $self->{output}->add_option_msg(short_msg => "No entry found.");
         $self->{output}->option_exit();
     }
-    
-    my $instances = [keys %{$self->{filesys_selected}}];
-    if (!$self->{snmp}->is_snmpv1()) {
-        $self->{snmp}->load(oids => [$mapping2->{df64TotalKBytes}->{oid}, $mapping2->{df64UsedKBytes}->{oid}], instances => $instances);
-    }
-    $self->{snmp}->load(oids => [$mapping2->{dfKBytesTotal}->{oid}, $mapping2->{dfKBytesUsed}->{oid}, 
-                                 $mapping2->{dfDedupeSavedPercent}->{oid}, $mapping2->{dfCompressSavedPercent}->{oid}], instances => $instances);
-    my $result = $self->{snmp}->get_leef();
-    foreach (@$instances) {
-        my $result = $self->{snmp}->map_instance(mapping => $mapping2, results => $result, instance => $_);
-        $self->{filesys_selected}->{$_}->{total} = $result->{dfKBytesTotal} * 1024;
-        $self->{filesys_selected}->{$_}->{used} = $result->{dfKBytesUsed} * 1024;
-        if (defined($result->{df64TotalKBytes}) && $result->{df64TotalKBytes} > 0) {
-            $self->{filesys_selected}->{$_}->{total} = $result->{df64TotalKBytes} * 1024;
-            $self->{filesys_selected}->{$_}->{used} = $result->{df64UsedKBytes} * 1024;
-        }
-        $self->{filesys_selected}->{$_}->{dfCompressSavedPercent} = $result->{dfCompressSavedPercent};
-        $self->{filesys_selected}->{$_}->{dfDedupeSavedPercent} = $result->{dfDedupeSavedPercent};
-    }
 }
 
 1;
@@ -321,13 +333,15 @@ Check filesystem usage (volumes, snapshots and aggregates also).
 
 =over 8
 
-=item B<--warning-usage>
+=item B<--warning-*>
 
 Threshold warning.
+Can be: usage, inodes (%).
 
-=item B<--critical-usage>
+=item B<--critical-*>
 
 Threshold critical.
+Can be: usage, inodes (%).
 
 =item B<--units>