/
ack.go
168 lines (150 loc) · 5.08 KB
/
ack.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
// Copyright (c) 2021 Terminus, Inc.
//
// This program is free software: you can use, redistribute, and/or modify
// it under the terms of the GNU Affero General Public License, version 3
// or later ("AGPL"), as published by the Free Software Foundation.
//
// This program is distributed in the hope that it will be useful, but WITHOUT
// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
// FITNESS FOR A PARTICULAR PURPOSE.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
package ack
import (
"encoding/json"
"fmt"
"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
"github.com/aliyun/alibaba-cloud-sdk-go/services/cs"
"github.com/sirupsen/logrus"
aliyun_resources "github.com/erda-project/erda/modules/cmp/impl/aliyun-resources"
)
type DescribeACKInstancesResponse struct {
aliyun_resources.ResponsePager
Instances []Instance
}
type Instance struct {
Name string `json:"name"`
ClusterID string `json:"cluster_id"`
Size int `json:"size"`
RegionID string `json:"region_id"`
ClusterType string `json:"cluster_type"`
CurrentVersion string `json:"current_version"` //k8s version
State string `json:"state"`
Parameters Parameters `json:"parameters"`
Tags []Tag `json:"tags"`
}
type Parameters struct {
MasterInstanceChargeType string `json:"MasterInstanceChargeType"`
MasterInstanceType string `json:"MasterInstanceType"`
WorkerInstanceChargeType string `json:"WorkerInstanceChargeType"`
WorkerInstanceType string `json:"WorkerInstanceType"`
}
type Tag struct {
Key string `json:"key"`
Value string `json:"value"`
}
func ListByCluster(ctx aliyun_resources.Context, page aliyun_resources.PageOption, cluster string) (*DescribeACKInstancesResponse, error) {
// create client
client, err := cs.NewClientWithAccessKey(ctx.Region, ctx.AccessKeyID, ctx.AccessSecret)
if err != nil {
logrus.Errorf("create vpc client error: %+v", err)
return nil, err
}
// create request
request := cs.CreateDescribeClustersRequest()
request.Scheme = "https"
if page.PageNumber == nil || page.PageSize == nil || *page.PageSize <= 0 || *page.PageNumber <= 0 {
err := fmt.Errorf("invalid page parameters: %+v", page)
logrus.Errorf(err.Error())
return nil, err
}
// describe resource
// status:
// running
// stoped
response, err := client.DescribeClusters(request)
if err != nil {
if response != nil && response.BaseResponse != nil && response.BaseResponse.GetHttpStatus() != 200 {
logrus.Errorf("describe vpc failed, error: %+v", err)
return nil, err
}
}
if response == nil {
err := fmt.Errorf("describe vpc failed, empty response")
logrus.Errorf(err.Error())
return nil, err
}
var resourceList []Instance
b := response.GetHttpContentBytes()
if err := json.Unmarshal(b, &resourceList); err != nil {
logrus.Errorf("unmarshal ack response failed, error: %+v", err)
return nil, err
}
var instances []Instance
tagKey, tagValue := aliyun_resources.GenClusterTag(cluster)
for _, resource := range resourceList {
for _, kv := range resource.Tags {
if kv.Key == tagKey && kv.Value == tagValue {
instances = append(instances, resource)
break
}
}
}
//// test
//instances = append(instances, Instance{
// Name: "terminus-dev-fake-ack",
// ClusterID: "123456",
// Size: 11,
// RegionID: "cn-hangzhou",
// ClusterType: "Kubernetes",
// CurrentVersion: "1.10.4",
// State: "running",
// Parameters: Parameters{
// MasterInstanceChargeType: "PrePaid",
// MasterInstanceType: "ecs.r5.xlarge",
// },
// Tags: nil},
//)
return &DescribeACKInstancesResponse{
ResponsePager: aliyun_resources.ResponsePager{
TotalCount: len(instances),
PageSize: *page.PageSize,
PageNumber: *page.PageNumber,
},
Instances: instances,
}, nil
}
func TagResource(ctx aliyun_resources.Context, cluster string, resourceIDs []string) error {
if len(resourceIDs) == 0 {
return nil
}
for _, id := range resourceIDs {
_ = TagOneResource(ctx, cluster, id)
}
return nil
}
func TagOneResource(ctx aliyun_resources.Context, cluster string, resourceID string) error {
client, err := cs.NewClientWithAccessKey(ctx.Region, ctx.AccessKeyID, ctx.AccessSecret)
if err != nil {
logrus.Errorf("create vpc client error: %+v", err)
return err
}
request := requests.NewCommonRequest()
request.Method = "POST"
request.Scheme = "https"
request.Domain = "cs.aliyuncs.com"
request.Version = "2015-12-15"
request.PathPattern = fmt.Sprintf("/clusters/%s/tags", resourceID)
request.Headers["Content-Type"] = "application/json"
request.QueryParams["RegionId"] = ctx.Region
tagKey, tagValue := aliyun_resources.GenClusterTag(cluster)
body := fmt.Sprintf(`[{"key":"%s","value":"%s"}]`, tagKey, tagValue)
request.Content = []byte(body)
_, err = client.ProcessCommonRequest(request)
if err != nil {
logrus.Errorf("tag ack resource failed, cluster: %s, resource id: %s, error: %+v", cluster, resourceID, err)
return err
}
return nil
}