yanic/respond/collector.go

258 lines
5.7 KiB
Go
Raw Normal View History

2016-02-26 09:28:31 +01:00
package respond
2015-12-29 04:08:03 +01:00
import (
2016-03-19 01:50:23 +01:00
"bytes"
"compress/flate"
2016-03-12 00:59:36 +01:00
"encoding/json"
2015-12-29 04:08:03 +01:00
"log"
"net"
"time"
"fmt"
2017-03-03 16:19:35 +01:00
"github.com/FreifunkBremen/yanic/data"
"github.com/FreifunkBremen/yanic/database"
"github.com/FreifunkBremen/yanic/jsontime"
"github.com/FreifunkBremen/yanic/models"
2015-12-29 04:08:03 +01:00
)
// Collector for a specificle respond messages
2015-12-29 04:08:03 +01:00
type Collector struct {
connection *net.UDPConn // UDP socket
queue chan *Response // received responses
iface string
db *database.DB
nodes *models.Nodes
interval time.Duration // Interval for multicast packets
stop chan interface{}
2015-12-29 04:08:03 +01:00
}
// NewCollector creates a Collector struct
func NewCollector(db *database.DB, nodes *models.Nodes, iface string, port int) *Collector {
linkLocalAddr, err := getLinkLocalAddr(iface)
2015-12-29 04:08:03 +01:00
if err != nil {
log.Panic(err)
}
// Open socket
conn, err := net.ListenUDP("udp", &net.UDPAddr{
IP: linkLocalAddr,
Port: port,
Zone: iface,
})
2015-12-29 04:08:03 +01:00
if err != nil {
log.Panic(err)
}
conn.SetReadBuffer(maxDataGramSize)
2015-12-29 04:08:03 +01:00
collector := &Collector{
connection: conn,
db: db,
nodes: nodes,
iface: iface,
queue: make(chan *Response, 400),
stop: make(chan interface{}),
2015-12-29 04:08:03 +01:00
}
go collector.receiver()
go collector.parser()
2016-03-12 01:04:22 +01:00
if collector.db != nil {
go collector.globalStatsWorker()
}
return collector
}
// Returns the first link local unicast address for the given interface name
func getLinkLocalAddr(ifname string) (net.IP, error) {
iface, err := net.InterfaceByName(ifname)
if err != nil {
return nil, err
}
addresses, err := iface.Addrs()
if err != nil {
return nil, err
}
for _, addr := range addresses {
if ipnet := addr.(*net.IPNet); ipnet.IP.IsLinkLocalUnicast() {
return ipnet.IP, nil
}
}
return nil, fmt.Errorf("unable to find link local unicast address for %s", ifname)
}
// Start Collector
func (coll *Collector) Start(interval time.Duration) {
2017-01-29 22:26:16 +01:00
if coll.interval != 0 {
panic("already started")
}
2017-01-29 22:26:16 +01:00
if interval <= 0 {
panic("invalid collector interval")
}
coll.interval = interval
2016-03-12 18:26:51 +01:00
go func() {
coll.sendOnce() // immediately
coll.sender() // periodically
2016-03-12 18:26:51 +01:00
}()
2015-12-29 04:08:03 +01:00
}
2016-03-11 23:56:23 +01:00
// Close Collector
2015-12-29 04:08:03 +01:00
func (coll *Collector) Close() {
2017-01-29 22:26:16 +01:00
close(coll.stop)
2015-12-29 04:08:03 +01:00
coll.connection.Close()
close(coll.queue)
}
2015-12-29 14:05:47 +01:00
func (coll *Collector) sendOnce() {
now := jsontime.Now()
coll.sendMulticast()
// Wait for the multicast responses to be processed and send unicasts
time.Sleep(coll.interval / 2)
coll.sendUnicasts(now)
2015-12-29 14:05:47 +01:00
}
func (coll *Collector) sendMulticast() {
log.Println("sending multicast")
coll.SendPacket(net.ParseIP(multiCastGroup))
}
// Send unicast packets to nodes that did not answer the multicast
func (coll *Collector) sendUnicasts(seenBefore jsontime.Time) {
seenAfter := seenBefore.Add(-time.Minute * 10)
// Select online nodes that has not been seen recently
nodes := coll.nodes.Select(func(n *models.Node) bool {
return n.Lastseen.After(seenAfter) && n.Lastseen.Before(seenBefore) && n.Address != nil
})
// Send unicast packets
log.Printf("sending unicast to %d nodes", len(nodes))
for _, node := range nodes {
coll.SendPacket(node.Address)
time.Sleep(10 * time.Millisecond)
}
}
// SendPacket sends a UDP request to the given unicast or multicast address
func (coll *Collector) SendPacket(address net.IP) {
addr := net.UDPAddr{
IP: address,
Port: port,
Zone: coll.iface,
2016-02-19 11:13:30 +01:00
}
2015-12-29 14:05:47 +01:00
if _, err := coll.connection.WriteToUDP([]byte("GET nodeinfo statistics neighbours"), &addr); err != nil {
2016-03-07 01:37:07 +01:00
log.Println("WriteToUDP failed:", err)
}
2015-12-29 04:08:03 +01:00
}
2016-03-11 23:56:23 +01:00
// send packets continously
func (coll *Collector) sender() {
2017-01-29 22:26:16 +01:00
ticker := time.NewTicker(coll.interval)
2016-03-11 23:56:23 +01:00
for {
select {
case <-coll.stop:
2017-01-29 22:26:16 +01:00
ticker.Stop()
2016-03-11 23:56:23 +01:00
return
2017-01-29 22:26:16 +01:00
case <-ticker.C:
2016-10-04 01:05:18 +02:00
// send the multicast packet to request per-node statistics
2016-03-11 23:56:23 +01:00
coll.sendOnce()
}
2015-12-29 04:08:03 +01:00
}
}
func (coll *Collector) parser() {
2016-01-04 02:07:09 +01:00
for obj := range coll.queue {
2016-10-03 19:55:37 +02:00
if data, err := obj.parse(); err != nil {
log.Println("unable to decode response from", obj.Address.String(), err, "\n", string(obj.Raw))
2016-10-03 19:55:37 +02:00
} else {
coll.saveResponse(obj.Address, data)
2016-03-12 00:59:36 +01:00
}
2015-12-29 04:08:03 +01:00
}
}
2016-10-03 19:55:37 +02:00
func (res *Response) parse() (*data.ResponseData, error) {
2016-03-19 23:27:07 +01:00
// Deflate
2016-10-03 19:55:37 +02:00
deflater := flate.NewReader(bytes.NewReader(res.Raw))
2016-03-19 23:27:07 +01:00
defer deflater.Close()
2016-03-19 15:07:44 +01:00
2016-03-19 23:27:07 +01:00
// Unmarshal
2016-10-03 19:55:37 +02:00
rdata := &data.ResponseData{}
err := json.NewDecoder(deflater).Decode(rdata)
return rdata, err
}
func (coll *Collector) saveResponse(addr net.UDPAddr, res *data.ResponseData) {
// Search for NodeID
var nodeID string
2016-10-03 19:55:37 +02:00
if val := res.NodeInfo; val != nil {
nodeID = val.NodeID
2016-10-03 19:55:37 +02:00
} else if val := res.Neighbours; val != nil {
nodeID = val.NodeID
2016-10-03 19:55:37 +02:00
} else if val := res.Statistics; val != nil {
nodeID = val.NodeID
2016-10-03 19:55:37 +02:00
}
2017-01-29 22:26:16 +01:00
// Check length of nodeID
if len(nodeID) != 12 {
log.Printf("invalid NodeID '%s' from %s", nodeID, addr.String())
2016-10-03 19:55:37 +02:00
return
2016-03-19 15:07:44 +01:00
}
2017-01-29 22:26:16 +01:00
// Process the data and update IP address
node := coll.nodes.Update(nodeID, res)
node.Address = addr.IP
2016-03-19 15:07:44 +01:00
2017-01-29 22:26:16 +01:00
// Store statistics in InfluxDB
2016-10-03 19:55:37 +02:00
if coll.db != nil && node.Statistics != nil {
coll.db.Add(nodeID, node)
2016-10-03 19:55:37 +02:00
}
2016-03-19 01:50:23 +01:00
}
2015-12-29 04:08:03 +01:00
func (coll *Collector) receiver() {
buf := make([]byte, maxDataGramSize)
2015-12-29 04:08:03 +01:00
for {
2016-01-04 02:07:09 +01:00
n, src, err := coll.connection.ReadFromUDP(buf)
2015-12-29 04:08:03 +01:00
if err != nil {
log.Println("ReadFromUDP failed:", err)
2015-12-29 14:05:47 +01:00
return
2015-12-29 04:08:03 +01:00
}
2016-01-04 02:07:09 +01:00
raw := make([]byte, n)
copy(raw, buf)
coll.queue <- &Response{
Address: *src,
Raw: raw,
}
2015-12-29 04:08:03 +01:00
}
}
func (coll *Collector) globalStatsWorker() {
ticker := time.NewTicker(time.Minute)
for {
select {
case <-coll.stop:
2017-01-29 22:26:16 +01:00
ticker.Stop()
return
case <-ticker.C:
coll.saveGlobalStats()
}
}
}
// saves global statistics
func (coll *Collector) saveGlobalStats() {
stats := models.NewGlobalStats(coll.nodes)
coll.db.AddPoint(database.MeasurementGlobal, nil, stats.Fields(), time.Now())
coll.db.AddCounterMap(database.MeasurementFirmware, stats.Firmwares)
coll.db.AddCounterMap(database.MeasurementModel, stats.Models)
}