288 lines
8.7 KiB
Go
288 lines
8.7 KiB
Go
package main
|
|
|
|
import (
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"io/ioutil"
|
|
"log"
|
|
"net/http"
|
|
"strings"
|
|
"time"
|
|
|
|
_ "github.com/fatih/structs"
|
|
|
|
//_ "github.com/influxdata/influxdb1-client" // this is important because of the bug in go mod
|
|
client "github.com/influxdata/influxdb1-client/v2"
|
|
)
|
|
|
|
// UNMS API processing (Richtfunk)
|
|
func processUISPRiFu() ([]node, []link, error) {
|
|
// Variables for runtime
|
|
var links []link
|
|
var nodes []node
|
|
|
|
d := getDevices(conf.UISP.DevicesURL)
|
|
|
|
// API CALL 1 (get Device overview)
|
|
log.Println("Starting UISP API Crawler for Rifu devices")
|
|
log.Println("Getting device overview from UNMS API")
|
|
var u []unifiAPIResponse
|
|
if err := UnmsCallAPI("/devices", &u); err != nil {
|
|
return nil, nil, err
|
|
}
|
|
|
|
for i := range d.Devices {
|
|
time.Sleep(time.Second)
|
|
var dev unifiAPIResponse
|
|
var currentDevice device
|
|
for j := range u {
|
|
if strings.ToUpper(u[j].Identification.MAC) == strings.ToUpper(d.Devices[i].MAC) {
|
|
dev = u[j]
|
|
currentDevice = d.Devices[i]
|
|
}
|
|
}
|
|
isOnline := dev.Overview.Status == "active"
|
|
// END OF API CALL 1
|
|
|
|
// Getting details from UISP
|
|
log.Println("Getting device details for: ", d.Devices[i].Name)
|
|
var details unifiAPIDetails
|
|
if err := UnmsCallAPI("/devices/erouters/"+dev.Identification.ID, &details); err != nil {
|
|
return nil, nil, err
|
|
}
|
|
|
|
// Getting details for RiFu
|
|
log.Println("Getting details for RiFu Link for: ", d.Devices[i].Name)
|
|
var airmaxes []unifiAPIAirmax
|
|
if err := UnmsCallAPI("/devices/airmaxes/"+dev.Identification.ID+"/stations", &airmaxes); err != nil {
|
|
return nil, nil, err
|
|
}
|
|
// check if remote mac address is part of our published network
|
|
for i := range airmaxes {
|
|
if isRemoteMACpublished(airmaxes[i].DeviceIdentification.MAC, d.Devices) {
|
|
links = UnmsAddLink(dev, airmaxes[i], links)
|
|
}
|
|
}
|
|
// END OF API CALL 3
|
|
|
|
// Get info from json file (static)
|
|
nodes = append(nodes, node{
|
|
Firstseen: dev.Overview.CreatedAt.Format(iso8601),
|
|
Lastseen: dev.Overview.LastSeen.Format(iso8601),
|
|
IsOnline: isOnline,
|
|
IsGateway: false,
|
|
Clients: 0,
|
|
ClientsWifi24: 0,
|
|
ClientsWifi5: 0,
|
|
ClientsOther: 0,
|
|
RootFSUsage: 0,
|
|
LoadAVG: details.Overview.CPU / 100,
|
|
MemoryUsage: details.Overview.RAM / 100,
|
|
Uptime: dev.Identification.Started.Format(iso8601),
|
|
GatewayNexthop: currentDevice.GatewayNexthop,
|
|
Gateway: currentDevice.Gateway,
|
|
Location: ¤tDevice.Location,
|
|
NodeID: strings.ReplaceAll(dev.Identification.MAC, ":", ""),
|
|
MAC: dev.Identification.MAC,
|
|
Adresses: UnmsGetAddresses(details.IPAddress),
|
|
Domain: currentDevice.Domain,
|
|
Hostname: "[RiFu] " + details.Identification.Name,
|
|
Owner: "Freifunk Rhein-Sieg",
|
|
Firmware: firmware{
|
|
Base: "Ubiquiti - Stock",
|
|
Release: details.Firmware.Current,
|
|
},
|
|
Autoupdater: autoupdater{
|
|
Enabled: false,
|
|
Branch: "stable",
|
|
},
|
|
NProc: 1,
|
|
Model: details.Identification.Model,
|
|
})
|
|
}
|
|
return nodes, links, nil
|
|
}
|
|
|
|
func processUISPRouter() ([]node, error) {
|
|
time.Sleep(time.Second)
|
|
// Variables for runtime
|
|
var nodes []node
|
|
d := getDevices(conf.UISP.RouterURL)
|
|
|
|
// API CALL 1, get all devices list from UNMS
|
|
log.Println("Get all Routers from UISP")
|
|
var u []unifiAPIResponse
|
|
if err := UnmsCallAPI("/devices", &u); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
// Get Information for devices device
|
|
for i := range d.Devices {
|
|
var dev unifiAPIResponse
|
|
var currentDevice device
|
|
for j := range u {
|
|
if strings.ToUpper(u[j].Identification.MAC) == strings.ToUpper(d.Devices[i].MAC) {
|
|
dev = u[j]
|
|
currentDevice = d.Devices[i]
|
|
}
|
|
}
|
|
|
|
isOnline := dev.Overview.Status == "active"
|
|
|
|
// API CALL FOR ROUTER DETAILS (Interface RX/TX)
|
|
log.Println("Getting details of ", d.Devices[i].Name, "from UISP API")
|
|
var details unifiAPIDetails
|
|
if err := UnmsCallAPI("/devices/erouters/"+dev.Identification.ID, &details); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
// API CALL FOR DEVICE STATISTICS (CPU, RAM)
|
|
log.Println("Getting statistics of ", d.Devices[i].Name, "from UISP API")
|
|
var statistics UNMSstatistics
|
|
if err := UnmsCallAPI("/devices/"+dev.Identification.ID+"/statistics?interval=hour", &statistics); err != nil {
|
|
return nil, err
|
|
}
|
|
// API CALL FOR DHCP LEASES
|
|
log.Println("Getting DHCP Leases of ", d.Devices[i].Name, "from UNMS API")
|
|
var dhcpleases UNMSdhcp
|
|
if isOnline {
|
|
if err := UnmsCallAPI("/devices/erouters/"+dev.Identification.ID+"/dhcp/leases", &dhcpleases); err != nil {
|
|
return nil, err
|
|
}
|
|
} else {
|
|
log.Println("Router ist offline, skipping DHCP Leases")
|
|
}
|
|
|
|
// fields := map[string]interface{}{}
|
|
fields := make(map[string]any)
|
|
tags := map[string]string{
|
|
"hostname": strings.ReplaceAll(d.Devices[i].Name, " ", "-"),
|
|
"nodeid": strings.ReplaceAll(dev.Identification.MAC, ":", ""),
|
|
}
|
|
// Generate fields for all network interfaces
|
|
for eth := range details.Interfaces {
|
|
interface_name_rx := ("rate.rx" + "_" + details.Interfaces[eth].Identification.Name)
|
|
interface_name_tx := ("rate.tx" + "_" + details.Interfaces[eth].Identification.Name)
|
|
fields[interface_name_rx] = details.Interfaces[eth].Statistics.Rxrate
|
|
fields[interface_name_tx] = details.Interfaces[eth].Statistics.Txrate
|
|
}
|
|
|
|
// set default values if we can't get statistics
|
|
fields["cpu"] = 0
|
|
fields["load"] = float64(0)
|
|
fields["ram"] = 0
|
|
|
|
if isOnline {
|
|
// Generate fields for all Statistics
|
|
load := (float64(statistics.CPU.AVG[0].Y) / float64(100))
|
|
fields["cpu"] = statistics.CPU.AVG[0].Y
|
|
fields["load"] = load
|
|
fields["ram"] = statistics.RAM.AVG[0].Y
|
|
}
|
|
|
|
// Generate field for DHCP Leases
|
|
fields["clients.total"] = len(dhcpleases)
|
|
|
|
// Generate Dataponts
|
|
point, err := client.NewPoint(
|
|
"node",
|
|
tags,
|
|
fields,
|
|
time.Now(),
|
|
)
|
|
if err != nil {
|
|
log.Fatalln("Error: ", err)
|
|
}
|
|
if conf.General.InfluxEnabled {
|
|
sendInfluxBatchDataPoint(point, conf.General.FreifunkInfluxPort)
|
|
}
|
|
// Get info from json file (static)
|
|
nodes = append(nodes, node{
|
|
Firstseen: dev.Overview.CreatedAt.Format(iso8601),
|
|
Lastseen: dev.Overview.LastSeen.Format(iso8601),
|
|
IsOnline: isOnline,
|
|
IsGateway: false,
|
|
Clients: 0,
|
|
ClientsWifi24: 0,
|
|
ClientsWifi5: 0,
|
|
ClientsOther: 0,
|
|
RootFSUsage: 0,
|
|
LoadAVG: details.Overview.CPU / 100,
|
|
MemoryUsage: details.Overview.RAM / 100,
|
|
Uptime: dev.Identification.Started.Format(iso8601),
|
|
GatewayNexthop: currentDevice.GatewayNexthop,
|
|
Gateway: currentDevice.Gateway,
|
|
Location: ¤tDevice.Location,
|
|
NodeID: strings.ReplaceAll(dev.Identification.MAC, ":", ""),
|
|
MAC: dev.Identification.MAC,
|
|
Adresses: UnmsGetAddresses(details.IPAddress),
|
|
Domain: currentDevice.Domain,
|
|
Hostname: "[VPN-Router] " + details.Identification.Name,
|
|
Owner: "Freifunk Rhein-Sieg",
|
|
Firmware: firmware{
|
|
Base: "Ubiquiti - Stock",
|
|
Release: details.Firmware.Current,
|
|
},
|
|
Autoupdater: autoupdater{
|
|
Enabled: false,
|
|
Branch: "stable",
|
|
},
|
|
NProc: 1,
|
|
Model: details.Identification.Model,
|
|
})
|
|
}
|
|
return nodes, nil
|
|
}
|
|
|
|
func UnmsCallAPI(url string, i any) error {
|
|
time.Sleep(time.Second)
|
|
request, err := http.NewRequest(http.MethodGet, conf.UISP.UnmsAPIURL+url, nil)
|
|
if err != nil {
|
|
return errors.New(fmt.Sprint("can't set request", conf.UISP.UnmsAPIURL+url))
|
|
}
|
|
//log.Println(conf.UISP.UnmsAPIURL + url)
|
|
request.Header.Set("x-auth-token", conf.UISP.APItoken)
|
|
client := &http.Client{}
|
|
response, err := client.Do(request)
|
|
if err != nil {
|
|
return fmt.Errorf("can't get request %s with x-auth-token %s", conf.UISP.UnmsAPIURL+url, conf.UISP.APItoken)
|
|
}
|
|
if response.StatusCode != 200 {
|
|
log.Println("Can't call UNMS API, check token and URL. Skipping device. HTTP Status: ", response.StatusCode)
|
|
return nil
|
|
}
|
|
data, err := ioutil.ReadAll(response.Body)
|
|
defer response.Body.Close()
|
|
if err != nil {
|
|
return fmt.Errorf("can't read response body: %+v", response.Body)
|
|
}
|
|
// no error occurred, unmarshal to struct
|
|
return json.Unmarshal(data, &i)
|
|
}
|
|
|
|
func UnmsGetAddresses(ip string) []string {
|
|
var adresses []string
|
|
adresses = append(adresses, strings.Split(ip, "/")[0])
|
|
return adresses
|
|
}
|
|
|
|
func UnmsAddLink(dev unifiAPIResponse, airmaxes unifiAPIAirmax, links []link) []link {
|
|
for i := range links {
|
|
if links[i].SourceAddr == airmaxes.DeviceIdentification.MAC {
|
|
// link already exists
|
|
return links
|
|
}
|
|
}
|
|
links = append(links, link{
|
|
Type: "wifi",
|
|
Source: strings.ReplaceAll(dev.Identification.MAC, ":", ""),
|
|
Target: strings.ReplaceAll(airmaxes.DeviceIdentification.MAC, ":", ""),
|
|
SourceTQ: airmaxes.Statistics.LinkScore,
|
|
TargetTQ: airmaxes.Statistics.LinkScore,
|
|
SourceAddr: dev.Identification.MAC,
|
|
TargetAddr: airmaxes.DeviceIdentification.MAC,
|
|
})
|
|
return links
|
|
}
|