+22

refstore/reftable/TODO

reviewed

··· 1 1 + * One-time load -> immutable snapshots and such; publish only fully loaded 2 2 + snapshots. 3 3 + * Reload behavior for tables.list; read tables.list, open all listed tables, 4 4 + and retry from the start if any listed table is missing during open. 5 5 + * Snapshot staleness detection 6 6 + * Resolve's block search should be restart aware. Then the linear scan is only 7 7 + within the chosen restart window. 8 8 + * Cache parsed index-block metadata per table and block offset. Reuse restart 9 9 + offsets and decoded key boundaries across lookups to try to reduce repeated 10 10 + parsing. 11 11 + * Pin one snapshot for each high-level read call. ResolveFully should resolve 12 12 + all symbolic hops against one snapshot and avoid repeated ensure/reload 13 13 + checks per hop. 14 14 + * Add lazy snapshot-derived caches for list-heavy operations. Build visible 15 15 + merged refs and sorted names once per snapshot, and reuse for List and 16 16 + Shorten. 17 17 + * Make format parser stricter to match Git-level behavior. Validate unaligned 18 18 + multi-ref-block tables require ref index, and enforce more precise 19 19 + first-block/restart invariants where applicable. 20 20 + * Improve parse and lookup diagnostics with contextual errors. Return 21 21 + fmt.Errorf values that include table name, block offset, and record offset, 22 22 + where possible.

+424

refstore/reftable/lookup.go

reviewed

··· 1 1 + package reftable 2 2 + 3 3 + import ( 4 4 + "encoding/binary" 5 5 + "fmt" 6 6 + "strings" 7 7 + 8 8 + "codeberg.org/lindenii/furgit/objectid" 9 9 + ) 10 10 + 11 11 + // resolveRecord resolves one ref name inside a single table file. 12 12 + func (table *tableFile) resolveRecord(name string) (recordValue, bool, error) { 13 13 + if table.refIndexPos != 0 { 14 14 + pos, ok, err := table.resolveRefBlockPosFromIndex(name, int(table.refIndexPos)) 15 15 + if err != nil { 16 16 + return recordValue{}, false, err 17 17 + } 18 18 + if !ok { 19 19 + return recordValue{}, false, nil 20 20 + } 21 21 + return table.lookupInRefBlock(name, pos) 22 22 + } 23 23 + 24 24 + // Without a ref index, fall back to scanning ref blocks in order. 25 25 + pos := table.headerLen 26 26 + for pos < table.refEnd { 27 27 + for pos < table.refEnd && table.data[pos] == 0 { 28 28 + pos++ 29 29 + } 30 30 + if pos >= table.refEnd { 31 31 + break 32 32 + } 33 33 + if table.data[pos] != blockTypeRef { 34 34 + return recordValue{}, false, fmt.Errorf("refstore/reftable: table %q: unexpected block type %q in ref section", table.name, table.data[pos]) 35 35 + } 36 36 + block, blockEnd, err := table.readBlockAt(pos) 37 37 + if err != nil { 38 38 + return recordValue{}, false, err 39 39 + } 40 40 + found, done, rec, err := lookupRecordInRefBlock(table, block, name) 41 41 + if err != nil { 42 42 + return recordValue{}, false, err 43 43 + } 44 44 + if found { 45 45 + return rec, true, nil 46 46 + } 47 47 + if done { 48 48 + return recordValue{}, false, nil 49 49 + } 50 50 + pos = table.nextBlockPos(blockEnd) 51 51 + } 52 52 + return recordValue{}, false, nil 53 53 + } 54 54 + 55 55 + // resolveRefBlockPosFromIndex resolves a candidate ref block position via index blocks. 56 56 + func (table *tableFile) resolveRefBlockPosFromIndex(name string, indexPos int) (int, bool, error) { 57 57 + block, _, err := table.readBlockAt(indexPos) 58 58 + if err != nil { 59 59 + return 0, false, err 60 60 + } 61 61 + if block.blockType != blockTypeIndex { 62 62 + return 0, false, fmt.Errorf("refstore/reftable: table %q: ref index root is not index block", table.name) 63 63 + } 64 64 + childPos, ok, err := lookupChildPosInIndexBlock(block, name) 65 65 + if err != nil { 66 66 + return 0, false, err 67 67 + } 68 68 + if !ok { 69 69 + return 0, false, nil 70 70 + } 71 71 + if childPos < 0 || childPos >= len(table.data) { 72 72 + return 0, false, fmt.Errorf("refstore/reftable: table %q: index child position out of range", table.name) 73 73 + } 74 74 + 75 75 + childType := table.data[childPos] 76 76 + switch childType { 77 77 + case blockTypeRef: 78 78 + return childPos, true, nil 79 79 + case blockTypeIndex: 80 80 + return table.resolveRefBlockPosFromIndex(name, childPos) 81 81 + default: 82 82 + return 0, false, fmt.Errorf("refstore/reftable: table %q: unexpected child block type %q", table.name, childType) 83 83 + } 84 84 + } 85 85 + 86 86 + // lookupInRefBlock searches one ref block by full ref name. 87 87 + func (table *tableFile) lookupInRefBlock(name string, pos int) (recordValue, bool, error) { 88 88 + block, _, err := table.readBlockAt(pos) 89 89 + if err != nil { 90 90 + return recordValue{}, false, err 91 91 + } 92 92 + if block.blockType != blockTypeRef { 93 93 + return recordValue{}, false, fmt.Errorf("refstore/reftable: table %q: expected ref block at %d", table.name, pos) 94 94 + } 95 95 + found, _, rec, err := lookupRecordInRefBlock(table, block, name) 96 96 + if err != nil { 97 97 + return recordValue{}, false, err 98 98 + } 99 99 + return rec, found, nil 100 100 + } 101 101 + 102 102 + // forEachRecord iterates all ref records in this table in lexical order. 103 103 + func (table *tableFile) forEachRecord(fn func(name string, rec recordValue) error) error { 104 104 + pos := table.headerLen 105 105 + prevLast := "" 106 106 + for pos < table.refEnd { 107 107 + for pos < table.refEnd && table.data[pos] == 0 { 108 108 + pos++ 109 109 + } 110 110 + if pos >= table.refEnd { 111 111 + break 112 112 + } 113 113 + if table.data[pos] != blockTypeRef { 114 114 + return fmt.Errorf("refstore/reftable: table %q: unexpected block type %q in ref section", table.name, table.data[pos]) 115 115 + } 116 116 + 117 117 + block, blockEnd, err := table.readBlockAt(pos) 118 118 + if err != nil { 119 119 + return err 120 120 + } 121 121 + var first, last string 122 122 + err = forEachRecordInRefBlock(table, block, func(name string, rec recordValue) error { 123 123 + if first == "" { 124 124 + first = name 125 125 + } 126 126 + last = name 127 127 + return fn(name, rec) 128 128 + }) 129 129 + if err != nil { 130 130 + return err 131 131 + } 132 132 + if prevLast != "" && first != "" && strings.Compare(first, prevLast) <= 0 { 133 133 + return fmt.Errorf("refstore/reftable: table %q: ref blocks are not strictly ordered", table.name) 134 134 + } 135 135 + if last != "" { 136 136 + prevLast = last 137 137 + } 138 138 + pos = table.nextBlockPos(blockEnd) 139 139 + } 140 140 + return nil 141 141 + } 142 142 + 143 143 + // blockView is one decoded block boundary within the mapped table bytes. 144 144 + type blockView struct { 145 145 + blockType byte 146 146 + start int 147 147 + end int 148 148 + first bool 149 149 + payload []byte 150 150 + } 151 151 + 152 152 + // readBlockAt validates and returns a block view starting at pos. 153 153 + func (table *tableFile) readBlockAt(pos int) (blockView, int, error) { 154 154 + if pos < 0 || pos+4 > len(table.data) { 155 155 + return blockView{}, 0, fmt.Errorf("refstore/reftable: table %q: block header out of range", table.name) 156 156 + } 157 157 + blockLen := int(readUint24(table.data[pos+1 : pos+4])) 158 158 + effectiveLen := blockLen 159 159 + if pos == table.headerLen { 160 160 + if blockLen < table.headerLen { 161 161 + return blockView{}, 0, fmt.Errorf("refstore/reftable: table %q: invalid first block length", table.name) 162 162 + } 163 163 + effectiveLen = blockLen - table.headerLen 164 164 + } 165 165 + if effectiveLen < 4 { 166 166 + return blockView{}, 0, fmt.Errorf("refstore/reftable: table %q: invalid block length", table.name) 167 167 + } 168 168 + end := pos + effectiveLen 169 169 + if end > len(table.data) { 170 170 + return blockView{}, 0, fmt.Errorf("refstore/reftable: table %q: block out of range", table.name) 171 171 + } 172 172 + view := blockView{blockType: table.data[pos], start: pos, end: end, first: pos == table.headerLen, payload: table.data[pos:end]} 173 173 + return view, end, nil 174 174 + } 175 175 + 176 176 + // nextBlockPos computes the next block start from current block end. 177 177 + func (table *tableFile) nextBlockPos(blockEnd int) int { 178 178 + if table.blockSize > 0 { 179 179 + return alignUp(blockEnd, table.blockSize) 180 180 + } 181 181 + return blockEnd 182 182 + } 183 183 + 184 184 + // lookupChildPosInIndexBlock selects a child block position for key. 185 185 + func lookupChildPosInIndexBlock(block blockView, key string) (int, bool, error) { 186 186 + off, recordsEnd, restarts, err := parseBlockLayout(block) 187 187 + if err != nil { 188 188 + return 0, false, err 189 189 + } 190 190 + if err := validateRestarts(block, restarts, off, recordsEnd, true); err != nil { 191 191 + return 0, false, err 192 192 + } 193 193 + prev := "" 194 194 + for off < recordsEnd { 195 195 + name, v, nextOff, err := parseKeyedRecord(block.payload, off, recordsEnd, prev) 196 196 + if err != nil { 197 197 + return 0, false, err 198 198 + } 199 199 + if (v & 0x7) != 0 { 200 200 + return 0, false, fmt.Errorf("index value_type must be 0") 201 201 + } 202 202 + childPos, nextOff, err := readVarint(block.payload, nextOff, recordsEnd) 203 203 + if err != nil { 204 204 + return 0, false, err 205 205 + } 206 206 + if strings.Compare(key, name) <= 0 { 207 207 + if childPos > uint64(int(^uint(0)>>1)) { 208 208 + return 0, false, fmt.Errorf("index child position overflows int") 209 209 + } 210 210 + return int(childPos), true, nil 211 211 + } 212 212 + prev = name 213 213 + off = nextOff 214 214 + } 215 215 + if off != recordsEnd { 216 216 + return 0, false, fmt.Errorf("malformed index block") 217 217 + } 218 218 + return 0, false, nil 219 219 + } 220 220 + 221 221 + // lookupRecordInRefBlock searches one ref block and may short-circuit by sort order. 222 222 + func lookupRecordInRefBlock(table *tableFile, block blockView, key string) (found bool, done bool, rec recordValue, err error) { 223 223 + off, recordsEnd, restarts, err := parseBlockLayout(block) 224 224 + if err != nil { 225 225 + return false, false, recordValue{}, err 226 226 + } 227 227 + if err := validateRestarts(block, restarts, off, recordsEnd, true); err != nil { 228 228 + return false, false, recordValue{}, err 229 229 + } 230 230 + prev := "" 231 231 + for off < recordsEnd { 232 232 + name, v, nextOff, err := parseKeyedRecord(block.payload, off, recordsEnd, prev) 233 233 + if err != nil { 234 234 + return false, false, recordValue{}, err 235 235 + } 236 236 + typeBits := byte(v & 0x7) 237 237 + _, nextOff, err = readVarint(block.payload, nextOff, recordsEnd) 238 238 + if err != nil { 239 239 + return false, false, recordValue{}, err 240 240 + } 241 241 + recVal, nextOff, err := parseRefValue(block.payload, nextOff, recordsEnd, table.algo, typeBits) 242 242 + if err != nil { 243 243 + return false, false, recordValue{}, err 244 244 + } 245 245 + cmp := strings.Compare(name, key) 246 246 + if cmp == 0 { 247 247 + return true, true, recVal, nil 248 248 + } 249 249 + if cmp > 0 { 250 250 + return false, true, recordValue{}, nil 251 251 + } 252 252 + prev = name 253 253 + off = nextOff 254 254 + } 255 255 + if off != recordsEnd { 256 256 + return false, false, recordValue{}, fmt.Errorf("malformed ref block") 257 257 + } 258 258 + return false, false, recordValue{}, nil 259 259 + } 260 260 + 261 261 + // forEachRecordInRefBlock iterates all records in one ref block. 262 262 + func forEachRecordInRefBlock(table *tableFile, block blockView, fn func(name string, rec recordValue) error) error { 263 263 + off, recordsEnd, restarts, err := parseBlockLayout(block) 264 264 + if err != nil { 265 265 + return err 266 266 + } 267 267 + if err := validateRestarts(block, restarts, off, recordsEnd, true); err != nil { 268 268 + return err 269 269 + } 270 270 + prev := "" 271 271 + for off < recordsEnd { 272 272 + name, v, nextOff, err := parseKeyedRecord(block.payload, off, recordsEnd, prev) 273 273 + if err != nil { 274 274 + return err 275 275 + } 276 276 + typeBits := byte(v & 0x7) 277 277 + _, nextOff, err = readVarint(block.payload, nextOff, recordsEnd) 278 278 + if err != nil { 279 279 + return err 280 280 + } 281 281 + recVal, nextOff, err := parseRefValue(block.payload, nextOff, recordsEnd, table.algo, typeBits) 282 282 + if err != nil { 283 283 + return err 284 284 + } 285 285 + if err := fn(name, recVal); err != nil { 286 286 + return err 287 287 + } 288 288 + prev = name 289 289 + off = nextOff 290 290 + } 291 291 + if off != recordsEnd { 292 292 + return fmt.Errorf("malformed ref block") 293 293 + } 294 294 + return nil 295 295 + } 296 296 + 297 297 + // parseBlockLayout parses common record/restart regions for ref and index blocks. 298 298 + func parseBlockLayout(block blockView) (recordsStart int, recordsEnd int, restarts []int, err error) { 299 299 + if len(block.payload) < 6 { 300 300 + return 0, 0, nil, fmt.Errorf("short block") 301 301 + } 302 302 + restartCount := int(binary.BigEndian.Uint16(block.payload[len(block.payload)-2:])) 303 303 + if restartCount <= 0 { 304 304 + return 0, 0, nil, fmt.Errorf("invalid restart count") 305 305 + } 306 306 + restarts = make([]int, restartCount) 307 307 + restartBytes := restartCount * 3 308 308 + restartsStart := len(block.payload) - 2 - restartBytes 309 309 + if restartsStart < 4 { 310 310 + return 0, 0, nil, fmt.Errorf("invalid restart table") 311 311 + } 312 312 + for i := 0; i < restartCount; i++ { 313 313 + off := restartsStart + i*3 314 314 + rel := int(readUint24(block.payload[off : off+3])) 315 315 + base := block.start 316 316 + if block.first { 317 317 + // In the first block, restart offsets are relative to file start. 318 318 + base = 0 319 319 + } 320 320 + abs := base + rel 321 321 + restarts[i] = abs - block.start 322 322 + } 323 323 + return 4, restartsStart, restarts, nil 324 324 + } 325 325 + 326 326 + // validateRestarts validates restart monotonicity, bounds and record-prefix invariants. 327 327 + func validateRestarts(block blockView, restarts []int, recordsStart, recordsEnd int, requirePrefixZero bool) error { 328 328 + prev := -1 329 329 + for _, off := range restarts { 330 330 + if off < recordsStart || off >= recordsEnd { 331 331 + return fmt.Errorf("restart offset out of range") 332 332 + } 333 333 + if off <= prev { 334 334 + return fmt.Errorf("restart offsets not strictly increasing") 335 335 + } 336 336 + prev = off 337 337 + if requirePrefixZero { 338 338 + prefix, _, err := readVarint(block.payload, off, recordsEnd) 339 339 + if err != nil { 340 340 + return err 341 341 + } 342 342 + if prefix != 0 { 343 343 + return fmt.Errorf("restart record prefix length must be zero") 344 344 + } 345 345 + } 346 346 + } 347 347 + return nil 348 348 + } 349 349 + 350 350 + // parseKeyedRecord parses one prefix-compressed key record header. 351 351 + func parseKeyedRecord(buf []byte, off, end int, prev string) (name string, rawType uint64, next int, err error) { 352 352 + prefixLen, next, err := readVarint(buf, off, end) 353 353 + if err != nil { 354 354 + return "", 0, 0, err 355 355 + } 356 356 + suffixAndType, next, err := readVarint(buf, next, end) 357 357 + if err != nil { 358 358 + return "", 0, 0, err 359 359 + } 360 360 + suffixLen := int(suffixAndType >> 3) 361 361 + if suffixLen < 0 || next+suffixLen > end { 362 362 + return "", 0, 0, fmt.Errorf("invalid suffix length") 363 363 + } 364 364 + if int(prefixLen) > len(prev) { 365 365 + return "", 0, 0, fmt.Errorf("invalid prefix length") 366 366 + } 367 367 + name = prev[:prefixLen] + string(buf[next:next+suffixLen]) 368 368 + next += suffixLen 369 369 + if prev != "" && strings.Compare(name, prev) <= 0 { 370 370 + return "", 0, 0, fmt.Errorf("keys not strictly increasing") 371 371 + } 372 372 + return name, suffixAndType, next, nil 373 373 + } 374 374 + 375 375 + // parseRefValue parses one ref-record value payload according to value_type. 376 376 + func parseRefValue(buf []byte, off, end int, algo objectid.Algorithm, valueType byte) (recordValue, int, error) { 377 377 + switch valueType { 378 378 + case 0x0: 379 379 + return recordValue{deleted: true}, off, nil 380 380 + case 0x1: 381 381 + id, next, err := readObjectID(buf, off, end, algo) 382 382 + if err != nil { 383 383 + return recordValue{}, 0, err 384 384 + } 385 385 + return recordValue{detachedID: id, hasDetached: true}, next, nil 386 386 + case 0x2: 387 387 + id, next, err := readObjectID(buf, off, end, algo) 388 388 + if err != nil { 389 389 + return recordValue{}, 0, err 390 390 + } 391 391 + peeled, next, err := readObjectID(buf, next, end, algo) 392 392 + if err != nil { 393 393 + return recordValue{}, 0, err 394 394 + } 395 395 + peeledCopy := peeled 396 396 + return recordValue{detachedID: id, hasDetached: true, peeled: &peeledCopy}, next, nil 397 397 + case 0x3: 398 398 + targetLen, next, err := readVarint(buf, off, end) 399 399 + if err != nil { 400 400 + return recordValue{}, 0, err 401 401 + } 402 402 + if targetLen > uint64(end-next) { 403 403 + return recordValue{}, 0, fmt.Errorf("invalid symref target length") 404 404 + } 405 405 + target := string(buf[next : next+int(targetLen)]) 406 406 + next += int(targetLen) 407 407 + return recordValue{symbolicTarget: target}, next, nil 408 408 + default: 409 409 + return recordValue{}, 0, fmt.Errorf("unsupported ref value type %d", valueType) 410 410 + } 411 411 + } 412 412 + 413 413 + // readObjectID reads one object ID using the table algorithm width. 414 414 + func readObjectID(buf []byte, off, end int, algo objectid.Algorithm) (objectid.ObjectID, int, error) { 415 415 + sz := algo.Size() 416 416 + if off < 0 || sz < 0 || off+sz > end { 417 417 + return objectid.ObjectID{}, 0, fmt.Errorf("truncated object id") 418 418 + } 419 419 + id, err := objectid.FromBytes(algo, buf[off:off+sz]) 420 420 + if err != nil { 421 421 + return objectid.ObjectID{}, 0, err 422 422 + } 423 423 + return id, off + sz, nil 424 424 + }

+36

refstore/reftable/parse_helpers.go

reviewed

··· 1 1 + package reftable 2 2 + 3 3 + import "fmt" 4 4 + 5 5 + // readUint24 reads a 24-bit big-endian unsigned integer. 6 6 + func readUint24(b []byte) uint32 { 7 7 + return uint32(b[0])<<16 | uint32(b[1])<<8 | uint32(b[2]) 8 8 + } 9 9 + 10 10 + // alignUp rounds pos up to the next multiple of blockSize. 11 11 + func alignUp(pos, blockSize int) int { 12 12 + rem := pos % blockSize 13 13 + if rem == 0 { 14 14 + return pos 15 15 + } 16 16 + return pos + (blockSize - rem) 17 17 + } 18 18 + 19 19 + // readVarint decodes one reftable/ofs-delta style varint. 20 20 + func readVarint(buf []byte, off, end int) (uint64, int, error) { 21 21 + if off >= end { 22 22 + return 0, 0, fmt.Errorf("unexpected EOF") 23 23 + } 24 24 + b := buf[off] 25 25 + val := uint64(b & 0x7f) 26 26 + off++ 27 27 + for b&0x80 != 0 { 28 28 + if off >= end { 29 29 + return 0, 0, fmt.Errorf("unexpected EOF") 30 30 + } 31 31 + b = buf[off] 32 32 + off++ 33 33 + val = ((val + 1) << 7) | uint64(b&0x7f) 34 34 + } 35 35 + return val, off, nil 36 36 + }

+8

refstore/reftable/path.go

reviewed

··· 1 1 + package reftable 2 2 + 3 3 + import "path" 4 4 + 5 5 + // pathMatch applies path.Match to full ref names. 6 6 + func pathMatch(pattern, name string) (bool, error) { 7 7 + return path.Match(pattern, name) 8 8 + }

+172

refstore/reftable/reftable_test.go

reviewed

··· 1 1 + package reftable_test 2 2 + 3 3 + import ( 4 4 + "errors" 5 5 + "os" 6 6 + "path/filepath" 7 7 + "slices" 8 8 + "testing" 9 9 + 10 10 + "codeberg.org/lindenii/furgit/internal/testgit" 11 11 + "codeberg.org/lindenii/furgit/objectid" 12 12 + "codeberg.org/lindenii/furgit/ref" 13 13 + "codeberg.org/lindenii/furgit/refstore" 14 14 + "codeberg.org/lindenii/furgit/refstore/reftable" 15 15 + ) 16 16 + 17 17 + // newBareReftableRepo creates a bare repository that uses reftable ref storage. 18 18 + func newBareReftableRepo(tb testing.TB, algo objectid.Algorithm) *testgit.TestRepo { 19 19 + tb.Helper() 20 20 + return testgit.NewRepo(tb, algo, testgit.RepoOptions{Bare: true, RefFormat: "reftable"}) 21 21 + } 22 22 + 23 23 + // openStore opens a reftable store against repoDir/reftable. 24 24 + func openStore(tb testing.TB, repoDir string, algo objectid.Algorithm) *reftable.Store { 25 25 + tb.Helper() 26 26 + root, err := os.OpenRoot(filepath.Join(repoDir, "reftable")) 27 27 + if err != nil { 28 28 + tb.Fatalf("OpenRoot(reftable): %v", err) 29 29 + } 30 30 + tb.Cleanup(func() { _ = root.Close() }) 31 31 + store, err := reftable.New(root, algo) 32 32 + if err != nil { 33 33 + tb.Fatalf("reftable.New: %v", err) 34 34 + } 35 35 + return store 36 36 + } 37 37 + 38 38 + func TestResolveAndResolveFully(t *testing.T) { 39 39 + testgit.ForEachAlgorithm(t, func(t *testing.T, algo objectid.Algorithm) { 40 40 + repo := newBareReftableRepo(t, algo) 41 41 + _, _, id := repo.MakeCommit(t, "resolve") 42 42 + repo.UpdateRef(t, "refs/heads/main", id) 43 43 + repo.SymbolicRef(t, "HEAD", "refs/heads/main") 44 44 + 45 45 + store := openStore(t, repo.Dir(), algo) 46 46 + head, err := store.Resolve("HEAD") 47 47 + if err != nil { 48 48 + t.Fatalf("Resolve(HEAD): %v", err) 49 49 + } 50 50 + sym, ok := head.(ref.Symbolic) 51 51 + if !ok { 52 52 + t.Fatalf("Resolve(HEAD) type = %T, want ref.Symbolic", head) 53 53 + } 54 54 + if sym.Target != "refs/heads/main" { 55 55 + t.Fatalf("Resolve(HEAD) target = %q, want refs/heads/main", sym.Target) 56 56 + } 57 57 + 58 58 + main, err := store.ResolveFully("HEAD") 59 59 + if err != nil { 60 60 + t.Fatalf("ResolveFully(HEAD): %v", err) 61 61 + } 62 62 + if main.ID != id { 63 63 + t.Fatalf("ResolveFully(HEAD) id = %s, want %s", main.ID, id) 64 64 + } 65 65 + 66 66 + if _, err := store.Resolve("refs/heads/missing"); !errors.Is(err, refstore.ErrReferenceNotFound) { 67 67 + t.Fatalf("Resolve(missing) error = %v", err) 68 68 + } 69 69 + }) 70 70 + } 71 71 + 72 72 + func TestResolveFullyCycle(t *testing.T) { 73 73 + testgit.ForEachAlgorithm(t, func(t *testing.T, algo objectid.Algorithm) { 74 74 + repo := newBareReftableRepo(t, algo) 75 75 + repo.SymbolicRef(t, "refs/heads/a", "refs/heads/b") 76 76 + repo.SymbolicRef(t, "refs/heads/b", "refs/heads/a") 77 77 + 78 78 + store := openStore(t, repo.Dir(), algo) 79 79 + if _, err := store.ResolveFully("refs/heads/a"); err == nil { 80 80 + t.Fatalf("ResolveFully(cycle) expected error") 81 81 + } 82 82 + }) 83 83 + } 84 84 + 85 85 + func TestListAndShorten(t *testing.T) { 86 86 + testgit.ForEachAlgorithm(t, func(t *testing.T, algo objectid.Algorithm) { 87 87 + repo := newBareReftableRepo(t, algo) 88 88 + _, _, id := repo.MakeCommit(t, "list") 89 89 + repo.UpdateRef(t, "refs/heads/main", id) 90 90 + repo.UpdateRef(t, "refs/heads/feature", id) 91 91 + repo.UpdateRef(t, "refs/tags/main", id) 92 92 + repo.UpdateRef(t, "refs/remotes/origin/main", id) 93 93 + 94 94 + store := openStore(t, repo.Dir(), algo) 95 95 + all, err := store.List("") 96 96 + if err != nil { 97 97 + t.Fatalf("List(all): %v", err) 98 98 + } 99 99 + names := make([]string, 0, len(all)) 100 100 + for _, entry := range all { 101 101 + names = append(names, entry.Name()) 102 102 + } 103 103 + want := []string{"HEAD", "refs/heads/feature", "refs/heads/main", "refs/remotes/origin/main", "refs/tags/main"} 104 104 + if !slices.Equal(names, want) { 105 105 + t.Fatalf("List(all) = %v, want %v", names, want) 106 106 + } 107 107 + 108 108 + heads, err := store.List("refs/heads/*") 109 109 + if err != nil { 110 110 + t.Fatalf("List(heads): %v", err) 111 111 + } 112 112 + headNames := make([]string, 0, len(heads)) 113 113 + for _, entry := range heads { 114 114 + headNames = append(headNames, entry.Name()) 115 115 + } 116 116 + wantHeads := []string{"refs/heads/feature", "refs/heads/main"} 117 117 + if !slices.Equal(headNames, wantHeads) { 118 118 + t.Fatalf("List(heads) = %v, want %v", headNames, wantHeads) 119 119 + } 120 120 + 121 121 + short, err := store.Shorten("refs/remotes/origin/main") 122 122 + if err != nil { 123 123 + t.Fatalf("Shorten(remote): %v", err) 124 124 + } 125 125 + if short != "origin/main" { 126 126 + t.Fatalf("Shorten(remote) = %q, want origin/main", short) 127 127 + } 128 128 + }) 129 129 + } 130 130 + 131 131 + func TestTombstoneNewestWins(t *testing.T) { 132 132 + testgit.ForEachAlgorithm(t, func(t *testing.T, algo objectid.Algorithm) { 133 133 + repo := newBareReftableRepo(t, algo) 134 134 + _, _, oldID := repo.MakeCommit(t, "old") 135 135 + repo.UpdateRef(t, "refs/heads/main", oldID) 136 136 + _, _, newID := repo.MakeCommit(t, "new") 137 137 + repo.UpdateRef(t, "refs/heads/main", newID) 138 138 + repo.DeleteRef(t, "refs/heads/main") 139 139 + 140 140 + store := openStore(t, repo.Dir(), algo) 141 141 + if _, err := store.Resolve("refs/heads/main"); !errors.Is(err, refstore.ErrReferenceNotFound) { 142 142 + t.Fatalf("Resolve(main) after delete error = %v", err) 143 143 + } 144 144 + }) 145 145 + } 146 146 + 147 147 + func TestAnnotatedTagPeeled(t *testing.T) { 148 148 + testgit.ForEachAlgorithm(t, func(t *testing.T, algo objectid.Algorithm) { 149 149 + repo := newBareReftableRepo(t, algo) 150 150 + _, _, commitID := repo.MakeCommit(t, "tagged") 151 151 + tagID := repo.TagAnnotated(t, "v1.0.0", commitID, "annotated") 152 152 + 153 153 + store := openStore(t, repo.Dir(), algo) 154 154 + resolved, err := store.Resolve("refs/tags/v1.0.0") 155 155 + if err != nil { 156 156 + t.Fatalf("Resolve(tag): %v", err) 157 157 + } 158 158 + detached, ok := resolved.(ref.Detached) 159 159 + if !ok { 160 160 + t.Fatalf("Resolve(tag) type = %T, want ref.Detached", resolved) 161 161 + } 162 162 + if detached.ID != tagID { 163 163 + t.Fatalf("Resolve(tag) id = %s, want %s", detached.ID, tagID) 164 164 + } 165 165 + if detached.Peeled == nil { 166 166 + t.Fatalf("Resolve(tag) peeled = nil") 167 167 + } 168 168 + if *detached.Peeled != commitID { 169 169 + t.Fatalf("Resolve(tag) peeled = %s, want %s", *detached.Peeled, commitID) 170 170 + } 171 171 + }) 172 172 + }

+266

refstore/reftable/store.go

reviewed

··· 1 1 + // Package reftable provides read access to Git reftable reference storage. 2 2 + // This store is experimental, has many issues, and should not be used in any serious capacity for now. 3 3 + package reftable 4 4 + 5 5 + import ( 6 6 + "errors" 7 7 + "os" 8 8 + "sort" 9 9 + "strings" 10 10 + "sync" 11 11 + 12 12 + "codeberg.org/lindenii/furgit/objectid" 13 13 + "codeberg.org/lindenii/furgit/ref" 14 14 + "codeberg.org/lindenii/furgit/refstore" 15 15 + ) 16 16 + 17 17 + // Store reads references from a reftable stack rooted at $GIT_DIR/reftable. 18 18 + // 19 19 + // Store does not own root. Callers are responsible for closing root. 20 20 + type Store struct { 21 21 + // root is the reftable directory capability. 22 22 + root *os.Root 23 23 + // algo is the repository object ID algorithm. 24 24 + algo objectid.Algorithm 25 25 + 26 26 + // loadOnce ensures tables.list and table handles are loaded once. 27 27 + loadOnce sync.Once 28 28 + // loadErr stores loading failure from loadOnce. 29 29 + loadErr error 30 30 + 31 31 + // stateMu guards tables publication and close transitions. 32 32 + stateMu sync.RWMutex 33 33 + // tables are loaded in oldest-to-newest order from tables.list. 34 34 + tables []*tableFile 35 35 + // closed reports whether Close has been called. 36 36 + closed bool 37 37 + } 38 38 + 39 39 + var _ refstore.Store = (*Store)(nil) 40 40 + 41 41 + // New creates a read-only reftable store rooted at $GIT_DIR/reftable. 42 42 + func New(root *os.Root, algo objectid.Algorithm) (*Store, error) { 43 43 + if algo.Size() == 0 { 44 44 + return nil, objectid.ErrInvalidAlgorithm 45 45 + } 46 46 + return &Store{root: root, algo: algo}, nil 47 47 + } 48 48 + 49 49 + // Close releases mapped table resources associated with this store. 50 50 + func (store *Store) Close() error { 51 51 + store.stateMu.Lock() 52 52 + if store.closed { 53 53 + store.stateMu.Unlock() 54 54 + return nil 55 55 + } 56 56 + store.closed = true 57 57 + tables := store.tables 58 58 + store.tables = nil 59 59 + store.stateMu.Unlock() 60 60 + 61 61 + var closeErr error 62 62 + for _, table := range tables { 63 63 + if table == nil { 64 64 + continue 65 65 + } 66 66 + if err := table.close(); err != nil && closeErr == nil { 67 67 + closeErr = err 68 68 + } 69 69 + } 70 70 + return closeErr 71 71 + } 72 72 + 73 73 + // Resolve resolves a reference name to either a symbolic or detached ref. 74 74 + func (store *Store) Resolve(name string) (ref.Ref, error) { 75 75 + tables, err := store.ensureTables() 76 76 + if err != nil { 77 77 + return nil, err 78 78 + } 79 79 + for i := len(tables) - 1; i >= 0; i-- { 80 80 + rec, found, err := tables[i].resolveRecord(name) 81 81 + if err != nil { 82 82 + return nil, err 83 83 + } 84 84 + if !found { 85 85 + continue 86 86 + } 87 87 + if rec.deleted { 88 88 + return nil, refstore.ErrReferenceNotFound 89 89 + } 90 90 + resolved, err := rec.toRef(name) 91 91 + if err != nil { 92 92 + return nil, err 93 93 + } 94 94 + return resolved, nil 95 95 + } 96 96 + return nil, refstore.ErrReferenceNotFound 97 97 + } 98 98 + 99 99 + // ResolveFully resolves symbolic references until it reaches a detached value. 100 100 + // 101 101 + // ResolveFully resolves symbolic references only. It does not imply peeling 102 102 + // annotated tag objects. 103 103 + func (store *Store) ResolveFully(name string) (ref.Detached, error) { 104 104 + seen := map[string]struct{}{} 105 105 + cur := name 106 106 + for { 107 107 + if _, exists := seen[cur]; exists { 108 108 + return ref.Detached{}, errors.New("refstore/reftable: symbolic reference cycle") 109 109 + } 110 110 + seen[cur] = struct{}{} 111 111 + resolved, err := store.Resolve(cur) 112 112 + if err != nil { 113 113 + return ref.Detached{}, err 114 114 + } 115 115 + switch resolved := resolved.(type) { 116 116 + case ref.Detached: 117 117 + return resolved, nil 118 118 + case ref.Symbolic: 119 119 + if resolved.Target == "" { 120 120 + return ref.Detached{}, errors.New("refstore/reftable: symbolic reference has empty target") 121 121 + } 122 122 + cur = resolved.Target 123 123 + default: 124 124 + return ref.Detached{}, errors.New("refstore/reftable: unsupported reference type") 125 125 + } 126 126 + } 127 127 + } 128 128 + 129 129 + // List returns references matching pattern. 130 130 + // 131 131 + // Pattern uses path.Match syntax against full reference names. 132 132 + // Empty pattern matches all references. 133 133 + func (store *Store) List(pattern string) ([]ref.Ref, error) { 134 134 + tables, err := store.ensureTables() 135 135 + if err != nil { 136 136 + return nil, err 137 137 + } 138 138 + visible := make(map[string]ref.Ref) 139 139 + masked := make(map[string]struct{}) 140 140 + 141 141 + for i := len(tables) - 1; i >= 0; i-- { 142 142 + if err := tables[i].forEachRecord(func(name string, rec recordValue) error { 143 143 + if _, done := masked[name]; done { 144 144 + return nil 145 145 + } 146 146 + masked[name] = struct{}{} 147 147 + if rec.deleted { 148 148 + return nil 149 149 + } 150 150 + resolved, err := rec.toRef(name) 151 151 + if err != nil { 152 152 + return err 153 153 + } 154 154 + visible[name] = resolved 155 155 + return nil 156 156 + }); err != nil { 157 157 + return nil, err 158 158 + } 159 159 + } 160 160 + 161 161 + matchAll := pattern == "" 162 162 + if !matchAll { 163 163 + if _, err := pathMatch(pattern, "refs/heads/main"); err != nil { 164 164 + return nil, err 165 165 + } 166 166 + } 167 167 + 168 168 + names := make([]string, 0, len(visible)) 169 169 + for name := range visible { 170 170 + names = append(names, name) 171 171 + } 172 172 + sort.Strings(names) 173 173 + 174 174 + out := make([]ref.Ref, 0, len(names)) 175 175 + for _, name := range names { 176 176 + if !matchAll { 177 177 + ok, err := pathMatch(pattern, name) 178 178 + if err != nil { 179 179 + return nil, err 180 180 + } 181 181 + if !ok { 182 182 + continue 183 183 + } 184 184 + } 185 185 + out = append(out, visible[name]) 186 186 + } 187 187 + return out, nil 188 188 + } 189 189 + 190 190 + // Shorten returns the shortest unambiguous shorthand for a full reference name. 191 191 + func (store *Store) Shorten(name string) (string, error) { 192 192 + refs, err := store.List("") 193 193 + if err != nil { 194 194 + return "", err 195 195 + } 196 196 + names := make([]string, 0, len(refs)) 197 197 + found := false 198 198 + for _, entry := range refs { 199 199 + if entry == nil { 200 200 + continue 201 201 + } 202 202 + full := entry.Name() 203 203 + names = append(names, full) 204 204 + if full == name { 205 205 + found = true 206 206 + } 207 207 + } 208 208 + if !found { 209 209 + return "", refstore.ErrReferenceNotFound 210 210 + } 211 211 + return refstore.ShortenName(name, names), nil 212 212 + } 213 213 + 214 214 + // ensureTables loads and validates tables listed by tables.list once. 215 215 + func (store *Store) ensureTables() ([]*tableFile, error) { 216 216 + store.loadOnce.Do(func() { 217 217 + tables, err := store.loadTables() 218 218 + store.stateMu.Lock() 219 219 + store.tables = tables 220 220 + store.loadErr = err 221 221 + store.stateMu.Unlock() 222 222 + }) 223 223 + 224 224 + store.stateMu.RLock() 225 225 + defer store.stateMu.RUnlock() 226 226 + if store.closed { 227 227 + return nil, errors.New("refstore/reftable: store is closed") 228 228 + } 229 229 + return store.tables, store.loadErr 230 230 + } 231 231 + 232 232 + // loadTables reads tables.list and opens all listed tables. 233 233 + func (store *Store) loadTables() ([]*tableFile, error) { 234 234 + listRaw, err := store.root.ReadFile("tables.list") 235 235 + if err != nil { 236 236 + if errors.Is(err, os.ErrNotExist) { 237 237 + return nil, nil 238 238 + } 239 239 + return nil, err 240 240 + } 241 241 + lines := strings.Split(string(listRaw), "\n") 242 242 + names := make([]string, 0, len(lines)) 243 243 + for _, line := range lines { 244 244 + line = strings.TrimSuffix(line, "\r") 245 245 + if line == "" { 246 246 + continue 247 247 + } 248 248 + if strings.Contains(line, "/") { 249 249 + return nil, errors.New("refstore/reftable: invalid table name") 250 250 + } 251 251 + names = append(names, line) 252 252 + } 253 253 + 254 254 + out := make([]*tableFile, 0, len(names)) 255 255 + for _, name := range names { 256 256 + table, err := openTableFile(store.root, name, store.algo) 257 257 + if err != nil { 258 258 + for _, opened := range out { 259 259 + _ = opened.close() 260 260 + } 261 261 + return nil, err 262 262 + } 263 263 + out = append(out, table) 264 264 + } 265 265 + return out, nil 266 266 + }

+231

refstore/reftable/table.go

reviewed

··· 1 1 + package reftable 2 2 + 3 3 + import ( 4 4 + "encoding/binary" 5 5 + "errors" 6 6 + "fmt" 7 7 + "hash/crc32" 8 8 + "os" 9 9 + "syscall" 10 10 + 11 11 + "codeberg.org/lindenii/furgit/objectid" 12 12 + "codeberg.org/lindenii/furgit/ref" 13 13 + ) 14 14 + 15 15 + const ( 16 16 + reftableMagic = "REFT" 17 17 + 18 18 + version1 = 1 19 19 + version2 = 2 20 20 + 21 21 + blockTypeRef = byte('r') 22 22 + blockTypeIndex = byte('i') 23 23 + ) 24 24 + 25 25 + var ( 26 26 + hashIDSHA1 = binary.BigEndian.Uint32([]byte("sha1")) 27 27 + hashIDSHA256 = binary.BigEndian.Uint32([]byte("s256")) 28 28 + ) 29 29 + 30 30 + // tableFile is one opened and mapped reftable file. 31 31 + type tableFile struct { 32 32 + // name is the table filename from tables.list. 33 33 + name string 34 34 + // algo is the expected object ID algorithm. 35 35 + algo objectid.Algorithm 36 36 + 37 37 + // file is the opened table file. 38 38 + file *os.File 39 39 + // data is the mapped table bytes. 40 40 + data []byte 41 41 + 42 42 + // headerLen is 24 for v1 or 28 for v2. 43 43 + headerLen int 44 44 + // blockSize is configured alignment; 0 means unaligned. 45 45 + blockSize int 46 46 + 47 47 + // refEnd is the exclusive end of ref blocks section. 48 48 + refEnd int 49 49 + // refIndexPos is the root ref-index block position, or 0 when absent. 50 50 + refIndexPos uint64 51 51 + } 52 52 + 53 53 + // recordValue is one decoded reference record value. 54 54 + type recordValue struct { 55 55 + // deleted marks a tombstone record. 56 56 + deleted bool 57 57 + // detachedID stores a direct object ID for detached refs. 58 58 + detachedID objectid.ObjectID 59 59 + // hasDetached reports whether detachedID is valid. 60 60 + hasDetached bool 61 61 + // peeled stores an optional peeled ID for annotated tags. 62 62 + peeled *objectid.ObjectID 63 63 + // symbolicTarget stores symref target for symbolic refs. 64 64 + symbolicTarget string 65 65 + } 66 66 + 67 67 + // openTableFile maps and validates one reftable file. 68 68 + func openTableFile(root *os.Root, name string, algo objectid.Algorithm) (*tableFile, error) { 69 69 + file, err := root.Open(name) 70 70 + if err != nil { 71 71 + return nil, err 72 72 + } 73 73 + info, err := file.Stat() 74 74 + if err != nil { 75 75 + _ = file.Close() 76 76 + return nil, err 77 77 + } 78 78 + size := info.Size() 79 79 + if size < 0 || size > int64(int(^uint(0)>>1)) { 80 80 + _ = file.Close() 81 81 + return nil, fmt.Errorf("refstore/reftable: table %q has unsupported size", name) 82 82 + } 83 83 + data, err := syscall.Mmap(int(file.Fd()), 0, int(size), syscall.PROT_READ, syscall.MAP_PRIVATE) 84 84 + if err != nil { 85 85 + _ = file.Close() 86 86 + return nil, err 87 87 + } 88 88 + out := &tableFile{name: name, algo: algo, file: file, data: data} 89 89 + if err := out.parseMeta(); err != nil { 90 90 + _ = out.close() 91 91 + return nil, err 92 92 + } 93 93 + return out, nil 94 94 + } 95 95 + 96 96 + // close unmaps and closes one table file. 97 97 + func (table *tableFile) close() error { 98 98 + var closeErr error 99 99 + if table.data != nil { 100 100 + if err := syscall.Munmap(table.data); err != nil && closeErr == nil { 101 101 + closeErr = err 102 102 + } 103 103 + table.data = nil 104 104 + } 105 105 + if table.file != nil { 106 106 + if err := table.file.Close(); err != nil && closeErr == nil { 107 107 + closeErr = err 108 108 + } 109 109 + table.file = nil 110 110 + } 111 111 + return closeErr 112 112 + } 113 113 + 114 114 + // parseMeta validates header/footer and section boundaries. 115 115 + func (table *tableFile) parseMeta() error { 116 116 + if len(table.data) < 24 { 117 117 + return fmt.Errorf("refstore/reftable: table %q: file too short", table.name) 118 118 + } 119 119 + if string(table.data[:4]) != reftableMagic { 120 120 + return fmt.Errorf("refstore/reftable: table %q: bad magic", table.name) 121 121 + } 122 122 + version := table.data[4] 123 123 + switch version { 124 124 + case version1: 125 125 + table.headerLen = 24 126 126 + if table.algo != objectid.AlgorithmSHA1 { 127 127 + return fmt.Errorf("refstore/reftable: table %q: version 1 requires sha1", table.name) 128 128 + } 129 129 + case version2: 130 130 + table.headerLen = 28 131 131 + if len(table.data) < table.headerLen { 132 132 + return fmt.Errorf("refstore/reftable: table %q: truncated header", table.name) 133 133 + } 134 134 + hashID := binary.BigEndian.Uint32(table.data[24:28]) 135 135 + if err := validateHashID(hashID, table.algo); err != nil { 136 136 + return fmt.Errorf("refstore/reftable: table %q: %w", table.name, err) 137 137 + } 138 138 + default: 139 139 + return fmt.Errorf("refstore/reftable: table %q: unsupported version %d", table.name, version) 140 140 + } 141 141 + table.blockSize = int(readUint24(table.data[5:8])) 142 142 + 143 143 + footerLen := 68 144 144 + if version == version2 { 145 145 + footerLen = 72 146 146 + } 147 147 + if len(table.data) < footerLen { 148 148 + return fmt.Errorf("refstore/reftable: table %q: missing footer", table.name) 149 149 + } 150 150 + footerStart := len(table.data) - footerLen 151 151 + footer := table.data[footerStart:] 152 152 + if string(footer[:4]) != reftableMagic || footer[4] != version { 153 153 + return fmt.Errorf("refstore/reftable: table %q: invalid footer header", table.name) 154 154 + } 155 155 + wantCRC := binary.BigEndian.Uint32(footer[footerLen-4:]) 156 156 + haveCRC := crc32.ChecksumIEEE(footer[:footerLen-4]) 157 157 + if wantCRC != haveCRC { 158 158 + return fmt.Errorf("refstore/reftable: table %q: footer crc mismatch", table.name) 159 159 + } 160 160 + if version == version2 { 161 161 + hashID := binary.BigEndian.Uint32(footer[24:28]) 162 162 + if err := validateHashID(hashID, table.algo); err != nil { 163 163 + return fmt.Errorf("refstore/reftable: table %q: %w", table.name, err) 164 164 + } 165 165 + } 166 166 + 167 167 + off := table.headerLen 168 168 + table.refIndexPos = binary.BigEndian.Uint64(footer[off : off+8]) 169 169 + off += 8 170 170 + objPosAndLen := binary.BigEndian.Uint64(footer[off : off+8]) 171 171 + off += 8 172 172 + objPos := objPosAndLen >> 5 173 173 + objIndexPos := binary.BigEndian.Uint64(footer[off : off+8]) 174 174 + off += 8 175 175 + logPos := binary.BigEndian.Uint64(footer[off : off+8]) 176 176 + off += 8 177 177 + logIndexPos := binary.BigEndian.Uint64(footer[off : off+8]) 178 178 + _ = objIndexPos 179 179 + _ = logIndexPos 180 180 + 181 181 + refEnd := uint64(footerStart) 182 182 + if table.refIndexPos != 0 && table.refIndexPos < refEnd { 183 183 + refEnd = table.refIndexPos 184 184 + } 185 185 + if objPos != 0 && objPos < refEnd { 186 186 + refEnd = objPos 187 187 + } 188 188 + if logPos != 0 && logPos < refEnd { 189 189 + refEnd = logPos 190 190 + } 191 191 + if refEnd < uint64(table.headerLen) || refEnd > uint64(len(table.data)) { 192 192 + return fmt.Errorf("refstore/reftable: table %q: invalid ref section", table.name) 193 193 + } 194 194 + if table.refIndexPos > uint64(len(table.data)) { 195 195 + return fmt.Errorf("refstore/reftable: table %q: invalid ref index position", table.name) 196 196 + } 197 197 + table.refEnd = int(refEnd) 198 198 + return nil 199 199 + } 200 200 + 201 201 + // validateHashID validates a reftable v2 hash identifier. 202 202 + func validateHashID(hashID uint32, algo objectid.Algorithm) error { 203 203 + switch hashID { 204 204 + case hashIDSHA1: 205 205 + if algo != objectid.AlgorithmSHA1 { 206 206 + return errors.New("hash id sha1 mismatch") 207 207 + } 208 208 + return nil 209 209 + case hashIDSHA256: 210 210 + if algo != objectid.AlgorithmSHA256 { 211 211 + return errors.New("hash id s256 mismatch") 212 212 + } 213 213 + return nil 214 214 + default: 215 215 + return fmt.Errorf("unknown hash id 0x%08x", hashID) 216 216 + } 217 217 + } 218 218 + 219 219 + // toRef converts a decoded record value into a public ref value. 220 220 + func (record recordValue) toRef(name string) (ref.Ref, error) { 221 221 + if record.deleted { 222 222 + return nil, errors.New("refstore/reftable: cannot materialize deleted record") 223 223 + } 224 224 + if record.symbolicTarget != "" { 225 225 + return ref.Symbolic{RefName: name, Target: record.symbolicTarget}, nil 226 226 + } 227 227 + if !record.hasDetached { 228 228 + return nil, errors.New("refstore/reftable: malformed detached record") 229 229 + } 230 230 + return ref.Detached{RefName: name, ID: record.detachedID, Peeled: record.peeled}, nil 231 231 + }