yonluandClaude Opus 5
4471db3aef
Phases 2 and 3 of plan 009, plus the parts of phase 1 that could not
land before them. Nothing in the tree imports wails/v2 any more; all
three lint and test configurations are green and `go build .` produces
a running binary.
The point of the migration is one file. backend/events/emit.go probed
ctx.Value("events") — a v2-*private* context key — to decide whether
emitting was safe, because runtime.EventsEmit called log.Fatalf on a
context without the runtime and took the process down with it. v3's
emit takes no context, so that is now application.Get() == nil. D1
held: events.Emit keeps its ctx as the WithSink test seam, and all 45
call sites and 7 test files are untouched.
The bootstrap splits into application.New + Window.NewWithOptions +
Run. Ten bound services implement ServiceStartup instead of being
handed a context by hand from OnStartup, which also stops ten
SetContext methods being exported as bindings. jobs.Registry and
explore.SearchIndex keep theirs — neither is bound, so converting them
would be churn for no binding removed.
Four things differed from the plan and are written up in it: GPU policy
moved to the per-window LinuxWindow options rather than surviving on
LinuxOptions; there is no OnStartup/OnDomReady option, so app-level
wiring hangs off ApplicationStarted; application.NewService is generic,
so FEBindings []any could not survive (the binding generator is a
static analyser and would have seen nothing); and the quit veto had to
be restructured, because v3's dialog answers on a callback rather than
returning the button, so ShouldQuit vetoes, asks, and quits again from
the callback.
Window state saving moves to a WindowClosing hook — the size has to be
read while the window still exists, and v3's OnShutdown has neither
context nor window. backend/logging is deleted rather than ported:
v3 takes a *slog.Logger directly, so the v2 logger.Logger adapter had
no caller left.
Phase 1's tail rides along, now that it can: the Makefile's wails
invocations, all 50 webkit2_41 sites, lefthook, both packaging recipes
and ci.yml's apt lists. v3 builds against GTK4 + WebKitGTK 6.0, which
Arch and ubuntu:24.04 both ship, so the tag is a deletion rather than
a translation.
Phase 4 is next and the branch is not usable until it lands: the app
builds, but frontend/wailsjs/ is v2's tree and nothing regenerates it,
so the frontend cannot reach the backend yet.
Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01UDCbcCZQepnpSQYJ6SxxZm
98 lines
3.1 KiB
Go
98 lines
3.1 KiB
Go
package events
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"log/slog"
|
|
|
|
"github.com/wailsapp/wails/v3/pkg/application"
|
|
)
|
|
|
|
// ErrNoRuntime is returned by Deliver when there is neither a test Sink
|
|
// in the context nor a running application, so the event went nowhere.
|
|
var ErrNoRuntime = errors.New(
|
|
"no Wails runtime or event sink in context",
|
|
)
|
|
|
|
// Sink receives events in place of the Wails runtime.
|
|
//
|
|
// Installing one with WithSink is what makes a service that emits
|
|
// events testable in-process: see Deliver for why the real runtime
|
|
// cannot be used there.
|
|
type Sink interface {
|
|
Emit(name string, data ...any)
|
|
}
|
|
|
|
// sinkKey is the private context key an installed Sink is stored under.
|
|
type sinkKey struct{}
|
|
|
|
// WithSink returns a context whose events are recorded by sink rather
|
|
// than pushed to the frontend.
|
|
//
|
|
// The sink travels in the context rather than in a package-level
|
|
// variable so that parallel tests cannot observe each other's events
|
|
// and so that production emits pay no synchronisation cost.
|
|
func WithSink(ctx context.Context, sink Sink) context.Context {
|
|
return context.WithValue(ctx, sinkKey{}, sink)
|
|
}
|
|
|
|
// sinkFrom returns the Sink installed in ctx, or nil.
|
|
func sinkFrom(ctx context.Context) Sink {
|
|
sink, _ := ctx.Value(sinkKey{}).(Sink)
|
|
|
|
return sink
|
|
}
|
|
|
|
// Emit publishes a Wails event, tolerating any context.
|
|
//
|
|
// This is the only supported way to emit an event: nothing outside this
|
|
// package may call app.Event.Emit, which TestNoDirectRuntimeEmits
|
|
// enforces. That rule outlived its original reason — v2's
|
|
// runtime.EventsEmit called log.Fatalf on a context that did not carry
|
|
// the runtime, taking the process down from any background worker —
|
|
// and is kept because one emit path is what keeps emitStatus-style
|
|
// deduplication honest.
|
|
//
|
|
// The context is no longer a delivery mechanism: v3's emit takes none.
|
|
// It stays because WithSink travels in it, which is what makes a
|
|
// service that emits events testable in-process.
|
|
func Emit(ctx context.Context, name string, data ...any) {
|
|
if err := Deliver(ctx, name, data...); err != nil {
|
|
slog.Default().Debug(
|
|
"dropping event, no Wails runtime in context",
|
|
"event", name,
|
|
)
|
|
}
|
|
}
|
|
|
|
// Deliver is Emit for the one caller that must know whether delivery
|
|
// happened: the dev control surface (backend/testctl), whose whole
|
|
// purpose is to impersonate a backend emit and which would otherwise
|
|
// report success for an event that went nowhere.
|
|
//
|
|
// Ordinary emitters want Emit.
|
|
func Deliver(ctx context.Context, name string, data ...any) error {
|
|
// A nil context cannot carry a sink, but it is no longer a reason
|
|
// not to deliver: v3 emits through the application, not the context.
|
|
if ctx != nil {
|
|
if sink := sinkFrom(ctx); sink != nil {
|
|
sink.Emit(name, data...)
|
|
|
|
return nil
|
|
}
|
|
}
|
|
|
|
// application.Get() returns nil when no app is running — under test,
|
|
// before Run, and after shutdown. It does not terminate the
|
|
// process, which is what the v2 probe of the private "events"
|
|
// context key existed to avoid.
|
|
app := application.Get()
|
|
if app == nil {
|
|
return ErrNoRuntime
|
|
}
|
|
|
|
app.Event.Emit(name, data...)
|
|
|
|
return nil
|
|
}
|