feat(bingocloud)：improve bingocloud driver

cmd/bingocli/main.go

@@ -96,12 +96,11 @@ func newClient(options *BaseOptions) (*bingocloud.SRegion, error) {
 			options.Endpoint,
 			options.AccessKey,
 			options.SecretKey,
-		).Debug(options.Debug).
-			CloudproviderConfig(
-				cloudprovider.ProviderConfig{
-					ProxyFunc: proxyFunc,
-				},
-			),
+		).Debug(options.Debug).SetCloudproviderConfig(
+			cloudprovider.ProviderConfig{
+				ProxyFunc: proxyFunc,
+			},
+		),
 	)
 	if err != nil {
 		return nil, err

pkg/multicloud/bingocloud/account.go

@@ -1,12 +1,63 @@
 package bingocloud
 
+import (
+	"crypto/aes"
+	"crypto/cipher"
+	"encoding/base64"
+	"fmt"
+	"unicode/utf8"
+)
+
 type SAccount struct {
-	AccessKeyId     string
-	SecretAccessKey string
-	Arn             string
-	DeptId          string
-	DeptName        string
-	IsEncrypted     string
-	UserId          string
-	UserName        string
+	Id          string `json:"Id"`
+	AccessKeyId string `json:"AccessKeyId"`
+	Arn         string `json:"Arn"`
+	FullName    string `json:"FullName"`
+	IsAdmin     string `json:"IsAdmin"`
+	IsEncrypted string `json:"IsEncrypted"`
+	SecurityKey string `json:"SecurityKey"`
+	Status      string `json:"Status"`
+	Type        string `json:"Type"`
+	UserId      string `json:"UserId"`
+	UserName    string `json:"UserName"`
+}
+
+func (self *SAccount) decryptKeys(masterSecretKey string) (string, string) {
+	if len(self.SecurityKey) == len(masterSecretKey) {
+		return self.AccessKeyId, self.SecurityKey
+	}
+
+	secretKeyBytes, err := base64.StdEncoding.DecodeString(self.SecurityKey)
+	if err != nil {
+		return "", ""
+	}
+	var adminSecretKey = ""
+	if len(masterSecretKey) >= 32 {
+		adminSecretKey = masterSecretKey[0:32]
+	} else {
+		adminSecretKey = fmt.Sprintf("%s%032s", masterSecretKey, "")[0:32]
+	}
+	decryptVal, err := aesCrtCrypt([]byte(secretKeyBytes), []byte(adminSecretKey), make([]byte, 16))
+	if err != nil {
+		return "", ""
+	}
+
+	decryptSecret := fmt.Sprintf("%s", decryptVal)
+
+	if !utf8.ValidString(decryptSecret) {
+		return self.AccessKeyId, self.SecurityKey
+	}
+
+	return self.AccessKeyId, decryptSecret
+}
+
+func aesCrtCrypt(val, key, iv []byte) ([]byte, error) {
+	block, err := aes.NewCipher(key)
+	if err != nil {
+		return nil, err
+	}
+	blockMode := cipher.NewCTR(block, iv)
+	body := make([]byte, len(val))
+	blockMode.XORKeyStream(body, val)
+	return body, nil
 }

pkg/multicloud/bingocloud/bingo.go

@@ -45,6 +45,16 @@ const (
 	MAX_RESULT = 20
 )
 
+var (
+	ManagerActions = []string{
+		"DescribeNodes",
+		"DescribePhysicalHosts",
+		"DescribeClusters",
+		"DescribeAvailabilityZones",
+		"DescribeStorages",
+	}
+)
+
 type BingoCloudConfig struct {
 	cpcfg     cloudprovider.ProviderConfig
 	endpoint  string
@@ -63,11 +73,15 @@ func NewBingoCloudClientConfig(endpoint, accessKey, secretKey string) *BingoClou
 	return cfg
 }
 
-func (cfg *BingoCloudConfig) CloudproviderConfig(cpcfg cloudprovider.ProviderConfig) *BingoCloudConfig {
+func (cfg *BingoCloudConfig) SetCloudproviderConfig(cpcfg cloudprovider.ProviderConfig) *BingoCloudConfig {
 	cfg.cpcfg = cpcfg
 	return cfg
 }
 
+func (cfg *BingoCloudConfig) GetCloudproviderConfig() cloudprovider.ProviderConfig {
+	return cfg.cpcfg
+}
+
 func (cfg *BingoCloudConfig) Debug(debug bool) *BingoCloudConfig {
 	cfg.debug = debug
 	return cfg
@@ -77,23 +91,31 @@ type SBingoCloudClient struct {
 	*BingoCloudConfig
 
 	regions []SRegion
+
+	managerClient *SBingoCloudClient
+
+	user string
 }
 
 func NewBingoCloudClient(cfg *BingoCloudConfig) (*SBingoCloudClient, error) {
 	client := &SBingoCloudClient{BingoCloudConfig: cfg}
-	var err error
-	client.regions, err = client.GetRegions()
-	if err != nil {
-		return nil, err
-	}
-	for i := range client.regions {
-		client.regions[i].client = client
+	client.regions, _ = client.GetRegions()
+	if client.regions != nil {
+		for i := range client.regions {
+			client.regions[i].client = client
+		}
 	}
+	client.user = client.getAccountUser()
 	return client, nil
 }
 
+func (self *SBingoCloudClient) SetManagerClient(client *SBingoCloudClient) {
+	self.regions = client.regions
+	self.managerClient = client
+}
+
 func (self *SBingoCloudClient) GetAccountId() string {
-	return self.endpoint
+	return self.accessKey
 }
 
 func (self *SBingoCloudClient) GetRegion(id string) (*SRegion, error) {
@@ -296,56 +318,36 @@ func (self *SBingoCloudClient) GetSubAccounts() ([]cloudprovider.SSubAccount, er
 	}
 	_ = result.Unmarshal(&tags, "tagSet")
 
-	var subAccounts []cloudprovider.SSubAccount
+	var subAccounts = []cloudprovider.SSubAccount{{
+		Id:           self.getAccountUser(),
+		Account:      self.accessKey,
+		Secret:       self.secretKey,
+		Name:         self.cpcfg.Name,
+		HealthStatus: api.CLOUD_PROVIDER_HEALTH_NORMAL,
+	}}
+
 	for i := range tags {
+		account, err := self.listAccessKeys(tags[i].ResourceId)
+		if err != nil {
+			continue
+		}
+		ak, sk := account.decryptKeys(self.secretKey)
 		subAccount := cloudprovider.SSubAccount{
-			Account:          self.accessKey,
-			Name:             tags[i].ResourceId,
-			DefaultProjectId: tags[i].Value,
+			Id:               account.UserId,
+			Name:             account.UserName,
 			HealthStatus:     api.CLOUD_PROVIDER_HEALTH_NORMAL,
+			Account:          ak,
+			Secret:           sk,
+			IsSubAccount:     true,
+			DefaultProjectId: tags[i].Value,
 		}
 		subAccounts = append(subAccounts, subAccount)
 	}
 	return subAccounts, nil
 }
 
 func (self *SBingoCloudClient) GetEnrollmentAccounts() ([]cloudprovider.SEnrollmentAccount, error) {
-	params := map[string]string{"Marker": "", "MaxItems": "1000", "AccountName": "paas_app"}
-	var result struct {
-		IsTruncated string
-		Marker      string `json:"marker,omitempty"`
-		Users       struct {
-			Member *SAccount `json:"member,omitempty"`
-		}
-	}
-	var eas []cloudprovider.SEnrollmentAccount
-	for {
-		resp, err := self.invoke("ListAccounts", params)
-		if err != nil {
-			return nil, err
-		}
-		err = resp.Unmarshal(&result, "ListAccountsResult")
-		if err != nil {
-			return nil, err
-		}
-		ea := cloudprovider.SEnrollmentAccount{
-			Id:   result.Users.Member.UserId,
-			Name: result.Users.Member.UserName,
-		}
-		eas = append(eas, ea)
-		//for _, user := range result.Users.Member {
-		//	ea := cloudprovider.SEnrollmentAccount{
-		//		Id:   user.UserId,
-		//		Name: user.UserName,
-		//	}
-		//	eas = append(eas, ea)
-		//}
-		if params["Marker"] == result.Marker {
-			break
-		}
-		params["Marker"] = result.Marker
-	}
-	return eas, nil
+	return nil, nil
 }
 
 func (self *SBingoCloudClient) GetIRegions() []cloudprovider.ICloudRegion {
@@ -357,6 +359,44 @@ func (self *SBingoCloudClient) GetIRegions() []cloudprovider.ICloudRegion {
 	return ret
 }
 
+func (self *SBingoCloudClient) listAccessKeys(userName string) (*SAccount, error) {
+	params := map[string]string{"Marker": "", "MaxItems": "1000", "UserName": userName}
+
+	resp, err := self.managerClient.invoke("ListAccessKeys", params)
+	if err != nil {
+		return nil, err
+	}
+
+	var account *SAccount
+	err = resp.Unmarshal(&account, "ListAccessKeysResult", "AccessKeyMetadata", "member")
+	if err != nil {
+		return nil, err
+	}
+
+	return account, nil
+}
+
+func (self *SBingoCloudClient) getAccountUser() string {
+	quotas, err := self.getQuotas()
+	if err != nil {
+		return ""
+	}
+	ownerId := ""
+	if len(quotas) > 0 {
+		ownerId = quotas[0].OwnerId
+	}
+	return ownerId
+}
+
+func (self *SBingoCloudClient) getQuotas() ([]SQuotas, error) {
+	resp, err := self.invoke("DescribeQuotas", nil)
+	if err != nil {
+		return nil, err
+	}
+	var ret []SQuotas
+	return ret, resp.Unmarshal(&ret, "quotaSet")
+}
+
 func (self *SBingoCloudClient) describeTags(filter map[string]string) (jsonutils.JSONObject, error) {
 	params := map[string]string{"MaxResults": "10000"}
 	i := 1

pkg/multicloud/bingocloud/bingo_test.go

@@ -0,0 +1,33 @@
+// Copyright 2019 Yunion
+//
+// 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 bingocloud
+
+import (
+	"testing"
+)
+
+var bingoCloudClient, _ = NewBingoCloudClient(&BingoCloudConfig{
+	endpoint:  "http://10.203.136.11",
+	accessKey: "373ABE5836BB9E82FCFB",
+	secretKey: "WzkzNzk0Mzg2ODQxODQ5REJEN0U4QTg1NTY5NzA2",
+	debug:     true,
+})
+
+func TestNewBingoCloudClient(t *testing.T) {
+	bingoCloudClient.managerClient = bingoCloudClient
+	regions, _ := bingoCloudClient.GetRegions()
+	regions[0].client = bingoCloudClient
+	t.Log(regions[0].getStorages())
+}

pkg/multicloud/bingocloud/disk.go

@@ -19,6 +19,7 @@ import (
 	"fmt"
 	"strconv"
 
+	"yunion.io/x/jsonutils"
 	"yunion.io/x/pkg/errors"
 
 	api "yunion.io/x/cloudmux/pkg/apis/compute"
@@ -60,6 +61,8 @@ type SDisk struct {
 	StorageId        string          `json:"storageId"`
 	VolumeId         string          `json:"volumeId"`
 	VolumeName       string          `json:"volumeName"`
+
+	ImageId string `json:"imageId"`
 }
 
 func (self *SDisk) GetISnapshots() ([]cloudprovider.ICloudSnapshot, error) {
@@ -118,7 +121,13 @@ func (self *SDisk) GetIsAutoDelete() bool {
 }
 
 func (self *SDisk) GetTemplateId() string {
-	return ""
+	if self.ImageId == "" && len(self.AttachmentSet) > 0 {
+		instances, _, _ := self.storage.cluster.region.GetInstances(self.AttachmentSet[0].InstanceId, "", 1, "")
+		if instances != nil {
+			self.ImageId = instances[0].InstancesSet.ImageId
+		}
+	}
+	return self.ImageId
 }
 
 func (self *SDisk) GetDiskType() string {
@@ -187,6 +196,14 @@ func (self *SDisk) Rebuild(ctx context.Context) error {
 	return cloudprovider.ErrNotImplemented
 }
 
+func (self *SDisk) Refresh() error {
+	newDisk, err := self.storage.cluster.region.GetDisk(self.GetGlobalId())
+	if err != nil {
+		return err
+	}
+	return jsonutils.Update(self, &newDisk)
+}
+
 func (self *SDisk) GetStatus() string {
 	switch self.Status {
 	case "available", "in-use":
@@ -203,6 +220,10 @@ func (self *SRegion) GetDisks(id string, maxResult int, nextToken string) ([]SDi
 		params[fmt.Sprintf("Filter.%d.Name", idx)] = "volume-id"
 		params[fmt.Sprintf("Filter.%d.Value.1", idx)] = id
 		idx++
+	} else {
+		params[fmt.Sprintf("Filter.%d.Name", idx)] = "owner-id"
+		params[fmt.Sprintf("Filter.%d.Value.1", idx)] = self.client.user
+		idx++
 	}
 
 	if len(nextToken) > 0 {
@@ -277,7 +298,7 @@ func (self *SRegion) GetDisk(id string) (*SDisk, error) {
 func (self *SStorage) CreateIDisk(conf *cloudprovider.DiskCreateConfig) (cloudprovider.ICloudDisk, error) {
 	params := map[string]string{}
 	params["VolumeName"] = conf.Name
-	params["AvailabilityZone"] = self.cluster.ClusterId
+	params["AvailabilityZone"] = conf.ZoneId
 	params["Size"] = strconv.Itoa(conf.SizeGb)
 
 	resp, err := self.cluster.region.invoke("CreateVolume", params)
@@ -286,6 +307,7 @@ func (self *SStorage) CreateIDisk(conf *cloudprovider.DiskCreateConfig) (cloudpr
 	}
 	ret := &SDisk{}
 	_ = resp.Unmarshal(&ret)
+	ret.storage = self
 
 	return ret, nil
 }