Skip to content

CTOR-1557-New-pack-network-extreme-cloudiq-restapi-location-and-new-pack-network-extreme-cloudiq-restapi-device #5902

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Draft
Evan-Adam wants to merge 2 commits into
base: develop
Choose a base branch
from
Draft

CTOR-1557-New-pack-network-extreme-cloudiq-restapi-location-and-new-pack-network-extreme-cloudiq-restapi-device #5902

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
2 commits
Select commit Hold shift + click to select a range
de3de4e
initial commit
rmorandell-pgum Mar 27, 2025
e8ea7dd
stopwords for new plugin Extreme Cloud IQ
rmorandell-pgum Mar 27, 2025
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
254 changes: 254 additions & 0 deletions src/network/extreme/cloudiq/restapi/custom/api.pm
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -0,0 +1,254 @@
#
# Copyright 2024 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::extreme::cloudiq::restapi::custom::api;

use strict;
use warnings;
use centreon::plugins::http;
use JSON::XS;
use Digest::MD5 qw(md5_hex);
use centreon::plugins::statefile;
use DateTime;

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' },
'username:s' => { name => 'username' },
'password:s' => { name => 'password' },
'timeout:s' => { name => 'timeout' },
'unknown-http-status:s' => { name => 'unknown_http_status' },
'warning-http-status:s' => { name => 'warning_http_status' },
'critical-http-status:s' => { name => 'critical_http_status' }
}
);
}
$options{options}->add_help(package => __PACKAGE__, sections => 'REST API OPTIONS', once => 1);

$self->{output} = $options{output};
$self->{http} = centreon::plugins::http->new(%options);
$self->{cache} = centreon::plugins::statefile->new(%options);

return $self;
}

sub set_options {
my ($self, %options) = @_;

$self->{option_results} = $options{option_results};
}

sub set_defaults {}

sub check_options {
my ($self, %options) = @_;

$self->{hostname} = (defined($self->{option_results}->{hostname})) ? $self->{option_results}->{hostname} : '';
$self->{proto} = (defined($self->{option_results}->{proto})) ? $self->{option_results}->{proto} : 'https';
$self->{port} = (defined($self->{option_results}->{port})) ? $self->{option_results}->{port} : 443;
$self->{username} = (defined($self->{option_results}->{username})) ? $self->{option_results}->{username} : '';
$self->{password} = (defined($self->{option_results}->{password})) ? $self->{option_results}->{password} : '';
$self->{timeout} = (defined($self->{option_results}->{timeout})) ? $self->{option_results}->{timeout} : 10;
$self->{unknown_http_status} = (defined($self->{option_results}->{unknown_http_status})) ?
$self->{option_results}->{unknown_http_status} :
'%{http_code} < 200 or %{http_code} >= 300';
$self->{warning_http_status} = (defined($self->{option_results}->{warning_http_status})) ?
$self->{option_results}->{warning_http_status} :
'';
$self->{critical_http_status} = (defined($self->{option_results}->{critical_http_status})) ?
$self->{option_results}->{critical_http_status} :
'';

if ($self->{hostname} eq '') {
$self->{output}->add_option_msg(short_msg => "Need to specify --hostname option.");
$self->{output}->option_exit();
}
if ($self->{username} eq '') {
$self->{output}->add_option_msg(short_msg => "Need to specify --username option.");
$self->{output}->option_exit();
}
if ($self->{password} eq '') {
$self->{output}->add_option_msg(short_msg => "Need to specify --password option.");
$self->{output}->option_exit();
}

$self->{cache}->check_options(option_results => $self->{option_results});

return 0;
}

sub json_decode {
my ($self, %options) = @_;

my $decoded;
eval {
$decoded = JSON::XS->new->utf8->decode($options{content});
};
if ($@) {
$self->{output}->add_option_msg(short_msg => "Cannot decode json response: $@");
$self->{output}->option_exit();
}

return $decoded;
}

sub get_connection_infos {
my ($self, %options) = @_;

return $self->{hostname} . '_' . $self->{http}->get_port();
}

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};
}

sub settings {
my ($self, %options) = @_;

$self->build_options_for_httplib();
$self->{http}->add_header(key => 'Accept', value => 'application/json');
$self->{http}->add_header(key => 'Content-Type', value => 'application/json');
$self->{http}->set_options(%{$self->{option_results}});
}

sub clean_token {
my ($self, %options) = @_;

my $datas = {};
$options{statefile}->write(data => $datas);
$self->{access_token} = undef;
$self->{http}->add_header(key => 'Authorization', value => undef);
}

sub get_auth_token {
my ($self, %options) = @_;

my $has_cache_file = $options{statefile}->read(statefile => 'extremecloudiq_api_' . md5_hex($self->{option_results}->{hostname}) . '_' . md5_hex($self->{option_results}->{username}));
my $expires_on = $options{statefile}->get(name => 'expires_on');
my $access_token = $options{statefile}->get(name => 'access_token');

# Token expires every 1 day
if ($has_cache_file == 0 || !defined($access_token) || (time() > $expires_on)) {
my $json_request = { username => $self->{username}, password => $self->{password} };
my $encoded;
eval {
$encoded = encode_json($json_request);
};
if ($@) {
$self->{output}->add_option_msg(short_msg => 'cannot encode json request');
$self->{output}->option_exit();
}

my ($content) = $self->{http}->request(
method => 'POST',
url_path => '/login',
query_form_post => $encoded,
warning_status => '', unknown_status => '', critical_status => ''
);

if ($self->{http}->get_code() != 200) {
$self->{output}->add_option_msg(short_msg => "Authentication error [code: '" . $self->{http}->get_code() . "'] [message: '" . $self->{http}->get_message() . "']");
$self->{output}->option_exit();
}

my $decoded = $self->json_decode(content => $content);
if (!defined($decoded->{access_token})) {
$self->{output}->add_option_msg(short_msg => "Cannot get token");
$self->{output}->option_exit();
}

$access_token = $decoded->{access_token};
my $datas = {
access_token => $access_token,
expires_on => time() + 86400
};
$options{statefile}->write(data => $datas);
}

$self->{access_token} = $access_token;
$self->{http}->add_header(key => 'Authorization', value => 'Bearer ' . $self->{access_token});
}

sub request_api {
my ($self, %options) = @_;

$self->settings();
if (!defined($self->{access_token})) {
$self->get_auth_token(statefile => $self->{cache});
}

my $content = $self->{http}->request(
method => 'GET',
url_path => $options{endpoint},
warning_status => '', unknown_status => '', critical_status => ''
);

# Maybe there is an issue with the token. So we retry.
if ($self->{http}->get_code() < 200 || $self->{http}->get_code() >= 300) {
$self->clean_token(statefile => $self->{cache});
$self->get_auth_token(statefile => $self->{cache});
$content = $self->{http}->request(
url_path => $options{endpoint},
warning_status => '', unknown_status => '', critical_status => ''
);
}

my $decoded = $self->json_decode(content => $content);
if (!defined($decoded)) {
$self->{output}->add_option_msg(short_msg => 'Error while retrieving data (add --debug option for detailed message)');
$self->{output}->option_exit();
}
if ($self->{http}->get_code() < 200 || $self->{http}->get_code() >= 300) {
my $message = 'api request error';
if (defined($decoded->{error_message})) {
$message .= ': ' . $decoded->{error_message};
}
$self->{output}->add_option_msg(short_msg => $message);
$self->{output}->option_exit();
}

return $decoded;
}

1;

__END__
Loading
Loading