The running pre-G indexer publishes a repository's packages only when every package directory it published last is
still in the tree; G moved contracts/go and sdk to modules/, so mesh-delivery's packages, G's renamed paths among them,
are never published and nothing importing them builds (2026-11-13, indexer journal 'its packages are not published').
These are the trees of e70754ef, unchanged, without sdk/module.json (no second module). Nothing imports them; they go
once G's indexer runs and publishes without them.
Claude-Session: https://claude.ai/code/session_01NcbgfGKaxw984XyAPfLm4h
123 lines
4.4 KiB
Go
123 lines
4.4 KiB
Go
package parts
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"crypto/sha256"
|
|
"encoding/hex"
|
|
"io"
|
|
"strings"
|
|
"testing"
|
|
)
|
|
|
|
// A file travels in parts (ADR 0611, ADR 0627 §2, design 51 *Publishing*; SDK-1), both sides in one test, since
|
|
// mesh-sdk is over its test budget: the sender's and the holder's (aHolderTakesAFileInParts, receive_test.go).
|
|
func TestAFileTravelsInTheParts(t *testing.T) {
|
|
t.Run("the sender sends only what the holder lacks", theSenderSendsOnlyWhatTheHolderLacks)
|
|
t.Run("a holder takes a file in parts", aHolderTakesAFileInParts)
|
|
}
|
|
|
|
// Only the parts the holder says it lacks are read and sent, each in chunks of at most MaxChunk in sequence with the
|
|
// last marked, so a cut transfer opened again goes on from what the holder holds; a part whose bytes are not its
|
|
// digest is refused before any of it travels.
|
|
func theSenderSendsOnlyWhatTheHolderLacks(t *testing.T) {
|
|
big := bytes.Repeat([]byte("x"), MaxChunk+10)
|
|
small, empty := []byte("config"), []byte{}
|
|
part := func(b []byte, opened *int) Part {
|
|
sum := sha256.Sum256(b)
|
|
return Part{Digest: "sha256:" + hex.EncodeToString(sum[:]), Size: int64(len(b)),
|
|
Open: func() (io.ReadCloser, error) { *opened++; return io.NopCloser(bytes.NewReader(b)), nil }}
|
|
}
|
|
type chunk struct {
|
|
part string
|
|
seq int64
|
|
last bool
|
|
data []byte
|
|
}
|
|
type receiver struct {
|
|
open Open
|
|
chunk Chunk
|
|
}
|
|
holder := func(lacks []string, got *[]chunk, asked *[]string) receiver {
|
|
return receiver{
|
|
open: func(_ context.Context, ps []Part) (Opened, error) {
|
|
*asked = append(*asked, "open")
|
|
return Opened{Lacks: lacks, Held: len(lacks) == 0}, nil
|
|
},
|
|
chunk: func(_ context.Context, part string, seq int, last bool, data []byte) error {
|
|
if len(data) > MaxChunk {
|
|
t.Errorf("a chunk is %d bytes, over MaxChunk", len(data))
|
|
}
|
|
*got = append(*got, chunk{part, int64(seq), last, append([]byte(nil), data...)})
|
|
return nil
|
|
},
|
|
}
|
|
}
|
|
var opens [3]int
|
|
parts := []Part{part(big, &opens[0]), part(small, &opens[1]), part(empty, &opens[2])}
|
|
|
|
for _, c := range []struct {
|
|
name string
|
|
lacks []int
|
|
chunks int
|
|
err string
|
|
}{
|
|
{"a fresh transfer sends every part, the big one in two chunks and the empty one as one", []int{0, 1, 2}, 4, ""},
|
|
{"a cut transfer opened again sends only what the holder lacks", []int{2}, 1, ""},
|
|
{"a digest the holder holds sends nothing", nil, 0, ""},
|
|
} {
|
|
opens = [3]int{}
|
|
var lacks []string
|
|
for _, i := range c.lacks {
|
|
lacks = append(lacks, parts[i].Digest)
|
|
}
|
|
var got []chunk
|
|
var asked []string
|
|
r := holder(lacks, &got, &asked)
|
|
sent, err := Send(context.Background(), r.open, r.chunk, parts)
|
|
if err != nil || sent.Chunks != c.chunks || len(got) != c.chunks || len(sent.Parts) != len(c.lacks) {
|
|
t.Errorf("%s: sent %+v, %d chunks heard, %v", c.name, sent, len(got), err)
|
|
continue
|
|
}
|
|
for i := range parts {
|
|
want := 0
|
|
for _, l := range c.lacks {
|
|
if l == i {
|
|
want = 2 // read once to check its digest, once to send it
|
|
}
|
|
}
|
|
if opens[i] != want {
|
|
t.Errorf("%s: part %d read %d times, want %d", c.name, i, opens[i], want)
|
|
}
|
|
}
|
|
whole := map[string][]byte{}
|
|
for i, ch := range got {
|
|
whole[ch.part] = append(whole[ch.part], ch.data...)
|
|
lastOfPart := i == len(got)-1 || got[i+1].part != ch.part
|
|
if ch.last != lastOfPart || (i > 0 && got[i-1].part == ch.part && got[i-1].seq+1 != ch.seq) {
|
|
t.Errorf("%s: chunk %d of %s is %d, last %v", c.name, i, ch.part[:12], ch.seq, ch.last)
|
|
}
|
|
}
|
|
for _, l := range c.lacks {
|
|
if p := parts[l]; int64(len(whole[p.Digest])) != p.Size {
|
|
t.Errorf("%s: part %d arrived as %d bytes of %d", c.name, l, len(whole[p.Digest]), p.Size)
|
|
}
|
|
}
|
|
}
|
|
|
|
// A part whose bytes are not its digest travels not at all; a part the holder names that the transfer does not is
|
|
// refused, naming it.
|
|
liar := part(small, &opens[1])
|
|
liar.Digest = parts[0].Digest
|
|
var got []chunk
|
|
var asked []string
|
|
r := holder([]string{liar.Digest}, &got, &asked)
|
|
if _, err := Send(context.Background(), r.open, r.chunk, []Part{liar}); err == nil || len(got) != 0 || !strings.Contains(err.Error(), "nothing of it is sent") {
|
|
t.Errorf("a part not its digest: %v, %d chunks sent", err, len(got))
|
|
}
|
|
r = holder([]string{"sha256:" + strings.Repeat("f", 64)}, &got, &asked)
|
|
if _, err := Send(context.Background(), r.open, r.chunk, parts); err == nil || !strings.Contains(err.Error(), "does not name") {
|
|
t.Errorf("a part the transfer does not name: %v", err)
|
|
}
|
|
}
|