be compatible for go 1.10

bachue · bachue · commit f824d4a08bad · 2024-04-26T08:34:56.000Z
diff --git a/storage/region_uc_v2_test.go b/storage/region_uc_v2_test.go
@@ -4,7 +4,9 @@
 package storage
 
 import (
+	"os"
 	"strings"
+	"sync"
 	"testing"
 
 	clientV1 "github.com/qiniu/go-sdk/v7/client"
@@ -21,6 +23,9 @@ func TestUCRetry(t *testing.T) {
 	SetUcHosts("aaa.aaa.com", "uc.qbox.me")
 	defer SetUcHosts("uc.qbox.me")
 
+	_ = os.Remove(regionV2CachePath)
+	regionV2Cache = sync.Map{}
+
 	r, err := GetRegion(testAK, testBucket)
 	if err != nil {
 		t.Fatalf("GetRegion error:%v", err)
diff --git a/storagev2/http_client/http_client.go b/storagev2/http_client/http_client.go
@@ -192,7 +192,9 @@ func NewClient(options *Options) *Client {
 		options.ShouldFreezeHost = defaultShouldFreezeHost
 	}
 	if options.Credentials == nil {
-		options.Credentials = auth.Default()
+		if defaultAuth := auth.Default(); defaultAuth != nil {
+			options.Credentials = defaultAuth
+		}
 	}
 
 	return &Client{
diff --git a/storagev2/internal/uplog/dns1.12.go b/storagev2/internal/uplog/dns1.12.go
@@ -0,0 +1,10 @@
+//go:build !1.13
+// +build !1.13
+
+package uplog
+
+import "net"
+
+func isDnsNotFoundError(dnsError *net.DNSError) bool {
+	return !dnsError.IsTemporary
+}
diff --git a/storagev2/internal/uplog/dns1.13.go b/storagev2/internal/uplog/dns1.13.go
@@ -0,0 +1,10 @@
+//go:build 1.13
+// +build 1.13
+
+package uplog
+
+import "net"
+
+func isDnsNotFoundError(dnsError *net.DNSError) bool {
+	return dnsError.IsNotFound
+}
diff --git a/storagev2/internal/uplog/uplog.go b/storagev2/internal/uplog/uplog.go
@@ -2,10 +2,7 @@ package uplog
 
 import (
 	"context"
-	"crypto/tls"
-	"errors"
 	"net"
-	"net/http"
 	"net/url"
 	"os"
 	"strings"
@@ -75,30 +72,47 @@ func getOsVersion() (string, error) {
 }
 
 func detectErrorType(err error) ErrorType {
-	var (
-		dnsError           *net.DNSError
-		urlError           *url.Error
-		tlsVerifyCertError *tls.CertificateVerificationError
-		syscallError       syscall.Errno
-	)
-	if os.IsTimeout(err) || errors.Is(err, syscall.ETIMEDOUT) {
+	tryToUnwrapUnderlyingError := func(err error) (error, bool) {
+		switch err := err.(type) {
+		case *os.PathError:
+			return err.Err, true
+		case *os.LinkError:
+			return err.Err, true
+		case *os.SyscallError:
+			return err.Err, true
+		case *url.Error:
+			return err.Err, true
+		case *net.OpError:
+			return err.Err, true
+		}
+		return err, false
+	}
+	unwrapUnderlyingError := func(err error) error {
+		ok := true
+		for ok {
+			err, ok = tryToUnwrapUnderlyingError(err)
+		}
+		return err
+	}
+
+	unwrapedErr := unwrapUnderlyingError(err)
+	if os.IsTimeout(unwrapedErr) {
 		return ErrorTypeTimeout
-	} else if errors.As(err, &dnsError) && dnsError.IsNotFound {
+	} else if dnsError, ok := unwrapedErr.(*net.DNSError); ok && isDnsNotFoundError(dnsError) {
 		return ErrorTypeUnknownHost
-	} else if os.IsNotExist(err) || os.IsPermission(err) {
+	} else if os.IsNotExist(unwrapedErr) || os.IsPermission(unwrapedErr) {
 		return ErrorTypeLocalIoError
-	} else if errors.Is(err, syscall.ECONNREFUSED) || errors.Is(err, syscall.ECONNABORTED) || errors.Is(err, syscall.ECONNRESET) {
-		return ErrorTypeCannotConnectToHost
-	} else if errors.As(err, &syscallError) {
-		return ErrorTypeUnexpectedSyscallError
-	} else if errors.Is(err, context.Canceled) {
+	} else if syscallError, ok := unwrapedErr.(*os.SyscallError); ok {
+		switch syscallError.Err {
+		case syscall.ECONNREFUSED, syscall.ECONNABORTED, syscall.ECONNRESET:
+			return ErrorTypeCannotConnectToHost
+		default:
+			return ErrorTypeUnexpectedSyscallError
+		}
+	} else if unwrapedErr == context.Canceled {
 		return ErrorTypeUserCanceled
-	} else if errors.Is(err, http.ErrSchemeMismatch) {
-		return ErrorTypeProtocolError
-	} else if errors.As(err, &tlsVerifyCertError) {
-		return ErrorTypeSSLError
-	} else if errors.As(err, &urlError) {
-		desc := urlError.Err.Error()
+	} else {
+		desc := unwrapedErr.Error()
 		if strings.HasPrefix(desc, "tls: ") ||
 			strings.HasPrefix(desc, "x509: ") {
 			return ErrorTypeSSLError
@@ -108,8 +122,8 @@ func detectErrorType(err error) ErrorType {
 			strings.Contains(desc, "server closed idle connection") {
 			return ErrorTypeTransmissionError
 		}
+		return ErrorTypeUnknownError
 	}
-	return ErrorTypeUnknownError
 }
 
 func getHttpClientName() string {
diff --git a/storagev2/internal/uplog/uplog_buffer.go b/storagev2/internal/uplog/uplog_buffer.go
@@ -4,6 +4,7 @@ import (
 	"bytes"
 	"compress/gzip"
 	"io"
+	"io/ioutil"
 	"os"
 	"path/filepath"
 	"strings"
@@ -243,7 +244,8 @@ func SetWriteFileBufferInterval(d time.Duration) {
 		d = 1 * time.Minute
 	}
 	uplogWriteFileBufferInterval = d
-	uplogWriteFileBufferTicker.Reset(d)
+	uplogWriteFileBufferTicker.Stop()
+	uplogWriteFileBufferTicker = time.NewTicker(d)
 }
 
 func GetWriteFileBufferInterval() time.Duration {
@@ -256,7 +258,8 @@ func GetWriteFileBufferInterval() time.Duration {
 func resetWriteFileBufferInterval() {
 	uplogWriteFileBufferTimerLock.Lock()
 	defer uplogWriteFileBufferTimerLock.Unlock()
-	uplogWriteFileBufferTicker.Reset(uplogWriteFileBufferInterval)
+	uplogWriteFileBufferTicker.Stop()
+	uplogWriteFileBufferTicker = time.NewTicker(uplogWriteFileBufferInterval)
 }
 
 type multipleFileReader struct {
@@ -330,14 +333,14 @@ func (r *multipleFileReader) Close() error {
 }
 
 func getArchivedUplogFileBufferPaths(dirPath string) ([]string, error) {
-	dirEntries, err := os.ReadDir(dirPath)
+	dirEntries, err := ioutil.ReadDir(dirPath)
 	if err != nil {
 		return nil, err
 	}
 
 	archivedPaths := make([]string, 0, len(dirEntries))
 	for _, dirEntry := range dirEntries {
-		if !dirEntry.Type().IsRegular() {
+		if !dirEntry.Mode().IsRegular() {
 			continue
 		}
 		if !strings.HasPrefix(dirEntry.Name(), UPLOG_FILE_BUFFER_NAME+".") {
diff --git a/storagev2/retrier/dns1.12.go b/storagev2/retrier/dns1.12.go
@@ -0,0 +1,10 @@
+//go:build !1.13
+// +build !1.13
+
+package retrier
+
+import "net"
+
+func isDnsNotFoundError(dnsError *net.DNSError) bool {
+	return !dnsError.IsTemporary
+}
diff --git a/storagev2/retrier/dns1.13.go b/storagev2/retrier/dns1.13.go
@@ -0,0 +1,10 @@
+//go:build 1.13
+// +build 1.13
+
+package retrier
+
+import "net"
+
+func isDnsNotFoundError(dnsError *net.DNSError) bool {
+	return dnsError.IsNotFound
+}
diff --git a/storagev2/retrier/retrier.go b/storagev2/retrier/retrier.go
@@ -2,7 +2,6 @@ package retrier
 
 import (
 	"context"
-	"errors"
 	"net"
 	"net/http"
 	"net/url"
@@ -114,37 +113,56 @@ func getRetryDecisionForError(err error) RetryDecision {
 		return DontRetry
 	}
 
-	var dnsError *net.DNSError
-	if os.IsTimeout(err) || errors.Is(err, syscall.ETIMEDOUT) {
-		return RetryRequest
-	} else if errors.As(err, &dnsError) && dnsError.IsNotFound {
-		return TryNextHost
-	} else if errors.Is(err, syscall.ECONNREFUSED) || errors.Is(err, syscall.ECONNABORTED) || errors.Is(err, syscall.ECONNRESET) {
-		return TryNextHost
-	} else if errors.Is(err, context.Canceled) {
-		return DontRetry
-	} else if errors.Is(err, http.ErrSchemeMismatch) {
-		return DontRetry
+	tryToUnwrapUnderlyingError := func(err error) (error, bool) {
+		switch err := err.(type) {
+		case *os.PathError:
+			return err.Err, true
+		case *os.LinkError:
+			return err.Err, true
+		case *os.SyscallError:
+			return err.Err, true
+		case *url.Error:
+			return err.Err, true
+		case *net.OpError:
+			return err.Err, true
+		}
+		return err, false
+	}
+	unwrapUnderlyingError := func(err error) error {
+		ok := true
+		for ok {
+			err, ok = tryToUnwrapUnderlyingError(err)
+		}
+		return err
 	}
 
-	switch t := err.(type) {
-	case *url.Error:
-		desc := err.Error()
-		if strings.Contains(desc, "use of closed network connection") ||
-			strings.Contains(desc, "unexpected EOF reading trailer") ||
-			strings.Contains(desc, "transport connection broken") ||
-			strings.Contains(desc, "server closed idle connection") {
-			return RetryRequest
-		} else {
+	unwrapedErr := unwrapUnderlyingError(err)
+	if os.IsTimeout(unwrapedErr) {
+		return RetryRequest
+	} else if dnsError, ok := unwrapedErr.(*net.DNSError); ok && isDnsNotFoundError(dnsError) {
+		return TryNextHost
+	} else if syscallError, ok := unwrapedErr.(*os.SyscallError); ok {
+		switch syscallError.Err {
+		case syscall.ECONNREFUSED, syscall.ECONNABORTED, syscall.ECONNRESET:
+			return TryNextHost
+		default:
 			return DontRetry
 		}
-	case *clientv1.ErrorInfo:
-		if isStatusCodeRetryable(t.Code) {
+	} else if unwrapedErr == context.Canceled {
+		return DontRetry
+	} else if clientErr, ok := unwrapedErr.(*clientv1.ErrorInfo); ok {
+		if isStatusCodeRetryable(clientErr.Code) {
 			return RetryRequest
 		} else {
 			return DontRetry
 		}
-	default:
+	}
+	desc := unwrapedErr.Error()
+	if strings.Contains(desc, "use of closed network connection") ||
+		strings.Contains(desc, "unexpected EOF reading trailer") ||
+		strings.Contains(desc, "transport connection broken") ||
+		strings.Contains(desc, "server closed idle connection") {
 		return RetryRequest
 	}
+	return DontRetry
 }

Original file line number	Diff line number	Diff line change
`@@ -192,7 +192,9 @@ func NewClient(options Options) Client {`
`192`	`192`	`options.ShouldFreezeHost = defaultShouldFreezeHost`
`193`	`193`	`}`
`194`	`194`	`if options.Credentials == nil {`
`195`		`- options.Credentials = auth.Default()`
	`195`	`+ if defaultAuth := auth.Default(); defaultAuth != nil {`
	`196`	`+ options.Credentials = defaultAuth`
	`197`	`+ }`
`196`	`198`	`}`
`197`	`199`
`198`	`200`	`return &Client{`