yanic/models/nodes.go

254 lines
5.8 KiB
Go
Raw Normal View History

package models
2015-12-29 14:05:47 +01:00
import (
"encoding/json"
"log"
"os"
"sync"
"time"
2016-03-12 03:23:12 +01:00
2016-03-15 23:26:30 +01:00
"github.com/FreifunkBremen/respond-collector/data"
2016-03-20 17:10:39 +01:00
"github.com/FreifunkBremen/respond-collector/jsontime"
2016-05-29 21:41:58 +02:00
"github.com/FreifunkBremen/respond-collector/meshviewer"
2015-12-29 14:05:47 +01:00
)
2016-03-07 01:37:38 +01:00
// Nodes struct: cache DB of Node's structs
2015-12-29 14:05:47 +01:00
type Nodes struct {
Version int `json:"version"`
2016-03-20 17:10:39 +01:00
Timestamp jsontime.Time `json:"timestamp"`
2016-03-07 01:37:38 +01:00
List map[string]*Node `json:"nodes"` // the current nodemap, indexed by node ID
2016-03-20 18:30:44 +01:00
config *Config
2016-06-16 18:50:43 +02:00
sync.RWMutex
2015-12-29 14:05:47 +01:00
}
2016-10-03 19:55:37 +02:00
type GlobalStats struct {
Nodes uint32
Clients uint32
ClientsWifi uint32
ClientsWifi24 uint32
ClientsWifi5 uint32
}
2016-03-20 18:30:44 +01:00
// NewNodes create Nodes structs
func NewNodes(config *Config) *Nodes {
2015-12-29 14:05:47 +01:00
nodes := &Nodes{
2016-03-20 18:30:44 +01:00
List: make(map[string]*Node),
config: config,
2015-12-29 14:05:47 +01:00
}
2016-03-20 18:30:44 +01:00
if config.Nodes.NodesPath != "" {
nodes.load()
}
2016-06-16 18:03:45 +02:00
nodes.Version = 2
2015-12-29 14:05:47 +01:00
return nodes
}
2016-11-20 18:45:18 +01:00
func (nodes *Nodes) Start() {
go nodes.worker()
}
2016-03-20 16:25:33 +01:00
// Update a Node
2016-07-14 01:19:03 +02:00
func (nodes *Nodes) Update(nodeID string, res *data.ResponseData) *Node {
2016-03-20 17:10:39 +01:00
now := jsontime.Now()
2015-12-29 14:05:47 +01:00
nodes.Lock()
2016-02-25 21:24:54 +01:00
node, _ := nodes.List[nodeID]
2015-12-29 14:05:47 +01:00
if node == nil {
node = &Node{
2016-03-20 16:25:33 +01:00
Firstseen: now,
2015-12-29 14:05:47 +01:00
}
2016-02-25 21:24:54 +01:00
nodes.List[nodeID] = node
2015-12-29 14:05:47 +01:00
}
nodes.Unlock()
node.Lastseen = now
node.Flags.Online = true
2016-05-23 14:20:58 +02:00
2016-03-20 16:25:33 +01:00
// Update neighbours
if val := res.Neighbours; val != nil {
node.Neighbours = val
}
// Update nodeinfo
if val := res.NodeInfo; val != nil {
node.Nodeinfo = val
node.Flags.Gateway = val.VPN
2016-03-20 16:25:33 +01:00
}
// Update statistics
if val := res.Statistics; val != nil {
2016-07-14 01:19:03 +02:00
// Update channel utilization if previous statistics are present
if node.Statistics != nil && node.Statistics.Wireless != nil && val.Wireless != nil {
val.Wireless.SetUtilization(node.Statistics.Wireless)
}
2016-05-29 21:41:58 +02:00
node.Statistics = val
}
2016-07-14 01:19:03 +02:00
return node
2016-05-29 21:41:58 +02:00
}
2016-06-16 18:50:43 +02:00
// GetNodesMini get meshviewer valide JSON
2016-06-16 18:03:45 +02:00
func (nodes *Nodes) GetNodesMini() *meshviewer.Nodes {
2016-05-29 21:41:58 +02:00
meshviewerNodes := &meshviewer.Nodes{
2016-06-16 18:03:45 +02:00
Version: 1,
2016-05-29 21:41:58 +02:00
List: make(map[string]*meshviewer.Node),
Timestamp: nodes.Timestamp,
}
2016-11-20 18:45:18 +01:00
for nodeID := range nodes.List {
2016-06-16 18:50:43 +02:00
node, _ := meshviewerNodes.List[nodeID]
nodeOrigin := nodes.List[nodeID]
2016-05-29 21:41:58 +02:00
if node == nil {
node = &meshviewer.Node{
2016-06-16 18:50:43 +02:00
Firstseen: nodeOrigin.Firstseen,
Lastseen: nodeOrigin.Lastseen,
Flags: nodeOrigin.Flags,
Nodeinfo: nodeOrigin.Nodeinfo,
2016-05-29 21:41:58 +02:00
}
meshviewerNodes.List[nodeID] = node
}
2016-06-16 18:50:43 +02:00
2016-07-13 16:50:59 +02:00
// Calculate Total
total := nodeOrigin.Statistics.Clients.Total
if total == 0 {
total = nodeOrigin.Statistics.Clients.Wifi24 + nodeOrigin.Statistics.Clients.Wifi5
}
2016-05-29 21:41:58 +02:00
node.Statistics = &meshviewer.Statistics{
2016-06-16 18:50:43 +02:00
NodeId: nodeOrigin.Statistics.NodeId,
Gateway: nodeOrigin.Statistics.Gateway,
RootFsUsage: nodeOrigin.Statistics.RootFsUsage,
LoadAverage: nodeOrigin.Statistics.LoadAverage,
Memory: nodeOrigin.Statistics.Memory,
Uptime: nodeOrigin.Statistics.Uptime,
Idletime: nodeOrigin.Statistics.Idletime,
Processes: nodeOrigin.Statistics.Processes,
MeshVpn: nodeOrigin.Statistics.MeshVpn,
Traffic: nodeOrigin.Statistics.Traffic,
2016-07-13 16:50:59 +02:00
Clients: total,
}
2016-03-20 16:25:33 +01:00
}
2016-05-29 21:41:58 +02:00
return meshviewerNodes
2015-12-29 14:05:47 +01:00
}
2016-03-20 18:30:44 +01:00
// Periodically saves the cached DB to json file
func (nodes *Nodes) worker() {
2016-05-21 13:11:29 +02:00
c := time.Tick(time.Second * time.Duration(nodes.config.Nodes.SaveInterval))
2015-12-29 14:05:47 +01:00
for range c {
nodes.expire()
nodes.save()
}
}
// Expires nodes and set nodes offline
func (nodes *Nodes) expire() {
nodes.Timestamp = jsontime.Now()
// Nodes last seen before expireTime will be removed
maxAge := nodes.config.Nodes.MaxAge
if maxAge <= 0 {
maxAge = 7 // our default
}
expireTime := nodes.Timestamp.Add(-time.Duration(maxAge) * time.Hour * 24)
// Nodes last seen before offlineTime are changed to 'offline'
offlineTime := nodes.Timestamp.Add(-time.Minute * 10)
// Locking foo
nodes.Lock()
defer nodes.Unlock()
for id, node := range nodes.List {
if node.Lastseen.Before(expireTime) {
// expire
delete(nodes.List, id)
} else if node.Lastseen.Before(offlineTime) {
// set to offline
node.Flags.Online = false
}
}
}
2016-03-20 18:30:44 +01:00
func (nodes *Nodes) load() {
path := nodes.config.Nodes.NodesPath
if f, err := os.Open(path); err == nil {
if err := json.NewDecoder(f).Decode(nodes); err == nil {
log.Println("loaded", len(nodes.List), "nodes")
} else {
log.Println("failed to unmarshal nodes:", err)
}
} else {
log.Println("failed to load cached nodes:", err)
}
}
func (nodes *Nodes) save() {
// Locking foo
nodes.RLock()
defer nodes.RUnlock()
// serialize nodes
save(nodes, nodes.config.Nodes.NodesPath)
save(nodes.GetNodesMini(), nodes.config.Nodes.NodesMiniPath)
2016-03-20 18:30:44 +01:00
if path := nodes.config.Nodes.GraphsPath; path != "" {
save(nodes.BuildGraph(), path)
2015-12-29 14:05:47 +01:00
}
}
2016-10-03 19:55:37 +02:00
// Returns global statistics for InfluxDB
2016-10-04 01:05:18 +02:00
func (nodes *Nodes) GlobalStats() (result *GlobalStats) {
result = &GlobalStats{}
2016-07-22 22:16:01 +02:00
nodes.Lock()
for _, node := range nodes.List {
if node.Flags.Online {
2016-10-03 19:55:37 +02:00
result.Nodes += 1
2016-07-22 22:16:01 +02:00
if stats := node.Statistics; stats != nil {
2016-10-03 19:55:37 +02:00
result.Clients += stats.Clients.Total
result.ClientsWifi24 += stats.Clients.Wifi24
result.ClientsWifi5 += stats.Clients.Wifi5
result.ClientsWifi += stats.Clients.Wifi
2016-07-22 22:16:01 +02:00
}
}
}
nodes.Unlock()
2016-10-03 19:55:37 +02:00
return
}
2016-07-22 22:16:01 +02:00
2016-10-03 19:55:37 +02:00
// Returns fields for InfluxDB
func (stats *GlobalStats) Fields() map[string]interface{} {
2016-07-22 22:16:01 +02:00
return map[string]interface{}{
2016-10-03 19:55:37 +02:00
"nodes": stats.Nodes,
"clients.total": stats.Clients,
"clients.wifi": stats.ClientsWifi,
"clients.wifi24": stats.ClientsWifi24,
"clients.wifi5": stats.ClientsWifi5,
2016-07-22 22:16:01 +02:00
}
}
// Marshals the input and writes it into the given file
2016-03-07 02:29:31 +01:00
func save(input interface{}, outputFile string) {
tmpFile := outputFile + ".tmp"
f, err := os.OpenFile(tmpFile, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0644)
if err != nil {
2016-02-19 11:30:42 +01:00
log.Panic(err)
2016-02-19 11:13:30 +01:00
}
2015-12-29 14:05:47 +01:00
err = json.NewEncoder(f).Encode(input)
if err != nil {
2016-02-19 11:30:42 +01:00
log.Panic(err)
}
2016-03-20 18:30:44 +01:00
f.Close()
2016-03-20 18:30:44 +01:00
if err := os.Rename(tmpFile, outputFile); err != nil {
2016-02-19 11:30:42 +01:00
log.Panic(err)
}
2015-12-29 14:05:47 +01:00
}