Repository Public
1package api23import (4 "context"5 "errors"6 "net/netip"7 "time"89 "github.com/google/uuid"10 "github.com/jackc/pgx/v5"1112 "clustr.spboucher.ai/mcc/internal/audit"13 "clustr.spboucher.ai/mcc/internal/authz"14 "clustr.spboucher.ai/mcc/internal/httpx"15 "clustr.spboucher.ai/mcc/internal/ids"16)1718// ── Volumes ────────────────────────────────────────────────────────────────1920const clVolumeCols = `v.id, v.node_id, n.alias::text, n.site, n.tags, v.mount, v.device, v.fs, v.kind, v.total_bytes, v.used_bytes,21 v.smart_status, v.remote, v.last_seen_at, v.gone_at, greatest(s.received_at, n.last_seen_at)`2223const clVolumeFrom = ` from volumes v join nodes n on n.id = v.node_id left join node_state s on s.node_id = n.id `2425const clVolumeKey = `(lower(n.alias::text) || ' ' || v.mount)`2627type clVolume struct {28 ID, NodeID uuid.UUID29 NodeAlias string30 Site string31 Tags []string32 Mount string33 Device *string34 FS *string35 Kind string36 Total *int6437 Used *int6438 Smart *string39 Remote *string40 LastSeenAt time.Time41 GoneAt *time.Time42 NodeSeen *time.Time43}4445func clScanVolume(row pgx.Row, extra ...any) (clVolume, error) {46 var v clVolume47 dst := append([]any{&v.ID, &v.NodeID, &v.NodeAlias, &v.Site, &v.Tags, &v.Mount, &v.Device, &v.FS, &v.Kind, &v.Total, &v.Used,48 &v.Smart, &v.Remote, &v.LastSeenAt, &v.GoneAt, &v.NodeSeen}, extra...)49 return v, row.Scan(dst...)50}5152func (h *clusterHandlers) toVolume(v *clVolume, now time.Time, acc *clAccess) Volume {53 out := Volume{Id: v.ID, NodeId: v.NodeID, NodeAlias: v.NodeAlias, Mount: v.Mount, Device: clNonEmpty(v.Device), Fs: clNonEmpty(v.FS),54 Kind: VolumeKindInternal, TotalBytes: v.Total, UsedBytes: v.Used, SmartStatus: clNonEmpty(v.Smart), LastSeenAt: v.LastSeenAt,55 GoneAt: v.GoneAt, ObservedAt: &v.LastSeenAt, Freshness: h.clFresh(now, v.NodeSeen)}56 if v.Kind == string(VolumeKindExternal) || v.Kind == string(VolumeKindNetwork) {57 out.Kind = VolumeKind(v.Kind)58 }59 if acc.can(authz.NodesPrivateRead, clNodeFacets(v.NodeID, v.Site, v.Tags)...) {60 out.Remote = clNonEmpty(v.Remote) // //host/share reveals an address61 } else if out.Kind == VolumeKindNetwork {62 out.Device = nil // the "device" of a network mount is its remote63 }64 return out65}6667// nodeVolumes returns the volumes currently mounted on one node.68func (h *clusterHandlers) nodeVolumes(ctx context.Context, acc *clAccess, now time.Time, nodeID uuid.UUID) ([]Volume, error) {69 rows, err := h.Pool.Query(ctx, `select `+clVolumeCols+clVolumeFrom+` where v.node_id = $1 and v.gone_at is null order by v.mount limit 64`, nodeID)70 if err != nil {71 return nil, err72 }73 list, err := pgx.CollectRows(rows, func(r pgx.CollectableRow) (clVolume, error) { return clScanVolume(r) })74 if err != nil {75 return nil, err76 }77 out := make([]Volume, 0, len(list))78 for i := range list {79 out = append(out, h.toVolume(&list[i], now, acc))80 }81 return out, nil82}8384func (h *clusterHandlers) ListVolumes(ctx context.Context, req ListVolumesRequestObject) (ListVolumesResponseObject, error) {85 p := req.Params86 limit, err := clLimit(p.Limit)87 if err != nil {88 return nil, err89 }90 acc, err := h.clAccessFor(ctx)91 if err != nil {92 return nil, err93 }94 b := &clSQL{}95 b.and("n.retired_at is null")96 if p.NodeId != nil {97 b.and("v.node_id = " + b.arg(*p.NodeId))98 }99 if p.Kind != nil {100 if *p.Kind != VolumeKindInternal && *p.Kind != VolumeKindExternal && *p.Kind != VolumeKindNetwork {101 return nil, clInvalid("kind", "must be internal, external or network")102 }103 b.and("v.kind = " + b.arg(string(*p.Kind)))104 }105 if p.MinUsedPct != nil {106 if *p.MinUsedPct < 0 || *p.MinUsedPct > 100 || *p.MinUsedPct != *p.MinUsedPct {107 return nil, clInvalid("min_used_pct", "must be between 0 and 100")108 }109 // Volumes whose usage was not observed cannot satisfy a usage filter.110 b.and("v.total_bytes > 0 and v.used_bytes is not null and v.used_bytes::float8 * 100 / v.total_bytes >= " + b.arg(float64(*p.MinUsedPct)))111 }112 cur, err := clDecodeCursor(p.Cursor, "volumes", 3)113 if err != nil {114 return nil, err115 }116 orderBy, err := b.clKeyset(clVolumeKey, "text", "v.id", false, cur)117 if err != nil {118 return nil, err119 }120 rows, err := h.Pool.Query(ctx, `select `+clVolumeCols+`, `+clVolumeKey+clVolumeFrom+b.where()+orderBy+` limit `+b.arg(limit+1), b.args...)121 if err != nil {122 return nil, err123 }124 type row struct {125 v clVolume126 key string127 }128 list, err := pgx.CollectRows(rows, func(r pgx.CollectableRow) (row, error) {129 var x row130 var err error131 x.v, err = clScanVolume(r, &x.key)132 return x, err133 })134 if err != nil {135 return nil, err136 }137 out := VolumeList{Items: make([]Volume, 0, len(list))}138 if len(list) > limit {139 list = list[:limit]140 out.NextCursor = clEncodeCursor("volumes", "0", list[limit-1].key, list[limit-1].v.ID.String())141 }142 now := time.Now().UTC()143 filter := acc.scoped(authz.NodesRead)144 for i := range list {145 v := &list[i].v146 if filter && !acc.can(authz.NodesRead, clNodeFacets(v.NodeID, v.Site, v.Tags)...) {147 continue148 }149 out.Items = append(out.Items, h.toVolume(v, now, acc))150 }151 return ListVolumes200JSONResponse{Body: out}, nil152}153154// ── NAS targets ────────────────────────────────────────────────────────────155156// clNasStaleAfter: an observation older than this no longer says anything157// about the present, so the state is reported as unknown (state_at still158// tells when the NAS was last observed).159const clNasStaleAfter = 15 * time.Minute160161const clNasCols = `id, name, host(host), share, protocol, note, state, state_at, observed_by, latency_ms::float8, mounted_on, total_bytes, used_bytes`162163type clNas struct {164 ID uuid.UUID165 Name string166 Host string167 Share string168 Protocol string169 Note string170 State string171 StateAt *time.Time172 ObservedBy *uuid.UUID173 LatencyMS *float64174 MountedOn int175 Total *int64176 Used *int64177}178179func clScanNas(row pgx.Row) (clNas, error) {180 var n clNas181 err := row.Scan(&n.ID, &n.Name, &n.Host, &n.Share, &n.Protocol, &n.Note, &n.State, &n.StateAt, &n.ObservedBy, &n.LatencyMS, &n.MountedOn, &n.Total, &n.Used)182 return n, err183}184185// clNasState is the state that can be asserted now: online or offline only186// with a recent observation.187func clNasState(state string, at *time.Time, now time.Time) NasTargetState {188 if at == nil || now.Sub(*at) > clNasStaleAfter {189 return NasTargetStateUnknown190 }191 switch NasTargetState(state) {192 case NasTargetStateOnline, NasTargetStateOffline:193 return NasTargetState(state)194 }195 return NasTargetStateUnknown196}197198func clToNas(n *clNas, now time.Time, private bool) NasTarget {199 out := NasTarget{Id: n.ID, Name: n.Name, Share: n.Share, Protocol: NasTargetProtocolSmb, Note: n.Note, State: clNasState(n.State, n.StateAt, now),200 StateAt: n.StateAt, ObservedBy: n.ObservedBy, MountedOn: n.MountedOn, TotalBytes: n.Total, UsedBytes: n.Used}201 if n.Protocol == "nfs" || n.Protocol == "afp" {202 out.Protocol = NasTargetProtocol(n.Protocol)203 }204 if private {205 out.Host = &n.Host206 }207 if out.State == NasTargetStateOnline {208 out.LatencyMs = clF32(n.LatencyMS)209 } else {210 out.MountedOn = 0 // nothing is known to have it mounted right now211 }212 return out213}214215func (h *clusterHandlers) ListNasTargets(ctx context.Context, _ ListNasTargetsRequestObject) (ListNasTargetsResponseObject, error) {216 acc, err := h.clAccessFor(ctx)217 if err != nil {218 return nil, err219 }220 rows, err := h.Pool.Query(ctx, `select `+clNasCols+` from nas_targets order by lower(name), id limit 500`)221 if err != nil {222 return nil, err223 }224 list, err := pgx.CollectRows(rows, func(r pgx.CollectableRow) (clNas, error) { return clScanNas(r) })225 if err != nil {226 return nil, err227 }228 now, private := time.Now().UTC(), acc.can(authz.NodesPrivateRead)229 out := NasTargetList{Items: make([]NasTarget, 0, len(list))}230 for i := range list {231 out.Items = append(out.Items, clToNas(&list[i], now, private))232 }233 return ListNasTargets200JSONResponse{Body: out}, nil234}235236func (h *clusterHandlers) CreateNasTarget(ctx context.Context, req CreateNasTargetRequestObject) (CreateNasTargetResponseObject, error) {237 if req.Body == nil {238 return nil, httpx.Validation("Body required.")239 }240 b := req.Body241 name, err := clText("name", &b.Name, 1, 64)242 if err != nil {243 return nil, err244 }245 addr, err := netip.ParseAddr(b.Host)246 if err != nil || addr.Zone() != "" || addr.IsUnspecified() || addr.IsMulticast() {247 return nil, clInvalid("host", "must be an IPv4 or IPv6 address")248 }249 addr = addr.Unmap()250 share, err := clText("share", b.Share, 0, 120)251 if err != nil {252 return nil, err253 }254 note, err := clText("note", b.Note, 0, 500)255 if err != nil {256 return nil, err257 }258 proto := "smb"259 if b.Protocol != nil {260 switch *b.Protocol {261 case CreateNasTargetRequestProtocolSmb, CreateNasTargetRequestProtocolNfs, CreateNasTargetRequestProtocolAfp:262 proto = string(*b.Protocol)263 default:264 return nil, clInvalid("protocol", "must be smb, nfs or afp")265 }266 }267 acc, err := h.clAccessFor(ctx)268 if err != nil {269 return nil, err270 }271 id := ids.New()272 tx, err := h.Pool.Begin(ctx)273 if err != nil {274 return nil, err275 }276 defer tx.Rollback(ctx)277 // case-insensitive uniqueness of the name, on top of the table's exact one278 var clash bool279 if err := tx.QueryRow(ctx, `select exists (select 1 from nas_targets where lower(name) = lower($1))`, name).Scan(&clash); err != nil {280 return nil, err281 }282 if clash {283 return nil, clConflict("A NAS target with this name already exists.")284 }285 _, err = tx.Exec(ctx, `insert into nas_targets(id, name, host, share, protocol, note) values ($1, $2, $3::inet, $4, $5, $6)`,286 id, name, addr.String(), share, proto, note)287 if clUniqueViolation(err) {288 return nil, clConflict("A NAS target with this name already exists.")289 } else if err != nil {290 return nil, err291 }292 // The host is recorded in the audit log: registering an address is the point of the action.293 if err := h.audit(ctx, tx, "nas.create", "nas", id.String(), audit.Success, "",294 map[string]any{"name": name, "host": addr.String(), "share": share, "protocol": proto}); err != nil {295 return nil, err296 }297 n, err := clScanNas(tx.QueryRow(ctx, `select `+clNasCols+` from nas_targets where id = $1`, id))298 if err != nil {299 return nil, err300 }301 if err := tx.Commit(ctx); err != nil {302 return nil, err303 }304 return CreateNasTarget201JSONResponse{Body: clToNas(&n, time.Now().UTC(), acc.can(authz.NodesPrivateRead))}, nil305}306307func (h *clusterHandlers) DeleteNasTarget(ctx context.Context, req DeleteNasTargetRequestObject) (DeleteNasTargetResponseObject, error) {308 tx, err := h.Pool.Begin(ctx)309 if err != nil {310 return nil, err311 }312 defer tx.Rollback(ctx)313 var name string314 err = tx.QueryRow(ctx, `delete from nas_targets where id = $1 returning name`, req.Id).Scan(&name) // observations cascade315 if errors.Is(err, pgx.ErrNoRows) {316 return nil, httpx.ErrNotFound317 } else if err != nil {318 return nil, err319 }320 if err := h.audit(ctx, tx, "nas.delete", "nas", req.Id.String(), audit.Success, "", map[string]any{"name": name}); err != nil {321 return nil, err322 }323 if err := tx.Commit(ctx); err != nil {324 return nil, err325 }326 return DeleteNasTarget204Response{}, nil327}328329// ── Backups ────────────────────────────────────────────────────────────────330331// clBackupStatus never upgrades an unrecognized word to "ok".332func clBackupStatus(s string) BackupLastStatus {333 switch BackupLastStatus(s) {334 case BackupLastStatusOk, BackupLastStatusFailed:335 return BackupLastStatus(s)336 }337 return BackupLastStatusUnknown338}339340func (h *clusterHandlers) ListBackups(ctx context.Context, _ ListBackupsRequestObject) (ListBackupsResponseObject, error) {341 rows, err := h.Pool.Query(ctx, `select b.id, b.name, b.node_id, n.alias::text, b.kind, b.last_run_at, b.last_success_at, b.last_status,342 b.size_bytes, b.detail, b.observed_at343 from backups b left join nodes n on n.id = b.node_id order by lower(b.name), b.id limit 500`)344 if err != nil {345 return nil, err346 }347 items, err := pgx.CollectRows(rows, func(r pgx.CollectableRow) (Backup, error) {348 var b Backup349 var status string350 err := r.Scan(&b.Id, &b.Name, &b.NodeId, &b.NodeAlias, &b.Kind, &b.LastRunAt, &b.LastSuccessAt, &status, &b.SizeBytes, &b.Detail, &b.ObservedAt)351 b.LastStatus = clBackupStatus(status)352 return b, err353 })354 if err != nil {355 return nil, err356 }357 if items == nil {358 items = []Backup{}359 }360 return ListBackups200JSONResponse{Body: BackupList{Items: items}}, nil361}362