tyler.durden
/
centreon-plugins
mirror of https://github.com/centreon/centreon-plugins.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

wip meraki rest api

This commit is contained in:
garnier-quentin 2020-03-31 15:56:16 +02:00
parent e9c92daeed
commit ee53c610f2
4 changed files with 548 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
centreon/plugins/templates/counter.pm
View File

@ -620,6 +620,13 @@ sub run_multiple {
}
}
sub read_statefile_key {
my ($self, %options) = @_;
$self->{statefile_value}->read(statefile => $self->{cache_name});
return $self->{statefile_value}->get(name => $options{key});
}
sub run {
my ($self, %options) = @_;

329
network/cisco/meraki/cloudcontroller/restapi/custom/api.pm Normal file
View File

@ -0,0 +1,329 @@
#
# Copyright 2020 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::cisco::meraki::cloudcontroller::restapi::custom::api;
use strict;
use warnings;
use centreon::plugins::http;
use centreon::plugins::statefile;
use JSON::XS;
use Digest::MD5 qw(md5_hex);
sub new {
my ($class, %options) = @_;
my $self = {};
bless $self, $class;
if (!defined($options{output})) {
print "Class Custom: Need to specify 'output' argument.\n";
exit 3;
}
if (!defined($options{options})) {
$options{output}->add_option_msg(short_msg => "Class Custom: Need to specify 'options' argument.");
$options{output}->option_exit();
}
if (!defined($options{noptions})) {
$options{options}->add_options(arguments => {
'hostname:s' => { name => 'hostname' },
'port:s' => { name => 'port' },
'proto:s' => { name => 'proto' },
'api-token:s' => { name => 'api_token' },
'timeout:s' => { name => 'timeout' },
'reload-cache-time:s' => { name => 'reload_cache_time' }
});
}
$options{options}->add_help(package => __PACKAGE__, sections => 'REST API OPTIONS', once => 1);
$self->{output} = $options{output};
$self->{mode} = $options{mode};
$self->{http} = centreon::plugins::http->new(%options);
$self->{cache} = centreon::plugins::statefile->new(%options);
$self->{cache_checked} = 0;
return $self;
}
sub set_options {
my ($self, %options) = @_;
$self->{option_results} = $options{option_results};
}
sub set_defaults {
my ($self, %options) = @_;
foreach (keys %{$options{default}}) {
if ($_ eq $self->{mode}) {
for (my $i = 0; $i < scalar(@{$options{default}->{$_}}); $i++) {
foreach my $opt (keys %{$options{default}->{$_}[$i]}) {
if (!defined($self->{option_results}->{$opt}[$i])) {
$self->{option_results}->{$opt}[$i] = $options{default}->{$_}[$i]->{$opt};
}
}
}
}
}
}
sub check_options {
my ($self, %options) = @_;
$self->{hostname} = (defined($self->{option_results}->{hostname})) ? $self->{option_results}->{hostname} : 'api.meraki.com';
$self->{port} = (defined($self->{option_results}->{port})) ? $self->{option_results}->{port} : 443;
$self->{proto} = (defined($self->{option_results}->{proto})) ? $self->{option_results}->{proto} : 'https';
$self->{timeout} = (defined($self->{option_results}->{timeout})) ? $self->{option_results}->{timeout} : 10;
$self->{api_token} = (defined($self->{option_results}->{api_token})) ? $self->{option_results}->{api_token} : '';
$self->{reload_cache_time} = (defined($self->{option_results}->{reload_cache_time})) ? $self->{option_results}->{reload_cache_time} : 180;
if (!defined($self->{hostname}) || $self->{hostname} eq '') {
$self->{output}->add_option_msg(short_msg => "Need to specify --hostname option.");
$self->{output}->option_exit();
}
if (!defined($self->{api_token}) || $self->{api_token} eq '') {
$self->{output}->add_option_msg(short_msg => "Need to specify --api-token option.");
$self->{output}->option_exit();
}
$self->{cache}->check_options(option_results => $self->{option_results});
return 0;
}
sub get_token {
my ($self, %options) = @_;
return md5_hex($self->{api_token});
}
sub get_cache_networks {
my ($self, %options) = @_;
$self->cache_networks_organizations();
return $self->{cache_networks};
}
sub build_options_for_httplib {
my ($self, %options) = @_;
$self->{option_results}->{hostname} = $self->{hostname};
$self->{option_results}->{timeout} = $self->{timeout};
$self->{option_results}->{port} = $self->{port};
$self->{option_results}->{proto} = $self->{proto};
$self->{http}->add_header(key => 'X-Cisco-Meraki-API-Key', value => $self->{api_token});
}
sub settings {
my ($self, %options) = @_;
$self->build_options_for_httplib();
$self->{http}->set_options(%{$self->{option_results}});
}
sub request_api {
my ($self, %options) = @_;
$self->settings();
#400: Bad Request- You did something wrong, e.g. a malformed request or missing parameter.
#403: Forbidden- You don't have permission to do that.
#404: Not found- No such URL, or you don't have access to the API or organization at all.
#429: Too Many Requests- You submitted more than 5 calls in 1 second to an Organization, triggering rate limiting. This also applies for API calls made across multiple organizations that triggers rate limiting for one of the organizations.
do {
my $response = $self->{http}->request(
url_path => '/api/v0' . $options{endpoint},
critical_status => '',
warning_status => '',
unknown_status => '(%{http_code} < 200 or %{http_code} >= 300) and %{http_code} != 429'
);
if ($self->{http}->get_code() == 429) {
sleep(1);
continue;
}
my $content;
eval {
$content = JSON::XS->new->utf8->decode($response);
};
if ($@) {
$self->{output}->add_option_msg(short_msg => "Cannot decode json response: $@");
$self->{output}->option_exit();
}
return ($content);
} while (1);
}
sub cache_networks_organizations {
my ($self, %options) = @_;
return if ($self->{cache_checked} == 1);
$self->{cache_checked} = 1;
my $has_cache_file = $self->{cache}->read(statefile => 'cache_cisco_meraki_' . $self->get_token());
my $timestamp_cache = $self->{cache}->get(name => 'last_timestamp');
$self->{cache_organizations} = $self->{cache}->get(name => 'organizations');
$self->{cache_networks} = $self->{cache}->get(name => 'networks');
if ($has_cache_file == 0 || !defined($timestamp_cache) || ((time() - $timestamp_cache) > (($self->{reload_cache_time}) * 60))) {
$self->{cache_organizations} = {};
$self->{cache_organizations} = $self->get_organizations(disable_cache => 1);
$self->{cache_networks} = $self->get_networks(organizations => [keys %{$self->{cache_organizations}}], disable_cache => 1);
$self->{cache}->write(data => {
last_timestamp => time(),
organizations => $self->{cache_organizations},
networks => $self->{cache_networks}
});
}
}
sub get_organizations {
my ($self, %options) = @_;
$self->cache_networks_organizations();
return $self->{cache_organizations} if (!defined($options{disable_cache}) || $options{disable_cache} == 0);
my $datas = $self->request_api(endpoint => '/organizations');
my $results = {};
$results->{$_->{id}} = $_ foreach (@$datas);
return $results;
}
sub get_networks {
my ($self, %options) = @_;
$self->cache_networks_organizations();
return $self->{cache_networks} if (!defined($options{disable_cache}) || $options{disable_cache} == 0);
my $results = {};
foreach my $id (keys %{$self->{cache_organizations}}) {
my $datas = $self->request_api(endpoint => '/organizations/' . $id . '/networks');
$results->{$_->{id}} = $_ foreach (@$datas);
}
return $results;
}
sub filter_networks {
my ($self, %options) = @_;
my $network_ids = [];
foreach (values %{$self->{cache_networks}}) {
if (!defined($options{filter_name}) || $options{filter_name} eq '') {
push @$network_ids, $_->{id};
} elsif ($_->{name} =~ /$options{filter_name}/) {
push @$network_ids, $_->{id};
}
}
if (scalar(@$network_ids) > 5) {
$self->{output}->add_option_msg(short_msg => 'cannot check than 5 networks at once');
$self->{output}->option_exit();
}
return $network_ids;
}
sub get_networks_connection_stats {
my ($self, %options) = @_;
$self->cache_networks_organizations();
my $network_ids = $self->filter_networks(filter_name => $options{filter_name});
my $timespan = defined($options{timespan}) ? $options{timespan} : 300;
$timespan = 1 if ($timespan <= 0);
my $results = {};
foreach my $id (@$network_ids) {
my $datas = $self->request_api(endpoint => '/networks/' . $id . '/connectionStats?timespan=' . $options{timespan});
$results->{$id} = $datas;
}
return $results;
}
sub get_networks_clients {
my ($self, %options) = @_;
$self->cache_networks_organizations();
my $network_ids = $self->filter_networks(filter_name => $options{filter_name});
my $timespan = defined($options{timespan}) ? $options{timespan} : 300;
$timespan = 1 if ($timespan <= 0);
my $results = {};
foreach my $id (@$network_ids) {
my $datas = $self->request_api(endpoint => '/networks/' . $id . '/clients?timespan=' . $options{timespan});
$results->{$id} = $datas;
}
return $results;
}
sub get_device_statuses {
my ($self, %options) = @_;
}
1;
__END__
=head1 NAME
Meraki REST API
=head1 SYNOPSIS
api_token Rest API custom mode
=head1 REST API OPTIONS
=over 8
=item B<--hostname>
Meraki api hostname (default: 'api.meraki.com')
=item B<--port>
Port used (Default: 443)
=item B<--proto>
Specify https if needed (Default: 'https')
=item B<--api-token>
Meraki api token.
=item B<--timeout>
Set HTTP timeout
=item B<--reload-cache-time>
Time in minutes before reloading cache file (default: 180).
=back
=head1 DESCRIPTION
B<custom>.
=cut

162
network/cisco/meraki/cloudcontroller/restapi/mode/networks.pm Normal file
View File

@ -0,0 +1,162 @@
#
# Copyright 2020 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::cisco::meraki::cloudcontroller::restapi::mode::networks;
use base qw(centreon::plugins::templates::counter);
use strict;
use warnings;
use Digest::MD5 qw(md5_hex);
sub set_counters {
my ($self, %options) = @_;
$self->{maps_counters_type} = [
{ name => 'networks', type => 1, cb_prefix_output => 'prefix_network_output', message_multiple => 'All networks are ok' }
];
$self->{maps_counters}->{networks} = [
{ label => 'connections-success', nlabel => 'network.connections.success.count', set => {
key_values => [ { name => 'assoc' }, { name => 'display' } ],
output_template => 'connections success: %s',
perfdatas => [
{ value => 'assoc_absolute',
template => '%d', min => 0, label_extra_instance => 1, instance_use => 'display_absolute' }
]
}
},
{ label => 'connections-auth', nlabel => 'network.connections.auth.count', display_ok => 0, set => {
key_values => [ { name => 'auth' }, { name => 'display' } ],
output_template => 'connections auth: %s',
perfdatas => [
{ value => 'auth_absolute',
template => '%d', min => 0, label_extra_instance => 1, instance_use => 'display_absolute' }
]
}
},
{ label => 'connections-assoc', nlabel => 'network.connections.assoc.count', display_ok => 0, set => {
key_values => [ { name => 'assoc' }, { name => 'display' } ],
output_template => 'connections assoc: %s',
perfdatas => [
{ value => 'assoc_absolute',
template => '%d', min => 0, label_extra_instance => 1, instance_use => 'display_absolute' }
]
}
},
{ label => 'connections-dhcp', nlabel => 'network.connections.dhcp.count', display_ok => 0, set => {
key_values => [ { name => 'dhcp' }, { name => 'display' } ],
output_template => 'connections dhcp: %s',
perfdatas => [
{ value => 'dhcp_absolute',
template => '%d', min => 0, label_extra_instance => 1, instance_use => 'display_absolute' }
]
}
},
{ label => 'connections-dns', nlabel => 'network.connections.dns.count', display_ok => 0, set => {
key_values => [ { name => 'dns' }, { name => 'display' } ],
output_template => 'connections dns: %s',
perfdatas => [
{ value => 'dns_absolute',
template => '%d', min => 0, label_extra_instance => 1, instance_use => 'display_absolute' }
]
}
}
];
}
sub prefix_network_output {
my ($self, %options) = @_;
return "Network '" . $options{instance_value}->{display} . "' ";
}
sub new {
my ($class, %options) = @_;
my $self = $class->SUPER::new(package => __PACKAGE__, %options, statefile => 1, force_new_perfdata => 1);
bless $self, $class;
$options{options}->add_options(arguments => {
'filter-name:s' => { name => 'filter_name' }
});
return $self;
}
sub manage_selection {
my ($self, %options) = @_;
$self->{cache_name} = 'meraki_' . $self->{mode} . '_' . $options{custom}->get_token() . '_' .
(defined($self->{option_results}->{filter_counters}) ? md5_hex($self->{option_results}->{filter_counters}) : md5_hex('all')) . '_' .
(defined($self->{option_results}->{filter_name}) ? md5_hex($self->{option_results}->{filter_name}) : md5_hex('all'));
my $last_timestamp = $self->read_statefile_key(key => 'last_timestamp');
my $timespan = 300;
$timespan = time() - $last_timestamp if (defined($last_timestamp));
my $cache_networks = $options{custom}->get_cache_networks();
my $connections = $options{custom}->get_networks_connection_stats(timespan => $timespan, filter_name => $self->{option_results}->{filter_name});
my $clients = $options{custom}->get_networks_clients(timespan => $timespan, filter_name => $self->{option_results}->{filter_name});
$self->{networks} = {};
foreach my $id (keys %$connections) {
$self->{networks}->{$id} = {
display => $cache_networks->{$id}->{name},
assoc => defined($connections->{$id}->{assoc}) ? $connections->{$id}->{assoc} : 0,
auth => defined($connections->{$id}->{assoc}) ? $connections->{$id}->{auth} : 0,
dhcp => defined($connections->{$id}->{assoc}) ? $connections->{$id}->{assoc} : 0,
dns => defined($connections->{$id}->{assoc}) ? $connections->{$id}->{dhcp} : 0,
success => defined($connections->{$id}->{assoc}) ? $connections->{$id}->{success} : 0
};
}
if (scalar(keys %{$self->{networks}}) <= 0) {
$self->{output}->add_option_msg(short_msg => "No networks found.");
$self->{output}->option_exit();
}
}
1;
__END__
=head1 MODE
Check networks.
=over 8
=item B<--filter-name>
Filter network name (Can be a regexp).
=item B<--warning-*> B<--critical-*>
Thresholds.
Can be: 'volume-data-read-bytespersecond', 'volume-data-written-bytespersecond',
'volume-reads-count', 'volume-writes-count',
'volume-data-transfer-bytespersecond', 'volume-iops-ops',
'volume-cache-write-usage-percentage', 'volume-cache-write-hits-count',
'volume-cache-write-misses-count', 'volume-cache-read-hits-count',
'volume-cache-read-misses-count'.
=back
=cut

50
network/cisco/meraki/cloudcontroller/restapi/plugin.pm Normal file
View File

@ -0,0 +1,50 @@
#
# Copyright 2020 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::cisco::meraki::cloudcontroller::restapi::plugin;
use strict;
use warnings;
use base qw(centreon::plugins::script_custom);
sub new {
my ($class, %options) = @_;
my $self = $class->SUPER::new(package => __PACKAGE__, %options);
bless $self, $class;
$self->{version} = '1.0';
%{$self->{modes}} = (
'devices' => 'network::cisco::meraki::cloudcontroller::restapi::mode::devices',
'networks' => 'network::cisco::meraki::cloudcontroller::restapi::mode::networks'
);
$self->{custom_modes}{api} = 'network::cisco::meraki::cloudcontroller::restapi::custom::api';
return $self;
}
1;
__END__
=head1 PLUGIN DESCRIPTION
Check Cisco Meraki cloud controller through HTTP/REST API.
=cut