-
Notifications
You must be signed in to change notification settings - Fork 72
/
data.go
234 lines (195 loc) · 6.36 KB
/
data.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
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
package create
import (
"github.com/redhat-developer/app-services-cli/pkg/shared/accountmgmtutil"
"github.com/redhat-developer/app-services-cli/pkg/shared/factory"
kafkamgmtclient "github.com/redhat-developer/app-services-sdk-go/kafkamgmt/apiv1/client"
)
// Types we use on backend to map AMS Quotas
type CloudProviderId = string
// Additional types that are used in backend to match
// AMS Quota instance types
const (
// Matches QuotaTrialType = trial
DeveloperType CloudProviderId = "developer"
// Matches QuotaStandardType = standard
StandardType CloudProviderId = "standard"
// Deprecated by DeveloperType
TrialType CloudProviderId = "eval"
)
// mapAmsTypeToBackendType - Cloud providers API is not using AMS types but some other values (CloudProviderValues)
func mapAmsTypeToBackendType(amsType *accountmgmtutil.QuotaSpec) CloudProviderId {
switch amsType.Name {
case accountmgmtutil.QuotaStandardType:
return StandardType
case accountmgmtutil.QuotaMarketplaceType:
return StandardType
case accountmgmtutil.QuotaTrialType:
return DeveloperType
default:
return DeveloperType
}
}
func GetValidKafkaSizesLabels(sizes []kafkamgmtclient.SupportedKafkaSize) []string {
var labels []string = make([]string, len(sizes))
for i := range sizes {
labels[i] = sizes[i].GetId()
}
return labels
}
func FetchValidKafkaSizesLabels(f *factory.Factory,
providerID string, regionId string, amsType accountmgmtutil.QuotaSpec) ([]string, error) {
sizes, err := FetchValidKafkaSizes(f, providerID, regionId, amsType)
if err != nil {
return nil, err
}
return GetValidKafkaSizesLabels(sizes), nil
}
func FetchSupportedBillingModels(userQuotas *accountmgmtutil.OrgQuotas) []string {
billingModels := []string{}
if len(userQuotas.StandardQuotas) > 0 {
billingModels = append(billingModels, accountmgmtutil.QuotaStandardType)
}
if len(userQuotas.MarketplaceQuotas) > 0 {
billingModels = append(billingModels, accountmgmtutil.QuotaMarketplaceType)
}
return billingModels
}
func FetchValidMarketplaces(amsTypes []accountmgmtutil.QuotaSpec) []string {
validMarketplaces := []string{}
for _, quota := range amsTypes {
if quota.CloudAccounts != nil {
for _, cloudAccount := range *quota.CloudAccounts {
validMarketplaces = append(validMarketplaces, *cloudAccount.CloudProviderId)
}
}
}
return unique(validMarketplaces)
}
func FetchValidMarketplaceAccounts(amsTypes []accountmgmtutil.QuotaSpec, marketplace string) []string {
validAccounts := []string{}
for _, quota := range amsTypes {
if quota.CloudAccounts != nil {
for _, cloudAccount := range *quota.CloudAccounts {
if marketplace != "" {
if cloudAccount.GetCloudProviderId() == marketplace {
validAccounts = append(validAccounts, cloudAccount.GetCloudAccountId())
}
} else {
validAccounts = append(validAccounts, cloudAccount.GetCloudAccountId())
}
}
}
}
return unique(validAccounts)
}
// return list of the valid instance sizes for the specified region and ams instance types
func FetchValidKafkaSizes(f *factory.Factory,
providerID string, regionId string, amsType accountmgmtutil.QuotaSpec) ([]kafkamgmtclient.SupportedKafkaSize, error) {
conn, err := f.Connection()
if err != nil {
return nil, err
}
validSizes := []kafkamgmtclient.SupportedKafkaSize{}
instanceTypes, _, err := conn.API().
KafkaMgmt().
GetInstanceTypesByCloudProviderAndRegion(f.Context, providerID, regionId).
Execute()
if err != nil {
return nil, err
}
desiredInstanceType := mapAmsTypeToBackendType(&amsType)
// Temporary workaround to be removed
if desiredInstanceType == DeveloperType {
for _, instanceType := range instanceTypes.GetInstanceTypes() {
if desiredInstanceType == instanceType.GetId() {
instanceSizes := instanceType.GetSizes()
for i := range instanceSizes {
validSizes = append(validSizes, instanceSizes[i])
}
}
}
} else {
for _, instanceType := range instanceTypes.GetInstanceTypes() {
if desiredInstanceType == instanceType.GetId() {
instanceSizes := instanceType.GetSizes()
for i := range instanceSizes {
if instanceSizes[i].GetQuotaConsumed() <= int32(amsType.Quota) {
validSizes = append(validSizes, instanceSizes[i])
}
}
}
}
}
return validSizes, nil
}
// GetEnabledCloudProviderNames returns a list of cloud provider names from the enabled cloud providers
func GetEnabledCloudProviderNames(f *factory.Factory) ([]string, error) {
validProviders := []string{}
conn, err := f.Connection()
if err != nil {
return validProviders, err
}
cloudProviderResponse, _, err := conn.API().KafkaMgmt().GetCloudProviders(f.Context).Execute()
if err != nil {
return validProviders, err
}
cloudProviders := cloudProviderResponse.GetItems()
cloudProviderNames := []string{}
for _, provider := range cloudProviders {
if provider.GetEnabled() {
cloudProviderNames = append(cloudProviderNames, provider.GetName())
}
}
return cloudProviderNames, err
}
// GetEnabledCloudRegionIDs extracts and returns a slice of the unique IDs of all enabled regions
func GetEnabledCloudRegionIDs(f *factory.Factory, providerID string, userAllowedAMSInstanceType *accountmgmtutil.QuotaSpec) ([]string, error) {
validRegions := []string{}
conn, err := f.Connection()
if err != nil {
return validRegions, err
}
cloudProviderResponse, _, err := conn.API().
KafkaMgmt().
GetCloudProviderRegions(f.Context, providerID).
Execute()
if err != nil {
return validRegions, err
}
regions := cloudProviderResponse.GetItems()
var regionIDs []string
for i, region := range regions {
if region.GetEnabled() {
if userAllowedAMSInstanceType != nil {
if IsRegionAllowed(®ions[i], userAllowedAMSInstanceType) {
regionIDs = append(regionIDs, region.GetId())
}
} else {
regionIDs = append(regionIDs, region.GetId())
}
}
}
return regionIDs, err
}
func IsRegionAllowed(region *kafkamgmtclient.CloudRegion, userInstanceType *accountmgmtutil.QuotaSpec) bool {
if len(region.Capacity) > 0 {
backendInstanceType := mapAmsTypeToBackendType(userInstanceType)
for _, capacityItem := range region.Capacity {
if capacityItem.InstanceType == backendInstanceType {
return true
}
}
}
return false
}
func unique(s []string) []string {
inResult := make(map[string]bool)
var result []string
for _, str := range s {
if _, ok := inResult[str]; !ok {
inResult[str] = true
result = append(result, str)
}
}
return result
}