snapshot of https://github.com/seaweedfs/seaweedfs.git (master, 2026-09-16; blobs > 131072B omitted)

weed/storage/super_block/replica_placement.go

@@ -0,0 +1,126 @@
+package super_block
+
+import (
+	"fmt"
+
+	"github.com/seaweedfs/seaweedfs/weed/glog"
+)
+
+type ReplicaPlacement struct {
+	SameRackCount       int `json:"node,omitempty"`
+	DiffRackCount       int `json:"rack,omitempty"`
+	DiffDataCenterCount int `json:"dc,omitempty"`
+}
+
+func NewReplicaPlacementFromString(t string) (*ReplicaPlacement, error) {
+	rp := &ReplicaPlacement{}
+	switch len(t) {
+	case 0:
+		t = "000"
+	case 1:
+		t = "00" + t
+	case 2:
+		t = "0" + t
+	}
+	for i, c := range t {
+		count := int(c - '0')
+		if count < 0 {
+			return rp, fmt.Errorf("unknown replication type: %s", t)
+		}
+		switch i {
+		case 0:
+			rp.DiffDataCenterCount = count
+		case 1:
+			rp.DiffRackCount = count
+		case 2:
+			rp.SameRackCount = count
+		}
+	}
+	value := rp.DiffDataCenterCount*100 + rp.DiffRackCount*10 + rp.SameRackCount
+	if value > 255 {
+		return rp, fmt.Errorf("unexpected replication type: %s", t)
+	}
+	return rp, nil
+}
+
+// replicaPlacementsByByte is one 6KB pointer-free array covering every encoding
+// a byte can hold. The master decodes one per volume in every volume server
+// heartbeat and keeps it for the volume's lifetime, so handing out a shared
+// element keeps that path off fmt and off the heap entirely.
+//
+// Elements are immutable. Callers must not write through the returned pointer.
+var replicaPlacementsByByte [256]ReplicaPlacement
+
+func init() {
+	for b := range replicaPlacementsByByte {
+		replicaPlacementsByByte[b] = ReplicaPlacement{
+			DiffDataCenterCount: b / 100,
+			DiffRackCount:       b / 10 % 10,
+			SameRackCount:       b % 10,
+		}
+	}
+}
+
+func NewReplicaPlacementFromByte(b byte) (*ReplicaPlacement, error) {
+	return &replicaPlacementsByByte[b], nil
+}
+
+func (rp *ReplicaPlacement) HasReplication() bool {
+	return rp.DiffDataCenterCount != 0 || rp.DiffRackCount != 0 || rp.SameRackCount != 0
+}
+
+func (a *ReplicaPlacement) Equals(b *ReplicaPlacement) bool {
+	if a == nil || b == nil {
+		return false
+	}
+	return (a.SameRackCount == b.SameRackCount &&
+		a.DiffRackCount == b.DiffRackCount &&
+		a.DiffDataCenterCount == b.DiffDataCenterCount)
+}
+
+func (rp *ReplicaPlacement) Byte() byte {
+	if rp == nil {
+		return 0
+	}
+	ret := rp.DiffDataCenterCount*100 + rp.DiffRackCount*10 + rp.SameRackCount
+	return byte(ret)
+}
+
+func (rp *ReplicaPlacement) String() string {
+	if rp == nil {
+		return ""
+	}
+	b := make([]byte, 3)
+	b[0] = byte(rp.DiffDataCenterCount + '0')
+	b[1] = byte(rp.DiffRackCount + '0')
+	b[2] = byte(rp.SameRackCount + '0')
+	return string(b)
+}
+
+func (rp *ReplicaPlacement) GetCopyCount() int {
+	return rp.DiffDataCenterCount + rp.DiffRackCount + rp.SameRackCount + 1
+}
+
+// ResolveReplicaPlacement picks the EC shard replica placement constraint: an
+// explicit spec wins; otherwise the cluster default (typically the master's
+// configured default replication). A missing, invalid, or zero-replication value
+// yields nil, meaning even spread / no constraint. Shared by EC encode, repair,
+// and balance so the three resolve replica placement identically.
+func ResolveReplicaPlacement(explicitSpec, clusterDefault string) *ReplicaPlacement {
+	spec := explicitSpec
+	if spec == "" {
+		spec = clusterDefault
+	}
+	if spec == "" {
+		return nil
+	}
+	rp, err := NewReplicaPlacementFromString(spec)
+	if err != nil {
+		glog.Warningf("ignoring invalid replica placement %q: %v", spec, err)
+		return nil
+	}
+	if !rp.HasReplication() {
+		return nil
+	}
+	return rp
+}

weed/storage/super_block/replica_placement_test.go

@@ -0,0 +1,63 @@
+package super_block
+
+import (
+	"fmt"
+	"testing"
+)
+
+func TestReplicaPlacementFromByteMatchesString(t *testing.T) {
+	for b := 0; b < 256; b++ {
+		want, err := NewReplicaPlacementFromString(fmt.Sprintf("%03d", b))
+		if err != nil {
+			t.Fatalf("byte %d: %v", b, err)
+		}
+		got, err := NewReplicaPlacementFromByte(byte(b))
+		if err != nil {
+			t.Fatalf("byte %d: %v", b, err)
+		}
+		if !got.Equals(want) {
+			t.Errorf("byte %d: got %+v, want %+v", b, got, want)
+		}
+		if got.Byte() != byte(b) {
+			t.Errorf("byte %d: round trip gave %d", b, got.Byte())
+		}
+	}
+}
+
+func TestReplicaPlacementSerialDeserial(t *testing.T) {
+	rp, _ := NewReplicaPlacementFromString("001")
+	newRp, _ := NewReplicaPlacementFromByte(rp.Byte())
+	if rp.String() != newRp.String() {
+		println("expected:", rp.String(), "actual:", newRp.String())
+		t.Fail()
+	}
+}
+
+func TestReplicaPlacementHasReplication(t *testing.T) {
+	testCases := []struct {
+		name             string
+		replicaPlacement string
+		want             bool
+	}{
+		{"empty replica placement", "", false},
+		{"no replication", "000", false},
+		{"same rack replication", "100", true},
+		{"diff rack replication", "020", true},
+		{"DC replication", "003", true},
+		{"full replication", "155", true},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			rp, err := NewReplicaPlacementFromString(tc.replicaPlacement)
+			if err != nil {
+				t.Errorf("failed to initialize ReplicaPlacement: %v", err)
+				return
+			}
+
+			if got, want := rp.HasReplication(), tc.want; got != want {
+				t.Errorf("expected %v, got %v", want, got)
+			}
+		})
+	}
+}

weed/storage/super_block/super_block.go

@@ -0,0 +1,69 @@
+package super_block
+
+import (
+	"google.golang.org/protobuf/proto"
+
+	"github.com/seaweedfs/seaweedfs/weed/glog"
+	"github.com/seaweedfs/seaweedfs/weed/pb/master_pb"
+	"github.com/seaweedfs/seaweedfs/weed/storage/needle"
+	"github.com/seaweedfs/seaweedfs/weed/util"
+)
+
+const (
+	SuperBlockSize = 8
+)
+
+/*
+* Super block currently has 8 bytes allocated for each volume.
+* Byte 0: version, 1 or 2
+* Byte 1: Replica Placement strategy, 000, 001, 002, 010, etc
+* Byte 2 and byte 3: Time to live. See TTL for definition
+* Byte 4 and byte 5: The number of times the volume has been compacted.
+* Rest bytes: Reserved
+ */
+type SuperBlock struct {
+	Version            needle.Version
+	ReplicaPlacement   *ReplicaPlacement
+	Ttl                *needle.TTL
+	CompactionRevision uint16
+	Extra              *master_pb.SuperBlockExtra
+	ExtraSize          uint16
+}
+
+func (s *SuperBlock) BlockSize() int {
+	switch s.Version {
+	case needle.Version2, needle.Version3:
+		return SuperBlockSize + int(s.ExtraSize)
+	}
+	return SuperBlockSize
+}
+
+func (s *SuperBlock) Bytes() []byte {
+	header := make([]byte, SuperBlockSize)
+	header[0] = byte(s.Version)
+	header[1] = s.ReplicaPlacement.Byte()
+	s.Ttl.ToBytes(header[2:4])
+	util.Uint16toBytes(header[4:6], s.CompactionRevision)
+
+	if s.Extra != nil {
+		extraData, err := proto.Marshal(s.Extra)
+		if err != nil {
+			glog.Fatalf("cannot marshal super block extra %+v: %v", s.Extra, err)
+		}
+		extraSize := len(extraData)
+		if extraSize > 256*256-2 {
+			// reserve a couple of bits for future extension
+			glog.Fatalf("super block extra size is %d bigger than %d", extraSize, 256*256-2)
+		}
+		s.ExtraSize = uint16(extraSize)
+		util.Uint16toBytes(header[6:8], s.ExtraSize)
+
+		header = append(header, extraData...)
+	}
+
+	return header
+}
+
+func (s *SuperBlock) Initialized() bool {
+	return s.ReplicaPlacement != nil && s.Ttl != nil
+}

weed/storage/super_block/super_block_read.go.go

@@ -0,0 +1,46 @@
+package super_block
+
+import (
+	"fmt"
+
+	"google.golang.org/protobuf/proto"
+
+	"github.com/seaweedfs/seaweedfs/weed/pb/master_pb"
+	"github.com/seaweedfs/seaweedfs/weed/storage/backend"
+	"github.com/seaweedfs/seaweedfs/weed/storage/needle"
+	"github.com/seaweedfs/seaweedfs/weed/util"
+)
+
+// ReadSuperBlock reads from data file and load it into volume's super block
+func ReadSuperBlock(datBackend backend.BackendStorageFile) (superBlock SuperBlock, err error) {
+
+	header := make([]byte, SuperBlockSize)
+	if n, e := datBackend.ReadAt(header, 0); e != nil {
+		if n != SuperBlockSize {
+			err = fmt.Errorf("cannot read volume %s super block: %v", datBackend.Name(), e)
+			return
+		}
+	}
+
+	superBlock.Version = needle.Version(header[0])
+	if superBlock.ReplicaPlacement, err = NewReplicaPlacementFromByte(header[1]); err != nil {
+		err = fmt.Errorf("cannot read replica type: %s", err.Error())
+		return
+	}
+	superBlock.Ttl = needle.LoadTTLFromBytes(header[2:4])
+	superBlock.CompactionRevision = util.BytesToUint16(header[4:6])
+	superBlock.ExtraSize = util.BytesToUint16(header[6:8])
+
+	if superBlock.ExtraSize > 0 {
+		// read more
+		extraData := make([]byte, int(superBlock.ExtraSize))
+		superBlock.Extra = &master_pb.SuperBlockExtra{}
+		err = proto.Unmarshal(extraData, superBlock.Extra)
+		if err != nil {
+			err = fmt.Errorf("cannot read volume %s super block extra: %v", datBackend.Name(), err)
+			return
+		}
+	}
+
+	return
+}

weed/storage/super_block/super_block_test.go

@@ -0,0 +1,25 @@
+package super_block
+
+import (
+	"testing"
+
+	"github.com/seaweedfs/seaweedfs/weed/storage/needle"
+)
+
+func TestSuperBlockReadWrite(t *testing.T) {
+	rp, _ := NewReplicaPlacementFromByte(byte(001))
+	ttl, _ := needle.ReadTTL("15d")
+	s := &SuperBlock{
+		Version:          needle.GetCurrentVersion(),
+		ReplicaPlacement: rp,
+		Ttl:              ttl,
+	}
+
+	bytes := s.Bytes()
+
+	if !(bytes[2] == 15 && bytes[3] == needle.Day) {
+		println("byte[2]:", bytes[2], "byte[3]:", bytes[3])
+		t.Fail()
+	}
+
+}