mirror of https://github.com/k3s-io/k3s
125 lines
4.7 KiB
Go
125 lines
4.7 KiB
Go
package etcd
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"strings"
|
|
|
|
"github.com/k3s-io/k3s/pkg/version"
|
|
controllerv1 "github.com/rancher/wrangler/pkg/generated/controllers/core/v1"
|
|
"github.com/sirupsen/logrus"
|
|
v1 "k8s.io/api/core/v1"
|
|
)
|
|
|
|
func RegisterMemberHandlers(ctx context.Context, etcd *ETCD, nodes controllerv1.NodeController) {
|
|
e := &etcdMemberHandler{
|
|
etcd: etcd,
|
|
nodeController: nodes,
|
|
ctx: ctx,
|
|
}
|
|
nodes.OnChange(ctx, "managed-etcd-controller", e.sync)
|
|
nodes.OnRemove(ctx, "managed-etcd-controller", e.onRemove)
|
|
}
|
|
|
|
var (
|
|
removalAnnotation = "etcd." + version.Program + ".cattle.io/remove"
|
|
removedNodeNameAnnotation = "etcd." + version.Program + ".cattle.io/removed-node-name"
|
|
)
|
|
|
|
type etcdMemberHandler struct {
|
|
etcd *ETCD
|
|
nodeController controllerv1.NodeController
|
|
ctx context.Context
|
|
}
|
|
|
|
func (e *etcdMemberHandler) sync(key string, node *v1.Node) (*v1.Node, error) {
|
|
if node == nil {
|
|
return nil, nil
|
|
}
|
|
|
|
if _, ok := node.Labels[EtcdRoleLabel]; !ok {
|
|
logrus.Debugf("Node %s was not labeled etcd node, skipping sync", key)
|
|
return node, nil
|
|
}
|
|
|
|
node = node.DeepCopy()
|
|
|
|
if removalRequested, ok := node.Annotations[removalAnnotation]; ok {
|
|
if removed, ok := node.Annotations[removedNodeNameAnnotation]; ok {
|
|
// check to see if removed is true. if it is, nothing to do.
|
|
if currentNodeName, ok := node.Annotations[NodeNameAnnotation]; ok {
|
|
if currentNodeName != removed {
|
|
// If the current node name is not the same as the removed node name, reset the tainted annotation and removed node name
|
|
logrus.Infof("Resetting removed node flag as removed node name ( did not match current node name")
|
|
delete(node.Annotations, removedNodeNameAnnotation)
|
|
node.Annotations[removalAnnotation] = "false"
|
|
return e.nodeController.Update(node)
|
|
}
|
|
// this is the case where the current node name matches the removed node name. We have already removed the
|
|
// node, so no need to perform any action. Fallthrough to the non-op below.
|
|
}
|
|
// This is the edge case where the removed annotation exists, but there is not a current node name annotation.
|
|
// This should be a non-op, as we can't remove the node anyway.
|
|
logrus.Debugf("etcd member %s was already marked via annotations as removed", key)
|
|
return node, nil
|
|
}
|
|
if strings.ToLower(removalRequested) == "true" {
|
|
// remove the member.
|
|
name, ok := node.Annotations[NodeNameAnnotation]
|
|
if !ok {
|
|
return node, fmt.Errorf("node name annotation for node %s not found", key)
|
|
}
|
|
address, ok := node.Annotations[NodeAddressAnnotation]
|
|
if !ok {
|
|
return node, fmt.Errorf("node address annotation for node %s not found", key)
|
|
}
|
|
|
|
logrus.Debugf("removing etcd member from cluster name: %s address: %s", name, address)
|
|
if err := e.etcd.RemovePeer(e.ctx, name, address, true); err != nil {
|
|
return node, err
|
|
}
|
|
logrus.Debugf("etcd member removal successful for name: %s address: %s", name, address)
|
|
// Set the removed node name annotation and clean up the other etcd node annotations.
|
|
// These will be set if the tombstone file is then created and the etcd member is re-added, to their new
|
|
// respective values.
|
|
node.Annotations[removedNodeNameAnnotation] = name
|
|
delete(node.Annotations, NodeNameAnnotation)
|
|
delete(node.Annotations, NodeAddressAnnotation)
|
|
return e.nodeController.Update(node)
|
|
}
|
|
// In the event that we had an unexpected removal value, simply return.
|
|
// Fallthrough to the non-op below.
|
|
}
|
|
// This is a non-op, as we don't have a tainted annotation to worry about.
|
|
return node, nil
|
|
}
|
|
|
|
func (e *etcdMemberHandler) onRemove(key string, node *v1.Node) (*v1.Node, error) {
|
|
if _, ok := node.Labels[EtcdRoleLabel]; !ok {
|
|
logrus.Debugf("Node %s was not labeled etcd node, skipping etcd member removal", key)
|
|
return node, nil
|
|
}
|
|
logrus.Infof("Removing etcd member %s from cluster", key)
|
|
if removalRequested, ok := node.Annotations[removalAnnotation]; ok {
|
|
if strings.ToLower(removalRequested) == "true" {
|
|
if removedNodeName, ok := node.Annotations[removedNodeNameAnnotation]; ok {
|
|
if len(removedNodeName) > 0 {
|
|
// If we received a node to delete that has already been removed via annotation, it will be missing
|
|
// the corresponding node name and address annotations.
|
|
logrus.Infof("etcd member %s was already removed as member name %s via annotation from the cluster", key, removedNodeName)
|
|
return node, nil
|
|
}
|
|
}
|
|
}
|
|
}
|
|
name, ok := node.Annotations[NodeNameAnnotation]
|
|
if !ok {
|
|
return node, fmt.Errorf("node name annotation for node %s not found", key)
|
|
}
|
|
address, ok := node.Annotations[NodeAddressAnnotation]
|
|
if !ok {
|
|
return node, fmt.Errorf("node address annotation for node %s not found", key)
|
|
}
|
|
return node, e.etcd.RemovePeer(e.ctx, name, address, true)
|
|
}
|