0
0
package openbaoctl
import (
"bytes"
"cmp"
"context"
"crypto/sha256"
"encoding/hex"
"errors"
"fmt"
"log/slog"
"os"
"path/filepath"
"strconv"
"strings"
"time"
"github.com/johnandersen777/socialweb-computer-kcp/api/v1alpha1"
"github.com/johnandersen777/socialweb-computer-kcp/internal/baosync"
"github.com/johnandersen777/socialweb-computer-kcp/internal/kit/conds"
"github.com/johnandersen777/socialweb-computer-kcp/internal/rootvault"
"github.com/johnandersen777/socialweb-computer-kcp/internal/vault/openbao"
"github.com/johnandersen777/socialweb-computer-kcp/internal/vaultcert"
)
const (
RetryAfter = 2 * time.Second
TidyRetryAfter = time.Minute
OIDCIssuerRetryAfter = 5 * time.Second
PassTimeout = 30 * time.Second
DefaultListen = rootvault.LoopbackHost + ":0"
DefaultShares = 1
DefaultThreshold = 1
DirName = "openbaoservers"
ChildPrefix = "bao-"
OwnerLabel = "socialweb.computer/openbaoserver"
ConditionReady = "Ready"
ConditionInitialized = "Initialized"
ConditionUnsealed = "Unsealed"
ConditionSynced = "Synced"
LogCapBytes = 64 << 20
)
var GVR = v1alpha1.OpenBaoServerGVR
var ErrNotHeld = errors.New(grantNotHeldReason)
type Config struct {
StateDir string
Prefix string
Env []v1alpha1.HostProcessEnv
Resolve func(v1alpha1.HostProcessAsset) (string, error)
Log *slog.Logger
}
var OutboundEnvNames = []string{"HTTPS_PROXY", "HTTP_PROXY", "NO_PROXY", "SSL_CERT_FILE"}
func OutboundEnv(getenv func(string) string) []v1alpha1.HostProcessEnv {
var out []v1alpha1.HostProcessEnv
for _, n := range OutboundEnvNames {
if v := getenv(n); v != "" {
out = append(out, v1alpha1.HostProcessEnv{Name: n, Value: v})
}
}
return out
}
type Children interface {
Ensure(ctx context.Context, name string, spec v1alpha1.HostProcessSpec) (v1alpha1.HostProcess, error)
Delete(ctx context.Context, name string) error
}
type Outcome struct {
Status v1alpha1.OpenBaoServerStatus
Grants map[string]v1alpha1.GuestIdentityGrantStatus
RequeueAfter time.Duration
Err error
}
type Servers struct {
c Config
log *slog.Logger
}
func New(c Config) (*Servers, error) {
if !filepath.IsAbs(c.StateDir) {
return nil, fmt.Errorf("openbaoctl: StateDir %q must be absolute", c.StateDir)
}
if c.Prefix == "" {
return nil, fmt.Errorf("openbaoctl: a unit prefix is required; a controller places only its own instance's servers")
}
log := c.Log
if log == nil {
log = slog.New(slog.DiscardHandler)
}
return &Servers{c: c, log: log.With("component", "openbaoserver")}, nil
}
func ServerDir(stateDir, name string) string { return filepath.Join(stateDir, DirName, name) }
func ChildName(name string) string { return ChildPrefix + name }
func NeedsGrants(o v1alpha1.OpenBaoServer) bool {
return o.Spec.Declared != nil && o.Spec.Declared.IdentityOIDC != nil
}
func (s *Servers) unit(o v1alpha1.OpenBaoServer) string {
if o.Spec.Unit != "" {
return o.Spec.Unit
}
return s.c.Prefix + ChildPrefix + o.Name + ".service"
}
func refs(dir string, t *v1alpha1.OpenBaoServerTLS) *v1alpha1.OpenBaoServerRefs {
ca := rootvault.TLSCAPath(dir)
if t != nil {
ca = t.CAFile
}
return &v1alpha1.OpenBaoServerRefs{UnsealKeys: "file:" + rootvault.UnsealKeysPath(dir), CA: "file:" + ca,
ClientCert: "file:" + rootvault.ClientCertPath(dir), ClientKey: "file:" + rootvault.ClientKeyPath(dir),
CertAuthMount: CertAuthMount, CertAuthRole: CertAuthRole, KVMount: KVMount}
}
var replaceable = map[v1alpha1.HostProcessLostReason]bool{v1alpha1.HostProcessLostUnitGone: true, v1alpha1.HostProcessLostHostRebooted: true,
v1alpha1.HostProcessLostManagerRestarted: true, v1alpha1.HostProcessLostIdentityMismatch: true}
func restartKey(config []byte, files ...string) string {
h := sha256.New()
h.Write(config)
for _, f := range files {
if f == "" {
continue
}
b, _ := os.ReadFile(f)
h.Write([]byte(f))
h.Write(b)
}
return hex.EncodeToString(h.Sum(nil))[:16]
}
const MemoryMax = 512 << 20
func (s *Servers) childSpec(o v1alpha1.OpenBaoServer, dir, key string) v1alpha1.HostProcessSpec {
rp := o.Spec.RestartPolicy
rp = cmp.Or(rp, v1alpha1.HostProcessRestartOnFailure)
spec := v1alpha1.HostProcessSpec{Unit: s.unit(o), Exec: o.Spec.Exec, Argv: []string{"server", "-config", rootvault.ConfigPath(dir)},
WorkDir: rootvault.Dir(dir), RestartPolicy: rp, Stop: &v1alpha1.HostProcessStop{Signal: "SIGTERM", GraceSeconds: 15},
Placement: v1alpha1.HostProcessPlacementSupervisor, Slice: o.Spec.Slice, RestartKey: key,
Limits: &v1alpha1.HostProcessLimits{MemoryMax: strconv.FormatUint(MemoryMax, 10)},
After: append([]string(nil), o.Spec.After...), Wants: append([]string(nil), o.Spec.Wants...)}
if o.Spec.Asset != nil {
a := *o.Spec.Asset
spec.Asset = &a
}
if o.Spec.Log != "" {
spec.Output = &v1alpha1.HostProcessOutput{Stdout: o.Spec.Log, Stderr: o.Spec.Log, CapBytes: LogCapBytes}
}
spec.Env = append(spec.Env, s.c.Env...)
return spec
}
func writeIfChanged(path string, data []byte, mode os.FileMode) error {
if cur, err := os.ReadFile(path); err == nil && bytes.Equal(cur, data) {
return os.Chmod(path, mode)
}
if err := os.MkdirAll(filepath.Dir(path), 0o700); err != nil {
return err
}
tmp := path + ".tmp"
if err := os.WriteFile(tmp, data, mode); err != nil {
return err
}
return os.Rename(tmp, path)
}
func unseal(ctx context.Context, client *openbao.Client, k UnsealKeys) error {
for i := 0; i < k.Threshold; i++ {
sealed, err := client.Unseal(ctx, k.Keys[i])
if err != nil {
return fmt.Errorf("unsealing with key %d of %d: %w", i+1, k.Threshold, err)
}
if !sealed {
return nil
}
}
return fmt.Errorf("still sealed after %d keys", k.Threshold)
}
type synced struct {
report baosync.Report
pending []string
how string
desired baosync.Desired
running map[string]string
tidied bool
tidyErr error
roles map[string]grantRole
refused map[string]string
}
func tidyInterval(s v1alpha1.OpenBaoServerSpec) (time.Duration, error) {
if s.Tidy == nil || s.Tidy.Interval == "" {
return DefaultTidyInterval, nil
}
d, err := time.ParseDuration(s.Tidy.Interval)
if err != nil || d < time.Minute {
return 0, fmt.Errorf("spec.tidy.interval %q: a duration of at least 1m", s.Tidy.Interval)
}
return d, nil
}
func tidyDue(prev *v1alpha1.OpenBaoServerTidyStatus, interval time.Duration, now time.Time) bool {
return tidyIn(prev, interval, now) <= 0
}
func tidyIn(prev *v1alpha1.OpenBaoServerTidyStatus, interval time.Duration, now time.Time) time.Duration {
if prev == nil || prev.LastRunAt == "" {
return 0
}
at, err := time.Parse(time.RFC3339Nano, prev.LastRunAt)
if err != nil {
return 0
}
return at.Add(interval).Sub(now)
}
func tidyTokensAndLeases(ctx context.Context, admin *openbao.Client) (bool, error) {
var errs []error
for _, p := range []string{"auth/token/tidy", "sys/leases/tidy"} {
if err := admin.Write(ctx, p, map[string]any{}); err != nil {
errs = append(errs, fmt.Errorf("%s: %w", p, err))
}
}
return len(errs) == 0, errors.Join(errs...)
}
func recordTidy(st *v1alpha1.OpenBaoServerStatus, s synced, interval time.Duration, log *slog.Logger) {
next := &v1alpha1.OpenBaoServerTidyStatus{Interval: interval.String()}
if st.Tidy != nil {
next.LastRunAt, next.Message = st.Tidy.LastRunAt, st.Tidy.Message
}
switch {
case s.tidyErr != nil:
next.Message = "token and lease tidy failed: " + s.tidyErr.Error()
log.Warn("token and lease tidy failed", "err", s.tidyErr.Error())
case s.tidied:
next.LastRunAt = time.Now().UTC().Format(time.RFC3339Nano)
next.Message = "token and lease tidy ran"
log.Info("token and lease tidy ran", "interval", interval.String())
}
st.Tidy = next
}
func syncWith(ctx context.Context, admin *openbao.Client, in layoutInput) (synced, error) {
in.accessors = accessorsOf(ctx, admin)
d, pending, roles, refused, err := desiredWithIdentity(ctx, in, pkiCA(admin))
if err != nil {
return synced{}, err
}
rep, err := baosync.Sync(ctx, admin, d)
generatedRoot := false
if err == nil && rep.Err == nil {
generatedRoot, err = ensurePKIRoots(ctx, admin, in.declared)
if err != nil {
return synced{}, err
}
}
if err == nil && rep.Err == nil && (generatedRoot || len(pending) > 0 && rep.Changed()) {
in.accessors = accessorsOf(ctx, admin)
if d2, pending2, roles2, refused2, derr := desiredWithIdentity(ctx, in, pkiCA(admin)); derr == nil {
rep2, err2 := baosync.Sync(ctx, admin, d2)
rep.Applied = append(rep.Applied, rep2.Applied...)
rep.Conflicts, rep.Err = rep2.Conflicts, errors.Join(rep.Err, rep2.Err)
d, pending, roles, refused, err = d2, pending2, roles2, refused2, err2
}
}
s := synced{report: rep, pending: pending, desired: d, roles: roles, refused: refused}
if err == nil && in.tidyDue {
s.tidied, s.tidyErr = tidyTokensAndLeases(ctx, admin)
}
if err == nil && len(in.plugins) > 0 {
s.running = map[string]string{}
if auths, aerr := admin.AuthMounts(ctx); aerr == nil {
for p, m := range auths {
s.running[p] = m.RunningSHA256
}
}
}
return s, err
}
const (
defaultPKIRootCommonName = "socialweb.local"
defaultPKIRootTTL = "8760h"
)
func ensurePKIRoots(ctx context.Context, c *openbao.Client, d *v1alpha1.OpenBaoServerDeclared) (bool, error) {
if d == nil {
return false, nil
}
generated := false
for _, m := range d.SecretMounts {
if m.Type != string(baosync.MountPKI) {
continue
}
if _, err := c.CAPEM(ctx, m.Path); err == nil {
continue
} else if !pkiRootMissing(err) {
return false, err
}
ttl := strings.TrimSpace(m.MaxLeaseTTL)
ttl = cmp.Or(ttl, defaultPKIRootTTL)
if _, err := c.GeneratePKIRoot(ctx, m.Path, defaultPKIRootCommonName, ttl); err != nil {
return false, fmt.Errorf("generating the pki root under %s: %w", m.Path, err)
}
generated = true
}
return generated, nil
}
func pkiRootMissing(err error) bool {
var re *openbao.ResponseError
return errors.As(err, &re) && (re.Status == 404 || re.Status == 400) || strings.Contains(err.Error(), "holds no certificate")
}
func accessorsOf(ctx context.Context, admin *openbao.Client) map[string]string {
out := map[string]string{}
auths, err := admin.AuthMounts(ctx)
if err != nil {
return out
}
for p, m := range auths {
if m.Accessor != "" {
out[p] = m.Accessor
}
}
return out
}
func syncCore(ctx context.Context, client *openbao.Client, keysPath string, in layoutInput) (synced, error) {
core, err := loginCore(ctx, client)
if err == nil {
s, serr := syncWith(ctx, core, in)
core.RevokeSelf(context.WithoutCancel(ctx))
if serr == nil || !permissionDenied(serr) {
s.how = "the core's cert-auth token"
return s, serr
}
err = serr
} else if !loginRefused(err) {
return synced{}, err
}
k, kerr := ReadUnsealKeys(keysPath)
if kerr != nil {
return synced{}, fmt.Errorf("the core cannot reconcile (%v) and %w", err, kerr)
}
root, gerr := client.GenerateRoot(ctx, k.Keys, k.Threshold)
if gerr != nil {
return synced{}, fmt.Errorf("the core cannot reconcile (%v) and %w", err, gerr)
}
defer root.RevokeSelf(context.WithoutCancel(ctx))
s, serr := syncWith(ctx, root, in)
s.how = fmt.Sprintf("a root token generated from the unseal keys and revoked after the pass, because the core's own token could not reconcile (%v)", err)
return s, serr
}
func recordSync(st *v1alpha1.OpenBaoServerStatus, gen int64, s synced, err error, log *slog.Logger) {
prev := st.Sync
next := &v1alpha1.OpenBaoServerSync{ObservedGeneration: gen}
if prev != nil {
next.SyncedAt, next.LastChange, next.LastChangeAt = prev.SyncedAt, prev.LastChange, prev.LastChangeAt
}
now := time.Now().UTC().Format(time.RFC3339Nano)
if err != nil {
st.Sync = next
if prev != nil {
next.Declared, next.Pending, next.Conflicts = prev.Declared, prev.Pending, prev.Conflicts
}
conds.Set(&st.Conditions, gen, ConditionSynced, false, "SyncFailed", err.Error())
log.Warn("the reconcile of the server against its declaration did not run", "err", err.Error())
return
}
next.Declared, next.Pending, next.Conflicts = s.desired.String(), s.pending, s.report.Conflicts
if s.report.Changed() {
next.LastChange, next.LastChangeAt = s.report.Summary(), now
ops := make([]string, 0, len(s.report.Applied))
for _, o := range s.report.Applied {
ops = append(ops, o.String()+" ("+o.Why+")")
}
log.Info("the server is brought back to its declaration", "at", now, "ops", ops, "by", s.how)
}
if prev == nil || prev.ObservedGeneration != gen || s.report.Changed() {
next.SyncedAt = now
}
st.Sync = next
switch {
case s.report.Err != nil:
conds.Set(&st.Conditions, gen, ConditionSynced, false, "ApplyFailed", s.report.Summary())
case len(s.report.Conflicts) > 0:
conds.Set(&st.Conditions, gen, ConditionSynced, false, "Conflict", strings.Join(s.report.Conflicts, "; "))
default:
conds.Set(&st.Conditions, gen, ConditionSynced, true, "InSync", "the server holds exactly its declaration: "+s.desired.String())
}
}
func (s *Servers) Reconcile(ctx context.Context, o v1alpha1.OpenBaoServer, grants []v1alpha1.GuestIdentityGrant, children Children) Outcome {
log := s.log.With("openbaoserver", o.Name)
var st v1alpha1.OpenBaoServerStatus
o.Status.DeepCopyInto(&st)
gen := o.Generation
st.ObservedGeneration = gen
dir := ServerDir(s.c.StateDir, o.Name)
st.HostProcess = ChildName(o.Name)
st.Refs = refs(dir, o.Spec.TLS)
st.Ready = false
failed := func(format string, args ...any) v1alpha1.OpenBaoServerStatus {
st.Phase, st.Message = v1alpha1.OpenBaoServerPhaseFailed, fmt.Sprintf(format, args...)
conds.Set(&st.Conditions, gen, ConditionReady, false, "Failed", st.Message)
log.Warn("failed", "msg", st.Message)
return st
}
fail := func(format string, args ...any) Outcome {
return Outcome{Status: failed(format, args...)}
}
retry := func(format string, args ...any) Outcome {
out := Outcome{Status: failed(format, args...)}
out.Err = errors.New(out.Status.Message)
return out
}
starting := func(after time.Duration, format string, args ...any) Outcome {
st.Phase, st.Message, st.Address = v1alpha1.OpenBaoServerPhaseStarting, fmt.Sprintf(format, args...), ""
conds.Set(&st.Conditions, gen, ConditionReady, false, "Starting", st.Message)
return Outcome{Status: st, RequeueAfter: after}
}
shares, threshold := int(o.Spec.Init.Shares), int(o.Spec.Init.Threshold)
shares = cmp.Or(shares, DefaultShares)
threshold = cmp.Or(threshold, DefaultThreshold)
if threshold > shares {
return fail("init.threshold %d is over init.shares %d", threshold, shares)
}
if o.Spec.Asset == nil && o.Spec.Exec == "" {
return fail("name the bao executable: spec.asset (name bao) or spec.exec (an absolute path)")
}
listen := o.Spec.Listen
listen = cmp.Or(listen, DefaultListen)
if err := checkClients(o.Spec.Clients, o.Spec.Declared); err != nil {
return fail("spec.clients: %v", err)
}
if o.Spec.Unit != "" && !strings.HasPrefix(o.Spec.Unit, s.c.Prefix) {
return fail("spec.unit %s is not under this controller's prefix %s", o.Spec.Unit, s.c.Prefix)
}
tidyEvery, err := tidyInterval(o.Spec)
if err != nil {
return fail("%v", err)
}
tlsm, err := vaultcert.EnsureRootVaultTLS(dir, rootvault.LoopbackHost)
if err != nil {
return retry("mutual TLS material: %v", err)
}
clientsCA, err := vaultcert.EnsureOpenBaoClientsCA(dir, tlsm.CAPEM)
if err != nil {
return retry("the clients CA: %v", err)
}
st.Clients = nil
for _, cl := range o.Spec.Clients {
m, err := clientsCA.EnsureClient(dir, cl.Name)
if err != nil {
return retry("client %s: %v", cl.Name, err)
}
st.Clients = append(st.Clients, v1alpha1.OpenBaoServerClientRefs{Name: cl.Name, CertAuthMount: CertAuthMount,
CertAuthRole: cl.Name, Policy: strings.Join(clientTokenPolicies(cl), ","), KVMount: cl.KVMount, ClientCert: "file:" + m.CertFile,
ClientKey: "file:" + m.KeyFile})
}
plugins, err := s.placePlugins(o, dir)
if err != nil {
st.Plugins = nil
return retry("spec.plugins: %v", err)
}
if !NeedsGrants(o) {
grants = nil
}
layout := layoutInput{caPEM: tlsm.CAPEM, clientsCAPEM: clientsCA.CAPEM, clients: o.Spec.Clients, declared: o.Spec.Declared, plugins: plugins, grants: grants,
tidyDue: tidyDue(st.Tidy, tidyEvery, time.Now())}
opts, err := serverOptions(o.Spec, clientsCA.BundlePath)
if err != nil {
return fail("%v", err)
}
if len(plugins) > 0 {
opts.PluginDirectory = PluginDir(dir)
}
body, err := rootvault.ServerConfigWith(dir, listen, opts)
if err != nil {
return fail("%v", err)
}
if err := os.MkdirAll(rootvault.StorageDir(dir), 0o700); err != nil {
return retry("storage dir: %v", err)
}
if err := writeIfChanged(rootvault.ConfigPath(dir), []byte(body), 0o600); err != nil {
return retry("server config: %v", err)
}
certFile := opts.CertFile
if certFile == "" {
certFile = rootvault.ServerCertPath(dir)
}
key := restartKey([]byte(body), certFile, caFile(o.Spec, dir), clientsCA.BundlePath)
child, err := children.Ensure(ctx, ChildName(o.Name), s.childSpec(o, dir, key))
if err != nil {
return retry("HostProcess %s: %v", ChildName(o.Name), err)
}
if rt := child.Status.Runtime; rt != nil {
st.Runtime = &v1alpha1.OpenBaoServerRuntime{Backend: rt.Backend, Ref: rt.Unit, Instance: rt.InvocationID, Pid: rt.Pid,
StartTime: rt.ActiveSince, HostBootID: rt.HostBootID}
}
if child.Status.Phase == v1alpha1.HostProcessPhaseLost && replaceable[child.Status.LostReason] && child.DeletionTimestamp == nil {
if err := children.Delete(ctx, child.Name); err != nil {
return retry("HostProcess %s is Lost (%s) and deleting it failed: %v", child.Name, child.Status.LostReason, err)
}
log.Info("the server's HostProcess was Lost; it is placed again on the same storage", "hostprocess", child.Name,
"reason", child.Status.LostReason)
return starting(0, "HostProcess %s was Lost (%s); placing it again from its storage", child.Name, child.Status.LostReason)
}
switch child.Status.Phase {
case v1alpha1.HostProcessPhaseFailed, v1alpha1.HostProcessPhaseLost:
return fail("HostProcess %s is %s %s: %s", child.Name, child.Status.Phase, child.Status.LostReason, child.Status.Message)
case v1alpha1.HostProcessPhaseRunning:
default:
return starting(0, "HostProcess %s is %q: %s", child.Name, child.Status.Phase, child.Status.Message)
}
if len(child.Status.Listeners) == 0 {
return starting(0, "HostProcess %s runs and reports no bound address yet", child.Name)
}
if child.Status.RestartKey != key {
return starting(0, "HostProcess %s restarts in place for its new config (restartKey %s)", child.Name, key)
}
addr := "https://" + child.Status.Listeners[0].Address
tlsConf, err := tlsm.ClientTLSConfig()
if err != nil {
return retry("%v", err)
}
pool := tlsConf.RootCAs
if o.Spec.TLS != nil {
raw, err := os.ReadFile(o.Spec.TLS.CAFile)
if err != nil {
return retry("spec.tls.caFile: %v", err)
}
if pool, err = openbao.CertPoolFromPEM(raw); err != nil {
return retry("spec.tls.caFile %s: %v", o.Spec.TLS.CAFile, err)
}
}
client := openbao.New(addr, "", openbao.WithCACertPool(pool), openbao.WithClientCertificate(tlsConf.Certificates[0]))
h, err := client.Health(ctx)
if err != nil {
return starting(RetryAfter, "the server at %s does not answer yet: %v", addr, err)
}
st.Address = addr
keysPath := rootvault.UnsealKeysPath(dir)
instance := ""
if st.Runtime != nil {
instance = st.Runtime.Instance
}
if !h.Initialized {
if _, err := os.Lstat(keysPath); err == nil {
return fail("the storage at %s is not initialized and unseal keys already exist at %s: refusing to initialize over them",
rootvault.StorageDir(dir), keysPath)
}
res, root, err := client.Init(ctx, shares, threshold)
if err != nil {
return retry("init: %v", err)
}
k := UnsealKeys{Threshold: threshold, Shares: shares, Keys: res.KeysBase64}
if err := WriteUnsealKeys(keysPath, k); err != nil {
return fail("initialized, and writing the unseal keys to %s failed (%v): the storage at %s cannot be unsealed again",
keysPath, err, rootvault.StorageDir(dir))
}
log.Info("initialized; unseal keys written to the state dir (0600), never to kcp", "shares", shares, "threshold", threshold,
"keys", st.Refs.UnsealKeys)
if err := unseal(ctx, client, k); err != nil {
return retry("%v", err)
}
st.UnsealedInstance, st.UnsealedAt = instance, time.Now().UTC().Format(time.RFC3339Nano)
sy, serr := syncWith(ctx, root, layout)
sy.how = "the initial root token"
if err := root.RevokeSelf(ctx); err != nil {
log.Warn("revoking the initial root token", "err", err.Error())
} else {
log.Info("the initial root token is revoked; the core logs in with its client certificate")
}
recordSync(&st, gen, sy, serr, log)
recordTidy(&st, sy, tidyEvery, log)
layout.tidyDue = tidyDue(st.Tidy, tidyEvery, time.Now())
} else if h.Sealed {
k, err := ReadUnsealKeys(keysPath)
if err != nil {
return retry("sealed: %v", err)
}
if err := unseal(ctx, client, k); err != nil {
return retry("%v", err)
}
st.UnsealedInstance, st.UnsealedAt = instance, time.Now().UTC().Format(time.RFC3339Nano)
log.Info("unsealed", "instance", instance, "address", addr)
}
sy, serr := syncCore(ctx, client, keysPath, layout)
recordSync(&st, gen, sy, serr, log)
recordTidy(&st, sy, tidyEvery, log)
var held error
switch {
case serr != nil:
held = serr
case sy.report.Err != nil:
held = sy.report.Err
case len(sy.pending) > 0:
held = ErrNotHeld
}
out := Outcome{}
if NeedsGrants(o) {
reason := ""
switch {
case held != nil:
reason = held.Error()
case len(sy.report.Conflicts) > 0:
reason = grantNotHeldReason
}
out.Grants = grantOutcomes(sy.roles, sy.refused, grants, reason == "", reason)
}
if len(plugins) > 0 {
perr := serr
if perr == nil {
perr = sy.report.Err
}
st.Plugins = pluginStatus(plugins, sy.running, perr)
if perr == nil {
if removed := prunePlugins(dir, plugins); len(removed) > 0 {
log.Info("removed plugin binaries no catalog entry runs", "files", removed)
}
}
} else {
st.Plugins = nil
}
h, err = client.Health(ctx)
if err != nil {
out.Status = starting(RetryAfter, "the server at %s stopped answering: %v", addr, err).Status
out.RequeueAfter = RetryAfter
return out
}
st.Initialized, st.Sealed, st.Version = h.Initialized, h.Sealed, h.Version
if ca, err := os.ReadFile(FileRef(st.Refs.CA)); err == nil {
st.CABundle = string(ca)
}
conds.Set(&st.Conditions, gen, ConditionInitialized, h.Initialized, "Health", "")
conds.Set(&st.Conditions, gen, ConditionUnsealed, !h.Sealed, "Health", "")
if !h.Initialized || h.Sealed {
st.Phase, st.Message = v1alpha1.OpenBaoServerPhaseSealed, "sealed"
conds.Set(&st.Conditions, gen, ConditionReady, false, "Sealed", st.Message)
out.Status, out.RequeueAfter = st, RetryAfter
return out
}
st.Phase, st.Message, st.Ready = v1alpha1.OpenBaoServerPhaseReady, "initialized and unsealed", true
conds.Set(&st.Conditions, gen, ConditionReady, true, "Ready", st.Message)
out.Status, out.Err = st, held
if held != nil && oidcIssuerDown(held) {
log.Info("a jwt auth mount waits for its OIDC issuer to answer its discovery URL", "retryIn", OIDCIssuerRetryAfter.String(), "err", held.Error())
out.Err, out.RequeueAfter = nil, OIDCIssuerRetryAfter
return out
}
out.RequeueAfter = tidyIn(st.Tidy, tidyEvery, time.Now())
if out.RequeueAfter <= 0 {
out.RequeueAfter = TidyRetryAfter
}
return out
}
func oidcIssuerDown(err error) bool {
return strings.Contains(err.Error(), "error checking oidc discovery URL")
}