autoscaler/cluster-autoscaler/cloudprovider/oci/oci_instance_pool.go

/*
Copyright 2021 Oracle and/or its affiliates.

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 oci

import (
	"fmt"
	"github.com/pkg/errors"
	apiv1 "k8s.io/api/core/v1"
	"k8s.io/autoscaler/cluster-autoscaler/cloudprovider"
	"k8s.io/autoscaler/cluster-autoscaler/config"
	"k8s.io/client-go/kubernetes"
	"k8s.io/klog/v2"
	schedulerframework "k8s.io/kubernetes/pkg/scheduler/framework"
)

const (
	ociInstanceIDAnnotation      = "oci.oraclecloud.com/instance-id"
	ociInstancePoolIDAnnotation  = "oci.oraclecloud.com/instancepool-id"
	ociInstancePoolResourceIdent = "instancepool"
)

// InstancePoolNodeGroup implements the NodeGroup interface using OCI instance pools.
type InstancePoolNodeGroup struct {
	manager    InstancePoolManager
	kubeClient kubernetes.Interface
	id         string
	minSize    int
	maxSize    int
}

// MaxSize returns maximum size of the instance-pool based node group.
func (ip *InstancePoolNodeGroup) MaxSize() int {
	return ip.maxSize
}

// MinSize returns minimum size of the instance-pool based node group.
func (ip *InstancePoolNodeGroup) MinSize() int {
	return ip.minSize
}

// TargetSize returns the current target size of the instance-pool based node group. It is possible that the
// number of nodes in Kubernetes is different at the moment but should be equal
// to Size() once everything stabilizes (new nodes finish startup and registration or
// removed nodes are deleted completely). Implementation required.
func (ip *InstancePoolNodeGroup) TargetSize() (int, error) {
	return ip.manager.GetInstancePoolSize(*ip)
}

// IncreaseSize increases the size of the instance-pool based node group. To delete a node you need
// to explicitly name it and use DeleteNode. This function should wait until
// instance-pool size is updated. Implementation required.
func (ip *InstancePoolNodeGroup) IncreaseSize(delta int) error {
	if delta <= 0 {
		return fmt.Errorf("size increase must be positive")
	}

	size, err := ip.manager.GetInstancePoolSize(*ip)
	if err != nil {
		return err
	}

	if size+delta > ip.MaxSize() {
		return fmt.Errorf("size increase too large - desired:%d max:%d", size+delta, ip.MaxSize())
	}

	return ip.manager.SetInstancePoolSize(*ip, size+delta)
}

// DeleteNodes deletes nodes from this instance-pool. Error is returned either on
// failure or if the given node doesn't belong to this instance-pool. This function
// should wait until instance-pool size is updated. Implementation required.
func (ip *InstancePoolNodeGroup) DeleteNodes(nodes []*apiv1.Node) error {

	// FYI, unregistered nodes come in as the provider id as node name.

	klog.Infof("DeleteNodes called with %d node(s)", len(nodes))

	size, err := ip.manager.GetInstancePoolSize(*ip)
	if err != nil {
		return err
	}

	if size <= ip.MinSize() {
		return fmt.Errorf("min size reached, nodes will not be deleted")
	}

	refs := make([]OciRef, 0, len(nodes))
	for _, node := range nodes {
		belongs, err := ip.Belongs(node)
		if err != nil {
			return err
		}
		if !belongs {
			return fmt.Errorf("%s belong to a different instance-pool than %s", node.Name, ip.Id())
		}
		ociRef, err := nodeToOciRef(node)
		if err != nil {
			return err
		}

		refs = append(refs, ociRef)
	}

	return ip.manager.DeleteInstances(*ip, refs)
}

// DecreaseTargetSize decreases the target size of the instance-pool based node group. This function
// doesn't permit to delete any existing node and can be used only to reduce the
// request for new nodes that have not been yet fulfilled. Delta should be negative.
// It is assumed that cloud provider will not delete the existing nodes when there
// is an option to just decrease the target. Implementation required.
func (ip *InstancePoolNodeGroup) DecreaseTargetSize(delta int) error {
	if delta >= 0 {
		return fmt.Errorf("size decrease must be negative")
	}

	size, err := ip.manager.GetInstancePoolSize(*ip)
	if err != nil {
		return err
	}

	nodes, err := ip.manager.GetInstancePoolNodes(*ip)
	if err != nil {
		return err
	}

	if size+delta < len(nodes) {
		return fmt.Errorf("attempt to delete existing nodes targetSize:%d delta:%d existingNodes: %d",
			size, delta, len(nodes))
	}

	return ip.manager.SetInstancePoolSize(*ip, size+delta)
}

// Belongs returns true if the given node belongs to the InstancePoolNodeGroup.
func (ip *InstancePoolNodeGroup) Belongs(node *apiv1.Node) (bool, error) {
	ref, err := nodeToOciRef(node)
	if err != nil {
		return false, err
	}

	targetInstancePool, err := ip.manager.GetInstancePoolForInstance(ref)
	if err != nil {
		return false, err
	}

	if targetInstancePool == nil {
		return false, fmt.Errorf("%s doesn't belong to a known instance-pool", node.Name)
	}

	return targetInstancePool.Id() == ip.Id(), nil
}

// Id returns an unique identifier of the instance-pool based node group.
func (ip *InstancePoolNodeGroup) Id() string {
	return ip.id
}

// Debug returns a string containing all information regarding this instance-pool.
func (ip *InstancePoolNodeGroup) Debug() string {
	return fmt.Sprintf("%s (%d:%d)", ip.Id(), ip.MinSize(), ip.MaxSize())
}

// Nodes returns a list of all nodes that belong to this instance-pool.
// It is required that Instance objects returned by this method have Id field set.
// Other fields are optional.
// This list should include also instances that might have not become a kubernetes node yet.
func (ip *InstancePoolNodeGroup) Nodes() ([]cloudprovider.Instance, error) {
	return ip.manager.GetInstancePoolNodes(*ip)
}

// TemplateNodeInfo returns a schedulerframework.NodeInfo structure of an empty
// (as if just started) node. This will be used in scale-up simulations to
// predict what would a new node look like if a instance-pool was expanded. The returned
// NodeInfo is expected to have a fully populated Node object, with all of the labels,
// capacity and allocatable information as well as all pods that are started on
// the node by default, using manifest (most likely only kube-proxy). Implementation optional.
func (ip *InstancePoolNodeGroup) TemplateNodeInfo() (*schedulerframework.NodeInfo, error) {
	node, err := ip.manager.GetInstancePoolTemplateNode(*ip)
	if err != nil {
		return nil, errors.Wrap(err, "unable to build node info template")
	}

	nodeInfo := schedulerframework.NewNodeInfo(
		cloudprovider.BuildKubeProxy(ip.id),
		buildCSINodePod(),
	)
	nodeInfo.SetNode(node)
	return nodeInfo, nil
}

// Exist checks if the instance-pool based node group really exists on the cloud provider side. Allows to tell the
// theoretical instance-pool from the real one. Implementation required.
func (ip *InstancePoolNodeGroup) Exist() bool {
	return true
}

// Create creates the instance-pool based node group on the cloud provider side. Implementation optional.
func (ip *InstancePoolNodeGroup) Create() (cloudprovider.NodeGroup, error) {
	return nil, cloudprovider.ErrNotImplemented
}

// Delete deletes the instance-pool based node group on the cloud provider side.
// This will be executed only for autoprovisioned instance-pools, once their size drops to 0.
// Implementation optional.
func (ip *InstancePoolNodeGroup) Delete() error {
	return cloudprovider.ErrNotImplemented
}

// GetOptions returns NodeGroupAutoscalingOptions that should be used for this particular
// InstancePoolNodeGroup. Returning a nil will result in using default options.
func (ip *InstancePoolNodeGroup) GetOptions(defaults config.NodeGroupAutoscalingOptions) (*config.NodeGroupAutoscalingOptions, error) {
	return nil, cloudprovider.ErrNotImplemented
}

// Autoprovisioned returns true if the instance-pool based node group is autoprovisioned. An autoprovisioned group
// was created by CA and can be deleted when scaled to 0.
func (ip *InstancePoolNodeGroup) Autoprovisioned() bool {
	return false
}