99 lines
2.3 KiB
Go
99 lines
2.3 KiB
Go
package main
|
|
|
|
import (
|
|
"encoding/json"
|
|
"reflect"
|
|
"strings"
|
|
|
|
klog "k8s.io/klog/v2"
|
|
)
|
|
|
|
// wkData can be either JSON data (map[string]interface{}) or plaintext data ([]string or string).
|
|
type wkData interface{}
|
|
|
|
// wkRegistry maps IDs to wkData.
|
|
type wkRegistry map[string]wkData
|
|
|
|
func (reg wkRegistry) encode() map[string]string {
|
|
encoded := make(map[string]string)
|
|
for key, data := range reg {
|
|
var result string
|
|
cmKey := strings.ReplaceAll(key, "/", "__")
|
|
|
|
switch v := data.(type) {
|
|
case []string:
|
|
// For text files, join the array into a single string
|
|
result = strings.Join(v, "\n")
|
|
encoded[cmKey+".txt"] = result // store as .txt file
|
|
case string:
|
|
// For single string data
|
|
result = v
|
|
encoded[cmKey+".txt"] = result // store as .txt file
|
|
case map[string]interface{}:
|
|
// For JSON-like data, marshal into JSON
|
|
jsonData, err := json.MarshalIndent(v, "", " ")
|
|
if err != nil {
|
|
klog.Error(err)
|
|
continue
|
|
}
|
|
result = string(jsonData)
|
|
encoded[cmKey+".json"] = result // store as .json file
|
|
encoded[cmKey] = result // store without .json extension for compatibility
|
|
default:
|
|
klog.Warningf("Unsupported data type: %T", data)
|
|
continue
|
|
}
|
|
}
|
|
return encoded
|
|
}
|
|
|
|
// mergeData merges two wkData instances.
|
|
func mergeData(d1, d2 wkData) wkData {
|
|
switch v1 := d1.(type) {
|
|
case map[string]interface{}:
|
|
if v2, ok := d2.(map[string]interface{}); ok {
|
|
return mergeMaps(v1, v2)
|
|
}
|
|
case []string:
|
|
if v2, ok := d2.([]string); ok {
|
|
return append(v1, v2...)
|
|
}
|
|
case string:
|
|
if v2, ok := d2.(string); ok {
|
|
return v2
|
|
}
|
|
}
|
|
return d1
|
|
}
|
|
|
|
// mergeMaps recursively merges two maps.
|
|
func mergeMaps(m1, m2 map[string]interface{}) map[string]interface{} {
|
|
for k, v2 := range m2 {
|
|
if v1, ok := m1[k]; ok {
|
|
m1[k] = mergeStructs(v1, v2)
|
|
} else {
|
|
m1[k] = v2
|
|
}
|
|
}
|
|
return m1
|
|
}
|
|
|
|
// mergeStructs recursively merges two data structures.
|
|
func mergeStructs(x1, x2 interface{}) interface{} {
|
|
if reflect.TypeOf(x1) != reflect.TypeOf(x2) {
|
|
// Overwrite x1 with x2 when types differ
|
|
return x2
|
|
}
|
|
|
|
switch x1 := x1.(type) {
|
|
case []interface{}:
|
|
return append(x1, x2.([]interface{})...)
|
|
case string:
|
|
return x2.(string)
|
|
case map[string]interface{}:
|
|
return mergeMaps(x1, x2.(map[string]interface{}))
|
|
default:
|
|
klog.Warningf("unknown type: %T", x1)
|
|
return x2
|
|
}
|
|
}
|