0
0
package requester
import (
"cmp"
"context"
"crypto/sha256"
"encoding/hex"
"encoding/json"
"errors"
"fmt"
"os"
"regexp"
"slices"
"strings"
"sync"
"time"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"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"
contractmarket "github.com/johnandersen777/socialweb-computer-kcp/internal/contract/market"
"github.com/johnandersen777/socialweb-computer-kcp/internal/kit/supervise"
"github.com/johnandersen777/socialweb-computer-kcp/internal/market/participant"
"github.com/johnandersen777/socialweb-computer-kcp/internal/sshtransport"
)
const (
heldContractTTLSeconds = 691200
transientContractTTLSeconds = 3600
)
var vmNamePattern = regexp.MustCompile(`^[A-Za-z0-9][A-Za-z0-9._-]*$`)
var localeNames = map[string]bool{
"LC_ALL": true,
"LC_CTYPE": true,
"LC_NUMERIC": true,
"LC_TIME": true,
"LC_COLLATE": true,
"LC_MONETARY": true,
"LC_MESSAGES": true,
"LC_PAPER": true,
"LC_NAME": true,
"LC_ADDRESS": true,
"LC_TELEPHONE": true,
"LC_MEASUREMENT": true,
"LC_IDENTIFICATION": true,
}
type SessionTarget struct {
VMName string
Address string
HostKeys sshtransport.GuestHostKeys
}
func (q *Requester) RunCommand(ctx context.Context, account sshtransport.AuthorizedAccount, command string, env map[string]string, io sshtransport.CommandIO) error {
if io == nil {
return errors.New("requester: the session has no command io")
}
if strings.TrimSpace(account.DID) != q.repoDID {
return commandFailed(io, "provisioning failed: ", fmt.Errorf("this requester rents only for %s, not for %s", q.repoDID, account.DID))
}
lc := lcEnv(env)
atirc := sessionWantsAtirc(command, lc)
delete(lc, SessionAtircEnv)
delete(lc, sessionAtircTokenEnv)
if name := strings.TrimSpace(lc["LC_SESSION"]); name != "" {
return q.runHeldCommand(ctx, account, name, command, lc, atirc, io)
}
return q.runTransientCommand(ctx, account, command, lc, atirc, io)
}
func commandFailed(io sshtransport.CommandIO, prefix string, err error) error {
io.WriteErr([]byte(prefix + err.Error() + "\n"))
io.Exit(1)
return err
}
func (q *Requester) sessionPolicy(lc map[string]string) (string, map[string]string, error) {
policyName := strings.TrimSpace(lc["LC_POLICY"])
switch strings.ToLower(policyName) {
case "none", "off":
return "", nil, fmt.Errorf("LC_POLICY %q: a policy always runs; name one, or open", policyName)
}
policyName = cmp.Or(policyName, q.cfg.PolicyWorkflow, DefaultPolicyWorkflow)
policyArgs := map[string]string{}
if raw := strings.TrimSpace(lc["LC_POLICY_ARGS"]); raw != "" {
parsed, err := participant.ParsePolicyArgs(raw)
if err != nil {
return "", nil, fmt.Errorf("LC_POLICY_ARGS: %w", err)
}
policyArgs = parsed
}
return policyName, policyArgs, nil
}
func (q *Requester) sessionVMName(lc map[string]string) (string, error) {
vmName := strings.TrimSpace(lc["LC_VM_NAME"])
if vmName == "" {
vmName = q.generatedVMName()
}
if len(vmName) > 63 || !vmNamePattern.MatchString(vmName) {
return "", fmt.Errorf("LC_VM_NAME %q is not a DNS-label-shaped name", vmName)
}
return vmName, nil
}
func (q *Requester) guestDialer() sshtransport.Dialer {
if socket := strings.TrimSpace(q.cfg.Spec.IrohSocket); socket != "" {
return sshtransport.UnixSocketDialer{Socket: socket, Log: q.log}
}
return sshtransport.DumbpipeDialer{Path: "dumbpipe", Log: q.log}
}
func (q *Requester) runTransientCommand(ctx context.Context, account sshtransport.AuthorizedAccount, command string, lc map[string]string, atirc bool, io sshtransport.CommandIO) error {
policyName, policyArgs, err := q.sessionPolicy(lc)
if err != nil {
return commandFailed(io, "provisioning failed: ", err)
}
vmName, err := q.sessionVMName(lc)
if err != nil {
return commandFailed(io, "provisioning failed: ", err)
}
sessionCtx, cancel := context.WithTimeout(ctx, q.cfg.SessionCap)
defer cancel()
ctx = sessionCtx
contractName := transientContractName(account.DID, vmName)
defer q.trackTransient(contractName, cancel)()
publicKey, privateKeyPath, err := sshtransport.GenerateGuestKeypair(q.guestKeyDir(), vmName)
if err != nil {
return commandFailed(io, "provisioning failed: ", err)
}
defer sshtransport.RemoveGuestKeypair(privateKeyPath)
agent := ""
if sub, ok := sessionAgentRun(command); ok && atirc {
if agent, err = agentSubhandle(sub, q.handle); err != nil {
return commandFailed(io, "atirc agent run: ", err)
}
}
userData := ""
if atirc {
if userData, err = sessionAtircUserData(defaultUserData([]string{publicKey})); err != nil {
return commandFailed(io, "provisioning failed: ", fmt.Errorf("the guest atirc agent: %w", err))
}
}
keep := truthy(lc["LC_KEEP_VM"])
var labels map[string]string
if keep {
labels = map[string]string{keepVMLabel: "true"}
}
target, err := q.provisionHeldContract(ctx, contractName, vmName, account.DID, publicKey, policyName, policyArgs, userData, transientContractTTLSeconds, labels)
if err != nil {
q.releaseHeldContract(contractName)
return commandFailed(io, "provisioning failed: ", err)
}
if !keep {
defer q.releaseHeldContract(contractName)
}
ticket, err := ValidateTicket(target.Address)
if err != nil {
return commandFailed(io, "guest session failed: ", err)
}
provider, err := sshtransport.NewGuestSessionProvider(q.guestDialer(), q.log)
if err != nil {
return commandFailed(io, "guest session failed: ", err)
}
if !provider.PollReady(ctx, privateKeyPath, ticket, DefaultVMReadyTimeout, target.HostKeys) {
return commandFailed(io, "guest session failed: ", errors.New("the guest ssh did not answer"))
}
minted, err := q.sessionAtirc(ctx, account, atirc, agent, q.contractState(contractName), io)
if err != nil {
io.Exit(1)
return err
}
defer q.revokeSessionAtirc(ctx, minted)
switch {
case minted != nil && agent != "":
command = atircCommand(sessionAgentCommand)
case minted != nil:
command = atircCommand(command)
}
code := provider.RunSessionEnv(ctx, privateKeyPath, ticket, renderExecCommand(command, lc), minted.env(), io, target.HostKeys)
io.Exit(code)
return nil
}
type heldSession struct {
mu sync.Mutex
name string
vmName string
privateKeyPath string
contract string
target *SessionTarget
atirc bool
timer *time.Timer
generation uint64
}
func (h *heldSession) stopTimer() {
if h.timer != nil {
h.timer.Stop()
h.timer = nil
}
h.generation++
}
func (h *heldSession) clear() {
h.name = ""
h.target = nil
h.privateKeyPath = ""
h.contract = ""
h.atirc = false
}
func (q *Requester) heldSession(key string) *heldSession {
q.heldMu.Lock()
defer q.heldMu.Unlock()
held := q.heldSessions[key]
if held == nil {
held = &heldSession{}
q.heldSessions[key] = held
}
return held
}
func (q *Requester) armHeldSession(key string, held *heldSession) {
q.armHeldSessionFor(key, held, q.cfg.SessionIdle)
held.mu.Lock()
contract, name, keyPath := held.contract, held.name, held.privateKeyPath
held.mu.Unlock()
if contract != "" {
q.recordHeld(contract, name, keyPath, q.cfg.SessionIdle)
}
}
func (q *Requester) armHeldSessionFor(key string, held *heldSession, after time.Duration) {
held.mu.Lock()
if held.timer != nil {
held.timer.Stop()
}
held.generation++
generation := held.generation
held.timer = time.AfterFunc(after, func() {
q.releaseHeldSession(key, held, generation, "idle")
})
held.mu.Unlock()
}
func (q *Requester) recordHeld(contract, name, keyPath string, after time.Duration) {
ctx, cancel := context.WithTimeout(context.WithoutCancel(q.runContext()), heldRecordTimeout)
defer cancel()
record := &v1alpha1.ComputeContractHeldSession{Name: name, GuestKeyPath: keyPath, Until: q.now().Add(after).UTC().Format(time.RFC3339)}
if err := q.deps.Intents.MergeComputeContractStatus(ctx, contract, v1alpha1.ComputeContractStatus{HeldSession: record}); err != nil {
q.log.Warn("requester_held_session_expiry_unrecorded", "contract", contract, "until", record.Until, "err", err)
}
}
func (q *Requester) keepHeldSessions(reason string) {
q.heldMu.Lock()
held := make([]*heldSession, 0, len(q.heldSessions))
for _, session := range q.heldSessions {
held = append(held, session)
}
q.heldMu.Unlock()
for _, session := range held {
session.mu.Lock()
session.stopTimer()
contract := session.contract
session.mu.Unlock()
if contract != "" {
q.log.Info("requester_held_session_kept", "contract", contract, "reason", reason)
}
}
}
func isHeldContractName(name string) bool {
rest, ok := strings.CutPrefix(name, heldContractPrefix)
if !ok || len(rest) != 20 || strings.HasPrefix(name, transientContractPrefix) {
return false
}
_, err := hex.DecodeString(rest)
return err == nil
}
func (q *Requester) sweepHeldContract(contract v1alpha1.ComputeContract) {
record := contract.Status.HeldSession
if record == nil {
record = &v1alpha1.ComputeContractHeldSession{}
}
until, err := time.Parse(time.RFC3339, record.Until)
name, keyPath := record.Name, record.GuestKeyPath
reason := ""
switch {
case err != nil:
reason = "the held session records no expiry"
case !q.now().Before(until):
reason = "the held session expired at " + until.UTC().Format(time.RFC3339)
case name == "" || keyPath == "":
reason = "the held session records no session name or guest key"
}
var target *SessionTarget
if reason == "" {
found, ready, terr := contractTarget(contract)
switch {
case terr != nil || !ready:
reason = "the held session has no guest address and host keys"
case !strings.HasPrefix(keyPath, q.guestKeyDir()+string(os.PathSeparator)):
reason = "the held session's guest key is outside the guest key dir"
default:
if _, serr := os.Stat(keyPath); serr != nil {
reason = "the held session's guest key is gone"
}
target = found
}
}
if reason != "" {
q.log.Info("requester_stale_session_release", "contract", contract.Name, "phase", contract.Status.Phase, "reason", reason)
q.releaseHeldContract(contract.Name)
if keyPath != "" && strings.HasPrefix(keyPath, q.guestKeyDir()+string(os.PathSeparator)) {
_ = sshtransport.RemoveGuestKeypair(keyPath)
}
return
}
key := strings.TrimSpace(contract.Spec.OwnerDid) + "\x00" + name
held := q.heldSession(key)
held.mu.Lock()
if held.target != nil {
held.mu.Unlock()
return
}
held.name, held.vmName, held.privateKeyPath, held.target, held.contract = name, target.VMName, keyPath, target, contract.Name
held.atirc = strings.Contains(contract.Spec.UserData, cloudinit.AgentExecPath)
held.mu.Unlock()
q.armHeldSessionFor(key, held, until.Sub(q.now()))
q.log.Info("requester_held_session_adopted", "contract", contract.Name, "until", until.UTC().Format(time.RFC3339))
}
func (q *Requester) releaseHeldSession(key string, held *heldSession, generation uint64, reason string) {
held.mu.Lock()
if generation != 0 && generation != held.generation {
held.mu.Unlock()
return
}
if held.timer != nil {
held.timer.Stop()
held.timer = nil
}
held.generation++
q.heldMu.Lock()
if q.heldSessions[key] == held {
delete(q.heldSessions, key)
}
q.heldMu.Unlock()
privateKeyPath := held.privateKeyPath
contract := held.contract
held.clear()
held.mu.Unlock()
if contract != "" {
q.releaseHeldContract(contract)
q.log.Info("requester_held_session_released", "contract", contract, "reason", reason)
}
_ = sshtransport.RemoveGuestKeypair(privateKeyPath)
}
func (q *Requester) runHeldCommand(ctx context.Context, account sshtransport.AuthorizedAccount, name, command string, lc map[string]string, atirc bool,
io sshtransport.CommandIO) error {
policyName, policyArgs, err := q.sessionPolicy(lc)
if err != nil {
return commandFailed(io, "provisioning failed: ", err)
}
vmName, err := q.sessionVMName(lc)
if err != nil {
return commandFailed(io, "provisioning failed: ", err)
}
sessionCtx, cancel := context.WithTimeout(ctx, q.cfg.SessionCap)
defer cancel()
ctx = sessionCtx
provider, err := sshtransport.NewGuestSessionProvider(q.guestDialer(), q.log)
if err != nil {
return commandFailed(io, "guest session failed: ", err)
}
agent := ""
if sub, ok := sessionAgentRun(command); ok && atirc {
if agent, err = agentSubhandle(sub, q.handle); err != nil {
return commandFailed(io, "atirc agent run: ", err)
}
}
contractName := heldContractName(account.DID, name)
provision := func() (*SessionTarget, string, error) {
publicKey, privateKeyPath, err := sshtransport.GenerateGuestKeypair(q.guestKeyDir(), vmName)
if err != nil {
return nil, "", err
}
userData := ""
if atirc {
if userData, err = sessionAtircUserData(defaultUserData([]string{publicKey})); err != nil {
_ = sshtransport.RemoveGuestKeypair(privateKeyPath)
return nil, "", fmt.Errorf("the guest atirc agent: %w", err)
}
}
target, err := q.provisionHeldContract(ctx, contractName, vmName, account.DID, publicKey, policyName, policyArgs, userData, heldContractTTLSeconds, nil)
if err != nil {
q.releaseHeldContract(contractName)
_ = sshtransport.RemoveGuestKeypair(privateKeyPath)
return nil, "", err
}
return target, privateKeyPath, nil
}
key := account.DID + "\x00" + name
held := q.heldSession(key)
var reused bool
var target *SessionTarget
var privateKeyPath, contract string
for {
held.mu.Lock()
held.stopTimer()
reused = held.target != nil
target, privateKeyPath, contract = held.target, held.privateKeyPath, held.contract
if !reused {
break
}
held.mu.Unlock()
policyCtx, policyCancel := context.WithTimeout(ctx, HeldSessionPolicyTimeout)
err := q.heldSessionAllowed(policyCtx, contract, policyName)
policyCancel()
held.mu.Lock()
if held.target != target || held.contract != contract {
held.mu.Unlock()
held = q.heldSession(key)
continue
}
held.stopTimer()
if err == nil {
break
}
q.log.Info("requester_held_session_policy_denied", "contract", contract, "err", err)
if errors.Is(err, ErrPolicyRejected) {
held.clear()
q.releaseHeldSessionTarget(contract, privateKeyPath)
}
held.mu.Unlock()
return commandFailed(io, "policy denied: ", err)
}
fresh := target == nil
if target == nil {
target, privateKeyPath, err = provision()
if err != nil {
held.mu.Unlock()
return commandFailed(io, "provisioning failed: ", err)
}
contract = contractName
held.name, held.vmName, held.privateKeyPath, held.target, held.contract = name, vmName, privateKeyPath, target, contract
held.atirc = atirc
}
ready := false
if ticket, ticketErr := ValidateTicket(target.Address); ticketErr == nil {
ready = provider.PollReady(ctx, privateKeyPath, ticket, DefaultVMReadyTimeout, target.HostKeys)
}
if !ready && reused {
q.log.Warn("requester_held_session_lost", "contract", contract)
held.clear()
q.releaseHeldSessionTarget(contract, privateKeyPath)
target, privateKeyPath, err = provision()
if err != nil {
held.mu.Unlock()
return commandFailed(io, "provisioning failed: ", err)
}
contract = contractName
held.name, held.vmName, held.privateKeyPath, held.target, held.contract = name, vmName, privateKeyPath, target, contract
held.atirc = atirc
fresh = true
ticket, ticketErr := ValidateTicket(target.Address)
if ticketErr != nil {
held.mu.Unlock()
return commandFailed(io, "guest session failed: ", ticketErr)
}
ready = provider.PollReady(ctx, privateKeyPath, ticket, DefaultVMReadyTimeout, target.HostKeys)
}
if !ready {
if fresh {
held.clear()
q.releaseHeldSessionTarget(contract, privateKeyPath)
}
held.mu.Unlock()
return commandFailed(io, "guest session failed: ", errors.New("the guest ssh did not answer"))
}
ticket, err := ValidateTicket(target.Address)
if err != nil {
if fresh {
held.clear()
q.releaseHeldSessionTarget(contract, privateKeyPath)
}
held.mu.Unlock()
return commandFailed(io, "guest session failed: ", err)
}
if atirc && !held.atirc {
held.mu.Unlock()
q.armHeldSession(key, held)
return commandFailed(io, "atirc: ", fmt.Errorf("the held session %s runs a VM started without atirc; start another LC_SESSION with LC_ATIRC=1 (or an atirc command) to get one", name))
}
q.recordHeld(contract, name, privateKeyPath, q.cfg.SessionCap+q.cfg.SessionIdle)
minted, err := q.sessionAtirc(ctx, account, atirc, agent, q.contractState(contract), io)
if err != nil {
held.mu.Unlock()
q.armHeldSession(key, held)
io.Exit(1)
return err
}
switch {
case minted != nil && agent != "":
command = atircCommand(sessionAgentCommand)
case minted != nil:
command = atircCommand(command)
}
code := func() int {
defer held.mu.Unlock()
defer q.revokeSessionAtirc(ctx, minted)
return provider.RunSessionEnv(ctx, privateKeyPath, ticket, renderExecCommand(command, lc), minted.env(), io, target.HostKeys)
}()
q.armHeldSession(key, held)
io.Exit(code)
return nil
}
func transientContractName(did, vmName string) string {
sum := sha256.Sum256([]byte(did + "\x00" + vmName))
return transientContractPrefix + hex.EncodeToString(sum[:10])
}
func (q *Requester) trackTransient(name string, cancel context.CancelFunc) func() {
q.transientMu.Lock()
if q.transient == nil {
q.transient = map[string]context.CancelFunc{}
}
q.transient[name] = cancel
q.transientWG.Add(1)
q.transientMu.Unlock()
return func() {
q.transientMu.Lock()
delete(q.transient, name)
q.transientMu.Unlock()
q.transientWG.Done()
}
}
func (q *Requester) transientLive(name string) bool {
q.transientMu.Lock()
defer q.transientMu.Unlock()
_, ok := q.transient[name]
return ok
}
func (q *Requester) endTransientSessions(ctx context.Context, reason string) {
q.transientMu.Lock()
cancels := make([]context.CancelFunc, 0, len(q.transient))
for _, cancel := range q.transient {
cancels = append(cancels, cancel)
}
q.transientMu.Unlock()
if len(cancels) == 0 {
return
}
q.log.Info("requester_transient_sessions_ended", "sessions", len(cancels), "reason", reason)
for _, cancel := range cancels {
cancel()
}
_ = supervise.Join(ctx, q.transientWG.Wait)
}
func (q *Requester) releaseStaleTransient() {
started := q.startedAt.Load()
for _, contract := range q.contracts.List() {
switch {
case !q.ownsContract(contract),
contract.DeletionTimestamp != nil, contract.Spec.Release, contract.Labels[keepVMLabel] == "true",
contract.Status.Phase == v1alpha1.ComputeContractReleased, contract.Status.Phase == v1alpha1.ComputeContractFailed,
started != nil && !contract.CreationTimestamp.Time.Before(*started):
continue
case isHeldContractName(contract.Name):
q.sweepHeldContract(contract)
continue
case !strings.HasPrefix(contract.Name, transientContractPrefix), q.transientLive(contract.Name):
continue
}
q.log.Info("requester_stale_session_release", "contract", contract.Name, "phase", contract.Status.Phase,
"reason", "no live ssh session holds this transient contract after a requester start")
q.releaseHeldContract(contract.Name)
}
}
func (q *Requester) contractState(name string) *v1alpha1.NodeClaimContract {
contract, ok := q.contracts.Get(name)
if !ok {
return nil
}
return contract.Status.Contract
}
func heldContractName(did, name string) string {
sum := sha256.Sum256([]byte(did + "\x00" + name))
return heldContractPrefix + hex.EncodeToString(sum[:10])
}
func sessionRKey(label string, parts ...string) string {
return market.SessionRKey(label, parts...)
}
func (q *Requester) existingSignedRecord(ctx context.Context, collection, rkey string) (market.SignedRecord, bool, error) {
record, err := q.repo.GetRecord(ctx, q.repoDID, collection, rkey)
if err != nil {
if errors.Is(err, market.ErrNotFound) {
return market.SignedRecord{}, false, nil
}
return market.SignedRecord{}, false, err
}
return market.SignedRecord{URI: record.URI, CID: record.CID, Record: record.Value}, true, nil
}
func contractTarget(contract v1alpha1.ComputeContract) (*SessionTarget, bool, error) {
state := contract.Status.Contract
if state == nil || state.VMAddress == "" || state.HostKeys == nil || len(state.HostKeys.Keys) == 0 ||
state.Receipt == nil || state.Receipt.URI == "" {
return nil, false, nil
}
ticket, err := ValidateTicket(state.VMAddress)
if err != nil {
return nil, false, err
}
keys := make([]string, 0, len(state.HostKeys.Keys))
for _, key := range state.HostKeys.Keys {
keys = append(keys, key.Type+" "+key.PublicKey)
}
return &SessionTarget{
VMName: state.VMName,
Address: ticket,
HostKeys: sshtransport.GuestHostKeys{Alias: hostKeyAlias(state.Receipt.URI), Keys: keys},
}, true, nil
}
func (q *Requester) awaitContractChange(ctx context.Context) error {
calls := 0
return q.contracts.Await(ctx, func() bool {
calls++
return calls > 1
})
}
func (q *Requester) heldSessionAllowed(ctx context.Context, contract, policyName string) error {
held, ok := q.contracts.Get(contract)
if !ok || held.Status.Contract == nil {
return errors.New("the held session contract " + contract + " is not known")
}
return q.recordedWinnerAllowed(ctx, held.Status.Contract, policyName)
}
func (q *Requester) provisionHeldContract(ctx context.Context, name, vmName, did, publicKey, policyName string, policyArgs map[string]string,
userData string, ttlSeconds int32, labels map[string]string) (*SessionTarget, error) {
args := ""
if len(policyArgs) > 0 {
raw, err := json.Marshal(policyArgs)
if err != nil {
return nil, err
}
args = string(raw)
}
deadline := q.now().Add(q.cfg.BidWindow + q.cfg.ReceiptTimeout + DefaultVMReadyTimeout)
waitCtx, cancel := context.WithDeadline(ctx, deadline)
defer cancel()
contract := v1alpha1.ComputeContract{
TypeMeta: metav1.TypeMeta{APIVersion: v1alpha1.GroupVersion.String(), Kind: contractmarket.KindComputeContract},
ObjectMeta: metav1.ObjectMeta{Name: name, Labels: labels},
Spec: v1alpha1.ComputeContractSpec{
ComputeContractTemplate: v1alpha1.ComputeContractTemplate{VMName: vmName, SshAuthorizedKeys: []string{publicKey},
Policy: policyName, PolicyArgs: args, UserData: userData},
OwnerDid: did,
TTLSecondsAfterFinished: new(ttlSeconds),
},
}
for {
if existing, ok := q.contracts.Get(name); ok {
if existing.DeletionTimestamp == nil {
if err := q.deps.Intents.DeleteComputeContract(ctx, name); err != nil {
return nil, err
}
}
gone := func() bool {
_, present := q.contracts.Get(name)
return !present
}
if err := q.contracts.Await(waitCtx, gone); err != nil {
if ctx.Err() != nil {
return nil, ctx.Err()
}
return nil, errors.New("the previous session contract was not removed in time")
}
continue
}
err := q.deps.Intents.CreateComputeContract(ctx, contract)
if err == nil {
break
}
if !errors.Is(err, contractmarket.ErrExists) {
return nil, err
}
if err := q.awaitContractChange(waitCtx); err != nil {
if ctx.Err() != nil {
return nil, ctx.Err()
}
return nil, errors.New("the session contract was not created in time")
}
}
return q.waitHeldContract(waitCtx, ctx, name)
}
func (q *Requester) waitHeldContract(waitCtx, ctx context.Context, name string) (*SessionTarget, error) {
var target *SessionTarget
var failure error
seen := false
_ = q.contracts.Await(waitCtx, func() bool {
contract, ok := q.contracts.Get(name)
if !ok {
if seen {
failure = errors.New("the session contract disappeared")
}
return seen
}
seen = true
switch contract.Status.Phase {
case v1alpha1.ComputeContractFailed:
failure = fmt.Errorf("the session contract failed: %s", contract.Status.Message)
return true
case v1alpha1.ComputeContractReleased:
failure = errors.New("the session contract was released before the guest was ready")
return true
}
found, ready, err := contractTarget(contract)
if err != nil {
failure = err
return true
}
target = found
return ready
})
switch {
case failure != nil:
return nil, failure
case target != nil:
return target, nil
case ctx.Err() != nil:
return nil, ctx.Err()
}
return nil, errors.New("the guest did not report onNetwork and hostKeys in time")
}
func (q *Requester) releaseHeldContract(name string) {
if name == "" {
return
}
for attempt := 1; ; attempt++ {
ctx, cancel := context.WithTimeout(context.WithoutCancel(q.runContext()), DefaultReleaseTimeout)
err := q.deps.Intents.ReleaseComputeContract(ctx, name)
cancel()
if err == nil || errors.Is(err, contractmarket.ErrNotFound) {
if attempt > 1 {
q.log.Info("requester_held_contract_released", "contract", name, "attempt", attempt)
}
return
}
q.log.Warn("requester_held_contract_release_failed", "contract", name, "attempt", attempt, "err", err)
if attempt >= heldReleaseAttempts {
q.log.Warn("requester_held_contract_release_left", "contract", name, "reason", "the next requester start releases it")
return
}
time.Sleep(min(time.Second<<(attempt-1), heldReleaseBackoffMax))
}
}
func (q *Requester) releaseHeldSessionTarget(contract, privateKeyPath string) {
if contract != "" {
q.releaseHeldContract(contract)
}
_ = sshtransport.RemoveGuestKeypair(privateKeyPath)
}
func (q *Requester) sessionBestBid(ctx context.Context, rfp market.SignedRecord, bids map[string]BidRecord, workflow PolicyGate, full map[string]bool, limit int) *BidRecord {
fullKey := func(bid BidRecord) string {
return strings.Join([]string{bid.URI, bid.CID, workflow.Key(), rfp.URI, rfp.CID}, "|")
}
var best *BidRecord
for denied := 0; ; {
if limit > 0 && denied >= limit {
return nil
}
best = nil
for _, bid := range bids {
candidate := bid
if err := q.classifyBid(ctx, &candidate); err != nil {
continue
}
if allowed, done := full[fullKey(candidate)]; done && !allowed {
continue
}
if !q.bidAllowedWithPolicy(ctx, candidate, workflow) {
continue
}
switch {
case best == nil:
best = &candidate
case best.Free:
case candidate.Free:
best = &candidate
case candidate.Cost < best.Cost:
best = &candidate
}
}
if best == nil {
return nil
}
key := fullKey(*best)
if _, done := full[key]; !done {
decision := q.policy.Evaluate(ctx, workflow.Input(PolicyInput{
SelfDid: q.marketDID,
SubjectDid: best.DID,
CounterpartyDid: best.DID,
RootRequesterDid: q.marketDID,
RFP: &PolicyRef{URI: rfp.URI, CID: rfp.CID},
Bid: &PolicyRef{URI: best.URI, CID: best.CID},
}))
full[key] = decision.Allow
if !decision.Allow {
denied++
q.log.Info("requester_bid_policy_denied", "bidder", best.DID, "bid", best.URI, "mode", participant.PolicyModeFull, "reason", decision.Reason)
}
}
if full[key] {
break
}
}
return best
}
func lcEnv(env map[string]string) map[string]string {
out := map[string]string{}
for key, value := range env {
if !strings.HasPrefix(key, "LC_") || localeNames[key] {
continue
}
out[key] = value
}
return out
}
func renderExecCommand(command string, env map[string]string) string {
if len(env) == 0 {
return command
}
keys := make([]string, 0, len(env))
for key := range env {
keys = append(keys, key)
}
slices.Sort(keys)
var b strings.Builder
for _, key := range keys {
b.WriteString("export ")
b.WriteString(key)
b.WriteString("=")
b.WriteString("'" + strings.ReplaceAll(env[key], "'", "'\"'\"'") + "'")
b.WriteString("; ")
}
b.WriteString(command)
return b.String()
}
func truthy(value string) bool {
switch strings.ToLower(strings.TrimSpace(value)) {
case "1", "true", "yes", "on":
return true
default:
return false
}
}