Fills in the `pubsub` section of the deployment health report on the server. Stacked on #31620. - New `pubsub.ReportingPubsub` interface: `Pubsub` plus `HealthReport(ctx) healthsdk.PubsubReport`. The `Pubsub` interface itself is unchanged. - The PostgreSQL, NATS and in-memory backends implement it. Each reports its backend name (`postgres`, `nats` or `memory`) and its connection state: - **PostgreSQL:** tracks the `pq` listener's connected state from its event callback. When it's not connected, the report has severity `warning` and `EPS01`. - **NATS:** warns with `EPS02` if the embedded server isn't `Running()`, and with `EPS01` for each publish or subscribe connection whose `Status()` isn't `CONNECTED`. - **In-memory:** always `ok`. - `coderd.Options.Pubsub` is now a `ReportingPubsub`. `ReplicaSyncPubsub` stays a plain `Pubsub`. - `coderd/healthcheck` has a new `Pubsub` check, which counts toward `healthy` and the overall severity like the other sections. `formatHealthcheck` applies the dismissed setting for it. - New health codes `EPS01` (not connected) and `EPS02` (embedded NATS server not running), documented in `docs/admin/monitoring/health-check.md`. - Test helpers follow the type change: `coderdtest.Options.Pubsub` and the pubsub returned by `dbtestutil.NewDB` are now `ReportingPubsub`, and a few test wrappers embed `ReportingPubsub` instead of `Pubsub`. <details> <summary>Decision log</summary> - `HealthReport` returns a `healthsdk.PubsubReport` rather than filling one in place. This matches the `healthcheck.Checker` methods. `ctx` is unused for now. - The healthcheck layer sets `Dismissed`, so backends don't need to know about health settings. - Problems are reported as warnings, not errors, so they show on the health page without marking the deployment unhealthy. Both backends reconnect on their own. - Postgres connection state comes from the listener event callback, not from `pq.Listener.Ping`, so the health check doesn't do database I/O. Closing the pubsub also marks it disconnected. - NATS `conn` gains `Status()`, which `*natsgo.Conn` already implements. The pools are immutable after construction, so `HealthReport` reads them without locking. - The docs say the pubsub section appears in the JSON response, because the health UI doesn't show it until a later PR in this stack. - psmock is not regenerated: none of its users pass it to coderd. </details> --- Generated by Coder Agents on behalf of @spikecurtis.
112 lines
2.5 KiB
Go
112 lines
2.5 KiB
Go
package pubsub
|
|
|
|
import (
|
|
"context"
|
|
"sync"
|
|
|
|
"github.com/google/uuid"
|
|
|
|
"github.com/coder/coder/v2/coderd/healthcheck/health"
|
|
"github.com/coder/coder/v2/codersdk/healthsdk"
|
|
)
|
|
|
|
// genericListener is either a Listener or ListenerWithErr
|
|
type genericListener struct {
|
|
l Listener
|
|
le ListenerWithErr
|
|
}
|
|
|
|
func (g genericListener) send(ctx context.Context, message []byte) {
|
|
if g.l != nil {
|
|
g.l(ctx, message)
|
|
}
|
|
if g.le != nil {
|
|
g.le(ctx, message, nil)
|
|
}
|
|
}
|
|
|
|
// MemoryPubsub is an in-memory Pubsub implementation. It's an exported type so that our test code can do type
|
|
// checks.
|
|
type MemoryPubsub struct {
|
|
mut sync.RWMutex
|
|
listeners map[string]map[uuid.UUID]genericListener
|
|
}
|
|
|
|
func (m *MemoryPubsub) Subscribe(event string, listener Listener) (cancel func(), err error) {
|
|
return m.subscribeGeneric(event, genericListener{l: listener})
|
|
}
|
|
|
|
func (m *MemoryPubsub) SubscribeWithErr(event string, listener ListenerWithErr) (cancel func(), err error) {
|
|
return m.subscribeGeneric(event, genericListener{le: listener})
|
|
}
|
|
|
|
func (m *MemoryPubsub) subscribeGeneric(event string, listener genericListener) (cancel func(), err error) {
|
|
m.mut.Lock()
|
|
defer m.mut.Unlock()
|
|
|
|
var listeners map[uuid.UUID]genericListener
|
|
var ok bool
|
|
if listeners, ok = m.listeners[event]; !ok {
|
|
listeners = map[uuid.UUID]genericListener{}
|
|
m.listeners[event] = listeners
|
|
}
|
|
var id uuid.UUID
|
|
for {
|
|
id = uuid.New()
|
|
if _, ok = listeners[id]; !ok {
|
|
break
|
|
}
|
|
}
|
|
listeners[id] = listener
|
|
return func() {
|
|
m.mut.Lock()
|
|
defer m.mut.Unlock()
|
|
listeners := m.listeners[event]
|
|
delete(listeners, id)
|
|
}, nil
|
|
}
|
|
|
|
func (m *MemoryPubsub) Publish(event string, message []byte) error {
|
|
m.mut.RLock()
|
|
defer m.mut.RUnlock()
|
|
listeners, ok := m.listeners[event]
|
|
if !ok {
|
|
return nil
|
|
}
|
|
var wg sync.WaitGroup
|
|
for _, listener := range listeners {
|
|
wg.Add(1)
|
|
go func() {
|
|
defer wg.Done()
|
|
listener.send(context.Background(), message)
|
|
}()
|
|
}
|
|
wg.Wait()
|
|
|
|
return nil
|
|
}
|
|
|
|
func (*MemoryPubsub) Close() error {
|
|
return nil
|
|
}
|
|
|
|
// BackendMemory is the backend name reported by MemoryPubsub.
|
|
const BackendMemory = "memory"
|
|
|
|
// HealthReport implements ReportingPubsub.
|
|
func (*MemoryPubsub) HealthReport(context.Context) healthsdk.PubsubReport {
|
|
return healthsdk.PubsubReport{
|
|
BaseReport: healthsdk.BaseReport{
|
|
Severity: health.SeverityOK,
|
|
Warnings: []health.Message{},
|
|
},
|
|
Backend: BackendMemory,
|
|
}
|
|
}
|
|
|
|
func NewInMemory() ReportingPubsub {
|
|
return &MemoryPubsub{
|
|
listeners: make(map[string]map[uuid.UUID]genericListener),
|
|
}
|
|
}
|