mirror of
https://github.com/netbirdio/netbird.git
synced 2026-05-16 05:39:56 +00:00
d841a6aa07
Two related daemon-side status-stream fixes that together keep the UI's
status in sync with the daemon's contextState:
* state.Set previously only mutated the in-memory enum — transitions
that weren't accompanied by a Mark{Management,Signal,...} call (e.g.
StatusNeedsLogin after a PermissionDenied login, StatusLoginFailed
after OAuth init failure, StatusIdle in the Login defer) left the
UI stuck on the previous snapshot until an unrelated peer event
happened to fire notifyStateChange. Add a callback on contextState
fired from Set (outside the mutex, to avoid lock-order issues with
the recorder's stateChangeMux), and wire it in Server.Start to the
recorder's new public NotifyStateChange. Every state.Set callsite
now pushes automatically; new ones don't need to opt in.
* WaitSSOLogin's WaitToken error branch lumped every failure into
StatusLoginFailed, including context.Canceled aborts from a parallel
profile switch (actCancel/waitCancel). That spurious LoginFailed
then wedged the new profile's Up RPC with "up already in progress:
current status LoginFailed". Split the branch by error type:
context.Canceled lets the top-level defer pick StatusIdle,
context.DeadlineExceeded sets StatusNeedsLogin (retryable; OAuth
device-code window just expired), other errors keep LoginFailed
(real auth/IO failures). Document the full state-transition table
in the function godoc.
99 lines
2.2 KiB
Go
99 lines
2.2 KiB
Go
package internal
|
|
|
|
import (
|
|
"context"
|
|
"sync"
|
|
)
|
|
|
|
type StatusType string
|
|
|
|
const (
|
|
StatusIdle StatusType = "Idle"
|
|
|
|
StatusConnecting StatusType = "Connecting"
|
|
StatusConnected StatusType = "Connected"
|
|
StatusNeedsLogin StatusType = "NeedsLogin"
|
|
StatusLoginFailed StatusType = "LoginFailed"
|
|
StatusSessionExpired StatusType = "SessionExpired"
|
|
)
|
|
|
|
// CtxInitState setup context state into the context tree.
|
|
//
|
|
// This function should be used to initialize context before
|
|
// CtxGetState will be executed.
|
|
func CtxInitState(ctx context.Context) context.Context {
|
|
return context.WithValue(ctx, stateCtx, &contextState{
|
|
status: StatusIdle,
|
|
})
|
|
}
|
|
|
|
// CtxGetState object to get/update state/errors of process.
|
|
func CtxGetState(ctx context.Context) *contextState {
|
|
return ctx.Value(stateCtx).(*contextState)
|
|
}
|
|
|
|
type contextState struct {
|
|
err error
|
|
status StatusType
|
|
mutex sync.Mutex
|
|
onChange func()
|
|
}
|
|
|
|
// SetOnChange installs a callback fired after every successful Set. Used by
|
|
// the daemon to wire the status recorder's notifyStateChange so any
|
|
// state.Set in the connect/login paths pushes a fresh snapshot to
|
|
// SubscribeStatus subscribers without each callsite having to opt in.
|
|
// The callback runs outside the contextState mutex to avoid a lock-order
|
|
// dependency with the recorder's stateChangeMux.
|
|
func (c *contextState) SetOnChange(fn func()) {
|
|
c.mutex.Lock()
|
|
c.onChange = fn
|
|
c.mutex.Unlock()
|
|
}
|
|
|
|
func (c *contextState) Set(update StatusType) {
|
|
c.mutex.Lock()
|
|
c.status = update
|
|
c.err = nil
|
|
cb := c.onChange
|
|
c.mutex.Unlock()
|
|
|
|
if cb != nil {
|
|
cb()
|
|
}
|
|
}
|
|
|
|
func (c *contextState) Status() (StatusType, error) {
|
|
c.mutex.Lock()
|
|
defer c.mutex.Unlock()
|
|
|
|
if c.err != nil {
|
|
return "", c.err
|
|
}
|
|
|
|
return c.status, nil
|
|
}
|
|
|
|
// CurrentStatus returns the last status set via Set, ignoring any wrapped
|
|
// error. Use when the status is needed for reporting purposes (e.g. the
|
|
// status snapshot stream) and a transient wrapped error from a retry loop
|
|
// shouldn't blank out the underlying status.
|
|
func (c *contextState) CurrentStatus() StatusType {
|
|
c.mutex.Lock()
|
|
defer c.mutex.Unlock()
|
|
|
|
return c.status
|
|
}
|
|
|
|
func (c *contextState) Wrap(err error) error {
|
|
c.mutex.Lock()
|
|
defer c.mutex.Unlock()
|
|
|
|
c.err = err
|
|
return err
|
|
}
|
|
|
|
type stateKey int
|
|
|
|
var stateCtx stateKey
|