Something went wrong. Try again.
Kasa smart plug Riemann monitoring
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471package controller
import ( "context" "fmt" "log" "net" "regexp" "strconv" "strings" "sync" "time"
riemanngo "github.com/riemann/riemann-go-client"
"go.iscode.ca/plugd/internal/config" "go.iscode.ca/plugd/internal/kasa" "go.iscode.ca/plugd/internal/riemann")
// Controller manages polling, state caching, and command dispatch between Kasa plugs and Riemann.type Controller struct { cfg *config.Config clients []kasa.Client publisher *riemann.Publisher subscriber *riemann.Subscriber
startTime time.Time mu sync.RWMutex // cache maps "<device-host>/<outlet-index>" to current bool state stateCache map[string]bool // maps alias/host identifiers to Client clientMap map[string]kasa.Client}
// New creates a new Controller.func New(cfg *config.Config, clients []kasa.Client, pub *riemann.Publisher, sub *riemann.Subscriber) *Controller { cMap := make(map[string]kasa.Client) for _, client := range clients { cMap[client.DeviceHost()] = client }
return &Controller{ cfg: cfg, clients: clients, publisher: pub, subscriber: sub, startTime: time.Now(), stateCache: make(map[string]bool), clientMap: cMap, }}
// Start begins periodic polling and event subscription until ctx is cancelled.func (c *Controller) Start(ctx context.Context) error { if c.cfg.Autodiscover { log.Printf("controller starting in autodiscovery mode (checking all attached networks)") c.runDiscovery(ctx) } else { log.Printf("controller starting with %d managed plug(s)", len(c.clients)) }
// Initial poll c.pollAll(ctx)
// Update clientMap with any aliases discovered during initial poll c.mu.Lock() for _, client := range c.clients { alias := client.DeviceAlias() if alias != "" { c.clientMap[alias] = client c.clientMap[strings.ToLower(alias)] = client } } c.mu.Unlock()
// Start command subscriber eventCh := c.subscriber.Subscribe(ctx)
// Start poll ticker ticker := time.NewTicker(c.cfg.PollInterval) defer ticker.Stop()
var discoverCh <-chan time.Time if c.cfg.Autodiscover && c.cfg.DiscoverInterval > 0 { discoverTicker := time.NewTicker(c.cfg.DiscoverInterval) defer discoverTicker.Stop() discoverCh = discoverTicker.C }
for { select { case <-ctx.Done(): log.Printf("controller shutting down...") return nil
case <-ticker.C: c.pollAll(ctx)
case <-discoverCh: c.runDiscovery(ctx)
case ev, ok := <-eventCh: if !ok { return nil } c.handleCommandEvent(ctx, &ev) } }}
func (c *Controller) runDiscovery(ctx context.Context) { if c.cfg.Verbose { log.Printf("running UDP discovery on attached networks / targets...") } devs, err := kasa.Discover(ctx, c.cfg.DiscoverTargets, 3*time.Second) if err != nil { log.Printf("discovery error: %v", err) return }
for _, d := range devs { c.mu.RLock() _, exists := c.clientMap[d.IP] c.mu.RUnlock()
if !exists { log.Printf("autodiscovered plug %s (model: %s, mac: %s)", d.IP, d.DeviceModel, d.MAC) client := c.AddPlug(d.IP) if client != nil { go func(cl kasa.Client) { ctxPoll, cancel := context.WithTimeout(context.Background(), 10*time.Second) defer cancel() c.pollPlug(ctxPoll, cl)
alias := cl.DeviceAlias() if alias != "" { c.mu.Lock() c.clientMap[alias] = cl c.clientMap[strings.ToLower(alias)] = cl c.mu.Unlock() } }(client) } } }}
// AddPlug dynamically registers a new plug into the controller and returns the Client.func (c *Controller) AddPlug(host string) kasa.Client { c.mu.Lock() if client, exists := c.clientMap[host]; exists { c.mu.Unlock() return client } client, err := kasa.NewClient(host, c.cfg.KasaUsername, c.cfg.KasaPassword) if err != nil { c.mu.Unlock() log.Printf("failed to initialize client for plug %s: %v", host, err) return nil } c.clients = append(c.clients, client) c.clientMap[host] = client c.mu.Unlock() return client}
func (c *Controller) pollAll(ctx context.Context) { c.mu.RLock() clients := make([]kasa.Client, len(c.clients)) copy(clients, c.clients) c.mu.RUnlock()
for _, client := range clients { select { case <-ctx.Done(): return default: } c.pollPlug(ctx, client) }}
func (c *Controller) pollPlug(ctx context.Context, client kasa.Client) { outlets, err := client.GetOutlets(ctx) if err != nil { log.Printf("poll error for plug %s: %v", client.DeviceHost(), err) return }
prefix := c.cfg.ServicePrefix if prefix != "" && !strings.HasSuffix(prefix, "/") && !strings.HasSuffix(prefix, "-") { prefix += "/" }
hostIdent := client.DeviceAlias() if hostIdent == "" { hostIdent = client.DeviceHost() }
var events []riemanngo.Event now := time.Now()
for _, outlet := range outlets { cacheKey := fmt.Sprintf("%s/%d", client.DeviceHost(), outlet.Index) c.mu.Lock() c.stateCache[cacheKey] = outlet.State c.mu.Unlock()
metricVal := 0.0 if outlet.State { metricVal = 1.0 }
serviceName := fmt.Sprintf("%s%s/%d/state", prefix, hostIdent, outlet.Index) tags := []string{"kasa", "plug", "power"} desc := fmt.Sprintf("%s outlet %d state", outlet.Alias, outlet.Index) attrs := map[string]string{ "outlet": strconv.Itoa(outlet.Index), "alias": outlet.Alias, "ip": client.DeviceHost(), "outlet_id": outlet.OutletID, } if outlet.IsBulb { tags = []string{"kasa", "bulb", "light"} desc = fmt.Sprintf("%s light state", outlet.Alias) attrs["brightness"] = strconv.Itoa(outlet.Brightness) if outlet.ColorTemp > 0 { attrs["color_temp"] = strconv.Itoa(outlet.ColorTemp) } if outlet.Hue > 0 { attrs["hue"] = strconv.Itoa(outlet.Hue) } if outlet.Saturation > 0 { attrs["saturation"] = strconv.Itoa(outlet.Saturation) } } if c.cfg.Tag != "" { tags = append(tags, c.cfg.Tag) }
events = append(events, riemanngo.Event{ Host: hostIdent, Service: serviceName, Metric: metricVal, State: "ok", TTL: c.cfg.RiemannTTL, Time: now, Tags: tags, Description: desc, Attributes: attrs, }) }
if err := c.publisher.Send(events); err != nil { log.Printf("error publishing status to riemann: %v", err) }}
// setCommandRegex matches service paths like "kasa/strip1/0/set" or "kasa/192.0.2.1/0/set"var setCommandRegex = regexp.MustCompile(`^(?:.*\/)?([^\/]+)\/(\d+)\/set$`)
func (c *Controller) handleCommandEvent(ctx context.Context, ev *riemann.Event) { // Replay protection: ignore events that occurred before this daemon started if ev.TimeMicros > 0 { eventTime := time.UnixMicro(ev.TimeMicros) if eventTime.Before(c.startTime.Add(-5 * time.Second)) { if c.cfg.Verbose { log.Printf("ignoring older pre-start command event: %s (time: %v)", ev.Service, eventTime) } return } }
// 1. Identify Target Plug and Outlet Index var targetIdent string outletIndex := -1
// Check service name pattern: e.g. "kasa/strip1/0/set" if matches := setCommandRegex.FindStringSubmatch(ev.Service); len(matches) == 3 { targetIdent = matches[1] idx, err := strconv.Atoi(matches[2]) if err == nil { outletIndex = idx } } else if ev.Attributes != nil { if oStr, ok := ev.Attributes["outlet"]; ok { if idx, err := strconv.Atoi(oStr); err == nil { outletIndex = idx } } if t, ok := ev.Attributes["target"]; ok { targetIdent = t } }
if targetIdent == "" { targetIdent = ev.Host }
// 2. Find matching client c.mu.RLock() client, ok := c.clientMap[targetIdent] if !ok { client, ok = c.clientMap[strings.ToLower(targetIdent)] } c.mu.RUnlock()
if !ok { if net.ParseIP(targetIdent) != nil { log.Printf("dynamically adopting plug %s from incoming command", targetIdent) client = c.AddPlug(targetIdent) if client == nil { log.Printf("failed to adopt plug %s", targetIdent) return } c.pollPlug(ctx, client) } else { if c.cfg.Verbose { log.Printf("received command for untracked device %q (service: %s)", targetIdent, ev.Service) } return } }
if outletIndex < 0 { outletIndex = 0 }
// 3. Determine requested state (on or off) desiredState := false s := strings.ToLower(strings.TrimSpace(ev.State)) if s == "on" || s == "1" || s == "true" || ev.Metric == 1.0 { desiredState = true } else if s == "off" || s == "0" || s == "false" || ev.Metric == 0.0 { desiredState = false } else { log.Printf("ignoring command with unrecognized state %q / metric %v", ev.State, ev.Metric) return }
lightOpts, hasLightOpts := parseLightOptions(ev.Attributes)
// 4. Check if state change is actually needed cacheKey := fmt.Sprintf("%s/%d", client.DeviceHost(), outletIndex) c.mu.RLock() currentState, cached := c.stateCache[cacheKey] c.mu.RUnlock()
if cached && currentState == desiredState && !hasLightOpts { if c.cfg.Verbose { log.Printf("plug %s outlet %d already in desired state (%v), no-op", client.DeviceHost(), outletIndex, desiredState) } return }
// 5. Execute hardware command on plug or bulb if hasLightOpts { if lc, ok := client.(kasa.LightController); ok { log.Printf("executing command: setting bulb %s -> %v", client.DeviceHost(), desiredState) if err := lc.SetLight(ctx, desiredState, lightOpts); err != nil { log.Printf("failed to set light state: %v", err) return } } else { log.Printf("executing command: setting plug %s outlet %d -> %v", client.DeviceHost(), outletIndex, desiredState) if err := client.SetOutlet(ctx, outletIndex, desiredState); err != nil { log.Printf("failed to set outlet state: %v", err) return } } } else { log.Printf("executing command: setting plug %s outlet %d -> %v", client.DeviceHost(), outletIndex, desiredState) if err := client.SetOutlet(ctx, outletIndex, desiredState); err != nil { log.Printf("failed to set outlet state: %v", err) return } }
// 6. Update local cache c.mu.Lock() c.stateCache[cacheKey] = desiredState c.mu.Unlock()
// 7. Publish immediate confirmed state back to Riemann c.publishSingleState(client, outletIndex, desiredState)}
func (c *Controller) publishSingleState(client kasa.Client, outletIndex int, state bool) { prefix := c.cfg.ServicePrefix if prefix != "" && !strings.HasSuffix(prefix, "/") && !strings.HasSuffix(prefix, "-") { prefix += "/" }
hostIdent := client.DeviceAlias() if hostIdent == "" { hostIdent = client.DeviceHost() }
metricVal := 0.0 if state { metricVal = 1.0 }
serviceName := fmt.Sprintf("%s%s/%d/state", prefix, hostIdent, outletIndex) tags := []string{"kasa", "plug", "power"} if c.cfg.Tag != "" { tags = append(tags, c.cfg.Tag) }
ev := riemanngo.Event{ Host: hostIdent, Service: serviceName, Metric: metricVal, State: "ok", TTL: c.cfg.RiemannTTL, Time: time.Now(), Tags: tags, Description: fmt.Sprintf("%s outlet %d state confirmed", hostIdent, outletIndex), Attributes: map[string]string{ "outlet": strconv.Itoa(outletIndex), "ip": client.DeviceHost(), }, }
if err := c.publisher.Send([]riemanngo.Event{ev}); err != nil { log.Printf("error publishing confirmed state to riemann: %v", err) } else if c.cfg.Verbose { log.Printf("confirmed state published: %s = %v", serviceName, metricVal) }}
func parseLightOptions(attrs map[string]string) (kasa.LightOptions, bool) { var opts kasa.LightOptions var hasOpts bool if len(attrs) == 0 { return opts, false } if v, ok := attrs["brightness"]; ok { if n, err := strconv.Atoi(v); err == nil { opts.Brightness = &n hasOpts = true } } if v, ok := attrs["color_temp"]; ok { if n, err := strconv.Atoi(v); err == nil { opts.ColorTemp = &n hasOpts = true } } if v, ok := attrs["hue"]; ok { if n, err := strconv.Atoi(v); err == nil { opts.Hue = &n hasOpts = true } } if v, ok := attrs["saturation"]; ok { if n, err := strconv.Atoi(v); err == nil { opts.Saturation = &n hasOpts = true } } if v, ok := attrs["transition_ms"]; ok { if n, err := strconv.Atoi(v); err == nil { opts.TransitionPeriod = &n hasOpts = true } } return opts, hasOpts}