107 lines
2.5 KiB
Go
107 lines
2.5 KiB
Go
package main
|
|
|
|
import (
|
|
"sync"
|
|
)
|
|
|
|
// EventCache stores recent events for each host (ring buffer)
|
|
type EventCache struct {
|
|
mu sync.RWMutex
|
|
events map[string][]DockerEvent // key: hostID, value: ring buffer of events
|
|
maxSize int // maximum events to keep per host
|
|
}
|
|
|
|
// NewEventCache creates a new event cache
|
|
func NewEventCache(maxSize int) *EventCache {
|
|
return &EventCache{
|
|
events: make(map[string][]DockerEvent),
|
|
maxSize: maxSize,
|
|
}
|
|
}
|
|
|
|
// AddEvent adds an event to the cache for a specific host
|
|
func (ec *EventCache) AddEvent(hostID string, event DockerEvent) {
|
|
ec.mu.Lock()
|
|
defer ec.mu.Unlock()
|
|
|
|
// Initialize slice if needed
|
|
if _, exists := ec.events[hostID]; !exists {
|
|
ec.events[hostID] = make([]DockerEvent, 0, ec.maxSize)
|
|
}
|
|
|
|
// Add event
|
|
ec.events[hostID] = append(ec.events[hostID], event)
|
|
|
|
// Trim if over max size (keep most recent)
|
|
if len(ec.events[hostID]) > ec.maxSize {
|
|
ec.events[hostID] = ec.events[hostID][len(ec.events[hostID])-ec.maxSize:]
|
|
}
|
|
}
|
|
|
|
// GetRecentEvents returns recent events for a specific host
|
|
func (ec *EventCache) GetRecentEvents(hostID string, limit int) []DockerEvent {
|
|
ec.mu.RLock()
|
|
defer ec.mu.RUnlock()
|
|
|
|
events, exists := ec.events[hostID]
|
|
if !exists || len(events) == 0 {
|
|
return []DockerEvent{}
|
|
}
|
|
|
|
// Return last N events
|
|
if limit <= 0 || limit > len(events) {
|
|
limit = len(events)
|
|
}
|
|
|
|
// Return copy to avoid race conditions
|
|
result := make([]DockerEvent, limit)
|
|
copy(result, events[len(events)-limit:])
|
|
return result
|
|
}
|
|
|
|
// GetAllRecentEvents returns recent events for all hosts
|
|
func (ec *EventCache) GetAllRecentEvents(limit int) map[string][]DockerEvent {
|
|
ec.mu.RLock()
|
|
defer ec.mu.RUnlock()
|
|
|
|
result := make(map[string][]DockerEvent)
|
|
|
|
for hostID, events := range ec.events {
|
|
if len(events) == 0 {
|
|
continue
|
|
}
|
|
|
|
// Get last N events
|
|
count := limit
|
|
if count <= 0 || count > len(events) {
|
|
count = len(events)
|
|
}
|
|
|
|
// Copy to avoid race conditions
|
|
hostEvents := make([]DockerEvent, count)
|
|
copy(hostEvents, events[len(events)-count:])
|
|
result[hostID] = hostEvents
|
|
}
|
|
|
|
return result
|
|
}
|
|
|
|
// ClearHost removes all cached events for a specific host
|
|
func (ec *EventCache) ClearHost(hostID string) {
|
|
ec.mu.Lock()
|
|
defer ec.mu.Unlock()
|
|
delete(ec.events, hostID)
|
|
}
|
|
|
|
// GetStats returns cache statistics
|
|
func (ec *EventCache) GetStats() (hostCount int, totalEvents int) {
|
|
ec.mu.RLock()
|
|
defer ec.mu.RUnlock()
|
|
|
|
hostCount = len(ec.events)
|
|
for _, events := range ec.events {
|
|
totalEvents += len(events)
|
|
}
|
|
return
|
|
}
|