traefik/pkg/provider/acme/local_store.go

174 lines
4.3 KiB
Go
Raw Normal View History

2018-03-05 19:54:04 +00:00
package acme
import (
"encoding/json"
2021-03-04 19:08:03 +00:00
"io"
2018-03-05 19:54:04 +00:00
"os"
2018-07-03 10:44:04 +00:00
"sync"
2018-03-05 19:54:04 +00:00
2022-11-21 17:36:05 +00:00
"github.com/rs/zerolog/log"
"github.com/traefik/traefik/v2/pkg/logs"
"github.com/traefik/traefik/v2/pkg/safe"
2018-03-05 19:54:04 +00:00
)
var _ Store = (*LocalStore)(nil)
2020-05-11 10:06:07 +00:00
// LocalStore Stores implementation for local file.
2018-03-05 19:54:04 +00:00
type LocalStore struct {
saveDataChan chan map[string]*StoredData
2018-03-05 19:54:04 +00:00
filename string
lock sync.RWMutex
storedData map[string]*StoredData
2018-03-05 19:54:04 +00:00
}
2020-05-11 10:06:07 +00:00
// NewLocalStore initializes a new LocalStore with a file name.
2018-07-03 10:44:04 +00:00
func NewLocalStore(filename string) *LocalStore {
store := &LocalStore{filename: filename, saveDataChan: make(chan map[string]*StoredData)}
2018-03-05 19:54:04 +00:00
store.listenSaveAction()
return store
}
func (s *LocalStore) save(resolverName string, storedData *StoredData) {
s.lock.Lock()
defer s.lock.Unlock()
s.storedData[resolverName] = storedData
// we cannot pass s.storedData directly, map is reference type and as result
// we can face with race condition, so we need to work with objects copy
s.saveDataChan <- s.unSafeCopyOfStoredData()
}
func (s *LocalStore) get(resolverName string) (*StoredData, error) {
s.lock.Lock()
defer s.lock.Unlock()
2018-03-05 19:54:04 +00:00
if s.storedData == nil {
s.storedData = map[string]*StoredData{}
2018-03-05 19:54:04 +00:00
2018-04-10 08:52:04 +00:00
hasData, err := CheckFile(s.filename)
2018-03-05 19:54:04 +00:00
if err != nil {
return nil, err
}
2018-04-10 08:52:04 +00:00
if hasData {
2022-11-21 17:36:05 +00:00
logger := log.With().Str(logs.ProviderName, "acme").Logger()
2018-11-14 09:18:03 +00:00
2018-04-10 08:52:04 +00:00
f, err := os.Open(s.filename)
if err != nil {
2018-03-05 19:54:04 +00:00
return nil, err
}
2018-04-10 08:52:04 +00:00
defer f.Close()
2021-03-04 19:08:03 +00:00
file, err := io.ReadAll(f)
2018-03-26 12:12:03 +00:00
if err != nil {
return nil, err
}
2018-04-10 08:52:04 +00:00
if len(file) > 0 {
if err := json.Unmarshal(file, &s.storedData); err != nil {
2018-04-10 08:52:04 +00:00
return nil, err
}
}
// Delete all certificates with no value
var certificates []*CertAndStore
for _, storedData := range s.storedData {
for _, certificate := range storedData.Certificates {
if len(certificate.Certificate.Certificate) == 0 || len(certificate.Key) == 0 {
2022-11-21 17:36:05 +00:00
logger.Debug().Msgf("Deleting empty certificate %v for %v", certificate, certificate.Domain.ToStrArray())
continue
}
certificates = append(certificates, certificate)
}
if len(certificates) < len(storedData.Certificates) {
storedData.Certificates = certificates
// we cannot pass s.storedData directly, map is reference type and as result
// we can face with race condition, so we need to work with objects copy
s.saveDataChan <- s.unSafeCopyOfStoredData()
}
}
2018-03-26 12:12:03 +00:00
}
2018-03-05 19:54:04 +00:00
}
if s.storedData[resolverName] == nil {
s.storedData[resolverName] = &StoredData{}
}
return s.storedData[resolverName], nil
2018-03-05 19:54:04 +00:00
}
2020-05-11 10:06:07 +00:00
// listenSaveAction listens to a chan to store ACME data in json format into `LocalStore.filename`.
2018-03-05 19:54:04 +00:00
func (s *LocalStore) listenSaveAction() {
safe.Go(func() {
2022-11-21 17:36:05 +00:00
logger := log.With().Str(logs.ProviderName, "acme").Logger()
for object := range s.saveDataChan {
2018-03-05 19:54:04 +00:00
data, err := json.MarshalIndent(object, "", " ")
if err != nil {
2022-11-21 17:36:05 +00:00
logger.Error().Err(err).Send()
2018-03-05 19:54:04 +00:00
}
2021-03-04 19:08:03 +00:00
err = os.WriteFile(s.filename, data, 0o600)
2018-03-05 19:54:04 +00:00
if err != nil {
2022-11-21 17:36:05 +00:00
logger.Error().Err(err).Send()
2018-03-05 19:54:04 +00:00
}
}
})
}
// unSafeCopyOfStoredData creates maps copy of storedData. Is not thread safe, you should use `s.lock`.
func (s *LocalStore) unSafeCopyOfStoredData() map[string]*StoredData {
result := map[string]*StoredData{}
for k, v := range s.storedData {
result[k] = v
}
return result
}
2020-05-11 10:06:07 +00:00
// GetAccount returns ACME Account.
func (s *LocalStore) GetAccount(resolverName string) (*Account, error) {
storedData, err := s.get(resolverName)
2018-03-05 19:54:04 +00:00
if err != nil {
return nil, err
}
return storedData.Account, nil
}
2020-05-11 10:06:07 +00:00
// SaveAccount stores ACME Account.
func (s *LocalStore) SaveAccount(resolverName string, account *Account) error {
storedData, err := s.get(resolverName)
2018-03-05 19:54:04 +00:00
if err != nil {
return err
}
storedData.Account = account
s.save(resolverName, storedData)
2018-03-05 19:54:04 +00:00
return nil
}
2020-05-11 10:06:07 +00:00
// GetCertificates returns ACME Certificates list.
func (s *LocalStore) GetCertificates(resolverName string) ([]*CertAndStore, error) {
storedData, err := s.get(resolverName)
2018-03-05 19:54:04 +00:00
if err != nil {
return nil, err
}
return storedData.Certificates, nil
}
2020-05-11 10:06:07 +00:00
// SaveCertificates stores ACME Certificates list.
func (s *LocalStore) SaveCertificates(resolverName string, certificates []*CertAndStore) error {
storedData, err := s.get(resolverName)
2018-03-05 19:54:04 +00:00
if err != nil {
return err
}
storedData.Certificates = certificates
s.save(resolverName, storedData)
2018-03-05 19:54:04 +00:00
return nil
}