115 lines
2.1 KiB
Go
115 lines
2.1 KiB
Go
package main
|
|
|
|
import (
|
|
"encoding/json"
|
|
"log"
|
|
"net"
|
|
"reflect"
|
|
"strings"
|
|
"time"
|
|
)
|
|
|
|
const (
|
|
maxDatagramSize = 8192
|
|
)
|
|
|
|
type Collector struct {
|
|
collectType string
|
|
connection *net.UDPConn // UDP socket
|
|
queue chan string // received responses
|
|
}
|
|
|
|
func NewCollector(collectType string) *Collector {
|
|
// Parse address
|
|
addr, err := net.ResolveUDPAddr("udp", "[::]:0")
|
|
if err != nil {
|
|
log.Panic(err)
|
|
}
|
|
|
|
// Open socket
|
|
conn, err := net.ListenUDP("udp", addr)
|
|
if err != nil {
|
|
log.Panic(err)
|
|
}
|
|
conn.SetReadBuffer(maxDatagramSize)
|
|
|
|
collector := &Collector{
|
|
collectType: collectType,
|
|
connection: conn,
|
|
queue: make(chan string, 100),
|
|
}
|
|
|
|
go collector.sendOnce()
|
|
go collector.sender()
|
|
|
|
go collector.receiver()
|
|
go collector.parser()
|
|
|
|
return collector
|
|
}
|
|
|
|
func (coll *Collector) Close() {
|
|
coll.connection.Close()
|
|
close(coll.queue)
|
|
}
|
|
|
|
func (coll *Collector) sendOnce() {
|
|
coll.sendPacket("[2a06:8782:ffbb:1337:c24a:ff:fe2c:c7ac]:1001")
|
|
coll.sendPacket("[2001:bf7:540:0:32b5:c2ff:fe6e:99d5]:1001")
|
|
}
|
|
|
|
func (coll *Collector) sendPacket(address string) {
|
|
addr, err := net.ResolveUDPAddr("udp", address)
|
|
check(err)
|
|
|
|
coll.connection.WriteToUDP([]byte(coll.collectType), addr)
|
|
}
|
|
|
|
func (coll *Collector) sender() {
|
|
c := time.Tick(collectInterval)
|
|
|
|
for range c {
|
|
coll.sendOnce()
|
|
}
|
|
}
|
|
|
|
func (coll *Collector) parser() {
|
|
for str := range coll.queue {
|
|
coll.parseSingle(str)
|
|
}
|
|
}
|
|
|
|
// Parst die Rückgabe
|
|
func (coll *Collector) parseSingle(str string) {
|
|
var result map[string]interface{}
|
|
json.Unmarshal([]byte(str), &result)
|
|
|
|
nodeId, _ := result["node_id"].(string)
|
|
|
|
if nodeId == "" {
|
|
log.Println("unable to parse node_id")
|
|
return
|
|
}
|
|
|
|
node := nodes.get(nodeId)
|
|
|
|
// Set result
|
|
elem := reflect.ValueOf(node).Elem()
|
|
field := elem.FieldByName(strings.Title(coll.collectType))
|
|
field.Set(reflect.ValueOf(result))
|
|
}
|
|
|
|
func (coll *Collector) receiver() {
|
|
b := make([]byte, maxDatagramSize)
|
|
for {
|
|
n, src, err := coll.connection.ReadFromUDP(b)
|
|
|
|
if err != nil {
|
|
log.Println("ReadFromUDP failed:", err)
|
|
return
|
|
}
|
|
coll.queue <- string(b[:n])
|
|
log.Println("received", coll.collectType, "from", src)
|
|
}
|
|
}
|