How does MergeConfig work ?

[srinidhis94]

Hi,
I am using viper and I have to load a file which has 35K lines. It roughly takes 150-200ms to load. Our design is such that this configuration can keep changing. So we always reload the file whenever it changes. We have an event watcher. The problem I am seeing is during the reload, <200ms, I am not able to read any configuration. This is causing failures in our service. Until configs are updated, i can afford previous config value but not nil/empty values. Also, i don't mind having a blocking get call until configs are loaded as I can afford to wait 200ms .
I was going to other options. MergeConfig also seems to help with my case as we can still access older values until they are overwritten. By looking at the code, it looks like we only update keys which already exist in the config and the data type matches exactly. Is my understanding correct ? If key 'k' is present in src but not in tgt or if key k has value of type t1 in src and t2 in tgt. We wouldn't merge the maps in this case is it ?

// mergeMaps merges two maps. The `itgt` parameter is for handling go-yaml's
// insistence on parsing nested structures as `map[interface{}]interface{}`
// instead of using a `string` as the key for nest structures beyond one level
// deep. Both map types are supported as there is a go-yaml fork that uses
// `map[string]interface{}` instead.
func mergeMaps(
    src, tgt map[string]interface{}, itgt map[interface{}]interface{}) {
    for sk, sv := range src {
        tk := keyExists(sk, tgt)
        if tk == "" {
            v.logger.Trace("", "tk", "\"\"", fmt.Sprintf("tgt[%s]", sk), sv)
            tgt[sk] = sv
            if itgt != nil {
                itgt[sk] = sv
            }
            continue
        }

        tv, ok := tgt[tk]
        if !ok {
            v.logger.Trace("", fmt.Sprintf("ok[%s]", tk), false, fmt.Sprintf("tgt[%s]", sk), sv)
            tgt[sk] = sv
            if itgt != nil {
                itgt[sk] = sv
            }
            continue
        }

        svType := reflect.TypeOf(sv)
        tvType := reflect.TypeOf(tv)
        if tvType != nil && svType != tvType { // Allow for the target to be nil
            v.logger.Error(
                "svType != tvType",
                "key", sk,
                "st", svType,
                "tt", tvType,
                "sv", sv,
                "tv", tv,
            )
            continue
        }

        v.logger.Trace(
            "processing",
            "key", sk,
            "st", svType,
            "tt", tvType,
            "sv", sv,
            "tv", tv,
        )

        switch ttv := tv.(type) {
        case map[interface{}]interface{}:
            v.logger.Trace("merging maps (must convert)")
            tsv := sv.(map[interface{}]interface{})
            ssv := castToMapStringInterface(tsv)
            stv := castToMapStringInterface(ttv)
            mergeMaps(ssv, stv, ttv)
        case map[string]interface{}:
            v.logger.Trace("merging maps")
            mergeMaps(sv.(map[string]interface{}), ttv, nil)
        default:
            v.logger.Trace("setting value")
            tgt[tk] = sv
            if itgt != nil {
                itgt[tk] = sv
            }
        }
    }
}