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

test/plugin_workers/volume_balance/detection_test.go

@@ -0,0 +1,139 @@
+package volume_balance_test
+
+import (
+	"context"
+	"testing"
+	"time"
+
+	pluginworkers "github.com/seaweedfs/seaweedfs/test/plugin_workers"
+	"github.com/seaweedfs/seaweedfs/weed/pb/master_pb"
+	"github.com/seaweedfs/seaweedfs/weed/pb/plugin_pb"
+	"github.com/seaweedfs/seaweedfs/weed/pb/worker_pb"
+	pluginworker "github.com/seaweedfs/seaweedfs/weed/plugin/worker"
+	"github.com/seaweedfs/seaweedfs/weed/worker/tasks/balance"
+	"github.com/stretchr/testify/require"
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/credentials/insecure"
+	"google.golang.org/protobuf/proto"
+)
+
+func TestVolumeBalanceDetectionIntegration(t *testing.T) {
+	response := buildBalanceVolumeListResponse(t)
+	master := pluginworkers.NewMasterServer(t, response)
+
+	dialOption := grpc.WithTransportCredentials(insecure.NewCredentials())
+	handler := balance.NewVolumeBalanceHandler(dialOption)
+	harness := pluginworkers.NewHarness(t, pluginworkers.HarnessConfig{
+		WorkerOptions: pluginworker.WorkerOptions{
+			GrpcDialOption: dialOption,
+		},
+		Handlers: []pluginworker.JobHandler{handler},
+	})
+	harness.WaitForJobType("volume_balance")
+
+	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+	defer cancel()
+
+	proposals, err := harness.Plugin().RunDetection(ctx, "volume_balance", &plugin_pb.ClusterContext{
+		MasterGrpcAddresses: []string{master.Address()},
+	}, 10)
+	require.NoError(t, err)
+	// With default batch_size=20 and 10 overloaded volumes vs 1 underloaded,
+	// all moves are grouped into a single batch proposal.
+	require.Len(t, proposals, 1, "expected exactly one batch proposal")
+
+	proposal := proposals[0]
+	require.Equal(t, "volume_balance", proposal.JobType)
+	paramsValue := proposal.Parameters["task_params_pb"]
+	require.NotNil(t, paramsValue)
+
+	params := &worker_pb.TaskParams{}
+	require.NoError(t, proto.Unmarshal(paramsValue.GetBytesValue(), params))
+
+	bp := params.GetBalanceParams()
+	require.NotNil(t, bp, "expected BalanceParams in batch proposal")
+	require.Greater(t, len(bp.Moves), 1, "batch proposal should contain multiple moves")
+	for _, move := range bp.Moves {
+		require.NotZero(t, move.VolumeId)
+		require.NotEmpty(t, move.SourceNode)
+		require.NotEmpty(t, move.TargetNode)
+	}
+}
+
+func buildBalanceVolumeListResponse(t *testing.T) *master_pb.VolumeListResponse {
+	t.Helper()
+
+	volumeSizeLimitMB := uint64(100)
+	volumeModifiedAt := time.Now().Add(-2 * time.Hour).Unix()
+
+	overloadedVolumes := make([]*master_pb.VolumeInformationMessage, 0, 10)
+	for i := 0; i < 10; i++ {
+		volumeID := uint32(1000 + i)
+		overloadedVolumes = append(overloadedVolumes, &master_pb.VolumeInformationMessage{
+			Id:               volumeID,
+			Collection:       "balance",
+			DiskId:           0,
+			Size:             20 * 1024 * 1024,
+			DeletedByteCount: 0,
+			ModifiedAtSecond: volumeModifiedAt,
+			ReplicaPlacement: 1,
+			ReadOnly:         false,
+		})
+	}
+
+	underloadedVolumes := []*master_pb.VolumeInformationMessage{
+		{
+			Id:               2000,
+			Collection:       "balance",
+			DiskId:           0,
+			Size:             20 * 1024 * 1024,
+			DeletedByteCount: 0,
+			ModifiedAtSecond: volumeModifiedAt,
+			ReplicaPlacement: 1,
+			ReadOnly:         false,
+		},
+	}
+
+	overloadedDisk := &master_pb.DiskInfo{
+		DiskId:         0,
+		MaxVolumeCount: 100,
+		VolumeCount:    int64(len(overloadedVolumes)),
+		VolumeInfos:    overloadedVolumes,
+	}
+
+	underloadedDisk := &master_pb.DiskInfo{
+		DiskId:         0,
+		MaxVolumeCount: 100,
+		VolumeCount:    int64(len(underloadedVolumes)),
+		VolumeInfos:    underloadedVolumes,
+	}
+
+	overloadedNode := &master_pb.DataNodeInfo{
+		Id:        "10.0.0.1:8080",
+		Address:   "10.0.0.1:8080",
+		DiskInfos: map[string]*master_pb.DiskInfo{"hdd": overloadedDisk},
+	}
+
+	underloadedNode := &master_pb.DataNodeInfo{
+		Id:        "10.0.0.2:8080",
+		Address:   "10.0.0.2:8080",
+		DiskInfos: map[string]*master_pb.DiskInfo{"hdd": underloadedDisk},
+	}
+
+	rack := &master_pb.RackInfo{
+		Id:            "rack-1",
+		DataNodeInfos: []*master_pb.DataNodeInfo{overloadedNode, underloadedNode},
+	}
+
+	return &master_pb.VolumeListResponse{
+		VolumeSizeLimitMb: volumeSizeLimitMB,
+		TopologyInfo: &master_pb.TopologyInfo{
+			DataCenterInfos: []*master_pb.DataCenterInfo{
+				{
+					Id:        "dc-1",
+					RackInfos: []*master_pb.RackInfo{rack},
+				},
+			},
+		},
+	}
+}

test/plugin_workers/volume_balance/execution_test.go

@@ -0,0 +1,162 @@
+package volume_balance_test
+
+import (
+	"context"
+	"fmt"
+	"testing"
+	"time"
+
+	pluginworkers "github.com/seaweedfs/seaweedfs/test/plugin_workers"
+	"github.com/seaweedfs/seaweedfs/weed/pb/plugin_pb"
+	"github.com/seaweedfs/seaweedfs/weed/pb/worker_pb"
+	pluginworker "github.com/seaweedfs/seaweedfs/weed/plugin/worker"
+	"github.com/seaweedfs/seaweedfs/weed/worker/tasks/balance"
+	"github.com/stretchr/testify/require"
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/credentials/insecure"
+	"google.golang.org/protobuf/proto"
+)
+
+const testVolumeDatSize = 1 * 1024 * 1024
+
+func TestVolumeBalanceExecutionIntegration(t *testing.T) {
+	volumeID := uint32(303)
+
+	dialOption := grpc.WithTransportCredentials(insecure.NewCredentials())
+	handler := balance.NewVolumeBalanceHandler(dialOption)
+	harness := pluginworkers.NewHarness(t, pluginworkers.HarnessConfig{
+		WorkerOptions: pluginworker.WorkerOptions{
+			GrpcDialOption: dialOption,
+		},
+		Handlers: []pluginworker.JobHandler{handler},
+	})
+	harness.WaitForJobType("volume_balance")
+
+	source := pluginworkers.NewVolumeServer(t, "")
+	target := pluginworkers.NewVolumeServer(t, "")
+	pluginworkers.WriteTestVolumeFiles(t, source.BaseDir(), volumeID, testVolumeDatSize)
+
+	job := &plugin_pb.JobSpec{
+		JobId:   fmt.Sprintf("balance-job-%d", volumeID),
+		JobType: "volume_balance",
+		Parameters: map[string]*plugin_pb.ConfigValue{
+			"volume_id": {
+				Kind: &plugin_pb.ConfigValue_Int64Value{Int64Value: int64(volumeID)},
+			},
+			"collection": {
+				Kind: &plugin_pb.ConfigValue_StringValue{StringValue: "balance"},
+			},
+			"source_server": {
+				Kind: &plugin_pb.ConfigValue_StringValue{StringValue: source.Address()},
+			},
+			"target_server": {
+				Kind: &plugin_pb.ConfigValue_StringValue{StringValue: target.Address()},
+			},
+		},
+	}
+
+	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
+	defer cancel()
+
+	result, err := harness.Plugin().ExecuteJob(ctx, job, nil, 1)
+	require.NoError(t, err)
+	require.NotNil(t, result)
+	require.True(t, result.Success)
+
+	require.GreaterOrEqual(t, source.MarkReadonlyCount(), 1)
+	require.GreaterOrEqual(t, len(source.DeleteRequests()), 1)
+
+	copyCalls, _, tailCalls := target.BalanceStats()
+	require.GreaterOrEqual(t, copyCalls, 1)
+	require.GreaterOrEqual(t, tailCalls, 1)
+}
+
+func TestVolumeBalanceBatchExecutionIntegration(t *testing.T) {
+	dialOption := grpc.WithTransportCredentials(insecure.NewCredentials())
+	handler := balance.NewVolumeBalanceHandler(dialOption)
+	harness := pluginworkers.NewHarness(t, pluginworkers.HarnessConfig{
+		WorkerOptions: pluginworker.WorkerOptions{
+			GrpcDialOption: dialOption,
+		},
+		Handlers: []pluginworker.JobHandler{handler},
+	})
+	harness.WaitForJobType("volume_balance")
+
+	// Create one source and one target fake volume server.
+	source := pluginworkers.NewVolumeServer(t, "")
+	target := pluginworkers.NewVolumeServer(t, "")
+
+	// Build a batch job with 3 volume moves from source → target.
+	volumeIDs := []uint32{401, 402, 403}
+	for _, vid := range volumeIDs {
+		pluginworkers.WriteTestVolumeFiles(t, source.BaseDir(), vid, testVolumeDatSize)
+	}
+	moves := make([]*worker_pb.BalanceMoveSpec, len(volumeIDs))
+	for i, vid := range volumeIDs {
+		moves[i] = &worker_pb.BalanceMoveSpec{
+			VolumeId:   vid,
+			SourceNode: source.Address(),
+			TargetNode: target.Address(),
+			Collection: "batch-test",
+		}
+	}
+
+	params := &worker_pb.TaskParams{
+		TaskId: "batch-balance-test",
+		TaskParams: &worker_pb.TaskParams_BalanceParams{
+			BalanceParams: &worker_pb.BalanceTaskParams{
+				MaxConcurrentMoves: 2,
+				Moves:              moves,
+			},
+		},
+	}
+	paramBytes, err := proto.Marshal(params)
+	require.NoError(t, err)
+
+	job := &plugin_pb.JobSpec{
+		JobId:   "batch-balance-test",
+		JobType: "volume_balance",
+		Parameters: map[string]*plugin_pb.ConfigValue{
+			"task_params_pb": {
+				Kind: &plugin_pb.ConfigValue_BytesValue{BytesValue: paramBytes},
+			},
+		},
+	}
+
+	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
+	defer cancel()
+
+	result, err := harness.Plugin().ExecuteJob(ctx, job, nil, 1)
+	require.NoError(t, err)
+	require.NotNil(t, result)
+	require.True(t, result.Success, "batch balance job should succeed; result: %+v", result)
+
+	// Each of the 3 moves should have marked the source readonly and deleted.
+	require.Equal(t, len(volumeIDs), source.MarkReadonlyCount(),
+		"each move should mark source volume readonly")
+	require.Equal(t, len(volumeIDs), len(source.DeleteRequests()),
+		"each move should delete the source volume")
+
+	// Verify delete requests reference the expected volume IDs.
+	deletedVols := make(map[uint32]bool)
+	for _, req := range source.DeleteRequests() {
+		deletedVols[req.VolumeId] = true
+	}
+	for _, vid := range volumeIDs {
+		require.True(t, deletedVols[vid], "volume %d should have been deleted from source", vid)
+	}
+
+	// Each move reads source status once inside the target's fake VolumeCopy
+	// implementation and once for the pre-delete verification, and reads
+	// target status once probing for a pre-existing copy and once for the
+	// verification.
+	require.Equal(t, len(volumeIDs)*2, source.ReadFileStatusCount(),
+		"each move should read source volume status during target copy and at verification")
+	require.Equal(t, len(volumeIDs)*2, target.ReadFileStatusCount(),
+		"each move should probe the target and read its status at verification")
+
+	// Target should have received copy and tail calls for all 3 volumes.
+	copyCalls, _, tailCalls := target.BalanceStats()
+	require.Equal(t, len(volumeIDs), copyCalls, "target should receive one copy per volume")
+	require.Equal(t, len(volumeIDs), tailCalls, "target should receive one tail per volume")
+}