134 lines
2.9 KiB
Go
134 lines
2.9 KiB
Go
package remote
|
|
|
|
import (
|
|
"encoding/json"
|
|
"errors"
|
|
"os"
|
|
"path/filepath"
|
|
"sync"
|
|
"time"
|
|
)
|
|
|
|
type issuedToken struct {
|
|
MachineID string `json:"machineId"`
|
|
MachineName string `json:"machineName"`
|
|
InstanceID string `json:"instanceId"`
|
|
Instance string `json:"instanceName"`
|
|
Token string `json:"token"`
|
|
IssuedAt time.Time `json:"issuedAt"`
|
|
}
|
|
|
|
type tokenStore struct {
|
|
mu sync.RWMutex
|
|
path string
|
|
byToken map[string]issuedToken
|
|
byKey map[string]issuedToken
|
|
}
|
|
|
|
func newTokenStore(dataDir string) (*tokenStore, error) {
|
|
store := &tokenStore{
|
|
path: filepath.Join(dataDir, "agent_tokens.json"),
|
|
byToken: make(map[string]issuedToken),
|
|
byKey: make(map[string]issuedToken),
|
|
}
|
|
if err := store.load(); err != nil {
|
|
return nil, err
|
|
}
|
|
return store, nil
|
|
}
|
|
|
|
func (s *tokenStore) Issue(machineID, machineName, instanceID, instance string) (string, error) {
|
|
key := instanceKey(machineID, instanceID)
|
|
s.mu.Lock()
|
|
if existing, ok := s.byKey[key]; ok && time.Since(existing.IssuedAt) < 24*time.Hour {
|
|
s.mu.Unlock()
|
|
return existing.Token, nil
|
|
}
|
|
token, err := RandomToken()
|
|
if err != nil {
|
|
s.mu.Unlock()
|
|
return "", err
|
|
}
|
|
item := issuedToken{
|
|
MachineID: machineID,
|
|
MachineName: machineName,
|
|
InstanceID: instanceID,
|
|
Instance: instance,
|
|
Token: token,
|
|
IssuedAt: time.Now(),
|
|
}
|
|
s.byToken[token] = item
|
|
s.byKey[key] = item
|
|
err = s.saveLocked()
|
|
s.mu.Unlock()
|
|
return token, err
|
|
}
|
|
|
|
func (s *tokenStore) Valid(token string) bool {
|
|
s.mu.RLock()
|
|
_, ok := s.byToken[token]
|
|
s.mu.RUnlock()
|
|
return ok
|
|
}
|
|
|
|
func (s *tokenStore) Matches(token, machineID, instanceID string) bool {
|
|
s.mu.RLock()
|
|
item, ok := s.byToken[token]
|
|
s.mu.RUnlock()
|
|
return ok && item.MachineID == machineID && item.InstanceID == instanceID
|
|
}
|
|
|
|
func (s *tokenStore) load() error {
|
|
data, err := os.ReadFile(s.path)
|
|
if errors.Is(err, os.ErrNotExist) {
|
|
return nil
|
|
}
|
|
if err != nil {
|
|
return err
|
|
}
|
|
var items []issuedToken
|
|
if err := json.Unmarshal(data, &items); err != nil {
|
|
return err
|
|
}
|
|
for _, item := range items {
|
|
if item.Token == "" || item.MachineID == "" || item.InstanceID == "" {
|
|
continue
|
|
}
|
|
s.byToken[item.Token] = item
|
|
s.byKey[instanceKey(item.MachineID, item.InstanceID)] = item
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (s *tokenStore) saveLocked() error {
|
|
items := make([]issuedToken, 0, len(s.byKey))
|
|
for _, item := range s.byKey {
|
|
items = append(items, item)
|
|
}
|
|
data, err := json.MarshalIndent(items, "", " ")
|
|
if err != nil {
|
|
return err
|
|
}
|
|
temp, err := os.CreateTemp(filepath.Dir(s.path), ".agent-tokens-*.tmp")
|
|
if err != nil {
|
|
return err
|
|
}
|
|
tempPath := temp.Name()
|
|
defer func() { _ = os.Remove(tempPath) }()
|
|
if err := temp.Chmod(0o600); err != nil {
|
|
_ = temp.Close()
|
|
return err
|
|
}
|
|
if _, err := temp.Write(data); err != nil {
|
|
_ = temp.Close()
|
|
return err
|
|
}
|
|
if err := temp.Close(); err != nil {
|
|
return err
|
|
}
|
|
if err := os.Rename(tempPath, s.path); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}
|