package 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 "/" 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 }