@@ -21,8 +21,10 @@ import (
21
21
"encoding/json"
22
22
"fmt"
23
23
"log"
24
+ "net"
24
25
"net/http"
25
26
"os"
27
+ "strconv"
26
28
"strings"
27
29
"time"
28
30
@@ -32,6 +34,7 @@ import (
32
34
corev1 "k8s.io/api/core/v1"
33
35
34
36
"github.com/minio/mcs/cluster"
37
+ madmin "github.com/minio/minio/pkg/madmin"
35
38
36
39
"github.com/go-openapi/runtime/middleware"
37
40
"github.com/go-openapi/swag"
@@ -128,45 +131,127 @@ func getDeleteTenantResponse(token string, params admin_api.DeleteTenantParams)
128
131
return deleteTenantAction (context .Background (), opClient , params .Namespace , params .Tenant )
129
132
}
130
133
131
- func getTenantInfoResponse (token string , params admin_api.TenantInfoParams ) (* models.Tenant , error ) {
132
- opClient , err := cluster .OperatorClient (token )
134
+ func identifyMinioInstanceScheme (mi * operator.MinIOInstance ) string {
135
+ scheme := "http"
136
+ if mi .RequiresAutoCertSetup () || mi .RequiresExternalCertSetup () {
137
+ scheme = "https"
138
+ }
139
+ return scheme
140
+ }
141
+
142
+ func getTenantAdminClient (ctx context.Context , client K8sClient , namespace , tenantName , serviceName , scheme string ) (* madmin.AdminClient , error ) {
143
+ // get admin credentials from secret
144
+ creds , err := client .getSecret (ctx , namespace , fmt .Sprintf ("%s-secret" , tenantName ), metav1.GetOptions {})
133
145
if err != nil {
134
146
return nil , err
135
147
}
148
+ accessKey , ok := creds .Data ["accesskey" ]
149
+ if ! ok {
150
+ log .Println ("tenant's secret doesn't contain accesskey" )
151
+ return nil , errorGeneric
152
+ }
153
+ secretkey , ok := creds .Data ["secretkey" ]
154
+ if ! ok {
155
+ log .Println ("tenant's secret doesn't contain secretkey" )
156
+ return nil , errorGeneric
157
+ }
158
+ service , err := client .getService (ctx , namespace , serviceName , metav1.GetOptions {})
159
+ if err != nil {
160
+ return nil , err
161
+ }
162
+ mAdmin , pErr := NewAdminClient (scheme + "://" + net .JoinHostPort (service .Spec .ClusterIP , strconv .Itoa (operator .MinIOPort )), string (accessKey ), string (secretkey ))
163
+ if pErr != nil {
164
+ return nil , pErr .Cause
165
+ }
166
+ return mAdmin , nil
167
+ }
136
168
137
- minInst , err := opClient .OperatorV1 ().MinIOInstances (params .Namespace ).Get (context .Background (), params .Tenant , metav1.GetOptions {})
169
+ func getMinioInstance (ctx context.Context , operatorClient OperatorClient , namespace , tenantName string ) (* operator.MinIOInstance , error ) {
170
+ minInst , err := operatorClient .MinIOInstanceGet (ctx , namespace , tenantName , metav1.GetOptions {})
138
171
if err != nil {
139
172
return nil , err
140
173
}
174
+ return minInst , nil
175
+ }
141
176
177
+ func getTenantInfo (minioInstance * operator.MinIOInstance , tenantInfo * usageInfo ) * models.Tenant {
142
178
var instanceCount int64
143
179
var volumeCount int64
144
- for _ , zone := range minInst .Spec .Zones {
180
+ for _ , zone := range minioInstance .Spec .Zones {
145
181
instanceCount = instanceCount + int64 (zone .Servers )
146
- volumeCount = volumeCount + int64 (zone .Servers * int32 (minInst .Spec .VolumesPerServer ))
182
+ volumeCount = volumeCount + int64 (zone .Servers * int32 (minioInstance .Spec .VolumesPerServer ))
147
183
}
148
184
149
185
var zones []* models.Zone
150
186
151
- for _ , z := range minInst .Spec .Zones {
187
+ for _ , z := range minioInstance .Spec .Zones {
152
188
zones = append (zones , & models.Zone {
153
189
Name : z .Name ,
154
190
Servers : int64 (z .Servers ),
155
191
})
156
192
}
157
193
158
194
return & models.Tenant {
159
- CreationDate : minInst .ObjectMeta .CreationTimestamp .String (),
195
+ CreationDate : minioInstance .ObjectMeta .CreationTimestamp .String (),
160
196
InstanceCount : instanceCount ,
161
- Name : params . Tenant ,
162
- VolumesPerServer : int64 (minInst .Spec .VolumesPerServer ),
197
+ Name : minioInstance . Name ,
198
+ VolumesPerServer : int64 (minioInstance .Spec .VolumesPerServer ),
163
199
VolumeCount : volumeCount ,
164
- VolumeSize : minInst .Spec .VolumeClaimTemplate .Spec .Resources .Requests .Storage ().Value (),
165
- ZoneCount : int64 (len (minInst .Spec .Zones )),
166
- CurrentState : minInst .Status .CurrentState ,
200
+ VolumeSize : minioInstance .Spec .VolumeClaimTemplate .Spec .Resources .Requests .Storage ().Value (),
201
+ TotalSize : int64 (minioInstance .Spec .VolumeClaimTemplate .Spec .Resources .Requests .Storage ().Value () * volumeCount ),
202
+ ZoneCount : int64 (len (minioInstance .Spec .Zones )),
203
+ CurrentState : minioInstance .Status .CurrentState ,
167
204
Zones : zones ,
168
- Namespace : minInst .ObjectMeta .Namespace ,
169
- }, nil
205
+ Namespace : minioInstance .ObjectMeta .Namespace ,
206
+ Image : minioInstance .Spec .Image ,
207
+ UsedSize : tenantInfo .DisksUsage ,
208
+ }
209
+ }
210
+
211
+ func getTenantInfoResponse (token string , params admin_api.TenantInfoParams ) (* models.Tenant , error ) {
212
+ // 20 seconds timeout
213
+ ctx , cancel := context .WithTimeout (context .Background (), 20 * time .Second )
214
+ defer cancel ()
215
+
216
+ opClientClientSet , err := cluster .OperatorClient (token )
217
+ if err != nil {
218
+ return nil , err
219
+ }
220
+ clientset , err := cluster .K8sClient (token )
221
+ if err != nil {
222
+ log .Println ("error getting k8sClient:" , err )
223
+ return nil , err
224
+ }
225
+
226
+ opClient := & operatorClient {
227
+ client : opClientClientSet ,
228
+ }
229
+ k8sClient := & k8sClient {
230
+ client : clientset ,
231
+ }
232
+
233
+ minInst , err := getMinioInstance (ctx , opClient , params .Namespace , params .Tenant )
234
+ if err != nil {
235
+ log .Println ("error getting minioInstance:" , err )
236
+ return nil , err
237
+ }
238
+ minioInstanceScheme := identifyMinioInstanceScheme (minInst )
239
+ mAdmin , err := getTenantAdminClient (ctx , k8sClient , params .Namespace , params .Tenant , minInst .Spec .ServiceName , minioInstanceScheme )
240
+ if err != nil {
241
+ log .Println ("error getting tenant's admin client:" , err )
242
+ return nil , err
243
+ }
244
+ // create a minioClient interface implementation
245
+ // defining the client to be used
246
+ adminClient := adminClient {client : mAdmin }
247
+ // serialize output
248
+ adminInfo , err := getAdminInfo (ctx , adminClient )
249
+ if err != nil {
250
+ log .Println ("error getting admin info:" , err )
251
+ return nil , err
252
+ }
253
+ info := getTenantInfo (minInst , adminInfo )
254
+ return info , nil
170
255
}
171
256
172
257
func listTenants (ctx context.Context , operatorClient OperatorClient , namespace string , limit * int32 ) (* models.ListTenantsResponse , error ) {
0 commit comments