Handling Errors During File Loading in a Data Map

Problem Outline:

This code snippet loads data from files into a map during startup. However, it faces an issue when encountering errors during file loading. The issue arises because the code clears the map before loading each new file, which can lead to data loss if an error occurs and the previous map state is not preserved.

Proposed Solution:

To overcome this issue, a more straightforward approach can be adopted:

1. Stateless Configuration Loading: Define a CustomerConfig struct to encapsulate the data to be cached.
2. Load Configuration Function: Create a loadConfig() function responsible for loading the configuration from files.
3. Cache Manager: Introduce a ConfigCache struct to manage the configuration, providing safe concurrent access and the ability to monitor changes through a refreshing goroutine.
4. Refresher Goroutine: This goroutine periodically checks for changes and loads new configurations, ensuring the cache is up to date.
5. Accessing Configuration: The GetConfig() method provides access to the most recent configuration, ensuring the latest data is always available.

Implementation:

type CustomerConfig struct {
    Data map[string]bool
    LoadedAt time.Time
}

func loadConfig() (*CustomerConfig, error) {
    cfg := &CustomerConfig{
        Data: map[string]bool{},
        LoadedAt: time.Now(),
    }
    // Load files and populate cfg.Data
    // Return error if encountered
    return cfg, nil
}

type ConfigCache struct {
    configMu sync.RWMutex
    config   *CustomerConfig
    closeCh  chan struct{}
}

func NewConfigCache() (*ConfigCache, error) {
    cfg, err := loadConfig()
    if err != nil {
        return nil, err
    }
    cc := &ConfigCache{
        config:  cfg,
        closeCh: make(chan struct{}),
    }
    go cc.refresher()
    return cc, nil
}

func (cc *ConfigCache) refresher() {
    ticker := time.NewTicker(1 * time.Minute)
    defer ticker.Stop()
    for {
        select {
        case <-ticker.C:
            // Check for changes
            changes := false // Implement logic to detect changes
            if !changes {
                continue
            }
            cfg, err := loadConfig()
            if err != nil {
                log.Printf("Failed to load config: %v", err)
                continue
            }
            cc.configMu.Lock()
            cc.config = cfg
            cc.configMu.Unlock()
        case <-cc.closeCh:
            return
        }
    }
}

func (cc *ConfigCache) Stop() {
    close(cc.closeCh)
}

func (cc *ConfigCache) GetConfig() *CustomerConfig {
    cc.configMu.RLock()
    defer cc.configMu.RUnlock()
    return cc.config
}

Usage:

cc, err := NewConfigCache()
if err != nil {
    // Handle error
}
cfg := cc.GetConfig() // Access the latest configuration