140 lines
4.3 KiB
Go
140 lines
4.3 KiB
Go
package service
|
|
|
|
import (
|
|
"acc-server-manager/local/utl/command"
|
|
"acc-server-manager/local/utl/env"
|
|
"acc-server-manager/local/utl/logging"
|
|
"context"
|
|
"fmt"
|
|
"path/filepath"
|
|
"strings"
|
|
)
|
|
|
|
type WindowsService struct {
|
|
executor *command.CommandExecutor
|
|
}
|
|
|
|
func NewWindowsService() *WindowsService {
|
|
return &WindowsService{
|
|
executor: &command.CommandExecutor{
|
|
ExePath: "powershell",
|
|
LogOutput: true,
|
|
},
|
|
}
|
|
}
|
|
|
|
// executeNSSM runs an NSSM command through PowerShell with elevation
|
|
func (s *WindowsService) ExecuteNSSM(ctx context.Context, args ...string) (string, error) {
|
|
// Get NSSM path from environment variable
|
|
nssmPath := env.GetNSSMPath()
|
|
|
|
// Prepend NSSM path to arguments
|
|
nssmArgs := append([]string{"-NoProfile", "-NonInteractive", "-Command", "& " + nssmPath}, args...)
|
|
|
|
output, err := s.executor.ExecuteWithOutput(nssmArgs...)
|
|
if err != nil {
|
|
// Log the full command and error for debugging
|
|
logging.Error("NSSM command failed: powershell %s", strings.Join(nssmArgs, " "))
|
|
logging.Error("NSSM error output: %s", output)
|
|
return "", err
|
|
}
|
|
|
|
// Clean up output by removing null bytes and trimming whitespace
|
|
cleaned := strings.TrimSpace(strings.ReplaceAll(output, "\x00", ""))
|
|
// Remove \r\n from status strings
|
|
cleaned = strings.TrimSuffix(cleaned, "\r\n")
|
|
|
|
return cleaned, nil
|
|
}
|
|
|
|
// Service Installation/Configuration Methods
|
|
|
|
func (s *WindowsService) CreateService(ctx context.Context, serviceName, execPath, workingDir string, args []string) error {
|
|
// Ensure paths are absolute and properly formatted for Windows
|
|
absExecPath, err := filepath.Abs(execPath)
|
|
if err != nil {
|
|
return fmt.Errorf("failed to get absolute path for executable: %v", err)
|
|
}
|
|
absExecPath = filepath.Clean(absExecPath)
|
|
|
|
absWorkingDir, err := filepath.Abs(workingDir)
|
|
if err != nil {
|
|
return fmt.Errorf("failed to get absolute path for working directory: %v", err)
|
|
}
|
|
absWorkingDir = filepath.Clean(absWorkingDir)
|
|
|
|
// Log the paths being used
|
|
logging.Info("Creating service '%s' with:", serviceName)
|
|
logging.Info(" Executable: %s", absExecPath)
|
|
logging.Info(" Working Directory: %s", absWorkingDir)
|
|
|
|
// First remove any existing service with the same name
|
|
s.ExecuteNSSM(ctx, "remove", serviceName, "confirm")
|
|
|
|
// Install service
|
|
if _, err := s.ExecuteNSSM(ctx, "install", serviceName, absExecPath); err != nil {
|
|
return fmt.Errorf("failed to install service: %v", err)
|
|
}
|
|
|
|
// Set arguments if provided
|
|
if len(args) > 0 {
|
|
cmdArgs := append([]string{"set", serviceName, "AppParameters"}, args...)
|
|
if _, err := s.ExecuteNSSM(ctx, cmdArgs...); err != nil {
|
|
// Try to clean up on failure
|
|
s.ExecuteNSSM(ctx, "remove", serviceName, "confirm")
|
|
return fmt.Errorf("failed to set arguments: %v", err)
|
|
}
|
|
}
|
|
|
|
// Verify service was created
|
|
if _, err := s.ExecuteNSSM(ctx, "get", serviceName, "Application"); err != nil {
|
|
return fmt.Errorf("service creation verification failed: %v", err)
|
|
}
|
|
|
|
logging.Info("Created Windows service: %s", serviceName)
|
|
return nil
|
|
}
|
|
|
|
func (s *WindowsService) DeleteService(ctx context.Context, serviceName string) error {
|
|
if _, err := s.ExecuteNSSM(ctx, "remove", serviceName, "confirm"); err != nil {
|
|
return fmt.Errorf("failed to remove service: %v", err)
|
|
}
|
|
|
|
logging.Info("Removed Windows service: %s", serviceName)
|
|
return nil
|
|
}
|
|
|
|
func (s *WindowsService) UpdateService(ctx context.Context, serviceName, execPath, workingDir string, args []string) error {
|
|
// First remove the existing service
|
|
if err := s.DeleteService(ctx, serviceName); err != nil {
|
|
return err
|
|
}
|
|
|
|
// Then create it again with new parameters
|
|
return s.CreateService(ctx, serviceName, execPath, workingDir, args)
|
|
}
|
|
|
|
// Service Control Methods
|
|
|
|
func (s *WindowsService) Status(ctx context.Context, serviceName string) (string, error) {
|
|
return s.ExecuteNSSM(ctx, "status", serviceName)
|
|
}
|
|
|
|
func (s *WindowsService) Start(ctx context.Context, serviceName string) (string, error) {
|
|
return s.ExecuteNSSM(ctx, "start", serviceName)
|
|
}
|
|
|
|
func (s *WindowsService) Stop(ctx context.Context, serviceName string) (string, error) {
|
|
return s.ExecuteNSSM(ctx, "stop", serviceName)
|
|
}
|
|
|
|
func (s *WindowsService) Restart(ctx context.Context, serviceName string) (string, error) {
|
|
// First stop the service
|
|
if _, err := s.Stop(ctx, serviceName); err != nil {
|
|
return "", err
|
|
}
|
|
|
|
// Then start it again
|
|
return s.Start(ctx, serviceName)
|
|
}
|