mirror of
https://github.com/Kyren223/eko.git
synced 2026-03-11 18:25:40 +00:00
143 lines
3.3 KiB
Go
143 lines
3.3 KiB
Go
// Eko: A terminal-native social media platform
|
|
// Copyright (C) 2025 Kyren223
|
|
//
|
|
// This program is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU Affero General Public License as published
|
|
// by the Free Software Foundation, either version 3 of the License, or
|
|
// (at your option) any later version.
|
|
//
|
|
// This program is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU Affero General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU Affero General Public License
|
|
// along with this program. If not, see <https://www.gnu.org/licenses/>.
|
|
|
|
package config
|
|
|
|
import (
|
|
"crypto/rand"
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"os"
|
|
"path/filepath"
|
|
"reflect"
|
|
|
|
"github.com/kyren223/eko/pkg/assert"
|
|
)
|
|
|
|
type Cache struct {
|
|
// Key is a server URL like "eko.kyren.codes" and value is the base 16 hash
|
|
TosHashes map[string]string `json:"tos_hashes"`
|
|
DeviceID string `json:"device_id"`
|
|
}
|
|
|
|
func DefaultCache() Cache {
|
|
return Cache{
|
|
TosHashes: map[string]string{},
|
|
DeviceID: GenerateDeviceID(),
|
|
}
|
|
}
|
|
|
|
func VerifyAndFixCache(cache *Cache) error {
|
|
if cache.DeviceID == "" {
|
|
cache.DeviceID = GenerateDeviceID()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func GenerateDeviceID() string {
|
|
// Generate a random 32-byte device ID
|
|
// Gurantees uniqueness, so it's not reverseable and it is annonymized
|
|
// For legal reasons: this may still be logged on the server, so associated with an IP address
|
|
deviceId := [32]byte{}
|
|
_, err := rand.Read(deviceId[:])
|
|
assert.NoError(err, "random never fails")
|
|
return fmt.Sprintf("%x", deviceId)
|
|
}
|
|
|
|
var (
|
|
cache = Cache{}
|
|
CacheDir string
|
|
CacheFile string
|
|
)
|
|
|
|
func LoadCache() error {
|
|
userCacheDir, err := os.UserCacheDir()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
CacheDir = filepath.Join(userCacheDir, "eko")
|
|
err = os.MkdirAll(CacheDir, 0o750)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
CacheFile = filepath.Join(CacheDir, "cache.json")
|
|
contents, err := os.ReadFile(CacheFile) // #nosec 304
|
|
if errors.Is(err, os.ErrNotExist) {
|
|
cache = DefaultCache()
|
|
return writeCache()
|
|
}
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
var rawMap map[string]json.RawMessage
|
|
if err := json.Unmarshal(contents, &rawMap); err != nil {
|
|
return err
|
|
}
|
|
|
|
defaultVal := reflect.ValueOf(DefaultCache())
|
|
finalCache := reflect.New(defaultVal.Type()).Elem()
|
|
finalCache.Set(defaultVal)
|
|
|
|
for i := 0; i < defaultVal.NumField(); i++ {
|
|
field := defaultVal.Type().Field(i)
|
|
jsonTag := field.Tag.Get("json")
|
|
if jsonTag == "" {
|
|
jsonTag = field.Name
|
|
}
|
|
|
|
rawValue, found := rawMap[jsonTag]
|
|
fieldValue := finalCache.Field(i)
|
|
if !found || !fieldValue.CanAddr() {
|
|
continue
|
|
}
|
|
|
|
err := json.Unmarshal(rawValue, fieldValue.Addr().Interface())
|
|
if err != nil {
|
|
return fmt.Errorf("error unmarshaling field %s: %w", field.Name, err)
|
|
}
|
|
}
|
|
|
|
cache = finalCache.Interface().(Cache)
|
|
|
|
err = VerifyAndFixCache(&cache)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
return writeCache()
|
|
}
|
|
|
|
func writeCache() error {
|
|
b, err := json.MarshalIndent(cache, "", " ")
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return os.WriteFile(CacheFile, b, 0o600)
|
|
}
|
|
|
|
func ReadCache() Cache {
|
|
return cache
|
|
}
|
|
|
|
func UseCache(f func(cache *Cache)) error {
|
|
f(&cache)
|
|
return writeCache()
|
|
}
|