refine code with vscode lint

sdk/endpoints/endpoints_config_test.go

@@ -1,17 +1,17 @@
 package endpoints
 
 import (
-  "testing"
+	"testing"
 
-  "github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/assert"
 )
 
 func Test_getEndpointConfigData(t *testing.T) {
-  r := getEndpointConfigData()
-  d, ok := r.(map[string]interface{})
-  assert.True(t, ok)
-  products := d["products"]
-  p, ok := products.([]interface{})
-  assert.True(t, ok)
-  assert.Equal(t, 47, len(p))
+	r := getEndpointConfigData()
+	d, ok := r.(map[string]interface{})
+	assert.True(t, ok)
+	products := d["products"]
+	p, ok := products.([]interface{})
+	assert.True(t, ok)
+	assert.Equal(t, 47, len(p))
 }

sdk/endpoints/local_global_resolver.go

@@ -16,16 +16,17 @@ package endpoints
 
 import (
 	"fmt"
-	"github.com/jmespath/go-jmespath"
 	"strings"
+
+	"github.com/jmespath/go-jmespath"
 )
 
 type LocalGlobalResolver struct {
 }
 
 func (resolver *LocalGlobalResolver) GetName() (name string) {
-  name = "local global resolver"
-  return
+	name = "local global resolver"
+	return
 }
 
 func (resolver *LocalGlobalResolver) TryResolve(param *ResolveParam) (endpoint string, support bool, err error) {

sdk/endpoints/local_global_resolver_test.go

@@ -1,39 +1,39 @@
 package endpoints
 
 import (
-  "testing"
+	"testing"
 
-  "github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/assert"
 )
 
 func TestLocalGlobalResolver_GetName(t *testing.T) {
-  resolver := &LocalGlobalResolver{}
-  assert.Equal(t, "local global resolver", resolver.GetName())
+	resolver := &LocalGlobalResolver{}
+	assert.Equal(t, "local global resolver", resolver.GetName())
 }
 
 func TestLocalGlobalResolver_TryResolve(t *testing.T) {
-  resolver := &LocalGlobalResolver{}
-  resolveParam := &ResolveParam{
+	resolver := &LocalGlobalResolver{}
+	resolveParam := &ResolveParam{
 		Product: "ecs",
 	}
-  endpoint, support, err := resolver.TryResolve(resolveParam)
-  assert.Nil(t, err)
-  assert.Equal(t, "", endpoint)
+	endpoint, support, err := resolver.TryResolve(resolveParam)
+	assert.Nil(t, err)
+	assert.Equal(t, "", endpoint)
 	assert.Equal(t, false, support)
 
 	resolveParam = &ResolveParam{
 		Product: "drds",
 	}
-  endpoint, support, err = resolver.TryResolve(resolveParam)
-  assert.Nil(t, err)
-  assert.Equal(t, "drds.aliyuncs.com", endpoint)
+	endpoint, support, err = resolver.TryResolve(resolveParam)
+	assert.Nil(t, err)
+	assert.Equal(t, "drds.aliyuncs.com", endpoint)
 	assert.Equal(t, true, support)
 
 	resolveParam = &ResolveParam{
 		Product: "inexist",
 	}
-  endpoint, support, err = resolver.TryResolve(resolveParam)
-  assert.Nil(t, err)
-  assert.Equal(t, "", endpoint)
+	endpoint, support, err = resolver.TryResolve(resolveParam)
+	assert.Nil(t, err)
+	assert.Equal(t, "", endpoint)
 	assert.Equal(t, false, support)
 }

sdk/endpoints/local_regional_resolver.go

@@ -16,16 +16,17 @@ package endpoints
 
 import (
 	"fmt"
-	"github.com/jmespath/go-jmespath"
 	"strings"
+
+	"github.com/jmespath/go-jmespath"
 )
 
 type LocalRegionalResolver struct {
 }
 
 func (resolver *LocalRegionalResolver) GetName() (name string) {
-  name = "local regional resolver"
-  return
+	name = "local regional resolver"
+	return
 }
 
 func (resolver *LocalRegionalResolver) TryResolve(param *ResolveParam) (endpoint string, support bool, err error) {

sdk/endpoints/local_regional_resolver_test.go

@@ -1,33 +1,33 @@
 package endpoints
 
 import (
-  "testing"
+	"testing"
 
-  "github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/assert"
 )
 
 func TestLocalRegionalResolver_GetName(t *testing.T) {
-  resolver := &LocalRegionalResolver{}
-  assert.Equal(t, "local regional resolver", resolver.GetName())
+	resolver := &LocalRegionalResolver{}
+	assert.Equal(t, "local regional resolver", resolver.GetName())
 }
 
 func TestLocalRegionalResolver_TryResolve(t *testing.T) {
-  resolver := &LocalRegionalResolver{}
-  resolveParam := &ResolveParam{
-		Product: "ecs",
+	resolver := &LocalRegionalResolver{}
+	resolveParam := &ResolveParam{
+		Product:  "ecs",
 		RegionId: "cn-beijing",
 	}
-  endpoint, support, err := resolver.TryResolve(resolveParam)
-  assert.Nil(t, err)
-  assert.Equal(t, "", endpoint)
+	endpoint, support, err := resolver.TryResolve(resolveParam)
+	assert.Nil(t, err)
+	assert.Equal(t, "", endpoint)
 	assert.Equal(t, false, support)
 
 	resolveParam = &ResolveParam{
-		Product: "arms",
+		Product:  "arms",
 		RegionId: "cn-beijing",
 	}
-  endpoint, support, err = resolver.TryResolve(resolveParam)
-  assert.Nil(t, err)
-  assert.Equal(t, "arms.cn-beijing.aliyuncs.com", endpoint)
+	endpoint, support, err = resolver.TryResolve(resolveParam)
+	assert.Nil(t, err)
+	assert.Equal(t, "arms.cn-beijing.aliyuncs.com", endpoint)
 	assert.Equal(t, true, support)
 }

sdk/endpoints/location_resolver_test.go

@@ -1,42 +1,42 @@
 package endpoints
 
 import (
-  "testing"
+	"testing"
 
-  "github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/assert"
 
-  "github.com/aliyun/alibaba-cloud-sdk-go/sdk/errors"
-  "github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
-  "github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/errors"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func TestLocationResolver_GetName(t *testing.T) {
-  resolver := &LocationResolver{}
-  assert.Equal(t, "location resolver", resolver.GetName())
+	resolver := &LocationResolver{}
+	assert.Equal(t, "location resolver", resolver.GetName())
 }
 
 func TestLocationResolver_TryResolve_EmptyLocationProduct(t *testing.T) {
-  resolver := &LocationResolver{}
-  resolveParam := &ResolveParam{}
-  endpoint, support, err := resolver.TryResolve(resolveParam)
-  assert.Nil(t, err)
-  assert.Equal(t, "", endpoint)
-  assert.Equal(t, false, support)
+	resolver := &LocationResolver{}
+	resolveParam := &ResolveParam{}
+	endpoint, support, err := resolver.TryResolve(resolveParam)
+	assert.Nil(t, err)
+	assert.Equal(t, "", endpoint)
+	assert.Equal(t, false, support)
 }
 
 func TestLocationResolver_TryResolve_LocationWithError(t *testing.T) {
-  resolver := &LocationResolver{}
-  resolveParam := &ResolveParam{
-    LocationProduct: "ecs",
-    RegionId: "cn-hangzhou",
-    Product:  "ecs",
-    CommonApi: func(request *requests.CommonRequest) (response *responses.CommonResponse, err error) {
-      err = errors.NewClientError("SDK.MockError", "Mock error", nil)
-      return
-    },
-  }
-  endpoint, support, err := resolver.TryResolve(resolveParam)
-  assert.Equal(t, "", endpoint)
-  assert.Equal(t, false, support)
-  assert.Equal(t, "[SDK.MockError] Mock error", err.Error())
+	resolver := &LocationResolver{}
+	resolveParam := &ResolveParam{
+		LocationProduct: "ecs",
+		RegionId:        "cn-hangzhou",
+		Product:         "ecs",
+		CommonApi: func(request *requests.CommonRequest) (response *responses.CommonResponse, err error) {
+			err = errors.NewClientError("SDK.MockError", "Mock error", nil)
+			return
+		},
+	}
+	endpoint, support, err := resolver.TryResolve(resolveParam)
+	assert.Equal(t, "", endpoint)
+	assert.Equal(t, false, support)
+	assert.Equal(t, "[SDK.MockError] Mock error", err.Error())
 }

sdk/endpoints/mapping_resolver.go

@@ -23,20 +23,24 @@ const keyFormatter = "%s::%s"
 
 var endpointMapping = make(map[string]string)
 
+// AddEndpointMapping Use product id and region id as key to store the endpoint into inner map
 func AddEndpointMapping(regionId, productId, endpoint string) (err error) {
 	key := fmt.Sprintf(keyFormatter, strings.ToLower(regionId), strings.ToLower(productId))
 	endpointMapping[key] = endpoint
 	return nil
 }
 
+// MappingResolver the mapping resolver type
 type MappingResolver struct {
 }
 
+// GetName get the resolver name: "mapping resolver"
 func (resolver *MappingResolver) GetName() (name string) {
-  name = "mapping resolver"
-  return
+	name = "mapping resolver"
+	return
 }
 
+// TryResolve use Product and RegionId as key to find endpoint from inner map
 func (resolver *MappingResolver) TryResolve(param *ResolveParam) (endpoint string, support bool, err error) {
 	key := fmt.Sprintf(keyFormatter, strings.ToLower(param.RegionId), strings.ToLower(param.Product))
 	endpoint, contains := endpointMapping[key]

sdk/endpoints/resolver.go

@@ -17,11 +17,12 @@ package endpoints
 import (
 	"encoding/json"
 	"fmt"
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/utils"
+	"sync"
+
 	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/errors"
 	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
 	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
-	"sync"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/utils"
 )
 
 var debug utils.Debug
@@ -42,6 +43,8 @@ type Resolver interface {
 	GetName() (name string)
 }
 
+// Resolve resolve endpoint with params
+// It will resolve with each supported resolver until anyone resolved
 func Resolve(param *ResolveParam) (endpoint string, err error) {
 	supportedResolvers := getAllResolvers()
 	var lastErr error

sdk/endpoints/simple_host_resolver.go

@@ -14,14 +14,17 @@
 
 package endpoints
 
+// SimpleHostResolver the simple host resolver type
 type SimpleHostResolver struct {
 }
 
+// GetName get the resolver name: "simple host resolver"
 func (resolver *SimpleHostResolver) GetName() (name string) {
-  name = "simple host resolver"
-  return
+	name = "simple host resolver"
+	return
 }
 
+// TryResolve if the Domain exist in param, use it as endpoint
 func (resolver *SimpleHostResolver) TryResolve(param *ResolveParam) (endpoint string, support bool, err error) {
 	if support = len(param.Domain) > 0; support {
 		endpoint = param.Domain