Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
1 change: 1 addition & 0 deletions changelog.d/changed-18315.md
Original file line number Diff line number Diff line change
@@ -0,0 +1 @@
- v6: converge kick_observer.go with v5's fan-out observers (#18315)
4 changes: 3 additions & 1 deletion src/cmd/hive/mention_runtime.go
Original file line number Diff line number Diff line change
Expand Up @@ -3,6 +3,7 @@ package main
import (
"context"

"github.com/hivecommons/hive/crux"
"github.com/hivecommons/hive/pkg/config"
"github.com/hivecommons/hive/pkg/github"
"github.com/hivecommons/hive/pkg/mention"
Expand Down Expand Up @@ -91,7 +92,8 @@ func (b *boot) syncMentionRuntime() {
responder.SetPerThreadMaxFunc(func() int {
return b.cfg.GitHub.Mentions.PerThreadMaxEffective()
})
b.agentMgr.SetKickObserver(responder.HandleAgentEvent)
// Fan-out, beside the Linear agent's observer (hivecommons/hive#7483).
crux.AddLegacyKickObserver(b.agentMgr, responder.HandleAgentEvent)
b.logger.Info("GitHub mention trigger poller started", "interval", b.cfg.GitHub.Mentions.PollIntervalEffective())
}

Expand Down
190 changes: 190 additions & 0 deletions src/crux/agent/kick_deferred_test.go
Original file line number Diff line number Diff line change
@@ -0,0 +1,190 @@
package agent

import (
"fmt"
"testing"
"time"
)

// Deferred startup kicks and the kick-dropped notification (v6-only; moved
// out of kick_observer_test.go so that file stays identical to v5's).

func TestDeferredStartupMentionsQueueFIFOWithoutDrop(t *testing.T) {
m := &Manager{agents: map[string]*AgentProcess{}, logger: discardLogger()}
agent := &AgentProcess{Name: "scanner", startupLaunchQueued: true}
m.agents[agent.Name] = agent
got := make(chan [3]string, 4)
m.SetKickObserver(func(agentName, event, detail string) {
got <- [3]string{agentName, event, detail}
})

m.mu.Lock()
for _, k := range []deferredKick{
{message: "first", source: "mention:first"},
{message: "second", source: "mention:second"},
{message: "first again", source: "mention:first"},
} {
if !m.deferStartupKickLocked(agent, k.message, k.source) {
t.Fatalf("deferred startup kick %q was not accepted", k.source)
}
}
m.mu.Unlock()

select {
case ev := <-got:
t.Fatalf("queued mentions must not be dropped, got %v", ev)
case <-time.After(50 * time.Millisecond):
}
want := []deferredKick{
{message: "first again", source: "mention:first"},
{message: "second", source: "mention:second"},
}
if len(agent.deferredMentionKicks) != len(want) {
t.Fatalf("deferredMentionKicks = %+v, want %+v", agent.deferredMentionKicks, want)
}
for i := range want {
if agent.deferredMentionKicks[i] != want[i] {
t.Fatalf("deferredMentionKicks[%d] = %+v, want %+v", i, agent.deferredMentionKicks[i], want[i])
}
}
if agent.pendingStartupKick != "" {
t.Fatalf("mention kick leaked into the coalesced startup slot: %q", agent.pendingStartupKick)
}
}

func TestDeferredStartupCadenceKickDoesNotEvictMention(t *testing.T) {
m := &Manager{agents: map[string]*AgentProcess{}, logger: discardLogger()}
agent := &AgentProcess{Name: "reviewer", startupLaunchQueued: true}
m.agents[agent.Name] = agent
got := make(chan [3]string, 4)
m.SetKickObserver(func(agentName, event, detail string) {
got <- [3]string{agentName, event, detail}
})

m.mu.Lock()
if !m.deferStartupKickLocked(agent, "please review", "mention:IC_1") {
t.Fatal("mention kick was not deferred")
}
if !m.deferStartupKickLocked(agent, "cadence 1", GovernorCadenceKickSource) {
t.Fatal("cadence kick was not deferred")
}
if !m.deferStartupKickLocked(agent, "cadence 2", GovernorCadenceKickSource) {
t.Fatal("second cadence kick was not deferred")
}
m.mu.Unlock()

select {
case ev := <-got:
t.Fatalf("cadence kick must not drop the deferred mention, got %v", ev)
case <-time.After(50 * time.Millisecond):
}
if len(agent.deferredMentionKicks) != 1 || agent.deferredMentionKicks[0].source != "mention:IC_1" {
t.Fatalf("deferredMentionKicks = %+v, want the mention kept", agent.deferredMentionKicks)
}
if agent.pendingStartupKick != "cadence 2" || agent.pendingStartupSource != GovernorCadenceKickSource {
t.Fatalf("cadence kicks did not coalesce: (%q,%q)", agent.pendingStartupKick, agent.pendingStartupSource)
}

m.mu.Lock()
msg, trigger, fromQueue := m.nextDeferredMentionKickLocked(agent, "one-shot prompt", "send-kick")
m.mu.Unlock()
if fromQueue || msg != "one-shot prompt" || trigger != "send-kick" {
t.Fatalf("one-shot kick must be delivered as sent, got (%q,%q,%v)", msg, trigger, fromQueue)
}
if len(agent.deferredMentionKicks) != 1 {
t.Fatalf("one-shot kick consumed the queued mention: %+v", agent.deferredMentionKicks)
}

m.mu.Lock()
msg, trigger, fromQueue = m.nextDeferredMentionKickLocked(agent, "cadence 3", GovernorCadenceKickSource)
m.mu.Unlock()
if !fromQueue || msg != "please review" || trigger != "mention:IC_1" {
t.Fatalf("next kick = (%q,%q,%v), want queued mention", msg, trigger, fromQueue)
}
removeDeferredMentionKickLocked(agent, trigger)
if len(agent.deferredMentionKicks) != 0 {
t.Fatalf("delivered mention not removed: %+v", agent.deferredMentionKicks)
}

m.mu.Lock()
msg, trigger, fromQueue = m.nextDeferredMentionKickLocked(agent, "cadence 4", GovernorCadenceKickSource)
m.mu.Unlock()
if fromQueue || msg != "cadence 4" || trigger != GovernorCadenceKickSource {
t.Fatalf("empty queue must pass the kick through, got (%q,%q,%v)", msg, trigger, fromQueue)
}
}

func TestDeferredStartupMentionQueueOverflowNotifiesDropped(t *testing.T) {
m := &Manager{agents: map[string]*AgentProcess{}, logger: discardLogger()}
agent := &AgentProcess{Name: "scanner", startupLaunchQueued: true}
m.agents[agent.Name] = agent
got := make(chan [3]string, 4)
m.SetKickObserver(func(agentName, event, detail string) {
got <- [3]string{agentName, event, detail}
})

m.mu.Lock()
for i := 0; i <= maxDeferredMentionKicks; i++ {
src := fmt.Sprintf("mention:%d", i)
if !m.deferStartupKickLocked(agent, "msg "+src, src) {
t.Fatalf("deferred startup kick %q was not accepted", src)
}
}
m.mu.Unlock()

select {
case ev := <-got:
want := [3]string{"scanner", "kick-dropped", "mention:0"}
if ev != want {
t.Fatalf("event = %v, want %v", ev, want)
}
case <-time.After(2 * time.Second):
t.Fatal("overflow did not notify dropped mention source")
}
if len(agent.deferredMentionKicks) != maxDeferredMentionKicks {
t.Fatalf("queue length = %d, want %d", len(agent.deferredMentionKicks), maxDeferredMentionKicks)
}
if agent.deferredMentionKicks[0].source != "mention:1" {
t.Fatalf("oldest queued = %q, want mention:1", agent.deferredMentionKicks[0].source)
}
}

func TestStopDropsDeferredMentionKicks(t *testing.T) {
m := &Manager{agents: map[string]*AgentProcess{}, logger: discardLogger()}
agent := &AgentProcess{Name: "scanner", State: StateStopped, startupLaunchQueued: true}
m.agents[agent.Name] = agent
got := make(chan [3]string, 4)
m.SetKickObserver(func(agentName, event, detail string) {
got <- [3]string{agentName, event, detail}
})

m.mu.Lock()
for _, src := range []string{"mention:a", "action:b"} {
if !m.deferStartupKickLocked(agent, "msg "+src, src) {
t.Fatalf("deferred startup kick %q was not accepted", src)
}
}
m.mu.Unlock()

if err := m.Stop("scanner"); err != nil {
t.Fatalf("Stop: %v", err)
}
if len(agent.deferredMentionKicks) != 0 {
t.Fatalf("Stop left queued mentions: %+v", agent.deferredMentionKicks)
}
dropped := map[string]bool{}
for i := 0; i < 2; i++ {
select {
case ev := <-got:
if ev[0] != "scanner" || ev[1] != "kick-dropped" {
t.Fatalf("event = %v, want kick-dropped", ev)
}
dropped[ev[2]] = true
case <-time.After(2 * time.Second):
t.Fatalf("Stop did not report every dropped mention, got %v", dropped)
}
}
if !dropped["mention:a"] || !dropped["action:b"] {
t.Fatalf("dropped sources = %v, want mention:a and action:b", dropped)
}
}
52 changes: 4 additions & 48 deletions src/crux/agent/kick_observer.go
Original file line number Diff line number Diff line change
@@ -1,7 +1,6 @@
package agent

import (
"strings"
"sync"
"time"

Expand All @@ -22,61 +21,18 @@ const kickObserverBuffer = 256
// Compile-time proof the in-process runtime offers fan-out observers.
var _ crux.KickObserverRegistry = (*Manager)(nil)

// kickObserverSourcePrefix separates the archive reason from the kick source
// in a kick-log-archived detail, so the mention responder can tell which
// kicks it summoned (hivecommons/hive#7483).
const kickObserverSourcePrefix = " source="

func kickObserverArchiveDetail(reason, source string) string {
reason = strings.TrimSpace(reason)
source = strings.TrimSpace(source)
if source == "" {
return reason
}
if reason == "" {
return kickObserverSourcePrefix + source
}
return reason + kickObserverSourcePrefix + source
}

// KickObserverDetailSource returns the kick source carried in an archive
// detail, or "" when it has none.
func KickObserverDetailSource(detail string) string {
if _, source, ok := strings.Cut(detail, kickObserverSourcePrefix); ok {
return strings.TrimSpace(source)
}
return ""
}

// KickObserverDetailReason returns the archive reason without the source.
func KickObserverDetailReason(detail string) string {
reason, _, _ := strings.Cut(detail, kickObserverSourcePrefix)
return strings.TrimSpace(reason)
}

// SetKickObserver installs (or with nil, removes) the single-slot kick
// lifecycle observer. Safe to leave unset: notifications are then no-ops.
//
// This is the compatibility path: it receives only kick-delivered and
// kick-log-archived, each on its own goroutine, and is independent of the
// fan-out observers (AddKickObserver). On this line it has two consumers,
// the mention responder and the Linear agent, so a second call chains after
// the installed observer instead of replacing it (hivecommons/hive#7483);
// nil clears every chained observer.
// This is the compatibility path (the Linear agent is its consumer): it
// receives only kick-delivered and kick-log-archived, each on its own
// goroutine, exactly as before AddKickObserver existed. It is independent of
// the fan-out observers.
func (m *Manager) SetKickObserver(fn func(agentName, event, detail string)) {
if fn == nil {
m.kickObserver.Store(nil)
return
}
if existing := m.kickObserver.Load(); existing != nil {
prev := *existing
chained := func(agentName, event, detail string) {
prev(agentName, event, detail)
fn(agentName, event, detail)
}
m.kickObserver.Store(&chained)
return
}
m.kickObserver.Store(&fn)
}

Expand Down
42 changes: 42 additions & 0 deletions src/crux/agent/kick_observer_source.go
Original file line number Diff line number Diff line change
@@ -0,0 +1,42 @@
package agent

import "strings"

// v6-only kick-source helpers (hivecommons/hive#7483). They live outside
// kick_observer.go so that file stays byte-identical to v5's and the v5 -> v6
// top-up carries it without a conflict.

// kickObserverSourcePrefix separates the archive reason from the kick source
// in a kick-log-archived detail, so the mention responder can tell which
// kicks it summoned (hivecommons/hive#7483).
const kickObserverSourcePrefix = " source="

// kickObserverArchiveDetail builds a kick-log-archived detail: the archive
// reason, then the kick source after kickObserverSourcePrefix when there is
// one.
func kickObserverArchiveDetail(reason, source string) string {
reason = strings.TrimSpace(reason)
source = strings.TrimSpace(source)
if source == "" {
return reason
}
if reason == "" {
return kickObserverSourcePrefix + source
}
return reason + kickObserverSourcePrefix + source
}

// KickObserverDetailSource returns the kick source carried in an archive
// detail, or "" when it has none.
func KickObserverDetailSource(detail string) string {
if _, source, ok := strings.Cut(detail, kickObserverSourcePrefix); ok {
return strings.TrimSpace(source)
}
return ""
}

// KickObserverDetailReason returns the archive reason without the source.
func KickObserverDetailReason(detail string) string {
reason, _, _ := strings.Cut(detail, kickObserverSourcePrefix)
return strings.TrimSpace(reason)
}
Loading
Loading