.drone.jsonnet

@@ -0,0 +1,53 @@
+local pipeline(os, arch) = {
+  kind: "pipeline",
+  name: os + "/" + arch,
+  platform: {
+    "os": os,
+    "arch": arch,
+  },
+  steps: [{
+      name: "compile " + os + "/" + arch,
+      image: "golang:1.20.3-alpine3.17",
+      environment: {
+        "GOOS": os,
+        "GOARCH": arch,
+        "CGO_ENABLED": "0",
+      },
+      commands: [
+        'go build -ldflags "-s -w -X main.version=${DRONE_TAG##v}" -trimpath -o release/' + os + "/" + arch + "/ubnt-freifunk-map-api .",
+        "tar -cvzf release/ubnt-freifunk-map-api_"+ os + "-" + arch + ".tar.gz -C release/" + os + "/" + arch + " ubnt-freifunk-map-api" 
+      ],
+    },
+    {
+      name: "gitea_release " + os + "/" + arch,
+      image: "plugins/gitea-release",
+      settings: {
+        api_key: { "from_secret": "gitea_api_key" },
+        base_url: "https://git.freifunk-rhein-sieg.net",
+        files: "release/*.tar.gz"
+      },
+      when: {
+        event: "tag"
+      },
+    },
+    {
+      name: "upload to gitea container registry",
+      image: "plugins/docker:latest",
+      settings: {
+        repo: "git.freifunk-rhein-sieg.net/freifunk-troisdorf/ubnt-freifunk-map-api",
+        registry: "git.freifunk-rhein-sieg.net",
+        username: { "from_secret": "docker_username" },
+        password: { "from_secret": "docker_password" },
+        tags: ["latest"],
+        auto_tag: true,
+      },
+      when: {
+        event: "tag"
+      },
+    },
+  ],
+};
+
+[
+  pipeline("linux", "amd64")
+]

.woodpecker.yml

@@ -1,25 +0,0 @@
----
-platform: linux/arm64
-
-pipeline:
-  build:
-    image: golang
-    environment:
-      - GOOS=linux
-      - GOARCH=amd64
-    commands:
-      - go build -ldflags "-s -w -X main.version=${CI_COMMIT_TAG}" -trimpath -o release/ubnt-freifunk-map-api .
-
-  docker:
-    image: woodpeckerci/plugin-docker-buildx
-    settings:
-      platforms: linux/amd64
-      registry: git.freifunk-rhein-sieg.net
-      repo: git.freifunk-rhein-sieg.net/freifunk-troisdorf/ubnt-freifunk-map-api
-      username:
-        from_secret: gitea_user
-      password:
-        from_secret: gitea_token
-      tags: ${CI_COMMIT_TAG}
-    when:
-      - branch: master

Dockerfile

@@ -1,7 +1,7 @@
 FROM alpine:3.12.3
 WORKDIR /opt/
 
-ADD ./release/ubnt-freifunk-map-api /opt/ubnt-freifunk-map-api
+ADD ./release/*/*/ubnt-freifunk-map-api /opt/ubnt-freifunk-map-api
 RUN chmod +x /opt/ubnt-freifunk-map-api
 
 EXPOSE 3000

README.md

@@ -1,17 +1,12 @@
 # Freifunk Meshviewer Unifi Access Points und Richtfunkstrecken import
 
-Dieses tool Importiert Nodes für die Freifunk Map aus den APIs UISP (Richtfunk) & Unifi (Access Points).
+Dieses tool Importiert Nodes für die Freifunk Map aus den APIs UNMS (Richtfunk) & Unifi (Access Points)
-Ebenfalls ist der Import statischer devices möglich. Da diese alle in unerem Proxmox cluster laufen, werden Statistikdaten aus der Proxmox InfluxDB geholt.
-
-Alle Config dateien müssen per http erreichbar sein (z.B. in einem Git)
-Für Troisdorf werden diese Dateien hier gepflegt: https://git.freifunk-rhein-sieg.net/Freifunk-Troisdorf/ubnt-api-devices
-Für die Rhein-Sieg-Map hier: https://git.freifunk-rhein-sieg.net/Freifunk-Rhein-Sieg/ubnt-api-devices
 
 ## Config
 
-### Unifi Access Points (unifi_devices.json)
+### Unifi Access Points (ucDevices.json)
 
-In der Datei unifi_devices.json können die Access Points gepflegt werden, die auf der Freifunk Map erscheinen sollen.
+In der Datei ucDevices.json können die Access Points gepflegt werden, die auf der Freifunk Map erscheinen sollen.
 
 Hierzu muss die Datei im json Format erweitert werden.
 
@@ -37,9 +32,9 @@ Erklärung:
 * linked_to: (Optional) Die MAC Adresse des Routers an dem der AP angeschlossen ist. Normalerweise gateway_nexthop mit Doppelpunkten. Wenn nicht gesetzt wird kein Link auf der Map angezeigt.
 * domain: Die Domain in der sich der AP befindet. (tdf, inn, flu)
 
-### UISP Richtfunkstrecken
+### UNMS Richtfunkstrecken
 
-In der Datei rifu_devices.json können die Richtfunkstrecken gepflegt werden, die auf der Freifunk Map erscheinen sollen.
+In der Datei devices.json können die Richtfunkstrecken gepflegt werden, die auf der Freifunk Map erscheinen sollen.
 
 ```json
 {
@@ -61,44 +56,11 @@ Erklärung:
 * gateway:    Im Normalfall die NodeID des Supernodes (zu finden in der MAP)
 * domain: Die Domain in der sich der AP befindet. (tdf, inn, flu)
 
-### UISP Router
-
-In dieser datei werden die Router (meist ER-X) gepflegt. Diese Daten werden dann ebenfalls aus der UISP API Importiert.
-
-```json
-{
-        "name": "Rathaus Uplink",
-        "mac": "18:e8:29:ad:9a:34",
-        "gateway_nexthop": "18e8292f7de6",
-        "gateway": "a28cae6ff604",
-        "domain": "tdf",
-        "location": {
-          "longitude":7.149406208,
-          "latitude":50.817093402
-        }
-      },
-```
-
-### Gateways.json
-
-Hier werden Statische Geräte eingetragen die auf dem Proxmox Cluster laufen.
-
-```json
-{
-      "name": "VPN01",
-      "fqdn": "vpn01.fftdf.de",
-      "mac": "00:00:00:00:00:01",
-      "domain": "VPN1",
-      "adresses": ["5.9.220.114"]
-    },
-```
-
 ### Config.json
 
 Es gibt 3 Module die Ein/Ausgeschatet werden können:
 * UNMS
 * Unifi
 * Meshviewer
-* Gateways
 
 Die Funktion Meshviewer importiert die vorhandenen meshviewer.json und manipuliert dort die Userzahlen. Sobald ein Access Point einen Node aus einer Meshviwer.json als "gateway_nexthop" eingetragen hat, werden die Clients an dem verbundenen Access Point und nicht mehr am Offloader angezeigt.

example.config.json

@@ -5,17 +5,14 @@
         "APItoken": "UNMS API TOKEN",
         "devicesURL": "https://git.freifunk-rhein-sieg.net/Freifunk-Troisdorf/ubnt-freifunk-map-api/raw/branch/master/example.devices.json"
     },
-    "unifi": [
+    "unifi": {
-        {
-        "name": "Unifi Freifunk Troisdorf",
         "enabled": false,
         "displayusers": true,
         "APIUrl": "https://unifi.freifunk-troisdorf.de",
         "user": "APIuser",
         "password": "PASSWORD",
         "ucDevicesURL": "https://git.freifunk-rhein-sieg.net/Freifunk-Troisdorf/ubnt-freifunk-map-api/raw/branch/master/example.ucDevices.json"
-        }
+    },
-    ],
     "meshviewer": {
         "enabled": false,
         "files": [

influx.go

@@ -1,63 +0,0 @@
-package main
-
-import (
-	"encoding/json"
-	"log"
-
-	client "github.com/influxdata/influxdb1-client/v2"
-)
-
-// Create InfluxDB Client
-func influxDBClient(port string) client.Client {
-	c, err := client.NewHTTPClient(client.HTTPConfig{
-		Addr: conf.General.InfluxURL + ":" + port,
-	})
-	if err != nil {
-		log.Fatalln("Error: ", err)
-	}
-	return c
-}
-
-// Get a single Datapoint from InfluxDB
-func getInfluxDataPoint(dp string, h string, p string) float64 {
-
-	//Build the Query
-	query := "SELECT last(" + dp + ") FROM system WHERE host = '" + h + "'"
-
-	c := influxDBClient(p)
-	q := client.NewQuery(query, "udp", "s")
-	response, err := c.Query(q)
-	if err != nil {
-		log.Println("Influx query error!")
-	}
-	res := 0.0
-	if len(response.Results) > 0 {
-		res, err := response.Results[0].Series[0].Values[0][1].(json.Number).Float64()
-		if err != nil {
-			log.Println("Error in type conversion")
-		}
-		return res
-	}
-	return res
-}
-
-// Send Datapoints to InfluxDB, point map and InfluxDB Port needed
-func sendInfluxBatchDataPoint(point *client.Point, influxPort string) {
-
-	// Open connection to InfluxDB
-	bp, err := client.NewBatchPoints(client.BatchPointsConfig{
-		Database:  "freifunk",
-		Precision: "s",
-	})
-	if err != nil {
-		log.Fatalln("Error: ", err)
-	}
-
-	bp.AddPoint(point)
-	c := influxDBClient(influxPort)
-	err = c.Write(bp)
-	if err != nil {
-		log.Fatal(err)
-	}
-	//
-}

main.go

@@ -9,28 +9,21 @@ import (
 	"net/http"
 	"net/http/cookiejar"
 	"os"
-	"sync"
 	"time"
 
 	_ "git.nils.zone/nils/prettify"
 )
 
 const (
-	iso8601       = "2006-01-02T15:04:05-0700"
+	iso8601 = "2006-01-02T15:04:05-0700"
-	fetchInterval = 1 * time.Minute
 )
 
 // flags
-var (
-	lastFetchTime time.Time
-	cacheMutex    sync.Mutex
-	cacheNodes    []node
-	cacheLinks    []link
-)
 var configPath = flag.String("configPath", "config.json", "Path to config.json")
 var version = "development"
 var delay time.Duration = 60 * time.Second
 var conf = loadconfig(*configPath)
+var ucDev = getDevices(conf.Unifi.UCDevicesURL)
 
 func main() {
 	log.Printf("starting version %s...\n", version)
@@ -45,52 +38,56 @@ func main() {
 	// start API processing (runs in a loop)
 	go func() {
 		if err := processAPIs(); err != nil {
-			log.Fatalln("API processing failed, error is: ", err)
+			log.Fatalln("API processing failed, error is", err)
 		}
 		tick := time.Tick(delay)
 		for range tick {
 			if err := processAPIs(); err != nil {
-				log.Fatalln("API processing failed, error is: ", err)
+				log.Fatalln("API processing failed, error is", err)
 			}
 		}
 	}()
+	//processUNMSAPIRouter()
+	//createMetrics(influxDBClient())
 	// start webserver on Port 3000
 	serveJSON()
 }
 
+func loadconfig(file string) config {
+	var config config
+	configFile, err := os.Open(file)
+	if err != nil {
+		log.Fatalln(err)
+	}
+	jsonParse := json.NewDecoder(configFile)
+	jsonParse.Decode(&config)
+	return config
+}
+
+// int to bool converter
+func itob(i int) bool {
+	return i == 1
+}
+
 func processAPIs() error {
 	var nodes []node
 	var links []link
 
-	if conf.UISP.Enabled {
+	if conf.Unms.Enabled {
-		log.Println("Processing UISP")
+		log.Println("Processing UNMS")
-		//Process UISP RiFu Nodes
+		unmsNodes, unmsLinks := processUNMSAPI()
-		uispNodes, uispLinks, err := processUISPRiFu()
+		unmsRouters, err := processUNMSAPIRouter()
 		if err != nil {
 			return err
 		}
-		//Process UISP Routers (like EDGE Router)
+		nodes = append(nodes, unmsNodes...)
-		uispRouters, err := processUISPRouter()
+		nodes = append(nodes, unmsRouters...)
-		if err != nil {
+		links = append(links, unmsLinks...)
-			return err
-		}
-		nodes = append(nodes, uispNodes...)
-		nodes = append(nodes, uispRouters...)
-		links = append(links, uispLinks...)
 	}
-	if len(conf.Unifi) > 0 {
+	if conf.Unifi.Enabled {
-		log.Println("Anazahl der Unifi Server:", len(conf.Unifi))
+		log.Println("Processing Unifi")
-		for i := range conf.Unifi {
+		ucNodes, _ := processUcAPIs()
-			if conf.Unifi[i].Enabled {
+		nodes = append(nodes, ucNodes...)
-				log.Println("Processing Unifi-Server: ", conf.Unifi[i].Name)
-				//Process Unifi Nodes
-				unifiNodes, _, err := processUnifiAPI(i)
-				if err != nil {
-					return err
-				}
-				nodes = append(nodes, unifiNodes...)
-			}
-		}
 	}
 	if conf.Meshviewer.Enabled {
 		log.Println("Processing Meshviewer")
@@ -100,7 +97,6 @@ func processAPIs() error {
 	}
 	if conf.Gateways.Enabled {
 		log.Println("Processing Gateways")
-		//Process Static Gateways from Json
 		gwNodes := processGateways()
 		nodes = append(nodes, gwNodes...)
 	}
@@ -117,30 +113,17 @@ func processAPIs() error {
 	if err := o.writeToFile(); err != nil {
 		log.Fatalln(err)
 	}
-
+	// get outages to serve as .csv
+	l := getUNMSLogs()
+	err := writeOutagesToCSV(l)
+	if err != nil {
+		log.Println("Error writing outages.csv")
+	}
 	// we're done here
 	log.Println("...done")
 	return nil
 }
 
-func loadconfig(file string) config {
-	var config config
-	configFile, err := os.Open(file)
-	if err != nil {
-		log.Fatalln("Failed loding Config file: ", err)
-	}
-	jsonParse := json.NewDecoder(configFile)
-	if err := jsonParse.Decode(&config); err != nil {
-		log.Fatalln(err)
-	}
-	return config
-}
-
-// int to bool converter
-func itob(i int) bool {
-	return i == 1
-}
-
 // function to get file from meshviewer
 func getFile(url string) []byte {
 	resp, err := http.Get(url)

meshviewer.go

@@ -3,7 +3,6 @@ package main
 import (
 	"encoding/json"
 	"log"
-	"time"
 )
 
 func getMeshviewerJSON(url string) (mvDevices, error) {
@@ -130,31 +129,18 @@ func addmvDevices(d mvDevices) ([]node, []link) {
 }
 
 func getMeshviewer() ([]node, []link) {
-	cacheMutex.Lock()
-	defer cacheMutex.Unlock()
-
-	// Überprüfen, ob die Daten kürzlich aktualisiert wurden
-	if time.Since(lastFetchTime) < fetchInterval {
-		return cacheNodes, cacheLinks
-	}
-
 	var nodes []node
 	var links []link
 
 	for i := range conf.Meshviewer.Files {
+		log.Println("Hole Meshviewer JSON von: ", conf.Meshviewer.Files[i].URL)
 		m, err := getMeshviewerJSON(conf.Meshviewer.Files[i].URL)
 		if err != nil {
-			return cacheNodes, cacheLinks
+			return nodes, links
 		}
 		mvNodes, mvLinks := addmvDevices(m)
 		nodes = append(nodes, mvNodes...)
 		links = append(links, mvLinks...)
 	}
-
+	return nodes, links
-	// Cache aktualisieren
-	cacheNodes = nodes
-	cacheLinks = links
-	lastFetchTime = time.Now()
-
-	return cacheNodes, cacheLinks
 }

outages.go

@@ -0,0 +1,37 @@
+package main
+
+import (
+	"encoding/csv"
+	"log"
+	"os"
+)
+
+func getUNMSLogs() UNMSLogResponse {
+
+	var l UNMSLogResponse
+	log.Println("Get Outages from UNMS")
+	err := UnmsCallAPI("/outages?count=100&page=1&type=outage", &l)
+	if err != nil {
+		log.Fatalln("Error calling Outages API")
+	}
+	return l
+}
+
+func writeOutagesToCSV(l UNMSLogResponse) error {
+	csvFile, err := os.Create("output/outages.csv")
+	if err != nil {
+		return err
+	}
+	writer := csv.NewWriter(csvFile)
+
+	for _, o := range l.Items {
+		var row []string
+		row = append(row, o.StartTime.Format("02.01.2006 15:04:05"))
+		row = append(row, o.EndTime.Format("02.01.2006 15:04:05"))
+		row = append(row, o.Site.Name)
+		row = append(row, o.Device.DisplayName)
+		writer.Write(row)
+	}
+	writer.Flush()
+	return nil
+}

staticDevices.go

@@ -4,66 +4,15 @@ import (
 	"log"
 	"strings"
 	"time"
-
-	client "github.com/influxdata/influxdb1-client/v2"
 )
 
 func processGateways() []node {
 	d := getDevices(conf.Gateways.GatewaysURL)
 	var nodes []node
-
 	for i := range d.Devices {
 		log.Println("Processing Static Device: ", d.Devices[i].Name)
-		currentDevice := d.Devices[i]
-
-		//Collect data
-		//Calulate Memory (%)
-		mem := getInfluxDataPoint("mem", currentDevice.FQDN, conf.General.ProxmoxInfluxPort)
-		maxmem := getInfluxDataPoint("maxmem", currentDevice.FQDN, conf.General.ProxmoxInfluxPort)
-		memoryMap := mem / maxmem
-		memory := memoryMap * 100
-		// Get Network
-		rx := getInfluxDataPoint("netin", currentDevice.FQDN, conf.General.ProxmoxInfluxPort)
-		tx := getInfluxDataPoint("netout", currentDevice.FQDN, conf.General.ProxmoxInfluxPort)
-		// Get CPU (%)
-		cpuMap := getInfluxDataPoint("cpu", currentDevice.FQDN, conf.General.ProxmoxInfluxPort)
-		cpu := cpuMap * 100
-		//Uptime (seconds)
-		uptime := getInfluxDataPoint("uptime", currentDevice.FQDN, conf.General.ProxmoxInfluxPort)
-		t := time.Duration(uptime * float64(time.Second))
-		up := time.Now().Add(-t)
-
-		// fields := map[string]interface{}{}
-		fields := make(map[string]any)
-		tags := map[string]string{
-			"hostname": strings.ReplaceAll(d.Devices[i].Name, " ", "-"),
-			"nodeid":   strings.ReplaceAll(d.Devices[i].MAC, ":", ""),
-		}
-
-		//Build fields for InfluxDB
-		fields["load"] = cpu
-		fields["ram"] = int(memory)
-		fields["time.up"] = int(uptime)
-		//Network
-		fields["traffic.rx.bytes"] = int(rx)
-		fields["traffic.tx.bytes"] = int(tx)
-
-		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)
-		}
-
-		//Build Nodes
 		nodes = append(nodes, node{
-			Firstseen:      up.Format(iso8601),
+			Firstseen:      time.Now().Format(iso8601),
 			Lastseen:       time.Now().Format(iso8601),
 			IsOnline:       true,
 			IsGateway:      true,
@@ -72,14 +21,13 @@ func processGateways() []node {
 			ClientsWifi5:   0,
 			ClientsOther:   0,
 			RootFSUsage:    0,
-			LoadAVG:        cpuMap,
+			LoadAVG:        0,
-			MemoryUsage:    memoryMap,
+			MemoryUsage:    0,
-			Uptime:         up.Format(iso8601),
+			Uptime:         time.Now().Format(iso8601),
-			GatewayNexthop: "",
+			GatewayNexthop: "00:00:00:00:00",
-			Gateway:        "",
+			Gateway:        "00:00:00:00:00",
 			NodeID:         strings.ReplaceAll(d.Devices[i].MAC, ":", ""),
 			MAC:            d.Devices[i].MAC,
-			Adresses:       d.Devices[i].Adresses,
 			Domain:         d.Devices[i].Domain,
 			Hostname:       "[Gateway] " + d.Devices[i].Name,
 			Owner:          "Freifunk Troisdorf",

types.go

@@ -10,20 +10,21 @@ import (
 )
 
 type config struct {
-	General struct {
+	Unms struct {
-		InfluxEnabled      bool   `json:"influx_enabled"`
-		FreifunkInfluxPort string `json:"freifunk_influx_port"`
-		ProxmoxInfluxPort  string `json:"proxmox_influx_port"`
-		InfluxURL          string `json:"influx_url"`
-	}
-	UISP struct {
 		Enabled    bool   `json:"enabled"`
 		UnmsAPIURL string `json:"unmsAPIUrl"`
 		APItoken   string `json:"APItoken"`
 		DevicesURL string `json:"devicesURL"`
 		RouterURL  string `json:"routerURL"`
 	} `json:"unms"`
-	Unifi      []UnifiServer `json:"unifi"`
+	Unifi struct {
+		Enabled      bool   `json:"enabled"`
+		DisplayUsers bool   `json:"displayusers"`
+		APIURL       string `json:"APIUrl"`
+		User         string `json:"user"`
+		Password     string `json:"password"`
+		UCDevicesURL string `json:"ucDevicesURL"`
+	} `json:"unifi"`
 	Meshviewer struct {
 		Enabled bool `json:"enabled"`
 		Files   []struct {
@@ -37,19 +38,8 @@ type config struct {
 	} `json:"gateways"`
 }
 
-type UnifiServer struct {
-	Name         string `json:"name"`
-	Enabled      bool   `json:"enabled"`
-	DisplayUsers bool   `json:"displayusers"`
-	APIURL       string `json:"APIUrl"`
-	User         string `json:"user"`
-	Password     string `json:"password"`
-	UCDevicesURL string `json:"ucDevicesURL"`
-}
-
 type device struct {
 	Name           string `json:"name"`
-	FQDN           string `json:"fqdn"`
 	MAC            string `json:"mac"`
 	GatewayNexthop string `json:"gateway_nexthop"`
 	LinkedTo       string `json:"linked_to"`
@@ -59,7 +49,6 @@ type device struct {
 		Longitude float64 `json:"longitude"`
 		Latitude  float64 `json:"latitude"`
 	} `json:"location"`
-	Adresses []string `json:"adresses"`
 }
 type devices struct {
 	Devices []device `json:"devices"`
@@ -334,26 +323,21 @@ type XY struct {
 	Y int `json:"y"`
 }
 
-type AvgMax struct {
-	AVG []XY `json:"avg"`
-	MAX []XY `json:"max"`
-}
-
 type UNMSstatistics struct {
 	Period   int `json:"period"`
 	Interval struct {
 		Start int `json:"start"`
 		End   int `json:"end"`
 	} `json:"interval"`
-	CPU        AvgMax `json:"cpu"`
+	CPU        []XY `json:"cpu"`
-	RAM        AvgMax `json:"ram"`
+	RAM        []XY `json:"ram"`
-	Errors     AvgMax `json:"errors"`
+	Errors     []XY `json:"errors"`
 	Interfaces []struct {
 		ID       string `json:"id"`
 		Priority int    `json:"priority"`
 		Name     string `json:"name"`
-		Receive  AvgMax `json:"receive"`
+		Receive  []XY   `json:"receive"`
-		Transmit AvgMax `json:"transmit"`
+		Transmit []XY   `json:"transmit"`
 	} `json:"interfaces"`
 }
 

unifi.go

@@ -10,32 +10,28 @@ import (
 	"strconv"
 	"strings"
 	"time"
-
-	client "github.com/influxdata/influxdb1-client/v2"
 )
 
 // Unifi Controller API processing
-func processUnifiAPI(s int) ([]node, []link, error) {
+func processUcAPIs() ([]node, []link) {
 	//get list of Unifi devices to display
 	var nodes []node
 	var links []link
-	d := getDevices(conf.Unifi[s].UCDevicesURL)
+	d := getDevices(conf.Unifi.UCDevicesURL)
 
 	//call Unifi Controller
-	ucAPI := UnifiNewAPI(conf.Unifi[s].User, conf.Unifi[s].Password, conf.Unifi[s].APIURL)
+	ucAPI := UnifiNewAPI(conf.Unifi.User, conf.Unifi.Password, conf.Unifi.APIURL)
 	//login
-	if err := ucAPI.ucLogin(); err != nil {
+	ucAPI.ucLogin()
-		return nil, nil, err
-	}
 	//get all Sites from Controller
 	sites, err := ucAPI.ucGetSites()
 	if err != nil {
-		return nil, nil, err
+		log.Println(err)
 	}
 	//get all devices in all sites
 	devices, err := ucAPI.ucGetDevices(sites)
 	if err != nil {
-		return nil, nil, err
+		log.Println(err)
 	}
 
 	//build nodes struct
@@ -49,127 +45,63 @@ func processUnifiAPI(s int) ([]node, []link, error) {
 				currentJSONDevice = jsonDevice
 			}
 		}
-
 		if isRemoteMACpublished(jsonDevice.MAC, d.Devices) {
 			//hier muss gecheckt werden ob der link valide ist
 			if checkMeshviewerLink(jsonDevice.LinkedTo) {
 				links = UnifiAddLink(jsonDevice, links)
 			}
 		}
-
+		load, err := strconv.ParseFloat(currentDevice.Sysstats.CPU, 64)
-		isOnline := currentDevice.State == 1
+		if err != nil {
-		var load float64
+			fmt.Println("Error: ", currentDevice.Name)
-		var mem float64
+			//log.Fatalln(err)
-		var cpu float64
+			load = 0
-		if isOnline {
+		}
-			load, err = strconv.ParseFloat(currentDevice.Sysstats.CPU, 64)
+		mem, err := strconv.ParseFloat(currentDevice.Sysstats.Memory, 64)
-			cpu = load * 100
+		if err != nil {
-			if err != nil {
+			//log.Fatalln(err)
-				log.Println("Error psrsing CPU of device ", currentDevice.Name)
+			load = 0
-				log.Println(err)
-				load = 0
-				cpu = 0
-			}
-			mem, err = strconv.ParseFloat(currentDevice.Sysstats.Memory, 64)
-			if err != nil {
-				log.Println("Error parsing Memory of device ", currentDevice.Name)
-				log.Println(err)
-				mem = 0
-			}
 		}
-
 		var model = lookupModels(currentDevice.Model)
 		var clients int
-		if conf.Unifi[s].DisplayUsers {
+		if conf.Unifi.DisplayUsers {
 			clients = currentDevice.Users
 		}
-
+		nodes = append(nodes, node{
-		//// INFLUX START
+			Firstseen:      "0",
-		// fields := map[string]interface{}{}
+			Lastseen:       time.Unix(int64(currentDevice.LastSeen), 0).Format(iso8601),
-		fields := make(map[string]any)
+			IsOnline:       itob(currentDevice.State),
-		tags := map[string]string{
+			IsGateway:      false,
-			"hostname": strings.ReplaceAll(currentDevice.Name, " ", "-"),
+			Clients:        clients,
-			"nodeid":   strings.ReplaceAll(currentDevice.Mac, ":", ""),
+			ClientsWifi24:  0,
-		}
+			ClientsWifi5:   0,
-		// Generate fields for all network interfaces (not availible for Unifi Nodes)
+			ClientsOther:   clients,
-		//for eth := range details.Interfaces {
+			RootFSUsage:    0,
-		//	interface_name_rx := ("rate.rx" + "_" + details.Interfaces[eth].Identification.Name)
+			LoadAVG:        load / 100,
-		//	interface_name_tx := ("rate.tx" + "_" + details.Interfaces[eth].Identification.Name)
+			MemoryUsage:    mem / 100,
-		//	fields[interface_name_rx] = details.Interfaces[eth].Statistics.Rxrate
+			Uptime:         time.Now().Add(-1 * time.Second * time.Duration(currentDevice.Uptime)).Format(iso8601),
-		//	fields[interface_name_tx] = details.Interfaces[eth].Statistics.Txrate
+			GatewayNexthop: currentJSONDevice.GatewayNexthop,
-		//}
+			Gateway:        currentJSONDevice.Gateway,
-
+			Location:       &currentJSONDevice.Location,
-		// set default values if we can't get statistics
+			NodeID:         strings.ReplaceAll(currentDevice.Mac, ":", ""),
-		fields["cpu"] = 0
+			MAC:            currentDevice.Mac,
-		fields["load"] = float64(0)
+			Adresses:       []string{currentDevice.IP},
-		fields["ram"] = 0
+			Domain:         currentJSONDevice.Domain,
-
+			Hostname:       "[Unifi] " + currentDevice.Name,
-		if isOnline {
+			Owner:          "Freifunk Rhein-Sieg",
-			// Generate fields for all Statistics
+			Firmware: firmware{
-			//load := (float64(load) / float64(100))
+				Base:    "Ubiquiti - Stock",
-			fields["cpu"] = int(cpu)
+				Release: currentDevice.Version,
-			fields["load"] = load
+			},
-			fields["ram"] = int(mem)
+			Autoupdater: autoupdater{
-		}
+				Enabled: false,
-
+				Branch:  "stable",
-		// Generate field for DHCP Leases
+			},
-		fields["clients.total"] = clients
+			NProc: 1,
-		fields["time.up"] = currentDevice.Uptime
+			Model: model,
-
+		})
-		// 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)
-		}
-
-		// INFLUX STOP
-		//log.Println(currentDevice.Mac)
-		if currentDevice.Mac != "" {
-			nodes = append(nodes, node{
-				Firstseen:      "0",
-				Lastseen:       time.Unix(int64(currentDevice.LastSeen), 0).Format(iso8601),
-				IsOnline:       itob(currentDevice.State),
-				IsGateway:      false,
-				Clients:        clients,
-				ClientsWifi24:  0,
-				ClientsWifi5:   0,
-				ClientsOther:   clients,
-				RootFSUsage:    0,
-				LoadAVG:        load / 100,
-				MemoryUsage:    mem / 100,
-				Uptime:         time.Now().Add(-1 * time.Second * time.Duration(currentDevice.Uptime)).Format(iso8601),
-				GatewayNexthop: currentJSONDevice.GatewayNexthop,
-				Gateway:        currentJSONDevice.Gateway,
-				Location:       &currentJSONDevice.Location,
-				NodeID:         strings.ReplaceAll(currentDevice.Mac, ":", ""),
-				MAC:            currentDevice.Mac,
-				Adresses:       []string{currentDevice.IP},
-				Domain:         currentJSONDevice.Domain,
-				Hostname:       "[Unifi] " + currentDevice.Name,
-				Owner:          "Freifunk Rhein-Sieg",
-				Firmware: firmware{
-					Base:    "Ubiquiti - Stock",
-					Release: currentDevice.Version,
-				},
-				Autoupdater: autoupdater{
-					Enabled: false,
-					Branch:  "stable",
-				},
-				NProc: 1,
-				Model: model,
-			})
-		}
 	}
-	return nodes, links, err
+	return nodes, links
 }
 
 func UnifiNewAPI(user string, pass string, baseURL string) UnifiAPIData {
@@ -272,12 +204,9 @@ func UnifiAddLink(dev device, links []link) []link {
 }
 
 func findNodeID(NodeID string) bool {
-	for s := range conf.Unifi {
+	for i := range ucDev.Devices {
-		ucDev := getDevices(conf.Unifi[s].UCDevicesURL)
+		if ucDev.Devices[i].GatewayNexthop == NodeID {
-		for i := range ucDev.Devices {
+			return true
-			if ucDev.Devices[i].GatewayNexthop == NodeID {
-				return true
-			}
 		}
 	}
 	return false

unms.go

@@ -17,23 +17,22 @@ import (
 )
 
 // UNMS API processing (Richtfunk)
-func processUISPRiFu() ([]node, []link, error) {
+func processUNMSAPI() ([]node, []link) {
 	// Variables for runtime
 	var links []link
 	var nodes []node
 
-	d := getDevices(conf.UISP.DevicesURL)
+	d := getDevices(conf.Unms.DevicesURL)
 
-	// API CALL 1 (get Device overview)
+	// API CALL 1
-	log.Println("Starting UISP API Crawler for Rifu devices")
+	log.Println("calling API 1")
-	log.Println("Getting device overview from UNMS API")
 	var u []unifiAPIResponse
-	if err := UnmsCallAPI("/devices", &u); err != nil {
+	err := UnmsCallAPI("/devices", &u)
-		return nil, nil, err
+	if err != nil {
+		log.Fatalln(err)
 	}
 
 	for i := range d.Devices {
-		time.Sleep(time.Second)
 		var dev unifiAPIResponse
 		var currentDevice device
 		for j := range u {
@@ -42,22 +41,20 @@ func processUISPRiFu() ([]node, []link, error) {
 				currentDevice = d.Devices[i]
 			}
 		}
+
 		isOnline := dev.Overview.Status == "active"
 		// END OF API CALL 1
 
-		// Getting details from UISP
+		// API CALL 2
-		log.Println("Getting device details for: ", d.Devices[i].Name)
+		log.Println("calling API 2 for device", d.Devices[i].Name)
 		var details unifiAPIDetails
-		if err := UnmsCallAPI("/devices/erouters/"+dev.Identification.ID, &details); err != nil {
+		UnmsCallAPI("/devices/erouters/"+dev.Identification.ID, &details)
-			return nil, nil, err
+		// END OF API CALL 2
-		}
 
-		// Getting details for RiFu
+		// API CALL 3
-		log.Println("Getting details for RiFu Link for: ", d.Devices[i].Name)
+		log.Println("calling API 3 for device", d.Devices[i].Name)
 		var airmaxes []unifiAPIAirmax
-		if err := UnmsCallAPI("/devices/airmaxes/"+dev.Identification.ID+"/stations", &airmaxes); err != nil {
+		UnmsCallAPI("/devices/airmaxes/"+dev.Identification.ID+"/stations", &airmaxes)
-			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) {
@@ -101,21 +98,23 @@ func processUISPRiFu() ([]node, []link, error) {
 			Model: details.Identification.Model,
 		})
 	}
-	return nodes, links, nil
+	return nodes, links
 }
 
-func processUISPRouter() ([]node, error) {
+func processUNMSAPIRouter() ([]node, error) {
-	time.Sleep(time.Second)
 	// Variables for runtime
 	var nodes []node
-	d := getDevices(conf.UISP.RouterURL)
+
+	d := getDevices(conf.Unms.RouterURL)
 
 	// API CALL 1, get all devices list from UNMS
-	log.Println("Get all Routers from UISP")
+	log.Println("Get all devices from UNMS")
 	var u []unifiAPIResponse
-	if err := UnmsCallAPI("/devices", &u); err != nil {
+	err := UnmsCallAPI("/devices", &u)
+	if err != nil {
 		return nil, err
 	}
+	// END OF API CALL 1
 
 	// Get Information for devices device
 	for i := range d.Devices {
@@ -131,18 +130,19 @@ func processUISPRouter() ([]node, error) {
 		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")
+		log.Println("Getting details of ", d.Devices[i].Name, "from UNMS 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")
+		log.Println("Getting statistics of ", d.Devices[i].Name, "from UNMS 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
@@ -154,6 +154,16 @@ func processUISPRouter() ([]node, error) {
 			log.Println("Router ist offline, skipping DHCP Leases")
 		}
 
+		// Open connection to InfluxDB
+		bp, err := client.NewBatchPoints(client.BatchPointsConfig{
+			Database:  "freifunk",
+			Precision: "s",
+		})
+		if err != nil {
+			log.Fatalln("Error: ", err)
+		}
+		//
+
 		// fields := map[string]interface{}{}
 		fields := make(map[string]any)
 		tags := map[string]string{
@@ -175,10 +185,10 @@ func processUISPRouter() ([]node, error) {
 
 		if isOnline {
 			// Generate fields for all Statistics
-			load := (float64(statistics.CPU.AVG[0].Y) / float64(100))
+			load := (float64(statistics.CPU[0].Y) / float64(100))
-			fields["cpu"] = statistics.CPU.AVG[0].Y
+			fields["cpu"] = statistics.CPU[0].Y
 			fields["load"] = load
-			fields["ram"] = statistics.RAM.AVG[0].Y
+			fields["ram"] = statistics.RAM[0].Y
 		}
 
 		// Generate field for DHCP Leases
@@ -194,9 +204,14 @@ func processUISPRouter() ([]node, error) {
 		if err != nil {
 			log.Fatalln("Error: ", err)
 		}
-		if conf.General.InfluxEnabled {
+		// Add Datapoints in InfluxDB
-			sendInfluxBatchDataPoint(point, conf.General.FreifunkInfluxPort)
+		bp.AddPoint(point)
+		c := influxDBClient()
+		err = c.Write(bp)
+		if err != nil {
+			log.Fatal(err)
 		}
+
 		// Get info from json file (static)
 		nodes = append(nodes, node{
 			Firstseen:      dev.Overview.CreatedAt.Format(iso8601),
@@ -235,22 +250,29 @@ func processUISPRouter() ([]node, error) {
 	return nodes, nil
 }
 
-func UnmsCallAPI(url string, i any) error {
+func influxDBClient() client.Client {
-	time.Sleep(time.Second)
+	c, err := client.NewHTTPClient(client.HTTPConfig{
-	request, err := http.NewRequest(http.MethodGet, conf.UISP.UnmsAPIURL+url, nil)
+		Addr: "http://statistik.freifunk-troisdorf.de:8886",
+	})
 	if err != nil {
-		return errors.New(fmt.Sprint("can't set request", conf.UISP.UnmsAPIURL+url))
+		log.Fatalln("Error: ", err)
 	}
-	//log.Println(conf.UISP.UnmsAPIURL + url)
+	return c
-	request.Header.Set("x-auth-token", conf.UISP.APItoken)
+}
+
+func UnmsCallAPI(url string, i any) error {
+	request, err := http.NewRequest(http.MethodGet, conf.Unms.UnmsAPIURL+url, nil)
+	if err != nil {
+		return errors.New(fmt.Sprint("can't set request", conf.Unms.UnmsAPIURL+url))
+	}
+	request.Header.Set("x-auth-token", conf.Unms.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)
+		return fmt.Errorf("can't get request %s with x-auth-token %s", conf.Unms.UnmsAPIURL+url, conf.Unms.APItoken)
 	}
 	if response.StatusCode != 200 {
-		log.Println("Can't call UNMS API, check token and URL. Skipping device. HTTP Status: ", response.StatusCode)
+		log.Fatalln("Can't call UNMS API, check token and URL. HTTP Status: ", response.StatusCode)
-		return nil
 	}
 	data, err := ioutil.ReadAll(response.Body)
 	defer response.Body.Close()