Gestion des erreurs lors du chargement de fichiers dans une carte de données

Aperçu du problème :

Cet extrait de code charge les données des fichiers dans une carte au démarrage. Cependant, il est confronté à un problème lorsqu'il rencontre des erreurs lors du chargement du fichier. Le problème se pose car le code efface la carte avant de charger chaque nouveau fichier, ce qui peut entraîner une perte de données si une erreur se produit et que l'état précédent de la carte n'est pas conservé.

Solution proposée :

Pour surmonter ce problème, une approche plus simple peut être adoptée :

1. Chargement de configuration sans état : Définir une structure CustomerConfig pour encapsuler les données à mettre en cache.
2. Load Configuration Function : Créer une fonction loadConfig() chargée de charger la configuration à partir des fichiers.
3. Cache Manager : Introduisez une structure ConfigCache pour gérer la configuration, fournissant un accès simultané sécurisé et la possibilité de surveiller les modifications via une actualisation goroutine.
4. Goroutine de mise à jour : Cette goroutine vérifie périodiquement les modifications et charge de nouvelles configurations, garantissant que le cache est à jour.
5. Accès à la configuration : La méthode GetConfig() donne accès à la configuration la plus récente, garantissant que les données les plus récentes sont toujours disponible.

Mise en œuvre :

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
}

Utilisation :

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