FJurmanovic/acc-server-manager
1
0
Fork 0
Code Issues 9 Pull Requests Actions Packages Projects 1 Releases Wiki Activity

update logging

Browse Source
This commit is contained in:
Fran Jurmanović
2025-05-29 00:21:32 +02:00
parent 3dfbe77219
commit 1f41f6003b
7 changed files with 238 additions and 56 deletions
Download Patch File Download Diff File Expand all files Collapse all files

24
local/service/config.go
View File

@@ -87,19 +87,32 @@ func (as *ConfigService) SetServerService(serverService *ServerService) {
func (as ConfigService) UpdateConfig(ctx *fiber.Ctx, body *map[string]interface{}) (*model.Config, error) {
serverID := ctx.Locals("serverId").(int)
configFile := ctx.Params("file")
override := ctx.QueryBool("override")
override := ctx.QueryBool("override", false)
server, err := as.serverRepository.GetByID(ctx.UserContext(), serverID)
if err != nil {
return nil, err
log.Print("Server not found")
return nil, fiber.NewError(404, "Server not found")
}
// Read existing config
configPath := filepath.Join(server.ConfigPath, "\\server\\cfg", configFile)
oldData, err := os.ReadFile(configPath)
if err != nil {
return nil, err
if os.IsNotExist(err) {
// Create directory if it doesn't exist
dir := filepath.Dir(configPath)
if err := os.MkdirAll(dir, 0755); err != nil {
return nil, err
}
// Create empty JSON file
if err := os.WriteFile(configPath, []byte("{}"), 0644); err != nil {
return nil, err
}
oldData = []byte("{}")
} else {
return nil, err
}
}
oldDataUTF8, err := DecodeUTF16LEBOM(oldData)
@@ -124,12 +137,11 @@ func (as ConfigService) UpdateConfig(ctx *fiber.Ctx, body *map[string]interface{
return nil, err
}
newDataUTF16, err := EncodeUTF16LEBOM(newData)
if err != nil {
return nil, err
}
context := ctx.UserContext()
if err := os.WriteFile(configPath, newDataUTF16, 0644); err != nil {

98
local/service/server.go
View File

@@ -21,6 +21,8 @@ type ServerService struct {
configService *ConfigService
lastInsertTimes sync.Map // Track last insert time per server
debouncers sync.Map // Track debounce timers per server
logTailers sync.Map // Track log tailers per server
sessionCache sync.Map // Cache of server event sessions
}
type pendingState struct {
@@ -28,26 +30,43 @@ type pendingState struct {
state *model.ServerState
}
func (s *ServerService) ensureLogTailing(server *model.Server, instance *tracking.AccServerInstance) {
// Check if we already have a tailer
if _, exists := s.logTailers.Load(server.ID); exists {
return
}
// Start tailing in a goroutine that handles file creation/deletion
go func() {
logPath := filepath.Join(server.ConfigPath, "\\server\\log\\server.log")
tailer := tracking.NewLogTailer(logPath, instance.HandleLogLine)
s.logTailers.Store(server.ID, tailer)
// Start tailing and automatically handle file changes
tailer.Start()
}()
}
func NewServerService(repository *repository.ServerRepository, stateHistoryRepo *repository.StateHistoryRepository, apiService *ApiService, configService *ConfigService) *ServerService {
service := &ServerService{
repository: repository,
apiService: apiService,
configService: configService,
repository: repository,
apiService: apiService,
configService: configService,
stateHistoryRepo: stateHistoryRepo,
}
// Initialize instances for all servers
servers, err := repository.GetAll(context.Background(), &model.ServerFilter{})
if err != nil {
log.Print(err.Error())
return service
}
for _, server := range *servers {
status, err := service.apiService.StatusServer(server.ServiceName)
if err != nil {
log.Print(err.Error())
}
if (status == string(model.StatusRunning)) {
service.StartAccServerRuntime(&server)
}
// Initialize instance regardless of status
service.StartAccServerRuntime(&server)
}
return service
}
@@ -77,10 +96,44 @@ func (s *ServerService) insertStateHistory(serverID uint, state *model.ServerSta
Session: state.Session,
PlayerCount: state.PlayerCount,
DateCreated: time.Now().UTC(),
SessionDurationMinutes: state.SessionDurationMinutes,
})
}
func (s *ServerService) updateSessionDuration(server *model.Server, sessionType string) {
sessionsInterface, exists := s.sessionCache.Load(server.ID)
if !exists {
// Try to load sessions from config
event, err := DecodeFileName(EventJson)(server.ConfigPath)
if err != nil {
log.Printf("Failed to load event config for server %d: %v", server.ID, err)
return
}
evt := event.(model.EventConfig)
s.sessionCache.Store(server.ID, evt.Sessions)
sessionsInterface = evt.Sessions
}
sessions := sessionsInterface.([]model.Session)
if (sessionType == "" && len(sessions) > 0) {
sessionType = sessions[0].SessionType
}
for _, session := range sessions {
if session.SessionType == sessionType {
if instance, ok := s.instances.Load(server.ID); ok {
serverInstance := instance.(*tracking.AccServerInstance)
serverInstance.State.SessionDurationMinutes = session.SessionDurationMinutes.ToInt()
serverInstance.State.Session = sessionType
}
break
}
}
}
func (s *ServerService) handleStateChange(server *model.Server, state *model.ServerState) {
// Update session duration when session changes
s.updateSessionDuration(server, state.Session)
// Cancel existing timer if any
if debouncer, exists := s.debouncers.Load(server.ID); exists {
pending := debouncer.(*pendingState)
@@ -111,10 +164,18 @@ func (s *ServerService) handleStateChange(server *model.Server, state *model.Ser
}
func (s *ServerService) StartAccServerRuntime(server *model.Server) {
s.instances.Delete(server.ID)
instance := tracking.NewAccServerInstance(server, func(state *model.ServerState, states ...tracking.StateChange) {
s.handleStateChange(server, state)
})
// Get or create instance
instanceInterface, exists := s.instances.Load(server.ID)
var instance *tracking.AccServerInstance
if !exists {
instance = tracking.NewAccServerInstance(server, func(state *model.ServerState, states ...tracking.StateChange) {
s.handleStateChange(server, state)
})
s.instances.Store(server.ID, instance)
} else {
instance = instanceInterface.(*tracking.AccServerInstance)
}
config, _ := DecodeFileName(ConfigurationJson)(server.ConfigPath)
cfg := config.(model.Configuration)
event, _ := DecodeFileName(EventJson)(server.ConfigPath)
@@ -123,8 +184,13 @@ func (s *ServerService) StartAccServerRuntime(server *model.Server) {
instance.State.MaxConnections = cfg.MaxConnections.ToInt()
instance.State.Track = evt.Track
go tracking.TailLogFile(filepath.Join(server.ConfigPath, "\\server\\log\\server.log"), instance.HandleLogLine)
s.instances.Store(server.ID, instance)
// Cache sessions for duration lookup
s.sessionCache.Store(server.ID, evt.Sessions)
s.updateSessionDuration(server, instance.State.Session)
// Ensure log tailing is running (regardless of server status)
s.ensureLogTailing(server, instance)
}
// GetAll