139 lines
3.1 KiB
Go
139 lines
3.1 KiB
Go
package certmagic
|
|
|
|
import (
|
|
"bytes"
|
|
"encoding/gob"
|
|
"errors"
|
|
"path"
|
|
"strings"
|
|
"time"
|
|
|
|
"github.com/caddyserver/certmagic"
|
|
"github.com/unistack-org/micro/v3/store"
|
|
"github.com/unistack-org/micro/v3/sync"
|
|
)
|
|
|
|
// File represents a "File" that will be stored in store.Store - the contents and last modified time
|
|
type File struct {
|
|
// last modified time
|
|
LastModified time.Time
|
|
// Contents
|
|
Contents []byte
|
|
}
|
|
|
|
// storage is an implementation of certmagic.Storage using micro's sync.Map and store.Store interfaces.
|
|
// As certmagic storage expects a filesystem (with stat() abilities) we have to implement
|
|
// the bare minimum of metadata.
|
|
type storage struct {
|
|
lock sync.Sync
|
|
store store.Store
|
|
}
|
|
|
|
func (s *storage) Lock(key string) error {
|
|
return s.lock.Lock(key, sync.LockTTL(10*time.Minute))
|
|
}
|
|
|
|
func (s *storage) Unlock(key string) error {
|
|
return s.lock.Unlock(key)
|
|
}
|
|
|
|
func (s *storage) Store(key string, value []byte) error {
|
|
f := File{
|
|
LastModified: time.Now(),
|
|
Contents: value,
|
|
}
|
|
buf := &bytes.Buffer{}
|
|
e := gob.NewEncoder(buf)
|
|
if err := e.Encode(f); err != nil {
|
|
return err
|
|
}
|
|
return s.store.Write(s.store.Options().Context, key, buf.Bytes())
|
|
}
|
|
|
|
func (s *storage) Load(key string) ([]byte, error) {
|
|
if !s.Exists(key) {
|
|
return nil, certmagic.ErrNotExist(errors.New(key + " doesn't exist"))
|
|
}
|
|
var val []byte
|
|
err := s.store.Read(s.store.Options().Context, key, val)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
b := bytes.NewBuffer(val)
|
|
d := gob.NewDecoder(b)
|
|
var f File
|
|
err = d.Decode(&f)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return f.Contents, nil
|
|
}
|
|
|
|
func (s *storage) Delete(key string) error {
|
|
return s.store.Delete(s.store.Options().Context, key)
|
|
}
|
|
|
|
func (s *storage) Exists(key string) bool {
|
|
if err := s.store.Read(s.store.Options().Context, key, nil); err != nil {
|
|
return false
|
|
}
|
|
return true
|
|
}
|
|
|
|
func (s *storage) List(prefix string, recursive bool) ([]string, error) {
|
|
keys, err := s.store.List(s.store.Options().Context)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
//nolint:prealloc
|
|
var results []string
|
|
for _, k := range keys {
|
|
if strings.HasPrefix(k, prefix) {
|
|
results = append(results, k)
|
|
}
|
|
}
|
|
if recursive {
|
|
return results, nil
|
|
}
|
|
keysMap := make(map[string]bool)
|
|
for _, key := range results {
|
|
dir := strings.Split(strings.TrimPrefix(key, prefix+"/"), "/")
|
|
keysMap[dir[0]] = true
|
|
}
|
|
results = make([]string, 0)
|
|
for k := range keysMap {
|
|
results = append(results, path.Join(prefix, k))
|
|
}
|
|
return results, nil
|
|
}
|
|
|
|
func (s *storage) Stat(key string) (certmagic.KeyInfo, error) {
|
|
var val []byte
|
|
err := s.store.Read(s.store.Options().Context, key, val)
|
|
if err != nil {
|
|
return certmagic.KeyInfo{}, err
|
|
}
|
|
b := bytes.NewBuffer(val)
|
|
d := gob.NewDecoder(b)
|
|
var f File
|
|
err = d.Decode(&f)
|
|
if err != nil {
|
|
return certmagic.KeyInfo{}, err
|
|
}
|
|
return certmagic.KeyInfo{
|
|
Key: key,
|
|
Modified: f.LastModified,
|
|
Size: int64(len(f.Contents)),
|
|
IsTerminal: false,
|
|
}, nil
|
|
}
|
|
|
|
// NewStorage returns a certmagic.Storage backed by a micro/lock and micro/store
|
|
func NewStorage(lock sync.Sync, store store.Store) certmagic.Storage {
|
|
return &storage{
|
|
lock: lock,
|
|
store: store,
|
|
}
|
|
}
|