seaweedfs/weed/shell/command_ec_encode.go

291 lines
9 KiB
Go
Raw Normal View History

2019-05-24 18:52:23 +00:00
package shell
import (
"context"
"flag"
"fmt"
"io"
2019-05-25 09:02:44 +00:00
"sync"
"time"
2019-05-24 18:52:23 +00:00
2019-12-22 12:31:36 +00:00
"google.golang.org/grpc"
2019-05-24 18:52:23 +00:00
"github.com/chrislusf/seaweedfs/weed/operation"
2019-05-25 09:02:44 +00:00
"github.com/chrislusf/seaweedfs/weed/pb/master_pb"
2019-05-24 18:52:23 +00:00
"github.com/chrislusf/seaweedfs/weed/pb/volume_server_pb"
2019-05-25 09:02:44 +00:00
"github.com/chrislusf/seaweedfs/weed/storage/erasure_coding"
2019-05-24 18:52:23 +00:00
"github.com/chrislusf/seaweedfs/weed/storage/needle"
2019-05-25 09:02:44 +00:00
"github.com/chrislusf/seaweedfs/weed/wdclient"
2019-05-24 18:52:23 +00:00
)
func init() {
Commands = append(Commands, &commandEcEncode{})
2019-05-24 18:52:23 +00:00
}
type commandEcEncode struct {
}
func (c *commandEcEncode) Name() string {
return "ec.encode"
}
func (c *commandEcEncode) Help() string {
return `apply erasure coding to a volume
2019-06-05 07:13:13 +00:00
ec.encode [-collection=""] [-fullPercent=95] [-quietFor=1h]
ec.encode [-collection=""] [-volumeId=<volume_id>]
2019-05-24 18:52:23 +00:00
This command will:
1. freeze one volume
2. apply erasure coding to the volume
3. move the encoded shards to multiple volume servers
The erasure coding is 10.4. So ideally you have more than 14 volume servers, and you can afford
to lose 4 volume servers.
If the number of volumes are not high, the worst case is that you only have 4 volume servers,
and the shards are spread as 4,4,3,3, respectively. You can afford to lose one volume server.
If you only have less than 4 volume servers, with erasure coding, at least you can afford to
have 4 corrupted shard files.
`
}
func (c *commandEcEncode) Do(args []string, commandEnv *CommandEnv, writer io.Writer) (err error) {
2019-05-24 18:52:23 +00:00
encodeCommand := flag.NewFlagSet(c.Name(), flag.ContinueOnError)
volumeId := encodeCommand.Int("volumeId", 0, "the volume id")
collection := encodeCommand.String("collection", "", "the collection name")
2019-06-05 07:13:13 +00:00
fullPercentage := encodeCommand.Float64("fullPercent", 95, "the volume reaches the percentage of max volume size")
quietPeriod := encodeCommand.Duration("quietFor", time.Hour, "select volumes without no writes for this period")
2019-05-24 18:52:23 +00:00
if err = encodeCommand.Parse(args); err != nil {
return nil
}
ctx := context.Background()
2019-05-31 22:48:40 +00:00
vid := needle.VolumeId(*volumeId)
2019-05-24 18:52:23 +00:00
2019-05-31 22:48:40 +00:00
// volumeId is provided
if vid != 0 {
return doEcEncode(ctx, commandEnv, *collection, vid)
}
// apply to all volumes in the collection
2019-06-05 07:13:13 +00:00
volumeIds, err := collectVolumeIdsForEcEncode(ctx, commandEnv, *collection, *fullPercentage, *quietPeriod)
2019-05-31 22:48:40 +00:00
if err != nil {
return err
}
2019-06-03 09:26:31 +00:00
fmt.Printf("ec encode volumes: %v\n", volumeIds)
2019-05-31 22:48:40 +00:00
for _, vid := range volumeIds {
if err = doEcEncode(ctx, commandEnv, *collection, vid); err != nil {
return err
}
}
return nil
}
func doEcEncode(ctx context.Context, commandEnv *CommandEnv, collection string, vid needle.VolumeId) (err error) {
2019-05-25 09:02:44 +00:00
// find volume location
locations, found := commandEnv.MasterClient.GetLocations(uint32(vid))
if !found {
2019-05-31 22:48:40 +00:00
return fmt.Errorf("volume %d not found", vid)
2019-05-24 18:52:23 +00:00
}
// fmt.Printf("found ec %d shards on %v\n", vid, locations)
// mark the volume as readonly
err = markVolumeReadonly(ctx, commandEnv.option.GrpcDialOption, needle.VolumeId(vid), locations)
if err != nil {
2019-11-25 07:13:40 +00:00
return fmt.Errorf("mark volume %d as readonly on %s: %v", vid, locations[0].Url, err)
}
2019-05-25 09:02:44 +00:00
// generate ec shards
2019-05-31 22:48:40 +00:00
err = generateEcShards(ctx, commandEnv.option.GrpcDialOption, needle.VolumeId(vid), collection, locations[0].Url)
2019-05-25 09:02:44 +00:00
if err != nil {
2019-05-31 22:48:40 +00:00
return fmt.Errorf("generate ec shards for volume %d on %s: %v", vid, locations[0].Url, err)
2019-05-25 09:02:44 +00:00
}
// balance the ec shards to current cluster
2019-06-03 09:26:31 +00:00
err = spreadEcShards(ctx, commandEnv, vid, collection, locations)
2019-05-25 09:02:44 +00:00
if err != nil {
return fmt.Errorf("spread ec shards for volume %d from %s: %v", vid, locations[0].Url, err)
2019-05-25 09:02:44 +00:00
}
2019-05-24 18:52:23 +00:00
2019-05-31 22:48:40 +00:00
return nil
2019-05-24 18:52:23 +00:00
}
func markVolumeReadonly(ctx context.Context, grpcDialOption grpc.DialOption, volumeId needle.VolumeId, locations []wdclient.Location) error {
for _, location := range locations {
err := operation.WithVolumeServerClient(location.Url, grpcDialOption, func(ctx context.Context, volumeServerClient volume_server_pb.VolumeServerClient) error {
_, markErr := volumeServerClient.VolumeMarkReadonly(ctx, &volume_server_pb.VolumeMarkReadonlyRequest{
2019-06-27 19:18:59 +00:00
VolumeId: uint32(volumeId),
})
return markErr
})
if err != nil {
return err
}
}
return nil
}
func generateEcShards(ctx context.Context, grpcDialOption grpc.DialOption, volumeId needle.VolumeId, collection string, sourceVolumeServer string) error {
2019-05-24 18:52:23 +00:00
err := operation.WithVolumeServerClient(sourceVolumeServer, grpcDialOption, func(ctx context.Context, volumeServerClient volume_server_pb.VolumeServerClient) error {
_, genErr := volumeServerClient.VolumeEcShardsGenerate(ctx, &volume_server_pb.VolumeEcShardsGenerateRequest{
VolumeId: uint32(volumeId),
Collection: collection,
2019-05-24 18:52:23 +00:00
})
return genErr
})
return err
}
2019-05-25 09:02:44 +00:00
func spreadEcShards(ctx context.Context, commandEnv *CommandEnv, volumeId needle.VolumeId, collection string, existingLocations []wdclient.Location) (err error) {
2019-05-25 09:02:44 +00:00
2019-06-11 04:32:56 +00:00
allEcNodes, totalFreeEcSlots, err := collectEcNodes(ctx, commandEnv, "")
2019-05-25 09:02:44 +00:00
if err != nil {
return err
}
if totalFreeEcSlots < erasure_coding.TotalShardsCount {
return fmt.Errorf("not enough free ec shard slots. only %d left", totalFreeEcSlots)
}
2019-05-30 08:38:59 +00:00
allocatedDataNodes := allEcNodes
if len(allocatedDataNodes) > erasure_coding.TotalShardsCount {
allocatedDataNodes = allocatedDataNodes[:erasure_coding.TotalShardsCount]
2019-05-25 09:02:44 +00:00
}
// calculate how many shards to allocate for these servers
allocatedEcIds := balancedEcDistribution(allocatedDataNodes)
2019-05-25 09:02:44 +00:00
// ask the data nodes to copy from the source volume server
copiedShardIds, err := parallelCopyEcShardsFromSource(ctx, commandEnv.option.GrpcDialOption, allocatedDataNodes, allocatedEcIds, volumeId, collection, existingLocations[0])
2019-05-25 09:02:44 +00:00
if err != nil {
2019-06-03 09:26:31 +00:00
return err
}
// unmount the to be deleted shards
err = unmountEcShards(ctx, commandEnv.option.GrpcDialOption, volumeId, existingLocations[0].Url, copiedShardIds)
if err != nil {
return err
2019-05-25 09:02:44 +00:00
}
// ask the source volume server to clean up copied ec shards
2019-06-03 09:26:31 +00:00
err = sourceServerDeleteEcShards(ctx, commandEnv.option.GrpcDialOption, collection, volumeId, existingLocations[0].Url, copiedShardIds)
if err != nil {
2019-06-03 09:26:31 +00:00
return fmt.Errorf("source delete copied ecShards %s %d.%v: %v", existingLocations[0].Url, volumeId, copiedShardIds, err)
}
2019-05-25 09:02:44 +00:00
// ask the source volume server to delete the original volume
for _, location := range existingLocations {
err = deleteVolume(ctx, commandEnv.option.GrpcDialOption, volumeId, location.Url)
if err != nil {
return fmt.Errorf("deleteVolume %s volume %d: %v", location.Url, volumeId, err)
}
}
2019-05-25 09:02:44 +00:00
return err
}
func parallelCopyEcShardsFromSource(ctx context.Context, grpcDialOption grpc.DialOption,
targetServers []*EcNode, allocatedEcIds [][]uint32,
volumeId needle.VolumeId, collection string, existingLocation wdclient.Location) (actuallyCopied []uint32, err error) {
2019-05-25 09:02:44 +00:00
// parallelize
shardIdChan := make(chan []uint32, len(targetServers))
2019-05-25 09:02:44 +00:00
var wg sync.WaitGroup
for i, server := range targetServers {
if len(allocatedEcIds[i]) <= 0 {
2019-05-25 09:02:44 +00:00
continue
}
wg.Add(1)
go func(server *EcNode, allocatedEcShardIds []uint32) {
2019-05-25 09:02:44 +00:00
defer wg.Done()
2019-06-03 09:26:31 +00:00
copiedShardIds, copyErr := oneServerCopyAndMountEcShardsFromSource(ctx, grpcDialOption, server,
allocatedEcShardIds, volumeId, collection, existingLocation.Url)
2019-05-25 09:02:44 +00:00
if copyErr != nil {
err = copyErr
} else {
shardIdChan <- copiedShardIds
2019-06-11 04:32:56 +00:00
server.addEcVolumeShards(volumeId, collection, copiedShardIds)
2019-05-25 09:02:44 +00:00
}
}(server, allocatedEcIds[i])
2019-05-25 09:02:44 +00:00
}
wg.Wait()
close(shardIdChan)
2019-05-25 09:02:44 +00:00
if err != nil {
return nil, err
}
for shardIds := range shardIdChan {
actuallyCopied = append(actuallyCopied, shardIds...)
}
return
2019-05-25 09:02:44 +00:00
}
func balancedEcDistribution(servers []*EcNode) (allocated [][]uint32) {
allocated = make([][]uint32, len(servers))
allocatedShardIdIndex := uint32(0)
serverIndex := 0
for allocatedShardIdIndex < erasure_coding.TotalShardsCount {
if servers[serverIndex].freeEcSlot > 0 {
allocated[serverIndex] = append(allocated[serverIndex], allocatedShardIdIndex)
allocatedShardIdIndex++
}
serverIndex++
if serverIndex >= len(servers) {
serverIndex = 0
2019-05-25 09:02:44 +00:00
}
}
return allocated
}
func collectVolumeIdsForEcEncode(ctx context.Context, commandEnv *CommandEnv, selectedCollection string, fullPercentage float64, quietPeriod time.Duration) (vids []needle.VolumeId, err error) {
2019-05-31 22:48:40 +00:00
var resp *master_pb.VolumeListResponse
err = commandEnv.MasterClient.WithClient(ctx, func(client master_pb.SeaweedClient) error {
2019-05-31 22:48:40 +00:00
resp, err = client.VolumeList(ctx, &master_pb.VolumeListRequest{})
return err
})
if err != nil {
return
}
2019-06-03 09:26:31 +00:00
quietSeconds := int64(quietPeriod / time.Second)
nowUnixSeconds := time.Now().Unix()
2019-06-03 09:26:31 +00:00
fmt.Printf("ec encode volumes quiet for: %d seconds\n", quietSeconds)
2019-05-31 22:48:40 +00:00
vidMap := make(map[uint32]bool)
2019-06-22 17:56:54 +00:00
eachDataNode(resp.TopologyInfo, func(dc string, rack RackId, dn *master_pb.DataNodeInfo) {
for _, v := range dn.VolumeInfos {
if v.Collection == selectedCollection && v.ModifiedAtSecond+quietSeconds < nowUnixSeconds {
if float64(v.Size) > fullPercentage/100*float64(resp.VolumeSizeLimitMb)*1024*1024 {
vidMap[v.Id] = true
2019-05-31 22:48:40 +00:00
}
}
}
2019-06-22 17:56:54 +00:00
})
2019-05-31 22:48:40 +00:00
2019-12-22 12:31:36 +00:00
for vid := range vidMap {
2019-05-31 22:48:40 +00:00
vids = append(vids, needle.VolumeId(vid))
}
return
}