energylink/pkg/services/alerting/alert_rule_reader.go

package alerting

import (
	"sync"
	"time"

	"github.com/grafana/grafana/pkg/bus"
	"github.com/grafana/grafana/pkg/log"
	m "github.com/grafana/grafana/pkg/models"
)

type RuleReader interface {
	Fetch() []AlertRule
}

type AlertRuleReader struct {
	sync.RWMutex
	serverID       string
	serverPosition int
	clusterSize    int
}

func NewRuleReader() *AlertRuleReader {
	ruleReader := &AlertRuleReader{}

	go ruleReader.initReader()
	return ruleReader
}

var (
	alertJobs []AlertRule
)

func (arr *AlertRuleReader) Fetch() []AlertRule {
	return alertJobs
}

func (arr *AlertRuleReader) initReader() {
	alertJobs = make([]AlertRule, 0)
	heartbeat := time.NewTicker(time.Second * 10)
	arr.updateRules()

	for {
		select {
		case <-heartbeat.C:
			arr.updateRules()
		}
	}
}

func (arr *AlertRuleReader) updateRules() {
	arr.Lock()
	defer arr.Unlock()

	cmd := &m.GetAllAlertsQuery{}
	err := bus.Dispatch(cmd)

	if err == nil {
		//alertJobs = cmd.Result
	} else {
		log.Error(1, "AlertRuleReader: Could not load alerts")
	}
}

func (arr *AlertRuleReader) heartBeat() {

	//Lets cheat on this until we focus on clustering
	//log.Info("Heartbeat: Sending heartbeat from " + this.serverId)
	arr.clusterSize = 1
	arr.serverPosition = 1

	/*
		cmd := &m.HeartBeatCommand{ServerId: this.serverId}
		err := bus.Dispatch(cmd)

		if err != nil {
			log.Error(1, "Failed to send heartbeat.")
		} else {
			this.clusterSize = cmd.Result.ClusterSize
			this.serverPosition = cmd.Result.UptimePosition
		}
	*/
}