allow custom speedtest bucket (#15271)

this allows for specifying existing buckets with

- object replication enabled
- object encryption enabled
- object versioning enabled
- object locking enabled

cmd/perf-tests.go

@@ -30,15 +30,13 @@ import (
 	"time"
 
 	"github.com/dustin/go-humanize"
-	"github.com/google/uuid"
 	"github.com/minio/madmin-go"
 	"github.com/minio/minio-go/v7"
-	"github.com/minio/minio-go/v7/pkg/credentials"
 	"github.com/minio/pkg/randreader"
 )
 
-// SpeedtestResult return value of the speedtest function
-type SpeedtestResult struct {
+// SpeedTestResult return value of the speedtest function
+type SpeedTestResult struct {
 	Endpoint  string
 	Uploads   uint64
 	Downloads uint64
@@ -50,10 +48,10 @@ func newRandomReader(size int) io.Reader {
 }
 
 // Runs the speedtest on local MinIO process.
-func selfSpeedtest(ctx context.Context, size, concurrent int, duration time.Duration, storageClass string) (SpeedtestResult, error) {
+func selfSpeedTest(ctx context.Context, opts speedTestOpts) (SpeedTestResult, error) {
 	objAPI := newObjectLayerFn()
 	if objAPI == nil {
-		return SpeedtestResult{}, errServerNotInitialized
+		return SpeedTestResult{}, errServerNotInitialized
 	}
 
 	var errOnce sync.Once
@@ -62,48 +60,34 @@ func selfSpeedtest(ctx context.Context, size, concurrent int, duration time.Dura
 	var totalBytesWritten uint64
 	var totalBytesRead uint64
 
-	region := globalSite.Region
-	if region == "" {
-		region = "us-east-1"
-	}
-
-	client, err := minio.New(globalLocalNodeName, &minio.Options{
-		Creds:     credentials.NewStaticV4(globalActiveCred.AccessKey, globalActiveCred.SecretKey, ""),
-		Secure:    globalIsTLS,
-		Transport: globalProxyTransport,
-		Region:    region,
-	})
-	if err != nil {
-		return SpeedtestResult{}, err
-	}
-
-	objCountPerThread := make([]uint64, concurrent)
+	objCountPerThread := make([]uint64, opts.concurrency)
 
 	uploadsCtx, uploadsCancel := context.WithCancel(context.Background())
 	defer uploadsCancel()
 
 	go func() {
-		time.Sleep(duration)
+		time.Sleep(opts.duration)
 		uploadsCancel()
 	}()
 
-	objNamePrefix := uuid.New().String() + SlashSeparator
+	objNamePrefix := pathJoin(speedTest, mustGetUUID())
 
 	userMetadata := make(map[string]string)
-	userMetadata[globalObjectPerfUserMetadata] = "true"
+	userMetadata[globalObjectPerfUserMetadata] = "true" // Bypass S3 API freeze
+	popts := minio.PutObjectOptions{
+		UserMetadata:         userMetadata,
+		DisableContentSha256: true,
+		DisableMultipart:     true,
+	}
 
-	wg.Add(concurrent)
-	for i := 0; i < concurrent; i++ {
+	wg.Add(opts.concurrency)
+	for i := 0; i < opts.concurrency; i++ {
 		go func(i int) {
 			defer wg.Done()
 			for {
-				reader := newRandomReader(size)
-				tmpObjName := fmt.Sprintf("%s%d.%d", objNamePrefix, i, objCountPerThread[i])
-				info, err := client.PutObject(uploadsCtx, globalObjectPerfBucket, tmpObjName, reader, int64(size), minio.PutObjectOptions{
-					UserMetadata:         userMetadata,
-					DisableContentSha256: true,
-					DisableMultipart:     true,
-				}) // Bypass S3 API freeze
+				reader := newRandomReader(opts.objectSize)
+				tmpObjName := pathJoin(objNamePrefix, fmt.Sprintf("%d/%d", i, objCountPerThread[i]))
+				info, err := globalMinioClient.PutObject(uploadsCtx, opts.bucketName, tmpObjName, reader, int64(opts.objectSize), popts)
 				if err != nil {
 					if !contextCanceled(uploadsCtx) && !errors.Is(err, context.Canceled) {
 						errOnce.Do(func() {
@@ -122,18 +106,21 @@ func selfSpeedtest(ctx context.Context, size, concurrent int, duration time.Dura
 
 	// We already saw write failures, no need to proceed into read's
 	if retError != "" {
-		return SpeedtestResult{Uploads: totalBytesWritten, Downloads: totalBytesRead, Error: retError}, nil
+		return SpeedTestResult{Uploads: totalBytesWritten, Downloads: totalBytesRead, Error: retError}, nil
 	}
 
 	downloadsCtx, downloadsCancel := context.WithCancel(context.Background())
 	defer downloadsCancel()
 	go func() {
-		time.Sleep(duration)
+		time.Sleep(opts.duration)
 		downloadsCancel()
 	}()
 
-	wg.Add(concurrent)
-	for i := 0; i < concurrent; i++ {
+	gopts := minio.GetObjectOptions{}
+	gopts.Set(globalObjectPerfUserMetadata, "true") // Bypass S3 API freeze
+
+	wg.Add(opts.concurrency)
+	for i := 0; i < opts.concurrency; i++ {
 		go func(i int) {
 			defer wg.Done()
 			var j uint64
@@ -144,9 +131,8 @@ func selfSpeedtest(ctx context.Context, size, concurrent int, duration time.Dura
 				if objCountPerThread[i] == j {
 					j = 0
 				}
-				opts := minio.GetObjectOptions{}
-				opts.Set(globalObjectPerfUserMetadata, "true") // Bypass S3 API freeze
-				r, err := client.GetObject(downloadsCtx, globalObjectPerfBucket, fmt.Sprintf("%s%d.%d", objNamePrefix, i, j), opts)
+				tmpObjName := pathJoin(objNamePrefix, fmt.Sprintf("%d/%d", i, j))
+				r, err := globalMinioClient.GetObject(downloadsCtx, opts.bucketName, tmpObjName, gopts)
 				if err != nil {
 					errResp, ok := err.(minio.ErrorResponse)
 					if ok && errResp.StatusCode == http.StatusNotFound {
@@ -183,7 +169,7 @@ func selfSpeedtest(ctx context.Context, size, concurrent int, duration time.Dura
 	}
 	wg.Wait()
 
-	return SpeedtestResult{Uploads: totalBytesWritten, Downloads: totalBytesRead, Error: retError}, nil
+	return SpeedTestResult{Uploads: totalBytesWritten, Downloads: totalBytesRead, Error: retError}, nil
 }
 
 // To collect RX stats during "mc support perf net"