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 (
"context"
"errors"
"flag"
"fmt"
"io"
"github.com/seaweedfs/seaweedfs/weed/pb"
"github.com/seaweedfs/seaweedfs/weed/pb/master_pb"
"github.com/seaweedfs/seaweedfs/weed/util/wildcard"
"github.com/seaweedfs/seaweedfs/weed/storage/needle"
)
func init() {
Commands = append(Commands, &commandVolumeMark{})
}
type commandVolumeMark struct {
}
func (c *commandVolumeMark) Name() string {
return "volume.mark"
}
func (c *commandVolumeMark) Help() string {
return `Mark volume writable or readonly from one volume server, or all volume replicas in one collection
volume.mark -node <volume server host:port> -volumeId <volume id> -writable, -readonly or -readonlyCanDelete
volume.mark -collection <collection> -writable, -readonly or -readonlyCanDelete
Use -collection ` + CollectionDefault + ` to target volumes that belong to no named collection.
-readonlyCanDelete rejects new writes but keeps accepting deletes, so a
volume holding expiring data drains over time until it can be vacuumed
away or merged into other volumes with fs.mergeVolumes.
`
}
func (c *commandVolumeMark) HasTag(CommandTag) bool {
return false
}
func (c *commandVolumeMark) Do(args []string, commandEnv *CommandEnv, writer io.Writer) (err error) {
volMarkCommand := flag.NewFlagSet(c.Name(), flag.ContinueOnError)
volumeIdInt := volMarkCommand.Int("volumeId", 0, "the volume id")
nodeStr := volMarkCommand.String("node", "", "the volume server <host>:<port>")
collection := volMarkCommand.String("collection", "", "comma-separated collection names, wildcards, or regex patterns; \""+CollectionDefault+"\" for the collection with no name")
writable := volMarkCommand.Bool("writable", false, "volume mark writable")
readonly := volMarkCommand.Bool("readonly", false, "volume mark readonly")
readonlyCanDelete := volMarkCommand.Bool("readonlyCanDelete", false, "volume mark readonly but still accepting deletes")
if err = volMarkCommand.Parse(args); err != nil {
return err
}
collectionSet, nodeSet, volumeIdSet := false, false, false
volMarkCommand.Visit(func(f *flag.Flag) {
switch f.Name {
case "collection":
collectionSet = true
case "node":
nodeSet = true
case "volumeId":
volumeIdSet = true
}
})
modeCount := 0
for _, set := range []bool{*writable, *readonly, *readonlyCanDelete} {
if set {
modeCount++
}
}
if modeCount != 1 {
return fmt.Errorf("use exactly one of -writable, -readonly or -readonlyCanDelete")
}
markWritable := *writable
if collectionSet {
if *collection == "" {
return fmt.Errorf("collection is required")
}
if nodeSet || volumeIdSet {
return fmt.Errorf("cannot use -collection with -node or -volumeId")
}
} else if !nodeSet || !volumeIdSet || *nodeStr == "" || *volumeIdInt == 0 {
return fmt.Errorf("use -node and -volumeId, or -collection")
}
if err = commandEnv.confirmIsLocked(args); err != nil {
return
}
if collectionSet {
topologyInfo, _, err := collectTopologyInfo(commandEnv, 0)
if err != nil {
return err
}
targets, err := collectVolumeMarkTargetsByCollection(topologyInfo, *collection)
if err != nil {
return err
}
state := "readonly"
if markWritable {
state = "writable"
} else if *readonlyCanDelete {
state = "readonly (can delete)"
}
var failures []error
for _, target := range targets {
if err := markVolumeState(context.Background(), commandEnv.option.GrpcDialOption, target.volumeId, target.sourceVolumeServer, markWritable, *readonlyCanDelete, true); err != nil {
failures = append(failures, fmt.Errorf("mark volume %d on %s: %w", target.volumeId, target.sourceVolumeServer, err))
fmt.Fprintf(writer, "volume %d on %s: %v\n", target.volumeId, target.sourceVolumeServer, err)
continue
}
fmt.Fprintf(writer, "volume %d on %s marked %s\n", target.volumeId, target.sourceVolumeServer, state)
}
if len(failures) > 0 {
return fmt.Errorf("marked %d of %d volumes %s, %d failed: %w", len(targets)-len(failures), len(targets), state, len(failures), errors.Join(failures...))
}
return nil
}
sourceVolumeServer := pb.ServerAddress(*nodeStr)
volumeId := needle.VolumeId(*volumeIdInt)
return markVolumeState(context.Background(), commandEnv.option.GrpcDialOption, volumeId, sourceVolumeServer, markWritable, *readonlyCanDelete, true)
}
type volumeMarkTarget struct {
volumeId needle.VolumeId
sourceVolumeServer pb.ServerAddress
}
func collectVolumeMarkTargetsByCollection(topoInfo *master_pb.TopologyInfo, collection string) ([]volumeMarkTarget, error) {
if collection == "" {
return nil, fmt.Errorf("collection is required")
}
collectionMatcher, err := wildcard.CompileCollectionMatcher(collection)
if err != nil {
return nil, fmt.Errorf("invalid collection pattern %q: %w", collection, err)
}
var targets []volumeMarkTarget
eachDataNode(topoInfo, func(dc DataCenterId, rack RackId, dn *master_pb.DataNodeInfo) {
if dn == nil {
return
}
sourceVolumeServer := pb.NewServerAddressFromDataNode(dn)
for _, diskInfo := range dn.GetDiskInfos() {
for _, v := range diskInfo.GetVolumeInfos() {
if collectionMatcher.Matches(v.GetCollection()) {
targets = append(targets, volumeMarkTarget{
volumeId: needle.VolumeId(v.GetId()),
sourceVolumeServer: sourceVolumeServer,
})
}
}
}
})
if len(targets) == 0 {
return nil, fmt.Errorf("no volumes match collection %s", collection)
}
return targets, nil
}