diff --git a/go.mod b/go.mod index 1427f832fb..a1807023f6 100644 --- a/go.mod +++ b/go.mod @@ -96,14 +96,14 @@ require ( k8s.io/cri-api v0.22.17 k8s.io/klog/v2 v2.20.0 moul.io/http2curl/v2 v2.3.0 - yunion.io/x/cloudmux v0.3.10-0-alpha.1.0.20250821083217-bda20d3c26a5 + yunion.io/x/cloudmux v0.3.10-0-alpha.1.0.20250902085711-5b2719ee9f5e yunion.io/x/executor v0.0.0-20250518005516-5402e9e0bed0 yunion.io/x/jsonutils v1.0.1-0.20250507052344-1abcf4f443b1 yunion.io/x/log v1.0.1-0.20240305175729-7cf2d6cd5a91 yunion.io/x/ovsdb v0.0.0-20230306173834-f164f413a900 yunion.io/x/pkg v1.10.4-0.20250820035218-6008459eb4f0 yunion.io/x/s3cli v0.0.0-20241221171442-1c11599d28e1 - yunion.io/x/sqlchemy v1.1.3-0.20250806073422-e37f5197cec0 + yunion.io/x/sqlchemy v1.1.3-0.20250902120005-3b18bc6371c7 yunion.io/x/structarg v0.0.0-20231017124457-df4d5009457c ) diff --git a/go.sum b/go.sum index d5ccdf1099..36635c63a2 100644 --- a/go.sum +++ b/go.sum @@ -1409,8 +1409,8 @@ sigs.k8s.io/structured-merge-diff/v4 v4.0.1/go.mod h1:bJZC9H9iH24zzfZ/41RGcq60oK sigs.k8s.io/yaml v1.1.0/go.mod h1:UJmg0vDUVViEyp3mgSv9WPwZCDxu4rQW1olrI1uml+o= sigs.k8s.io/yaml v1.2.0 h1:kr/MCeFWJWTwyaHoR9c8EjH9OumOmoF9YGiZd7lFm/Q= sigs.k8s.io/yaml v1.2.0/go.mod h1:yfXDCHCao9+ENCvLSE62v9VSji2MKu5jeNfTrofGhJc= -yunion.io/x/cloudmux v0.3.10-0-alpha.1.0.20250821083217-bda20d3c26a5 h1:BpfscCJPENsuWoNQ7tymbpeijx8Sc+JvZV+3zyjnMX4= -yunion.io/x/cloudmux v0.3.10-0-alpha.1.0.20250821083217-bda20d3c26a5/go.mod h1:FXxAEbdNfWXX9gjME3K2nJhkydHY5EKEUZb+RLEzVwQ= +yunion.io/x/cloudmux v0.3.10-0-alpha.1.0.20250902085711-5b2719ee9f5e h1:SnIRJpK1HXC7F8X3AIT/oPA1+sQAjlqs40wZsySs+7o= +yunion.io/x/cloudmux v0.3.10-0-alpha.1.0.20250902085711-5b2719ee9f5e/go.mod h1:FXxAEbdNfWXX9gjME3K2nJhkydHY5EKEUZb+RLEzVwQ= yunion.io/x/executor v0.0.0-20250518005516-5402e9e0bed0 h1:msG4SiDSVU7CrXH06WuHlNEZXIooTcmNbfrIGHuIHBU= yunion.io/x/executor v0.0.0-20250518005516-5402e9e0bed0/go.mod h1:Uxuou9WQIeJXNpy7t2fPLL0BYLvLiMvGQwY7Qc6aSws= yunion.io/x/jsonutils v0.0.0-20190625054549-a964e1e8a051/go.mod h1:4N0/RVzsYL3kH3WE/H1BjUQdFiWu50JGCFQuuy+Z634= @@ -1428,7 +1428,7 @@ yunion.io/x/pkg v1.10.4-0.20250820035218-6008459eb4f0 h1:/vHcYqzQInxqR1jjS+e7A0o yunion.io/x/pkg v1.10.4-0.20250820035218-6008459eb4f0/go.mod h1:0Bwxqd9MA3ACi119/l02FprY/o9gHahmYC2bsSbnVpM= yunion.io/x/s3cli v0.0.0-20241221171442-1c11599d28e1 h1:1KJ3YYinydPHpDEQRXdr/T8SYcKZ5Er+m489H+PnaQ4= yunion.io/x/s3cli v0.0.0-20241221171442-1c11599d28e1/go.mod h1:0iFKpOs1y4lbCxeOmq3Xx/0AcQoewVPwj62eRluioEo= -yunion.io/x/sqlchemy v1.1.3-0.20250806073422-e37f5197cec0 h1:Eha/ywh4foMJm7VJ8ibFOi+WPHacuTWtosAGpOld5vo= -yunion.io/x/sqlchemy v1.1.3-0.20250806073422-e37f5197cec0/go.mod h1:vCIZpqhZ5Jzaq3tFyrti/vv8BijQKtkzSgNT/uH4H5A= +yunion.io/x/sqlchemy v1.1.3-0.20250902120005-3b18bc6371c7 h1:0OccQYkey6OsNUZNxd6CpCB/espBPnwlLT/gjl9YbXM= +yunion.io/x/sqlchemy v1.1.3-0.20250902120005-3b18bc6371c7/go.mod h1:vCIZpqhZ5Jzaq3tFyrti/vv8BijQKtkzSgNT/uH4H5A= yunion.io/x/structarg v0.0.0-20231017124457-df4d5009457c h1:QuLab2kSRECZRxo4Lo2KcYn6XjQFDGaZ1+x0pYDVVwQ= yunion.io/x/structarg v0.0.0-20231017124457-df4d5009457c/go.mod h1:EP6NSv2C0zzqBDTKumv8hPWLb3XvgMZDHQRfyuOrQng= diff --git a/pkg/compute/models/networks.go b/pkg/compute/models/networks.go index c03fae6be7..5d29950ecb 100644 --- a/pkg/compute/models/networks.go +++ b/pkg/compute/models/networks.go @@ -2738,9 +2738,11 @@ func (manager *SNetworkManager) ListItemFilter( ipStart := sqlchemy.INET_ATON(q.Field("guest_ip_start")) ipEnd := sqlchemy.INET_ATON(q.Field("guest_ip_end")) + ipConst := sqlchemy.INET_ATON(q.StringField(ip4Addr.String())) + ipCondtion = sqlchemy.AND( - sqlchemy.GE(ipEnd, uint32(ip4Addr)), - sqlchemy.LE(ipStart, uint32(ip4Addr)), + sqlchemy.GE(ipEnd, ipConst), + sqlchemy.LE(ipStart, ipConst), ) if !exactIpMatch { ipCondtion = sqlchemy.OR( @@ -2751,18 +2753,20 @@ func (manager *SNetworkManager) ListItemFilter( } } else if ip6Addr, err := netutils.NewIPV6Addr(ipstr); err == nil { // ipv6 address, exactly - ipStart := q.Field("guest_ip6_start") - ipEnd := q.Field("guest_ip6_end") + ipStart := sqlchemy.INET6_ATON(q.Field("guest_ip6_start")) + ipEnd := sqlchemy.INET6_ATON(q.Field("guest_ip6_end")) + + ipConst := sqlchemy.INET6_ATON(q.StringField(ip6Addr.String())) ipCondtion = sqlchemy.AND( - sqlchemy.GE(ipEnd, ip6Addr.String()), - sqlchemy.LE(ipStart, ip6Addr.String()), + sqlchemy.GE(ipEnd, ipConst), + sqlchemy.LE(ipStart, ipConst), ) if !exactIpMatch { ipCondtion = sqlchemy.OR( ipCondtion, - sqlchemy.Contains(q.Field("guest_ip6_start"), ipstr), - sqlchemy.Contains(q.Field("guest_ip6_end"), ipstr), + sqlchemy.Contains(q.Field("guest_ip6_start"), ip6Addr.String()), + sqlchemy.Contains(q.Field("guest_ip6_end"), ip6Addr.String()), ) } } else { @@ -2884,6 +2888,8 @@ func (manager *SNetworkManager) ListItemFilter( q = q.In("wire_id", subq.SubQuery()) } + q.DebugQuery() + return q, nil } diff --git a/vendor/modules.txt b/vendor/modules.txt index 37a1268a9a..5a232a1f0d 100644 --- a/vendor/modules.txt +++ b/vendor/modules.txt @@ -1852,7 +1852,7 @@ sigs.k8s.io/structured-merge-diff/v4/value # sigs.k8s.io/yaml v1.2.0 ## explicit; go 1.12 sigs.k8s.io/yaml -# yunion.io/x/cloudmux v0.3.10-0-alpha.1.0.20250821083217-bda20d3c26a5 +# yunion.io/x/cloudmux v0.3.10-0-alpha.1.0.20250902085711-5b2719ee9f5e ## explicit; go 1.21 yunion.io/x/cloudmux/pkg/apis yunion.io/x/cloudmux/pkg/apis/billing @@ -2003,7 +2003,7 @@ yunion.io/x/pkg/utils # yunion.io/x/s3cli v0.0.0-20241221171442-1c11599d28e1 ## explicit; go 1.12 yunion.io/x/s3cli -# yunion.io/x/sqlchemy v1.1.3-0.20250806073422-e37f5197cec0 +# yunion.io/x/sqlchemy v1.1.3-0.20250902120005-3b18bc6371c7 ## explicit; go 1.17 yunion.io/x/sqlchemy yunion.io/x/sqlchemy/backends diff --git a/vendor/yunion.io/x/cloudmux/pkg/apis/compute/cloudregions_const.go b/vendor/yunion.io/x/cloudmux/pkg/apis/compute/cloudregions_const.go index 72a7a98e80..a4600bc991 100644 --- a/vendor/yunion.io/x/cloudmux/pkg/apis/compute/cloudregions_const.go +++ b/vendor/yunion.io/x/cloudmux/pkg/apis/compute/cloudregions_const.go @@ -73,6 +73,7 @@ const ( CITY_HUAI_NAN = "HuaiNan" //淮南 CITY_SU_QIAN = "SuQian" //宿迁 CITY_DA_LIAN = "Dalian" //大连 + CITY_TAI_BEI = "TaiBei" //台北 // 日本 CITY_TOKYO = "Tokyo" //东京 @@ -161,6 +162,7 @@ const ( CITY_QUEBEC = "Quebec" //魁北克市 CITY_TORONTO = "Toronto" //多伦多 CITY_MONTREAL = "Montreal" //蒙特利尔 + CITY_CALGARY = "Calgary" //卡尔加里 // 爱尔兰 CITY_IRELAND = "Ireland" //爱尔兰 @@ -224,6 +226,9 @@ const ( // 卡塔尔 CITY_DOHA = "Doha" // 多哈 + // 新西兰 + CITY_NEW_ZEALAND = "New Zealand" // 新西兰 + COUNTRY_CODE_CN = "CN" //中国 COUNTRY_CODE_JP = "JP" //日本 COUNTRY_CODE_SG = "SG" //新加坡 @@ -259,4 +264,5 @@ const ( COUNTRY_CODE_IT = "IT" //意大利 COUNTRY_CODE_ES = "ES" //西班牙 COUNTRY_CODE_QA = "QA" //卡塔尔 + COUNTRY_CODE_NZ = "NZ" //新西兰 ) diff --git a/vendor/yunion.io/x/cloudmux/pkg/apis/compute/dbinstance_const.go b/vendor/yunion.io/x/cloudmux/pkg/apis/compute/dbinstance_const.go index a72c167e7a..1c30a385fb 100644 --- a/vendor/yunion.io/x/cloudmux/pkg/apis/compute/dbinstance_const.go +++ b/vendor/yunion.io/x/cloudmux/pkg/apis/compute/dbinstance_const.go @@ -106,6 +106,11 @@ const ( AWS_DBINSTANCE_CATEGORY_EXPRESS_EDITION = "Express Edition" AWS_DBINSTANCE_CATEGORY_STANDARD_EDITION = "Standard Edition" AWS_DBINSTANCE_CATEGORY_WEB_EDITION = "Web Edition" + + AWS_DBINSTANCE_CATEGORY_CLUSTER = "Cluster" + + AWS_DBINSTANCE_CATEGORY_MASTER = "Master" + AWS_DBINSTANCE_CATEGORY_SLAVE = "Slave" // Oracle AWS_DBINSTANCE_CATEGORY_STANDARD_EDITION_TWO = "Standard Edition Two" diff --git a/vendor/yunion.io/x/cloudmux/pkg/apis/compute/regiondata.go b/vendor/yunion.io/x/cloudmux/pkg/apis/compute/regiondata.go index 7b5e8f1a04..371713244d 100644 --- a/vendor/yunion.io/x/cloudmux/pkg/apis/compute/regiondata.go +++ b/vendor/yunion.io/x/cloudmux/pkg/apis/compute/regiondata.go @@ -768,4 +768,22 @@ var ( City: CITY_NAGPUR, CountryCode: COUNTRY_CODE_IN, } + RegionNewZealand = cloudprovider.SGeographicInfo{ + Latitude: -41.287, + Longitude: 174.776, + City: CITY_NEW_ZEALAND, + CountryCode: COUNTRY_CODE_NZ, + } + RegionTaipei = cloudprovider.SGeographicInfo{ + Latitude: 25.038, + Longitude: 121.525, + City: CITY_TAI_BEI, + CountryCode: COUNTRY_CODE_CN, + } + RegionCalgary = cloudprovider.SGeographicInfo{ + Latitude: 51.0486, + Longitude: -114.0708, + City: CITY_CALGARY, + CountryCode: COUNTRY_CODE_CA, + } ) diff --git a/vendor/yunion.io/x/cloudmux/pkg/cloudprovider/objectstore.go b/vendor/yunion.io/x/cloudmux/pkg/cloudprovider/objectstore.go index bd6627be37..0c9bddfc44 100644 --- a/vendor/yunion.io/x/cloudmux/pkg/cloudprovider/objectstore.go +++ b/vendor/yunion.io/x/cloudmux/pkg/cloudprovider/objectstore.go @@ -544,7 +544,7 @@ type uploadPartOfMultipartJob struct { offset int64 debug bool etags []string - errs []error + errs *[]error } func uploadPartOfMultipartWorker(wg *sync.WaitGroup, queue chan uploadPartOfMultipartJob) { @@ -552,7 +552,7 @@ func uploadPartOfMultipartWorker(wg *sync.WaitGroup, queue chan uploadPartOfMult for job := range queue { tag, err := uploadPartOfMultipart(job.ctx, job.bucket, job.key, job.input, job.sizeBytes, job.uploadId, job.partIndex, job.partSize, job.offset, job.debug) if err != nil { - job.errs = append(job.errs, err) + *job.errs = append(*job.errs, err) } else { job.etags[job.partIndex] = tag } @@ -640,7 +640,7 @@ func UploadObjectParallel(ctx context.Context, bucket ICloudBucket, key string, offset: offset, debug: debug, etags: etags, - errs: errs, + errs: &errs, } queue <- job } @@ -721,7 +721,7 @@ type copyPartOfMultipartJob struct { partIndex int debug bool etags []string - errs []error + errs *[]error } func copyPartOfMultipartWorker(wg *sync.WaitGroup, queue chan copyPartOfMultipartJob) { @@ -729,7 +729,7 @@ func copyPartOfMultipartWorker(wg *sync.WaitGroup, queue chan copyPartOfMultipar for job := range queue { tag, err := copyPartOfMultipart(job.ctx, job.dstBucket, job.dstKey, job.srcBucket, job.srcKey, job.rangeOpt, job.sizeBytes, job.uploadId, job.partIndex, job.debug) if err != nil { - job.errs = append(job.errs, err) + *job.errs = append(*job.errs, err) } else { job.etags[job.partIndex] = tag } @@ -844,7 +844,7 @@ func CopyObjectParallel(ctx context.Context, blocksz int64, dstBucket ICloudBuck partIndex: partIndex, debug: debug, etags: etags, - errs: errs, + errs: &errs, } queue <- job } @@ -1052,7 +1052,7 @@ func (ow *sOffsetWriter) Write(p []byte) (int, error) { } func calculateRateMbps(sizeBytes int64, duration time.Duration) float64 { - return float64(sizeBytes*8) / (float64(duration) / float64(time.Second)) / 1000 / 1000 + return float64(sizeBytes*8/1000/1000) / (float64(duration) / float64(time.Second)) } type downloadPartOfMultipartJob struct { @@ -1064,7 +1064,7 @@ type downloadPartOfMultipartJob struct { partIndex int debug bool segSizes []int64 - errs []error + errs *[]error callback func(saved int64, written int64) } @@ -1073,7 +1073,7 @@ func downloadPartOfMultipartWorker(wg *sync.WaitGroup, queue chan downloadPartOf for job := range queue { sz, err := downloadPartOfMultipart(job.ctx, job.bucket, job.key, job.rangeOpt, job.output, job.partIndex, job.debug, job.callback) if err != nil { - job.errs = append(job.errs, err) + *job.errs = append(*job.errs, err) } else { job.segSizes[job.partIndex] = sz } @@ -1237,7 +1237,7 @@ func DownloadObjectParallelWithProgress(ctx context.Context, bucket ICloudBucket partIndex: partIndex, debug: debug, segSizes: segSizes, - errs: errs, + errs: &errs, callback: progressCallback, } queue <- job diff --git a/vendor/yunion.io/x/cloudmux/pkg/multicloud/aliyun/alb.go b/vendor/yunion.io/x/cloudmux/pkg/multicloud/aliyun/alb.go index c553694445..89fba5d5f6 100644 --- a/vendor/yunion.io/x/cloudmux/pkg/multicloud/aliyun/alb.go +++ b/vendor/yunion.io/x/cloudmux/pkg/multicloud/aliyun/alb.go @@ -164,7 +164,7 @@ func (alb *SAlb) Delete(ctx context.Context) error { } func (alb *SAlb) GetILoadBalancerBackendGroups() ([]cloudprovider.ICloudLoadbalancerBackendGroup, error) { - groups, err := alb.region.GetAlbServerGroups() + groups, err := alb.region.ListServerGroups() if err != nil { return nil, err } diff --git a/vendor/yunion.io/x/cloudmux/pkg/multicloud/aliyun/albservergroup.go b/vendor/yunion.io/x/cloudmux/pkg/multicloud/aliyun/albservergroup.go index f97225efc6..052f5f8fc1 100644 --- a/vendor/yunion.io/x/cloudmux/pkg/multicloud/aliyun/albservergroup.go +++ b/vendor/yunion.io/x/cloudmux/pkg/multicloud/aliyun/albservergroup.go @@ -42,7 +42,6 @@ type SAlbServerGroup struct { SlowStartConfig map[string]interface{} `json:"SlowStartConfig"` ConnectionDrainConfig map[string]interface{} `json:"ConnectionDrainConfig"` RelatedLoadBalancerIds []string `json:"RelatedLoadBalancerIds"` - Servers []AlbServer `json:"Servers"` CreateTime string `json:"CreateTime"` RegionId string `json:"RegionId"` ResourceGroupId string `json:"ResourceGroupId"` @@ -117,20 +116,16 @@ func (group *SAlbServerGroup) IsEmulated() bool { return false } -func (group *SAlbServerGroup) Refresh() error { - serverGroup, err := group.alb.region.GetAlbServerGroup(group.ServerGroupId) - if err != nil { - return err - } - return jsonutils.Update(group, serverGroup) -} - func (group *SAlbServerGroup) GetILoadbalancerBackends() ([]cloudprovider.ICloudLoadbalancerBackend, error) { backends := []cloudprovider.ICloudLoadbalancerBackend{} - for i := 0; i < len(group.Servers); i++ { + servers, err := group.alb.region.ListServerGroupServers(group.ServerGroupId) + if err != nil { + return nil, err + } + for i := 0; i < len(servers); i++ { server := &SAlbServerGroupServer{ albServerGroup: group, - AlbServer: group.Servers[i], + AlbServer: servers[i], } backends = append(backends, server) } @@ -182,61 +177,70 @@ func (group *SAlbServerGroup) GetProjectId() string { return group.ResourceGroupId } -// region methods -func (region *SRegion) GetAlbServerGroups() ([]SAlbServerGroup, error) { +func (region *SRegion) ListServerGroups() ([]SAlbServerGroup, error) { params := map[string]string{ "RegionId": region.RegionId, "MaxResults": "100", } groups := []SAlbServerGroup{} - nextToken := "" for { - if nextToken != "" { - params["NextToken"] = nextToken - } - body, err := region.albRequest("ListServerGroups", params) if err != nil { return nil, err } - pageGroups := []SAlbServerGroup{} - err = body.Unmarshal(&pageGroups, "ServerGroups") + part := struct { + TotalCount int `json:"TotalCount"` + NextToken string `json:"NextToken"` + ServerGroups []SAlbServerGroup `json:"ServerGroups"` + }{} + err = body.Unmarshal(&part) if err != nil { return nil, err } - groups = append(groups, pageGroups...) - - nextToken, _ = body.GetString("NextToken") - if nextToken == "" { + groups = append(groups, part.ServerGroups...) + if len(part.ServerGroups) == 0 || len(part.NextToken) == 0 { break } + params["NextToken"] = part.NextToken } return groups, nil } -func (region *SRegion) GetAlbServerGroup(serverGroupId string) (*SAlbServerGroup, error) { +func (region *SRegion) ListServerGroupServers(serverGroupId string) ([]AlbServer, error) { params := map[string]string{ "RegionId": region.RegionId, "ServerGroupId": serverGroupId, } - body, err := region.albRequest("ListServerGroupServers", params) - if err != nil { - return nil, err + ret := []AlbServer{} + nextToken := "" + for { + body, err := region.albRequest("ListServerGroupServers", params) + if err != nil { + return nil, err + } + part := struct { + TotalCount int `json:"TotalCount"` + NextToken string `json:"NextToken"` + Servers []AlbServer `json:"Servers"` + }{} + err = body.Unmarshal(&part) + if err != nil { + return nil, err + } + ret = append(ret, part.Servers...) + if len(part.Servers) == 0 || len(part.NextToken) == 0 { + break + } + params["NextToken"] = nextToken } - group := &SAlbServerGroup{} - err = body.Unmarshal(group) - if err != nil { - return nil, err - } - - return group, nil + return ret, nil } func (region *SRegion) CreateAlbServerGroup(group *cloudprovider.SLoadbalancerBackendGroup, vpcId string) (*SAlbServerGroup, error) { @@ -259,7 +263,17 @@ func (region *SRegion) CreateAlbServerGroup(group *cloudprovider.SLoadbalancerBa return nil, err } - return region.GetAlbServerGroup(serverGroupId) + groups, err := region.ListServerGroups() + if err != nil { + return nil, err + } + for i := 0; i < len(groups); i++ { + if groups[i].ServerGroupId == serverGroupId { + return &groups[i], nil + } + } + + return nil, cloudprovider.ErrNotFound } func (region *SRegion) DeleteAlbServerGroup(serverGroupId string) error { diff --git a/vendor/yunion.io/x/cloudmux/pkg/multicloud/aliyun/albservergroupserver.go b/vendor/yunion.io/x/cloudmux/pkg/multicloud/aliyun/albservergroupserver.go index b41eed97ab..7e215a1b85 100644 --- a/vendor/yunion.io/x/cloudmux/pkg/multicloud/aliyun/albservergroupserver.go +++ b/vendor/yunion.io/x/cloudmux/pkg/multicloud/aliyun/albservergroupserver.go @@ -37,7 +37,7 @@ func (server *SAlbServerGroupServer) GetName() string { } func (server *SAlbServerGroupServer) GetId() string { - return fmt.Sprintf("%s/%s/%d", server.albServerGroup.ServerGroupId, server.ServerId, server.Port) + return fmt.Sprintf("%s/%s/%s/%d", server.albServerGroup.ServerGroupId, server.ServerId, server.ServerIp, server.Port) } func (server *SAlbServerGroupServer) GetGlobalId() string { @@ -60,12 +60,12 @@ func (server *SAlbServerGroupServer) IsEmulated() bool { } func (server *SAlbServerGroupServer) Refresh() error { - serverGroup, err := server.albServerGroup.alb.region.GetAlbServerGroup(server.albServerGroup.ServerGroupId) + servers, err := server.albServerGroup.alb.region.ListServerGroupServers(server.albServerGroup.ServerGroupId) if err != nil { return err } - for _, s := range serverGroup.Servers { + for _, s := range servers { if s.ServerId == server.ServerId && s.Port == server.Port { return jsonutils.Update(server, &s) } diff --git a/vendor/yunion.io/x/cloudmux/pkg/multicloud/aliyun/loadbalancerlistenerrule.go b/vendor/yunion.io/x/cloudmux/pkg/multicloud/aliyun/loadbalancerlistenerrule.go index ca8a6afbc2..686146d897 100644 --- a/vendor/yunion.io/x/cloudmux/pkg/multicloud/aliyun/loadbalancerlistenerrule.go +++ b/vendor/yunion.io/x/cloudmux/pkg/multicloud/aliyun/loadbalancerlistenerrule.go @@ -98,6 +98,9 @@ func (lbr *SLoadbalancerListenerRule) GetDomain() string { } func (lbr *SLoadbalancerListenerRule) GetPath() string { + if len(lbr.Url) == 0 { + return "/" + } return lbr.Url } diff --git a/vendor/yunion.io/x/cloudmux/pkg/multicloud/aws/dbinstance.go b/vendor/yunion.io/x/cloudmux/pkg/multicloud/aws/dbinstance.go index 7d6e35201e..684bd05b3f 100644 --- a/vendor/yunion.io/x/cloudmux/pkg/multicloud/aws/dbinstance.go +++ b/vendor/yunion.io/x/cloudmux/pkg/multicloud/aws/dbinstance.go @@ -108,20 +108,15 @@ type SDBInstance struct { PerformanceInsightsEnabled bool `xml:"PerformanceInsightsEnabled"` DBName string `xml:"DBName"` MultiAZ bool `xml:"MultiAZ"` - //DomainMemberships string `xml:"DomainMemberships"` - StorageEncrypted bool `xml:"StorageEncrypted"` - DBSubnetGroup SDBSubnetGroup `xml:"DBSubnetGroup"` - VpcSecurityGroups SVpcSecurityGroups `xml:"VpcSecurityGroups"` - LicenseModel string `xml:"LicenseModel"` - PreferredMaintenanceWindow string `xml:"PreferredMaintenanceWindow"` - StorageType string `xml:"StorageType"` - AutoMinorVersionUpgrade bool `xml:"AutoMinorVersionUpgrade"` - CopyTagsToSnapshot bool `xml:"CopyTagsToSnapshot"` -} - -type SDBInstances struct { - DBInstances []SDBInstance `xml:"DBInstances>DBInstance"` - Marker string `xml:"Marker"` + DBClusterIdentifier string `xml:"DBClusterIdentifier"` + StorageEncrypted bool `xml:"StorageEncrypted"` + DBSubnetGroup SDBSubnetGroup `xml:"DBSubnetGroup"` + VpcSecurityGroups SVpcSecurityGroups `xml:"VpcSecurityGroups"` + LicenseModel string `xml:"LicenseModel"` + PreferredMaintenanceWindow string `xml:"PreferredMaintenanceWindow"` + StorageType string `xml:"StorageType"` + AutoMinorVersionUpgrade bool `xml:"AutoMinorVersionUpgrade"` + CopyTagsToSnapshot bool `xml:"CopyTagsToSnapshot"` } func (rds *SDBInstance) GetName() string { @@ -169,6 +164,10 @@ func (rds *SDBInstance) Reboot() error { return rds.region.RebootDBInstance(rds.DBInstanceIdentifier) } +func (rds *SDBInstance) GetMasterInstanceId() string { + return rds.DBClusterIdentifier +} + func (self *SDBInstance) GetCategory() string { switch self.Engine { case "aurora", "aurora-mysql": @@ -185,6 +184,20 @@ func (self *SDBInstance) GetCategory() string { return api.AWS_DBINSTANCE_CATEGORY_EXPRESS_EDITION case "sqlserver-web": return api.AWS_DBINSTANCE_CATEGORY_WEB_EDITION + case "docdb": + cluster, err := self.region.GetDBInstanceCluster(self.DBClusterIdentifier) + if err != nil { + return api.AWS_DBINSTANCE_CATEGORY_GENERAL_PURPOSE + } + for _, member := range cluster.DBClusterMembers { + if member.DBInstanceIdentifier == self.DBInstanceIdentifier { + if member.IsClusterWriter { + return api.AWS_DBINSTANCE_CATEGORY_MASTER + } + return api.AWS_DBINSTANCE_CATEGORY_SLAVE + } + } + return api.AWS_DBINSTANCE_CATEGORY_GENERAL_PURPOSE default: if strings.HasPrefix(self.DBInstanceClass, "db.r") || strings.HasPrefix(self.DBInstanceClass, "db.x") || strings.HasPrefix(self.DBInstanceClass, "db.d") { return api.AWS_DBINSTANCE_CATEGORY_MEMORY_OPTIMIZED @@ -297,24 +310,17 @@ func (rds *SDBInstance) Refresh() error { } func (region *SRegion) GetDBInstance(instanceId string) (*SDBInstance, error) { - instances, _, err := region.GetDBInstances(instanceId, "") + instances, err := region.GetDBInstances(instanceId) if err != nil { return nil, errors.Wrap(err, "GetDBInstances") } - - if len(instances) == 1 { - if instances[0].DbiResourceId == instanceId { - instances[0].region = region - return &instances[0], nil + for i := range instances { + if instances[i].DbiResourceId == instanceId { + instances[i].region = region + return &instances[i], nil } - return nil, cloudprovider.ErrNotFound } - - if len(instances) == 0 { - return nil, cloudprovider.ErrNotFound - } - - return nil, cloudprovider.ErrDuplicateId + return nil, errors.Wrapf(cloudprovider.ErrNotFound, instanceId) } func (rds *SDBInstance) GetZone1Id() string { @@ -421,65 +427,67 @@ func (rds *SDBInstance) CreateIBackup(conf *cloudprovider.SDBInstanceBackupCreat return ret.DBSnapshot.GetGlobalId(), nil } -func (region *SRegion) GetDBInstances(instanceId, marker string) ([]SDBInstance, string, error) { - instances := SDBInstances{} +func (region *SRegion) GetDBInstances(instanceId string) ([]SDBInstance, error) { params := map[string]string{} idx := 1 if len(instanceId) > 0 { params[fmt.Sprintf("Filters.Filter.%d.Name", idx)] = "dbi-resource-id" params[fmt.Sprintf("Filters.Filter.%d.Values.Value.1", idx)] = instanceId } - - if len(marker) > 0 { - params["Marker"] = marker + ret := []SDBInstance{} + for { + part := struct { + DBInstances []SDBInstance `xml:"DBInstances>DBInstance"` + Marker string `xml:"Marker"` + }{} + err := region.rdsRequest("DescribeDBInstances", params, &part) + if err != nil { + return nil, errors.Wrap(err, "DescribeDBInstances") + } + ret = append(ret, part.DBInstances...) + if len(part.DBInstances) == 0 || len(part.Marker) == 0 { + break + } + params["Marker"] = part.Marker } - err := region.rdsRequest("DescribeDBInstances", params, &instances) - if err != nil { - return nil, "", errors.Wrap(err, "DescribeDBInstances") - } - return instances.DBInstances, instances.Marker, nil + return ret, nil } func (region *SRegion) GetIDBInstances() ([]cloudprovider.ICloudDBInstance, error) { - idbinstances := []cloudprovider.ICloudDBInstance{} - instances, marker, err := region.GetDBInstances("", "") + ret := []cloudprovider.ICloudDBInstance{} + instances, err := region.GetDBInstances("") if err != nil { return nil, errors.Wrap(err, "GetDBInstances") } - for i := 0; i < len(instances); i++ { + for i := range instances { instances[i].region = region - idbinstances = append(idbinstances, &instances[i]) + ret = append(ret, &instances[i]) } - for len(marker) > 0 { - instances, marker, err = region.GetDBInstances("", marker) - if err != nil { - return nil, errors.Wrap(err, "GetDBInstances") - } - for i := 0; i < len(instances); i++ { - instances[i].region = region - idbinstances = append(idbinstances, &instances[i]) - } + clusters, err := region.GetDBInstanceClusters("") + if err != nil { + return nil, errors.Wrap(err, "GetDBInstanceClusters") } - return idbinstances, nil + for i := range clusters { + clusters[i].region = region + ret = append(ret, &clusters[i]) + } + return ret, nil } func (self *SRegion) GetIDBInstanceById(id string) (cloudprovider.ICloudDBInstance, error) { - instances, _, err := self.GetDBInstances(id, "") + if strings.HasPrefix(id, "db-") { + ret, err := self.GetDBInstance(id) + if err != nil { + return nil, errors.Wrap(err, "GetDBInstance") + } + return ret, nil + } + cluster, err := self.GetDBInstanceCluster(id) if err != nil { - return nil, errors.Wrap(err, "GetDBInstances") + return nil, errors.Wrap(err, "GetDBInstanceCluster") } - - if len(instances) > 1 { - return nil, errors.Wrapf(cloudprovider.ErrDuplicateId, id) - } - - if len(instances) == 0 { - return nil, errors.Wrapf(cloudprovider.ErrNotFound, id) - } - - instances[0].region = self - return &instances[0], nil + return cluster, nil } func (self *SRegion) CreateIDBInstance(desc *cloudprovider.SManagedDBInstanceCreateConfig) (cloudprovider.ICloudDBInstance, error) { diff --git a/vendor/yunion.io/x/cloudmux/pkg/multicloud/aws/dbinstance_cluster.go b/vendor/yunion.io/x/cloudmux/pkg/multicloud/aws/dbinstance_cluster.go new file mode 100644 index 0000000000..5b4e67ca00 --- /dev/null +++ b/vendor/yunion.io/x/cloudmux/pkg/multicloud/aws/dbinstance_cluster.go @@ -0,0 +1,310 @@ +// 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 aws + +import ( + "context" + "time" + + billing "yunion.io/x/cloudmux/pkg/apis/billing" + api "yunion.io/x/cloudmux/pkg/apis/compute" + "yunion.io/x/cloudmux/pkg/cloudprovider" + "yunion.io/x/cloudmux/pkg/multicloud" + "yunion.io/x/pkg/errors" +) + +type SDBInstanceCluster struct { + multicloud.SDBInstanceBase + AwsTags + + region *SRegion + + CrossAccountClone bool `xml:"CrossAccountClone"` + AllocatedStorage int `xml:"AllocatedStorage"` + IOOptimizedNextAllowedModificationTime time.Time `xml:"IOOptimizedNextAllowedModificationTime"` + AssociatedRoles []string `xml:"AssociatedRoles"` + DBActivityStreamStatus string `xml:"DBActivityStreamStatus"` + HttpEndpointEnabled bool `xml:"HttpEndpointEnabled"` + DBClusterIdentifier string `xml:"DBClusterIdentifier"` + Status string `xml:"Status"` + PreferredBackupWindow string `xml:"PreferredBackupWindow"` + DeletionProtection bool `xml:"DeletionProtection"` + Endpoint string `xml:"Endpoint"` + ReaderEndpoint string `xml:"ReaderEndpoint"` + EarliestRestorableTime time.Time `xml:"EarliestRestorableTime"` + ClusterCreateTime time.Time `xml:"ClusterCreateTime"` + ActivityStreamStatus string `xml:"ActivityStreamStatus"` + DBSubnetGroup string `xml:"DBSubnetGroup"` + VpcSecurityGroups []SVpcSecurityGroupMembership `xml:"VpcSecurityGroups>VpcSecurityGroupMembership"` + PreferredMaintenanceWindow string `xml:"PreferredMaintenanceWindow"` + DBClusterParameterGroup string `xml:"DBClusterParameterGroup"` + AutoMinorVersionUpgrade bool `xml:"AutoMinorVersionUpgrade"` + DBClusterArn string `xml:"DBClusterArn"` + AvailabilityZones []string `xml:"AvailabilityZones>AvailabilityZone"` + ReadReplicaIdentifiers []string `xml:"ReadReplicaIdentifiers"` + DocdbAnalyticsEnabled bool `xml:"DocdbAnalyticsEnabled"` + EngineVersion string `xml:"EngineVersion"` + MasterUsername string `xml:"MasterUsername"` + DBClusterMembers []struct { + DBInstanceIdentifier string `xml:"DBInstanceIdentifier"` + DBClusterParameterGroupStatus string `xml:"DBClusterParameterGroupStatus"` + PromotionTier int `xml:"PromotionTier"` + IsClusterWriter bool `xml:"IsClusterWriter"` + } `xml:"DBClusterMembers>DBClusterMember"` + Port int `xml:"Port"` + BackupRetentionPeriod int `xml:"BackupRetentionPeriod"` + KmsKeyId string `xml:"KmsKeyId"` + DbClusterResourceId string `xml:"DbClusterResourceId"` + LatestRestorableTime time.Time `xml:"LatestRestorableTime"` + EngineMode string `xml:"EngineMode"` + Engine string `xml:"Engine"` + IAMDatabaseAuthenticationEnabled bool `xml:"IAMDatabaseAuthenticationEnabled"` + NetworkType string `xml:"NetworkType"` + MultiAZ bool `xml:"MultiAZ"` + DomainMemberships []string `xml:"DomainMemberships"` + StorageEncrypted bool `xml:"StorageEncrypted"` + HostedZoneId string `xml:"HostedZoneId"` + StorageType string `xml:"StorageType"` + CopyTagsToSnapshot bool `xml:"CopyTagsToSnapshot"` +} + +func (rds *SDBInstanceCluster) GetName() string { + return rds.DBClusterIdentifier +} + +func (rds *SDBInstanceCluster) GetId() string { + return rds.DBClusterIdentifier +} + +func (rds *SDBInstanceCluster) GetGlobalId() string { + return rds.GetId() +} + +func (rds *SDBInstanceCluster) GetStatus() string { + switch rds.Status { + case "creating", "backing-up": + return api.DBINSTANCE_DEPLOYING + case "available": + return api.DBINSTANCE_RUNNING + case "deleting": + return api.DBINSTANCE_DELETING + case "rebooting": + return api.DBINSTANCE_REBOOTING + default: + return api.DBINSTANCE_UNKNOWN + } +} + +func (rds *SDBInstanceCluster) GetBillingType() string { + return billing.BILLING_TYPE_POSTPAID +} + +func (rds *SDBInstanceCluster) Reboot() error { + return cloudprovider.ErrNotImplemented +} + +func (rds *SDBInstanceCluster) GetSecurityGroupIds() ([]string, error) { + ids := []string{} + for _, v := range rds.VpcSecurityGroups { + ids = append(ids, v.VpcSecurityGroupId) + } + return ids, nil +} + +func (rds *SDBInstanceCluster) SetSecurityGroups(ids []string) error { + return cloudprovider.ErrNotSupported +} + +func (rds *SDBInstanceCluster) GetPort() int { + return rds.Port +} + +func (rds *SDBInstanceCluster) GetEngine() string { + return rds.Engine +} + +func (rds *SDBInstanceCluster) GetEngineVersion() string { + return rds.EngineVersion +} + +func (rds *SDBInstanceCluster) GetInstanceType() string { + return "" +} + +func (rds *SDBInstanceCluster) GetVcpuCount() int { + return 0 +} + +func (rds *SDBInstanceCluster) GetDiskSizeGB() int { + return 0 +} + +func (rds *SDBInstanceCluster) GetDiskSizeUsedMB() int { + return 0 +} + +func (rds *SDBInstanceCluster) GetCategory() string { + return api.AWS_DBINSTANCE_CATEGORY_CLUSTER +} + +func (rds *SDBInstanceCluster) GetStorageType() string { + return "standard" +} + +func (rds *SDBInstanceCluster) GetVmemSizeMB() int { + return 0 +} + +func (rds *SDBInstanceCluster) GetMaintainTime() string { + return "" +} + +func (rds *SDBInstanceCluster) GetConnectionStr() string { + return "" +} + +func (rds *SDBInstanceCluster) GetInternalConnectionStr() string { + return "" +} + +func (rds *SDBInstanceCluster) GetZone1Id() string { + for i, zone := range rds.AvailabilityZones { + if i == 0 { + return zone + } + } + return "" +} + +func (rds *SDBInstanceCluster) GetZone2Id() string { + for i, zone := range rds.AvailabilityZones { + if i == 1 { + return zone + } + } + return "" +} + +func (rds *SDBInstanceCluster) GetZone3Id() string { + for i, zone := range rds.AvailabilityZones { + if i == 2 { + return zone + } + } + return "" +} + +func (rds *SDBInstanceCluster) GetIVpcId() string { + return "" +} + +func (rds *SDBInstanceCluster) GetIops() int { + return 0 +} + +func (rds *SDBInstanceCluster) GetDBNetworks() ([]cloudprovider.SDBInstanceNetwork, error) { + return nil, cloudprovider.ErrNotSupported +} + +func (rds *SDBInstanceCluster) GetIDBInstanceParameters() ([]cloudprovider.ICloudDBInstanceParameter, error) { + return nil, cloudprovider.ErrNotSupported +} + +func (rds *SDBInstanceCluster) GetIDBInstanceDatabases() ([]cloudprovider.ICloudDBInstanceDatabase, error) { + return nil, cloudprovider.ErrNotSupported +} + +func (rds *SDBInstanceCluster) GetIDBInstanceAccounts() ([]cloudprovider.ICloudDBInstanceAccount, error) { + return nil, cloudprovider.ErrNotSupported +} + +func (rds *SDBInstanceCluster) GetIDBInstanceBackups() ([]cloudprovider.ICloudDBInstanceBackup, error) { + return nil, cloudprovider.ErrNotSupported +} + +func (rds *SDBInstanceCluster) ChangeConfig(ctx context.Context, config *cloudprovider.SManagedDBInstanceChangeConfig) error { + return cloudprovider.ErrNotSupported +} + +func (rds *SDBInstanceCluster) OpenPublicConnection() error { + return cloudprovider.ErrNotSupported +} + +func (rds *SDBInstanceCluster) ClosePublicConnection() error { + return cloudprovider.ErrNotSupported +} + +func (rds *SDBInstanceCluster) CreateDatabase(conf *cloudprovider.SDBInstanceDatabaseCreateConfig) error { + return cloudprovider.ErrNotSupported +} + +func (rds *SDBInstanceCluster) CreateAccount(conf *cloudprovider.SDBInstanceAccountCreateConfig) error { + return cloudprovider.ErrNotSupported +} + +func (rds *SDBInstanceCluster) CreateIBackup(conf *cloudprovider.SDBInstanceBackupCreateConfig) (string, error) { + return "", cloudprovider.ErrNotSupported +} + +func (rds *SDBInstanceCluster) RecoveryFromBackup(conf *cloudprovider.SDBInstanceRecoveryConfig) error { + return cloudprovider.ErrNotSupported +} + +func (rds *SDBInstanceCluster) Update(ctx context.Context, input cloudprovider.SDBInstanceUpdateOptions) error { + return cloudprovider.ErrNotSupported +} + +func (rds *SDBInstanceCluster) Delete() error { + return cloudprovider.ErrNotSupported +} + +func (region *SRegion) GetDBInstanceClusters(id string) ([]SDBInstanceCluster, error) { + ret := []SDBInstanceCluster{} + params := map[string]string{} + if len(id) > 0 { + params["DBClusterIdentifier"] = id + } + for { + part := struct { + DBClusters []SDBInstanceCluster `xml:"DBClusters>DBCluster"` + Marker string `xml:"Marker"` + }{} + err := region.rdsRequest("DescribeDBClusters", params, &part) + if err != nil { + return nil, errors.Wrap(err, "DescribeDBClusters") + } + ret = append(ret, part.DBClusters...) + if len(part.DBClusters) == 0 || len(part.Marker) == 0 { + break + } + params["Marker"] = part.Marker + } + + return ret, nil +} + +func (region *SRegion) GetDBInstanceCluster(id string) (*SDBInstanceCluster, error) { + clusters, err := region.GetDBInstanceClusters(id) + if err != nil { + return nil, err + } + for i := range clusters { + if clusters[i].DBClusterIdentifier == id { + clusters[i].region = region + return &clusters[i], nil + } + } + return nil, errors.Wrapf(cloudprovider.ErrNotFound, id) +} diff --git a/vendor/yunion.io/x/cloudmux/pkg/multicloud/aws/latitude_and_longitude.go b/vendor/yunion.io/x/cloudmux/pkg/multicloud/aws/latitude_and_longitude.go index 68f75a96cd..3d973ccc51 100644 --- a/vendor/yunion.io/x/cloudmux/pkg/multicloud/aws/latitude_and_longitude.go +++ b/vendor/yunion.io/x/cloudmux/pkg/multicloud/aws/latitude_and_longitude.go @@ -55,4 +55,11 @@ var LatitudeAndLongitude = map[string]cloudprovider.SGeographicInfo{ "ap-southeast-3": api.RegionJakarta, "me-central-1": api.RegionDubai, "il-central-1": api.RegionTelAviv, + + "ap-southeast-6": api.RegionNewZealand, + "ap-east-2": api.RegionTaipei, + "mx-central-1": api.RegionMexico, + "ap-southeast-7": api.RegionBangkok, + "ap-southeast-5": api.RegionKualaLumpur, + "ca-west-1": api.RegionCalgary, } diff --git a/vendor/yunion.io/x/cloudmux/pkg/multicloud/aws/loadbalancerbackend.go b/vendor/yunion.io/x/cloudmux/pkg/multicloud/aws/loadbalancerbackend.go index f302f73be5..dab4e7d895 100644 --- a/vendor/yunion.io/x/cloudmux/pkg/multicloud/aws/loadbalancerbackend.go +++ b/vendor/yunion.io/x/cloudmux/pkg/multicloud/aws/loadbalancerbackend.go @@ -21,6 +21,7 @@ import ( api "yunion.io/x/cloudmux/pkg/apis/compute" "yunion.io/x/cloudmux/pkg/cloudprovider" "yunion.io/x/cloudmux/pkg/multicloud" + "yunion.io/x/pkg/util/netutils" ) type SElbBackends struct { @@ -100,7 +101,11 @@ func (self *SElbBackend) Update(ctx context.Context, opts *cloudprovider.SLoadba } func (self *SElbBackend) GetIpAddress() string { - return "" + _, err := netutils.NewIPV4Addr(self.Target.Id) + if err != nil { + return "" + } + return self.Target.Id } func (self *SRegion) SyncElbBackend(backendId, serverId string, oldPort, newPort int) error { diff --git a/vendor/yunion.io/x/cloudmux/pkg/multicloud/aws/loadbalancercert.go b/vendor/yunion.io/x/cloudmux/pkg/multicloud/aws/loadbalancercert.go index 7b72581172..f155db8318 100644 --- a/vendor/yunion.io/x/cloudmux/pkg/multicloud/aws/loadbalancercert.go +++ b/vendor/yunion.io/x/cloudmux/pkg/multicloud/aws/loadbalancercert.go @@ -38,11 +38,11 @@ type SElbCertificate struct { cert *x509.Certificate Path string `json:"Path"` - ServerCertificateName string `json:"ServerCertificateName"` - ServerCertificateID string `json:"ServerCertificateId"` - Arn string `json:"Arn"` - UploadDate time.Time `json:"UploadDate"` - Expiration time.Time `json:"Expiration"` + ServerCertificateName string `xml:"ServerCertificateName"` + ServerCertificateID string `xml:"ServerCertificateId"` + Arn string `xml:"Arn"` + UploadDate time.Time `xml:"UploadDate"` + Expiration time.Time `xml:"Expiration"` PublicKey string } diff --git a/vendor/yunion.io/x/cloudmux/pkg/multicloud/aws/loadbalancerlistener.go b/vendor/yunion.io/x/cloudmux/pkg/multicloud/aws/loadbalancerlistener.go index 32fc11432d..da013b66bd 100644 --- a/vendor/yunion.io/x/cloudmux/pkg/multicloud/aws/loadbalancerlistener.go +++ b/vendor/yunion.io/x/cloudmux/pkg/multicloud/aws/loadbalancerlistener.go @@ -42,22 +42,22 @@ type SElbListener struct { lb *SElb group *SElbBackendGroup - Port int `json:"Port"` - Protocol string `json:"Protocol"` + Port int `xml:"Port"` + Protocol string `xml:"Protocol"` DefaultActions []DefaultAction `xml:"DefaultActions>member"` - SSLPolicy string `json:"SslPolicy"` - Certificates []Certificate `json:"Certificates"` - LoadBalancerArn string `json:"LoadBalancerArn"` - ListenerArn string `json:"ListenerArn"` + SSLPolicy string `xml:"SslPolicy"` + Certificates []Certificate `xml:"Certificates>member"` + LoadBalancerArn string `xml:"LoadBalancerArn"` + ListenerArn string `xml:"ListenerArn"` } type Certificate struct { - CertificateArn string `json:"CertificateArn"` + CertificateArn string `xml:"CertificateArn"` } type DefaultAction struct { - TargetGroupArn string `json:"TargetGroupArn"` - Type string `json:"Type"` + TargetGroupArn string `xml:"TargetGroupArn"` + Type string `xml:"Type"` } func (self *SElbListener) GetId() string { @@ -379,7 +379,7 @@ func (self *SElbListener) CreateILoadBalancerListenerRule(rule *cloudprovider.SL } func (self *SElbListener) GetILoadBalancerListenerRuleById(ruleId string) (cloudprovider.ICloudLoadbalancerListenerRule, error) { - rule, err := self.lb.region.GetElbListenerRule(ruleId) + rule, err := self.lb.region.GetElbListenerRule(self.ListenerArn, ruleId) if err != nil { return nil, errors.Wrap(err, "GetElbListenerRule") } @@ -389,19 +389,13 @@ func (self *SElbListener) GetILoadBalancerListenerRuleById(ruleId string) (cloud func (self *SElbListener) GetILoadbalancerListenerRules() ([]cloudprovider.ICloudLoadbalancerListenerRule, error) { ret := []cloudprovider.ICloudLoadbalancerListenerRule{} - marker := "" - for { - part, marker, err := self.lb.region.GetElbListenerRules(self.ListenerArn, "", marker) - if err != nil { - return nil, err - } - for i := range part { - part[i].listener = self - ret = append(ret, &part[i]) - } - if len(marker) == 0 || len(part) == 0 { - break - } + rules, err := self.lb.region.GetElbListenerRules(self.ListenerArn, "") + if err != nil { + return nil, err + } + for i := range rules { + rules[i].listener = self + ret = append(ret, &rules[i]) } return ret, nil } @@ -603,7 +597,7 @@ func (self *SRegion) CreateElbListener(lbId string, opts *cloudprovider.SLoadbal return nil, errors.Wrapf(cloudprovider.ErrNotFound, "after created") } -func (self *SRegion) GetElbListenerRules(listenerId string, ruleId, marker string) ([]SElbListenerRule, string, error) { +func (self *SRegion) GetElbListenerRules(listenerId string, ruleId string) ([]SElbListenerRule, error) { params := map[string]string{} if len(listenerId) > 0 { params["ListenerArn"] = listenerId @@ -611,28 +605,37 @@ func (self *SRegion) GetElbListenerRules(listenerId string, ruleId, marker strin if len(ruleId) > 0 { params["RuleArns.member.1"] = ruleId } - if len(marker) > 0 { - params["Marker"] = marker + + ret := []SElbListenerRule{} + for { + part := struct { + Rules []SElbListenerRule `xml:"Rules>member"` + NextMarker string + }{} + err := self.elbRequest("DescribeRules", params, &part) + if err != nil { + return nil, errors.Wrapf(err, "DescribeRules") + } + ret = append(ret, part.Rules...) + if len(part.NextMarker) == 0 || len(part.Rules) == 0 { + break + } + params["Marker"] = part.NextMarker } - ret := &SElbListenerRules{} - err := self.elbRequest("DescribeRules", params, ret) - if err != nil { - return nil, "", errors.Wrapf(err, "DescribeRules") - } - return ret.Rules, ret.NextMarker, nil + return ret, nil } -func (self *SRegion) GetElbListenerRule(id string) (*SElbListenerRule, error) { - rules, _, err := self.GetElbListenerRules("", id, "") +func (self *SRegion) GetElbListenerRule(lisId, ruleId string) (*SElbListenerRule, error) { + rules, err := self.GetElbListenerRules(lisId, ruleId) if err != nil { return nil, errors.Wrapf(err, "GetElbListenerRules") } for i := range rules { - if rules[i].RuleArn == id { + if rules[i].RuleArn == ruleId { return &rules[i], nil } } - return nil, errors.Wrapf(cloudprovider.ErrNotFound, id) + return nil, errors.Wrapf(cloudprovider.ErrNotFound, ruleId) } func (self *SRegion) DeleteElbListener(id string) error { diff --git a/vendor/yunion.io/x/cloudmux/pkg/multicloud/aws/loadbalancerlistenerrule.go b/vendor/yunion.io/x/cloudmux/pkg/multicloud/aws/loadbalancerlistenerrule.go index 9ed6f0df3a..536c6231aa 100644 --- a/vendor/yunion.io/x/cloudmux/pkg/multicloud/aws/loadbalancerlistenerrule.go +++ b/vendor/yunion.io/x/cloudmux/pkg/multicloud/aws/loadbalancerlistenerrule.go @@ -40,45 +40,45 @@ type SElbListenerRule struct { listener *SElbListener region *SRegion - Priority string `json:"Priority"` - IsDefaultRule bool `json:"IsDefault"` - Actions []Action `json:"Actions"` - RuleArn string `json:"RuleArn"` - Conditions []Condition `json:"Conditions"` + Priority string `xml:"Priority"` + IsDefaultRule bool `xml:"IsDefault"` + Actions []Action `xml:"Actions>member"` + RuleArn string `xml:"RuleArn"` + Conditions []Condition `xml:"Conditions>member"` } type Action struct { - TargetGroupArn string `json:"TargetGroupArn"` - Type string `json:"Type"` + TargetGroupArn string `xml:"TargetGroupArn"` + Type string `xml:"Type"` } type Condition struct { - Field string `json:"field"` - HTTPRequestMethodConfig *Config `json:"httpRequestMethodConfig,omitempty"` - Values []string `json:"values"` - SourceIPConfig *Config `json:"sourceIpConfig,omitempty"` - QueryStringConfig *QueryStringConfig `json:"queryStringConfig,omitempty"` - HTTPHeaderConfig *HTTPHeaderConfig `json:"httpHeaderConfig,omitempty"` - PathPatternConfig *Config `json:"pathPatternConfig,omitempty"` - HostHeaderConfig *Config `json:"hostHeaderConfig,omitempty"` + Field string `xml:"Field"` + HTTPRequestMethodConfig *Config `xml:"HttpRequestMethodConfig"` + Values []string `xml:"Values>member"` + SourceIPConfig *Config `xml:"SourceIpConfig"` + QueryStringConfig *QueryStringConfig `xml:"QueryStringConfig"` + HTTPHeaderConfig *HTTPHeaderConfig `xml:"HttpHeaderConfig"` + PathPatternConfig *Config `xml:"PathPatternConfig"` + HostHeaderConfig *Config `xml:"HostHeaderConfig"` } type HTTPHeaderConfig struct { - HTTPHeaderName string `json:"HttpHeaderName"` - Values []string `json:"values"` + HTTPHeaderName string `xml:"HttpHeaderName"` + Values []string `xml:"Values>member"` } type Config struct { - Values []string `json:"values"` + Values []string `xml:"Values>member"` } type QueryStringConfig struct { - Values []Query `json:"values"` + Values []Query `xml:"Values>member"` } type Query struct { - Key string `json:"key"` - Value string `json:"value"` + Key string `xml:"key"` + Value string `xml:"value"` } func (self *SElbListenerRule) GetId() string { @@ -99,7 +99,7 @@ func (self *SElbListenerRule) GetStatus() string { } func (self *SElbListenerRule) Refresh() error { - rule, err := self.region.GetElbListenerRule(self.RuleArn) + rule, err := self.region.GetElbListenerRule(self.listener.ListenerArn, self.RuleArn) if err != nil { return err } diff --git a/vendor/yunion.io/x/cloudmux/pkg/multicloud/aws/region.go b/vendor/yunion.io/x/cloudmux/pkg/multicloud/aws/region.go index 0d3a0f9a3b..5233febe56 100644 --- a/vendor/yunion.io/x/cloudmux/pkg/multicloud/aws/region.go +++ b/vendor/yunion.io/x/cloudmux/pkg/multicloud/aws/region.go @@ -74,6 +74,12 @@ var RegionLocations = map[string]string{ "me-central-1": "中东(阿联酋)", "ap-southeast-3": "亚太地区(雅加达)", "il-central-1": "以色列(特拉维夫)", + "ap-southeast-6": "亚太地区(新西兰)", + "ap-east-2": "亚太地区(台北)", + "mx-central-1": "北美地区(墨西哥)", + "ap-southeast-7": "亚太地区(泰国)", + "ap-southeast-5": "亚太地区(马来西亚)", + "ca-west-1": "加拿大(卡尔加里)", } // https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Concepts.RegionsAndAvailabilityZones.html @@ -111,6 +117,12 @@ var RegionLocationsEN = map[string]string{ "me-central-1": "Middle East (UAE)", "ap-southeast-3": "Asia Pacific (Jakarta)", "il-central-1": "Israel (Tel Aviv)", + "ap-southeast-6": "Asia Pacific (New Zealand)", + "ap-east-2": "Asia Pacific (Taipei)", + "mx-central-1": "North America (Mexico)", + "ap-southeast-7": "Asia Pacific (Thailand)", + "ap-southeast-5": "Asia Pacific (Malaysia)", + "ca-west-1": "Canada (Calgary)", } const ( @@ -275,7 +287,7 @@ func (self *SRegion) eksRequest(apiName, path string, params map[string]interfac return self.client.invoke(self.RegionId, EKS_SERVICE_NAME, EKS_SERVICE_ID, "2017-11-01", apiName, path, params, retval, true) } -///////////////////////////////////////////////////////////////////////////// +// /////////////////////////////////////////////////////////////////////////// func (self *SRegion) GetZones(id string) ([]SZone, error) { params := map[string]string{ "Filter.1.Name": "region-name", diff --git a/vendor/yunion.io/x/cloudmux/pkg/multicloud/google/latitude_and_longitude.go b/vendor/yunion.io/x/cloudmux/pkg/multicloud/google/latitude_and_longitude.go index 3b9cb1884d..d4768cbf97 100644 --- a/vendor/yunion.io/x/cloudmux/pkg/multicloud/google/latitude_and_longitude.go +++ b/vendor/yunion.io/x/cloudmux/pkg/multicloud/google/latitude_and_longitude.go @@ -59,10 +59,12 @@ var LatitudeAndLongitude = map[string]cloudprovider.SGeographicInfo{ "us-south1": api.RegionDallas, "southamerica-west1": api.RegionSantiago, - "me-west1": api.RegionTelAviv, - "me-central1": api.RegionDoha, - "me-central2": api.RegionDamman, - "africa-south1": api.RegionJohannesburg, + "me-west1": api.RegionTelAviv, + "me-central1": api.RegionDoha, + "me-central2": api.RegionDamman, + "africa-south1": api.RegionJohannesburg, + "europe-north2": api.RegionStockholm, + "northamerica-south1": api.RegionMexico, } var RegionNames = map[string]string{ @@ -118,6 +120,8 @@ var RegionNames = map[string]string{ "nam4": "爱荷华和南卡罗来纳", "eur4": "荷兰和芬兰", - "global": "全球", - "africa-south1": "约翰内斯堡", + "global": "全球", + "africa-south1": "约翰内斯堡", + "europe-north2": "斯德哥尔摩", + "northamerica-south1": "墨西哥", } diff --git a/vendor/yunion.io/x/cloudmux/pkg/multicloud/qcloud/loadbalancer_backend.go b/vendor/yunion.io/x/cloudmux/pkg/multicloud/qcloud/loadbalancer_backend.go index 2de5da8eae..a02717561f 100644 --- a/vendor/yunion.io/x/cloudmux/pkg/multicloud/qcloud/loadbalancer_backend.go +++ b/vendor/yunion.io/x/cloudmux/pkg/multicloud/qcloud/loadbalancer_backend.go @@ -17,6 +17,7 @@ package qcloud import ( "context" "fmt" + "strings" "yunion.io/x/jsonutils" @@ -58,14 +59,15 @@ type Rule struct { Targets []SLBBackend `json:"Targets"` } -// ========================================================== - -// backend InstanceId + protocol +Port + ip + rip全局唯一 +// backend InstanceId + protocol + port + ip + rip全局唯一 func (self *SLBBackend) GetId() string { - if len(self.Domain) == 0 { - return fmt.Sprintf("%s/%s-%d", self.group.GetId(), self.InstanceId, self.Port) + ret := []string{self.group.GetId(), self.InstanceId, fmt.Sprintf("%d", self.Port)} + ret = append(ret, self.PrivateIPAddresses...) + if len(self.Domain) > 0 { + ret = append(ret, self.Domain) + ret = append(ret, self.Url) } - return fmt.Sprintf("%s/%s-%d:%s%s", self.group.GetId(), self.InstanceId, self.Port, self.Domain, self.Url) + return strings.Join(ret, "/") } func (self *SLBBackend) GetName() string { diff --git a/vendor/yunion.io/x/sqlchemy/backends.go b/vendor/yunion.io/x/sqlchemy/backends.go index 16253f3cde..4b0eafab6b 100644 --- a/vendor/yunion.io/x/sqlchemy/backends.go +++ b/vendor/yunion.io/x/sqlchemy/backends.go @@ -123,6 +123,8 @@ type IBackend interface { DATE_FORMAT(name string, field IQueryField, format string) IQueryField // INET_ATON INET_ATON(field IQueryField) IQueryField + // INET6_ATON + INET6_ATON(field IQueryField) IQueryField // AND_Val AND_Val(name string, field IQueryField, v interface{}) IQueryField // OR_Val diff --git a/vendor/yunion.io/x/sqlchemy/backends/dameng/functions.go b/vendor/yunion.io/x/sqlchemy/backends/dameng/functions.go index ed534cce29..46d161b422 100644 --- a/vendor/yunion.io/x/sqlchemy/backends/dameng/functions.go +++ b/vendor/yunion.io/x/sqlchemy/backends/dameng/functions.go @@ -31,7 +31,7 @@ func (dameng *SDamengBackend) GROUP_CONCAT2(name string, sep string, field sqlch // INET_ATON represents the SQL function INET_ATON func (dameng *SDamengBackend) INET_ATON(field sqlchemy.IQueryField) sqlchemy.IQueryField { - expr := "" + /*expr := "" vars := make([]sqlchemy.IQueryField, 0) expr += `TO_NUMBER(SUBSTR(%s,1,INSTR(%s,'.')-1))*POWER(256,3)+` vars = append(vars, field, field) @@ -41,7 +41,8 @@ func (dameng *SDamengBackend) INET_ATON(field sqlchemy.IQueryField) sqlchemy.IQu vars = append(vars, field, field, field, field) expr += `TO_NUMBER(SUBSTR(%s,INSTR(%s,'.',1,3)+1))` vars = append(vars, field, field) - return sqlchemy.NewFunctionField("", false, expr, vars...) + return sqlchemy.NewFunctionField("", false, expr, vars...)*/ + return sqlchemy.NewFunctionField("", false, `HEX(SF_INET_SORT(%s))`, field) } // cast field to string @@ -58,3 +59,8 @@ func (dameng *SDamengBackend) CASTInt(field sqlchemy.IQueryField, fieldname stri func (dameng *SDamengBackend) CASTFloat(field sqlchemy.IQueryField, fieldname string) sqlchemy.IQueryField { return sqlchemy.NewFunctionField(fieldname, false, `CAST(%s AS REAL)`, field) } + +// INET6_ATON represents a SQL function INET6_ATON +func (dameng *SDamengBackend) INET6_ATON(field sqlchemy.IQueryField) sqlchemy.IQueryField { + return sqlchemy.NewFunctionField("", false, `HEX(SF_INET_SORT(%s))`, field) +} diff --git a/vendor/yunion.io/x/sqlchemy/backends_base.go b/vendor/yunion.io/x/sqlchemy/backends_base.go index 3855e21ad5..92f95e37ed 100644 --- a/vendor/yunion.io/x/sqlchemy/backends_base.go +++ b/vendor/yunion.io/x/sqlchemy/backends_base.go @@ -154,6 +154,11 @@ func (bb *SBaseBackend) INET_ATON(field IQueryField) IQueryField { return NewFunctionField("", false, `INET_ATON(%s)`, field) } +// INET6_ATON represents a SQL function INET6_ATON +func (bb *SBaseBackend) INET6_ATON(field IQueryField) IQueryField { + return NewFunctionField("", false, `INET6_ATON(%s)`, field) +} + // SubStr represents a SQL function SUBSTR func (bb *SBaseBackend) SUBSTR(name string, field IQueryField, pos, length int) IQueryField { var rightStr string diff --git a/vendor/yunion.io/x/sqlchemy/functions.go b/vendor/yunion.io/x/sqlchemy/functions.go index 9542b67ad6..4bd8ca73b6 100644 --- a/vendor/yunion.io/x/sqlchemy/functions.go +++ b/vendor/yunion.io/x/sqlchemy/functions.go @@ -228,6 +228,8 @@ func REPLACE(name string, field IQueryField, old string, new string) IQueryField type SConstField struct { constVar interface{} alias string + + db *SDatabase } // Expression implementation of SConstField for IQueryField @@ -260,7 +262,7 @@ func (s *SConstField) ConvertFromValue(val interface{}) interface{} { // database implementation of SConstField for IQueryField func (s *SConstField) database() *SDatabase { - return nil + return s.db } // Variables implementation of SConstField for IQueryField @@ -278,10 +280,24 @@ func NewConstField(variable interface{}) *SConstField { return &SConstField{constVar: variable} } +// database implementation of SStringField for IQueryField +func (s *SConstField) WithField(f IQueryField) *SConstField { + s.db = f.database() + return s +} + +func (q *SQuery) ConstField(variable interface{}) *SConstField { + f := NewConstField(variable) + f.db = q.db + return f +} + // SStringField is a query field of a string constant type SStringField struct { strConst string alias string + + db *SDatabase } // Expression implementation of SStringField for IQueryField @@ -314,7 +330,7 @@ func (s *SStringField) ConvertFromValue(val interface{}) interface{} { // database implementation of SStringField for IQueryField func (s *SStringField) database() *SDatabase { - return nil + return s.db } // Variables implementation of SStringField for IQueryField @@ -327,11 +343,23 @@ func (s *SStringField) IsAggregate() bool { return true } +// database implementation of SStringField for IQueryField +func (s *SStringField) WithField(f IQueryField) *SStringField { + s.db = f.database() + return s +} + // NewStringField returns an instance of SStringField func NewStringField(strConst string) *SStringField { return &SStringField{strConst: strConst} } +func (q *SQuery) StringField(strConst string) *SStringField { + f := NewStringField(strConst) + f.db = q.db + return f +} + // CONCAT represents a SQL function CONCAT func CONCAT(name string, fields ...IQueryField) IQueryField { return getFieldBackend(fields...).CONCAT(name, fields...) @@ -363,6 +391,11 @@ func INET_ATON(field IQueryField) IQueryField { return getFieldBackend(field).INET_ATON(field) } +// INET6_ATON represents a SQL function INET_ATON +func INET6_ATON(field IQueryField) IQueryField { + return getFieldBackend(field).INET6_ATON(field) +} + // TimestampAdd represents a SQL function TimestampAdd func TimestampAdd(name string, field IQueryField, offsetSeconds int) IQueryField { return TIMESTAMPADD(name, field, offsetSeconds)