0
0
package baosync
import (
"context"
"errors"
"fmt"
"strings"
"time"
"github.com/johnandersen777/socialweb-computer-kcp/internal/vault/openbao"
)
func mountType(m openbao.Mount) string {
if m.Type == MountKV && fmt.Sprint(m.Options["version"]) == "2" {
return MountKV2
}
return m.Type
}
func objectMounted(p string, a Actual) bool {
segs := strings.Split(strings.Trim(p, "/"), "/")
if segs[0] == "auth" {
if len(segs) < 2 {
return false
}
_, ok := a.AuthMounts[segs[1]]
return ok
}
_, ok := a.SecretMounts[segs[0]]
return ok
}
func Read(ctx context.Context, c *openbao.Client, d Desired) (Actual, error) {
a := Actual{Plugins: map[string]PluginEntry{}, AuthSHA256: map[string]string{}, SecretMounts: map[string]string{}, AuthMounts: map[string]string{}, Policies: map[string]string{},
Collections: map[string][]string{}, Objects: map[string]map[string]any{}, KV: map[string][]string{},
KVUpdated: map[string]time.Time{}, Now: time.Now()}
secrets, err := c.SecretMounts(ctx)
if err != nil {
return a, fmt.Errorf("baosync: listing the secret mounts: %w; an unread list is not an empty one", err)
}
for p, m := range secrets {
a.SecretMounts[p] = mountType(m)
}
auths, err := c.AuthMounts(ctx)
if err != nil {
return a, fmt.Errorf("baosync: listing the auth mounts: %w; an unread list is not an empty one", err)
}
for p, m := range auths {
a.AuthMounts[p] = m.Type
a.AuthSHA256[p] = m.RunningSHA256
}
if err := readPlugins(ctx, c, d, &a); err != nil {
return a, err
}
names, err := c.List(ctx, "sys/policies/acl")
if err != nil {
return a, fmt.Errorf("baosync: listing the policies: %w; an unread list is not an empty one", err)
}
if len(names) == 0 {
return a, errors.New("baosync: the policy list came back empty; a server always holds the default policy, so the read is wrong")
}
want := map[string]bool{}
for _, p := range d.Policies {
want[p.Name] = true
}
for _, n := range names {
a.Policies[n] = ""
if !want[n] {
continue
}
hcl, err := c.GetPolicy(ctx, n)
if err != nil {
return a, fmt.Errorf("baosync: reading policy %s: %w", n, err)
}
a.Policies[n] = hcl
}
for _, coll := range d.Collections() {
if !objectMounted(coll, a) || !collectionTypeMatches(coll, d, a) {
continue
}
keys, err := c.List(ctx, coll)
if err != nil {
return a, fmt.Errorf("baosync: listing %s: %w; an unread list is not an empty one", coll, err)
}
a.Collections[coll] = keys
}
for _, o := range d.Objects {
p := strings.Trim(o.Path, "/")
if !objectMounted(p, a) {
continue
}
data, err := c.Read(ctx, p)
if err != nil {
continue
}
a.Objects[p] = data
}
for _, s := range d.KV {
if _, ok := a.SecretMounts[strings.Trim(s.Mount, "/")]; !ok {
continue
}
key := KVScopeKey(s)
keys, err := c.List(ctx, key)
if err != nil {
return a, fmt.Errorf("baosync: listing %s: %w; an unread list is not an empty one", key, err)
}
keep := KeptKV(s)
var entries []string
for _, name := range keys {
if keep[KVTop(name)] {
entries = append(entries, name)
continue
}
leaves, err := kvLeaves(ctx, c, key, name)
if err != nil {
return a, err
}
for _, leaf := range leaves {
entries = append(entries, leaf)
if s.Grace <= 0 {
continue
}
target := strings.TrimSuffix(key, "/") + "/" + leaf
meta, err := c.Read(ctx, target)
if errors.Is(err, openbao.ErrNotFound) {
continue
}
at, perr := time.Parse(time.RFC3339Nano, fmt.Sprint(meta["updated_time"]))
if err != nil || perr != nil {
at = a.Now
}
a.KVUpdated[target] = at
}
}
a.KV[key] = entries
}
return a, nil
}
func kvLeaves(ctx context.Context, c *openbao.Client, key, name string) ([]string, error) {
if !strings.HasSuffix(name, "/") {
return []string{name}, nil
}
path := strings.TrimSuffix(key, "/") + "/" + strings.TrimSuffix(name, "/")
under, err := c.List(ctx, path)
if err != nil {
return nil, fmt.Errorf("baosync: listing %s: %w; an unread list is not an empty one", path, err)
}
var out []string
for _, u := range under {
leaves, err := kvLeaves(ctx, c, path, u)
if err != nil {
return nil, err
}
for _, l := range leaves {
out = append(out, name+l)
}
}
return out, nil
}
func collectionTypeMatches(coll string, d Desired, a Actual) bool {
if coll == IdentityRoleCollection {
return d.IdentityOIDC
}
for _, m := range d.AuthMounts {
if d.AuthRoleCollection(m) == coll {
return a.AuthMounts[strings.Trim(m.Path, "/")] == m.Type
}
}
for _, m := range d.SecretMounts {
if m.Type == MountPKI && PKIRoleCollection(m.Path) == coll {
return a.SecretMounts[strings.Trim(m.Path, "/")] == MountPKI
}
}
return false
}
func readPlugins(ctx context.Context, c *openbao.Client, d Desired, a *Actual) error {
if len(d.Plugins) == 0 {
return nil
}
cat, err := c.Read(ctx, "sys/plugins/catalog")
if err != nil {
return fmt.Errorf("baosync: reading the plugin catalog: %w; an unread catalog is not an empty one", err)
}
detailed, _ := cat["detailed"].([]any)
for _, x := range detailed {
e, ok := x.(map[string]any)
if !ok || e["builtin"] == true {
continue
}
a.External = append(a.External, fmt.Sprint(e["type"])+"/"+fmt.Sprint(e["name"]))
}
for _, p := range d.Plugins {
got, err := c.Read(ctx, "sys/plugins/catalog/"+PluginKey(p))
if errors.Is(err, openbao.ErrNotFound) {
continue
}
if err != nil {
return fmt.Errorf("baosync: reading plugin %s: %w", PluginKey(p), err)
}
if got["builtin"] == true {
continue
}
a.Plugins[PluginKey(p)] = PluginEntry{Command: fmt.Sprint(got["command"]), SHA256: fmt.Sprint(got["sha256"])}
}
return nil
}