MM-25943: Upgrade dependencies for server (#14932)

* MM-25943: Upgrade dependencies for server

* tmp

vendor/github.com/minio/minio-go/v6/.gitignore

@@ -1,3 +1,4 @@
 *~
 *.test
 validator
+golangci-lint

vendor/github.com/minio/minio-go/v6/.golangci.yml

@@ -0,0 +1,16 @@
+linters-settings:
+  misspell:
+    locale: US
+
+linters:
+  disable-all: true
+  enable:
+    - typecheck
+    - goimports
+    - misspell
+    - govet
+    - golint
+    - ineffassign
+    - gosimple
+    - deadcode
+    - structcheck

vendor/github.com/minio/minio-go/v6/.travis.yml

@@ -1,30 +0,0 @@
-sudo: false
-language: go
-
-os:
-- linux
-
-env:
-- ARCH=x86_64
-
-go:
-- 1.13.x
-- tip
-
-matrix:
-  fast_finish: true
-  allow_failures:
-  - go: tip
-
-before_install:
-  - sudo apt-get install devscripts
-  - mkdir /tmp/minio
-  - (cd /tmp/minio; GO111MODULE=on go get github.com/minio/minio)
-  - sudo cp testcerts/public.crt /usr/local/share/ca-certificates/
-  - sudo update-ca-certificates
-  - MINIO_ACCESS_KEY=minio MINIO_SECRET_KEY=minio123 ${GOPATH}/bin/minio server --compat --quiet --certs-dir testcerts data 2>&1 > minio.log &
-
-script:
-  - diff -au <(gofmt -d .) <(printf "")
-  - diff -au <(licensecheck --check '.go$' --recursive --lines 0 * | grep -v -w 'Apache (v2.0)') <(printf "")
-  - make

vendor/github.com/minio/minio-go/v6/Makefile

@@ -2,7 +2,11 @@ all: checks
 
 .PHONY: examples docs
 
-checks: vet test examples functional-test
+checks: diff vet test examples functional-test
+
+diff:
+	@curl -sSfL https://raw.githubusercontent.com/golangci/golangci-lint/master/install.sh | sh -s -- -b . v1.21.0
+	@./golangci-lint run --timeout=5m --config ./.golangci.yml
 
 vet:
 	@GO111MODULE=on go vet ./...

vendor/github.com/minio/minio-go/v6/api-bucket-tagging.go

@@ -0,0 +1,147 @@
+/*
+ * MinIO Go Library for Amazon S3 Compatible Cloud Storage
+ * Copyright 2020 MinIO, Inc.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package minio
+
+import (
+	"bytes"
+	"context"
+	"encoding/xml"
+	"errors"
+	"io"
+	"io/ioutil"
+	"net/http"
+	"net/url"
+
+	"github.com/minio/minio-go/v6/pkg/s3utils"
+	"github.com/minio/minio-go/v6/pkg/tags"
+)
+
+// GetBucketTagging gets tagging configuration for a bucket.
+func (c Client) GetBucketTagging(bucketName string) (*tags.Tags, error) {
+	return c.GetBucketTaggingWithContext(context.Background(), bucketName)
+}
+
+// GetBucketTaggingWithContext gets tagging configuration for a bucket with a context to control cancellations and timeouts.
+func (c Client) GetBucketTaggingWithContext(ctx context.Context, bucketName string) (*tags.Tags, error) {
+	// Input validation.
+	if err := s3utils.CheckValidBucketName(bucketName); err != nil {
+		return nil, err
+	}
+
+	// Get resources properly escaped and lined up before
+	// using them in http request.
+	urlValues := make(url.Values)
+	urlValues.Set("tagging", "")
+
+	// Execute GET on bucket to get tagging configuration.
+	resp, err := c.executeMethod(ctx, http.MethodGet, requestMetadata{
+		bucketName:  bucketName,
+		queryValues: urlValues,
+	})
+
+	defer closeResponse(resp)
+	if err != nil {
+		return nil, err
+	}
+
+	if resp.StatusCode != http.StatusOK {
+		return nil, httpRespToErrorResponse(resp, bucketName, "")
+	}
+
+	defer io.Copy(ioutil.Discard, resp.Body)
+	return tags.ParseBucketXML(resp.Body)
+}
+
+// SetBucketTagging sets tagging configuration for a bucket.
+func (c Client) SetBucketTagging(bucketName string, tags *tags.Tags) error {
+	return c.SetBucketTaggingWithContext(context.Background(), bucketName, tags)
+}
+
+// SetBucketTaggingWithContext sets tagging configuration for a bucket with a context to control cancellations and timeouts.
+func (c Client) SetBucketTaggingWithContext(ctx context.Context, bucketName string, tags *tags.Tags) error {
+	// Input validation.
+	if err := s3utils.CheckValidBucketName(bucketName); err != nil {
+		return err
+	}
+
+	if tags == nil {
+		return errors.New("nil tags passed")
+	}
+
+	buf, err := xml.Marshal(tags)
+	if err != nil {
+		return err
+	}
+
+	// Get resources properly escaped and lined up before
+	// using them in http request.
+	urlValues := make(url.Values)
+	urlValues.Set("tagging", "")
+
+	// Content-length is mandatory to set a default encryption configuration
+	reqMetadata := requestMetadata{
+		bucketName:       bucketName,
+		queryValues:      urlValues,
+		contentBody:      bytes.NewReader(buf),
+		contentLength:    int64(len(buf)),
+		contentMD5Base64: sumMD5Base64(buf),
+	}
+
+	// Execute PUT on bucket to put tagging configuration.
+	resp, err := c.executeMethod(ctx, http.MethodPut, reqMetadata)
+	defer closeResponse(resp)
+	if err != nil {
+		return err
+	}
+	if resp.StatusCode != http.StatusOK && resp.StatusCode != http.StatusNoContent {
+		return httpRespToErrorResponse(resp, bucketName, "")
+	}
+	return nil
+}
+
+// DeleteBucketTagging removes tagging configuration for a bucket.
+func (c Client) DeleteBucketTagging(bucketName string) error {
+	return c.DeleteBucketTaggingWithContext(context.Background(), bucketName)
+}
+
+// DeleteBucketTaggingWithContext removes tagging configuration for a bucket with a context to control cancellations and timeouts.
+func (c Client) DeleteBucketTaggingWithContext(ctx context.Context, bucketName string) error {
+	// Input validation.
+	if err := s3utils.CheckValidBucketName(bucketName); err != nil {
+		return err
+	}
+
+	// Get resources properly escaped and lined up before
+	// using them in http request.
+	urlValues := make(url.Values)
+	urlValues.Set("tagging", "")
+
+	// Execute DELETE on bucket to remove tagging configuration.
+	resp, err := c.executeMethod(ctx, http.MethodDelete, requestMetadata{
+		bucketName:       bucketName,
+		queryValues:      urlValues,
+		contentSHA256Hex: emptySHA256Hex,
+	})
+	defer closeResponse(resp)
+	if err != nil {
+		return err
+	}
+	if resp.StatusCode != http.StatusOK && resp.StatusCode != http.StatusNoContent {
+		return httpRespToErrorResponse(resp, bucketName, "")
+	}
+	return nil
+}

vendor/github.com/minio/minio-go/v6/api-datatypes.go

@@ -41,7 +41,7 @@ type StringMap map[string]string
 //
 // The fact this function is on the pointer of Map is important, so that
 // if m is nil it can be initialized, which is often the case if m is
-// nested in another xml structurel. This is also why the first thing done
+// nested in another xml structural. This is also why the first thing done
 // on the first line is initialize it.
 func (m *StringMap) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error {
 	*m = StringMap{}

vendor/github.com/minio/minio-go/v6/api-notification.go

@@ -146,16 +146,22 @@ func (c Client) ListenBucketNotification(bucketName, prefix, suffix string, even
 
 		// Validate the bucket name.
 		if err := s3utils.CheckValidBucketName(bucketName); err != nil {
-			notificationInfoCh <- NotificationInfo{
+			select {
+			case notificationInfoCh <- NotificationInfo{
 				Err: err,
+			}:
+			case <-doneCh:
 			}
 			return
 		}
 
 		// Check ARN partition to verify if listening bucket is supported
 		if s3utils.IsAmazonEndpoint(*c.endpointURL) || s3utils.IsGoogleEndpoint(*c.endpointURL) {
-			notificationInfoCh <- NotificationInfo{
+			select {
+			case notificationInfoCh <- NotificationInfo{
 				Err: ErrAPINotSupported("Listening for bucket notification is specific only to `minio` server endpoints"),
+			}:
+			case <-doneCh:
 			}
 			return
 		}
@@ -176,14 +182,17 @@ func (c Client) ListenBucketNotification(bucketName, prefix, suffix string, even
 		// Wait on the jitter retry loop.
 		for range c.newRetryTimerContinous(time.Second, time.Second*30, MaxJitter, retryDoneCh) {
 			// Execute GET on bucket to list objects.
-			resp, err := c.executeMethod(context.Background(), "GET", requestMetadata{
+			resp, err := c.executeMethod(context.Background(), http.MethodGet, requestMetadata{
 				bucketName:       bucketName,
 				queryValues:      urlValues,
 				contentSHA256Hex: emptySHA256Hex,
 			})
 			if err != nil {
-				notificationInfoCh <- NotificationInfo{
+				select {
+				case notificationInfoCh <- NotificationInfo{
 					Err: err,
+				}:
+				case <-doneCh:
 				}
 				return
 			}
@@ -191,8 +200,11 @@ func (c Client) ListenBucketNotification(bucketName, prefix, suffix string, even
 			// Validate http response, upon error return quickly.
 			if resp.StatusCode != http.StatusOK {
 				errResponse := httpRespToErrorResponse(resp, bucketName, "")
-				notificationInfoCh <- NotificationInfo{
+				select {
+				case notificationInfoCh <- NotificationInfo{
 					Err: errResponse,
+				}:
+				case <-doneCh:
 				}
 				return
 			}
@@ -205,14 +217,18 @@ func (c Client) ListenBucketNotification(bucketName, prefix, suffix string, even
 			bio.Buffer(notificationEventBuffer, notificationCapacity)
 			var json = jsoniter.ConfigCompatibleWithStandardLibrary
 
-			// Unmarshal each line, returns marshalled values.
+			// Unmarshal each line, returns marshaled values.
 			for bio.Scan() {
 				var notificationInfo NotificationInfo
 				if err = json.Unmarshal(bio.Bytes(), &notificationInfo); err != nil {
 					// Unexpected error during json unmarshal, send
 					// the error to caller for actionable as needed.
-					notificationInfoCh <- NotificationInfo{
+					select {
+					case notificationInfoCh <- NotificationInfo{
 						Err: err,
+					}:
+					case <-doneCh:
+						return
 					}
 					closeResponse(resp)
 					continue
@@ -225,13 +241,20 @@ func (c Client) ListenBucketNotification(bucketName, prefix, suffix string, even
 					return
 				}
 			}
+
 			if err = bio.Err(); err != nil {
-				notificationInfoCh <- NotificationInfo{
+				select {
+				case notificationInfoCh <- NotificationInfo{
 					Err: err,
+				}:
+				case <-doneCh:
+					return
 				}
 			}
+
 			// Close current connection before looping further.
 			closeResponse(resp)
+
 		}
 	}(notificationInfoCh)
 

vendor/github.com/minio/minio-go/v6/api-object-lock.go

@@ -33,7 +33,7 @@ import (
 type RetentionMode string
 
 const (
-	// Governance - goverance mode.
+	// Governance - governance mode.
 	Governance RetentionMode = "GOVERNANCE"
 
 	// Compliance - compliance mode.

vendor/github.com/minio/minio-go/v6/api-object-tagging.go

@@ -26,6 +26,7 @@ import (
 	"net/url"
 
 	"github.com/minio/minio-go/v6/pkg/s3utils"
+	"github.com/minio/minio-go/v6/pkg/tags"
 )
 
 // PutObjectTagging replaces or creates object tag(s)
@@ -46,23 +47,12 @@ func (c Client) PutObjectTaggingWithContext(ctx context.Context, bucketName, obj
 	urlValues := make(url.Values)
 	urlValues.Set("tagging", "")
 
-	tags := make([]tag, 0)
-	for k, v := range objectTags {
-		t := tag{
-			Key:   k,
-			Value: v,
-		}
-		tags = append(tags, t)
+	tags, err := tags.NewTags(objectTags, true)
+	if err != nil {
+		return err
 	}
 
-	// Prepare Tagging struct
-	reqBody := tagging{
-		TagSet: tagSet{
-			Tags: tags,
-		},
-	}
-
-	reqBytes, err := xml.Marshal(reqBody)
+	reqBytes, err := xml.Marshal(tags)
 	if err != nil {
 		return err
 	}

vendor/github.com/minio/minio-go/v6/api-put-bucket.go

@@ -51,6 +51,21 @@ type ServerSideEncryptionConfiguration struct {
 /// Bucket operations
 
 func (c Client) makeBucket(ctx context.Context, bucketName string, location string, objectLockEnabled bool) (err error) {
+	// Validate the input arguments.
+	if err := s3utils.CheckValidBucketNameStrict(bucketName); err != nil {
+		return err
+	}
+
+	err = c.doMakeBucket(ctx, bucketName, location, objectLockEnabled)
+	if err != nil && (location == "" || location == "us-east-1") {
+		if resp, ok := err.(ErrorResponse); ok && resp.Code == "AuthorizationHeaderMalformed" && resp.Region != "" {
+			err = c.doMakeBucket(ctx, bucketName, resp.Region, objectLockEnabled)
+		}
+	}
+	return err
+}
+
+func (c Client) doMakeBucket(ctx context.Context, bucketName string, location string, objectLockEnabled bool) (err error) {
 	defer func() {
 		// Save the location into cache on a successful makeBucket response.
 		if err == nil {
@@ -58,11 +73,6 @@ func (c Client) makeBucket(ctx context.Context, bucketName string, location stri
 		}
 	}()
 
-	// Validate the input arguments.
-	if err := s3utils.CheckValidBucketNameStrict(bucketName); err != nil {
-		return err
-	}
-
 	// If location is empty, treat is a default region 'us-east-1'.
 	if location == "" {
 		location = "us-east-1"

vendor/github.com/minio/minio-go/v6/api-put-object-multipart.go

@@ -28,7 +28,6 @@ import (
 	"io/ioutil"
 	"net/http"
 	"net/url"
-	"runtime/debug"
 	"sort"
 	"strconv"
 	"strings"
@@ -98,7 +97,6 @@ func (c Client) putObjectMultipartNoStream(ctx context.Context, bucketName, obje
 
 	// Create a buffer.
 	buf := make([]byte, partSize)
-	defer debug.FreeOSMemory()
 
 	for partNumber <= totalPartsCount {
 		// Choose hash algorithms to be calculated by hashCopyN,
@@ -118,6 +116,7 @@ func (c Client) putObjectMultipartNoStream(ctx context.Context, bucketName, obje
 		for k, v := range hashAlgos {
 			v.Write(buf[:length])
 			hashSums[k] = v.Sum(nil)
+			v.Close()
 		}
 
 		// Update progress reader appropriately to the latest offset

vendor/github.com/minio/minio-go/v6/api-put-object-streaming.go

@@ -20,12 +20,10 @@ package minio
 import (
 	"bytes"
 	"context"
-	"crypto/md5"
 	"encoding/base64"
 	"fmt"
 	"io"
 	"net/http"
-	"runtime/debug"
 	"sort"
 	"strings"
 
@@ -263,7 +261,6 @@ func (c Client) putObjectMultipartStreamOptionalChecksum(ctx context.Context, bu
 
 	// Create a buffer.
 	buf := make([]byte, partSize)
-	defer debug.FreeOSMemory()
 
 	// Avoid declaring variables in the for loop
 	var md5Base64 string
@@ -287,9 +284,11 @@ func (c Client) putObjectMultipartStreamOptionalChecksum(ctx context.Context, bu
 				return 0, rerr
 			}
 			// Calculate md5sum.
-			hash := md5.New()
+			hash := c.md5Hasher()
 			hash.Write(buf[:length])
 			md5Base64 = base64.StdEncoding.EncodeToString(hash.Sum(nil))
+			hash.Close()
+
 			// Update progress reader appropriately to the latest offset
 			// as we read from the source.
 			hookReader = newHook(bytes.NewReader(buf[:length]), opts.Progress)
@@ -385,7 +384,6 @@ func (c Client) putObject(ctx context.Context, bucketName, objectName string, re
 	if opts.SendContentMd5 {
 		// Create a buffer.
 		buf := make([]byte, size)
-		defer debug.FreeOSMemory()
 
 		length, rErr := io.ReadFull(reader, buf)
 		if rErr != nil && rErr != io.ErrUnexpectedEOF {
@@ -393,10 +391,11 @@ func (c Client) putObject(ctx context.Context, bucketName, objectName string, re
 		}
 
 		// Calculate md5sum.
-		hash := md5.New()
+		hash := c.md5Hasher()
 		hash.Write(buf[:length])
 		md5Base64 = base64.StdEncoding.EncodeToString(hash.Sum(nil))
 		reader = bytes.NewReader(buf[:length])
+		hash.Close()
 	}
 
 	// Update progress reader appropriately to the latest offset as we

vendor/github.com/minio/minio-go/v6/api-put-object.go

@@ -20,13 +20,11 @@ package minio
 import (
 	"bytes"
 	"context"
-	"crypto/md5"
 	"encoding/base64"
 	"errors"
 	"fmt"
 	"io"
 	"net/http"
-	"runtime/debug"
 	"sort"
 	"time"
 
@@ -253,7 +251,6 @@ func (c Client) putObjectMultipartStreamNoLength(ctx context.Context, bucketName
 
 	// Create a buffer.
 	buf := make([]byte, partSize)
-	defer debug.FreeOSMemory()
 
 	for partNumber <= totalPartsCount {
 		length, rerr := io.ReadFull(reader, buf)
@@ -267,9 +264,10 @@ func (c Client) putObjectMultipartStreamNoLength(ctx context.Context, bucketName
 		var md5Base64 string
 		if opts.SendContentMd5 {
 			// Calculate md5sum.
-			hash := md5.New()
+			hash := c.md5Hasher()
 			hash.Write(buf[:length])
 			md5Base64 = base64.StdEncoding.EncodeToString(hash.Sum(nil))
+			hash.Close()
 		}
 
 		// Update progress reader appropriately to the latest offset

vendor/github.com/minio/minio-go/v6/api-s3-datatypes.go

@@ -243,19 +243,3 @@ type deleteMultiObjectsResult struct {
 	DeletedObjects   []deletedObject    `xml:"Deleted"`
 	UnDeletedObjects []nonDeletedObject `xml:"Error"`
 }
-
-type tagging struct {
-	XMLName xml.Name `xml:"http://s3.amazonaws.com/doc/2006-03-01/ Tagging"`
-	TagSet  tagSet
-}
-
-type tagSet struct {
-	XMLName xml.Name `xml:"TagSet"`
-	Tags    []tag
-}
-
-type tag struct {
-	XMLName xml.Name `xml:"Tag"`
-	Key     string   `xml:"Key"`
-	Value   string   `xml:"Value"`
-}

vendor/github.com/minio/minio-go/v6/api.go

@@ -20,10 +20,8 @@ package minio
 import (
 	"bytes"
 	"context"
-	"crypto/md5"
 	"errors"
 	"fmt"
-	"hash"
 	"io"
 	"io/ioutil"
 	"math/rand"
@@ -38,13 +36,11 @@ import (
 	"sync"
 	"time"
 
-	"github.com/minio/sha256-simd"
-
-	"golang.org/x/net/publicsuffix"
-
+	md5simd "github.com/minio/md5-simd"
 	"github.com/minio/minio-go/v6/pkg/credentials"
 	"github.com/minio/minio-go/v6/pkg/s3utils"
 	"github.com/minio/minio-go/v6/pkg/signer"
+	"golang.org/x/net/publicsuffix"
 )
 
 // Client implements Amazon S3 compatible methods.
@@ -90,6 +86,10 @@ type Client struct {
 	// lookup indicates type of url lookup supported by server. If not specified,
 	// default to Auto.
 	lookup BucketLookupType
+
+	// Factory for MD5 hash functions.
+	md5Hasher    func() md5simd.Hasher
+	sha256Hasher func() md5simd.Hasher
 }
 
 // Options for New method
@@ -98,13 +98,16 @@ type Options struct {
 	Secure       bool
 	Region       string
 	BucketLookup BucketLookupType
-	// Add future fields here
+
+	// Custom hash routines. Leave nil to use standard.
+	CustomMD5    func() md5simd.Hasher
+	CustomSHA256 func() md5simd.Hasher
 }
 
 // Global constants.
 const (
 	libraryName    = "minio-go"
-	libraryVersion = "v6.0.55"
+	libraryVersion = "v6.0.57"
 )
 
 // User Agent should always following the below style.
@@ -129,8 +132,11 @@ const (
 // NewV2 - instantiate minio client with Amazon S3 signature version
 // '2' compatibility.
 func NewV2(endpoint string, accessKeyID, secretAccessKey string, secure bool) (*Client, error) {
-	creds := credentials.NewStaticV2(accessKeyID, secretAccessKey, "")
-	clnt, err := privateNew(endpoint, creds, secure, "", BucketLookupAuto)
+	clnt, err := privateNew(endpoint, Options{
+		Creds:        credentials.NewStaticV2(accessKeyID, secretAccessKey, ""),
+		Secure:       secure,
+		BucketLookup: BucketLookupAuto,
+	})
 	if err != nil {
 		return nil, err
 	}
@@ -141,8 +147,11 @@ func NewV2(endpoint string, accessKeyID, secretAccessKey string, secure bool) (*
 // NewV4 - instantiate minio client with Amazon S3 signature version
 // '4' compatibility.
 func NewV4(endpoint string, accessKeyID, secretAccessKey string, secure bool) (*Client, error) {
-	creds := credentials.NewStaticV4(accessKeyID, secretAccessKey, "")
-	clnt, err := privateNew(endpoint, creds, secure, "", BucketLookupAuto)
+	clnt, err := privateNew(endpoint, Options{
+		Creds:        credentials.NewStaticV4(accessKeyID, secretAccessKey, ""),
+		Secure:       secure,
+		BucketLookup: BucketLookupAuto,
+	})
 	if err != nil {
 		return nil, err
 	}
@@ -152,8 +161,11 @@ func NewV4(endpoint string, accessKeyID, secretAccessKey string, secure bool) (*
 
 // New - instantiate minio client, adds automatic verification of signature.
 func New(endpoint, accessKeyID, secretAccessKey string, secure bool) (*Client, error) {
-	creds := credentials.NewStaticV4(accessKeyID, secretAccessKey, "")
-	clnt, err := privateNew(endpoint, creds, secure, "", BucketLookupAuto)
+	clnt, err := privateNew(endpoint, Options{
+		Creds:        credentials.NewStaticV4(accessKeyID, secretAccessKey, ""),
+		Secure:       secure,
+		BucketLookup: BucketLookupAuto,
+	})
 	if err != nil {
 		return nil, err
 	}
@@ -172,7 +184,12 @@ func New(endpoint, accessKeyID, secretAccessKey string, secure bool) (*Client, e
 // for retrieving credentials from various credentials provider such as
 // IAM, File, Env etc.
 func NewWithCredentials(endpoint string, creds *credentials.Credentials, secure bool, region string) (*Client, error) {
-	return privateNew(endpoint, creds, secure, region, BucketLookupAuto)
+	return privateNew(endpoint, Options{
+		Creds:        creds,
+		Secure:       secure,
+		BucketLookup: BucketLookupAuto,
+		Region:       region,
+	})
 }
 
 // NewWithRegion - instantiate minio client, with region configured. Unlike New(),
@@ -180,12 +197,20 @@ func NewWithCredentials(endpoint string, creds *credentials.Credentials, secure
 // Use this function when if your application deals with single region.
 func NewWithRegion(endpoint, accessKeyID, secretAccessKey string, secure bool, region string) (*Client, error) {
 	creds := credentials.NewStaticV4(accessKeyID, secretAccessKey, "")
-	return privateNew(endpoint, creds, secure, region, BucketLookupAuto)
+	return privateNew(endpoint, Options{
+		Creds:        creds,
+		Secure:       secure,
+		Region:       region,
+		BucketLookup: BucketLookupAuto,
+	})
 }
 
 // NewWithOptions - instantiate minio client with options
 func NewWithOptions(endpoint string, opts *Options) (*Client, error) {
-	return privateNew(endpoint, opts.Creds, opts.Secure, opts.Region, opts.BucketLookup)
+	if opts == nil {
+		return nil, errors.New("no options provided")
+	}
+	return privateNew(endpoint, *opts)
 }
 
 // EndpointURL returns the URL of the S3 endpoint.
@@ -277,9 +302,9 @@ func (c *Client) redirectHeaders(req *http.Request, via []*http.Request) error {
 	return nil
 }
 
-func privateNew(endpoint string, creds *credentials.Credentials, secure bool, region string, lookup BucketLookupType) (*Client, error) {
+func privateNew(endpoint string, opts Options) (*Client, error) {
 	// construct endpoint.
-	endpointURL, err := getEndpointURL(endpoint, secure)
+	endpointURL, err := getEndpointURL(endpoint, opts.Secure)
 	if err != nil {
 		return nil, err
 	}
@@ -295,15 +320,15 @@ func privateNew(endpoint string, creds *credentials.Credentials, secure bool, re
 	clnt := new(Client)
 
 	// Save the credentials.
-	clnt.credsProvider = creds
+	clnt.credsProvider = opts.Creds
 
 	// Remember whether we are using https or not
-	clnt.secure = secure
+	clnt.secure = opts.Secure
 
 	// Save endpoint URL, user agent for future uses.
 	clnt.endpointURL = endpointURL
 
-	transport, err := DefaultTransport(secure)
+	transport, err := DefaultTransport(opts.Secure)
 	if err != nil {
 		return nil, err
 	}
@@ -316,10 +341,10 @@ func privateNew(endpoint string, creds *credentials.Credentials, secure bool, re
 	}
 
 	// Sets custom region, if region is empty bucket location cache is used automatically.
-	if region == "" {
-		region = s3utils.GetRegionFromURL(*clnt.endpointURL)
+	if opts.Region == "" {
+		opts.Region = s3utils.GetRegionFromURL(*clnt.endpointURL)
 	}
-	clnt.region = region
+	clnt.region = opts.Region
 
 	// Instantiate bucket location cache.
 	clnt.bucketLocCache = newBucketLocationCache()
@@ -327,9 +352,18 @@ func privateNew(endpoint string, creds *credentials.Credentials, secure bool, re
 	// Introduce a new locked random seed.
 	clnt.random = rand.New(&lockedRandSource{src: rand.NewSource(time.Now().UTC().UnixNano())})
 
+	// Add default md5 hasher.
+	clnt.md5Hasher = opts.CustomMD5
+	clnt.sha256Hasher = opts.CustomSHA256
+	if clnt.md5Hasher == nil {
+		clnt.md5Hasher = newMd5Hasher
+	}
+	if clnt.sha256Hasher == nil {
+		clnt.sha256Hasher = newSHA256Hasher
+	}
 	// Sets bucket lookup style, whether server accepts DNS or Path lookup. Default is Auto - determined
 	// by the SDK. When Auto is specified, DNS lookup is used for Amazon/Google cloud endpoints and Path for all other endpoints.
-	clnt.lookup = lookup
+	clnt.lookup = opts.BucketLookup
 	// Return.
 	return clnt, nil
 }
@@ -413,22 +447,22 @@ func (c *Client) SetS3TransferAccelerate(accelerateEndpoint string) {
 //  - For signature v4 request if the connection is insecure compute only sha256.
 //  - For signature v4 request if the connection is secure compute only md5.
 //  - For anonymous request compute md5.
-func (c *Client) hashMaterials(isMd5Requested bool) (hashAlgos map[string]hash.Hash, hashSums map[string][]byte) {
+func (c *Client) hashMaterials(isMd5Requested bool) (hashAlgos map[string]md5simd.Hasher, hashSums map[string][]byte) {
 	hashSums = make(map[string][]byte)
-	hashAlgos = make(map[string]hash.Hash)
+	hashAlgos = make(map[string]md5simd.Hasher)
 	if c.overrideSignerType.IsV4() {
 		if c.secure {
-			hashAlgos["md5"] = md5.New()
+			hashAlgos["md5"] = c.md5Hasher()
 		} else {
-			hashAlgos["sha256"] = sha256.New()
+			hashAlgos["sha256"] = c.sha256Hasher()
 		}
 	} else {
 		if c.overrideSignerType.IsAnonymous() {
-			hashAlgos["md5"] = md5.New()
+			hashAlgos["md5"] = c.md5Hasher()
 		}
 	}
 	if isMd5Requested {
-		hashAlgos["md5"] = md5.New()
+		hashAlgos["md5"] = c.md5Hasher()
 	}
 	return hashAlgos, hashSums
 }
@@ -683,7 +717,7 @@ func (c Client) executeMethod(ctx context.Context, method string, metadata reque
 				// handle this appropriately.
 				if metadata.bucketName != "" {
 					// Gather Cached location only if bucketName is present.
-					if _, cachedOk := c.bucketLocCache.Get(metadata.bucketName); cachedOk {
+					if location, cachedOk := c.bucketLocCache.Get(metadata.bucketName); cachedOk && location != errResponse.Region {
 						c.bucketLocCache.Set(metadata.bucketName, errResponse.Region)
 						continue // Retry.
 					}

vendor/github.com/minio/minio-go/v6/appveyor.yml

@@ -1,35 +0,0 @@
-# version format
-version: "{build}"
-
-# Operating system (build VM template)
-os: Windows Server 2012 R2
-
-clone_folder: c:\gopath\src\github.com\minio\minio-go
-
-# environment variables
-environment:
-  GOPATH: c:\gopath
-  GO111MODULE: on
-
-# scripts that run after cloning repository
-install:
-  - set PATH=%GOPATH%\bin;c:\go\bin;%PATH%
-  - go version
-  - go env
-  - go get golang.org/x/lint/golint
-  - go get honnef.co/go/tools/cmd/staticcheck
-
-# to run your custom scripts instead of automatic MSBuild
-build_script:
-  - go vet ./...
-  - gofmt -s -l .
-  - golint -set_exit_status ./...
-  - staticcheck
-  - go test -short -v ./...
-  - go test -short -race -v ./...
-
-# to disable automatic tests
-test: off
-
-# to disable deployment
-deploy: off

vendor/github.com/minio/minio-go/v6/bucket-cache.go

@@ -187,7 +187,7 @@ func (c Client) getBucketLocationRequest(bucketName string) (*http.Request, erro
 
 	var urlStr string
 
-	//only suport Aliyun OSS for virtual hosted path,  compatible  Amazon & Google Endpoint
+	//only support Aliyun OSS for virtual hosted path,  compatible  Amazon & Google Endpoint
 	if isVirtualHost && s3utils.IsAliyunOSSEndpoint(targetURL) {
 		urlStr = c.endpointURL.Scheme + "://" + bucketName + "." + targetURL.Host + "/?location"
 	} else {

vendor/github.com/minio/minio-go/v6/core.go

@@ -21,7 +21,6 @@ import (
 	"context"
 	"io"
 	"net/http"
-	"strings"
 
 	"github.com/minio/minio-go/v6/pkg/encrypt"
 )
@@ -85,34 +84,13 @@ func (c Core) CopyObjectPart(srcBucket, srcObject, destBucket, destObject string
 }
 
 // PutObjectWithContext - Upload object. Uploads using single PUT call.
-func (c Core) PutObjectWithContext(ctx context.Context, bucket, object string, data io.Reader, size int64, md5Base64, sha256Hex string, metadata map[string]string, sse encrypt.ServerSide) (ObjectInfo, error) {
-	opts := PutObjectOptions{}
-	m := make(map[string]string)
-	for k, v := range metadata {
-		if strings.ToLower(k) == "content-encoding" {
-			opts.ContentEncoding = v
-		} else if strings.ToLower(k) == "content-disposition" {
-			opts.ContentDisposition = v
-		} else if strings.ToLower(k) == "content-language" {
-			opts.ContentLanguage = v
-		} else if strings.ToLower(k) == "content-type" {
-			opts.ContentType = v
-		} else if strings.ToLower(k) == "cache-control" {
-			opts.CacheControl = v
-		} else if strings.EqualFold(k, amzWebsiteRedirectLocation) {
-			opts.WebsiteRedirectLocation = v
-		} else {
-			m[k] = metadata[k]
-		}
-	}
-	opts.UserMetadata = m
-	opts.ServerSideEncryption = sse
+func (c Core) PutObjectWithContext(ctx context.Context, bucket, object string, data io.Reader, size int64, md5Base64, sha256Hex string, opts PutObjectOptions) (ObjectInfo, error) {
 	return c.putObjectDo(ctx, bucket, object, data, md5Base64, sha256Hex, size, opts)
 }
 
 // PutObject - Upload object. Uploads using single PUT call.
-func (c Core) PutObject(bucket, object string, data io.Reader, size int64, md5Base64, sha256Hex string, metadata map[string]string, sse encrypt.ServerSide) (ObjectInfo, error) {
-	return c.PutObjectWithContext(context.Background(), bucket, object, data, size, md5Base64, sha256Hex, metadata, sse)
+func (c Core) PutObject(bucket, object string, data io.Reader, size int64, md5Base64, sha256Hex string, opts PutObjectOptions) (ObjectInfo, error) {
+	return c.PutObjectWithContext(context.Background(), bucket, object, data, size, md5Base64, sha256Hex, opts)
 }
 
 // NewMultipartUpload - Initiates new multipart upload and returns the new uploadID.

vendor/github.com/minio/minio-go/v6/go.mod

@@ -5,6 +5,7 @@ go 1.12
 require (
 	github.com/dustin/go-humanize v1.0.0 // indirect
 	github.com/json-iterator/go v1.1.9
+	github.com/minio/md5-simd v1.1.0
 	github.com/minio/sha256-simd v0.1.1
 	github.com/mitchellh/go-homedir v1.1.0
 	github.com/sirupsen/logrus v1.5.0 // indirect

vendor/github.com/minio/minio-go/v6/go.sum

@@ -10,7 +10,13 @@ github.com/json-iterator/go v1.1.9 h1:9yzud/Ht36ygwatGx56VwCZtlI/2AD15T1X2sjSuGn
 github.com/json-iterator/go v1.1.9/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4=
 github.com/jtolds/gls v4.20.0+incompatible h1:xdiiI2gbIgH/gLH7ADydsJ1uDOEzR8yvV7C0MuV77Wo=
 github.com/jtolds/gls v4.20.0+incompatible/go.mod h1:QJZ7F/aHp+rZTRtaJ1ow/lLfFfVYBRgL+9YlvaHOwJU=
+github.com/klauspost/cpuid v1.2.3 h1:CCtW0xUnWGVINKvE/WWOYKdsPV6mawAtvQuSl8guwQs=
+github.com/klauspost/cpuid v1.2.3/go.mod h1:Pj4uuM528wm8OyEC2QMXAi2YiTZ96dNQPGgoMS4s3ek=
 github.com/konsorten/go-windows-terminal-sequences v1.0.1/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
+github.com/minio/md5-simd v1.0.1 h1:tj/FH8APTKxIkOGUX2YGAVJVXXC3AJ5T2SkHoT/dUFI=
+github.com/minio/md5-simd v1.0.1/go.mod h1:EhdyA+Dr0guvfyc8d6yrgs9YzHGfaI+YIjA6gt/7mJk=
+github.com/minio/md5-simd v1.1.0 h1:QPfiOqlZH+Cj9teu0t9b1nTBfPbyTl16Of5MeuShdK4=
+github.com/minio/md5-simd v1.1.0/go.mod h1:XpBqgZULrMYD3R+M28PcmP0CkI7PEMzB3U77ZrKZ0Gw=
 github.com/minio/sha256-simd v0.1.1 h1:5QHSlgo3nt5yKOJrC7W8w7X+NFl8cMPZm96iu8kKUJU=
 github.com/minio/sha256-simd v0.1.1/go.mod h1:B5e1o+1/KgNmWrSQK08Y6Z1Vb5pwIktudl0J58iy0KM=
 github.com/mitchellh/go-homedir v1.1.0 h1:lukF9ziXFxDFPkA1vsr5zpc1XuPDn/wFntq5mG+4E0Y=
@@ -21,6 +27,7 @@ github.com/modern-go/reflect2 v0.0.0-20180701023420-4b7aa43c6742 h1:Esafd1046DLD
 github.com/modern-go/reflect2 v0.0.0-20180701023420-4b7aa43c6742/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/remeh/sizedwaitgroup v1.0.0/go.mod h1:3j2R4OIe/SeS6YDhICBy22RWjJC5eNCJ1V+9+NVNYlo=
 github.com/sirupsen/logrus v1.5.0 h1:1N5EYkVAPEywqZRJd7cwnRtCb6xJx7NH3T3WUTF980Q=
 github.com/sirupsen/logrus v1.5.0/go.mod h1:+F7Ogzej0PZc/94MaYx/nvG9jOFMD2osvC3s+Squfpo=
 github.com/smartystreets/assertions v0.0.0-20180927180507-b2de0cb4f26d h1:zE9ykElWQ6/NYmHa3jpm/yHnI4xSofP+UP6SpjHcSeM=

vendor/github.com/minio/minio-go/v6/pkg/tags/tags.go

@@ -0,0 +1,330 @@
+/*
+ * MinIO Cloud Storage, (C) 2020 MinIO, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package tags
+
+import (
+	"encoding/xml"
+	"io"
+	"net/url"
+	"strings"
+	"unicode/utf8"
+)
+
+// Error contains tag specific error.
+type Error interface {
+	error
+	Code() string
+}
+
+type errTag struct {
+	code    string
+	message string
+}
+
+// Code contains error code.
+func (err errTag) Code() string {
+	return err.code
+}
+
+// Error contains error message.
+func (err errTag) Error() string {
+	return err.message
+}
+
+var (
+	errTooManyObjectTags = &errTag{"BadRequest", "Tags cannot be more than 10"}
+	errTooManyTags       = &errTag{"BadRequest", "Tags cannot be more than 50"}
+	errInvalidTagKey     = &errTag{"InvalidTag", "The TagKey you have provided is invalid"}
+	errInvalidTagValue   = &errTag{"InvalidTag", "The TagValue you have provided is invalid"}
+	errDuplicateTagKey   = &errTag{"InvalidTag", "Cannot provide multiple Tags with the same key"}
+)
+
+// Tag comes with limitation as per
+// https://docs.aws.amazon.com/AmazonS3/latest/dev/object-tagging.html amd
+// https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Using_Tags.html#tag-restrictions
+const (
+	maxKeyLength      = 128
+	maxValueLength    = 256
+	maxObjectTagCount = 10
+	maxTagCount       = 50
+)
+
+func checkKey(key string) error {
+	if len(key) == 0 || utf8.RuneCountInString(key) > maxKeyLength || strings.Contains(key, "&") {
+		return errInvalidTagKey
+	}
+
+	return nil
+}
+
+func checkValue(value string) error {
+	if utf8.RuneCountInString(value) > maxValueLength || strings.Contains(value, "&") {
+		return errInvalidTagValue
+	}
+
+	return nil
+}
+
+// Tag denotes key and value.
+type Tag struct {
+	Key   string `xml:"Key"`
+	Value string `xml:"Value"`
+}
+
+func (tag Tag) String() string {
+	return tag.Key + "=" + tag.Value
+}
+
+// IsEmpty returns whether this tag is empty or not.
+func (tag Tag) IsEmpty() bool {
+	return tag.Key == ""
+}
+
+// Validate checks this tag.
+func (tag Tag) Validate() error {
+	if err := checkKey(tag.Key); err != nil {
+		return err
+	}
+
+	return checkValue(tag.Value)
+}
+
+// MarshalXML encodes to XML data.
+func (tag Tag) MarshalXML(e *xml.Encoder, start xml.StartElement) error {
+	if err := tag.Validate(); err != nil {
+		return err
+	}
+
+	type subTag Tag // to avoid recursively calling MarshalXML()
+	return e.EncodeElement(subTag(tag), start)
+}
+
+// UnmarshalXML decodes XML data to tag.
+func (tag *Tag) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error {
+	type subTag Tag // to avoid recursively calling UnmarshalXML()
+	var st subTag
+	if err := d.DecodeElement(&st, &start); err != nil {
+		return err
+	}
+
+	if err := Tag(st).Validate(); err != nil {
+		return err
+	}
+
+	*tag = Tag(st)
+	return nil
+}
+
+// tagSet represents list of unique tags.
+type tagSet struct {
+	tagMap   map[string]string
+	isObject bool
+}
+
+func (tags tagSet) String() string {
+	s := []string{}
+	for key, value := range tags.tagMap {
+		s = append(s, key+"="+value)
+	}
+
+	return strings.Join(s, "&")
+}
+
+func (tags *tagSet) remove(key string) {
+	delete(tags.tagMap, key)
+}
+
+func (tags *tagSet) set(key, value string, failOnExist bool) error {
+	if failOnExist {
+		if _, found := tags.tagMap[key]; found {
+			return errDuplicateTagKey
+		}
+	}
+
+	if err := checkKey(key); err != nil {
+		return err
+	}
+
+	if err := checkValue(value); err != nil {
+		return err
+	}
+
+	if tags.isObject {
+		if len(tags.tagMap) == maxObjectTagCount {
+			return errTooManyObjectTags
+		}
+	} else if len(tags.tagMap) == maxTagCount {
+		return errTooManyTags
+	}
+
+	tags.tagMap[key] = value
+	return nil
+}
+
+func (tags tagSet) toMap() map[string]string {
+	m := make(map[string]string)
+	for key, value := range tags.tagMap {
+		m[key] = value
+	}
+	return m
+}
+
+// MarshalXML encodes to XML data.
+func (tags tagSet) MarshalXML(e *xml.Encoder, start xml.StartElement) error {
+	tagList := struct {
+		Tags []Tag `xml:"Tag"`
+	}{}
+
+	for key, value := range tags.tagMap {
+		tagList.Tags = append(tagList.Tags, Tag{key, value})
+	}
+
+	return e.EncodeElement(tagList, start)
+}
+
+// UnmarshalXML decodes XML data to tag list.
+func (tags *tagSet) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error {
+	tagList := struct {
+		Tags []Tag `xml:"Tag"`
+	}{}
+
+	if err := d.DecodeElement(&tagList, &start); err != nil {
+		return err
+	}
+
+	if tags.isObject {
+		if len(tagList.Tags) > maxObjectTagCount {
+			return errTooManyObjectTags
+		}
+	} else if len(tagList.Tags) > maxTagCount {
+		return errTooManyTags
+	}
+
+	m := map[string]string{}
+	for _, tag := range tagList.Tags {
+		if _, found := m[tag.Key]; found {
+			return errDuplicateTagKey
+		}
+
+		m[tag.Key] = tag.Value
+	}
+
+	tags.tagMap = m
+	return nil
+}
+
+type tagging struct {
+	XMLName xml.Name `xml:"Tagging"`
+	TagSet  *tagSet  `xml:"TagSet"`
+}
+
+// Tags is list of tags of XML request/response as per
+// https://docs.aws.amazon.com/AmazonS3/latest/API/API_GetBucketTagging.html#API_GetBucketTagging_RequestBody
+type Tags tagging
+
+func (tags Tags) String() string {
+	return tags.TagSet.String()
+}
+
+// Remove removes a tag by its key.
+func (tags *Tags) Remove(key string) {
+	tags.TagSet.remove(key)
+}
+
+// Set sets new tag.
+func (tags *Tags) Set(key, value string) error {
+	return tags.TagSet.set(key, value, false)
+}
+
+// ToMap returns copy of tags.
+func (tags Tags) ToMap() map[string]string {
+	return tags.TagSet.toMap()
+}
+
+// NewTags creates Tags from tagMap, If isObject is set, it validates for object tags.
+func NewTags(tagMap map[string]string, isObject bool) (*Tags, error) {
+	tagging := &Tags{
+		TagSet: &tagSet{
+			tagMap:   make(map[string]string),
+			isObject: isObject,
+		},
+	}
+
+	for key, value := range tagMap {
+		if err := tagging.TagSet.set(key, value, true); err != nil {
+			return nil, err
+		}
+	}
+
+	return tagging, nil
+}
+
+func unmarshalXML(reader io.Reader, isObject bool) (*Tags, error) {
+	tagging := &Tags{
+		TagSet: &tagSet{
+			tagMap:   make(map[string]string),
+			isObject: isObject,
+		},
+	}
+
+	if err := xml.NewDecoder(reader).Decode(tagging); err != nil {
+		return nil, err
+	}
+
+	return tagging, nil
+}
+
+// ParseBucketXML decodes XML data of tags in reader specified in
+// https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutBucketTagging.html#API_PutBucketTagging_RequestSyntax.
+func ParseBucketXML(reader io.Reader) (*Tags, error) {
+	return unmarshalXML(reader, false)
+}
+
+// ParseObjectXML decodes XML data of tags in reader specified in
+// https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObjectTagging.html#API_PutObjectTagging_RequestSyntax
+func ParseObjectXML(reader io.Reader) (*Tags, error) {
+	return unmarshalXML(reader, true)
+}
+
+// Parse decodes HTTP query formatted string into tags which is limited by isObject.
+// A query formatted string is like "key1=value1&key2=value2".
+func Parse(s string, isObject bool) (*Tags, error) {
+	values, err := url.ParseQuery(s)
+	if err != nil {
+		return nil, err
+	}
+
+	tagging := &Tags{
+		TagSet: &tagSet{
+			tagMap:   make(map[string]string),
+			isObject: isObject,
+		},
+	}
+
+	for key := range values {
+		if err := tagging.TagSet.set(key, values.Get(key), true); err != nil {
+			return nil, err
+		}
+	}
+
+	return tagging, nil
+}
+
+// ParseObjectTags decodes HTTP query formatted string into tags. A query formatted string is like "key1=value1&key2=value2".
+func ParseObjectTags(s string) (*Tags, error) {
+	return Parse(s, true)
+}

vendor/github.com/minio/minio-go/v6/post-policy.go

@@ -263,7 +263,7 @@ func (p PostPolicy) String() string {
 	return string(p.marshalJSON())
 }
 
-// marshalJSON - Provides Marshalled JSON in bytes.
+// marshalJSON - Provides Marshaled JSON in bytes.
 func (p PostPolicy) marshalJSON() []byte {
 	expirationStr := `"expiration":"` + p.expiration.Format(expirationDateFormat) + `"`
 	var conditionsStr string
@@ -285,7 +285,7 @@ func (p PostPolicy) marshalJSON() []byte {
 	return []byte(retStr)
 }
 
-// base64 - Produces base64 of PostPolicy's Marshalled json.
+// base64 - Produces base64 of PostPolicy's Marshaled json.
 func (p PostPolicy) base64() string {
 	return base64.StdEncoding.EncodeToString(p.marshalJSON())
 }

vendor/github.com/minio/minio-go/v6/s3-endpoints.go

@@ -29,6 +29,7 @@ var awsS3EndpointMap = map[string]string{
 	"eu-west-3":      "s3.dualstack.eu-west-3.amazonaws.com",
 	"eu-central-1":   "s3.dualstack.eu-central-1.amazonaws.com",
 	"eu-north-1":     "s3.dualstack.eu-north-1.amazonaws.com",
+	"eu-south-1":     "s3.dualstack.eu-south-1.amazonaws.com",
 	"ap-east-1":      "s3.dualstack.ap-east-1.amazonaws.com",
 	"ap-south-1":     "s3.dualstack.ap-south-1.amazonaws.com",
 	"ap-southeast-1": "s3.dualstack.ap-southeast-1.amazonaws.com",
@@ -36,6 +37,7 @@ var awsS3EndpointMap = map[string]string{
 	"ap-northeast-1": "s3.dualstack.ap-northeast-1.amazonaws.com",
 	"ap-northeast-2": "s3.dualstack.ap-northeast-2.amazonaws.com",
 	"ap-northeast-3": "s3.dualstack.ap-northeast-3.amazonaws.com",
+	"af-south-1":     "s3.dualstack.af-south-1.amazonaws.com",
 	"me-south-1":     "s3.dualstack.me-south-1.amazonaws.com",
 	"sa-east-1":      "s3.dualstack.sa-east-1.amazonaws.com",
 	"us-gov-west-1":  "s3.dualstack.us-gov-west-1.amazonaws.com",

vendor/github.com/minio/minio-go/v6/transport.go

@@ -21,11 +21,23 @@ package minio
 
 import (
 	"crypto/tls"
+	"crypto/x509"
+	"io/ioutil"
 	"net"
 	"net/http"
+	"os"
 	"time"
 )
 
+// mustGetSystemCertPool - return system CAs or empty pool in case of error (or windows)
+func mustGetSystemCertPool() *x509.CertPool {
+	pool, err := x509.SystemCertPool()
+	if err != nil {
+		return x509.NewCertPool()
+	}
+	return pool
+}
+
 // DefaultTransport - this default transport is similar to
 // http.DefaultTransport but with additional param  DisableCompression
 // is set to true to avoid decompressing content with 'gzip' encoding.
@@ -36,12 +48,12 @@ var DefaultTransport = func(secure bool) (http.RoundTripper, error) {
 			Timeout:   30 * time.Second,
 			KeepAlive: 30 * time.Second,
 		}).DialContext,
-		MaxIdleConns:          1024,
-		MaxIdleConnsPerHost:   1024,
-		ResponseHeaderTimeout: 60 * time.Second,
-		IdleConnTimeout:       60 * time.Second,
+		MaxIdleConns:          256,
+		MaxIdleConnsPerHost:   16,
+		ResponseHeaderTimeout: time.Minute,
+		IdleConnTimeout:       time.Minute,
 		TLSHandshakeTimeout:   10 * time.Second,
-		ExpectContinueTimeout: 1 * time.Second,
+		ExpectContinueTimeout: 10 * time.Second,
 		// Set this value so that the underlying transport round-tripper
 		// doesn't try to auto decode the body of objects with
 		// content-encoding set to `gzip`.
@@ -58,6 +70,14 @@ var DefaultTransport = func(secure bool) (http.RoundTripper, error) {
 			// Can't use TLSv1.1 because of RC4 cipher usage
 			MinVersion: tls.VersionTLS12,
 		}
+		if f := os.Getenv("SSL_CERT_FILE"); f != "" {
+			rootCAs := mustGetSystemCertPool()
+			data, err := ioutil.ReadFile(f)
+			if err == nil {
+				rootCAs.AppendCertsFromPEM(data)
+			}
+			tr.TLSClientConfig.RootCAs = rootCAs
+		}
 	}
 	return tr, nil
 }

vendor/github.com/minio/minio-go/v6/utils.go

@@ -22,6 +22,7 @@ import (
 	"encoding/base64"
 	"encoding/hex"
 	"encoding/xml"
+	"hash"
 	"io"
 	"io/ioutil"
 	"net"
@@ -30,11 +31,12 @@ import (
 	"regexp"
 	"strconv"
 	"strings"
+	"sync"
 	"time"
 
-	"github.com/minio/sha256-simd"
-
+	md5simd "github.com/minio/md5-simd"
 	"github.com/minio/minio-go/v6/pkg/s3utils"
+	"github.com/minio/sha256-simd"
 )
 
 func trimEtag(etag string) string {
@@ -50,14 +52,16 @@ func xmlDecoder(body io.Reader, v interface{}) error {
 
 // sum256 calculate sha256sum for an input byte array, returns hex encoded.
 func sum256Hex(data []byte) string {
-	hash := sha256.New()
+	hash := newSHA256Hasher()
+	defer hash.Close()
 	hash.Write(data)
 	return hex.EncodeToString(hash.Sum(nil))
 }
 
 // sumMD5Base64 calculate md5sum for an input byte array, returns base64 encoded.
 func sumMD5Base64(data []byte) string {
-	hash := md5.New()
+	hash := newMd5Hasher()
+	defer hash.Close()
 	hash.Write(data)
 	return base64.StdEncoding.EncodeToString(hash.Sum(nil))
 }
@@ -175,6 +179,7 @@ func extractObjMetadata(header http.Header) http.Header {
 		"X-Amz-Object-Lock-Legal-Hold",
 		"X-Amz-Website-Redirect-Location",
 		"X-Amz-Server-Side-Encryption",
+		"X-Amz-Tagging-Count",
 		"X-Amz-Meta-",
 		// Add new headers to be preserved.
 		// if you add new headers here, please extend
@@ -324,6 +329,7 @@ var supportedHeaders = []string{
 	"content-language",
 	"x-amz-website-redirect-location",
 	"x-amz-object-lock-mode",
+	"x-amz-metadata-directive",
 	"x-amz-object-lock-retain-until-date",
 	"expires",
 	// Add more supported headers here.
@@ -372,3 +378,34 @@ func isAmzHeader(headerKey string) bool {
 
 	return strings.HasPrefix(key, "x-amz-meta-") || strings.HasPrefix(key, "x-amz-grant-") || key == "x-amz-acl" || isSSEHeader(headerKey)
 }
+
+var md5Pool = sync.Pool{New: func() interface{} { return md5.New() }}
+var sha256Pool = sync.Pool{New: func() interface{} { return sha256.New() }}
+
+func newMd5Hasher() md5simd.Hasher {
+	return hashWrapper{Hash: md5Pool.New().(hash.Hash), isMD5: true}
+}
+
+func newSHA256Hasher() md5simd.Hasher {
+	return hashWrapper{Hash: sha256Pool.New().(hash.Hash), isSHA256: true}
+}
+
+// hashWrapper implements the md5simd.Hasher interface.
+type hashWrapper struct {
+	hash.Hash
+	isMD5    bool
+	isSHA256 bool
+}
+
+// Close will put the hasher back into the pool.
+func (m hashWrapper) Close() {
+	if m.isMD5 && m.Hash != nil {
+		m.Reset()
+		md5Pool.Put(m.Hash)
+	}
+	if m.isSHA256 && m.Hash != nil {
+		m.Reset()
+		sha256Pool.Put(m.Hash)
+	}
+	m.Hash = nil
+}