451e84aa76
Protect the global `instance` variable with sync.RWMutex to prevent data races when SetInstance/App() are called concurrently (especially in tests). Changes: - Add instanceMu mutex to protect instance variable - Update App() to use RLock for reading - Update SetInstance() to use Lock for writing - Add GetInstance() for non-panicking access - Add ClearInstance() for test cleanup - Update tests to use new thread-safe functions - Add concurrent access test with race detector Closes #84 Co-authored-by: Claude <noreply@anthropic.com>
123 lines
4 KiB
Go
123 lines
4 KiB
Go
package core
|
|
|
|
import (
|
|
"context"
|
|
"embed"
|
|
"sync"
|
|
)
|
|
|
|
// This file defines the public API contracts (interfaces) for the services
|
|
// in the Core framework. Services depend on these interfaces, not on
|
|
// concrete implementations.
|
|
|
|
// Contract specifies the operational guarantees that the Core and its services must adhere to.
|
|
// This is used for configuring panic handling and other resilience features.
|
|
type Contract struct {
|
|
// DontPanic, if true, instructs the Core to recover from panics and return an error instead.
|
|
DontPanic bool
|
|
// DisableLogging, if true, disables all logging from the Core and its services.
|
|
DisableLogging bool
|
|
}
|
|
|
|
// Features provides a way to check if a feature is enabled.
|
|
// This is used for feature flagging and conditional logic.
|
|
type Features struct {
|
|
// Flags is a list of enabled feature flags.
|
|
Flags []string
|
|
}
|
|
|
|
// IsEnabled returns true if the given feature is enabled.
|
|
func (f *Features) IsEnabled(feature string) bool {
|
|
for _, flag := range f.Flags {
|
|
if flag == feature {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
// Option is a function that configures the Core.
|
|
// This is used to apply settings and register services during initialization.
|
|
type Option func(*Core) error
|
|
|
|
// Message is the interface for all messages that can be sent through the Core's IPC system.
|
|
// Any struct can be a message, allowing for structured data to be passed between services.
|
|
// Used with ACTION for fire-and-forget broadcasts.
|
|
type Message interface{}
|
|
|
|
// Query is the interface for read-only requests that return data.
|
|
// Used with QUERY (first responder) or QUERYALL (all responders).
|
|
type Query interface{}
|
|
|
|
// Task is the interface for requests that perform side effects.
|
|
// Used with PERFORM (first responder executes).
|
|
type Task interface{}
|
|
|
|
// QueryHandler handles Query requests. Returns (result, handled, error).
|
|
// If handled is false, the query will be passed to the next handler.
|
|
type QueryHandler func(*Core, Query) (any, bool, error)
|
|
|
|
// TaskHandler handles Task requests. Returns (result, handled, error).
|
|
// If handled is false, the task will be passed to the next handler.
|
|
type TaskHandler func(*Core, Task) (any, bool, error)
|
|
|
|
// Startable is an interface for services that need to perform initialization.
|
|
type Startable interface {
|
|
OnStartup(ctx context.Context) error
|
|
}
|
|
|
|
// Stoppable is an interface for services that need to perform cleanup.
|
|
type Stoppable interface {
|
|
OnShutdown(ctx context.Context) error
|
|
}
|
|
|
|
// Core is the central application object that manages services, assets, and communication.
|
|
type Core struct {
|
|
App any // GUI runtime (e.g., Wails App) - set by WithApp option
|
|
assets embed.FS
|
|
Features *Features
|
|
serviceLock bool
|
|
ipcMu sync.RWMutex
|
|
ipcHandlers []func(*Core, Message) error
|
|
queryMu sync.RWMutex
|
|
queryHandlers []QueryHandler
|
|
taskMu sync.RWMutex
|
|
taskHandlers []TaskHandler
|
|
serviceMu sync.RWMutex
|
|
services map[string]any
|
|
servicesLocked bool
|
|
startables []Startable
|
|
stoppables []Stoppable
|
|
}
|
|
|
|
var (
|
|
instance *Core
|
|
instanceMu sync.RWMutex
|
|
)
|
|
|
|
// Config provides access to application configuration.
|
|
type Config interface {
|
|
// Get retrieves a configuration value by key and stores it in the 'out' variable.
|
|
Get(key string, out any) error
|
|
// Set stores a configuration value by key.
|
|
Set(key string, v any) error
|
|
}
|
|
|
|
// WindowOption is an interface for applying configuration options to a window.
|
|
type WindowOption interface {
|
|
Apply(any)
|
|
}
|
|
|
|
// Display provides access to windowing and visual elements.
|
|
type Display interface {
|
|
// OpenWindow creates a new window with the given options.
|
|
OpenWindow(opts ...WindowOption) error
|
|
}
|
|
|
|
// ActionServiceStartup is a message sent when the application's services are starting up.
|
|
// This provides a hook for services to perform initialization tasks.
|
|
type ActionServiceStartup struct{}
|
|
|
|
// ActionServiceShutdown is a message sent when the application is shutting down.
|
|
// This allows services to perform cleanup tasks, such as saving state or closing resources.
|
|
type ActionServiceShutdown struct{}
|