update caching and server creation

2025-06-01 19:48:39 +02:00
parent 8a3b11b1ef
commit d57013bb50
26 changed files with 888 additions and 249 deletions
--- a/local/service/config.go
+++ b/local/service/config.go
@@ -6,6 +6,7 @@ import (
 	"acc-server-manager/local/utl/common"
 	"acc-server-manager/local/utl/logging"
 	"bytes"
+	"context"
 	"encoding/json"
 	"errors"
 	"fmt"
@@ -70,6 +71,7 @@ type ConfigService struct {
 }

 func NewConfigService(repository *repository.ConfigRepository, serverRepository *repository.ServerRepository) *ConfigService {
+	logging.Debug("Initializing ConfigService with 5m expiration and 1s throttle")
 	return &ConfigService{
 		repository:       repository,
 		serverRepository: serverRepository,
@@ -97,14 +99,19 @@ func (as *ConfigService) UpdateConfig(ctx *fiber.Ctx, body *map[string]interface
 	configFile := ctx.Params("file")
 	override := ctx.QueryBool("override", false)

-	server, err := as.serverRepository.GetByID(ctx.UserContext(), serverID)
+	return as.updateConfigInternal(ctx.UserContext(), serverID, configFile, body, override)
+}
+
+// updateConfigInternal handles the actual config update logic without Fiber dependencies
+func (as *ConfigService) updateConfigInternal(ctx context.Context, serverID int, configFile string, body *map[string]interface{}, override bool) (*model.Config, error) {
+	server, err := as.serverRepository.GetByID(ctx, serverID)
 	if err != nil {
 		logging.Error("Server not found")
-		return nil, fiber.NewError(404, "Server not found")
+		return nil, fmt.Errorf("server not found")
 	}

 	// Read existing config
-	configPath := filepath.Join(server.ConfigPath, "\\server\\cfg", configFile)
+	configPath := filepath.Join(server.GetConfigPath(), configFile)
 	oldData, err := os.ReadFile(configPath)
 	if err != nil {
 		if os.IsNotExist(err) {
@@ -150,8 +157,6 @@ func (as *ConfigService) UpdateConfig(ctx *fiber.Ctx, body *map[string]interface
 		return nil, err
 	}

-	context := ctx.UserContext()
-
 	if err := os.WriteFile(configPath, newDataUTF16, 0644); err != nil {
 		return nil, err
 	}
@@ -162,7 +167,7 @@ func (as *ConfigService) UpdateConfig(ctx *fiber.Ctx, body *map[string]interface
 	as.serverService.StartAccServerRuntime(server)

 	// Log change
-	return as.repository.UpdateConfig(context, &model.Config{
+	return as.repository.UpdateConfig(ctx, &model.Config{
 		ServerID:   uint(serverID),
 		ConfigFile: configFile,
 		OldConfig:  string(oldDataUTF8),
@@ -183,6 +188,8 @@ func (as *ConfigService) GetConfig(ctx *fiber.Ctx) (interface{}, error) {
 	configFile := ctx.Params("file")
 	serverIDStr := strconv.Itoa(serverID)

+	logging.Debug("Getting config for server ID: %d, file: %s", serverID, configFile)
+
 	server, err := as.serverRepository.GetByID(ctx.UserContext(), serverID)
 	if err != nil {
 		logging.Error("Server not found")
@@ -193,56 +200,77 @@ func (as *ConfigService) GetConfig(ctx *fiber.Ctx) (interface{}, error) {
 	switch configFile {
 	case ConfigurationJson:
 		if cached, ok := as.configCache.GetConfiguration(serverIDStr); ok {
+			logging.Debug("Returning cached configuration for server ID: %s", serverIDStr)
 			return cached, nil
 		}
 	case AssistRulesJson:
 		if cached, ok := as.configCache.GetAssistRules(serverIDStr); ok {
+			logging.Debug("Returning cached assist rules for server ID: %s", serverIDStr)
 			return cached, nil
 		}
 	case EventJson:
 		if cached, ok := as.configCache.GetEvent(serverIDStr); ok {
+			logging.Debug("Returning cached event config for server ID: %s", serverIDStr)
 			return cached, nil
 		}
 	case EventRulesJson:
 		if cached, ok := as.configCache.GetEventRules(serverIDStr); ok {
+			logging.Debug("Returning cached event rules for server ID: %s", serverIDStr)
 			return cached, nil
 		}
 	case SettingsJson:
 		if cached, ok := as.configCache.GetSettings(serverIDStr); ok {
+			logging.Debug("Returning cached settings for server ID: %s", serverIDStr)
 			return cached, nil
 		}
 	}

-	decoded, err := DecodeFileName(configFile)(server.ConfigPath)
+	logging.Debug("Cache miss for server ID: %s, file: %s - loading from disk", serverIDStr, configFile)
+
+	// Not in cache, load from disk
+	configPath := filepath.Join(server.GetConfigPath(), configFile)
+	decoder := DecodeFileName(configFile)
+	if decoder == nil {
+		return nil, errors.New("invalid config file")
+	}
+
+	config, err := decoder(configPath)
 	if err != nil {
+		if os.IsNotExist(err) {
+			logging.Debug("Config file not found, creating default for server ID: %s, file: %s", serverIDStr, configFile)
+			// Return empty config if file doesn't exist
+			switch configFile {
+			case ConfigurationJson:
+				return &model.Configuration{}, nil
+			case AssistRulesJson:
+				return &model.AssistRules{}, nil
+			case EventJson:
+				return &model.EventConfig{}, nil
+			case EventRulesJson:
+				return &model.EventRules{}, nil
+			case SettingsJson:
+				return &model.ServerSettings{}, nil
+			}
+		}
 		return nil, err
 	}

-	// Cache the result based on config file type
+	// Cache the loaded config
 	switch configFile {
 	case ConfigurationJson:
-		if config, ok := decoded.(model.Configuration); ok {
-			as.configCache.UpdateConfiguration(serverIDStr, config)
-		}
+		as.configCache.UpdateConfiguration(serverIDStr, *config.(*model.Configuration))
 	case AssistRulesJson:
-		if rules, ok := decoded.(model.AssistRules); ok {
-			as.configCache.UpdateAssistRules(serverIDStr, rules)
-		}
+		as.configCache.UpdateAssistRules(serverIDStr, *config.(*model.AssistRules))
 	case EventJson:
-		if event, ok := decoded.(model.EventConfig); ok {
-			as.configCache.UpdateEvent(serverIDStr, event)
-		}
+		as.configCache.UpdateEvent(serverIDStr, *config.(*model.EventConfig))
 	case EventRulesJson:
-		if rules, ok := decoded.(model.EventRules); ok {
-			as.configCache.UpdateEventRules(serverIDStr, rules)
-		}
+		as.configCache.UpdateEventRules(serverIDStr, *config.(*model.EventRules))
 	case SettingsJson:
-		if settings, ok := decoded.(model.ServerSettings); ok {
-			as.configCache.UpdateSettings(serverIDStr, settings)
-		}
+		as.configCache.UpdateSettings(serverIDStr, *config.(*model.ServerSettings))
 	}

-	return decoded, nil
+	logging.Debug("Successfully loaded and cached config for server ID: %s, file: %s", serverIDStr, configFile)
+	return config, nil
 }

 // GetConfigs
@@ -261,7 +289,7 @@ func (as *ConfigService) GetConfigs(ctx *fiber.Ctx) (*model.Configurations, erro

 func (as *ConfigService) LoadConfigs(server *model.Server) (*model.Configurations, error) {
 	serverIDStr := strconv.Itoa(int(server.ID))
-	logging.Info("Loading configs for server ID: %s at path: %s", serverIDStr, server.ConfigPath)
+	logging.Info("Loading configs for server ID: %s at path: %s", serverIDStr, server.GetConfigPath())
 	configs := &model.Configurations{}

 	// Load configuration
@@ -270,7 +298,7 @@ func (as *ConfigService) LoadConfigs(server *model.Server) (*model.Configuration
 		configs.Configuration = *cached
 	} else {
 		logging.Debug("Loading configuration from disk for server %s", serverIDStr)
-		config, err := mustDecode[model.Configuration](ConfigurationJson, server.ConfigPath)
+		config, err := mustDecode[model.Configuration](ConfigurationJson, server.GetConfigPath())
 		if err != nil {
 			logging.Error("Failed to load configuration for server %s: %v", serverIDStr, err)
 			return nil, fmt.Errorf("failed to load configuration: %v", err)
@@ -285,7 +313,7 @@ func (as *ConfigService) LoadConfigs(server *model.Server) (*model.Configuration
 		configs.AssistRules = *cached
 	} else {
 		logging.Debug("Loading assist rules from disk for server %s", serverIDStr)
-		rules, err := mustDecode[model.AssistRules](AssistRulesJson, server.ConfigPath)
+		rules, err := mustDecode[model.AssistRules](AssistRulesJson, server.GetConfigPath())
 		if err != nil {
 			logging.Error("Failed to load assist rules for server %s: %v", serverIDStr, err)
 			return nil, fmt.Errorf("failed to load assist rules: %v", err)
@@ -300,7 +328,7 @@ func (as *ConfigService) LoadConfigs(server *model.Server) (*model.Configuration
 		configs.Event = *cached
 	} else {
 		logging.Debug("Loading event config from disk for server %s", serverIDStr)
-		event, err := mustDecode[model.EventConfig](EventJson, server.ConfigPath)
+		event, err := mustDecode[model.EventConfig](EventJson, server.GetConfigPath())
 		if err != nil {
 			logging.Error("Failed to load event config for server %s: %v", serverIDStr, err)
 			return nil, fmt.Errorf("failed to load event config: %v", err)
@@ -316,7 +344,7 @@ func (as *ConfigService) LoadConfigs(server *model.Server) (*model.Configuration
 		configs.EventRules = *cached
 	} else {
 		logging.Debug("Loading event rules from disk for server %s", serverIDStr)
-		rules, err := mustDecode[model.EventRules](EventRulesJson, server.ConfigPath)
+		rules, err := mustDecode[model.EventRules](EventRulesJson, server.GetConfigPath())
 		if err != nil {
 			logging.Error("Failed to load event rules for server %s: %v", serverIDStr, err)
 			return nil, fmt.Errorf("failed to load event rules: %v", err)
@@ -331,7 +359,7 @@ func (as *ConfigService) LoadConfigs(server *model.Server) (*model.Configuration
 		configs.Settings = *cached
 	} else {
 		logging.Debug("Loading settings from disk for server %s", serverIDStr)
-		settings, err := mustDecode[model.ServerSettings](SettingsJson, server.ConfigPath)
+		settings, err := mustDecode[model.ServerSettings](SettingsJson, server.GetConfigPath())
 		if err != nil {
 			logging.Error("Failed to load settings for server %s: %v", serverIDStr, err)
 			return nil, fmt.Errorf("failed to load settings: %v", err)
@@ -359,7 +387,7 @@ func readAndDecode[T interface{}](path string, configFile string) (T, error) {
 }

 func readFile(path string, configFile string) ([]byte, error) {
-	configPath := filepath.Join(path, "server", "cfg", configFile)
+	configPath := filepath.Join(path, configFile)
 	oldData, err := os.ReadFile(configPath)
 	if err != nil {
 		if errors.Is(err, os.ErrNotExist) {
@@ -419,7 +447,7 @@ func (as *ConfigService) GetEventConfig(server *model.Server) (*model.EventConfi
 		return cached, nil
 	}
 	
-	event, err := mustDecode[model.EventConfig](EventJson, server.ConfigPath)
+	event, err := mustDecode[model.EventConfig](EventJson, server.GetConfigPath())
 	if err != nil {
 		return nil, err
 	}
@@ -433,10 +461,27 @@ func (as *ConfigService) GetConfiguration(server *model.Server) (*model.Configur
 		return cached, nil
 	}
 	
-	config, err := mustDecode[model.Configuration](ConfigurationJson, server.ConfigPath)
+	config, err := mustDecode[model.Configuration](ConfigurationJson, server.GetConfigPath())
 	if err != nil {
 		return nil, err
 	}
 	as.configCache.UpdateConfiguration(serverIDStr, config)
 	return &config, nil
 }
+
+// SaveConfiguration saves the configuration for a server
+func (as *ConfigService) SaveConfiguration(server *model.Server, config *model.Configuration) error {
+	// Convert config to map for UpdateConfig
+	configMap := make(map[string]interface{})
+	configBytes, err := json.Marshal(config)
+	if err != nil {
+		return fmt.Errorf("failed to marshal configuration: %v", err)
+	}
+	if err := json.Unmarshal(configBytes, &configMap); err != nil {
+		return fmt.Errorf("failed to unmarshal configuration: %v", err)
+	}
+
+	// Update the configuration using the internal method
+	_, err = as.updateConfigInternal(context.Background(), int(server.ID), ConfigurationJson, &configMap, true)
+	return err
+}