mirrors/object-browser
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Added CPU size selector & add tenant cleanup (#1326)

Browse Source
This commit is contained in:
Alex
2021-12-17 12:29:10 -06:00
committed by GitHub
parent 725d6f9691
commit 21158e6c7a
19 changed files with 1489 additions and 370 deletions
Download Patch File Download Diff File Expand all files Collapse all files

130
operatorapi/embedded_spec.go
View File

@@ -52,6 +52,39 @@ func init() {
},
"basePath": "/api/v1",
"paths": {
"/cluster/allocatable-resources": {
"get": {
"tags": [
"OperatorAPI"
],
"summary": "Get allocatable cpu and memory for given number of nodes",
"operationId": "GetAllocatableResources",
"parameters": [
{
"minimum": 1,
"type": "integer",
"format": "int32",
"name": "num_nodes",
"in": "query",
"required": true
}
],
"responses": {
"200": {
"description": "A successful response.",
"schema": {
"$ref": "#/definitions/allocatableResourcesResponse"
}
},
"default": {
"description": "Generic error response.",
"schema": {
"$ref": "#/definitions/error"
}
}
}
}
},
"/cluster/max-allocatable-memory": {
"get": {
"tags": [
@@ -1382,6 +1415,25 @@ func init() {
}
},
"definitions": {
"allocatableResourcesResponse": {
"type": "object",
"properties": {
"cpu_priority": {
"$ref": "#/definitions/nodeMaxAllocatableResources"
},
"mem_priority": {
"$ref": "#/definitions/nodeMaxAllocatableResources"
},
"min_allocatable_cpu": {
"type": "integer",
"format": "int64"
},
"min_allocatable_mem": {
"type": "integer",
"format": "int64"
}
}
},
"awsConfiguration": {
"type": "object",
"required": [
@@ -2229,6 +2281,19 @@ func init() {
}
}
},
"nodeMaxAllocatableResources": {
"type": "object",
"properties": {
"max_allocatable_cpu": {
"type": "integer",
"format": "int64"
},
"max_allocatable_mem": {
"type": "integer",
"format": "int64"
}
}
},
"nodeSelectorTerm": {
"description": "A null or empty node selector term matches no objects. The requirements of them are ANDed. The TopologySelectorTerm type implements a subset of the NodeSelectorTerm.",
"type": "object",
@@ -3187,6 +3252,39 @@ func init() {
},
"basePath": "/api/v1",
"paths": {
"/cluster/allocatable-resources": {
"get": {
"tags": [
"OperatorAPI"
],
"summary": "Get allocatable cpu and memory for given number of nodes",
"operationId": "GetAllocatableResources",
"parameters": [
{
"minimum": 1,
"type": "integer",
"format": "int32",
"name": "num_nodes",
"in": "query",
"required": true
}
],
"responses": {
"200": {
"description": "A successful response.",
"schema": {
"$ref": "#/definitions/allocatableResourcesResponse"
}
},
"default": {
"description": "Generic error response.",
"schema": {
"$ref": "#/definitions/error"
}
}
}
}
},
"/cluster/max-allocatable-memory": {
"get": {
"tags": [
@@ -5242,6 +5340,25 @@ func init() {
}
}
},
"allocatableResourcesResponse": {
"type": "object",
"properties": {
"cpu_priority": {
"$ref": "#/definitions/nodeMaxAllocatableResources"
},
"mem_priority": {
"$ref": "#/definitions/nodeMaxAllocatableResources"
},
"min_allocatable_cpu": {
"type": "integer",
"format": "int64"
},
"min_allocatable_mem": {
"type": "integer",
"format": "int64"
}
}
},
"awsConfiguration": {
"type": "object",
"required": [
@@ -6077,6 +6194,19 @@ func init() {
}
}
},
"nodeMaxAllocatableResources": {
"type": "object",
"properties": {
"max_allocatable_cpu": {
"type": "integer",
"format": "int64"
},
"max_allocatable_mem": {
"type": "integer",
"format": "int64"
}
}
},
"nodeSelectorTerm": {
"description": "A null or empty node selector term matches no objects. The requirements of them are ANDed. The TopologySelectorTerm type implements a subset of the NodeSelectorTerm.",
"type": "object",

12
operatorapi/operations/operator_api.go
View File

@@ -78,6 +78,9 @@ func NewOperatorAPI(spec *loads.Document) *OperatorAPI {
OperatorAPIDirectCSIFormatDriveHandler: operator_api.DirectCSIFormatDriveHandlerFunc(func(params operator_api.DirectCSIFormatDriveParams, principal *models.Principal) middleware.Responder {
return middleware.NotImplemented("operation operator_api.DirectCSIFormatDrive has not yet been implemented")
}),
OperatorAPIGetAllocatableResourcesHandler: operator_api.GetAllocatableResourcesHandlerFunc(func(params operator_api.GetAllocatableResourcesParams, principal *models.Principal) middleware.Responder {
return middleware.NotImplemented("operation operator_api.GetAllocatableResources has not yet been implemented")
}),
OperatorAPIGetDirectCSIDriveListHandler: operator_api.GetDirectCSIDriveListHandlerFunc(func(params operator_api.GetDirectCSIDriveListParams, principal *models.Principal) middleware.Responder {
return middleware.NotImplemented("operation operator_api.GetDirectCSIDriveList has not yet been implemented")
}),
@@ -236,6 +239,8 @@ type OperatorAPI struct {
OperatorAPIDeleteTenantHandler operator_api.DeleteTenantHandler
// OperatorAPIDirectCSIFormatDriveHandler sets the operation handler for the direct c s i format drive operation
OperatorAPIDirectCSIFormatDriveHandler operator_api.DirectCSIFormatDriveHandler
// OperatorAPIGetAllocatableResourcesHandler sets the operation handler for the get allocatable resources operation
OperatorAPIGetAllocatableResourcesHandler operator_api.GetAllocatableResourcesHandler
// OperatorAPIGetDirectCSIDriveListHandler sets the operation handler for the get direct c s i drive list operation
OperatorAPIGetDirectCSIDriveListHandler operator_api.GetDirectCSIDriveListHandler
// OperatorAPIGetDirectCSIVolumeListHandler sets the operation handler for the get direct c s i volume list operation
@@ -398,6 +403,9 @@ func (o *OperatorAPI) Validate() error {
if o.OperatorAPIDirectCSIFormatDriveHandler == nil {
unregistered = append(unregistered, "operator_api.DirectCSIFormatDriveHandler")
}
if o.OperatorAPIGetAllocatableResourcesHandler == nil {
unregistered = append(unregistered, "operator_api.GetAllocatableResourcesHandler")
}
if o.OperatorAPIGetDirectCSIDriveListHandler == nil {
unregistered = append(unregistered, "operator_api.GetDirectCSIDriveListHandler")
}
@@ -618,6 +626,10 @@ func (o *OperatorAPI) initHandlerCache() {
if o.handlers["GET"] == nil {
o.handlers["GET"] = make(map[string]http.Handler)
}
o.handlers["GET"]["/cluster/allocatable-resources"] = operator_api.NewGetAllocatableResources(o.context, o.OperatorAPIGetAllocatableResourcesHandler)
if o.handlers["GET"] == nil {
o.handlers["GET"] = make(map[string]http.Handler)
}
o.handlers["GET"]["/direct-csi/drives"] = operator_api.NewGetDirectCSIDriveList(o.context, o.OperatorAPIGetDirectCSIDriveListHandler)
if o.handlers["GET"] == nil {
o.handlers["GET"] = make(map[string]http.Handler)

88
operatorapi/operations/operator_api/get_allocatable_resources.go Normal file
View File

@@ -0,0 +1,88 @@
// Code generated by go-swagger; DO NOT EDIT.
// This file is part of MinIO Console Server
// Copyright (c) 2021 MinIO, Inc.
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// 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. See the
// GNU Affero General Public License for more details.
//
// 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 operator_api
// This file was generated by the swagger tool.
// Editing this file might prove futile when you re-run the generate command
import (
"net/http"
"github.com/go-openapi/runtime/middleware"
"github.com/minio/console/models"
)
// GetAllocatableResourcesHandlerFunc turns a function with the right signature into a get allocatable resources handler
type GetAllocatableResourcesHandlerFunc func(GetAllocatableResourcesParams, *models.Principal) middleware.Responder
// Handle executing the request and returning a response
func (fn GetAllocatableResourcesHandlerFunc) Handle(params GetAllocatableResourcesParams, principal *models.Principal) middleware.Responder {
return fn(params, principal)
}
// GetAllocatableResourcesHandler interface for that can handle valid get allocatable resources params
type GetAllocatableResourcesHandler interface {
Handle(GetAllocatableResourcesParams, *models.Principal) middleware.Responder
}
// NewGetAllocatableResources creates a new http.Handler for the get allocatable resources operation
func NewGetAllocatableResources(ctx *middleware.Context, handler GetAllocatableResourcesHandler) *GetAllocatableResources {
return &GetAllocatableResources{Context: ctx, Handler: handler}
}
/* GetAllocatableResources swagger:route GET /cluster/allocatable-resources OperatorAPI getAllocatableResources
Get allocatable cpu and memory for given number of nodes
*/
type GetAllocatableResources struct {
Context *middleware.Context
Handler GetAllocatableResourcesHandler
}
func (o *GetAllocatableResources) ServeHTTP(rw http.ResponseWriter, r *http.Request) {
route, rCtx, _ := o.Context.RouteInfo(r)
if rCtx != nil {
*r = *rCtx
}
var Params = NewGetAllocatableResourcesParams()
uprinc, aCtx, err := o.Context.Authorize(r, route)
if err != nil {
o.Context.Respond(rw, r, route.Produces, route, err)
return
}
if aCtx != nil {
*r = *aCtx
}
var principal *models.Principal
if uprinc != nil {
principal = uprinc.(*models.Principal) // this is really a models.Principal, I promise
}
if err := o.Context.BindValidRequest(r, route, &Params); err != nil { // bind params
o.Context.Respond(rw, r, route.Produces, route, err)
return
}
res := o.Handler.Handle(Params, principal) // actually handle the request
o.Context.Respond(rw, r, route.Produces, route, res)
}

120
operatorapi/operations/operator_api/get_allocatable_resources_parameters.go Normal file
View File

@@ -0,0 +1,120 @@
// Code generated by go-swagger; DO NOT EDIT.
// This file is part of MinIO Console Server
// Copyright (c) 2021 MinIO, Inc.
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// 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. See the
// GNU Affero General Public License for more details.
//
// 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 operator_api
// This file was generated by the swagger tool.
// Editing this file might prove futile when you re-run the swagger generate command
import (
"net/http"
"github.com/go-openapi/errors"
"github.com/go-openapi/runtime"
"github.com/go-openapi/runtime/middleware"
"github.com/go-openapi/strfmt"
"github.com/go-openapi/swag"
"github.com/go-openapi/validate"
)
// NewGetAllocatableResourcesParams creates a new GetAllocatableResourcesParams object
//
// There are no default values defined in the spec.
func NewGetAllocatableResourcesParams() GetAllocatableResourcesParams {
return GetAllocatableResourcesParams{}
}
// GetAllocatableResourcesParams contains all the bound params for the get allocatable resources operation
// typically these are obtained from a http.Request
//
// swagger:parameters GetAllocatableResources
type GetAllocatableResourcesParams struct {
// HTTP Request Object
HTTPRequest *http.Request `json:"-"`
/*
Required: true
Minimum: 1
In: query
*/
NumNodes int32
}
// BindRequest both binds and validates a request, it assumes that complex things implement a Validatable(strfmt.Registry) error interface
// for simple values it will use straight method calls.
//
// To ensure default values, the struct must have been initialized with NewGetAllocatableResourcesParams() beforehand.
func (o *GetAllocatableResourcesParams) BindRequest(r *http.Request, route *middleware.MatchedRoute) error {
var res []error
o.HTTPRequest = r
qs := runtime.Values(r.URL.Query())
qNumNodes, qhkNumNodes, _ := qs.GetOK("num_nodes")
if err := o.bindNumNodes(qNumNodes, qhkNumNodes, route.Formats); err != nil {
res = append(res, err)
}
if len(res) > 0 {
return errors.CompositeValidationError(res...)
}
return nil
}
// bindNumNodes binds and validates parameter NumNodes from query.
func (o *GetAllocatableResourcesParams) bindNumNodes(rawData []string, hasKey bool, formats strfmt.Registry) error {
if !hasKey {
return errors.Required("num_nodes", "query", rawData)
}
var raw string
if len(rawData) > 0 {
raw = rawData[len(rawData)-1]
}
// Required: true
// AllowEmptyValue: false
if err := validate.RequiredString("num_nodes", "query", raw); err != nil {
return err
}
value, err := swag.ConvertInt32(raw)
if err != nil {
return errors.InvalidType("num_nodes", "query", "int32", raw)
}
o.NumNodes = value
if err := o.validateNumNodes(formats); err != nil {
return err
}
return nil
}
// validateNumNodes carries on validations for parameter NumNodes
func (o *GetAllocatableResourcesParams) validateNumNodes(formats strfmt.Registry) error {
if err := validate.MinimumInt("num_nodes", "query", int64(o.NumNodes), 1, false); err != nil {
return err
}
return nil
}

133
operatorapi/operations/operator_api/get_allocatable_resources_responses.go Normal file
View File

@@ -0,0 +1,133 @@
// Code generated by go-swagger; DO NOT EDIT.
// This file is part of MinIO Console Server
// Copyright (c) 2021 MinIO, Inc.
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// 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. See the
// GNU Affero General Public License for more details.
//
// 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 operator_api
// This file was generated by the swagger tool.
// Editing this file might prove futile when you re-run the swagger generate command
import (
"net/http"
"github.com/go-openapi/runtime"
"github.com/minio/console/models"
)
// GetAllocatableResourcesOKCode is the HTTP code returned for type GetAllocatableResourcesOK
const GetAllocatableResourcesOKCode int = 200
/*GetAllocatableResourcesOK A successful response.
swagger:response getAllocatableResourcesOK
*/
type GetAllocatableResourcesOK struct {
/*
In: Body
*/
Payload *models.AllocatableResourcesResponse `json:"body,omitempty"`
}
// NewGetAllocatableResourcesOK creates GetAllocatableResourcesOK with default headers values
func NewGetAllocatableResourcesOK() *GetAllocatableResourcesOK {
return &GetAllocatableResourcesOK{}
}
// WithPayload adds the payload to the get allocatable resources o k response
func (o *GetAllocatableResourcesOK) WithPayload(payload *models.AllocatableResourcesResponse) *GetAllocatableResourcesOK {
o.Payload = payload
return o
}
// SetPayload sets the payload to the get allocatable resources o k response
func (o *GetAllocatableResourcesOK) SetPayload(payload *models.AllocatableResourcesResponse) {
o.Payload = payload
}
// WriteResponse to the client
func (o *GetAllocatableResourcesOK) WriteResponse(rw http.ResponseWriter, producer runtime.Producer) {
rw.WriteHeader(200)
if o.Payload != nil {
payload := o.Payload
if err := producer.Produce(rw, payload); err != nil {
panic(err) // let the recovery middleware deal with this
}
}
}
/*GetAllocatableResourcesDefault Generic error response.
swagger:response getAllocatableResourcesDefault
*/
type GetAllocatableResourcesDefault struct {
_statusCode int
/*
In: Body
*/
Payload *models.Error `json:"body,omitempty"`
}
// NewGetAllocatableResourcesDefault creates GetAllocatableResourcesDefault with default headers values
func NewGetAllocatableResourcesDefault(code int) *GetAllocatableResourcesDefault {
if code <= 0 {
code = 500
}
return &GetAllocatableResourcesDefault{
_statusCode: code,
}
}
// WithStatusCode adds the status to the get allocatable resources default response
func (o *GetAllocatableResourcesDefault) WithStatusCode(code int) *GetAllocatableResourcesDefault {
o._statusCode = code
return o
}
// SetStatusCode sets the status to the get allocatable resources default response
func (o *GetAllocatableResourcesDefault) SetStatusCode(code int) {
o._statusCode = code
}
// WithPayload adds the payload to the get allocatable resources default response
func (o *GetAllocatableResourcesDefault) WithPayload(payload *models.Error) *GetAllocatableResourcesDefault {
o.Payload = payload
return o
}
// SetPayload sets the payload to the get allocatable resources default response
func (o *GetAllocatableResourcesDefault) SetPayload(payload *models.Error) {
o.Payload = payload
}
// WriteResponse to the client
func (o *GetAllocatableResourcesDefault) WriteResponse(rw http.ResponseWriter, producer runtime.Producer) {
rw.WriteHeader(o._statusCode)
if o.Payload != nil {
payload := o.Payload
if err := producer.Produce(rw, payload); err != nil {
panic(err) // let the recovery middleware deal with this
}
}
}

119
operatorapi/operations/operator_api/get_allocatable_resources_urlbuilder.go Normal file
View File

@@ -0,0 +1,119 @@
// Code generated by go-swagger; DO NOT EDIT.
// This file is part of MinIO Console Server
// Copyright (c) 2021 MinIO, Inc.
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// 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. See the
// GNU Affero General Public License for more details.
//
// 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 operator_api
// This file was generated by the swagger tool.
// Editing this file might prove futile when you re-run the generate command
import (
"errors"
"net/url"
golangswaggerpaths "path"
"github.com/go-openapi/swag"
)
// GetAllocatableResourcesURL generates an URL for the get allocatable resources operation
type GetAllocatableResourcesURL struct {
NumNodes int32
_basePath string
// avoid unkeyed usage
_ struct{}
}
// WithBasePath sets the base path for this url builder, only required when it's different from the
// base path specified in the swagger spec.
// When the value of the base path is an empty string
func (o *GetAllocatableResourcesURL) WithBasePath(bp string) *GetAllocatableResourcesURL {
o.SetBasePath(bp)
return o
}
// SetBasePath sets the base path for this url builder, only required when it's different from the
// base path specified in the swagger spec.
// When the value of the base path is an empty string
func (o *GetAllocatableResourcesURL) SetBasePath(bp string) {
o._basePath = bp
}
// Build a url path and query string
func (o *GetAllocatableResourcesURL) Build() (*url.URL, error) {
var _result url.URL
var _path = "/cluster/allocatable-resources"
_basePath := o._basePath
if _basePath == "" {
_basePath = "/api/v1"
}
_result.Path = golangswaggerpaths.Join(_basePath, _path)
qs := make(url.Values)
numNodesQ := swag.FormatInt32(o.NumNodes)
if numNodesQ != "" {
qs.Set("num_nodes", numNodesQ)
}
_result.RawQuery = qs.Encode()
return &_result, nil
}
// Must is a helper function to panic when the url builder returns an error
func (o *GetAllocatableResourcesURL) Must(u *url.URL, err error) *url.URL {
if err != nil {
panic(err)
}
if u == nil {
panic("url can't be nil")
}
return u
}
// String returns the string representation of the path with query string
func (o *GetAllocatableResourcesURL) String() string {
return o.Must(o.Build()).String()
}
// BuildFull builds a full url with scheme, host, path and query string
func (o *GetAllocatableResourcesURL) BuildFull(scheme, host string) (*url.URL, error) {
if scheme == "" {
return nil, errors.New("scheme is required for a full url on GetAllocatableResourcesURL")
}
if host == "" {
return nil, errors.New("host is required for a full url on GetAllocatableResourcesURL")
}
base, err := o.Build()
if err != nil {
return nil, err
}
base.Scheme = scheme
base.Host = host
return base, nil
}
// StringFull returns the string representation of a complete url
func (o *GetAllocatableResourcesURL) StringFull(scheme, host string) string {
return o.Must(o.BuildFull(scheme, host)).String()
}

159
operatorapi/operator_nodes.go
View File

@@ -18,6 +18,7 @@ package operatorapi
import (
"context"
"errors"
"sort"
"github.com/minio/minio-go/v7/pkg/set"
@@ -50,6 +51,20 @@ func registerNodesHandlers(api *operations.OperatorAPI) {
}
return operator_api.NewListNodeLabelsOK().WithPayload(*resp)
})
api.OperatorAPIGetAllocatableResourcesHandler = operator_api.GetAllocatableResourcesHandlerFunc(func(params operator_api.GetAllocatableResourcesParams, principal *models.Principal) middleware.Responder {
resp, err := getAllocatableResourcesResponse(params.NumNodes, principal)
if err != nil {
return operator_api.NewGetAllocatableResourcesDefault(int(err.Code)).WithPayload(err)
}
return operator_api.NewGetAllocatableResourcesOK().WithPayload(resp)
})
}
type NodeResourceInfo struct {
Name string
AllocatableMemory int64
AllocatableCPU int64
}
// getMaxAllocatableMemory get max allocatable memory given a desired number of nodes
@@ -211,3 +226,147 @@ func getNodeLabelsResponse(ctx context.Context, session *models.Principal) (*mod
}
return clusterResources, nil
}
func getClusterResourcesInfo(numNodes int32, inNodesResources []NodeResourceInfo) *models.AllocatableResourcesResponse {
// purge any nodes with 0 cpu
var nodesResources []NodeResourceInfo
for _, n := range inNodesResources {
if n.AllocatableCPU > 0 {
nodesResources = append(nodesResources, n)
}
}
if int32(len(nodesResources)) < numNodes || numNodes == 0 {
return &models.AllocatableResourcesResponse{
CPUPriority: &models.NodeMaxAllocatableResources{
MaxAllocatableCPU: 0,
MaxAllocatableMem: 0,
},
MemPriority: &models.NodeMaxAllocatableResources{
MaxAllocatableCPU: 0,
MaxAllocatableMem: 0,
},
MinAllocatableCPU: 0,
MinAllocatableMem: 0,
}
}
allocatableResources := &models.AllocatableResourcesResponse{}
// sort nodesResources giving CPU priority
sort.Slice(nodesResources, func(i, j int) bool { return nodesResources[i].AllocatableCPU < nodesResources[j].AllocatableCPU })
maxCPUNodesNeeded := len(nodesResources) - int(numNodes)
maxMemNodesNeeded := maxCPUNodesNeeded
maxAllocatableCPU := nodesResources[maxCPUNodesNeeded].AllocatableCPU
minAllocatableCPU := nodesResources[maxCPUNodesNeeded].AllocatableCPU
minAllocatableMem := nodesResources[maxMemNodesNeeded].AllocatableMemory
availableMemsForMaxCPU := []int64{}
for _, info := range nodesResources {
if info.AllocatableCPU >= maxAllocatableCPU {
availableMemsForMaxCPU = append(availableMemsForMaxCPU, info.AllocatableMemory)
}
// min allocatable resources overall
minAllocatableCPU = min(minAllocatableCPU, info.AllocatableCPU)
minAllocatableMem = min(minAllocatableMem, info.AllocatableMemory)
}
sort.Slice(availableMemsForMaxCPU, func(i, j int) bool { return availableMemsForMaxCPU[i] < availableMemsForMaxCPU[j] })
maxAllocatableMem := availableMemsForMaxCPU[len(availableMemsForMaxCPU)-int(numNodes)]
allocatableResources.MinAllocatableCPU = minAllocatableCPU
allocatableResources.MinAllocatableMem = minAllocatableMem
allocatableResources.CPUPriority = &models.NodeMaxAllocatableResources{
MaxAllocatableCPU: maxAllocatableCPU,
MaxAllocatableMem: maxAllocatableMem,
}
// sort nodesResources giving Mem priority
sort.Slice(nodesResources, func(i, j int) bool { return nodesResources[i].AllocatableMemory < nodesResources[j].AllocatableMemory })
maxMemNodesNeeded = len(nodesResources) - int(numNodes)
maxAllocatableMem = nodesResources[maxMemNodesNeeded].AllocatableMemory
availableCPUsForMaxMem := []int64{}
for _, info := range nodesResources {
if info.AllocatableMemory >= maxAllocatableMem {
availableCPUsForMaxMem = append(availableCPUsForMaxMem, info.AllocatableCPU)
}
}
sort.Slice(availableCPUsForMaxMem, func(i, j int) bool { return availableCPUsForMaxMem[i] < availableCPUsForMaxMem[j] })
maxAllocatableCPU = availableCPUsForMaxMem[len(availableCPUsForMaxMem)-int(numNodes)]
allocatableResources.MemPriority = &models.NodeMaxAllocatableResources{
MaxAllocatableCPU: maxAllocatableCPU,
MaxAllocatableMem: maxAllocatableMem,
}
return allocatableResources
}
// getAllocatableResources get max allocatable memory given a desired number of nodes
func getAllocatableResources(ctx context.Context, clientset v1.CoreV1Interface, numNodes int32) (*models.AllocatableResourcesResponse, error) {
if numNodes == 0 {
return nil, errors.New("error NumNodes must be greated than 0")
}
// get all nodes from cluster
nodes, err := clientset.Nodes().List(ctx, metav1.ListOptions{})
if err != nil {
return nil, err
}
nodesInfo := []NodeResourceInfo{}
OUTER:
for _, n := range nodes.Items {
// Don't consider node if it has a NoSchedule or NoExecute Taint
for _, t := range n.Spec.Taints {
switch t.Effect {
case corev1.TaintEffectNoSchedule:
continue OUTER
case corev1.TaintEffectNoExecute:
continue OUTER
default:
continue
}
}
var nodeMemory int64
var nodeCPU int64
if quantity, ok := n.Status.Allocatable[corev1.ResourceMemory]; ok {
// availableMemSizes = append(availableMemSizes, quantity.Value())
nodeMemory = quantity.Value()
}
// we assume all nodes have allocatable cpu resource
if quantity, ok := n.Status.Allocatable[corev1.ResourceCPU]; ok {
// availableCPU = append(availableCPU, quantity.Value())
nodeCPU = quantity.Value()
}
nodeInfo := NodeResourceInfo{
Name: n.Name,
AllocatableCPU: nodeCPU,
AllocatableMemory: nodeMemory,
}
nodesInfo = append(nodesInfo, nodeInfo)
}
res := getClusterResourcesInfo(numNodes, nodesInfo)
return res, nil
}
// Get allocatable resources response
func getAllocatableResourcesResponse(numNodes int32, session *models.Principal) (*models.AllocatableResourcesResponse, *models.Error) {
ctx := context.Background()
client, err := cluster.K8sClient(session.STSSessionToken)
if err != nil {
return nil, prepareError(err)
}
clusterResources, err := getAllocatableResources(ctx, client.CoreV1(), numNodes)
if err != nil {
return nil, prepareError(err)
}
return clusterResources, nil
}