SeaweedFS is a distributed storage system for object storage (S3), file systems, Iceberg table buckets, and Lance vector buckets, designed to handle billions of files with O(1) disk access and effortless horizontal scaling.
Go blob-storagecloud-drivedistributed-file-systemdistributed-storageerasure-codingfusehadoop-hdfshdfskuberneteslancelancedbobject-storageposixs3s3-storageseaweedfstiered-file-systemvector-search
package shell
import (
"bytes"
"flag"
"fmt"
"slices"
"sort"
"strings"
"time"
"github.com/seaweedfs/seaweedfs/weed/pb/master_pb"
"github.com/seaweedfs/seaweedfs/weed/storage"
"github.com/seaweedfs/seaweedfs/weed/storage/erasure_coding"
"github.com/seaweedfs/seaweedfs/weed/storage/types"
"github.com/seaweedfs/seaweedfs/weed/util"
"github.com/seaweedfs/seaweedfs/weed/util/wildcard"
"io"
)
func init() {
Commands = append(Commands, &commandVolumeList{})
}
type commandVolumeList struct {
collectionMatcher *wildcard.CollectionMatcher
dataCenter *string
rack *string
dataNode *string
readonly *bool
writable *bool
volumeId *uint64
volumeSizeLimitMb uint64
}
func (c *commandVolumeList) Name() string {
return "volume.list"
}
func (c *commandVolumeList) Help() string {
return `list all volumes
This command list all volumes as a tree of dataCenter > rack > dataNode > volume.
`
}
func (c *commandVolumeList) HasTag(CommandTag) bool {
return false
}
func (c *commandVolumeList) Do(args []string, commandEnv *CommandEnv, writer io.Writer) (err error) {
volumeListCommand := flag.NewFlagSet(c.Name(), flag.ContinueOnError)
verbosityLevel := volumeListCommand.Int("v", 5, "verbose mode: 0, 1, 2, 3, 4, 5")
collectionPattern := volumeListCommand.String("collectionPattern", "", "comma-separated collection names, with '*' and '?' wildcards; empty matches all")
c.readonly = volumeListCommand.Bool("readonly", false, "show only readonly volumes")
c.writable = volumeListCommand.Bool("writable", false, "show only writable volumes")
c.volumeId = volumeListCommand.Uint64("volumeId", 0, "show only volume id")
c.dataCenter = volumeListCommand.String("dataCenter", "", "show volumes only from the specified data center")
c.rack = volumeListCommand.String("rack", "", "show volumes only from the specified rack")
c.dataNode = volumeListCommand.String("dataNode", "", "show volumes only from the specified data node")
if err = volumeListCommand.Parse(args); err != nil {
return err
}
if c.collectionMatcher, err = wildcard.CompileCollectionMatcher(*collectionPattern); err != nil {
return err
}
// collect topology information
var topologyInfo *master_pb.TopologyInfo
topologyInfo, c.volumeSizeLimitMb, err = collectTopologyInfo(commandEnv, 0)
if err != nil {
return err
}
c.writeTopologyInfo(writer, topologyInfo, c.volumeSizeLimitMb, *verbosityLevel)
return nil
}
func sortMapKey[T1 comparable, T2 any](m map[T1]T2) []T1 {
keys := make([]T1, 0, len(m))
for k, _ := range m {
keys = append(keys, k)
}
sort.Slice(keys, func(i, j int) bool {
switch v1 := any(keys[i]).(type) {
case int:
return v1 < any(keys[j]).(int)
case string:
if strings.Compare(v1, any(keys[j]).(string)) < 0 {
return true
}
return false
default:
return false
}
})
return keys
}
func diskInfosToString(diskInfos map[string]*master_pb.DiskInfo) string {
var buf bytes.Buffer
for _, diskType := range sortMapKey(diskInfos) {
diskInfo := diskInfos[diskType]
if diskType == "" {
diskType = types.HddType
}
fmt.Fprintf(&buf, " %s(volume:%d/%d active:%d free:%d remote:%d)", diskType, diskInfo.VolumeCount, diskInfo.MaxVolumeCount, diskInfo.ActiveVolumeCount, diskInfo.FreeVolumeCount, diskInfo.RemoteVolumeCount)
}
return buf.String()
}
func diskInfoToString(diskInfo *master_pb.DiskInfo) string {
var buf bytes.Buffer
fmt.Fprintf(&buf, "volume:%d/%d active:%d free:%d remote:%d", diskInfo.VolumeCount, diskInfo.MaxVolumeCount, diskInfo.ActiveVolumeCount, diskInfo.FreeVolumeCount, diskInfo.RemoteVolumeCount)
return buf.String()
}
func (c *commandVolumeList) writeTopologyInfo(writer io.Writer, t *master_pb.TopologyInfo, volumeSizeLimitMb uint64, verbosityLevel int) *statistics {
output(verbosityLevel >= 0, writer, "Topology volumeSizeLimit:%d MB%s\n", volumeSizeLimitMb, diskInfosToString(t.DiskInfos))
slices.SortFunc(t.DataCenterInfos, func(a, b *master_pb.DataCenterInfo) int {
return strings.Compare(a.Id, b.Id)
})
s := newStatistics()
for _, dc := range t.DataCenterInfos {
if *c.dataCenter != "" && *c.dataCenter != dc.Id {
continue
}
s.add(c.writeDataCenterInfo(writer, dc, verbosityLevel))
}
output(verbosityLevel >= 0, writer, "%+v \n", s)
// Scan the full topology (ignoring any -collection/-volumeId/-dataCenter
// filters) so this cluster-health warning always fires.
writeDuplicateVolumeIdWarning(writer, findDuplicateVolumeIds(t))
return s
}
// findDuplicateVolumeIds returns volume ids that appear under more than one
// collection, mapped to the sorted list of collections they live in. Volume
// ids are meant to be globally unique; a duplicate means the master handed out
// an id already in use by another collection (historically after losing its
// max-volume-id counter on restart, see the master resumeState flag). Such ids
// are dangerous: collection.delete on one collection destroys that collection's
// copy, and any operation keyed on the bare id (lookup, move, vacuum) is
// ambiguous. Both normal volumes and EC shards are scanned. Replicas of the
// same volume share a collection, so they collapse into a single entry and do
// not register as duplicates.
func findDuplicateVolumeIds(t *master_pb.TopologyInfo) map[uint32][]string {
// Duplicates are rare, so track only the first collection seen per id and
// allocate a set lazily on the first clash. Keeps allocations O(duplicates)
// rather than O(volumes), which matters on clusters with millions of ids.
firstCollectionByVid := make(map[uint32]string)
collectionsByVid := make(map[uint32]map[string]struct{})
note := func(vid uint32, collection string) {
if collections := collectionsByVid[vid]; collections != nil {
collections[collection] = struct{}{}
return
}
first, seen := firstCollectionByVid[vid]
if !seen {
firstCollectionByVid[vid] = collection
return
}
if first == collection {
return
}
collectionsByVid[vid] = map[string]struct{}{first: {}, collection: {}}
}
for _, dc := range t.DataCenterInfos {
for _, rack := range dc.RackInfos {
for _, dn := range rack.DataNodeInfos {
for _, disk := range dn.DiskInfos {
for _, vi := range disk.VolumeInfos {
note(vi.Id, vi.Collection)
}
for _, ec := range disk.EcShardInfos {
note(ec.Id, ec.Collection)
}
}
}
}
}
duplicates := make(map[uint32][]string)
for vid, collections := range collectionsByVid {
names := make([]string, 0, len(collections))
for name := range collections {
names = append(names, name)
}
sort.Strings(names)
duplicates[vid] = names
}
return duplicates
}
func writeDuplicateVolumeIdWarning(writer io.Writer, duplicates map[uint32][]string) {
if len(duplicates) == 0 {
return
}
vids := make([]uint32, 0, len(duplicates))
for vid := range duplicates {
vids = append(vids, vid)
}
slices.Sort(vids)
fmt.Fprintf(writer, "\nWARNING: %d volume id(s) exist in more than one collection. "+
"Deleting one collection (e.g. collection.delete) will destroy that collection's data on these shared ids, "+
"and lookups/moves on the bare id are ambiguous. Verify before any destructive operation:\n", len(vids))
for _, vid := range vids {
collections := duplicates[vid]
for i, name := range collections {
if name == "" {
collections[i] = `"" (default)`
}
}
fmt.Fprintf(writer, " volume %d in collections: %s\n", vid, strings.Join(collections, ", "))
}
}
func (c *commandVolumeList) writeDataCenterInfo(writer io.Writer, t *master_pb.DataCenterInfo, verbosityLevel int) statistics {
var s statistics
slices.SortFunc(t.RackInfos, func(a, b *master_pb.RackInfo) int {
return strings.Compare(a.Id, b.Id)
})
dataCenterInfoFound := false
dataCenterHeaderPrinted := false
for _, r := range t.RackInfos {
if *c.rack != "" && *c.rack != r.Id {
continue
}
s.add(c.writeRackInfo(writer, r, verbosityLevel, func() {
if dataCenterHeaderPrinted {
return
}
output(verbosityLevel >= 1, writer, " DataCenter %s%s\n", t.Id, diskInfosToString(t.DiskInfos))
dataCenterHeaderPrinted = true
}))
if !dataCenterInfoFound && !s.isEmpty() {
dataCenterInfoFound = true
}
}
output(dataCenterInfoFound && verbosityLevel >= 1, writer, " DataCenter %s %+v \n", t.Id, s)
return s
}
func (c *commandVolumeList) writeRackInfo(writer io.Writer, t *master_pb.RackInfo, verbosityLevel int, outCenterInfo func()) statistics {
var s statistics
slices.SortFunc(t.DataNodeInfos, func(a, b *master_pb.DataNodeInfo) int {
return strings.Compare(a.Id, b.Id)
})
rackInfoFound := false
rackHeaderPrinted := false
for _, dn := range t.DataNodeInfos {
if *c.dataNode != "" && *c.dataNode != dn.Id {
continue
}
s.add(c.writeDataNodeInfo(writer, dn, verbosityLevel, func() {
outCenterInfo()
if rackHeaderPrinted {
return
}
output(verbosityLevel >= 2, writer, " Rack %s%s\n", t.Id, diskInfosToString(t.DiskInfos))
rackHeaderPrinted = true
}))
if !rackInfoFound && !s.isEmpty() {
rackInfoFound = true
}
}
output(rackInfoFound && verbosityLevel >= 2, writer, " Rack %s %+v \n", t.Id, s)
return s
}
func (c *commandVolumeList) writeDataNodeInfo(writer io.Writer, t *master_pb.DataNodeInfo, verbosityLevel int, outRackInfo func()) statistics {
var s statistics
diskInfoFound := false
headerPrinted := false
// DataNodeInfo.DiskInfos keys by disk type, so a node with several disks
// of the same type collapses into a single entry. Split each one back
// into per-physical-disk views (using the DiskId carried on each
// VolumeInfo / EcShardInfo) so the verbose Disk block shows one entry
// per physical disk instead of summing them all under "id:0". headerPrinted
// guards against the inner callback firing once per split disk and
// emitting the DataNode header on every iteration.
for _, diskType := range sortMapKey(t.DiskInfos) {
perDiskInfos := t.DiskInfos[diskType].SplitByPhysicalDisk()
slices.SortFunc(perDiskInfos, func(a, b *master_pb.DiskInfo) int {
switch {
case a.DiskId < b.DiskId:
return -1
case a.DiskId > b.DiskId:
return 1
default:
return 0
}
})
for _, diskInfo := range perDiskInfos {
s.add(c.writeDiskInfo(writer, diskInfo, verbosityLevel, func() {
if headerPrinted {
return
}
outRackInfo()
output(verbosityLevel >= 3, writer, " DataNode %s%s\n", t.Id, diskInfosToString(t.DiskInfos))
headerPrinted = true
}))
if !diskInfoFound && !s.isEmpty() {
diskInfoFound = true
}
}
}
output(diskInfoFound && verbosityLevel >= 3, writer, " DataNode %s %+v \n", t.Id, s)
return s
}
func (c *commandVolumeList) isNotMatchDiskInfo(readOnly bool, collection string, volumeId uint32, volumeSize int64) bool {
if *c.readonly && !readOnly {
return true
}
if *c.writable && (readOnly || volumeSize == -1 || (c.volumeSizeLimitMb > 0 && uint64(volumeSize) >= c.volumeSizeLimitMb*util.MiByte)) {
return true
}
if !c.collectionMatcher.Matches(collection) {
return true
}
if *c.volumeId > 0 && *c.volumeId != uint64(volumeId) {
return true
}
return false
}
func (c *commandVolumeList) writeDiskInfo(writer io.Writer, t *master_pb.DiskInfo, verbosityLevel int, outNodeInfo func()) statistics {
var s statistics
diskType := t.Type
if diskType == "" {
diskType = types.HddType
}
slices.SortFunc(t.VolumeInfos, func(a, b *master_pb.VolumeInformationMessage) int {
return int(a.Id) - int(b.Id)
})
volumeInfosFound := false
for _, vi := range t.VolumeInfos {
if c.isNotMatchDiskInfo(vi.ReadOnly, vi.Collection, vi.Id, int64(vi.Size)) {
continue
}
if !volumeInfosFound {
outNodeInfo()
output(verbosityLevel >= 4, writer, " Disk %s(%s) id:%d\n", diskType, diskInfoToString(t), t.DiskId)
volumeInfosFound = true
}
s.add(writeVolumeInformationMessage(writer, vi, verbosityLevel))
}
ecShardInfoFound := false
for _, ecShardInfo := range t.EcShardInfos {
if c.isNotMatchDiskInfo(false, ecShardInfo.Collection, ecShardInfo.Id, -1) {
continue
}
if !volumeInfosFound && !ecShardInfoFound {
outNodeInfo()
output(verbosityLevel >= 4, writer, " Disk %s(%s) id:%d\n", diskType, diskInfoToString(t), t.DiskId)
ecShardInfoFound = true
}
s.add(writeECShardInformationMessage(writer, ecShardInfo, verbosityLevel))
}
output((volumeInfosFound || ecShardInfoFound) && verbosityLevel >= 4, writer, " Disk %s %+v \n", diskType, s)
return s
}
func writeVolumeInformationMessage(writer io.Writer, t *master_pb.VolumeInformationMessage, verbosityLevel int) statistics {
if verbosityLevel >= 5 {
vi, err := storage.NewVolumeInfo(t)
if err == nil {
output(true, writer, " volume %s \n", vi.String())
} else {
output(true, writer, " volume %+v \n", t)
}
}
return statistics{
Size: t.Size,
FileCount: t.FileCount,
DeletedFileCount: t.DeleteCount,
DeletedBytes: t.DeletedByteCount,
}
}
func writeECShardInformationMessage(writer io.Writer, t *master_pb.VolumeEcShardInformationMessage, verbosityLevel int) statistics {
var expireAtString string
if t.ExpireAtSec > 0 {
expireAtString = fmt.Sprintf("expireAt:%s", time.Unix(int64(t.ExpireAtSec), 0).Format("2006-01-02 15:04:05"))
}
// Build shard size information
si := erasure_coding.ShardsInfoFromVolumeEcShardInformationMessage(t)
var totalSize uint64
var shardSizeInfo string
if len(t.ShardSizes) > 0 {
var shardDetails []string
for _, shardId := range si.Ids() {
size := uint64(si.Size(shardId))
shardDetails = append(shardDetails, fmt.Sprintf("%d:%s", shardId, util.BytesToHumanReadable(uint64(size))))
totalSize += size
}
shardSizeInfo = fmt.Sprintf(" sizes:[%s] total:%s", strings.Join(shardDetails, " "), util.BytesToHumanReadable(uint64(totalSize)))
}
output(verbosityLevel >= 5, writer, " ec volume id:%v collection:%v shards:%v%s %s\n",
t.Id, t.Collection, si.Ids(), shardSizeInfo, expireAtString)
// TODO: add file counts once available in VolumeInformationMessage.
return statistics{
Size: totalSize,
}
}
func output(condition bool, w io.Writer, format string, a ...interface{}) {
if condition {
fmt.Fprintf(w, format, a...)
}
}
type statistics struct {
Size uint64
FileCount uint64
DeletedFileCount uint64
DeletedBytes uint64
}
func newStatistics() *statistics {
return &statistics{
Size: 0,
FileCount: 0,
DeletedFileCount: 0,
DeletedBytes: 0,
}
}
func (s *statistics) add(t statistics) {
s.Size += t.Size
s.FileCount += t.FileCount
s.DeletedFileCount += t.DeletedFileCount
s.DeletedBytes += t.DeletedBytes
}
func (s *statistics) isEmpty() bool {
return s.Size == 0 && s.FileCount == 0 && s.DeletedFileCount == 0 && s.DeletedBytes == 0
}
func (s *statistics) String() string {
if s.DeletedFileCount > 0 {
return fmt.Sprintf("total size:%d file_count:%d deleted_file:%d deleted_bytes:%d", s.Size, s.FileCount, s.DeletedFileCount, s.DeletedBytes)
}
return fmt.Sprintf("total size:%d file_count:%d", s.Size, s.FileCount)
}