How to Design a Configuration Cache That Handles Updates and Errors Gracefully?-Golang-php.cn

How to Design a Configuration Cache That Handles Updates and Errors Gracefully?

Mary-Kate Olsen

Release： 2024-10-25 06:43:02

Original

825 people have browsed it

How to Design a Configuration Cache That Handles Updates and Errors Gracefully?

Load Configuration From Files and Refresh with New Updates

Problem Statement:

A code design involves loading a configuration from files at startup and periodically refreshing it with newer versions. The aim is to have a mechanism that handles the following requirements:

Concurrent access to the configuration
Reloading of detected configuration changes
Accessibility to the most recent configuration
Immediate accessibility to the most recent configuration during updates
Preservation of the previous configuration if an update fails

The initial design utilizes a concurrent map to store the configuration, but faces an issue where errors during updating can lead to an empty map.

Solution:

A simplified design is proposed that addresses all the requirements:

CustomerConfig Structure:

Defines the configuration to be cached:

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

Copy after login

loadConfig Function:

Loads the configuration from files:

func loadConfig() (*CustomerConfig, error) {
    cfg := &CustomerConfig{
        Data:     map[string]bool{},
        LoadedAt: time.Now(),
    }

    // Logic to load files and populate cfg.Data
    // If an error occurs, return it

    // If loading succeeds, return the config
    return cfg, nil
}

Copy after login

ConfigCache Structure:

Manages the configuration caching:

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

Copy after login

NewConfigCache Function:

Creates a new configuration cache:

func NewConfigCache() (*ConfigCache, error) {
    cfg, err := loadConfig()
    if err != nil {
        return nil, fmt.Errorf("loading initial config failed: %w", err)
    }

    cc := &ConfigCache{
        config:  cfg,
        closeCh: make(chan struct{}),
    }

    // Launch a goroutine to periodically check for changes and load new configs
    go cc.refresher()

    return cc, nil
}

Copy after login

refresher Function:

Periodically checks for configuration changes and updates the cache:

func (cc *ConfigCache) refresher() {
    ticker := time.NewTicker(1 * time.Minute) // Every minute
    defer ticker.Stop()

    for {
        select {
        case <-ticker.C:
            // Check for changes
            changes := false // Logic to detect changes
            if !changes {
                continue // No changes, continue
            }

            // Changes! Load new config:
            cfg, err := loadConfig()
            if err != nil {
                log.Printf("Failed to load config: %v", err)
                continue // Keep the previous config
            }

            // Apply / store new config
            cc.configMu.Lock()
            cc.config = cfg
            cc.configMu.Unlock()

        case <-cc.closeCh:
            return
        }
    }
}

Copy after login

Stop Function:

Stops the refresher goroutine:

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

Copy after login

GetConfig Function:

Accesses the current configuration:

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

Copy after login

Usage:

cc, err := NewConfigCache()
if err != nil {
    // Handle the error appropriately
}

// Access the configuration whenever needed:
cfg := cc.GetConfig()
// Use the configuration here

// Stop the cache refreshing when necessary:
cc.Stop()

Copy after login

This solution ensures:

Concurrent access to the configuration
Reload on detected changes
Accessibility to the most recent configuration
Immediate accessibility during updates
Preservation of the previous configuration on update failures

The above is the detailed content of How to Design a Configuration Cache That Handles Updates and Errors Gracefully?. For more information, please follow other related articles on the PHP Chinese website!