0
0
package requester
import (
"bytes"
"cmp"
"context"
"encoding/json"
"errors"
"fmt"
"io"
"log/slog"
"net"
"net/http"
"path/filepath"
"regexp"
"strings"
"sync"
"time"
"github.com/bluesky-social/indigo/atproto/identity"
commonv1 "github.com/johnandersen777/socialweb-computer-kcp/api/common/v1alpha1"
"github.com/johnandersen777/socialweb-computer-kcp/api/v1alpha1"
"github.com/johnandersen777/socialweb-computer-kcp/internal/atproto/cloudinit"
"github.com/johnandersen777/socialweb-computer-kcp/internal/atproto/market"
"github.com/johnandersen777/socialweb-computer-kcp/internal/contract/tunnel"
"github.com/johnandersen777/socialweb-computer-kcp/internal/kit/netretry"
)
const (
SecretsNSID = "com.publicdomainrelay.temp.compute.secrets"
SecretsRoute = cloudinit.GetSecretsRoute
SecretsAPIAudience = "ATProto"
FedproxyRBACNSID = "com.fedproxy.rbac"
)
const (
SecretsChannelIroh = "iroh"
SecretsChannelWebRTC = "webrtc"
SecretsChannelHTTPS = "https"
)
type secretsChannelKey struct{}
func WithSecretsChannel(ctx context.Context, channel string) context.Context {
return context.WithValue(ctx, secretsChannelKey{}, channel)
}
func secretsChannelOf(ctx context.Context) string {
if channel, _ := ctx.Value(secretsChannelKey{}).(string); channel != "" {
return channel
}
return SecretsChannelHTTPS
}
type SecretEntry struct {
Path string `json:"path"`
Value string `json:"value"`
Mode string `json:"mode,omitempty"`
}
func (e *SecretEntry) UnmarshalJSON(raw []byte) error {
var in struct {
Path string `json:"path"`
Value json.RawMessage `json:"value"`
Mode string `json:"mode,omitempty"`
}
if err := json.Unmarshal(raw, &in); err != nil {
return err
}
value, err := secretValueText(in.Value)
if err != nil {
return err
}
*e = SecretEntry{Path: in.Path, Value: value, Mode: in.Mode}
return nil
}
func secretValueText(raw json.RawMessage) (string, error) {
if len(raw) == 0 {
return "", nil
}
var text string
if err := json.Unmarshal(raw, &text); err == nil {
return text, nil
}
var out bytes.Buffer
if err := json.Compact(&out, raw); err != nil {
return "", err
}
return out.String(), nil
}
var secretModeRE = regexp.MustCompile(`^0?[0-7]{1,3}$`)
type secretsState struct {
mu sync.Mutex
name string
log *slog.Logger
entries []SecretEntry
issuer string
audience string
subject string
verifier TokenVerifier
fetchedAt string
fetchedVia string
fetched chan struct{}
once sync.Once
unminted map[string]bool
}
func (s *secretsState) withholdUnminted(paths ...string) {
s.mu.Lock()
defer s.mu.Unlock()
for _, path := range paths {
if s.unminted == nil {
s.unminted = map[string]bool{}
}
s.unminted[path] = true
}
}
func (s *secretsState) minted(path string) bool {
if s == nil {
return false
}
s.mu.Lock()
defer s.mu.Unlock()
if !s.unminted[path] {
return false
}
delete(s.unminted, path)
return true
}
func (s *secretsState) servable(entries []SecretEntry) []SecretEntry {
if s == nil {
return entries
}
s.mu.Lock()
defer s.mu.Unlock()
return s.servableLocked(entries)
}
func (s *secretsState) servableLocked(entries []SecretEntry) []SecretEntry {
if len(s.unminted) == 0 {
return entries
}
out := make([]SecretEntry, 0, len(entries))
for _, entry := range entries {
if s.unminted[entry.Path] {
continue
}
out = append(out, entry)
}
return out
}
func newSecretsState(name string, log *slog.Logger) *secretsState {
if log == nil {
log = slog.New(slog.DiscardHandler)
}
return &secretsState{name: name, log: log, fetched: make(chan struct{})}
}
func (s *secretsState) install(issuer, audience, subject string, verifier TokenVerifier) {
s.mu.Lock()
s.issuer, s.audience, s.subject, s.verifier = issuer, audience, subject, verifier
s.mu.Unlock()
}
func (s *secretsState) addEntries(entries ...SecretEntry) {
s.mu.Lock()
for _, entry := range entries {
replaced := false
for i := range s.entries {
if s.entries[i].Path == entry.Path {
s.entries[i] = entry
replaced = true
break
}
}
if !replaced {
s.entries = append(s.entries, entry)
}
}
s.mu.Unlock()
}
func (s *secretsState) fetchedAtValue() string {
s.mu.Lock()
defer s.mu.Unlock()
return s.fetchedAt
}
func (s *secretsState) fetchedViaValue() string {
s.mu.Lock()
defer s.mu.Unlock()
return s.fetchedVia
}
func (s *secretsState) markFetched(now, via string) bool {
s.mu.Lock()
if s.fetchedAt != "" {
s.mu.Unlock()
return false
}
s.fetchedAt, s.fetchedVia = now, via
s.mu.Unlock()
s.once.Do(func() { close(s.fetched) })
return true
}
func (s *secretsState) fetch(ctx context.Context, authorization string) ([]SecretEntry, error) {
s.mu.Lock()
issuer, audience, subject, verifier := s.issuer, s.audience, s.subject, s.verifier
already := s.fetchedAt
s.mu.Unlock()
if verifier == nil || issuer == "" || audience == "" || subject == "" {
s.log.Warn("the secrets server is not ready", "contract", s.name)
return nil, &RequestError{Status: http.StatusServiceUnavailable, Code: "NotReady"}
}
token, ok := strings.CutPrefix(strings.TrimSpace(authorization), "Bearer ")
if !ok || strings.TrimSpace(token) == "" {
s.log.Warn("the guest's secrets request carries no bearer token", "contract", s.name, "err", "requester: no bearer token")
return nil, &RequestError{Status: http.StatusUnauthorized, Code: "AuthenticationRequired"}
}
claims, err := verifier.VerifyAudience(ctx, strings.TrimSpace(token), audience)
if err != nil {
s.log.Warn("the guest's secrets token is not accepted", "contract", s.name, "issuer", issuer, "err", err.Error())
return nil, &RequestError{Status: http.StatusUnauthorized, Code: "InvalidToken"}
}
if got, _ := claims[cloudinit.NodeJWTUserClaim].(string); got != subject {
s.log.Warn("the guest's secrets token names another subject", "contract", s.name, "subject", subject)
return nil, &RequestError{Status: http.StatusUnauthorized, Code: "InvalidToken"}
}
s.mu.Lock()
entries := s.servableLocked(append([]SecretEntry(nil), s.entries...))
s.mu.Unlock()
channel := secretsChannelOf(ctx)
if already == "" {
s.markFetched(time.Now().UTC().Format(time.RFC3339Nano), channel)
}
s.log.Info("requester_guest_secrets_fetched", "contract", s.name, "entries", len(entries), "channel", channel)
return entries, nil
}
func (q *Requester) Secrets(ctx context.Context, contract, authorization string) ([]SecretEntry, error) {
q.secretsMu.Lock()
state := q.secrets[contract]
q.secretsMu.Unlock()
if state == nil {
return nil, &RequestError{Status: http.StatusNotFound, Code: "NotFound"}
}
return state.fetch(ctx, authorization)
}
func (q *Requester) registerSecrets(name string, state *secretsState) {
q.secretsMu.Lock()
q.secrets[name] = state
q.secretsMu.Unlock()
}
func (q *Requester) unregisterSecrets(name string) {
q.secretsMu.Lock()
delete(q.secrets, name)
q.secretsMu.Unlock()
}
func (q *Requester) readSecretsBundle(ctx context.Context, ref commonv1.SecretRef) ([]SecretEntry, error) {
if q.deps.Vault == nil {
return nil, errors.New("requester: the contract names a secrets bundle and the component names no OpenBaoServer")
}
kv, err := q.deps.Vault(ctx, ref)
if err != nil {
return nil, retryable(err)
}
data, err := kv.Read(ctx, ref.Mount, ref.Path, 0)
if err != nil {
return nil, retryable(fmt.Errorf("requester: reading the secrets bundle %s/%s: %w", ref.Mount, ref.Path, err))
}
text, _ := data["bundle"].(string)
if text == "" {
return nil, fmt.Errorf("requester: the secrets bundle %s/%s carries no bundle", ref.Mount, ref.Path)
}
entries, err := ParseSecretsBundle(text)
if err != nil {
return nil, fmt.Errorf("requester: the secrets bundle %s/%s: %w", ref.Mount, ref.Path, err)
}
return entries, nil
}
func ParseSecretsBundle(text string) ([]SecretEntry, error) {
entries := []SecretEntry{}
if err := json.Unmarshal([]byte(text), &entries); err != nil {
return nil, errors.New("the bundle is not a JSON array of {path, value, mode}")
}
for i := range entries {
if err := CheckSecretEntry(entries[i].Path, entries[i].Mode); err != nil {
return nil, fmt.Errorf("entry %d: %w", i, err)
}
}
return entries, nil
}
func CheckSecretEntry(path, mode string) error {
if path == "" || path == "/" || !strings.HasPrefix(path, "/") || strings.ContainsFunc(path, secretPathControl) || filepath.Clean(path) != path {
return errors.New("the path is not a clean absolute path")
}
if mode != "" && !secretModeRE.MatchString(mode) {
return errors.New("the mode is not an octal string of at most 0777")
}
return nil
}
func secretPathControl(r rune) bool {
return r < 0x20 || r == 0x7f
}
func (q *Requester) ingressExposureURL(ctx context.Context) (string, error) {
name := "svc-" + strings.ToLower(KindRequester) + "-" + strings.TrimSpace(q.cfg.Name) + "-ingress"
if raw := q.deps.Inputs.AwaitAddress(ctx, name, DefaultExposureWait, nil); raw != "" {
return raw, nil
}
if err := ctx.Err(); err != nil {
return "", err
}
return "", retryable(fmt.Errorf("requester: the %s exposure reports no url", name))
}
func (q *Requester) guestIrohURL(ctx context.Context) string {
ref := q.cfg.Spec.GuestIrohExposureRef
if ref == nil || strings.TrimSpace(ref.Name) == "" {
return ""
}
raw := q.deps.Inputs.AwaitAddress(ctx, ref.Name, DefaultExposureWait, nil)
if raw == "" {
q.log.Warn("requester_guest_iroh_unavailable", "exposure", ref.Name)
}
return raw
}
func (q *Requester) issuerVerifier(issuer string) TokenVerifier {
issuer = strings.TrimRight(issuer, "/")
client := q.deps.HTTP
return q.deps.Guests.Verifier(issuer, func(ctx context.Context) ([]byte, error) {
req, err := http.NewRequestWithContext(ctx, http.MethodGet, issuer+"/.well-known/keys", nil)
if err != nil {
return nil, err
}
res, err := client.Do(req)
if err != nil {
return nil, err
}
defer res.Body.Close()
if res.StatusCode != http.StatusOK {
io.Copy(io.Discard, io.LimitReader(res.Body, 4096))
return nil, fmt.Errorf("requester: the bidder OIDC keys answered HTTP %d", res.StatusCode)
}
return io.ReadAll(io.LimitReader(res.Body, 1<<20))
})
}
var errSecretsNeedIngress = errors.New("secrets need the requester ingress (getSecrets) or secretsFallback: Sealed")
var errSecretsDirectOnly = errors.New("the requester has an inbound endpoint, so secrets go over getSecrets only and are never sealed into a record")
func secretsAudience(requesterDID string) string {
return "api://" + SecretsAPIAudience + "?actx=" + requesterDID
}
func secretsRouteOf(contract string) string {
return SecretsRoute + "/" + contract
}
func secretsRBACKey(contract string) string {
safe := strings.Map(func(r rune) rune {
switch {
case r >= 'a' && r <= 'z', r >= 'A' && r <= 'Z', r >= '0' && r <= '9':
return r
case r == '.', r == '_', r == '~', r == ':', r == '-':
return r
default:
return '-'
}
}, "node."+contract)
if len(safe) > 512 {
return safe[:512]
}
return safe
}
type bidConfig struct {
IssuerURI string
Actx string
}
func resolveBidConfig(ctx context.Context, reader market.RecordResolver, bidderDID string, record map[string]any) (bidConfig, error) {
raw, _ := record["config"].(map[string]any)
uri, _ := raw["uri"].(string)
cid, _ := raw["cid"].(string)
if uri == "" {
return bidConfig{}, errors.New("the winning bid carries no bid config reference")
}
if market.ATURIAuthority(uri) != bidderDID {
return bidConfig{}, fmt.Errorf("the winning bid's config record %s is not in the bidder %s's repo", uri, bidderDID)
}
resolved, err := reader.Resolve(ctx, market.RecordRef{URI: uri, CID: cid})
if err != nil {
return bidConfig{}, fmt.Errorf("reading the winning bid's config record: %w", err)
}
issuer, _ := resolved.Value["issuer_uri"].(string)
actx, _ := resolved.Value["actx"].(string)
if issuer == "" {
return bidConfig{}, errors.New("the winning bid's config record carries no issuer_uri")
}
return bidConfig{IssuerURI: issuer, Actx: actx}, nil
}
func (q *Requester) nodeGrant(bidderDID, requesterDID, role, cluster string, cfg bidConfig) (*v1alpha1.NodeClaimGrant, error) {
subject, err := q.deps.Guests.Subject(bidderDID, requesterDID, role)
if err != nil {
return nil, err
}
return &v1alpha1.NodeClaimGrant{
Issuer: cfg.IssuerURI,
Subject: subject,
Audience: cloudinit.NodeAudience(cluster, role),
Role: role,
}, nil
}
func nodeClaimDocument(cluster, node, issuer string) map[string]any {
return map[string]any{
"node": node,
"cluster": cluster,
"jwtMount": cloudinit.NodeJWTMount(issuer),
"role": node,
"audience": cloudinit.NodeAudience(cluster, node),
"kvMount": cloudinit.NodeKVMount,
"kvPath": node,
}
}
func nodeRBACRecord(role, issuer, subject, secretsAud, nodeAud string, nodeJoin bool) map[string]any {
roles := map[string]any{
role: map[string]any{
"role_name": role,
"definition": map[string]any{
"iss": issuer,
"aud": secretsAud,
"sub": subject,
"policies": []string{},
},
},
}
if nodeJoin {
nodeRole := role + "-node"
roles[nodeRole] = map[string]any{
"role_name": nodeRole,
"definition": map[string]any{
"iss": issuer,
"aud": nodeAud,
"sub": subject,
"policies": []string{},
},
}
}
return map[string]any{
"$type": FedproxyRBACNSID,
"roles": roles,
"policies": map[string]any{},
"createdAt": time.Now().UTC().Format(time.RFC3339),
}
}
func meshdPinOf(meshd *v1alpha1.ComputeContractMeshd) *cloudinit.MeshdPin {
if meshd == nil || meshd.DownloadBase == "" {
return nil
}
out := &cloudinit.MeshdPin{DownloadBase: meshd.DownloadBase, Sha256: map[string]string{}}
for _, pin := range meshd.Pins {
out.Sha256[pin.Arch] = pin.Sha256
}
return out
}
func nodeAgentPinFromJoin(join *v1alpha1.ComputeContractNodeJoin) *cloudinit.NodeAgentPin {
if join == nil || join.NodeAgent == nil || join.NodeAgent.DownloadBase == "" {
return nil
}
out := &cloudinit.NodeAgentPin{DownloadBase: join.NodeAgent.DownloadBase, Sha256: map[string]string{}}
for _, pin := range join.NodeAgent.Pins {
out.Sha256[pin.Arch] = pin.Sha256
}
return out
}
func contractAcceptPath(contract v1alpha1.ComputeContract) string {
if contract.Spec.NodeJoin != nil {
return cloudinit.NodeSecretsDir + "/accept.json"
}
return "/root/secrets/publicdomainrelay.com/market/accept.json"
}
func (r *contractRunner) ensureSecrets(ctx context.Context, contract v1alpha1.ComputeContract) error {
if contract.Spec.SecretsRef == nil || r.secrets != nil {
return nil
}
inbound, sealed := r.q.cfg.InboundXRPC(), r.q.cfg.SealedSecrets()
if !inbound && !sealed {
return errSecretsNeedIngress
}
entries, err := r.q.readSecretsBundle(ctx, *contract.Spec.SecretsRef)
if err != nil {
return err
}
state := newSecretsState(r.name, r.q.log)
state.addEntries(entries...)
if envFile, err := agentEnvFile(contract); err == nil && envFile != "" && !agentPeerReady(entries, envFile) {
state.withholdUnminted(envFile, cloudinit.AgentIrohKeyFile)
}
if contract.Spec.NodeJoin == nil {
if err := r.installResumedVerifier(ctx, contract, state); err != nil {
return err
}
}
url, iroh := "", ""
if inbound {
if url, err = r.q.ingressExposureURL(ctx); err != nil {
return err
}
iroh = r.q.guestIrohURL(ctx)
r.q.registerSecrets(r.name, state)
}
r.mu.Lock()
r.secrets = state
r.secretsURL = url
r.secretsIrohURL = iroh
r.mu.Unlock()
if grant := contract.Status.Grant; grant != nil && contract.Spec.NodeJoin != nil {
audience := secretsAudience(r.q.callbackDID())
state.install(grant.Issuer, audience, grant.Subject, r.q.issuerVerifier(grant.Issuer))
doc, err := json.Marshal(nodeClaimDocument(contract.Spec.NodeJoin.ClusterRef.Name, grant.Role, grant.Issuer))
if err != nil {
return err
}
state.addEntries(SecretEntry{Path: cloudinit.NodeClaimDocPath, Value: string(doc) + "\n"})
record := nodeRBACRecord(grant.Role, grant.Issuer, grant.Subject, audience, grant.Audience, true)
key := r.rbacKeyOf(contract.Status.Contract)
if key == "" {
return nil
}
if err := r.putRBAC(ctx, key, record); err != nil {
return fmt.Errorf("requester: rewriting the contract's RBAC record: %w", err)
}
}
return nil
}
func transientOnly(err error) error {
if netretry.Transient(err) || isRetryable(err) || errors.Is(err, identity.ErrDIDResolutionFailed) {
return retryable(err)
}
return err
}
func (r *contractRunner) installResumedVerifier(ctx context.Context, contract v1alpha1.ComputeContract, state *secretsState) error {
st := contract.Status.Contract
if st == nil || st.Accept == nil || st.Bid == nil || st.Bid.URI == "" || winnerDID(st) == "" {
return nil
}
reader := market.NewHTTPReader(r.q.deps.Directory)
reader.Client = r.q.deps.HTTP
bid, err := reader.Resolve(ctx, market.RecordRef{URI: st.Bid.URI, CID: st.Bid.CID})
if err != nil {
return transientOnly(fmt.Errorf("requester: the guest token verifier of a resumed contract: reading the winning bid: %w", err))
}
cfg, err := resolveBidConfig(ctx, reader, winnerDID(st), bid.Value)
if err != nil {
return transientOnly(fmt.Errorf("requester: the guest token verifier of a resumed contract: %w", err))
}
subject, err := r.q.deps.Guests.Subject(winnerDID(st), r.q.callbackDID(), cmp.Or(st.VMName, contract.Spec.VMName))
if err != nil {
return fmt.Errorf("requester: the guest token verifier of a resumed contract: %w", err)
}
state.install(cfg.IssuerURI, secretsAudience(r.q.callbackDID()), subject, r.q.issuerVerifier(cfg.IssuerURI))
r.log().Info("requester_guest_secrets_resumed", "contract", r.name)
return nil
}
func (r *contractRunner) rbacKeyOf(state *v1alpha1.NodeClaimContract) string {
switch {
case state == nil:
return ""
case state.Accept != nil && state.Accept.URI != "":
return market.RBACRKeyOfAccept(state.Accept.URI)
case state.RFP != nil && state.RFP.URI != "" && state.Bid != nil && state.Bid.URI != "":
return market.RBACRKey(acceptRKeyFor(r.q.repoDID, r.name, state.RFP.URI, state.RFP.CID, state.Bid.URI, state.Bid.CID))
}
return ""
}
func acceptRKeyFor(repoDID, contract, rfpURI, rfpCID, bidURI, bidCID string) string {
return sessionRKey("accept", repoDID, contract, rfpURI, rfpCID, bidURI, bidCID)
}
func (r *contractRunner) putRBAC(ctx context.Context, key string, record map[string]any) error {
_, err := r.putSetupRecordAt(ctx, "putRBAC", FedproxyRBACNSID, key, record)
if settled, ok := errors.AsType[retryableError](err); ok {
return settled.error
}
if err != nil {
return err
}
r.mu.Lock()
r.rbacRKey = key
r.mu.Unlock()
r.deleteLegacyRBAC(ctx)
return nil
}
func (r *contractRunner) deleteLegacyRBAC(ctx context.Context) {
key := secretsRBACKey(r.name)
if _, err := r.q.repo.GetRecord(ctx, r.q.repoDID, FedproxyRBACNSID, key); err != nil {
if !rbacGone(err) {
r.log().Warn("requester_rbac_legacy_unread", "rkey", key, "err", err)
}
return
}
if err := r.q.repo.DeleteRecord(ctx, r.q.repoDID, FedproxyRBACNSID, key); err != nil && !rbacGone(err) {
r.log().Warn("requester_rbac_delete_failed", "rkey", key, "err", err)
}
}
func (r *contractRunner) contractModules(userData string, contract v1alpha1.ComputeContract) (string, error) {
modules := []any{}
values := cloudinit.Context{}
if contract.Spec.NodeJoin != nil {
opts := cloudinit.K3sJoinOptions{Meshd: meshdPinOf(contract.Spec.NodeJoin.Meshd),
NodeAgent: nodeAgentPinFromJoin(contract.Spec.NodeJoin)}
modules = append(modules, "k3s", cloudinit.K3sJoinModule(opts))
}
if len(contract.Spec.Tunnels) > 0 {
opts, err := tunnelsOptions(contract)
if err != nil {
return "", fmt.Errorf("the contract's tunnels: %w", err)
}
modules = append(modules, cloudinit.TunnelsModule(opts))
}
envFile, err := agentEnvFile(contract)
if err != nil {
return "", fmt.Errorf("the contract's agent: %w", err)
}
if envFile != "" {
agentPLC, _ := guestNetworkOf(r.q.cfg.Spec.Network)
modules = append(modules, cloudinit.AgentModule(cloudinit.AgentOptions{EnvFile: envFile, PLC: agentPLC}))
}
if a := contract.Spec.Association; a != nil && a.FromGuest == (strings.TrimSpace(a.Subject) != "") {
return "", errors.New("spec.association takes exactly one of a subject or fromGuest")
}
if fromGuest(contract) {
if contract.Spec.SecretsRef == nil {
return "", errors.New("spec.association.fromGuest needs spec.secretsRef: the association ref reaches the guest in the secrets bundle")
}
refFile, err := associationRefFile(contract)
if err != nil {
return "", err
}
guestPLC, guestIngress := guestNetworkOf(r.q.cfg.Spec.Network)
modules = append(modules, cloudinit.AssociationModule(refFile, guestPLC, guestIngress))
}
if len(contract.Spec.GuestTools) > 0 {
modules = append(modules, cloudinit.GuestToolsModule(contract.Spec.GuestTools))
}
if r.secrets != nil {
inbound := r.q.cfg.InboundXRPC()
if inbound {
modules = append(modules, "secrets")
values.SecretsURL = r.secretsURLValue()
values.SecretsRoute = secretsRouteOf(r.name)
values.SecretsAud = secretsAudience(r.q.callbackDID())
values.SecretsAcceptPath = contractAcceptPath(contract)
peer := cloudinit.GuestRequester{Iroh: r.secretsIrohURLValue()}
if r.q.guestWebRTC() {
peer.WebRTC = tunnel.ID(r.q.repoDID)
}
if peer.Iroh != "" || peer.WebRTC != "" {
modules = append(modules, cloudinit.GuestRequesterModule(peer))
}
}
if r.q.cfg.SealedSecrets() {
modules = append(modules, cloudinit.GuestSecretsModule())
}
}
if len(modules) == 0 {
return userData, nil
}
return cloudinit.BuildUserData(cloudinit.BuildOptions{Base: userData, Modules: modules, Ctx: values})
}
func (r *contractRunner) prepareWorkloadGrant(ctx context.Context, state *v1alpha1.NodeClaimContract, winner *BidRecord, acceptRKey string) error {
if winner == nil || (r.nodeJoin == nil && r.secrets == nil) {
return nil
}
reader := market.NewHTTPReader(r.q.deps.Directory)
reader.Client = r.q.deps.HTTP
var cfg bidConfig
err := r.untilSettled(ctx, "readBidConfig", func() error {
var readErr error
cfg, readErr = resolveBidConfig(ctx, reader, winner.DID, winner.Record)
return transientRetryable(readErr)
})
if err != nil {
return err
}
vmName := state.VMName
if vmName == "" {
vmName = r.snapshot().Spec.VMName
}
subject := ""
if r.nodeJoin != nil {
grant, err := r.q.nodeGrant(winner.DID, r.q.callbackDID(), vmName, r.nodeJoin.ClusterRef.Name, cfg)
if err != nil {
return err
}
r.mu.Lock()
r.grant = grant
r.mu.Unlock()
subject = grant.Subject
} else {
subject, err = r.q.deps.Guests.Subject(winner.DID, r.q.callbackDID(), vmName)
if err != nil {
return err
}
}
if r.secrets == nil {
return nil
}
audience := secretsAudience(r.q.callbackDID())
r.secrets.install(cfg.IssuerURI, audience, subject, r.q.issuerVerifier(cfg.IssuerURI))
if r.nodeJoin != nil {
doc, err := json.Marshal(nodeClaimDocument(r.nodeJoin.ClusterRef.Name, vmName, cfg.IssuerURI))
if err != nil {
return err
}
r.secrets.addEntries(SecretEntry{Path: cloudinit.NodeClaimDocPath, Value: string(doc) + "\n"})
}
nodeAud := ""
if r.nodeJoin != nil {
nodeAud = cloudinit.NodeAudience(r.nodeJoin.ClusterRef.Name, vmName)
}
record := nodeRBACRecord(vmName, cfg.IssuerURI, subject, audience, nodeAud, r.nodeJoin != nil)
if err := r.putRBAC(ctx, market.RBACRKey(acceptRKey), record); err != nil {
return fmt.Errorf("requester: writing the contract's RBAC record: %w", err)
}
return nil
}
func (r *contractRunner) cleanup() {
r.mu.Lock()
secrets := r.secrets
r.mu.Unlock()
if secrets != nil {
r.q.unregisterSecrets(r.name)
}
r.q.forgetGuestWebRTC(r.name)
}
func (r *contractRunner) deleteRBAC(ctx context.Context) {
r.mu.Lock()
held := r.rbacRKey
r.mu.Unlock()
if r.q.repo == nil || (held == "" && r.snapshot().Spec.SecretsRef == nil) {
return
}
deleteCtx, cancel := context.WithTimeout(ctx, 10*time.Second)
defer cancel()
keys := []string{held}
if key := r.rbacKeyOf(r.stateCopy()); key != held {
keys = append(keys, key)
}
for _, key := range keys {
if key == "" {
continue
}
if err := r.q.repo.DeleteRecord(deleteCtx, r.q.repoDID, FedproxyRBACNSID, key); err != nil && !rbacGone(err) {
r.log().Warn("requester_rbac_delete_failed", "rkey", key, "err", err)
}
}
r.deleteLegacyRBAC(deleteCtx)
r.mu.Lock()
r.rbacRKey = ""
r.mu.Unlock()
}
func rbacGone(err error) bool {
return errors.Is(err, market.ErrNotFound) || strings.Contains(err.Error(), "not found")
}
func (r *contractRunner) secretsFetched() string {
r.mu.Lock()
defer r.mu.Unlock()
return r.secretsFetchedAt
}
func (r *contractRunner) setSecretsFetched(at, via string) {
if at == "" {
return
}
r.mu.Lock()
r.secretsFetchedAt, r.secretsFetchedVia = at, via
r.mu.Unlock()
}
func (r *contractRunner) secretsFetchedViaValue() string {
r.mu.Lock()
defer r.mu.Unlock()
return r.secretsFetchedVia
}
func secretsFetchedReason(via string) string {
switch via {
case SecretsChannelIroh:
return "GetSecretsIroh"
case SecretsChannelWebRTC:
return "GetSecretsWebRTC"
case SecretsChannelHTTPS:
return "GetSecretsHTTPS"
}
return "GetSecrets"
}
func (r *contractRunner) secretsIrohURLValue() string {
r.mu.Lock()
defer r.mu.Unlock()
return r.secretsIrohURL
}
func (r *contractRunner) secretsURLValue() string {
r.mu.Lock()
defer r.mu.Unlock()
return r.secretsURL
}
func (r *contractRunner) grantValue() *v1alpha1.NodeClaimGrant {
r.mu.Lock()
defer r.mu.Unlock()
if r.grant == nil {
return nil
}
grant := *r.grant
return &grant
}
// guestNetworkOf: the PLC and the ingress a guest of this requester uses, the requester's own (a network guest's
// requester serves its guests the network it is on, plan 0050); a *.localhost network names a separate guest PLC (its
// direct address is loopback); outside a network, none (plc.directory and the public ingress)
func guestNetworkOf(n *v1alpha1.MarketNetworkValue) (plc, ingress string) {
if n == nil {
return "", ""
}
plc = strings.TrimRight(strings.TrimSpace(n.PLCDirectoryURL), "/")
if plc == "" || plc == v1alpha1.PublicPLCDirectoryURL {
return "", ""
}
if g := strings.TrimSpace(n.GuestPLCDirectoryURL); g != "" {
plc = g
}
if host, _, err := net.SplitHostPort(n.IngressProxyHost); err == nil {
ingress = host
} else {
ingress = strings.TrimSpace(n.IngressProxyHost)
}
return plc, ingress
}