mirror of
https://github.com/seaweedfs/seaweedfs.git
synced 2026-11-18 09:46:24 +01:00
* master: carry replica read-only state in volume lookups * volume: refresh writable replica targets * volume: preserve read-only replicas for deletes * master: propagate read-only delete capability * volume: target delete-capable replicas * volume: honor configured HTTPS for replica deletes * volume: reject insecure delete authorization forwarding * master: broadcast delete capability changes * volume: align Rust replica routing * http: protect credentialed replica redirects * master: preserve digest compatibility for delete capability * volume: propagate read-only state in short heartbeats * volume: report changed short volume state * http: guard TLS client redirects * master: announce mounted volume read-only state * volume: replace changed identity deltas * master: replace incremental volume layouts in order * master: keep moved volume lookup available * volume: announce read-only mounts
142 lines
4.1 KiB
Go
142 lines
4.1 KiB
Go
package topology
|
|
|
|
import (
|
|
"slices"
|
|
"strings"
|
|
|
|
"github.com/seaweedfs/seaweedfs/weed/pb/master_pb"
|
|
)
|
|
|
|
type TopologyInfo struct {
|
|
Max int64 `json:"Max"`
|
|
Free int64 `json:"Free"`
|
|
DataCenters []DataCenterInfo `json:"DataCenters"`
|
|
Layouts []VolumeLayoutInfo `json:"Layouts"`
|
|
}
|
|
|
|
type VolumeLayoutCollection struct {
|
|
Collection string
|
|
VolumeLayout *VolumeLayout
|
|
}
|
|
|
|
func (t *Topology) ToInfo() (info TopologyInfo) {
|
|
info.Max = t.diskUsages.GetMaxVolumeCount()
|
|
info.Free = t.diskUsages.FreeSpace()
|
|
var dcs []DataCenterInfo
|
|
for _, c := range t.Children() {
|
|
dc := c.(*DataCenter)
|
|
dcs = append(dcs, dc.ToInfo())
|
|
}
|
|
|
|
slices.SortFunc(dcs, func(a, b DataCenterInfo) int {
|
|
return strings.Compare(string(a.Id), string(b.Id))
|
|
})
|
|
|
|
info.DataCenters = dcs
|
|
var layouts []VolumeLayoutInfo
|
|
for _, col := range t.collectionMap.Items() {
|
|
c := col.(*Collection)
|
|
for _, layout := range c.storageType2VolumeLayout.Items() {
|
|
if layout != nil {
|
|
tmp := layout.(*VolumeLayout).ToInfo()
|
|
tmp.Collection = c.Name
|
|
layouts = append(layouts, tmp)
|
|
}
|
|
}
|
|
}
|
|
info.Layouts = layouts
|
|
return
|
|
}
|
|
|
|
func (t *Topology) ListVolumeLayoutCollections() (volumeLayouts []*VolumeLayoutCollection) {
|
|
for _, col := range t.collectionMap.Items() {
|
|
for _, volumeLayout := range col.(*Collection).storageType2VolumeLayout.Items() {
|
|
volumeLayouts = append(volumeLayouts,
|
|
&VolumeLayoutCollection{col.(*Collection).Name, volumeLayout.(*VolumeLayout)},
|
|
)
|
|
}
|
|
}
|
|
return volumeLayouts
|
|
}
|
|
|
|
func (t *Topology) ToVolumeMap() interface{} {
|
|
m := make(map[string]interface{})
|
|
m["Max"] = t.diskUsages.GetMaxVolumeCount()
|
|
m["Free"] = t.diskUsages.FreeSpace()
|
|
dcs := make(map[NodeId]interface{})
|
|
for _, c := range t.Children() {
|
|
dc := c.(*DataCenter)
|
|
racks := make(map[NodeId]interface{})
|
|
for _, r := range dc.Children() {
|
|
rack := r.(*Rack)
|
|
dataNodes := make(map[NodeId]interface{})
|
|
for _, d := range rack.Children() {
|
|
dn := d.(*DataNode)
|
|
dnVolumes := dn.GetVolumes()
|
|
volumes := make([]interface{}, 0, len(dnVolumes))
|
|
for _, v := range dnVolumes {
|
|
volumes = append(volumes, v)
|
|
}
|
|
dataNodes[d.Id()] = volumes
|
|
}
|
|
racks[r.Id()] = dataNodes
|
|
}
|
|
dcs[dc.Id()] = racks
|
|
}
|
|
m["DataCenters"] = dcs
|
|
return m
|
|
}
|
|
|
|
// ToVolumeLocations snapshots every data node's volume set into a list of
|
|
// per-node VolumeLocation messages. NewVids carries every volume; RemoteVids
|
|
// repeats the remote-tier subset so clients can route reads to a local
|
|
// replica first when one exists on any node. EC shards are flattened into
|
|
// NewEcVids so each vid is reported once even when its shards live on
|
|
// multiple disks of the same node.
|
|
func (t *Topology) ToVolumeLocations() (volumeLocations []*master_pb.VolumeLocation) {
|
|
for _, c := range t.Children() {
|
|
dc := c.(*DataCenter)
|
|
for _, r := range dc.Children() {
|
|
rack := r.(*Rack)
|
|
for _, d := range rack.Children() {
|
|
dn := d.(*DataNode)
|
|
volumeLocation := &master_pb.VolumeLocation{
|
|
Url: dn.Url(),
|
|
PublicUrl: dn.PublicUrl,
|
|
DataCenter: dn.GetDataCenterId(),
|
|
GrpcPort: uint32(dn.GrpcPort),
|
|
}
|
|
|
|
volumeLocation.NewVids, volumeLocation.RemoteVids, volumeLocation.ReadOnlyVids, volumeLocation.ReadOnlyCanDeleteVids = dn.AppendVolumeIds(nil, nil, nil, nil)
|
|
|
|
// A single EC volume's shards can live on multiple disks of
|
|
// one DataNode, so GetEcShards returns per-(vid,disk) entries.
|
|
// Dedupe so the snapshot carries each vid once.
|
|
seenEcVids := make(map[uint32]struct{})
|
|
for _, s := range dn.GetEcShards() {
|
|
vid := uint32(s.VolumeId)
|
|
if _, ok := seenEcVids[vid]; ok {
|
|
continue
|
|
}
|
|
seenEcVids[vid] = struct{}{}
|
|
volumeLocation.NewEcVids = append(volumeLocation.NewEcVids, vid)
|
|
}
|
|
volumeLocations = append(volumeLocations, volumeLocation)
|
|
}
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
func (t *Topology) ToTopologyInfo(filter VolumeFilter) *master_pb.TopologyInfo {
|
|
m := &master_pb.TopologyInfo{
|
|
Id: string(t.Id()),
|
|
DiskInfos: t.diskUsages.ToDiskInfo(),
|
|
}
|
|
for _, c := range t.Children() {
|
|
dc := c.(*DataCenter)
|
|
m.DataCenterInfos = append(m.DataCenterInfos, dc.ToDataCenterInfo(filter))
|
|
}
|
|
return m
|
|
}
|