release 0.0.5-beta source code for go

Author: unionsdk

CHANGELOG.md

@@ -1,4 +1,15 @@
-# 0.0.4-beta # 0.0.4-beta 2023-02-20
+# 0.0.5-beta 2023-04-14
+
+### G42Cloud SDK Core
+
+- _Features_
+  - None
+- _Bug Fix_
+  - None
+- _Change_
+  - Optimize the code structure.
+
+# 0.0.4-beta 2023-02-20
 
 ### G42Cloud SDK CBR
 

core/auth/signer/derived_signer.go

@@ -22,6 +22,7 @@ package signer
 import (
 	"crypto/sha256"
 	"encoding/hex"
+	"errors"
 	"fmt"
 	"github.com/g42cloud-sdk/g42cloud-sdk-go/core/request"
 	"golang.org/x/crypto/hkdf"
@@ -62,8 +63,17 @@ func StringToSignDerived(canonicalRequest string, info string, t time.Time) (str
 
 // SignDerived SignRequest set Authorization header
 func SignDerived(r *request.DefaultHttpRequest, ak string, sk string, derivedAuthServiceName string, regionId string) (map[string]string, error) {
-	if derivedAuthServiceName == "" || regionId == "" {
-		panic("DerivedAuthServiceName and RegionId in credential is required when using derived auth")
+	if ak == "" {
+		return nil, errors.New("AK is required in credentials")
+	}
+	if sk == "" {
+		return nil, errors.New("SK is required in credentials")
+	}
+	if derivedAuthServiceName == "" {
+		return nil, errors.New("DerivedAuthServiceName is required in credentials when using derived auth")
+	}
+	if regionId == "" {
+		return nil, errors.New("RegionId is required in credentials when using derived auth")
 	}
 
 	var err error

core/auth/signer/signer.go

@@ -8,6 +8,7 @@ package signer
 import (
 	"crypto/hmac"
 	"crypto/sha256"
+	"errors"
 	"fmt"
 	"net/url"
 	"reflect"
@@ -213,6 +214,13 @@ func AuthHeaderValue(signature, accessKey string, signedHeaders []string) string
 
 // SignRequest set Authorization header
 func Sign(r *request.DefaultHttpRequest, ak string, sk string) (map[string]string, error) {
+	if ak == "" {
+		return nil, errors.New("ak is required in credentials")
+	}
+	if sk == "" {
+		return nil, errors.New("sk is required in credentials")
+	}
+
 	var err error
 	var t time.Time
 	var headerParams = make(map[string]string)

core/converter/converters.go

@@ -61,6 +61,8 @@ func ConvertInterfaceToString(value interface{}) string {
 		return strconv.FormatInt(value.(int64), 10)
 	case uint64:
 		return strconv.FormatUint(value.(uint64), 10)
+	case bool:
+		return strconv.FormatBool(value.(bool))
 	case string:
 		return value.(string)
 	case []byte:

core/hc_http_client.go

@@ -34,32 +34,37 @@ import (
 	"github.com/g42cloud-sdk/g42cloud-sdk-go/core/response"
 	"github.com/g42cloud-sdk/g42cloud-sdk-go/core/sdkerr"
 	jsoniter "github.com/json-iterator/go"
+	"go.mongodb.org/mongo-driver/bson"
 	"io/ioutil"
+	"net"
 	"net/url"
 	"reflect"
 	"strings"
+	"sync/atomic"
 )
 
 const (
-	userAgent      = "User-Agent"
-	xRequestId     = "X-Request-Id"
-	contentType    = "Content-Type"
-	applicationXml = "application/xml"
+	userAgent       = "User-Agent"
+	xRequestId      = "X-Request-Id"
+	contentType     = "Content-Type"
+	applicationXml  = "application/xml"
+	applicationBson = "application/bson"
 )
 
 type HcHttpClient struct {
-	endpoint    string
-	credential  auth.ICredential
-	extraHeader map[string]string
-	httpClient  *impl.DefaultHttpClient
+	endpoints     []string
+	endpointIndex int32
+	credential    auth.ICredential
+	extraHeader   map[string]string
+	httpClient    *impl.DefaultHttpClient
 }
 
 func NewHcHttpClient(httpClient *impl.DefaultHttpClient) *HcHttpClient {
 	return &HcHttpClient{httpClient: httpClient}
 }
 
-func (hc *HcHttpClient) WithEndpoint(endpoint string) *HcHttpClient {
-	hc.endpoint = endpoint
+func (hc *HcHttpClient) WithEndpoints(endpoints []string) *HcHttpClient {
+	hc.endpoints = endpoints
 	return hc
 }
 
@@ -87,14 +92,23 @@ func (hc *HcHttpClient) Sync(req interface{}, reqDef *def.HttpRequestDef) (inter
 
 func (hc *HcHttpClient) SyncInvoke(req interface{}, reqDef *def.HttpRequestDef,
 	exchange *exchange.SdkExchange) (interface{}, error) {
-	httpRequest, err := hc.buildRequest(req, reqDef)
-	if err != nil {
-		return nil, err
-	}
+	var resp *response.DefaultHttpResponse
+	for {
+		httpRequest, err := hc.buildRequest(req, reqDef)
+		if err != nil {
+			return nil, err
+		}
 
-	resp, err := hc.httpClient.SyncInvokeHttpWithExchange(httpRequest, exchange)
-	if err != nil {
-		return nil, err
+		resp, err = hc.httpClient.SyncInvokeHttpWithExchange(httpRequest, exchange)
+		if err == nil {
+			break
+		}
+
+		if isNoSuchHostErr(err) && atomic.LoadInt32(&hc.endpointIndex) < int32(len(hc.endpoints)-1) {
+			atomic.AddInt32(&hc.endpointIndex, 1)
+		} else {
+			return nil, err
+		}
 	}
 
 	return hc.extractResponse(resp, reqDef)
@@ -104,7 +118,7 @@ func (hc *HcHttpClient) extractEndpoint(req interface{}, reqDef *def.HttpRequest
 	var endpoint string
 	for _, v := range reqDef.RequestFields {
 		if v.LocationType == def.Cname {
-			u, err := url.Parse(hc.endpoint)
+			u, err := url.Parse(hc.endpoints[atomic.LoadInt32(&hc.endpointIndex)])
 			if err != nil {
 				return "", err
 			}
@@ -117,7 +131,7 @@ func (hc *HcHttpClient) extractEndpoint(req interface{}, reqDef *def.HttpRequest
 	}
 
 	if endpoint == "" {
-		endpoint = hc.endpoint
+		endpoint = hc.endpoints[hc.endpointIndex]
 	}
 
 	return endpoint, nil
@@ -342,14 +356,16 @@ func (hc *HcHttpClient) deserializeResponseFields(resp *response.DefaultHttpResp
 
 			bodyErr := hc.deserializeResponseBody(reqDef, data)
 			if bodyErr != nil {
-				return processError(err)
+				return processError(bodyErr)
 			}
 		}
 	}
 
 	if len(data) != 0 && !hasBody {
 		if strings.Contains(resp.Response.Header.Get(contentType), applicationXml) {
 			err = xml.Unmarshal(data, &reqDef.Response)
+		} else if strings.Contains(resp.Response.Header.Get(contentType), applicationBson) {
+			err = bson.Unmarshal(data, reqDef.Response)
 		} else {
 			err = jsoniter.Unmarshal(data, &reqDef.Response)
 		}
@@ -387,8 +403,12 @@ func (hc *HcHttpClient) deserializeResponseBody(reqDef *def.HttpRequestDef, data
 			} else {
 				bodyIns = reflect.New(body.Type).Interface()
 			}
-
-			err := json.Unmarshal(data, bodyIns)
+			var err error
+			if reqDef.ContentType == applicationBson {
+				err = bson.Unmarshal(data, bodyIns)
+			} else {
+				err = json.Unmarshal(data, bodyIns)
+			}
 			if err != nil {
 				return err
 			}
@@ -451,3 +471,27 @@ func (hc *HcHttpClient) getFieldInfo(reqDef *def.HttpRequestDef, item *def.Field
 
 	return isPtr, fieldKind
 }
+
+func isNoSuchHostErr(err error) bool {
+	if err == nil {
+		return false
+	}
+	var errInterface interface{} = err
+	if innerErr, ok := errInterface.(*url.Error); !ok {
+		return false
+	} else {
+		errInterface = innerErr.Err
+	}
+
+	if innerErr, ok := errInterface.(*net.OpError); !ok {
+		return false
+	} else {
+		errInterface = innerErr.Err
+	}
+
+	if innerErr, ok := errInterface.(*net.DNSError); !ok {
+		return false
+	} else {
+		return innerErr.Err == "no such host"
+	}
+}

core/hc_http_client_builder.go

@@ -34,7 +34,7 @@ type HcHttpClientBuilder struct {
 	CredentialsType        []string
 	derivedAuthServiceName string
 	credentials            auth.ICredential
-	endpoint               string
+	endpoints              []string
 	httpConfig             *config.HttpConfig
 	region                 *region.Region
 }
@@ -56,8 +56,13 @@ func (builder *HcHttpClientBuilder) WithDerivedAuthServiceName(derivedAuthServic
 	return builder
 }
 
+// Deprecated: As of 0.1.27, because of the support of the multi-endpoint feature, use WithEndpoints instead
 func (builder *HcHttpClientBuilder) WithEndpoint(endpoint string) *HcHttpClientBuilder {
-	builder.endpoint = endpoint
+	return builder.WithEndpoints([]string{endpoint})
+}
+
+func (builder *HcHttpClientBuilder) WithEndpoints(endpoints []string) *HcHttpClientBuilder {
+	builder.endpoints = endpoints
 	return builder
 }
 
@@ -109,18 +114,20 @@ func (builder *HcHttpClientBuilder) Build() *HcHttpClient {
 	}
 
 	if builder.region != nil {
-		builder.endpoint = builder.region.Endpoint
+		builder.endpoints = builder.region.Endpoints
 		builder.credentials.ProcessAuthParams(defaultHttpClient, builder.region.Id)
 
 		if credential, ok := builder.credentials.(auth.IDerivedCredential); ok {
 			credential.ProcessDerivedAuthParams(builder.derivedAuthServiceName, builder.region.Id)
 		}
 	}
 
-	if !strings.HasPrefix(builder.endpoint, "http") {
-		builder.endpoint = "https://" + builder.endpoint
+	for index, endpoint := range builder.endpoints {
+		if !strings.HasPrefix(endpoint, "http") {
+			builder.endpoints[index] = "https://" + endpoint
+		}
 	}
 
-	hcHttpClient := NewHcHttpClient(defaultHttpClient).WithEndpoint(builder.endpoint).WithCredential(builder.credentials)
+	hcHttpClient := NewHcHttpClient(defaultHttpClient).WithEndpoints(builder.endpoints).WithCredential(builder.credentials)
 	return hcHttpClient
 }

core/hc_http_client_builder_test.go

@@ -30,15 +30,16 @@ func TestHcHttpClientBuilder_Build(t *testing.T) {
 		err := recover()
 		assert.NotNil(t, err)
 	}()
+	endpoints := []string{"endpoint"}
 	err := os.Setenv("G42CLOUD_SDK_CREDENTIALS_FILE", "/cred")
 	assert.Nil(t, err)
-	client := NewHcHttpClientBuilder().WithEndpoint("endpoint").Build()
+	client := NewHcHttpClientBuilder().WithEndpoints(endpoints).Build()
 	assert.Nil(t, client.credential)
 
 	err = os.Setenv("G42CLOUD_SDK_AK", "ak")
 	assert.Nil(t, err)
 	err = os.Setenv("G42CLOUD_SDK_SK", "sk")
 	assert.Nil(t, err)
-	client = NewHcHttpClientBuilder().WithEndpoint("endpoint").Build()
+	client = NewHcHttpClientBuilder().WithEndpoints(endpoints).Build()
 	assert.NotNil(t, client.credential)
 }

core/region/region.go

@@ -20,18 +20,23 @@
 package region
 
 type Region struct {
-	Id       string
-	Endpoint string
+	Id        string
+	Endpoints []string
 }
 
-func NewRegion(id string, endpoint string) *Region {
+func NewRegion(id string, endpoints ...string) *Region {
 	return &Region{
-		Id:       id,
-		Endpoint: endpoint,
+		Id:        id,
+		Endpoints: endpoints,
 	}
 }
 
+// Deprecated: As of 0.1.27, because of the support of the multi-endpoint feature, use WithEndpointsOverride instead
 func (r *Region) WithEndpointOverride(endpoint string) *Region {
-	r.Endpoint = endpoint
+	return r.WithEndpointsOverride([]string{endpoint})
+}
+
+func (r *Region) WithEndpointsOverride(endpoints []string) *Region {
+	r.Endpoints = endpoints
 	return r
 }

core/region/region_test.go

@@ -36,14 +36,15 @@ var endpoint = fmt.Sprintf("https://%s.%s.myg42cloud.com", strings.ToLower(servi
 func TestNewRegion(t *testing.T) {
 	reg := NewRegion(regionId, endpoint)
 	assert.Equal(t, &Region{
-		Id:       regionId,
-		Endpoint: endpoint,
+		Id:        regionId,
+		Endpoints: []string{endpoint},
 	}, reg)
 }
 
-func TestRegion_WithEndpointOverride(t *testing.T) {
+func TestRegion_WithEndpointsOverride(t *testing.T) {
+	testEndpoints := []string{"test"}
 	reg := NewRegion(regionId, endpoint)
-	assert.Equal(t, endpoint, reg.Endpoint)
-	reg.WithEndpointOverride("test")
-	assert.Equal(t, "test", reg.Endpoint)
+	assert.Equal(t, endpoint, reg.Endpoints[0])
+	reg.WithEndpointsOverride(testEndpoints)
+	assert.Equal(t, testEndpoints, reg.Endpoints)
 }

core/request/default_http_request.go

@@ -27,6 +27,7 @@ import (
 	"errors"
 	"fmt"
 	"github.com/g42cloud-sdk/g42cloud-sdk-go/core/converter"
+	"go.mongodb.org/mongo-driver/bson"
 	"io"
 	"mime/multipart"
 	"net/http"
@@ -114,12 +115,17 @@ func (httpRequest *DefaultHttpRequest) GetBodyToBytes() (*bytes.Buffer, error) {
 			if httpRequest.headerParams["Content-Type"] == "application/xml" {
 				encoder := xml.NewEncoder(buf)
 				err = encoder.Encode(httpRequest.body)
+			} else if httpRequest.headerParams["Content-Type"] == "application/bson" {
+				buffer, err := bson.Marshal(httpRequest.body)
+				if err != nil {
+					return nil, err
+				}
+				buf.Write(buffer)
 			} else {
 				encoder := json.NewEncoder(buf)
 				encoder.SetEscapeHTML(false)
 				err = encoder.Encode(httpRequest.body)
 			}
-
 			if err != nil {
 				return nil, err
 			}