func newNodeAnnotator()

in cmd/gcp-controller-manager/node_annotator.go [65:174]
98 lines of code
13 McCabe index (conditional complexity)

func newNodeAnnotator(client clientset.Interface, nodeInformer coreinformers.NodeInformer, cs *compute.Service) (*nodeAnnotator, error) {
	gce := compute.NewInstancesService(cs)

	// TODO(mikedanese): create a registry for the labels that GKE uses. This was
	// lifted from node_startup.go and the naming scheme is adhoc and
	// inconsistent.
	ownedKubeLabels := []string{
		"cloud.google.com/gke-nodepool",
		"cloud.google.com/gke-local-ssd",
		"cloud.google.com/gke-local-scsi-ssd",
		"cloud.google.com/gke-local-nvme-ssd",
		"cloud.google.com/gke-preemptible",
		"cloud.google.com/gke-gpu",
		"cloud.google.com/gke-accelerator",
		"beta.kubernetes.io/fluentd-ds-ready",
		"beta.kubernetes.io/kube-proxy-ds-ready",
		"beta.kubernetes.io/masq-agent-ds-ready",
		"projectcalico.org/ds-ready",
		"beta.kubernetes.io/metadata-proxy-ready",
		"addon.gke.io/node-local-dns-ds-ready",
	}

	na := &nodeAnnotator{
		c:         client,
		ns:        nodeInformer.Lister(),
		hasSynced: nodeInformer.Informer().HasSynced,
		queue: workqueue.NewNamedRateLimitingQueue(workqueue.NewMaxOfRateLimiter(
			workqueue.NewItemExponentialFailureRateLimiter(200*time.Millisecond, 1000*time.Second),
		), "node-annotator"),
		getInstance: func(nodeURL string) (*compute.Instance, error) {
			project, zone, instance, err := parseNodeURL(nodeURL)
			if err != nil {
				return nil, err
			}
			return gce.Get(project, zone, instance).Do()
		},
		annotators: []annotator{
			{
				name: "instance-id-reconciler",
				annotate: func(node *core.Node, instance *compute.Instance) bool {
					eid := strconv.FormatUint(instance.Id, 10)
					if len(node.ObjectMeta.Annotations) != 0 && eid == node.ObjectMeta.Annotations[InstanceIDAnnotationKey] {
						// node restarted but no update of ExternalID required
						return false
					}
					if node.ObjectMeta.Annotations == nil {
						node.ObjectMeta.Annotations = make(map[string]string)
					}
					node.ObjectMeta.Annotations[InstanceIDAnnotationKey] = eid
					return true
				},
			},
			{
				name: "labels-reconciler",
				annotate: func(node *core.Node, instance *compute.Instance) bool {
					klog.Infof("Triggering label reconcilation")
					desiredLabels, err := extractKubeLabels(instance)
					if err != nil {
						if err != errNoMetadata {
							klog.Errorf("Error reconciling labels: %v", err)
						}
						return false
					}

					if node.ObjectMeta.Labels == nil {
						node.ObjectMeta.Labels = make(map[string]string)
					}

					for _, key := range ownedKubeLabels {
						delete(node.ObjectMeta.Labels, key)
					}

					err = mergeManagedLabels(node, desiredLabels)
					if err != nil {
						klog.Errorf("Error merging labels: %v", err)
						return false
					}

					return true
				},
			},
			{
				name: "taints-reconciler",
				annotate: func(node *core.Node, instance *compute.Instance) bool {
					klog.Infof("Triggering taint reconcilation")
					desiredTaints, err := extractNodeTaints(instance)
					if err != nil {
						if err != errNoMetadata {
							klog.Errorf("Error reconciling taints: %v", err)
						}
						return false
					}

					err = mergeManagedTaints(node, desiredTaints)
					if err != nil {
						klog.Errorf("Error merging taints: %v", err)
						return false
					}

					return true
				},
			},
		},
	}
	nodeInformer.Informer().AddEventHandler(cache.ResourceEventHandlerFuncs{
		AddFunc:    na.add,
		UpdateFunc: na.update,
	})
	return na, nil
}