feat(volcengine): add demo replay support

Author: 404tk

pkg/providers/alibaba/replay/meta.go

@@ -1,26 +1,30 @@
 package replay
 
-import "strings"
+import (
+	"strings"
+
+	demoreplay "github.com/404tk/cloudtoolkit/pkg/providers/replay"
+)
 
 type Credentials struct {
 	AccessKey string
 	SecretKey string
 }
 
 func SupportsProvider(provider string) bool {
-	return normalizeProvider(provider) == "alibaba"
+	return strings.TrimSpace(provider) == "alibaba"
 }
 
 func CredentialsFor(provider string) (Credentials, bool) {
 	if !SupportsProvider(provider) {
 		return Credentials{}, false
 	}
+	creds, ok := demoreplay.CredentialsFor("alibaba")
+	if !ok {
+		return Credentials{}, false
+	}
 	return Credentials{
-		AccessKey: DemoAccessKeyID,
-		SecretKey: DemoAccessKeySecret,
+		AccessKey: creds.AccessKey,
+		SecretKey: creds.SecretKey,
 	}, true
 }
-
-func normalizeProvider(provider string) string {
-	return strings.TrimSpace(provider)
-}

pkg/providers/alibaba/replay/state.go

@@ -1,46 +1,23 @@
 package replay
 
-import "sync"
-
-type replayState struct {
-	Active   bool
-	Provider string
-}
-
-var (
-	replayStateMu sync.RWMutex
-	currentState  replayState
-)
+import demoreplay "github.com/404tk/cloudtoolkit/pkg/providers/replay"
 
 func Enable(provider string) {
-	replayStateMu.Lock()
-	defer replayStateMu.Unlock()
-	currentState = replayState{
-		Active:   true,
-		Provider: normalizeProvider(provider),
-	}
+	demoreplay.Enable(provider)
 }
 
 func Disable() {
-	replayStateMu.Lock()
-	defer replayStateMu.Unlock()
-	currentState = replayState{}
+	demoreplay.Disable()
 }
 
 func IsActive() bool {
-	replayStateMu.RLock()
-	defer replayStateMu.RUnlock()
-	return currentState.Active && currentState.Provider != ""
+	return demoreplay.IsActive()
 }
 
 func ActiveProvider() string {
-	replayStateMu.RLock()
-	defer replayStateMu.RUnlock()
-	return currentState.Provider
+	return demoreplay.ActiveProvider()
 }
 
 func IsActiveForProvider(provider string) bool {
-	replayStateMu.RLock()
-	defer replayStateMu.RUnlock()
-	return currentState.Active && currentState.Provider != "" && currentState.Provider == normalizeProvider(provider)
+	return demoreplay.IsActiveForProvider(provider)
 }

pkg/providers/alibaba/replay/transport.go

@@ -69,8 +69,8 @@ func (t *transport) handleRPC(req *http.Request) (*http.Response, error) {
 
 	host := strings.ToLower(req.URL.Hostname())
 	action := strings.TrimSpace(req.URL.Query().Get("Action"))
-	switch host {
-	case "sts.aliyuncs.com":
+	switch rpcProductFromHost(host) {
+	case "sts":
 		if action == "GetCallerIdentity" {
 			return jsonResponse(req, http.StatusOK, api.GetCallerIdentityResponse{
 				IdentityType: "RAMUser",
@@ -81,7 +81,7 @@ func (t *transport) handleRPC(req *http.Request) (*http.Response, error) {
 				Arn:          demoCallerArn(),
 			}), nil
 		}
-	case "business.aliyuncs.com":
+	case "bssopenapi":
 		if action == "QueryAccountBalance" {
 			return jsonResponse(req, http.StatusOK, api.QueryAccountBalanceResponse{
 				Code:      "Success",
@@ -93,23 +93,51 @@ func (t *transport) handleRPC(req *http.Request) (*http.Response, error) {
 				},
 			}), nil
 		}
-	case "ecs.aliyuncs.com":
+	case "ecs":
 		return t.handleECS(req, action)
-	case "ram.aliyuncs.com":
+	case "ram":
 		return t.handleRAM(req, action)
-	case "rds.aliyuncs.com":
+	case "rds":
 		return t.handleRDS(req, action)
-	case "tds.aliyuncs.com":
+	case "sas":
 		return t.handleSAS(req, action)
-	case "alidns.aliyuncs.com":
+	case "alidns":
 		return t.handleDNS(req, action)
-	case "dysmsapi.aliyuncs.com":
+	case "dysmsapi":
 		return t.handleSMS(req, action)
+	case "location":
+		return t.handleLocation(req, action)
 	}
 
 	return rpcErrorResponse(req, http.StatusNotFound, "InvalidAction.NotFound", fmt.Sprintf("Unsupported replay action: %s", action)), nil
 }
 
+func (t *transport) handleLocation(req *http.Request, action string) (*http.Response, error) {
+	if action != "DescribeEndpoints" {
+		return rpcErrorResponse(req, http.StatusNotFound, "InvalidAction.NotFound", fmt.Sprintf("Unsupported Location replay action: %s", action)), nil
+	}
+
+	serviceCode := strings.TrimSpace(req.URL.Query().Get("ServiceCode"))
+	region := strings.TrimSpace(req.URL.Query().Get("Id"))
+	if region == "" {
+		region = api.DefaultRegion
+	}
+	host := ""
+	switch serviceCode {
+	case "ecs":
+		host = replayECSEndpoint(region)
+	}
+	return jsonResponse(req, http.StatusOK, map[string]any{
+		"RequestId": "req-location-endpoints",
+		"Success":   true,
+		"Endpoints": map[string]any{
+			"Endpoint": []map[string]string{
+				{"Endpoint": host},
+			},
+		},
+	}), nil
+}
+
 func (t *transport) handleECS(req *http.Request, action string) (*http.Response, error) {
 	query := req.URL.Query()
 	switch action {
@@ -906,6 +934,68 @@ func isSLSHost(req *http.Request) bool {
 	return strings.Contains(strings.ToLower(req.URL.Hostname()), ".log.aliyuncs.com")
 }
 
+func rpcProductFromHost(host string) string {
+	host = normalizeRPCReplayHost(host)
+	switch {
+	case host == "sts.aliyuncs.com" || strings.HasPrefix(host, "sts-vpc."):
+		return "sts"
+	case host == "location-readonly.aliyuncs.com":
+		return "location"
+	case host == "business.aliyuncs.com" || strings.HasPrefix(host, "business."):
+		return "bssopenapi"
+	case host == "ram.aliyuncs.com":
+		return "ram"
+	case host == "alidns.aliyuncs.com":
+		return "alidns"
+	case host == "dysmsapi.aliyuncs.com":
+		return "dysmsapi"
+	case host == "tds.aliyuncs.com":
+		return "sas"
+	case isECSRPCHost(host):
+		return "ecs"
+	case isRDSRPCHost(host):
+		return "rds"
+	default:
+		return ""
+	}
+}
+
+func isECSRPCHost(host string) bool {
+	host = normalizeRPCReplayHost(host)
+	return host == "ecs.aliyuncs.com" ||
+		strings.HasPrefix(host, "ecs-") ||
+		strings.HasPrefix(host, "ecs.") ||
+		strings.HasPrefix(host, "ecs-vpc.")
+}
+
+func isRDSRPCHost(host string) bool {
+	host = normalizeRPCReplayHost(host)
+	return host == "rds.aliyuncs.com" ||
+		strings.HasPrefix(host, "rds-") ||
+		strings.HasPrefix(host, "rds.") ||
+		strings.HasPrefix(host, "rds-vpc.")
+}
+
+func replayECSEndpoint(region string) string {
+	region = strings.TrimSpace(region)
+	if region == "" {
+		region = api.DefaultRegion
+	}
+	switch {
+	case strings.HasPrefix(region, "cn-"):
+		return "ecs-" + region + ".aliyuncs.com"
+	default:
+		return "ecs." + region + ".aliyuncs.com"
+	}
+}
+
+func normalizeRPCReplayHost(host string) string {
+	host = strings.ToLower(strings.TrimSpace(host))
+	host = strings.TrimSuffix(host, ":443")
+	host = strings.TrimSuffix(host, ":80")
+	return host
+}
+
 func requestHost(req *http.Request) string {
 	if req == nil {
 		return ""

pkg/providers/providers.go

@@ -11,8 +11,10 @@ import (
 	"github.com/404tk/cloudtoolkit/pkg/providers/gcp"
 	"github.com/404tk/cloudtoolkit/pkg/providers/huawei"
 	"github.com/404tk/cloudtoolkit/pkg/providers/jdcloud"
+	demoreplay "github.com/404tk/cloudtoolkit/pkg/providers/replay"
 	"github.com/404tk/cloudtoolkit/pkg/providers/tencent"
 	"github.com/404tk/cloudtoolkit/pkg/providers/volcengine"
+	volcreplay "github.com/404tk/cloudtoolkit/pkg/providers/volcengine/replay"
 	"github.com/404tk/cloudtoolkit/pkg/schema"
 )
 
@@ -30,7 +32,7 @@ var catalog = []entry{
 	{
 		info: Info{Name: "alibaba", Desc: "Alibaba Cloud"},
 		new: func(block schema.Options) (schema.Provider, error) {
-			if alireplay.IsActiveForProvider("alibaba") {
+			if demoreplay.IsActiveForProvider("alibaba") {
 				return alibaba.NewWithConfig(block, alireplay.ClientConfig())
 			}
 			return alibaba.New(block)
@@ -63,6 +65,9 @@ var catalog = []entry{
 	{
 		info: Info{Name: "volcengine", Desc: "Volcengine"},
 		new: func(block schema.Options) (schema.Provider, error) {
+			if demoreplay.IsActiveForProvider("volcengine") {
+				return volcengine.NewWithConfig(block, volcreplay.ClientConfig())
+			}
 			return volcengine.New(block)
 		},
 	},

pkg/providers/replay/replay.go

@@ -0,0 +1,113 @@
+package replay
+
+import (
+	"strings"
+	"sync"
+)
+
+type State struct {
+	Active   bool
+	Provider string
+}
+
+type Credentials struct {
+	AccessKey string
+	SecretKey string
+}
+
+type providerMeta struct {
+	Credentials Credentials
+	Payloads    []string
+}
+
+var (
+	stateMu sync.RWMutex
+	state   State
+)
+
+var providers = map[string]providerMeta{
+	"alibaba": {
+		Credentials: Credentials{
+			AccessKey: "LTAI4tDVhjxvrWKTsEXAMPLE",
+			SecretKey: "EXAMPLEv2fYAa2s7GhvLun7xqctKEY",
+		},
+		Payloads: []string{
+			"cloudlist",
+			"iam-user-check",
+			"bucket-check",
+			"event-check",
+			"rds-account-check",
+			"instance-cmd-check",
+		},
+	},
+	"volcengine": {
+		Credentials: Credentials{
+			AccessKey: "AKLTOTgzY2UyYzA1NDQ5NGE5MzkEXAMPLE",
+			SecretKey: "QkN5ZlJmM0d1R2JMb2M5dVhLQXBQd1pHc2ZEXAMPLE",
+		},
+		Payloads: []string{
+			"cloudlist",
+			"iam-user-check",
+			"bucket-check",
+			"instance-cmd-check",
+		},
+	},
+}
+
+func Enable(provider string) {
+	stateMu.Lock()
+	defer stateMu.Unlock()
+	state = State{
+		Active:   true,
+		Provider: normalizeProvider(provider),
+	}
+}
+
+func Disable() {
+	stateMu.Lock()
+	defer stateMu.Unlock()
+	state = State{}
+}
+
+func IsActive() bool {
+	stateMu.RLock()
+	defer stateMu.RUnlock()
+	return state.Active && state.Provider != ""
+}
+
+func ActiveProvider() string {
+	stateMu.RLock()
+	defer stateMu.RUnlock()
+	return state.Provider
+}
+
+func IsActiveForProvider(provider string) bool {
+	stateMu.RLock()
+	defer stateMu.RUnlock()
+	return state.Active && state.Provider != "" && state.Provider == normalizeProvider(provider)
+}
+
+func SupportsProvider(provider string) bool {
+	_, ok := providers[normalizeProvider(provider)]
+	return ok
+}
+
+func CredentialsFor(provider string) (Credentials, bool) {
+	meta, ok := providers[normalizeProvider(provider)]
+	if !ok {
+		return Credentials{}, false
+	}
+	return meta.Credentials, true
+}
+
+func SupportedPayloads(provider string) []string {
+	meta, ok := providers[normalizeProvider(provider)]
+	if !ok || len(meta.Payloads) == 0 {
+		return nil
+	}
+	return append([]string(nil), meta.Payloads...)
+}
+
+func normalizeProvider(provider string) string {
+	return strings.TrimSpace(provider)
+}