bashclub/check-unifi-controller
1
0
Fork 0
mirror of https://github.com/bashclub/check-unifi-controller.git synced 2024-12-26 13:20:11 +01:00
Code Issues Projects Releases Wiki Activity
d67358acef
check-unifi-controller/share/check_mk/agents/special/agent_unifi_controller

655 lines
26 KiB
Python
Raw Blame History

#!/usr/bin/env python3
# -*- encoding: utf-8; py-indent-offset: 4 -*-
## MIT License
##
## Copyright (c) 2021 Bash Club
##
## Permission is hereby granted, free of charge, to any person obtaining a copy
## of this software and associated documentation files (the "Software"), to deal
## in the Software without restriction, including without limitation the rights
## to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
## copies of the Software, and to permit persons to whom the Software is
## furnished to do so, subject to the following conditions:
##
## The above copyright notice and this permission notice shall be included in all
## copies or substantial portions of the Software.
##
## THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
## IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
## FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
## AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
## LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
## OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
## SOFTWARE.
###
__VERSION__ = 0.87
import sys
import socket
import re
import json
import requests
from urllib3.exceptions import InsecureRequestWarning
from statistics import mean
from collections import defaultdict
from pprint import pprint
try:
import cmk.utils.paths
AGENT_TMP_PATH = cmk.utils.paths.Path(cmk.utils.paths.tmp_dir, "agents/agent_unifi")
except ImportError:
AGENT_TMP_PATH = None
UNIFI_DEVICE_TABLE = {
'BZ2' : 'UAP',
'BZ2LR' : 'UAP-LR',
'U2HSR' : 'UAP-Outdoor+',
'U2IW' : 'UAP-IW',
'U2L48' : 'UAP-AC-LR',
'U2Lv2' : 'UAP-AC-LR',
'U2M' : 'UAP-Mini',
'U2O' : 'UAP-Outdoor',
'U2S48' : 'UAP-AC',
'U2Sv2' : 'UAP-AC',
'U5O' : 'UAP-Outdoor5',
'U7E' : 'UAP-AC',
'U7EDU' : 'UAP-AC-EDU',
'U7Ev2' : 'UAP-AC',
'U7HD' : 'UAP-AC-HD',
'U7SHD' : 'UAP-AC-SHD',
'U7NHD' : 'UAP-nanoHD',
'UFLHD' : 'UAP-FlexHD',
'UHDIW' : 'UAP-IW-HD',
'UAIW6' : 'U6-IW',
'UAE6' : 'U6-Extender',
'UAL6' : 'U6-Lite',
'UAM6' : 'U6-Mesh',
'UALR6' : 'U6-LR-EA',
'UAP6' : 'U6-LR',
'UALR6v2' : 'U6-LR',
'UALR6v3' : 'U6-LR',
'UCXG' : 'UAP-XG',
'UXSDM' : 'UWB-XG',
'UXBSDM' : 'UWB-XG-BK',
'UCMSH' : 'UAP-XG-Mesh',
'U7IW' : 'UAP-AC-IW',
'U7IWP' : 'UAP-AC-IW-Pro',
'U7MP' : 'UAP-AC-M-Pro',
'U7LR' : 'UAP-AC-LR',
'U7LT' : 'UAP-AC-Lite',
'U7O' : 'UAP-AC-Outdoor',
'U7P' : 'UAP-Pro',
'U7MSH' : 'UAP-AC-M',
'U7PG2' : 'UAP-AC-Pro',
'p2N' : 'PICOM2HP',
'UDMB' : 'UAP-BeaconHD',
'USF5P' : 'USW-Flex',
'US8' : 'US-8',
'US8P60' : 'US-8-60W',
'US8P150' : 'US-8-150W',
'S28150' : 'US-8-150W',
'USC8' : 'US-8',
'USC8P60' : 'US-8-60W',
'USC8P150' : 'US-8-150W',
'US16P150' : 'US-16-150W',
'S216150' : 'US-16-150W',
'US24' : 'US-24-G1',
'US24PRO' : 'USW-Pro-24-PoE',
'US24PRO2' : 'USW-Pro-24',
'US24P250' : 'US-24-250W',
'US24PL2' : 'US-L2-24-PoE',
'US24P500' : 'US-24-500W',
'S224250' : 'US-24-250W',
'S224500' : 'US-24-500W',
'US48' : 'US-48-G1',
'US48PRO' : 'USW-Pro-48-PoE',
'US48PRO2' : 'USW-Pro-48',
'US48P500' : 'US-48-500W',
'US48PL2' : 'US-L2-48-PoE',
'US48P750' : 'US-48-750W',
'S248500' : 'US-48-500W',
'S248750' : 'US-48-750W',
'US6XG150' : 'US-XG-6PoE',
'USMINI' : 'USW-Flex-Mini',
'USXG' : 'US-16-XG',
'USC8P450' : 'USW-Industrial',
'UDC48X6' : 'USW-Leaf',
'USL8A' : 'UniFi Switch Aggregation',
'USAGGPRO' : 'UniFi Switch Aggregation Pro',
'USL8LP' : 'USW-Lite-8-PoE',
'USL8MP' : 'USW-Mission-Critical',
'USL16P' : 'USW-16-PoE',
'USL16LP' : 'USW-Lite-16-PoE',
'USL24' : 'USW-24-G2',
'USL48' : 'USW-48-G2',
'USL24P' : 'USW-24-PoE',
'USL48P' : 'USW-48-PoE',
'UGW3' : 'USG-3P',
'UGW4' : 'USG-Pro-4',
'UGWHD4' : 'USG',
'UGWXG' : 'USG-XG-8',
'UDM' : 'UDM',
'UDMSE' : 'UDM-SE',
'UDMPRO' : 'UDM-Pro',
'UP4' : 'UVP-X',
'UP5' : 'UVP',
'UP5t' : 'UVP-Pro',
'UP7' : 'UVP-Executive',
'UP5c' : 'UVP',
'UP5tc' : 'UVP-Pro',
'UP7c' : 'UVP-Executive',
'UCK' : 'UCK',
'UCK-v2' : 'UCK',
'UCK-v3' : 'UCK',
'UCKG2' : 'UCK-G2',
'UCKP' : 'UCK-G2-Plus',
'UASXG' : 'UAS-XG',
'ULTE' : 'U-LTE',
'ULTEPUS' : 'U-LTE-Pro',
'ULTEPEU' : 'U-LTE-Pro',
'UP1' : 'USP-Plug',
'UP6' : 'USP-Strip',
'USPPDUP' : 'USP - Power Distribution Unit Pro',
'USPRPS' : 'USP-RPS',
'US624P' : 'UniFi6 Switch 24',
'UBB' : 'UBB',
'UXGPRO' : 'UniFi NeXt-Gen Gateway PRO'
}
try:
from cmk.special_agents.utils.argument_parsing import create_default_argument_parser
#from check_api import LOGGER ##/TODO
except ImportError:
from argparse import ArgumentParser as create_default_argument_parser
class unifi_api_exception(Exception):
pass
class unifi_object(object):
def __init__(self,**kwargs):
for _k,_v in kwargs.items():
_k = _k.replace("-","_")
if type(_v) == bool:
_v = int(_v)
setattr(self,_k,_v)
self._PARENT = kwargs.get("_PARENT",object)
if hasattr(self._PARENT,"_UNIFICONTROLLER"):
self._UNIFICONTROLLER = self._PARENT._UNIFICONTROLLER
self._API = self._PARENT._API
if hasattr(self,"_init"):
self._init()
def __repr__(self):
return repr([(_k,_v) for _k,_v in self.__dict__.items() if type(_v) in (int,str)])
########################################
######
###### S S I D
######
########################################
class unifi_network_ssid(unifi_object):
def _init(self):
self._UNIFICONTROLLER._UNIFI_SSIDS.append(self)
self._UNIFI_SITE = self._PARENT._PARENT
for _k,_v in getattr(self,"reasons_bar_chart_now",{}).items():
setattr(self,_k,_v)
setattr(self,f"{self.radio}_num_sta",self.num_sta)
setattr(self,f"{self.radio}_tcp_packet_loss",self.tcp_packet_loss)
setattr(self,f"{self.radio}_wifi_retries",self.wifi_retries)
setattr(self,f"{self.radio}_wifi_latency",self.wifi_latency)
setattr(self,f"{self.radio}_avg_client_signal",self.avg_client_signal)
def __str__(self):
_ret = []
_unwanted = ["essid","radio","id","t","name","radio_name","wlanconf_id","is_wep","up","site_id","ap_mac","state",
"na_num_sta","ng_num_sta","ng_tcp_packet_loss","na_tcp_packet_loss","na_wifi_retries","ng_wifi_retries",
"na_wifi_latency","ng_wifi_latency","na_avg_client_signal","ng_avg_client_signal"
]
for _k,_v in self.__dict__.items():
if _k.startswith("_") or _k in _unwanted or type(_v) not in (str,int,float):
continue
_ret.append(f"{self.essid}|{self.radio}_{_k}|{_v}")
return "\n".join(_ret)
########################################
######
###### R A D I O
######
########################################
class unifi_network_radio(unifi_object):
def _update_stats(self,stats):
_prefixlen = len(self.name) +1
for _k,_v in stats.items():
if _k.startswith(self.name):
if type(_v) == float:
_v = int(_v)
setattr(self,_k[_prefixlen:],_v)
def __str__(self):
_ret = []
_unwanted = ["name","ast_be_xmit","extchannel","cu_total","cu_self_rx","cu_self_tx"]
for _k,_v in self.__dict__.items():
if _k.startswith("_") or _k in _unwanted or type(_v) not in (str,int,float):
continue
_ret.append(f"{self.name}|{_k}|{_v}")
return "\n".join(_ret)
########################################
######
###### P O R T
######
########################################
class unifi_network_port(unifi_object):
def _init(self):
self.oper_status = self._get_state(getattr(self,"up",None))
self.admin_status = self._get_state(getattr(self,"enable",None))
if hasattr(self,"ifname"): ## GW / UDM Names
_name = list(filter(lambda x: x.get("ifname") == self.ifname,self._PARENT.ethernet_overrides))
if _name:
_name = _name[0]
if getattr(self,"name",None) and _name.get("networkgroup") != "LAN":
self.name = _name.get("networkgroup","unkn")
else:
self.name = self.ifname
if not hasattr(self,"port_idx") and hasattr(self,"ifname"):
self.port_idx = int(self.ifname[-1])+1 ## ethX
self.portconf = self._PARENT._PARENT._PORTCONFIGS.get(getattr(self,"portconf_id",None))
def _get_state(self,state):
return {
"1" : 1, ## up
"0" : 2 ## down
}.get(str(state),4) ##unknown
def __str__(self):
_ret = []
_unwanted = ["up","enabled","media","anonymous_id","www_gw_mac","wan_gw_mac","attr_hidden_id","masked","flowctrl_tx","flowctrl_rx","portconf_id","speed_caps"]
for _k,_v in self.__dict__.items():
if _k.startswith("_") or _k in _unwanted or type(_v) not in (str,int,float):
continue
_ret.append(f"{self.port_idx}|{_k}|{_v}")
return "\n".join(_ret)
########################################
######
###### D E V I C E
######
########################################
class unifi_device(unifi_object):
def _init(self):
if not hasattr(self,"name"):
_mac_end = self.mac.replace(":","")[-4:]
self.name = f"{self.model}:{_mac_end}"
self._piggy_back = True
self._PARENT._SITE_DEVICES.append(self)
self._NETWORK_PORTS = []
self._NETWORK_RADIO = []
self._NETWORK_SSIDS = []
for _k,_v in getattr(self,"sys_stats",{}).items():
_k = _k.replace("-","_")
setattr(self,_k,_v)
self.model_name = UNIFI_DEVICE_TABLE.get(self.model)
if self.type in ("ugw","udm"):
## change ip to local ip
self.wan_ip = self.ip
self.ip = self.connect_request_ip
if getattr(self,"speedtest_status_saved",False):
_speedtest = getattr(self,"speedtest_status",{})
self.speedtest_time = int(_speedtest.get("rundate","0"))
self.speedtest_status = int(_speedtest.get("status_summary","0"))
self.speedtest_ping = round(_speedtest.get("latency",-1),1)
self.speedtest_download = round(_speedtest.get("xput_download",0.0),1)
self.speedtest_upload = round(_speedtest.get("xput_upload",0.0),1)
_temp = list(map(lambda x: x.get("value",0),getattr(self,"temperatures",[])))
if _temp:
self.general_temperature = "{0:.1f}".format(mean(_temp))
for _port in getattr(self,"port_table",[]):
self._NETWORK_PORTS.append(unifi_network_port(_PARENT=self,**_port))
for _radio in getattr(self,"radio_table_stats",[]):
_radio_obj = unifi_network_radio(_PARENT=self,**_radio)
_radio_obj._update_stats(getattr(self,"stat",{}).get("ap",{}))
self._NETWORK_RADIO.append(_radio_obj)
for _ssid in getattr(self,"vap_table",[]):
self._NETWORK_SSIDS.append(unifi_network_ssid(_PARENT=self,**_ssid))
def _get_uplink(self):
if type(getattr(self,"uplink",None)) == dict:
self.uplink_up = int(self.uplink.get("up","0"))
self.uplink_device = self._UNIFICONTROLLER._get_device_by_mac(self.uplink.get("uplink_mac"))
self.uplink_remote_port = self.uplink.get("uplink_remote_port")
self.uplink_type = self.uplink.get("type")
def _get_short_info(self):
_ret = []
_wanted = ["version","ip","mac","serial","model","model_name","uptime","upgradeable","num_sta","adopted","state"]
for _k,_v in self.__dict__.items():
if _k.startswith("_") or _k not in _wanted or type(_v) not in (str,int,float):
continue
_ret.append(f"{self.name}|{_k}|{_v}")
return "\n".join(_ret)
def __str__(self):
if self._piggy_back:
_piggybackname = getattr(self,self._API.PIGGYBACK_ATTRIBUT,self.name)
_ret = [f"<<<<{_piggybackname}>>>>"]
else:
_ret = []
_ret.append("<<<unifi_device:sep(124)>>>")
_unwanted = ["anon_id","device_id","site_id","known_cfgversion","cfgversion","syslog_key","has_speaker","has_eth1",
"next_interval","next_heartbeat","next_heartbeat_at","guest_token","connect_request_ip","connect_request_port",
"start_connected_millis","start_disconnected_millis","wlangroup_id_na","wlangroup_id_ng","uplink_down_timeout"
"unsupported_reason","connected_at","provisioned_at","fw_caps","hw_caps","manufacturer_id","use_custom_config",
"led_override","led_override_color","led_override_color_brightness","sys_error_caps","adoptable_when_upgraded",
"mesh_uplink_1","mesh_uplink_1","considered_lost_at","outdoor_mode_override","unsupported_reason","architecture",
"kernel_version","required_version","prev_non_busy_state","has_fan","has_temperature","flowctrl_enabled","hash_id",
"speedtest-status-saved","usg_caps","two_phase_adopt","rollupgrade","locating","dot1x_portctrl_enabled",
"lcm_idle_timeout_override","lcm_brightness_override","uplink_depth","mesh_sta_vap_enabled","mesh_uplink_2",
"lcm_tracker_enabled","model_incompatible","model_in_lts","model_in_eol","country_code","wifi_caps",
"meshv3_peer_mac","element_peer_mac","vwireEnabled","hide_ch_width","x_authkey","x_ssh_hostkey_fingerprint",
"x_fingerprint","x_inform_authkey","op_mode","uptime"
]
for _k,_v in self.__dict__.items():
if _k.startswith("_") or _k in _unwanted or type(_v) not in (str,int,float):
continue
_ret.append(f"{_k}|{_v}")
_ret.append("<<<labels:sep(0)>>>")
_ret.append(f"{{\"unifi_device\":\"unifi-{self.type}\"}}")
_uptime = getattr(self,"uptime",None)
if _uptime:
_ret.append("<<<uptime>>>")
_ret.append(str(_uptime))
if self._NETWORK_PORTS:
_ret += ["","<<<unifi_network_ports:sep(124)>>>"] + [str(_port) for _port in self._NETWORK_PORTS]
if self._NETWORK_RADIO:
_ret += ["","<<<unifi_network_radios:sep(124)>>>"] + [str(_radio) for _radio in self._NETWORK_RADIO]
if self._NETWORK_SSIDS:
_ret += ["","<<<unifi_network_ssids:sep(124)>>>"] + [str(_ssid) for _ssid in sorted(self._NETWORK_SSIDS,key=lambda x: x.essid)]
return "\n".join(_ret)
########################################
######
###### S I T E
######
########################################
class unifi_site(unifi_object):
def _init(self):
for _subsys in self.health:
_name = _subsys.get("subsystem")
for _k,_v in _subsys.items():
_k = _k.replace("-","_")
if _k == "subsystem" or type(_v) not in (str,int,float):
continue
#print(f"{_k}:{_v}")
setattr(self,f"{_name}_{_k}",_v)
##pprint(_api.get_data("/stat/rogueap"))
self._SITE_DEVICES = []
self._PORTCONFIGS = {}
self._get_portconfig()
self._get_devices()
_satisfaction = list(filter(
lambda x: x != None,map(
lambda x: getattr(x,"satisfaction",None),self._SITE_DEVICES
)
))
self.satisfaction = max(0,int(mean(_satisfaction)) if _satisfaction else 0)
def _get_portconfig(self):
_data = self._API.get_portconfig(site=self.name)
for _config in _data:
self._PORTCONFIGS[_config["_id"]] = _config.get("name")
def _get_devices(self):
_data = self._API.get_devices(site=self.name)
for _device in _data:
self._UNIFICONTROLLER._UNIFI_DEVICES.append(unifi_device(_PARENT=self,**_device))
def __str__(self):
_ret = ["<<<unifi_sites:sep(124)>>>"]
_unwanted = ["name","anonymous_id","www_gw_mac","wan_gw_mac","attr_hidden_id","attr_no_delete",""]
for _k,_v in self.__dict__.items():
if _k.startswith("_") or _k in _unwanted or type(_v) not in (str,int,float):
continue
_ret.append(f"{self.name}|{_k}|{_v}")
return "\n".join(_ret)
########################################
######
###### C O N T R O L L E R
######
########################################
class unifi_controller(unifi_object):
def _init(self):
self._UNIFICONTROLLER = self
self._UNIFI_SITES = []
self._UNIFI_DEVICES = []
self._UNIFI_SSIDS = []
self._get_systemhealth()
self._get_sites()
for _dev in self._UNIFI_DEVICES:
_dev._get_uplink()
if hasattr(self,"cloudkey_version"):
self.cloudkey_version = re.sub(".*?v(\d+\.\d+\.\d+\.[a-z0-9]+).*","\\1",self.cloudkey_version)
self.type = getattr(self,"ubnt_device_type","unifi-sw-controller")
self.controller_version = self.version
delattr(self,"version")
def _get_systemhealth(self):
_data = self._API.get_sysinfo()
_wanted = ["timezone","autobackup","version","previous_version","update_available","hostname","name","uptime","cloudkey_update_available","cloudkey_update_version","cloudkey_version","ubnt_device_type","udm_version","udm_update_version","udm_update_available"]
if _data:
for _k,_v in _data[0].items():
if _k in _wanted:
if type(_v) == bool:
_v = int(_v)
setattr(self,_k,_v)
def _get_device_by_mac(self,mac):
try:
return next(filter(lambda x: x.mac == mac,self._UNIFI_DEVICES)).name
except StopIteration:
return None
def _get_sites(self):
_data = self._API.get_sites()
for _site in _data:
if self._API.SITES and _site.get("name") not in self._API.SITES and _site.get("desc").lower() not in self._API.SITES:
continue
self._UNIFI_SITES.append(unifi_site(_PARENT=self,**_site))
def _get_ssidlist(self):
_dict = defaultdict(list)
for _ssid in self._UNIFI_SSIDS:
_dict[f"{_ssid.essid}@{_ssid._UNIFI_SITE.desc}"].append(_ssid)
_ret = []
for _ssid,_obj in _dict.items():
#pprint(_obj)
for _key in ("num_sta","ng_num_sta","na_num_sta","ng_tcp_packet_loss","na_tcp_packet_loss","ng_wifi_retries","na_wifi_retries","ng_wifi_latency","na_wifi_latency"):
_ret.append("|".join([_ssid,_key,str(sum(map(lambda x: getattr(x,_key,0),_obj)))]))
_signals = list(map(lambda x: getattr(x,"ng_avg_client_signal",0),filter(lambda x: x.radio == "ng",_obj)))
_ret.append("|".join([_ssid,"ng_avg_client_signal",str(mean(_signals if _signals else [0]))]))
_signals = list(map(lambda x: getattr(x,"na_avg_client_signal",0),filter(lambda x: x.radio == "na",_obj)))
_ret.append("|".join([_ssid,"na_avg_client_signal",str(mean(_signals if _signals else [0]))]))
_ret.append("|".join([_ssid,"channels",",".join(
sorted(
set(map(lambda x: str(getattr(x,"channel","0")),_obj))
,key = lambda x: int(x))
)]))
_ret.append("|".join([_ssid,"avg_client_signal",str(mean(map(lambda x: getattr(x,"avg_client_signal",0),_obj))) ]))
return _ret
def __str__(self):
_ret = ["<<<unifi_controller:sep(124)>>>"]
for _k,_v in self.__dict__.items():
if _k.startswith("_") or type(_v) not in (str,int,float):
continue
_ret.append(f"{_k}|{_v}")
## check udm
_has_udm = list(filter(lambda x: x.name == self.name,self._UNIFI_DEVICES))
if _has_udm:
_udm = _has_udm[0]
_udm._piggy_back = False
_ret.append(str(_udm))
_ret.append("<<<labels:sep(0)>>>")
_ret.append(f"{{\"unifi_device\":\"unifi-{self.type}\"}}")
## SITES ##
for _site in self._UNIFI_SITES:
_ret.append(str(_site))
_ret.append("<<<unifi_device_shortlist:sep(124)>>>")
for _device in self._UNIFI_DEVICES:
if _device._piggy_back:
_ret.append(_device._get_short_info())
## device list
## ssid list
_ret.append("<<<unifi_ssid_list:sep(124)>>>")
_ret += self._get_ssidlist()
if self._API.PIGGYBACK_ATTRIBUT.lower() != "none":
## PIGGYBACK DEVICES ##
for _device in self._UNIFI_DEVICES:
if _device._piggy_back and _device.adopted:
_ret.append(str(_device))
return "\n".join(_ret)
########################################
######
###### A P I
###### https://ubntwiki.com/products/software/unifi-controller/api
########################################
class unifi_controller_api(object):
def __init__(self,host,username,password,port,site,verify_cert,rawapi,piggybackattr,**kwargs):
self.host = host
self.url = f"https://{host}"
if port != 443:
self.url = f"https://{host}:{port}"
self._verify_cert = verify_cert
if not verify_cert:
requests.packages.urllib3.disable_warnings(category=InsecureRequestWarning)
self.RAW_API = rawapi
self.PIGGYBACK_ATTRIBUT = piggybackattr
self.SITES = site.lower().split(",") if site else None
self._session = requests.Session()
self.check_unifi_os()
self.login(username,password)
def check_unifi_os(self):
_response = self.request("GET",url=self.url,allow_redirects=False)
self.is_unifios= _response.status_code == 200 and _response.headers.get("x-csrf-token")
def get_sysinfo(self):
return self.get_data("/stat/sysinfo")
def get_sites(self):
return self.get_data("/stat/sites",site=None)
def get_portconfig(self,site):
return self.get_data("/rest/portconf",site=site)
def get_devices(self,site):
return self.get_data("/stat/device",site=site)
def login(self,username,password):
if self.is_unifios:
url=f"{self.url}/api/auth/login"
else:
url=f"{self.url}/api/login"
auth = {
"username" : username,
"password" : password,
"remember" : True
}
_response = self.request("POST",url=url,json=auth)
if _response.status_code == 404:
raise unifi_api_exception("API not Found try other Port or IP")
_json = _response.json()
if _json.get("meta",{}).get("rc") == "ok" or _json.get("status") == "ACTIVE":
return
raise unifi_api_exception("Login failed")
def get_data(self,path,site="default",method="GET",**kwargs):
_json = self.request(method=method,path=path,site=site,**kwargs).json()
_meta = _json.get("meta",{})
if _meta.get("rc") == "ok":
return _json.get("data",[])
raise unifi_api_exception(_meta.get("msg",_json.get("errors",repr(_json))))
def request(self,method,url=None,path=None,site=None,json=None,**kwargs):
if not url:
if self.is_unifios:
url = f"{self.url}/proxy/network/api"
else:
url = f"{self.url}/api"
if site is not None:
url += f"/s/{site}"
if path is not None:
url += f"{path}"
_request = requests.Request(method,url,json=json)
_prepped_request = self._session.prepare_request(_request)
else:
_request = requests.Request(method,url,json=json)
_prepped_request = _request.prepare()
_response = self._session.send(_prepped_request,verify=self._verify_cert,timeout=10,**kwargs)
if _response.status_code == 200 and hasattr(_response,"json") and self.RAW_API:
try:
pprint(_response.json())
except:
pass
return _response
########################################
######
###### M A I N
######
########################################
if __name__ == '__main__':
parser = create_default_argument_parser(description=__doc__)
parser.add_argument('-u', '--user', dest='username', required=True,
help='User to access the DSM.')
parser.add_argument('-p', '--password', dest='password', required=True,
help='Password to access the DSM.')
parser.add_argument('--ignore-cert', dest='verify_cert', action='store_false',
help='Do not verify the SSL cert')
parser.add_argument('-s','--site', dest='site', required=False,
help='Site')
parser.add_argument('--port', dest='port',type=int,default='443')
parser.add_argument('--piggyback', dest='piggybackattr',type=str,default='name')
parser.add_argument('--rawapi', dest='rawapi', action='store_true')
parser.add_argument("host",type=str,
help="""Host name or IP address of Unifi Controller""")
args = parser.parse_args()
print("<<<check_mk>>>")
print(f"Version: {__VERSION__}")
try:
_api = unifi_controller_api(**args.__dict__)
except socket.error as e:
pprint(e)
sys.exit(1)
if _api.is_unifios:
print("AgentOS: UnifiOS")
##pprint(_api.get_data("/stat/rogueap?within=4"))
##pprint(_api.get_data("/rest/user",site="default",method="GET"))
##pprint(_api.get_data("/stat/sta",site="default",method="GET"))
##sys.exit(0)
_controller = unifi_controller(_API=_api)
if args.rawapi == False:
print(_controller)
Reference in New Issue View Git Blame Copy Permalink