mirror of
https://github.com/yusing/godoxy.git
synced 2025-05-20 12:42:34 +02:00
113 lines
2.4 KiB
Go
113 lines
2.4 KiB
Go
package jsonstore
|
|
|
|
import (
|
|
"encoding/json"
|
|
"fmt"
|
|
"path/filepath"
|
|
"sync"
|
|
|
|
"github.com/puzpuzpuz/xsync/v3"
|
|
"github.com/yusing/go-proxy/internal/common"
|
|
"github.com/yusing/go-proxy/internal/gperr"
|
|
"github.com/yusing/go-proxy/internal/logging"
|
|
"github.com/yusing/go-proxy/internal/task"
|
|
"github.com/yusing/go-proxy/internal/utils"
|
|
)
|
|
|
|
type namespace string
|
|
|
|
type Typed[VT any] struct {
|
|
*xsync.MapOf[string, VT]
|
|
}
|
|
|
|
type storesMap struct {
|
|
sync.RWMutex
|
|
m map[namespace]any
|
|
}
|
|
|
|
var stores = storesMap{m: make(map[namespace]any)}
|
|
var storesPath = common.DataDir
|
|
|
|
func init() {
|
|
if err := load(); err != nil {
|
|
logging.Error().Err(err).Msg("failed to load stores")
|
|
}
|
|
|
|
task.OnProgramExit("save_stores", func() {
|
|
if err := save(); err != nil {
|
|
logging.Error().Err(err).Msg("failed to save stores")
|
|
}
|
|
})
|
|
}
|
|
|
|
func load() error {
|
|
stores.Lock()
|
|
defer stores.Unlock()
|
|
errs := gperr.NewBuilder("failed to load data stores")
|
|
for ns, store := range stores.m {
|
|
if err := utils.LoadJSONIfExist(filepath.Join(storesPath, string(ns)+".json"), &store); err != nil {
|
|
errs.Add(err)
|
|
} else {
|
|
logging.Info().Str("name", string(ns)).Msg("store loaded")
|
|
}
|
|
}
|
|
return errs.Error()
|
|
}
|
|
|
|
func save() error {
|
|
stores.Lock()
|
|
defer stores.Unlock()
|
|
errs := gperr.NewBuilder("failed to save data stores")
|
|
for ns, store := range stores.m {
|
|
if err := utils.SaveJSON(filepath.Join(storesPath, string(ns)+".json"), &store, 0o644); err != nil {
|
|
errs.Add(err)
|
|
}
|
|
}
|
|
return errs.Error()
|
|
}
|
|
|
|
func Store[VT any](namespace namespace) Typed[VT] {
|
|
stores.Lock()
|
|
defer stores.Unlock()
|
|
if s, ok := stores.m[namespace]; ok {
|
|
return s.(Typed[VT])
|
|
}
|
|
m := Typed[VT]{MapOf: xsync.NewMapOf[string, VT]()}
|
|
stores.m[namespace] = m
|
|
return m
|
|
}
|
|
|
|
func Object[VT any](namespace namespace) *VT {
|
|
stores.Lock()
|
|
defer stores.Unlock()
|
|
if s, ok := stores.m[namespace]; ok {
|
|
v, ok := s.(*VT)
|
|
if ok {
|
|
return v
|
|
}
|
|
panic(fmt.Errorf("type mismatch: %T != %T", s, v))
|
|
}
|
|
v := new(VT)
|
|
stores.m[namespace] = v
|
|
return v
|
|
}
|
|
|
|
func (s Typed[VT]) MarshalJSON() ([]byte, error) {
|
|
tmp := make(map[string]VT, s.Size())
|
|
for k, v := range s.Range {
|
|
tmp[k] = v
|
|
}
|
|
return json.Marshal(tmp)
|
|
}
|
|
|
|
func (s Typed[VT]) UnmarshalJSON(data []byte) error {
|
|
tmp := make(map[string]VT)
|
|
if err := json.Unmarshal(data, &tmp); err != nil {
|
|
return err
|
|
}
|
|
s.MapOf = xsync.NewMapOf[string, VT](xsync.WithPresize(len(tmp)))
|
|
for k, v := range tmp {
|
|
s.MapOf.Store(k, v)
|
|
}
|
|
return nil
|
|
}
|