Munin contributed plugins

#!/usr/bin/perl

# -*- perl -*-

=encoding utf8

=head1 NAME

unifi_api - Munin plugin to display device and network information from the 

            Ubiquiti unifi API

=head1 APPLICABLE SYSTEMS

Unifi controllors with direct API access

Controller version 5+ required (tested with 5.8.x)

WebRTC is not supported at this time

=head1 CONFIGURATION

This script uses the multigraph functionality to generate many graphs.  As such, there

are a significant amount of available configuration options

=head2 API Details

You will need to supply your API login details:

  [unifi_api]

    # User name to login to unifi controller API.  Default is "ubnt".  Ideally, this should

    # point to a read-only account.

    env.user Controller_Username

    # Password to login to unifi controller API. Default is "ubnt"

    env.pass Controller_Password

    # URL of the API, with port if needed.  No trailing slash.

    # Default is https://localhost:8443

    env.api_url https://unifi.fqdn.com:8443

    # Verify SSL certificate name against host.

    # Note: if using a default cloudkey certificate, this will fail unless you manually add it

    # to the local keystore.

    # Default is "yes"

    env.ssl_verify_host no

    # Verify Peer's SSL vertiicate.

    # Note: if using a default cloudkey certificate, this will fail

    # Default is "yes"

    env.ssl_verify_peer no 

    # The human readable name of the unifi site - used for graph titles

    env.name Site Name

    # "Site" string - the internal unifi API site identifier. 

    # default is "default" - found when you connect to the web interface

    # it's the term in the URL - /manage/site/site_string/dashboard

    env.site site_string 

=head2 Graph Categories / Host Management

Sometimes, you need more control over where the unifi graphs appear.

    env.force_category 0

    # By default, Use standard munin well know categories - 

    #  system: cpu, mem, load, & uptime

    #  network: clients, transfer statistics.

    #

To use this feature, set "force_category" to a text string (i.e. "unifi").

This is very helpful if your graphs are going to appear inside another host - for instance

if your munin graphs for that host are monitoring the host the controller is running on, and

the unifi API instance.

Sometimes however, you want to monitor either an offsite API, or a cloudkey which, at least by

default, does not run munin-node.  In that case, you can actually create a "virtual" munin host to

display only these graphs (or any combination you like).  This is documented in the main munin docs, 

but in a nutshell:

In your munin-node plugin configuration: (Something like: /etc/munin/plugin-conf.d/munin-node)

  [unifi_api]

    host_name hostname.whatever.youlike

    env.force_category unifi

And, in your munin master configuration: (Something like: /etc/munin/munin.conf)

  [hostname.whatever.youlike]

    address ip.of.munin.node

Make sure you do *not* set "use_node_name" on this new host.  It may be necessary to define "host_name"

in your munin-node configuration as well, if you have not already (Likely, on a multi-homed host, this 

has been done to keep munin-node from advertising itself as localhost)

More information:

 * L<host_name|http://guide.munin-monitoring.org/en/latest/plugin/use.html>

=head2 Toggling of graphs / Individual options

You can turn off individual graphs.  A few graphs have extra configuration

options.

By default, everything is enabled.  Set to "no" to disable

  [unifi_api]

    # Show device CPU utilization

    env.enable_device_cpu yes

    # Show device memory usage

    env.enable_device_mem yes

    # Show device load average (switches and APs only)

    env.enable_device_load yes

    # Show device uptime

    env.enable_device_uptime yes

    # Show number of clients connected to each device

    env.enable_clients_device yes

    # Show detailed graphs for each device (per device graphs)

    env.enable_detail_clients_device yes

    # Show number of clients connected to each network type

    env.enable_clients_type yes

    # Show detailed graphs for each client type (per type graphs)

    env.enable_detail_clients_type yes

    # Show unauthorized / authorized client list

    # if you are not using the guest portal, this is useless

    env.show_authorized_clients_type yes

    # Show transfer statistics on switch ports

    env.enable_xfer_port yes

    # Show detailed graphs per switch port

    env.enable_detail_xfer_port yes

    # Hide ports that have no link (When set to no, unplugged ports will transfer 0, not be undefined)

    env.hide_empty_xfer_port yes

    # Show transfer statistics per device

    env.enable_xfer_device yes

    # Show detailed graphs for each device

    env.enable_detail_xfer_device yes

    # Show transfer statistics per named network

    env.enable_xfer_network yes

    # Show detailed graphs for each named network

    env.enable_detail_xfer_network yes

    # Show transfer statistics per radio

    env.enable_xfer_radio yes

    # Show detailed graphs for each radio

    env.enable_detail_xfer_radio yes

=head1 CAPABILITIES

This plugin supports L<DIRTYCONFIG|http://guide.munin-monitoring.org/en/latest/plugin/protocol-dirtyconfig.html>

=head1 DEPENDENCIES

This plugin requires munin-multiugraph.

=over

=item WWW::Curl::Easy

Perl extension interface for libcurl

=item JSON

 JSON (JavaScript Object Notation) encoder/decoder

=back

=head1 PERFORMANCE CONCERNS

The main performance concern on this is the huge number of graphs that may be

generated.  Using the cron version of munin-graph may hurt a lot.

A bit of a case study:

                 | My Site  | UBNT Demo

---------------------------------------

Devices          |       8  |     126

AP's             |       4  |     118

24xSwitch        |       1  |       5

8xSwitch         |       2  |       2

Output Bytes     |  64,262  | 431,434

Output Lines     |   1,761  |  14,586

Output Graphs    |      77  |     530

So, just note that the growth in the amount of graphed date can be extreme.

=head1 LICENSE

Copyright (C) 2018 J.T.Sage (jtsage@gmail.com)

This program is free software: you can redistribute it and/or modify

it under the terms of the GNU General Public License as published by

the Free Software Foundation, either version 3 of the License, or

any later version.

This program is distributed in the hope that it will be useful,

but WITHOUT ANY WARRANTY; without even the implied warranty of

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

GNU General Public License for more details.

You should have received a copy of the GNU General Public License

along with this program.  If not, see L<http://www.gnu.org/licenses/>.

=head1 MAGIC MARKERS

  #%# family=manual

  #%# capabilities=

=cut

use warnings;

use strict;

use utf8;

use Munin::Plugin;

# Check dependencies

my @errorCode;

my $me = (split '/', $0)[-1];

if (! eval {require JSON; JSON->import(); 1; } ) {

	push @errorCode, "JSON module not found";

}

if (! eval {require WWW::Curl::Easy; 1;} ) {

	push @errorCode, "WWW::Curl::Easy module not found";

}

# Fail on not found dependencies

if ( @errorCode != 0 ) {

	die "FATAL:$me: Perl dependencies not installed (", join(", " => @errorCode), ")\n";

}

# Multigraph cabability is required for this plugin

need_multigraph();

# Somewhat (in)sane defaults for host, pass, etc

my %APIconfig = (

	'user'            => env_default_text('user'           , 'ubnt'),

	'pass'            => env_default_text('pass'           , 'ubnt'),

	'api_url'         => env_default_text('api_url'        , 'https://localhost:8443'),

	'site'            => env_default_text('site'           , 'default'),

	'ssl_verify_host' => env_default_text('ssl_verify_host', 'yes'),

	'ssl_verify_peer' => env_default_text('ssl_verify_peer', 'yes'),

	'name'            => env_default_text('name'           , 'Unnamed Site'),

);

# The big table of plugin options - see POD documentation for what these do.

my %PluginConfig = (

	'enable_device_cpu'             => env_default_bool_true('enable_device_cpu'),

	'enable_device_mem'             => env_default_bool_true('enable_device_mem'),

	'enable_device_load'            => env_default_bool_true('enable_device_load'),

	'enable_device_uptime'          => env_default_bool_true('enable_device_uptime'),

	'enable_clients_device'         => env_default_bool_true('enable_clients_device'),

	'enable_clients_type'           => env_default_bool_true('enable_clients_network'),

	'enable_xfer_port'              => env_default_bool_true('enable_xfer_port'),

	'enable_xfer_device'            => env_default_bool_true('enable_xfer_device'),

	'enable_xfer_network'           => env_default_bool_true('enable_xfer_network'),

	'enable_xfer_radio'             => env_default_bool_true('enable_xfer_radio'),

	'enable_detail_xfer_port'       => env_default_bool_true('enable_detail_xfer_port'),

	'enable_detail_xfer_device'     => env_default_bool_true('enable_detail_xfer_device'),

	'enable_detail_xfer_network'    => env_default_bool_true('enable_detail_xfer_network'),

	'enable_detail_xfer_radio'      => env_default_bool_true('enable_detail_xfer_radio'),

	'enable_detail_clients_device'  => env_default_bool_true('enable_detail_clients_device'),

	'enable_detail_clients_type'    => env_default_bool_true('enable_detail_clients_network'),

	'hide_empty_xfer_port'          => env_default_bool_true('hide_empty_xfer_port'),

	'show_authorized_clients_type'  => env_default_bool_true('show_authorized_clients_type'),

	'force_category'                => env_default_text('force_category', 0),

);

# Set up needed API endpoints

my %APIPoint = (

	'login'  => $APIconfig{"api_url"} . "/api/login",

	'device' => $APIconfig{"api_url"} . "/api/s/" . $APIconfig{"site"} . "/stat/device",

	'wlan'   => $APIconfig{"api_url"} . "/api/s/" . $APIconfig{"site"} . "/rest/wlanconf",

	'sta'    => $APIconfig{"api_url"} . "/api/s/" . $APIconfig{"site"} . "/stat/sta",

);

my %APIResponse;

my %APIJsonResponse;

my %Data;

my $retcode;

# Init curl and JSON

my $curl = WWW::Curl::Easy->new() or die "FATAL:$me: WWW::Curl::Easy init failed!\n";

my $jsonOBJ = JSON->new() or die "FATAL:$me: JSON init failed!\n";

## Fetch the data from the API

# The rest is a way to use local files from the local disk. Undocumented and not really supported.

if ( !env_default_bool_true('USE_API') ) {

	if (! eval {require File::Slurp; File::Slurp->import(); 1; } ) {

		die "Local debug unavailable, File::Slurp CPAN module required\n";

	}

	foreach ( "./demo-test-files/device", "./demo-test-files/sta", "./demo-test-files/wlanconf" ) {

		if ( ! -f $_ ) { die "File not found: $_\n"; }

	}

	$APIJsonResponse{'device'} = $jsonOBJ->allow_nonref->utf8->relaxed->decode(read_file('./demo-test-files/device'));

	$APIJsonResponse{'sta'} = $jsonOBJ->allow_nonref->utf8->relaxed->decode(read_file('./demo-test-files/sta'));

	$APIJsonResponse{'wlan'} = $jsonOBJ->allow_nonref->utf8->relaxed->decode(read_file('./demo-test-files/wlanconf'));

} else {

	fetch_data();

}

## Process the data

make_data();

if ( defined($ARGV[0]) && $ARGV[0] eq "config" ) {

	# Do the config step for each set of graphs

	do_config_mem();

	do_config_cpu();

	do_config_load();

	do_config_uptime();

	do_config_xfer_by_device();

	do_config_xfer_by_uplink();

	do_config_xfer_by_port();

	do_config_xfer_by_network();

	do_config_xfer_by_radio();

	do_config_clients_by_device();

	do_config_clients_by_type();

	# If dirtyconfig is not supported, or turned off, exit here.  Otherwise, continue to fetch section

	if ( !defined($ENV{'MUNIN_CAP_DIRTYCONFIG'}) || !$ENV{'MUNIN_CAP_DIRTYCONFIG'} ) {  exit 0; }

}

# Do the fetch step for each set of graphs

do_values_cpu();

do_values_mem();

do_values_load();

do_values_uptime();

do_values_xfer_by_device();

do_values_xfer_by_uplink();

do_values_xfer_by_port();

do_values_xfer_by_network();

do_values_xfer_by_radio();

do_values_clients_by_device();

do_values_clients_by_type();

#######################

# SUBROUTINES  CONFIG #

#######################

sub do_config_clients_by_type {

	# Provide client count by type - CONFIG

	if ( !$PluginConfig{'enable_clients_type'} ) { return 0; }

	graph_prologue(

		'unifi_clients_per_network',

		'Clients Connected / Network',

		'-l 0 --base 1000',

		'clients',

		'network',

		'Clients connected per type - manually summing these numbers may be meaningful, as clients are often of multiple types'

	);

	foreach ( @{$Data{'typesOrder'}} ) {

		print $_ , ".label " , $Data{'types'}{$_}[0] , "\n";

	}

	if ( ! $PluginConfig{'enable_detail_clients_type'} ) { return 1; }

	foreach ( @{$Data{'typesOrder'}} ) {

		if ( $Data{'types'}{$_}[1] == 1 ) {

			graph_prologue(

				'unifi_clients_per_network.' . $_,

				'Clients Connected : ' . $Data{'types'}{$_}[0],

				'-l 0 --base 1000',

				'clients',

				'network',

				'Clients connected via that are of type: ' . $Data{'types'}{$_}[0]

			);

			print "users.label Users\n";

			print "guests.label Guests\n";

		}

	}

	return 1;

}

sub do_config_clients_by_device {

	# Provide client count by device - CONFIG

	if ( !$PluginConfig{'enable_clients_device'} ) { return 0; }

	graph_prologue(

		'unifi_clients_per_device',

		'Clients Connected / Device',

		'-l 0 --base 1000',

		'clients',

		'network',

		'Clients connected to each unifi device'

	);

	foreach ( sort keys %{$Data{'device'}} ) {

		print $_ , ".label " , $Data{'device'}{$_}->{'label'} , "\n";

	}

	if ( ! $PluginConfig{'enable_detail_clients_device'} ) { return 1; }

	foreach ( sort keys %{$Data{'device'}} ) {

		graph_prologue(

			'unifi_clients_per_device.' . $_,

			'Clients / Device : ' . $Data{'device'}{$_}->{'label'},

			'-l 0 --base 1000',

			'clients',

			'network',

			'Clients connected to the ' . $Data{'device'}{$_}->{'label'} . " unifi device"

		);

		print "users.label Users\n";

		print "guests.label Guests\n";

	}

	return 1;

}

sub do_config_xfer_by_radio {

	# Provide transfer for radios - CONFIG

	if ( !$PluginConfig{'enable_xfer_radio'} ) { return 0; }

	graph_prologue(

		'unifi_xfer_per_radio',

		'Transfer / radio',

		'--base 1000',

		'Packets/${graph_period}',

		'network',

		'Number of packets transferred per individual radio band'

	);

	foreach my $thisDevice ( sort keys %{$Data{'device'}} ) {

		if ( $Data{'device'}{$thisDevice}->{'type'} ne "uap" ) { next; }

		foreach ( @{$Data{'device'}{$thisDevice}{'radio'}} ) {

			print $thisDevice , "_" , $_->{"name"} , "_pack.label " , $_->{"label"} , "\n";

			print $thisDevice , "_" , $_->{"name"} , "_pack.type DERIVE\n";

			print $thisDevice , "_" , $_->{"name"} , "_pack.min 0\n";

		}

	}

	if ( ! $PluginConfig{'enable_detail_xfer_radio'} ) { return 1; }

	foreach my $thisDevice ( sort keys %{$Data{'device'}} ) {

		if ( $Data{'device'}{$thisDevice}->{'type'} ne "uap" ) { next; }

		graph_prologue(

			'unifi_xfer_per_radio.' .  $thisDevice,

			'Transfer / radio : ' . $Data{'device'}{$thisDevice}->{'name'},

			'--base 1000',

			'Packets/${graph_period}',

			'network',

			'Transfered Packets, Dropped / Retried Packets, and Error Packets for the WLAN device: ' . $Data{'device'}{$thisDevice}->{'name'}

		);

		foreach ( @{$Data{'device'}{$thisDevice}{'radio'}} ) {

			print $_->{"name"} , "_pkt.label " , $_->{"type"} , " Packets\n";

			print $_->{"name"} , "_pkt.type DERIVE\n";

			print $_->{"name"} , "_pkt.min 0\n";

			print $_->{"name"} , "_dret.label " , $_->{"type"} , " Dropped / Retries\n";

			print $_->{"name"} , "_dret.type DERIVE\n";

			print $_->{"name"} , "_dret.min 0\n";

			print $_->{"name"} , "_err.label " , $_->{"type"} , " Errors\n";

			print $_->{"name"} , "_err.type DERIVE\n";

			print $_->{"name"} , "_err.min 0\n";

		}

	}

	return 1;

}

sub do_config_xfer_by_network {

	# Provide transfer for named networks - CONFIG

	if ( !$PluginConfig{'enable_xfer_network'} ) { return 0; }

	graph_prologue(

		'unifi_xfer_per_network',

		'Transfer / named network',

		'--base 1000',

		'Bytes/${graph_period} rcvd (-) / trans (+)',

		'network',

		'Bytes sent and received per each named network'

	);

	foreach my $thisNet ( sort keys %{$Data{'networks'}} ) {

		foreach ( "_rxbytes", "_txbytes" ) {

			print $thisNet , $_ , ".label " , $Data{'networks'}{$thisNet}->{"label"} . "\n";

			print $thisNet , $_ , ".type DERIVE\n";

			print $thisNet , $_ , ".min 0\n";

		}

		print $thisNet , "_rxbytes.graph no\n";

		print $thisNet , "_txbytes.negative " , $thisNet , "_rxbytes\n";

	}

	if ( ! $PluginConfig{'enable_detail_xfer_network'} ) { return 1; }

	foreach my $thisNet ( sort keys %{$Data{'networks'}} ) {

		graph_prologue(

			'unifi_xfer_per_network.' . $thisNet,

			'Transfer / named network : ' . $Data{'networks'}{$thisNet}->{'label'},

			'--base 1000',

			'Bytes/${graph_period} rcvd (-) / trans (+)',

			'network',

			'Bytes sent and received for the network named: ' . $Data{'networks'}{$thisNet}->{'label'}

		);

		foreach ( "rxbyte", "txbyte" ) {

			print $_ , ".label Bytes\n";

			print $_ , ".type DERIVE\n";

			print $_ , ".min 0\n";

		}

		print "rxbyte.graph no\n";

		print "txbyte.negative rxbyte\n";

	}

	return 1;

}

sub do_config_xfer_by_port {

	# Provide transfer for switch ports - CONFIG

	if ( !$PluginConfig{'enable_xfer_port'} ) { return 0; }

	foreach my $thisDevice ( sort keys %{$Data{'device'}} ) {

		if ( $Data{'device'}{$thisDevice}->{'type'} ne "usw" ) { next; }

		graph_prologue(

			'unifi_xfer_per_port_' .  $thisDevice,

			'Transfer / port : ' . $Data{'device'}{$thisDevice}->{'label'},

			'--base 1000',

			'Bytes/${graph_period} rcvd (-) / trans (+)',

			'network',

			'Bytes sent and received per port on the switch named: ' . $Data{'device'}{$thisDevice}->{'label'}

		);

		foreach my $thisPort ( @{$Data{'device'}{$thisDevice}{'ports'}} ) {

			foreach ( "_rxbytes", "_txbytes" ) {

				print $thisDevice , "_" , $thisPort->{"name"} , $_ , ".label " , $thisPort->{"label"} . "\n";

				print $thisDevice , "_" , $thisPort->{"name"} , $_ , ".type DERIVE\n";

				print $thisDevice , "_" , $thisPort->{"name"} , $_ , ".min 0\n";

			}

			print $thisDevice , "_" , $thisPort->{"name"} , "_rxbytes.graph no\n";

			print $thisDevice , "_" , $thisPort->{"name"} , "_txbytes.negative " , $thisDevice , "_" , $thisPort->{"name"} , "_rxbytes\n";

		}

	}

	if ( ! $PluginConfig{'enable_detail_xfer_port'} ) { return 1; }

	# Extended graphs

	foreach my $thisDevice ( sort keys %{$Data{'device'}} ) {

		if ( $Data{'device'}{$thisDevice}->{'type'} ne "usw" ) { next; }

		foreach my $thisPort ( @{$Data{'device'}{$thisDevice}{'ports'}} ) {

			graph_prologue(

				'unifi_xfer_per_port_' .  $thisDevice . "." . $thisPort->{'name'},

				'Transfer / port : ' . $Data{'device'}{$thisDevice}->{'label'} . " : " . $thisPort->{'label'},

				'--base 1000',

				'Bytes/${graph_period} rcvd (-) / trans (+)',

				'network',

				'Bytes sent and received on port "' . $thisPort->{'label'} . '" of the switch "' . $Data{'device'}{$thisDevice}->{'label'} . '"'

			);

			foreach ( "rxbyte", "txbyte" ) {

				print $_ . ".label Bytes\n";

				print $_ . ".type DERIVE\n";

				print $_ . ".min 0\n";

			}

			print "rxbyte.graph no\n";

			print "txbyte.negative rxbyte\n";

		}

	}

	return 1;

}

sub do_config_xfer_by_uplink {

	# Provide transfer for unifi uplink - CONFIG

	if ( !$PluginConfig{'enable_xfer_device'} ) { return 0; }

	graph_prologue(

		'unifi_xfer_by_uplink',

		'Transfer on uplink : ' . $Data{'uplink'}{'devName'},

		'--base 1000',

		'Bytes/${graph_period} rcvd (-) / trans (+)',

		'network',

		'Bytes sent and received on the WAN port of the USG, and the speedtest result of the same port'

	);

	foreach ( "rx", "tx" ) {

		print $_ , "_speed.label Speedtest\n";

		print $_ , "_bytes.label Transferred\n";

		print $_ , "_speed.type GAUGE\n";

		print $_ , "_bytes.type DERIVE\n";

		print $_ , "_speed.min 0\n";

		print $_ , "_bytes.min 0\n";

	}

	print "rx_speed.graph no\n";

	print "rx_bytes.graph no\n";

	print "tx_speed.negative rx_speed\n";

	print "tx_bytes.negative rx_bytes\n";

	return 1;

}

sub do_config_xfer_by_device {

	# Provide transfer for each unifi device - CONFIG

	if ( !$PluginConfig{'enable_xfer_device'} ) { return 0; }

	graph_prologue(

		'unifi_xfer_per_device',

		'Transfer / device',

		'--base 1000',

		'Bytes/${graph_period} rcvd (-) / trans (+)',

		'network',

		'Bytes sent and received per unifi device'

	);

	foreach my $thisDevice ( sort keys %{$Data{'device'}} ) {

		foreach ( "_rxbytes", "_txbytes" ) {

			print $thisDevice , $_ , ".label " , $Data{'device'}{$thisDevice}->{'label'} , "\n";

			print $thisDevice , $_ , ".type DERIVE\n";

			print $thisDevice , $_ , ".min 0\n";

		}

		print $thisDevice , "_rxbytes.graph no\n";

		print $thisDevice , "_txbytes.negative " , $thisDevice , "_rxbytes\n";

	}

	if ( $PluginConfig{'enable_detail_xfer_device'} ) {

		foreach my $thisDevice ( sort keys %{$Data{'device'}} ) {

			graph_prologue(

				'unifi_xfer_per_device.' . $thisDevice,

				'Transfer / device : ' . $Data{'device'}{$thisDevice}->{'label'},

				'--base 1000',

				'Bytes/${graph_period} rcvd (-) / trans (+)',

				'network',

				'Bytes sent and received on the unifi device named: ' . $Data{'device'}{$thisDevice}->{'label'}

			);

			foreach ( "rxbyte", "txbyte" ) {

				print $_ , ".label Bytes\n";

				print $_ , ".type DERIVE\n";

				print $_ , ".min 0\n";

			}

			print "rxbyte.graph no\n";

			print "txbyte.negative rxbyte\n";

		}

	}

	return 1;

}

sub do_config_uptime {

	# Provide device uptime for each unifi device - CONFIG

	if ( !$PluginConfig{'enable_device_uptime'} ) { return 0; }

	graph_prologue(

		'unifi_device_uptime',

		'Uptime',

		'--base 1000 -r --lower-limit 0',

		'days',

		'system',

		'Uptime in days for each unifi device'

	);

	foreach ( sort keys %{$Data{'device'}} ) {

		print $_ , ".label " , $Data{'device'}{$_}->{"name"} , "\n";

	}

	return 1;

}

sub do_config_cpu {

	# Provide device CPU usage for each unifi device - CONFIG

	if ( !$PluginConfig{'enable_device_cpu'} ) { return 0; }

	graph_prologue(

		'unifi_device_cpu',

		'CPU Usage',

		'--base 1000 -r --lower-limit 0 --upper-limit 100',

		'%',

		'system',

		'CPU usage as a percentage for each unifi device'

	);

	foreach ( sort keys %{$Data{'device'}} ) {

		print $_ , ".label " , $Data{'device'}{$_}->{"name"} , "\n";

	}

	return 1;

}

sub do_config_load {

	# Provide device load average for each unifi device - CONFIG

	if ( !$PluginConfig{'enable_device_load'} ) { return 0; }

	graph_prologue(

		'unifi_device_load',

		'Load Average',

		'-l 0 --base 1000',

		'load',

		'system',

		'Load average for each unifi Access Point or Switch'

	);

	foreach ( sort keys %{$Data{'device'}} ) {

		if ( $Data{'device'}{$_}->{'type'} eq 'ugw' ) { next; }

		print $_ , ".label " , $Data{'device'}{$_}->{"name"} , "\n";

	}

	return 1;

}

sub do_config_mem {

	# Provide device memory usage for each unifi device - CONFIG

	if ( !$PluginConfig{'enable_device_mem'} ) { return 0; }

	graph_prologue(

		'unifi_device_mem',

		'Memory Usage',

		'--base 1000 -r --lower-limit 0 --upper-limit 100',

		'%',

		'system',

		'Memory usage as a percentage for each unifi device'

	);

	foreach ( sort keys %{$Data{'device'}} ) {

		print $_ , ".label " , $Data{'device'}{$_}->{"name"} , "\n";

	}

	return 1;

}

#########################

# SUBROUTINES    VALUES #

#########################

sub do_values_clients_by_type {

	# Provide client count by type - VALUES

	if ( !$PluginConfig{'enable_clients_type'} ) { return 0; }

	print "multigraph unifi_clients_per_network\n";

	foreach ( @{$Data{'typesOrder'}} ) {

		print $_ , ".value " , ( $Data{'types'}{$_}[2] + $Data{'types'}{$_}[3] ) , "\n";

	}

	if ( ! $PluginConfig{'enable_detail_clients_type'} ) { return 1; }

	foreach ( @{$Data{'typesOrder'}} ) {

		if ( $Data{'types'}{$_}[1] == 1 ) {

			print "multigraph unifi_clients_per_network.$_\n";

			print "users.value "  , $Data{'types'}{$_}[2] , "\n";

			print "guests.value " , $Data{'types'}{$_}[3] , "\n";

		}

	}

	return 1;

}

sub do_values_clients_by_device {

	# Provide client count by device - VALUES

	if ( !$PluginConfig{'enable_clients_device'} ) { return 0; }

	print "multigraph unifi_clients_per_device\n";

	foreach ( sort keys %{$Data{'device'}} ) {

		print $_ , ".value " , $Data{'device'}{$_}->{'clients'} , "\n";

	}

	if ( ! $PluginConfig{'enable_detail_clients_device'} ) { return 1; }

	foreach ( sort keys %{$Data{'device'}} ) {

		print "multigraph unifi_clients_per_device.$_\n";

		print "users.value "  , $Data{'device'}{$_}->{'users'}  , "\n";

		print "guests.value " , $Data{'device'}{$_}->{'guests'} , "\n";

	}

	return 1;

}

sub do_values_xfer_by_radio {

	# Provide transfer for radios - VALUES

	if ( !$PluginConfig{'enable_xfer_radio'} ) { return 0; }

	print "multigraph unifi_xfer_per_radio\n";

	foreach my $thisDevice ( sort keys %{$Data{'device'}} ) {

		if ( $Data{'device'}{$thisDevice}->{'type'} ne "uap" ) { next; }

		foreach ( @{$Data{'device'}{$thisDevice}{'radio'}} ) {

			print $thisDevice , "_" , $_->{"name"} , "_pack.value " , ($_->{"pckt"} // 0), "\n";;

		}

	}

	if ( ! $PluginConfig{'enable_detail_xfer_radio'} ) { return 1; }

	foreach my $thisDevice ( sort keys %{$Data{'device'}} ) {

		if ( $Data{'device'}{$thisDevice}->{'type'} ne "uap" ) { next; }

		print "multigraph unifi_xfer_per_radio.$thisDevice\n";

		foreach ( @{$Data{'device'}{$thisDevice}{'radio'}} ) {

			print $_->{"name"} , "_pkt.value "  , ($_->{"pckt"} // 0) , "\n";

			print $_->{"name"} , "_dret.value " , ($_->{"dret"} // 0) , "\n";

			print $_->{"name"} , "_err.value "  , ($_->{"err"} // 0) , "\n";

		}

	}

	return 1;

}

sub do_values_xfer_by_network {

	# Provide transfer for named networks - CONFIG

	if ( !$PluginConfig{'enable_xfer_network'} ) { return 0; }

	print "multigraph unifi_xfer_per_network\n";

	foreach my $thisNet ( sort keys %{$Data{'networks'}} ) {

		print $thisNet , "_rxbytes.value " , ($Data{'networks'}{$thisNet}->{"rx"} // 0) , "\n";

		print $thisNet , "_txbytes.value " , ($Data{'networks'}{$thisNet}->{"tx"} // 0) , "\n";

	}

	if ( ! $PluginConfig{'enable_detail_xfer_network'} ) { return 1; }

	foreach my $thisNet ( sort keys %{$Data{'networks'}} ) {

		print "multigraph unifi_xfer_per_network.$thisNet\n";

		print "rxbyte.value " , ($Data{'networks'}{$thisNet}->{"rx"} // 0) , "\n";

		print "txbyte.value " , ($Data{'networks'}{$thisNet}->{"tx"} // 0) , "\n";

	}

	return 1;

}

sub do_values_xfer_by_port {

	# Provide transfer for switch ports - VALUES

	if ( !$PluginConfig{'enable_xfer_port'} ) { return 0; }

	foreach my $thisDevice ( sort keys %{$Data{'device'}} ) {

		if ( $Data{'device'}{$thisDevice}->{'type'} ne "usw" ) { next; }

		print "multigraph unifi_xfer_per_port_$thisDevice\n";

		foreach ( @{$Data{'device'}{$thisDevice}{'ports'}} ) {

			print $thisDevice , "_" , $_->{"name"} , "_rxbytes.value " , $_->{"rx"} , "\n";

			print $thisDevice , "_" , $_->{"name"} , "_txbytes.value " , $_->{"tx"} , "\n";

		}

	}

	if ( ! $PluginConfig{'enable_detail_xfer_port'} ) { return 1; }

	# Extended graphs

	foreach my $thisDevice ( sort keys %{$Data{'device'}} ) {

		if ( $Data{'device'}{$thisDevice}->{'type'} ne "usw" ) { next; }

		foreach ( @{$Data{'device'}{$thisDevice}{'ports'}} ) {

			print 'multigraph unifi_xfer_per_port_' .  $thisDevice . "." . $_->{'name'} . "\n";

			print "rxbyte.value " , $_->{"rx"} , "\n";

			print "txbyte.value " , $_->{"tx"} , "\n";

		}

	}

	return 1;

}

sub do_values_xfer_by_uplink {

	# Provide transfer for unifi uplink - CONFIG

	if ( !$PluginConfig{'enable_xfer_device'} ) { return 0; }

	print "multigraph unifi_xfer_by_uplink\n";

	print "rx_speed.value " . $Data{'uplink'}{"rx_speed"} . "\n";

	print "tx_speed.value " . $Data{'uplink'}{"tx_speed"} . "\n";

	print "rx_bytes.value " . $Data{'uplink'}{"rx_bytes"} . "\n";

	print "tx_bytes.value " . $Data{'uplink'}{"tx_bytes"} . "\n";

	return 1;

}

sub do_values_xfer_by_device {

	# Provide transfer for each unifi device - CONFIG

	if ( !$PluginConfig{'enable_xfer_device'} ) { return 0; }

	print "multigraph unifi_xfer_per_device\n";

	foreach ( sort keys %{$Data{'device'}} ) {

		print $_ . "_rxbytes.value " . $Data{'device'}{$_}->{"rx"} , "\n";

		print $_ . "_txbytes.value " . $Data{'device'}{$_}->{"tx"} , "\n";

	}

	if ( $PluginConfig{'enable_detail_xfer_device'} ) {

		foreach ( sort keys %{$Data{'device'}} ) {

			print "multigraph unifi_xfer_per_device." , $_ , "\n";

			print "rxbyte.value " , $Data{'device'}{$_}->{"rx"} , "\n";

			print "txbyte.value " , $Data{'device'}{$_}->{"tx"} , "\n";

		}

	}

	return 1;

}

sub do_values_cpu {

	# Provide device CPU usage for each unifi device - VALUES

	if ( !$PluginConfig{'enable_device_cpu'} ) { return 0; }

	print "multigraph unifi_device_cpu\n";

	foreach ( sort keys %{$Data{'device'}} ) {

		print $_ , ".value " , ( $Data{'device'}{$_}->{"cpu"} ) , "\n";

	}

	return 1;

}

sub do_values_mem {

	# Provide device memory usage for each unifi device - VALUES

	if ( !$PluginConfig{'enable_device_mem'} ) { return 0; }

	print "multigraph unifi_device_mem\n";

	foreach ( sort keys %{$Data{'device'}} ) {

		print $_ , ".value " , ( $Data{'device'}{$_}->{"mem"} ) , "\n";

	}

	return 1;

}

sub do_values_load {

	# Provide device load average for each unifi device - VALUES

	if ( !$PluginConfig{'enable_device_load'} ) { return 0; }

	print "multigraph unifi_device_load\n";

	foreach ( sort keys %{$Data{'device'}} ) {

		if ( $Data{'device'}{$_}->{'type'} eq 'ugw' ) { next; }

		print $_ , ".value " , ( $Data{'device'}{$_}->{"load"} ) , "\n";

	}

	return 1;

}

sub do_values_uptime {

	# Provide device uptime for each unifi device - VALUES

	if ( !$PluginConfig{'enable_device_uptime'} ) { return 0; }

	print "multigraph unifi_device_uptime\n";

	foreach ( sort keys %{$Data{'device'}} ) {

		print $_ , ".value " , ( $Data{'device'}{$_}->{"uptime"} / 86400 ) , "\n";

	}

	return 1;

}

#########################

# SUBROUTINES   GENERAL #

#########################

sub graph_prologue {

	# Generate graph prologues - slightly less copy-pasta, and less chance for things to go wrong

	my ( $id, $title, $args, $vlabel, $category, $info ) = (@_);

	print "multigraph $id\n";

	print 'graph_title ' , $title , ' : ' , $APIconfig{"name"} , "\n";

	print "graph_args $args\n";

	print "graph_vlabel $vlabel\n";

	if ( $PluginConfig{'force_category'} ) {

		print "graph_category ", $PluginConfig{'force_category'}, "\n";

	} else {

		print "graph_category $category\n";

	}

	if ( $info ) {

		print 'graph_info For the unifi site named "' , $APIconfig{"name"} , "\", $info\n";

	}

	return 1;

}

# Collate all collected data into something we can use.

sub make_data {

	foreach my $thisDevice ( @{$APIJsonResponse{'device'}->{'data'}} ) {

		# Grab everything we care to know about each device.

		$Data{'device'}{ make_safe($thisDevice->{'name'}, $thisDevice->{'serial'}) } = {

			'label'   => $thisDevice->{'name'},

			'users'   => ($thisDevice->{'user-num_sta'} || 0),

			'guests'  => ($thisDevice->{'guest-num_sta'} || 0),

			'clients' => ($thisDevice->{'user-num_sta'} + $thisDevice->{'guest-num_sta'} || 0),

			'tx'      => $thisDevice->{'rx_bytes'},

			'rx'      => $thisDevice->{'tx_bytes'},

			'name'    => $thisDevice->{'name'},

			'uptime'  => $thisDevice->{'uptime'},

			'cpu'     => $thisDevice->{'system-stats'}->{'cpu'},

			'mem'     => $thisDevice->{'system-stats'}->{'mem'},

			'load'    => ( $thisDevice->{'type'} eq 'ugw' ? 'U' : $thisDevice->{'sys_stats'}->{'loadavg_1'} ),

			'type'    => $thisDevice->{'type'}

		};

		if ( $thisDevice->{'type'} eq 'ugw' ) { # Handle firewall specially, record uplink and networks

			foreach my $thisNet ( @{$thisDevice->{'network_table'}} ) {

				$Data{'networks'}{ make_safe($thisNet->{'name'}, $thisNet->{'_id'} ) } = {

					'label' => $thisNet->{'name'},

					'tx'    => $thisNet->{'tx_bytes'},

					'rx'    => $thisNet->{'rx_bytes'}

				}

			}

			$Data{'uplink'}{'devName'}  = $thisDevice->{'name'};

			$Data{'uplink'}{'rx_speed'} = $thisDevice->{'speedtest-status'}->{'xput_download'} * 1000000;

			$Data{'uplink'}{'tx_speed'} = $thisDevice->{'speedtest-status'}->{'xput_upload'} * 1000000;

			foreach ( @{$thisDevice->{"port_table"}} ) {

				if ( $_->{name} eq "wan" ) {

					$Data{'uplink'}{'rx_bytes'} = $_->{'rx_bytes'};

					$Data{'uplink'}{'tx_bytes'} = $_->{'tx_bytes'};

				}

			}

		}

		if ( $thisDevice->{'type'} eq 'usw' ) { # Handle swiches specially - record port stats

			my @port_list;

			foreach my $port ( @{$thisDevice->{'port_table'}} ) {

				if ( !$PluginConfig{'hide_empty_xfer_port'} || $port->{'up'} ) {

					push @port_list , {

						'name'  => 'port_' . zPad($port->{'port_idx'}),

						'label' => zPad($port->{'port_idx'}) . '-' . $port->{'name'},

						'rx'    => $port->{'rx_bytes'},

						'tx'    => $port->{'tx_bytes'}

					};

				}

			}

			$Data{'device'}{ make_safe($thisDevice->{'name'}, $thisDevice->{'serial'}) }{'ports'} = \@port_list;

		}

		if ( $thisDevice->{'type'} eq 'uap' ) { # Handle APS specially - record radio stats

			my @theseRadios;

			foreach my $thisRadio ( @{$thisDevice->{'radio_table_stats'}} ) {

				my $name  = make_safe( $thisRadio->{'name'}, "" );

				my $label = ( $thisRadio->{'channel'} < 12 ) ? '2.4Ghz' : '5Ghz';

				$_ = $thisDevice->{'stat'}->{'ap'};

				push @theseRadios, {

					'name'  => $name,

					'label' => $label . '-' . $thisDevice->{'name'},

					'pckt'  => ($_->{$name . '-rx_packets'} // 0) + ($_->{$name . '-tx_packets'} // 0),

					'dret'  => ($_->{$name . '-rx_dropped'} // 0) + ($_->{$name . '-tx_retries'} // 0) + ($_->{$name . '-tx_dropped'} // 0),

					'err'   => ($_->{$name . '-rx_errors'} // 0) + ($_->{$name . '-tx_errors'} // 0),

					'type'  => $label

				};

			}

			$Data{'device'}{ make_safe($thisDevice->{'name'}, $thisDevice->{'serial'}) }{'radio'} = \@theseRadios;

		}

	} # END PROCESSING OF DEVICE DATA

	# PROCESS NETWORK TYPE DATA

	# -> UNLESS, type graph is disabled.

	#

	# WHY: if the client list is large (huge.  10,000+), this is CPU intensive

	if ( !$PluginConfig{'enable_clients_type'} ) { return 1; }

	$Data{'types'} = {

		"wired"  => ["Wired Connection", 1, 0, 0],

		"wifi"   => ["Wireless Connection", 1, 0, 0],

		"tuser"   => ["Total Users", 0, 0, 0],

		"tguest"  => ["Total Guests", 0, 0, 0],

		"authed" => ["Authorized Guests", 0, 0, 0],

		"unauth" => ["Unauthorized Guests", 0, 0, 0],

	};

	$Data{'typesOrder'} = ( $PluginConfig{'show_authorized_clients_type'} ) ?

		[ "wired", "wifi", "tuser", "tguest", "authed", "unauth"] :

		[ "wired", "wifi", "tuser", "tguest" ];

	my @wlans;

	foreach my $thisNet ( @{$APIJsonResponse{'wlan'}->{'data'}} ) {

		$Data{'types'}{ make_safe($thisNet->{'name'}, "") } = [ $thisNet->{'name'}, 1, 0, 0 ];

		push @wlans, make_safe($thisNet->{'name'}, "");

	}

	foreach ( sort @wlans ) {

		push @{$Data{'typesOrder'}}, $_;

	}

	foreach my $client ( @{$APIJsonResponse{'sta'}->{'data'}} ) {

		if ( $client->{"is_wired"} ) {

			if ( $client->{"is_guest"} ) {

				$Data{'types'}->{'wired'}[3]++;

				$Data{'types'}->{'guest'}[3]++;

			} else {

				$Data{'types'}->{'wired'}[2]++;

				$Data{'types'}->{'user'}[2]++;

			}

		} else {

			if ( $client->{"is_guest"} ) {

				$Data{'types'}->{make_safe($client->{"essid"}, "")}[3]++;

				$Data{'types'}->{'wifi'}[3]++;

				$Data{'types'}->{'guest'}[3]++;

				if ( $client->{"authorized"} ) {

					$Data{'types'}->{'authed'}[3]++;

				} else {

					$Data{'types'}->{'unauth'}[3]++;

				}

			} else {

				$Data{'types'}->{make_safe($client->{"essid"}, "")}[2]++;

				$Data{'types'}->{'wifi'}[2]++;

				$Data{'types'}->{'user'}[2]++;

			}

		}

	}

	return 1;

}

sub fetch_data {

	# Set up curl, and login to API

	$curl->setopt($curl->CURLOPT_POST,1);

	$curl->setopt($curl->CURLOPT_COOKIEFILE,"");  # Session only cookie

	$curl->setopt($curl->CURLOPT_SSL_VERIFYPEER, (( $APIconfig{"ssl_verify_peer"} =~ m/no/i ) ? 0 : 1) );

	$curl->setopt($curl->CURLOPT_SSL_VERIFYHOST, (( $APIconfig{"ssl_verify_host"} =~ m/no/i ) ? 0 : 2) );

	$curl->setopt($curl->CURL_SSLVERSION_TLSv1, 1);

	$curl->setopt($curl->CURLOPT_URL, $APIPoint{'login'});

	$curl->setopt($curl->CURLOPT_POSTFIELDS, q[{"username":"] . $APIconfig{"user"} . q[", "password":"] . $APIconfig{"pass"} . q["}] );

	$curl->setopt($curl->CURLOPT_WRITEDATA, \$APIResponse{'login'});

	$retcode = $curl->perform;

	if ( $retcode != 0 ) {

		die "FATAL:$me: Unable to connect to API: " . $curl->strerror($retcode) . " " . $curl->errbuf . "\n";

	}

	$APIJsonResponse{'login'} = $jsonOBJ->allow_nonref->utf8->relaxed->decode($APIResponse{'login'});

	if ( $APIJsonResponse{'login'}->{'meta'}->{'rc'} ne 'ok' ) {

		die "FATAL:$me: Unable to login to API - it said: " , $APIJsonResponse{'login'}->{'meta'}->{'msg'} , "\n";

	}

	# Change method to GET

	$curl->setopt($curl->CURLOPT_HTTPGET,1);

	# Get some API data.

	# Device data

	$curl->setopt($curl->CURLOPT_WRITEDATA, \$APIResponse{'device'});

	$curl->setopt($curl->CURLOPT_URL, $APIPoint{'device'});

	$retcode = $curl->perform;

	if ( $retcode != 0 ) {

		die "FATAL:$me: Unable to connect to API: " . $curl->strerror($retcode) . " " . $curl->errbuf . "\n";

	}

	$APIJsonResponse{'device'} = $jsonOBJ->allow_nonref->utf8->relaxed->decode($APIResponse{'device'});

	if ( $APIJsonResponse{'device'}->{'meta'}->{'rc'} ne 'ok' ) {

		die "FATAL:$me: Unable get device data from API - it said: " , $APIJsonResponse{'device'}->{'meta'}->{'msg'} , "\n";

	}

	# STA (client) data

	$curl->setopt($curl->CURLOPT_WRITEDATA, \$APIResponse{'sta'});

	$curl->setopt($curl->CURLOPT_URL, $APIPoint{'sta'});

	$retcode = $curl->perform;

	if ( $retcode != 0 ) {

		die "FATAL:$me: Unable to connect to API: " . $curl->strerror($retcode) . " " . $curl->errbuf . "\n";

	}

	$APIJsonResponse{'sta'} = $jsonOBJ->allow_nonref->utf8->relaxed->decode($APIResponse{'sta'});

	if ( $APIJsonResponse{'sta'}->{'meta'}->{'rc'} ne 'ok' ) {

		die "FATAL:$me: Unable get sta data from API - it said: " , $APIJsonResponse{'sta'}->{'meta'}->{'msg'} , "\n";

	}

	# WLAN data

	$curl->setopt($curl->CURLOPT_WRITEDATA, \$APIResponse{'wlan'});

	$curl->setopt($curl->CURLOPT_URL, $APIPoint{'wlan'});

	$retcode = $curl->perform;

	if ( $retcode != 0 ) {

		die "FATAL:$me: Unable to connect to API: " . $curl->strerror($retcode) . " " . $curl->errbuf . "\n";

	}

	$APIJsonResponse{'wlan'} = $jsonOBJ->allow_nonref->utf8->relaxed->decode($APIResponse{'wlan'});

	if ( $APIJsonResponse{'wlan'}->{'meta'}->{'rc'} ne 'ok' ) {

		die "FATAL:$me: Unable get wlan data from API - it said: " , $APIJsonResponse{'wlan'}->{'meta'}->{'msg'} , "\n";

	}

}

# Make field names safe, and lowercase.

# 

# Typically, $extraName should be the MAC address of the unique ID identifier as the unifi

# controller software does not enforce that device names or network names are unique.

sub make_safe {

	my ( $name, $extraName ) = ( @_ );

	if ( $extraName ne "" ) {

		return clean_fieldname(lc($name) . "_" . $extraName);

	} else {

		return lc(clean_fieldname($name));

	}

}

# Get a default from an environmental variable - return text

#

# env_default(<variable name>, <default>)

sub env_default_text {

	my ( $env_var, $default ) = (@_);

	return ( ( defined $ENV{$env_var} ) ? $ENV{$env_var} : $default ),

}

# Get a default from an environmental variable - boolean true

#

# env_default_bool_true (<variable name>, <default>)

sub env_default_bool_true {

	my $env_var = $_[0];

	return ( ( defined $ENV{$env_var} && $ENV{$env_var} =~ m/no/i ) ? 0 : 1 );

}

# Quick 2 digit zero pad

sub zPad { return sprintf("%02d", $_[0]); }