storj/storagenode/trust/cache.go
Egon Elbre 6615ecc9b6 common: separate repository
Change-Id: Ibb89c42060450e3839481a7e495bbe3ad940610a
2019-12-27 14:11:15 +02:00

117 lines
2.9 KiB
Go

// Copyright (C) 2019 Storj Labs, Inc.
// See LICENSE for copying information.
package trust
import (
"context"
"encoding/json"
"io/ioutil"
"os"
"path/filepath"
"github.com/zeebo/errs"
"storj.io/common/fpath"
)
// Cache caches source information about trusted satellites
type Cache struct {
path string
data *CacheData
}
// LoadCache loads a cache from a file on disk. If the file is not present, the
// cache is still loaded. If the file cannot be read for any other reason, the
// function will return an error. LoadCache ensures the containing directory
// exists.
func LoadCache(path string) (*Cache, error) {
if path == "" {
return nil, Error.New("cache path cannot be empty")
}
if err := os.MkdirAll(filepath.Dir(path), 0777); err != nil {
return nil, Error.New("unable to make cache parent directory: %v", err)
}
data, err := LoadCacheData(path)
switch {
case err == nil:
case errs.IsFunc(err, os.IsNotExist):
data = NewCacheData()
default:
return nil, err
}
return &Cache{
path: path,
data: data,
}, nil
}
// Path returns the path on disk to the file containing the cache
func (cache *Cache) Path() string {
return cache.path
}
// Lookup takes a cache key and returns entries associated with that key. If
// the key is unset in the cache, false is returned for ok. Otherwise the
// entries are returned with ok returned as true.
func (cache *Cache) Lookup(key string) (entries []Entry, ok bool) {
entries, ok = cache.data.Entries[key]
return entries, ok
}
// Set sets the entries in the cache for the provided key
func (cache *Cache) Set(key string, entries []Entry) {
cache.data.Entries[key] = entries
}
// Save persists the cache to disk
func (cache *Cache) Save(ctx context.Context) (err error) {
defer mon.Task()(&ctx)(&err)
return SaveCacheData(cache.path, cache.data)
}
// CacheData represents the data stored in the cache
type CacheData struct {
Entries map[string][]Entry `json:"entries"`
}
// NewCacheData returns an new CacheData
func NewCacheData() *CacheData {
return &CacheData{
Entries: make(map[string][]Entry),
}
}
// LoadCacheData loads the cache data from the given path
func LoadCacheData(path string) (*CacheData, error) {
dataBytes, err := ioutil.ReadFile(path)
if err != nil {
return nil, Error.Wrap(err)
}
data := NewCacheData()
if err := json.Unmarshal(dataBytes, data); err != nil {
return nil, Error.New("malformed cache: %v", err)
}
// Ensure the entries map is always non-nil on load
if data.Entries == nil {
data.Entries = map[string][]Entry{}
}
return data, nil
}
// SaveCacheData persists the cache data to the given path
func SaveCacheData(path string, data *CacheData) error {
// Ensure the entries map is always non-nil on save
if data.Entries == nil {
data.Entries = map[string][]Entry{}
}
dataBytes, err := json.MarshalIndent(data, "", " ")
if err != nil {
return Error.Wrap(err)
}
return fpath.AtomicWriteFile(path, dataBytes, 0644)
}