update logging

local/service/server.go

@@ -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