mirror of
https://github.com/Xevion/HATray.git
synced 2025-12-05 23:15:09 -06:00
feat!: expand to internal project, add app layer, develop service layer
This commit is contained in:
110
internal/app.go
Normal file
110
internal/app.go
Normal file
@@ -0,0 +1,110 @@
|
||||
package internal
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"io"
|
||||
"log/slog"
|
||||
"os"
|
||||
"path/filepath"
|
||||
|
||||
"ha-tray/internal/app"
|
||||
"ha-tray/internal/service"
|
||||
)
|
||||
|
||||
// App represents the main application
|
||||
type App struct {
|
||||
appLayer *app.App
|
||||
service service.Service
|
||||
logger *slog.Logger
|
||||
logFile *os.File
|
||||
}
|
||||
|
||||
// NewApp creates a new application instance
|
||||
func NewApp() *App {
|
||||
return &App{}
|
||||
}
|
||||
|
||||
// Setup initializes the application with logging and panic handling
|
||||
func (a *App) Setup() error {
|
||||
// Setup panic recovery
|
||||
defer a.recoverPanic()
|
||||
|
||||
// Setup logging
|
||||
if err := a.setupLogging(); err != nil {
|
||||
return fmt.Errorf("failed to setup logging: %v", err)
|
||||
}
|
||||
|
||||
// Setup app layer
|
||||
a.appLayer = app.NewApp(a.logger)
|
||||
|
||||
// Setup service
|
||||
if err := a.setupService(); err != nil {
|
||||
return fmt.Errorf("failed to setup service: %v", err)
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
// Run starts the application
|
||||
func (a *App) Run() error {
|
||||
defer a.cleanup()
|
||||
|
||||
a.logger.Info("Starting HATray application")
|
||||
|
||||
// Run the service
|
||||
return a.service.Run()
|
||||
}
|
||||
|
||||
// setupLogging initializes structured logging
|
||||
func (a *App) setupLogging() error {
|
||||
// Get the directory where the executable is located
|
||||
exePath, err := os.Executable()
|
||||
if err != nil {
|
||||
return fmt.Errorf("failed to get executable path: %v", err)
|
||||
}
|
||||
exeDir := filepath.Dir(exePath)
|
||||
|
||||
// Open log file in the same directory as the executable
|
||||
logFile, err := os.OpenFile(filepath.Join(exeDir, "current.log"), os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
|
||||
if err != nil {
|
||||
return fmt.Errorf("failed to open log file: %v", err)
|
||||
}
|
||||
|
||||
a.logFile = logFile
|
||||
|
||||
// Create multi-writer to log to both file and stdout
|
||||
multiWriter := io.MultiWriter(logFile, os.Stdout)
|
||||
|
||||
// Create JSON handler for structured logging
|
||||
handler := slog.NewJSONHandler(multiWriter, &slog.HandlerOptions{
|
||||
Level: slog.LevelDebug,
|
||||
})
|
||||
a.logger = slog.New(handler)
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
// setupService initializes the platform-specific service
|
||||
func (a *App) setupService() error {
|
||||
// Platform-specific service initialization using build flags
|
||||
a.service = service.NewService(a.logger, a.appLayer)
|
||||
return nil
|
||||
}
|
||||
|
||||
// recoverPanic handles panic recovery and logs the error
|
||||
func (a *App) recoverPanic() {
|
||||
if r := recover(); r != nil {
|
||||
if a.logger != nil {
|
||||
a.logger.Error("Panic recovered", "panic", r)
|
||||
} else {
|
||||
fmt.Printf("Panic recovered: %v\n", r)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// cleanup performs cleanup operations
|
||||
func (a *App) cleanup() {
|
||||
if a.logFile != nil {
|
||||
a.logFile.Close()
|
||||
}
|
||||
}
|
||||
148
internal/app/app.go
Normal file
148
internal/app/app.go
Normal file
@@ -0,0 +1,148 @@
|
||||
package app
|
||||
|
||||
import (
|
||||
"log/slog"
|
||||
"sync"
|
||||
)
|
||||
|
||||
// App represents the main application layer that is generic and cross-platform
|
||||
type App struct {
|
||||
logger *slog.Logger
|
||||
mu sync.RWMutex
|
||||
state AppState
|
||||
}
|
||||
|
||||
// AppState represents the current state of the application
|
||||
type AppState string
|
||||
|
||||
const (
|
||||
StateRunning AppState = "running"
|
||||
StatePaused AppState = "paused"
|
||||
StateStopped AppState = "stopped"
|
||||
)
|
||||
|
||||
// NewApp creates a new application instance
|
||||
func NewApp(logger *slog.Logger) *App {
|
||||
return &App{
|
||||
logger: logger,
|
||||
state: StateRunning,
|
||||
}
|
||||
}
|
||||
|
||||
// Pause disconnects from the server and ceases any background tasks
|
||||
func (a *App) Pause() error {
|
||||
a.mu.Lock()
|
||||
defer a.mu.Unlock()
|
||||
|
||||
a.logger.Info("Pausing application",
|
||||
"action", "pause",
|
||||
"previous_state", a.state,
|
||||
"new_state", StatePaused)
|
||||
|
||||
// TODO: Implement actual pause logic
|
||||
// - Disconnect from Home Assistant WebSocket
|
||||
// - Stop background tasks
|
||||
// - Pause sensor monitoring
|
||||
|
||||
a.state = StatePaused
|
||||
|
||||
a.logger.Info("Application paused successfully",
|
||||
"action", "pause",
|
||||
"state", a.state)
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
// Resume connects to the server and initiates background tasks
|
||||
func (a *App) Resume() error {
|
||||
a.mu.Lock()
|
||||
defer a.mu.Unlock()
|
||||
|
||||
a.logger.Info("Resuming application",
|
||||
"action", "resume",
|
||||
"previous_state", a.state,
|
||||
"new_state", StateRunning)
|
||||
|
||||
// TODO: Implement actual resume logic
|
||||
// - Connect to Home Assistant WebSocket
|
||||
// - Start background tasks
|
||||
// - Resume sensor monitoring
|
||||
|
||||
a.state = StateRunning
|
||||
|
||||
a.logger.Info("Application resumed successfully",
|
||||
"action", "resume",
|
||||
"state", a.state)
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
// Reload pauses the application, re-reads configuration files, then resumes
|
||||
func (a *App) Reload() error {
|
||||
a.logger.Info("Starting application reload",
|
||||
"action", "reload",
|
||||
"current_state", a.state)
|
||||
|
||||
// Pause if not already paused
|
||||
if a.state != StatePaused {
|
||||
if err := a.Pause(); err != nil {
|
||||
a.logger.Error("Failed to pause during reload",
|
||||
"action", "reload",
|
||||
"error", err)
|
||||
return err
|
||||
}
|
||||
}
|
||||
|
||||
// TODO: Implement configuration reload logic
|
||||
// - Re-read TOML configuration files
|
||||
// - Validate configuration
|
||||
// - Update internal state with new configuration
|
||||
|
||||
a.logger.Info("Configuration reloaded successfully",
|
||||
"action", "reload")
|
||||
|
||||
// Resume the application
|
||||
if err := a.Resume(); err != nil {
|
||||
a.logger.Error("Failed to resume after reload",
|
||||
"action", "reload",
|
||||
"error", err)
|
||||
return err
|
||||
}
|
||||
|
||||
a.logger.Info("Application reload completed successfully",
|
||||
"action", "reload",
|
||||
"final_state", a.state)
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
// GetState returns the current state of the application
|
||||
func (a *App) GetState() AppState {
|
||||
a.mu.RLock()
|
||||
defer a.mu.RUnlock()
|
||||
return a.state
|
||||
}
|
||||
|
||||
// Stop stops the application completely
|
||||
func (a *App) Stop() error {
|
||||
a.mu.Lock()
|
||||
defer a.mu.Unlock()
|
||||
|
||||
a.logger.Info("Stopping application",
|
||||
"action", "stop",
|
||||
"previous_state", a.state,
|
||||
"new_state", StateStopped)
|
||||
|
||||
// TODO: Implement actual stop logic
|
||||
// - Disconnect from all services
|
||||
// - Clean up resources
|
||||
// - Stop all background tasks
|
||||
|
||||
a.state = StateStopped
|
||||
|
||||
a.logger.Info("Application stopped successfully",
|
||||
"action", "stop",
|
||||
"state", a.state)
|
||||
|
||||
return nil
|
||||
}
|
||||
17
internal/service/service.go
Normal file
17
internal/service/service.go
Normal file
@@ -0,0 +1,17 @@
|
||||
package service
|
||||
|
||||
import (
|
||||
"ha-tray/internal/app"
|
||||
"log/slog"
|
||||
)
|
||||
|
||||
// This is an intentionally very-simple interface as the main program entrypoint needs to know very little about the service layer.
|
||||
// The service layer is completely responsible for the lifecycle of the application, implemented per-platform.
|
||||
type Service interface {
|
||||
Run() error
|
||||
}
|
||||
|
||||
// NewService creates a new service instance for the current platform
|
||||
func NewService(logger *slog.Logger, appLayer *app.App) Service {
|
||||
return newService(logger, appLayer)
|
||||
}
|
||||
149
internal/service/windows.go
Normal file
149
internal/service/windows.go
Normal file
@@ -0,0 +1,149 @@
|
||||
//go:build windows
|
||||
|
||||
package service
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"log/slog"
|
||||
"time"
|
||||
|
||||
"ha-tray/internal/app"
|
||||
|
||||
"golang.org/x/sys/windows/svc"
|
||||
"golang.org/x/sys/windows/svc/debug"
|
||||
"golang.org/x/sys/windows/svc/eventlog"
|
||||
)
|
||||
|
||||
const serviceName = "HATray"
|
||||
|
||||
// WindowsService implements the Service interface for Windows
|
||||
type WindowsService struct {
|
||||
logger *slog.Logger
|
||||
elog debug.Log
|
||||
isDebug bool
|
||||
app *app.App
|
||||
}
|
||||
|
||||
// newService creates a new Windows service instance
|
||||
func newService(logger *slog.Logger, appLayer *app.App) Service {
|
||||
return &WindowsService{
|
||||
logger: logger,
|
||||
app: appLayer,
|
||||
}
|
||||
}
|
||||
|
||||
// Run implements the Service interface for Windows
|
||||
func (w *WindowsService) Run() error {
|
||||
// Determine if we're running as a Windows service
|
||||
isService, err := svc.IsWindowsService()
|
||||
if err != nil {
|
||||
return fmt.Errorf("failed to determine if running as Windows service: %v", err)
|
||||
}
|
||||
|
||||
w.isDebug = !isService
|
||||
|
||||
if isService {
|
||||
return w.runAsService()
|
||||
}
|
||||
|
||||
// Interactive mode
|
||||
return w.runInteractive()
|
||||
}
|
||||
|
||||
// runAsService runs the application as a Windows service
|
||||
func (w *WindowsService) runAsService() error {
|
||||
var err error
|
||||
if w.isDebug {
|
||||
w.elog = debug.New(serviceName)
|
||||
} else {
|
||||
w.elog, err = eventlog.Open(serviceName)
|
||||
if err != nil {
|
||||
return fmt.Errorf("failed to open event log: %v", err)
|
||||
}
|
||||
}
|
||||
defer w.elog.Close()
|
||||
|
||||
w.elog.Info(1, fmt.Sprintf("starting %s service", serviceName))
|
||||
|
||||
run := svc.Run
|
||||
if w.isDebug {
|
||||
run = debug.Run
|
||||
}
|
||||
|
||||
err = run(serviceName, &windowsServiceHandler{
|
||||
service: w,
|
||||
})
|
||||
|
||||
if err != nil {
|
||||
w.elog.Error(1, fmt.Sprintf("%s service failed: %v", serviceName, err))
|
||||
return err
|
||||
}
|
||||
|
||||
w.elog.Info(1, fmt.Sprintf("%s service stopped", serviceName))
|
||||
return nil
|
||||
}
|
||||
|
||||
// runInteractive runs the application in interactive mode
|
||||
func (w *WindowsService) runInteractive() error {
|
||||
w.logger.Info("Application starting in interactive mode")
|
||||
|
||||
// Simple interactive loop
|
||||
ticker := time.NewTicker(30 * time.Second)
|
||||
defer ticker.Stop()
|
||||
|
||||
for range ticker.C {
|
||||
w.logger.Debug("Application heartbeat")
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
// windowsServiceHandler implements the Windows service handler interface
|
||||
type windowsServiceHandler struct {
|
||||
service *WindowsService
|
||||
}
|
||||
|
||||
func (h *windowsServiceHandler) Execute(args []string, r <-chan svc.ChangeRequest, changes chan<- svc.Status) (ssec bool, errno uint32) {
|
||||
const cmdsAccepted = svc.AcceptStop | svc.AcceptShutdown | svc.AcceptPauseAndContinue
|
||||
changes <- svc.Status{State: svc.StartPending}
|
||||
|
||||
h.service.logger.Info("Service starting")
|
||||
changes <- svc.Status{State: svc.Running, Accepts: cmdsAccepted}
|
||||
|
||||
// Main service loop
|
||||
ticker := time.NewTicker(5 * time.Second)
|
||||
defer ticker.Stop()
|
||||
|
||||
for {
|
||||
select {
|
||||
case c := <-r:
|
||||
switch c.Cmd {
|
||||
case svc.Interrogate:
|
||||
changes <- c.CurrentStatus
|
||||
case svc.Stop, svc.Shutdown:
|
||||
h.service.logger.Info("Service stopping")
|
||||
changes <- svc.Status{State: svc.StopPending}
|
||||
if err := h.service.app.Stop(); err != nil {
|
||||
h.service.logger.Error("Failed to stop app layer", "error", err)
|
||||
}
|
||||
return
|
||||
case svc.Pause:
|
||||
h.service.logger.Info("Service pausing")
|
||||
changes <- svc.Status{State: svc.Paused, Accepts: cmdsAccepted}
|
||||
if err := h.service.app.Pause(); err != nil {
|
||||
h.service.logger.Error("Failed to pause app layer", "error", err)
|
||||
}
|
||||
case svc.Continue:
|
||||
h.service.logger.Info("Service continuing")
|
||||
changes <- svc.Status{State: svc.Running, Accepts: cmdsAccepted}
|
||||
if err := h.service.app.Resume(); err != nil {
|
||||
h.service.logger.Error("Failed to resume app layer", "error", err)
|
||||
}
|
||||
default:
|
||||
h.service.elog.Error(uint32(1), fmt.Sprintf("unexpected control request #%d", c))
|
||||
}
|
||||
case <-ticker.C:
|
||||
h.service.logger.Debug("Service heartbeat")
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user