Repository Public
1package api23import (4 "context"5 "encoding/hex"6 "encoding/json"7 "errors"8 "regexp"9 "strings"10 "time"1112 "github.com/google/uuid"13 "github.com/jackc/pgx/v5"1415 "clustr.spboucher.ai/mcc/internal/audit"16 "clustr.spboucher.ai/mcc/internal/events"17 "clustr.spboucher.ai/mcc/internal/httpx"18 "clustr.spboucher.ai/mcc/internal/ids"19 "clustr.spboucher.ai/mcc/internal/secret"20)2122// ── Agents ─────────────────────────────────────────────────────────────────2324const admAgentCols = `a.id, a.node_id, n.alias::text, a.version, a.os, a.capabilities, a.cert_serial, a.cert_fingerprint, a.cert_not_after,25 a.enrolled_at, a.last_seen_at, a.overhead, a.revoked_at, a.revoked_reason`2627const admAgentFrom = ` from agents a join nodes n on n.id = a.node_id `2829func (c *core) admScanAgent(row pgx.Row, now time.Time) (Agent, error) {30 var a Agent31 var fp, overhead []byte32 if err := row.Scan(&a.Id, &a.NodeId, &a.NodeAlias, &a.Version, &a.Os, &a.Capabilities, &a.CertSerial, &fp, &a.CertNotAfter,33 &a.EnrolledAt, &a.LastSeenAt, &overhead, &a.RevokedAt, &a.RevokedReason); err != nil {34 return a, err35 }36 if a.Capabilities == nil {37 a.Capabilities = []string{}38 }39 a.CertFingerprintSha256 = hex.EncodeToString(fp)40 a.Freshness = c.clFresh(now, a.LastSeenAt)41 if a.RevokedAt != nil {42 a.Freshness = FreshnessOffline // a revoked agent is refused by ingest whatever it last sent43 }44 // overhead is the agent's own {cpu, rss} from its reports; absent members stay absent.45 o := clObject(overhead)46 var oh AgentOverhead47 if v, ok := clNumber(o, "cpu"); ok {48 oh.CpuPct = clF32(&v)49 } else if v, ok := clNumber(o, "cpu_pct"); ok {50 oh.CpuPct = clF32(&v)51 } else if v, ok := clNumber(o, "cpu_percent"); ok { // key written by telemetry-ingest52 oh.CpuPct = clF32(&v)53 }54 if v, ok := clNumber(o, "rss"); ok {55 oh.RssBytes = ptr(int64(v))56 } else if v, ok := clNumber(o, "rss_bytes"); ok {57 oh.RssBytes = ptr(int64(v))58 }59 if oh.CpuPct != nil || oh.RssBytes != nil {60 a.Overhead = &oh61 }62 return a, nil63}6465// activeAgent returns the non-revoked agent of a node, if any.66func (c *core) activeAgent(ctx context.Context, now time.Time, nodeID uuid.UUID) (*Agent, error) {67 a, err := c.admScanAgent(c.Pool.QueryRow(ctx, `select `+admAgentCols+admAgentFrom+` where a.node_id = $1 and a.revoked_at is null`, nodeID), now)68 if errors.Is(err, pgx.ErrNoRows) {69 return nil, nil70 } else if err != nil {71 return nil, err72 }73 return &a, nil74}7576func (h *adminHandlers) ListAgents(ctx context.Context, req ListAgentsRequestObject) (ListAgentsResponseObject, error) {77 p := req.Params78 limit, err := clLimit(p.Limit)79 if err != nil {80 return nil, err81 }82 b := &clSQL{}83 if p.NodeId != nil {84 b.and("a.node_id = " + b.arg(*p.NodeId))85 }86 if p.Revoked == nil || !*p.Revoked {87 b.and("a.revoked_at is null")88 }89 cur, err := clDecodeCursor(p.Cursor, "agents", 2)90 if err != nil {91 return nil, err92 }93 if cur != nil {94 at, err := clCursorTime(cur[0])95 if err != nil {96 return nil, err97 }98 id, err := clCursorUUID(cur[1])99 if err != nil {100 return nil, err101 }102 b.and("(a.enrolled_at, a.id) < (" + b.arg(at) + "::timestamptz, " + b.arg(id) + "::uuid)")103 }104 rows, err := h.Pool.Query(ctx, `select `+admAgentCols+admAgentFrom+b.where()+` order by a.enrolled_at desc, a.id desc limit `+b.arg(limit+1), b.args...)105 if err != nil {106 return nil, err107 }108 now := time.Now().UTC()109 items, err := pgx.CollectRows(rows, func(r pgx.CollectableRow) (Agent, error) { return h.admScanAgent(r, now) })110 if err != nil {111 return nil, err112 }113 out := AgentList{Items: items}114 if len(items) > limit {115 out.Items = items[:limit]116 last := out.Items[limit-1]117 out.NextCursor = clEncodeCursor("agents", clTimeKey(last.EnrolledAt), last.Id.String())118 }119 if out.Items == nil {120 out.Items = []Agent{}121 }122 return ListAgents200JSONResponse{Body: out}, nil123}124125// RevokeAgent revokes the agent's certificate: ingest refuses it from then126// on. Commands already issued are the orchestrator's to expire.127func (h *adminHandlers) RevokeAgent(ctx context.Context, req RevokeAgentRequestObject) (RevokeAgentResponseObject, error) {128 if req.Body == nil {129 return nil, httpx.Validation("Body required.")130 }131 reason, err := clText("reason", &req.Body.Reason, 1, 500)132 if err != nil {133 return nil, err134 }135 tx, err := h.Pool.Begin(ctx)136 if err != nil {137 return nil, err138 }139 defer tx.Rollback(ctx)140 var nodeID uuid.UUID141 var revoked bool142 err = tx.QueryRow(ctx, `select node_id, revoked_at is not null from agents where id = $1 for update`, req.Id).Scan(&nodeID, &revoked)143 if errors.Is(err, pgx.ErrNoRows) {144 return nil, httpx.ErrNotFound145 } else if err != nil {146 return nil, err147 }148 if revoked {149 return nil, clConflict("This agent is already revoked.")150 }151 if _, err := tx.Exec(ctx, `update agents set revoked_at = now(), revoked_reason = $2 where id = $1`, req.Id, reason); err != nil {152 return nil, err153 }154 if err := h.audit(ctx, tx, "agent.revoke", "agent", req.Id.String(), audit.Success, reason, map[string]any{"node_id": nodeID.String()}); err != nil {155 return nil, err156 }157 if err := events.Publish(ctx, tx, "node.updated", NodeUpdatedEvent{NodeId: nodeID, Change: NodeUpdatedEventChangeAgent}); err != nil {158 return nil, err159 }160 a, err := h.admScanAgent(tx.QueryRow(ctx, `select `+admAgentCols+admAgentFrom+` where a.id = $1`, req.Id), time.Now().UTC())161 if err != nil {162 return nil, err163 }164 if err := tx.Commit(ctx); err != nil {165 return nil, err166 }167 return RevokeAgent200JSONResponse{Body: a}, nil168}169170// ── Enrollment tokens ──────────────────────────────────────────────────────171172const (173 admEnrollDefaultTTL = 15 * time.Minute174 admEnrollMaxMinutes = 1440175 admSettingCA = "pki.ca" // written by telemetry-ingest when it creates its CA176)177178const admTokenCols = `id, node_alias::text, node_kind::text, created_by, created_at, expires_at, consumed_at, revoked_at`179180func admScanToken(row pgx.Row, now time.Time) (EnrollmentToken, error) {181 var t EnrollmentToken182 var kind string183 err := row.Scan(&t.Id, &t.NodeAlias, &kind, &t.CreatedBy, &t.CreatedAt, &t.ExpiresAt, &t.ConsumedAt, &t.RevokedAt)184 t.NodeKind = NodeKind(kind)185 switch {186 case t.RevokedAt != nil:187 t.Status = EnrollmentTokenStatusRevoked188 case t.ConsumedAt != nil:189 t.Status = EnrollmentTokenStatusConsumed190 case !now.Before(t.ExpiresAt):191 t.Status = EnrollmentTokenStatusExpired192 default:193 t.Status = EnrollmentTokenStatusPending194 }195 return t, err196}197198func (h *adminHandlers) ListEnrollmentTokens(ctx context.Context, req ListEnrollmentTokensRequestObject) (ListEnrollmentTokensResponseObject, error) {199 limit, err := clLimit(req.Params.Limit)200 if err != nil {201 return nil, err202 }203 cur, err := clDecodeCursor(req.Params.Cursor, "enrollment-tokens", 1)204 if err != nil {205 return nil, err206 }207 b := &clSQL{}208 if cur != nil {209 id, err := clCursorUUID(cur[0])210 if err != nil {211 return nil, err212 }213 b.and("id < " + b.arg(id))214 }215 // The token hash is never selected. Ids are UUIDv7: descending id is most recent first.216 rows, err := h.Pool.Query(ctx, `select `+admTokenCols+` from agent_enrollment_tokens`+b.where()+` order by id desc limit `+b.arg(limit+1), b.args...)217 if err != nil {218 return nil, err219 }220 now := time.Now().UTC()221 items, err := pgx.CollectRows(rows, func(r pgx.CollectableRow) (EnrollmentToken, error) { return admScanToken(r, now) })222 if err != nil {223 return nil, err224 }225 out := EnrollmentTokenList{Items: items}226 if len(items) > limit {227 out.Items = items[:limit]228 out.NextCursor = clEncodeCursor("enrollment-tokens", out.Items[limit-1].Id.String())229 }230 if out.Items == nil {231 out.Items = []EnrollmentToken{}232 }233 return ListEnrollmentTokens200JSONResponse{Body: out}, nil234}235236var admHexSHA256 = regexp.MustCompile(`^[0-9a-f]{64}$`)237238// caFingerprint reads the SHA-256 fingerprint of the ingest CA published by239// telemetry-ingest in settings (`pki.ca` = {"pem": …, "fingerprint_sha256": …}).240// It returns "" when ingest has not created its CA yet, or when the stored241// value is not a fingerprint: nothing is derived or guessed here.242func (h *adminHandlers) caFingerprint(ctx context.Context) (string, error) {243 var raw []byte244 err := h.Pool.QueryRow(ctx, `select value from settings where key = $1`, admSettingCA).Scan(&raw)245 if errors.Is(err, pgx.ErrNoRows) {246 return "", nil247 } else if err != nil {248 return "", err249 }250 var v struct {251 Fingerprint string `json:"fingerprint_sha256"`252 Short string `json:"fingerprint"` // key written by telemetry-ingest253 }254 if json.Unmarshal(raw, &v) != nil {255 return "", nil256 }257 if v.Fingerprint == "" {258 v.Fingerprint = v.Short259 }260 fp := strings.ToLower(strings.ReplaceAll(strings.TrimPrefix(v.Fingerprint, "sha256:"), ":", ""))261 if !admHexSHA256.MatchString(fp) {262 return "", nil263 }264 return fp, nil265}266267// admInstallHint is the command to run on the node. When something it needs268// is not known, the hint says so and the command is deliberately not269// runnable as is, rather than carrying a made-up value.270func admInstallHint(endpoints []string, token, caFingerprint string) string {271 var notes []string272 eps := strings.Join(endpoints, ",")273 if eps == "" {274 eps = "<INGEST_ENDPOINTS>"275 notes = append(notes, "# No ingest endpoint is configured on the server (MCC_INGEST_ADVERTISE): replace <INGEST_ENDPOINTS> with host:port of telemetry-ingest.")276 }277 fp := "sha256:" + caFingerprint278 if caFingerprint == "" {279 fp = "sha256:<CA_FINGERPRINT_UNAVAILABLE>"280 notes = append(notes, "# The ingest CA fingerprint is not available: telemetry-ingest has not initialised its CA yet (setting pki.ca is absent).",281 "# Start telemetry-ingest, then create a new token: the agent must pin the CA and cannot enroll without its fingerprint.")282 }283 cmd := "mcc-agent enroll --endpoints " + eps + " --token " + token + " --ca-fingerprint " + fp284 return strings.Join(append(notes, cmd), "\n")285}286287// CreateEnrollmentToken issues a single-use token for one node alias. Only288// its SHA-256 is stored; the clear value is in this response and nowhere else.289func (h *adminHandlers) CreateEnrollmentToken(ctx context.Context, req CreateEnrollmentTokenRequestObject) (CreateEnrollmentTokenResponseObject, error) {290 if req.Body == nil {291 return nil, httpx.Validation("Body required.")292 }293 alias, err := clAlias("node_alias", req.Body.NodeAlias)294 if err != nil {295 return nil, err296 }297 if k := req.Body.NodeKind; k != NodeKindMac && k != NodeKindLinux && k != NodeKindNas {298 return nil, clInvalid("node_kind", "must be mac, linux or nas")299 }300 ttl := admEnrollDefaultTTL301 if m := req.Body.TtlMinutes; m != nil {302 if *m < 1 || *m > admEnrollMaxMinutes {303 return nil, clInvalid("ttl_minutes", "must be between 1 and 1440")304 }305 ttl = time.Duration(*m) * time.Minute306 }307 // A node that is retired, or that already has a working agent, cannot be enrolled again as is.308 var retired, hasAgent bool309 err = h.Pool.QueryRow(ctx, `select n.retired_at is not null, exists (select 1 from agents a where a.node_id = n.id and a.revoked_at is null)310 from nodes n where n.alias = $1`, alias).Scan(&retired, &hasAgent)311 switch {312 case errors.Is(err, pgx.ErrNoRows): // unknown alias: the node is created at enrollment313 case err != nil:314 return nil, err315 case retired:316 return nil, clConflict("This alias belongs to a retired node.").With("retired", true)317 case hasAgent:318 return nil, clConflict("This node already has an enrolled agent; revoke it first.").With("agent_enrolled", true)319 }320 fp, err := h.caFingerprint(ctx)321 if err != nil {322 return nil, err323 }324 clear, hash := secret.NewToken()325 id := ids.New()326 now := time.Now().UTC()327 tx, err := h.Pool.Begin(ctx)328 if err != nil {329 return nil, err330 }331 defer tx.Rollback(ctx)332 t, err := admScanToken(tx.QueryRow(ctx, `insert into agent_enrollment_tokens(id, token_hash, node_alias, node_kind, created_by, created_at, expires_at)333 values ($1, $2, $3, $4::node_kind, $5, $6, $7) returning `+admTokenCols,334 id, hash, alias, string(req.Body.NodeKind), principalFrom(ctx).Session.User.ID, now, now.Add(ttl)), now)335 if err != nil {336 return nil, err337 }338 if err := h.audit(ctx, tx, "agent.enrollment.create", "enrollment", id.String(), audit.Success, "",339 map[string]any{"node_alias": alias, "node_kind": string(req.Body.NodeKind), "ttl_minutes": int(ttl / time.Minute), "ca_known": fp != ""}); err != nil {340 return nil, err341 }342 if err := tx.Commit(ctx); err != nil {343 return nil, err344 }345 return CreateEnrollmentToken201JSONResponse{Body: EnrollmentTokenCreated{EnrollmentToken: t, Token: clear,346 InstallHint: admInstallHint(h.Cfg.IngestAdvertise, clear, fp), CaFingerprintSha256: fp}}, nil347}348349// RevokeEnrollmentToken revokes a token that was not used. Revoking twice is350// a no-op; a token that was already consumed is not "unused" and is reported351// as not found (the agent it enrolled is revoked through POST /agents/{id}/revoke).352func (h *adminHandlers) RevokeEnrollmentToken(ctx context.Context, req RevokeEnrollmentTokenRequestObject) (RevokeEnrollmentTokenResponseObject, error) {353 tx, err := h.Pool.Begin(ctx)354 if err != nil {355 return nil, err356 }357 defer tx.Rollback(ctx)358 var alias string359 var consumed, revoked bool360 err = tx.QueryRow(ctx, `select node_alias::text, consumed_at is not null, revoked_at is not null from agent_enrollment_tokens where id = $1 for update`,361 req.Id).Scan(&alias, &consumed, &revoked)362 switch {363 case errors.Is(err, pgx.ErrNoRows):364 return nil, httpx.ErrNotFound365 case err != nil:366 return nil, err367 case revoked:368 return RevokeEnrollmentToken204Response{}, nil369 case consumed:370 return nil, httpx.Err(404, "not_found", "No unused enrollment token has this id: it was already consumed.").With("status", "consumed")371 }372 if _, err := tx.Exec(ctx, `update agent_enrollment_tokens set revoked_at = now() where id = $1`, req.Id); err != nil {373 return nil, err374 }375 if err := h.audit(ctx, tx, "agent.enrollment.revoke", "enrollment", req.Id.String(), audit.Success, "", map[string]any{"node_alias": alias}); err != nil {376 return nil, err377 }378 if err := tx.Commit(ctx); err != nil {379 return nil, err380 }381 return RevokeEnrollmentToken204Response{}, nil382}383