Feature-Gate affinity in annotations

pkg/api/v1/helpers.go

@@ -27,7 +27,9 @@ import (
 	"k8s.io/apimachinery/pkg/types"
 	"k8s.io/apimachinery/pkg/util/sets"
 
+	utilfeature "k8s.io/apiserver/pkg/util/feature"
 	"k8s.io/kubernetes/pkg/api"
+	"k8s.io/kubernetes/pkg/features"
 )
 
 // IsOpaqueIntResourceName returns true if the resource name has the opaque
@@ -277,6 +279,10 @@ const (
 	// an object (e.g. secret, config map) before fetching it again from apiserver.
 	// This annotation can be attached to node.
 	ObjectTTLAnnotationKey string = "node.alpha.kubernetes.io/ttl"
+
+	// AffinityAnnotationKey represents the key of affinity data (json serialized)
+	// in the Annotations of a Pod.  TODO remove in 1.7
+	AffinityAnnotationKey string = "scheduler.alpha.kubernetes.io/affinity"
 )
 
 // GetTolerationsFromPodAnnotations gets the json serialized tolerations data from Pod.Annotations
@@ -597,3 +603,41 @@ func RemoveTaint(node *Node, taint *Taint) (*Node, bool, error) {
 	}
 	return newNode, true, nil
 }
+
+// GetAffinityFromPodAnnotations gets the json serialized affinity data from Pod.Annotations
+// and converts it to the Affinity type in api.
+// TODO remove for 1.7
+func GetAffinityFromPodAnnotations(annotations map[string]string) (*Affinity, error) {
+	if len(annotations) > 0 && annotations[AffinityAnnotationKey] != "" {
+		var affinity Affinity
+		err := json.Unmarshal([]byte(annotations[AffinityAnnotationKey]), &affinity)
+		if err != nil {
+			return nil, err
+		}
+		return &affinity, nil
+	}
+	return nil, nil
+}
+
+// Reconcile api and annotation affinity definitions.
+// TODO remove for 1.7
+func ReconcileAffinity(pod *Pod) *Affinity {
+	affinity := pod.Spec.Affinity
+	if utilfeature.DefaultFeatureGate.Enabled(features.AffinityInAnnotations) {
+		annotationsAffinity, _ := GetAffinityFromPodAnnotations(pod.Annotations)
+		if affinity == nil && annotationsAffinity != nil {
+			affinity = annotationsAffinity
+		} else if annotationsAffinity != nil {
+			if affinity != nil && affinity.NodeAffinity == nil && annotationsAffinity.NodeAffinity != nil {
+				affinity.NodeAffinity = annotationsAffinity.NodeAffinity
+			}
+			if affinity != nil && affinity.PodAffinity == nil && annotationsAffinity.PodAffinity != nil {
+				affinity.PodAffinity = annotationsAffinity.PodAffinity
+			}
+			if affinity != nil && affinity.PodAntiAffinity == nil && annotationsAffinity.PodAntiAffinity != nil {
+				affinity.PodAntiAffinity = annotationsAffinity.PodAntiAffinity
+			}
+		}
+	}
+	return affinity
+}

pkg/api/v1/helpers_test.go

@@ -17,12 +17,14 @@ limitations under the License.
 package v1
 
 import (
+	"fmt"
 	"reflect"
 	"testing"
 
 	apiequality "k8s.io/apimachinery/pkg/api/equality"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/labels"
+	utilfeature "k8s.io/apiserver/pkg/util/feature"
 )
 
 func TestAddToNodeAddresses(t *testing.T) {
@@ -644,3 +646,180 @@ func TestSysctlsFromPodAnnotation(t *testing.T) {
 		}
 	}
 }
+
+func TestGetAffinityFromPodAnnotations(t *testing.T) {
+	testCases := []struct {
+		pod       *Pod
+		expectErr bool
+	}{
+		{
+			pod:       &Pod{},
+			expectErr: false,
+		},
+		{
+			pod: &Pod{
+				ObjectMeta: metav1.ObjectMeta{
+					Annotations: map[string]string{
+						AffinityAnnotationKey: `
+						{"nodeAffinity": { "requiredDuringSchedulingIgnoredDuringExecution": {
+							"nodeSelectorTerms": [{
+								"matchExpressions": [{
+									"key": "foo",
+									"operator": "In",
+									"values": ["value1", "value2"]
+								}]
+							}]
+						}}}`,
+					},
+				},
+			},
+			expectErr: false,
+		},
+		{
+			pod: &Pod{
+				ObjectMeta: metav1.ObjectMeta{
+					Annotations: map[string]string{
+						AffinityAnnotationKey: `
+						{"nodeAffinity": { "requiredDuringSchedulingIgnoredDuringExecution": {
+							"nodeSelectorTerms": [{
+								"matchExpressions": [{
+									"key": "foo",
+						`,
+					},
+				},
+			},
+			expectErr: true,
+		},
+	}
+
+	for i, tc := range testCases {
+		_, err := GetAffinityFromPodAnnotations(tc.pod.Annotations)
+		if err == nil && tc.expectErr {
+			t.Errorf("[%v]expected error but got none.", i)
+		}
+		if err != nil && !tc.expectErr {
+			t.Errorf("[%v]did not expect error but got: %v", i, err)
+		}
+	}
+}
+
+func TestReconcileAffinity(t *testing.T) {
+	baseAffinity := &Affinity{
+		NodeAffinity: &NodeAffinity{
+			RequiredDuringSchedulingIgnoredDuringExecution: &NodeSelector{
+				NodeSelectorTerms: []NodeSelectorTerm{
+					{
+						MatchExpressions: []NodeSelectorRequirement{
+							{
+								Key:      "foo",
+								Operator: NodeSelectorOpIn,
+								Values:   []string{"bar", "value2"},
+							},
+						},
+					},
+				},
+			},
+		},
+		PodAffinity: &PodAffinity{
+			RequiredDuringSchedulingIgnoredDuringExecution: []PodAffinityTerm{
+				{
+					LabelSelector: &metav1.LabelSelector{
+						MatchExpressions: []metav1.LabelSelectorRequirement{
+							{
+								Key:      "security",
+								Operator: metav1.LabelSelectorOpDoesNotExist,
+								Values:   []string{"securityscan"},
+							},
+						},
+					},
+					TopologyKey: "topologyKey1",
+				},
+			},
+		},
+		PodAntiAffinity: &PodAntiAffinity{
+			RequiredDuringSchedulingIgnoredDuringExecution: []PodAffinityTerm{
+				{
+					LabelSelector: &metav1.LabelSelector{
+						MatchExpressions: []metav1.LabelSelectorRequirement{
+							{
+								Key:      "service",
+								Operator: metav1.LabelSelectorOpIn,
+								Values:   []string{"S1", "value2"},
+							},
+						},
+					},
+					TopologyKey: "topologyKey2",
+					Namespaces:  []string{"ns1"},
+				},
+			},
+		},
+	}
+
+	nodeAffinityAnnotation := map[string]string{
+		AffinityAnnotationKey: `
+		{"nodeAffinity": {"preferredDuringSchedulingIgnoredDuringExecution": [
+			{
+				"weight": 2,
+				"preference": {"matchExpressions": [
+					{
+						"key": "foo",
+						"operator": "In", "values": ["bar"]
+					}
+				]}
+			}
+		]}}`,
+	}
+
+	testCases := []struct {
+		pod                *Pod
+		expected           *Affinity
+		annotationsEnabled bool
+	}{
+		{
+			pod: &Pod{
+				ObjectMeta: metav1.ObjectMeta{
+					Annotations: nodeAffinityAnnotation,
+				},
+				Spec: PodSpec{
+					Affinity: baseAffinity,
+				},
+			},
+			expected:           baseAffinity,
+			annotationsEnabled: true,
+		},
+		{
+			pod: &Pod{
+				ObjectMeta: metav1.ObjectMeta{
+					Annotations: nodeAffinityAnnotation,
+				},
+			},
+			expected: &Affinity{
+				NodeAffinity: &NodeAffinity{
+					PreferredDuringSchedulingIgnoredDuringExecution: []PreferredSchedulingTerm{
+						{
+							Weight: 2,
+							Preference: NodeSelectorTerm{
+								MatchExpressions: []NodeSelectorRequirement{
+									{
+										Key:      "foo",
+										Operator: NodeSelectorOpIn,
+										Values:   []string{"bar"},
+									},
+								},
+							},
+						},
+					},
+				},
+			},
+			annotationsEnabled: true,
+		},
+	}
+
+	for i, tc := range testCases {
+		utilfeature.DefaultFeatureGate.Set(fmt.Sprintf("AffinityInAnnotations=%t", tc.annotationsEnabled))
+		affinity := ReconcileAffinity(tc.pod)
+		if affinity != tc.expected {
+			t.Errorf("[%v]did not get expected affinity. got: %v instead of %v", i, affinity, tc.expected)
+		}
+	}
+}

pkg/features/kube_features.go

@@ -85,6 +85,7 @@ var defaultKubernetesFeatureGates = map[utilfeature.Feature]utilfeature.FeatureS
 	DynamicVolumeProvisioning:                   {Default: true, PreRelease: utilfeature.Alpha},
 	ExperimentalHostUserNamespaceDefaultingGate: {Default: false, PreRelease: utilfeature.Beta},
 	ExperimentalCriticalPodAnnotation:           {Default: false, PreRelease: utilfeature.Alpha},
+	AffinityInAnnotations:                       {Default: false, PreRelease: utilfeature.Alpha},
 
 	// inherited features from generic apiserver, relisted here to get a conflict if it is changed
 	// unintentionally on either side: