follow

ExampleDir tails a whole WAL directory, following rotation: it reads the current file and, when that file is finalised, switches to the next file in the chain — indefinitely, until the context is cancelled. A directory follow must be given a start position (here, the head of the chain). This example breaks out after the two rows it knows are present; a real consumer keeps ranging until it cancels the context.

dir, err := os.MkdirTemp("", "follow-dir")
if err != nil {
	log.Fatal(err)
}

// Two finalised files forming a chain: file 2's PrevVClock == file 1's VClock.
writeExampleChainFile(dir, format.VClock{1: 1}, nil, 1)
writeExampleChainFile(dir, format.VClock{1: 2}, format.VClock{1: 1}, 2)

ctx, cancel := context.WithCancel(context.Background())

seq := follow.Dir(ctx, dir, format.FiletypeXLOG, follow.WithFromHead())

n := 0

for r, err := range seq {
	if err != nil {
		log.Fatal(err)
	}

	fmt.Printf("replica %d lsn %d\n", r.ReplicaID, r.LSN)

	if n++; n == 2 {
		break // stop following (a real consumer would cancel on its own condition)
	}
}

cancel()

_ = os.RemoveAll(dir)

Output:
replica 1 lsn 1
replica 1 lsn 2

ExampleFile tails a single .xlog file. It blocks for rows as they are appended and ends when the file is finalised (its EOF marker is written). Here the file is already complete, so the follow drains it and stops.

dir, err := os.MkdirTemp("", "follow-file")
if err != nil {
	log.Fatal(err)
}

path := filepath.Join(dir, "00000000000000000000.xlog")
writeExampleFile(path, 1, 2, 3)

// Tail it: the loop yields each row, then ends at the EOF marker.
for r, err := range follow.File(context.Background(), path) {
	if err != nil {
		log.Fatal(err)
	}

	fmt.Println(r.LSN)
}

_ = os.RemoveAll(dir)

Output:
1
2
3