~ knotless Search/
↑↓ move↵ open⇧↵ all results

socialweb.computer/socialweb-computer-kcp

socialweb.computer: a compute market on atproto (kcp)

1 collaborator
0
0
424 lines · 16.0 KB Raw History
package cloudinit

import (
	"encoding/json"
	"fmt"
	"net/url"
	"path"
	"slices"
	"strconv"
	"strings"
	"time"
)

const (
	RequestReleaseWait = 3 * time.Minute

	RequestRevokeWait = 15 * time.Minute

	GuestRequesterReleaseEach = RequestReleaseWait + RequestRevokeWait + 2*time.Minute

	GuestRequesterReleaseUnitTimeout = GuestRequesterReleaseEach + time.Minute

	GuestRequesterStopTimeout = 2 * time.Minute

	GuestRequesterReleaseTimeout = GuestRequesterStopTimeout + GuestRequesterReleaseUnitTimeout + time.Minute

	GuestRequesterIdentityReleaseTimeout = GuestRequesterStopTimeout + time.Minute
)

const (
	DefaultAgentEnvFile = "/etc/atirc/atirc.env"

	AgentIrohKeyFile = "/etc/atirc/iroh_key.hex"

	AgentConfigFile = "/etc/atirc/config.toml"

	AssociationRefDir = "/etc/socialweb-computer"

	DefaultAssociationRefFile = AssociationRefDir + "/association-ref"

	DefaultAssociationRequestFile = AssociationRefDir + "/association-request.json"

	GuestRequesterAtircEnvFile = AssociationRefDir + "/r2-atirc.env"

	GuestRequesterAgentEnvFile = AssociationRefDir + "/r2-agent.env"

	GuestRequesterGroup = "socialweb-r2"

	GuestRequesterDir = "/run/socialweb-r2"

	GuestRequesterUser = "r2"

	GuestRequesterUnit = "socialweb-r2.service"

	GuestRequesterReleaseUnit = "socialweb-r2-release.service"

	GuestRequesterRunPath = "/usr/local/bin/socialweb-r2-run.sh"

	GuestRequesterReleasePath = "/usr/local/bin/socialweb-r2-release.sh"

	GuestRequesterStartEnv = GuestRequesterDir + "/r2-start.env"

	// a guest requester's kcp starts in a 2 vCPU guest (and nested, a guest of a staging bidder): the default 1m readyz
	// budget is too tight (staging cycle 14: rbac/bootstrap-roles and kcp-bootstrap-policy still pending at 87 s)
	GuestRequesterReadyTimeout = "5m"

	GuestAgentAssociationPath = GuestAgentConfigDir + "/association.json"

	GuestRequesterNetworkEnv = GuestAgentConfigDir + "/r2-network.env"

	RequestExecUsage = "--exec -- <command> [args...]"

	GuestRequesterDIDPath = GuestAgentStateDir + "/requester-did"

	SecretsFetchScriptPath = "/usr/local/bin/setup-secrets.sh"

	SecretsRefetchEnv = "SECRETS_REFETCH"

	AgentUnit = "atirc-agent.service"

	AgentRunPath = "/usr/local/bin/atirc-agent-run.sh"

	AgentEnvPathUnit = "atirc-agent-env.path"

	AgentEnvUnit = "atirc-agent-env.service"

	AgentEnvRestartPath = "/usr/local/bin/atirc-agent-env.sh"

	AgentEnvStampDir = "/run/atirc-agent"

	AgentEnvStampPath = AgentEnvStampDir + "/env.sha256"

	AgentEnvSnapshotPath = AgentEnvStampDir + "/env"

	AtircBinary = "/usr/local/bin/atirc"

	AgentUserPath = "/usr/local/bin/atirc-agent-user.sh"

	AgentExecPath = "/usr/local/bin/atirc-agent-exec.sh"

	GuestAgentAgentPath = GuestAgentConfigDir + "/agent.json"
)

type AgentOptions struct {
	EnvFile string

	// PLC: the PLC the agent resolves DIDs at (a network's, plan 0050); unset: atirc's default, plc.directory
	PLC string
}

type guestAgentAgent struct {
	Unit string `json:"unit"`
}

func (opts AgentOptions) envFile() string {
	if opts.EnvFile == "" {
		return DefaultAgentEnvFile
	}
	return opts.EnvFile
}

func (opts AgentOptions) Validate() error {
	if opts.PLC != "" {
		if u, err := url.Parse(opts.PLC); err != nil || u.Scheme != "https" || u.Host == "" || strings.ContainsAny(opts.PLC, " \t\n'\"$`\\") {
			return fmt.Errorf("cloudinit agent: the PLC %q is not an https URL", opts.PLC)
		}
	}
	if !tunnelPathRE.MatchString(opts.envFile()) {
		return fmt.Errorf("cloudinit agent: envFile %q is not an absolute path of [A-Za-z0-9._/-]", opts.EnvFile)
	}
	return nil
}

// agentPLCEnvironment: the unit's Environment= line for a network's PLC (an empty Environment= is a no-op)
func agentPLCEnvironment(plc string) string {
	if plc == "" {
		return "Environment="
	}
	return "Environment=" + AtircPLCEnv + "=" + plc
}

const AtircPLCEnv = "ATIRC_PLC_DIRECTORY_URL"

func AgentModule(opts AgentOptions) UserDataModule {
	return func(Context) (UserDataPatch, error) {
		return agentPatch(opts)
	}
}

func agentPatch(opts AgentOptions) (UserDataPatch, error) {
	if err := opts.Validate(); err != nil {
		return UserDataPatch{}, err
	}
	raw, err := json.Marshal(guestAgentAgent{Unit: AgentUnit})
	if err != nil {
		return UserDataPatch{}, fmt.Errorf("cloudinit agent: encoding %s: %w", GuestAgentAgentPath, err)
	}
	return UserDataPatch{
		WriteFiles: []WriteFileEntry{
			{Path: "/etc/systemd/system/" + AgentUnit, Owner: "root:root", Permissions: "0644", Content: unitFile(
				[]string{
					"Description=atirc agent",
					"After=network-online.target " + GuestBinariesUnit + " " + strings.Join(SecretsReadyUnits, " "),
					"Wants=network-online.target " + GuestBinariesUnit + " " + GuestSecretsUnit,
					"StartLimitIntervalSec=0",
				},
				[]string{
					"Type=simple",
					agentPLCEnvironment(opts.PLC),
					"ExecStart=" + AgentRunPath + " " + opts.envFile(),
					"Restart=always",
					"RestartSec=30",
					"StandardOutput=journal",
					"StandardError=journal",
				})},
			{Path: AgentRunPath, Owner: "root:root", Permissions: "0700", Content: agentRunScript},
			{Path: AgentUserPath, Owner: "root:root", Permissions: "0700", Content: agentUserScript},
			{Path: AgentExecPath, Owner: "root:root", Permissions: "0700", Content: agentExecScript},
			{Path: AgentEnvRestartPath, Owner: "root:root", Permissions: "0700", Content: agentEnvRestartScript},
			{Path: "/etc/systemd/system/" + AgentEnvUnit, Owner: "root:root", Permissions: "0644", Content: strings.Join([]string{
				"[Unit]",
				"Description=restart a running atirc agent when its env file changed",
				"",
				"[Service]",
				"Type=oneshot",
				"ExecStart=" + AgentEnvRestartPath + " " + opts.envFile(),
				"StandardOutput=journal",
				"StandardError=journal",
				"",
			}, "\n")},
			{Path: "/etc/systemd/system/" + AgentEnvPathUnit, Owner: "root:root", Permissions: "0644", Content: strings.Join([]string{
				"[Unit]",
				"Description=watch the atirc agent env file",
				"",
				"[Path]",
				"PathChanged=" + opts.envFile(),
				"Unit=" + AgentEnvUnit,
				"",
				"[Install]",
				"WantedBy=paths.target",
				"",
			}, "\n")},
			{Path: GuestAgentAgentPath, Owner: "root:root", Permissions: "0644", Content: string(raw) + "\n"},
		},
		RuncmdPrepend: []any{"systemctl daemon-reload", "systemctl enable --now " + AgentEnvPathUnit},
	}, nil
}

const agentEnvRestartScript = `#!/usr/bin/env bash
set -euo pipefail
ENV_FILE="$1"
now="$(sha256sum < "${ENV_FILE}" 2>/dev/null || sha256sum < /dev/null)"
if [ "${now}" = "$(cat "` + AgentEnvStampPath + `" 2>/dev/null || true)" ]; then
  exit 0
fi
echo "atirc-agent-env: ${ENV_FILE} changed; restarting ` + AgentUnit + ` if it runs" >&2
exec systemctl try-restart --no-block ` + AgentUnit + `
`

const agentRunScript = `#!/usr/bin/env bash
set -euo pipefail
ENV_FILE="$1"
install -d -m 0700 -o root -g root "` + AgentEnvStampDir + `"
if [ -f "${ENV_FILE}" ]; then cp -f "${ENV_FILE}" "` + AgentEnvSnapshotPath + `"; else : > "` + AgentEnvSnapshotPath + `"; fi
chmod 0600 "` + AgentEnvSnapshotPath + `"
sha256sum < "` + AgentEnvSnapshotPath + `" > "` + AgentEnvStampPath + `"
while IFS= read -r line || [ -n "${line}" ]; do
  if [[ "${line}" =~ ^[A-Za-z_][A-Za-z0-9_]*= ]]; then
    if ! (export "${line}") 2>/dev/null; then
      echo "atirc-agent: skipped ${line%%=*} from the env file (not exportable)" >&2
      continue
    fi
    export "${line}"
  fi
done < "` + AgentEnvSnapshotPath + `"
if [ ! -f "` + GuestSecretsReadyPath + `" ] && [ ! -f "` + SecretsDoneStamp + `" ]; then
  echo "atirc-agent: the secrets bundle is not written yet (` + GuestSecretsReadyPath + `); the agent waits" >&2
  exit 1
fi
if [ ! -x "` + AtircBinary + `" ]; then
  echo "atirc-agent: ` + AtircBinary + ` is not installed yet (` + GuestBinariesUnit + `); the agent waits" >&2
  exit 1
fi
if [ -z "${ATP_USERNAME:-}" ] || [ ! -s "` + AgentIrohKeyFile + `" ]; then
  echo "atirc-agent: the mesh identity (ATP_USERNAME, ` + AgentIrohKeyFile + `) is not in the secrets bundle yet; the agent waits" >&2
  exit 1
fi
hex="$(tr -d '[:space:]' < "` + AgentIrohKeyFile + `")"
if ! [[ "${hex}" =~ ^[0-9a-f]{64}$ ]]; then
  echo "atirc-agent: ` + AgentIrohKeyFile + ` is not 32 bytes of hex" >&2
  exit 1
fi
export ATP_USERNAME ATIRC_NICK
nick="$(` + AgentUserPath + `)"
uid="$(id -u "${nick}")"
home="$(getent passwd "${nick}" | cut -d: -f6)"
dir="${home}/.config/atirc"
install -d -m 0700 -o "${nick}" -g "${nick}" "${home}/.config" "${dir}"
(umask 077; printf '%b' "$(printf '%s' "${hex}" | sed 's/../\\x&/g')" > "${dir}/iroh_key.tmp")
chown "${nick}:${nick}" "${dir}/iroh_key.tmp"
chmod 0600 "${dir}/iroh_key.tmp"
mv -f "${dir}/iroh_key.tmp" "${dir}/iroh_key"
if [ -s "` + AgentConfigFile + `" ]; then
  install -m 0600 -o "${nick}" -g "${nick}" "` + AgentConfigFile + `" "${dir}/config.toml"
fi
run=(runuser -u "${nick}" -- env XDG_RUNTIME_DIR="/run/user/${uid}" DBUS_SESSION_BUS_ADDRESS="unix:path=/run/user/${uid}/bus" ATIRC_CONFIG_DIR="${dir}")
[ -n "${` + AtircPLCEnv + `:-}" ] && run+=(` + AtircPLCEnv + `="${` + AtircPLCEnv + `}")
"${run[@]}" ` + AtircBinary + ` agent run &
exec "${run[@]}" ` + AtircBinary + ` mesh run --no-publish
`

const agentUserScript = `#!/usr/bin/env bash
set -euo pipefail
nick="${ATIRC_NICK:-$(` + AtircBinary + ` nick)}"
if ! [[ "${nick}" =~ ^[a-z_][a-z0-9_-]{0,31}$ ]]; then
  echo "atirc-agent: atirc nick printed ${nick@Q}, not a user name" >&2
  exit 1
fi
getent group wheel >/dev/null || groupadd wheel
mkdir -p /etc/sudoers.d
printf '%%wheel ALL=(ALL) NOPASSWD: ALL\n' > /etc/sudoers.d/wheel
chmod 440 /etc/sudoers.d/wheel
id "${nick}" >/dev/null 2>&1 || useradd -m -G wheel -s /bin/bash "${nick}"
if getent group ` + GuestRequesterGroup + ` >/dev/null; then usermod -aG ` + GuestRequesterGroup + ` "${nick}"; fi
loginctl enable-linger "${nick}" >&2
uid="$(id -u "${nick}")"
for _ in $(seq 1 30); do
  [ -S "/run/user/${uid}/bus" ] && break
  sleep 1
done
printf '%s\n' "${nick}"
`

const agentExecScript = `#!/usr/bin/env bash
set -euo pipefail
if [ -z "${ATIRC_TOKEN:-}" ]; then
  echo "atirc-agent-exec: ATIRC_TOKEN is empty" >&2
  exit 1
fi
nick="$(` + AgentUserPath + `)"
uid="$(id -u "${nick}")"
home="$(getent passwd "${nick}" | cut -d: -f6)"
cd "${home}"
exec runuser -u "${nick}" -- env XDG_RUNTIME_DIR="/run/user/${uid}" DBUS_SESSION_BUS_ADDRESS="unix:path=/run/user/${uid}/bus" bash -c "$1"
`

func AssociationRefPath(raw string) (string, error) {
	raw = strings.TrimSpace(raw)
	if raw == "" {
		return DefaultAssociationRefFile, nil
	}
	clean := path.Clean(raw)
	if !strings.HasPrefix(raw, "/") || slices.Contains(strings.Split(raw, "/"), "..") || !strings.HasPrefix(clean, AssociationRefDir+"/") {
		return "", fmt.Errorf("cloudinit association: refFile %q is not an absolute path under %s/ without a .. segment", raw, AssociationRefDir)
	}
	return clean, nil
}

type GuestAgentAssociation struct {
	RefFile string `json:"refFile"`
}

// guestRequesterNetwork: a network guest's requester registers on the network's PLC and serves through the network's
// ingress (plan 0050), as its renter does; outside a network both stay unset (plc.directory and the public ingress)
func guestRequesterNetwork(guestPLC, ingress string) string {
	return "R2_PLC=" + guestPLC + "\nR2_INGRESS=" + ingress + "\n"
}

func AssociationModule(refFile, guestPLC, ingress string) UserDataModule {
	return func(Context) (UserDataPatch, error) {
		clean, err := AssociationRefPath(refFile)
		if err != nil {
			return UserDataPatch{}, err
		}
		if ingress != "" && (strings.ContainsAny(ingress, " \t\n'\"$`\\/:") || strings.Trim(ingress, ".") != ingress) {
			return UserDataPatch{}, fmt.Errorf("cloudinit association: the guest ingress %q is not a host name", ingress)
		}
		if guestPLC != "" {
			if u, err := url.Parse(guestPLC); err != nil || u.Scheme != "https" || u.Host == "" || u.RawQuery != "" || strings.ContainsAny(guestPLC, " \t\n'\"$`\\") {
				return UserDataPatch{}, fmt.Errorf("cloudinit association: the guest PLC %q is not an https URL", guestPLC)
			}
		}
		raw, err := json.Marshal(GuestAgentAssociation{RefFile: clean})
		if err != nil {
			return UserDataPatch{}, fmt.Errorf("cloudinit association: encoding %s: %w", GuestAgentAssociationPath, err)
		}
		after := []string{"After=network-online.target " + GuestBinariesUnit + " " + strings.Join(SecretsReadyUnits, " "),
			"Wants=network-online.target " + GuestBinariesUnit + " " + GuestSecretsUnit}
		return UserDataPatch{WriteFiles: []WriteFileEntry{
			{Path: GuestRequesterNetworkEnv, Owner: "root:root", Permissions: "0644", Content: guestRequesterNetwork(guestPLC, ingress)},
			{Path: GuestAgentAssociationPath, Owner: "root:root", Permissions: "0644", Content: string(raw) + "\n"},
			{Path: GuestRequesterRunPath, Owner: "root:root", Permissions: "0755", Content: guestRequesterRunScript},
			{Path: GuestRequesterReleasePath, Owner: "root:root", Permissions: "0755", Content: guestRequesterReleaseScript},
			{Path: "/etc/systemd/system/" + GuestRequesterUnit, Owner: "root:root", Permissions: "0644", Content: unitFile(
				append([]string{"Description=the guest requester (plan 0036 A7), started by guest.r2Start", "StartLimitIntervalSec=0"}, after...),
				[]string{"Type=exec", "User=" + GuestRequesterUser, "ExecStart=" + GuestRequesterRunPath, "Restart=on-failure", "RestartSec=10s",
					"TimeoutStopSec=" + seconds(GuestRequesterStopTimeout-30*time.Second), "StandardOutput=journal", "StandardError=journal"})},
			{Path: "/etc/systemd/system/" + GuestRequesterReleaseUnit, Owner: "root:root", Permissions: "0644", Content: unitFile(
				append([]string{"Description=release every contract of the guest requester (plan 0036 A8), started by guest.r2Release"}, after...),
				[]string{"Type=oneshot", "User=" + GuestRequesterUser, "ExecStart=" + GuestRequesterReleasePath,
					"TimeoutStartSec=" + seconds(GuestRequesterReleaseUnitTimeout), "StandardOutput=journal", "StandardError=journal"})},
		}, RuncmdPrepend: []any{
			"groupadd -f " + GuestRequesterGroup,
			"id " + GuestRequesterUser + " >/dev/null 2>&1 || useradd -m -s /bin/bash -G " + GuestRequesterGroup + " " + GuestRequesterUser,
			"loginctl enable-linger " + GuestRequesterUser,
			"systemctl daemon-reload",
		}}, nil
	}
}

const guestRequesterEnv = `uid="$(id -u)"
export XDG_RUNTIME_DIR="/run/user/${uid}" DBUS_SESSION_BUS_ADDRESS="unix:path=/run/user/${uid}/bus"
for _ in $(seq 1 30); do
  [ -S "${XDG_RUNTIME_DIR}/bus" ] && break
  sleep 1
done
`

const guestRequesterRunScript = `#!/usr/bin/env bash
set -euo pipefail
. ` + GuestRequesterStartEnv + `
` + guestRequesterEnv + `args=(run request --name "${R2_NAME}" --guest-requester --ready-timeout ` + GuestRequesterReadyTimeout + `)
[ "${R2_AGENT:-}" = 1 ] && args+=(--agent)
[ "${R2_HOLD:-}" = 1 ] && args+=(--hold)
[ -n "${R2_COLOCATED:-}" ] && args+=(--colocated "${R2_COLOCATED}")
[ "${R2_IDENTITY:-}" = 1 ] && args+=(--identity-only)
R2_PLC= R2_INGRESS=
[ -r ` + GuestRequesterNetworkEnv + ` ] && . ` + GuestRequesterNetworkEnv + `
pass=()
[ -n "${R2_PLC}" ] && pass+=(--plc-directory-url "${R2_PLC}")
[ -n "${R2_INGRESS}" ] && pass+=(--ingress-proxy-host "${R2_INGRESS}")
if [ ${#pass[@]} -gt 0 ]; then
  case "$(socialweb-computer run request --help 2>&1 || true)" in
    *"` + RequestExecUsage + `"*) args+=("${pass[@]}") ;;
    *) args+=(-- "${pass[@]}") ;;
  esac
fi
# a restart after a start that failed (its kcp not up in time): the invocation is kept for this, resume it
[ -d "${HOME}/.local/state/socialweb-computer/requests/${R2_NAME}" ] && args=(run request resume "${R2_NAME}" --ready-timeout ` + GuestRequesterReadyTimeout + `)
[ "${R2_IDENTITY:-}" = 1 ] && exec socialweb-computer "${args[@]}"
socialweb-computer "${args[@]}"
if [ "${R2_AGENT:-}" = 1 ] && [ "${R2_HOLD:-}" = 1 ]; then
  exec socialweb-computer run request agent "${R2_NAME}"
fi
`

var guestRequesterReleaseScript = `#!/usr/bin/env bash
set -uo pipefail
command -v socialweb-computer >/dev/null || exit 0
` + guestRequesterEnv + `fail=0
pids=()
for name in $(socialweb-computer run request list --json | jq -r '.[] | select(.phase != "Released") | .name'); do
  timeout --kill-after=30 ` + seconds(GuestRequesterReleaseEach) + ` socialweb-computer run request release --contract-timeout ` + seconds(RequestReleaseWait) + `s "${name}" &
  pids+=("$!")
done
for pid in "${pids[@]}"; do
  wait "${pid}" || fail=1
done
exit "${fail}"
`

func seconds(d time.Duration) string {
	return strconv.Itoa(int(d / time.Second))
}