@@ -2,7 +2,6 @@ package config

 import (

 	"fmt"

-	"reflect"

 	kapi "github.com/GoogleCloudPlatform/kubernetes/pkg/api"

 	errs "github.com/GoogleCloudPlatform/kubernetes/pkg/api/errors"

@@ -10,8 +9,10 @@ import (

 	"github.com/GoogleCloudPlatform/kubernetes/pkg/kubectl"

 	"github.com/GoogleCloudPlatform/kubernetes/pkg/labels"

 	"github.com/GoogleCloudPlatform/kubernetes/pkg/runtime"

+

 	"github.com/openshift/origin/pkg/config/api"

 	deployapi "github.com/openshift/origin/pkg/deploy/api"

+	"github.com/openshift/origin/pkg/util"

 )

 // ApplyResult holds the response from the REST server and potential errors

@@ -103,40 +104,40 @@ func addLabelError(kind string, err error) error {

 func AddConfigLabel(obj runtime.Object, labels labels.Set) error {

 	switch t := obj.(type) {

 	case *kapi.Pod:

-		if err := mergeMaps(&t.Labels, labels, ErrorOnDifferentDstKeyValue); err != nil {

+		if err := util.MergeInto(&t.Labels, labels, util.ErrorOnDifferentDstKeyValue); err != nil {

 			return addLabelError("Pod", err)

 		}

 	case *kapi.Service:

-		if err := mergeMaps(&t.Labels, labels, ErrorOnDifferentDstKeyValue); err != nil {

+		if err := util.MergeInto(&t.Labels, labels, util.ErrorOnDifferentDstKeyValue); err != nil {

 			return addLabelError("Service", err)

 		}

 	case *kapi.ReplicationController:

-		if err := mergeMaps(&t.Labels, labels, ErrorOnDifferentDstKeyValue); err != nil {

+		if err := util.MergeInto(&t.Labels, labels, util.ErrorOnDifferentDstKeyValue); err != nil {

 			return addLabelError("ReplicationController", err)

 		}

-		if err := mergeMaps(&t.DesiredState.PodTemplate.Labels, labels, ErrorOnDifferentDstKeyValue); err != nil {

+		if err := util.MergeInto(&t.DesiredState.PodTemplate.Labels, labels, util.ErrorOnDifferentDstKeyValue); err != nil {

 			return addLabelError("ReplicationController.PodTemplate", err)

 		}

-		if err := mergeMaps(&t.DesiredState.PodTemplate.Labels, t.DesiredState.ReplicaSelector, ErrorOnDifferentDstKeyValue); err != nil {

+		if err := util.MergeInto(&t.DesiredState.PodTemplate.Labels, t.DesiredState.ReplicaSelector, util.ErrorOnDifferentDstKeyValue); err != nil {

 			return addLabelError("ReplicationController.ReplicaSelector", err)

 		}

 		// The ReplicaSelector and DesiredState.PodTemplate.Labels need to make

 		// create succeed

-		if err := mergeMaps(&t.DesiredState.ReplicaSelector, t.DesiredState.PodTemplate.Labels, ErrorOnDifferentDstKeyValue); err != nil {

+		if err := util.MergeInto(&t.DesiredState.ReplicaSelector, t.DesiredState.PodTemplate.Labels, util.ErrorOnDifferentDstKeyValue); err != nil {

 			return addLabelError("ReplicationController.PodTemplate", err)

 		}

 	case *deployapi.Deployment:

-		if err := mergeMaps(&t.Labels, labels, ErrorOnDifferentDstKeyValue); err != nil {

+		if err := util.MergeInto(&t.Labels, labels, util.ErrorOnDifferentDstKeyValue); err != nil {

 			return addLabelError("Deployment", err)

 		}

-		if err := mergeMaps(&t.ControllerTemplate.PodTemplate.Labels, labels, ErrorOnDifferentDstKeyValue); err != nil {

+		if err := util.MergeInto(&t.ControllerTemplate.PodTemplate.Labels, labels, util.ErrorOnDifferentDstKeyValue); err != nil {

 			return addLabelError("Deployment.ControllerTemplate.PodTemplate", err)

 		}

 	case *deployapi.DeploymentConfig:

-		if err := mergeMaps(&t.Labels, labels, ErrorOnDifferentDstKeyValue); err != nil {

+		if err := util.MergeInto(&t.Labels, labels, util.ErrorOnDifferentDstKeyValue); err != nil {

 			return addLabelError("DeploymentConfig", err)

 		}

-		if err := mergeMaps(&t.Template.ControllerTemplate.PodTemplate.Labels, labels, ErrorOnDifferentDstKeyValue); err != nil {

+		if err := util.MergeInto(&t.Template.ControllerTemplate.PodTemplate.Labels, labels, util.ErrorOnDifferentDstKeyValue); err != nil {

 			return addLabelError("DeploymentConfig.ControllerTemplate.PodTemplate", err)

 		}

 	default:

@@ -168,72 +169,3 @@ func AddConfigLabels(c *api.Config, labels labels.Set) errs.ValidationErrorList

 	}

 	return itemErrors.Prefix("Config")

 }

-

-// mergeMaps flags

-const (

-	OverwriteExistingDstKey     = 1 << iota

-	ErrorOnExistingDstKey       = 1 << iota

-	ErrorOnDifferentDstKeyValue = 1 << iota

-)

-

-// mergeMaps merges items from a src map into a dst map.

-// Returns an error when the maps are not of the same type.

-// Flags:

-// - ErrorOnExistingDstKey

-//     When set: Return an error if any of the dst keys is already set.

-// - ErrorOnDifferentDstKeyValue

-//     When set: Return an error if any of the dst keys is already set

-//               to a different value than src key.

-// - OverwriteDstKey

-//     When set: Overwrite existing dst key value with src key value.

-func mergeMaps(dst, src interface{}, flags int) error {

-	dstVal := reflect.ValueOf(dst)

-	srcVal := reflect.ValueOf(src)

-

-	if dstVal.Kind() == reflect.Interface || dstVal.Kind() == reflect.Ptr {

-		dstVal = dstVal.Elem()

-	}

-	if srcVal.Kind() == reflect.Interface || srcVal.Kind() == reflect.Ptr {

-		srcVal = srcVal.Elem()

-	}

-

-	if !dstVal.IsValid() {

-		return fmt.Errorf("Dst is not a valid value")

-	}

-	if dstVal.Kind() != reflect.Map {

-		return fmt.Errorf("Dst is not a map")

-	}

-

-	dstTyp := dstVal.Type()

-	srcTyp := srcVal.Type()

-	if !dstTyp.AssignableTo(srcTyp) {

-		return fmt.Errorf("Type mismatch, can't assign '%v' to '%v'", srcTyp, dstTyp)

-	}

-

-	if dstVal.IsNil() {

-		if !dstVal.CanSet() {

-			return fmt.Errorf("Dst value is (not addressable) nil, pass a pointer instead")

-		}

-		dstVal.Set(reflect.MakeMap(dstTyp))

-	}

-

-	for _, k := range srcVal.MapKeys() {

-		if dstVal.MapIndex(k).IsValid() {

-			if flags&ErrorOnExistingDstKey != 0 {

-				return fmt.Errorf("ErrorOnExistingDstKey flag: Dst key already set to a different value, '%v'='%v'", k, dstVal.MapIndex(k))

-			}

-			if dstVal.MapIndex(k).String() != srcVal.MapIndex(k).String() {

-				if flags&ErrorOnDifferentDstKeyValue != 0 {

-					return fmt.Errorf("ErrorOnDifferentDstKeyValue flag: Dst key already set to a different value, '%v'='%v'", k, dstVal.MapIndex(k))

-				}

-				if flags&OverwriteExistingDstKey != 0 {

-					dstVal.SetMapIndex(k, srcVal.MapIndex(k))

-				}

-			}

-		} else {

-			dstVal.SetMapIndex(k, srcVal.MapIndex(k))

-		}

-	}

-

-	return nil

-}

@@ -294,76 +294,3 @@ func TestAddConfigLabels(t *testing.T) {

 		}

 	}

 }

-

-func TestMergeMaps(t *testing.T) {

-	testCases := []struct {

-		dst        interface{}

-		src        interface{}

-		flags      int

-		shouldPass bool

-		expected   interface{}

-	}{

-		{ // Test empty maps

-			map[int]int{},

-			map[int]int{},

-			0,

-			true,

-			map[int]int{},

-		},

-		{ // Test dst + src => expected

-			map[int]string{1: "foo"},

-			map[int]string{2: "bar"},

-			0,

-			true,

-			map[int]string{1: "foo", 2: "bar"},

-		},

-		{ // Test dst + src => expected, do not overwrite dst

-			map[string]string{"foo": "bar"},

-			map[string]string{"foo": ""},

-			0,

-			true,

-			map[string]string{"foo": "bar"},

-		},

-		{ // Test dst + src => expected, overwrite dst

-			map[string]string{"foo": "bar"},

-			map[string]string{"foo": ""},

-			OverwriteExistingDstKey,

-			true,

-			map[string]string{"foo": ""},

-		},

-		{ // Test dst + src => expected, error on existing key value

-			map[string]string{"foo": "bar"},

-			map[string]string{"foo": "bar"},

-			ErrorOnExistingDstKey | OverwriteExistingDstKey,

-			false,

-			map[string]string{"foo": "bar"},

-		},

-		{ // Test dst + src => expected, do not error on same key value

-			map[string]string{"foo": "bar"},

-			map[string]string{"foo": "bar"},

-			ErrorOnDifferentDstKeyValue | OverwriteExistingDstKey,

-			true,

-			map[string]string{"foo": "bar"},

-		},

-		{ // Test dst + src => expected, error on different key value

-			map[string]string{"foo": "bar"},

-			map[string]string{"foo": ""},

-			ErrorOnDifferentDstKeyValue | OverwriteExistingDstKey,

-			false,

-			map[string]string{"foo": "bar"},

-		},

-	}

-

-	for i, test := range testCases {

-		err := mergeMaps(test.dst, test.src, test.flags)

-		if err != nil && test.shouldPass {

-			t.Errorf("Unexpected error while merging maps on testCase[%v].", i)

-		}

-		if err == nil && !test.shouldPass {

-			t.Errorf("Unexpected non-error while merging maps on testCase[%v].", i)

-		}

-		if !reflect.DeepEqual(test.dst, test.expected) {

-			t.Errorf("Unexpected map on testCase[%v]. Expected: %v, got: %v.", i, test.expected, test.dst)

-		}

-	}

-}

new file mode 100644

@@ -0,0 +1,4 @@

+// Package util implements various utility functions used in both testing and

+// implementation of OpenShift. Package util may not depend on any other

+// package in the OpenShift package tree.

+package util

new file mode 100644

@@ -0,0 +1,75 @@

+package util

+

+import (

+	"fmt"

+	"reflect"

+)

+

+// MergeInto flags

+const (

+	OverwriteExistingDstKey     = 1 << iota

+	ErrorOnExistingDstKey       = 1 << iota

+	ErrorOnDifferentDstKeyValue = 1 << iota

+)

+

+// MergeInto merges items from a src map into a dst map.

+// Returns an error when the maps are not of the same type.

+// Flags:

+// - ErrorOnExistingDstKey

+//     When set: Return an error if any of the dst keys is already set.

+// - ErrorOnDifferentDstKeyValue

+//     When set: Return an error if any of the dst keys is already set

+//               to a different value than src key.

+// - OverwriteDstKey

+//     When set: Overwrite existing dst key value with src key value.

+func MergeInto(dst, src interface{}, flags int) error {

+	dstVal := reflect.ValueOf(dst)

+	srcVal := reflect.ValueOf(src)

+

+	if dstVal.Kind() == reflect.Interface || dstVal.Kind() == reflect.Ptr {

+		dstVal = dstVal.Elem()

+	}

+	if srcVal.Kind() == reflect.Interface || srcVal.Kind() == reflect.Ptr {

+		srcVal = srcVal.Elem()

+	}

+

+	if !dstVal.IsValid() {

+		return fmt.Errorf("Dst is not a valid value")

+	}

+	if dstVal.Kind() != reflect.Map {

+		return fmt.Errorf("Dst is not a map")

+	}

+

+	dstTyp := dstVal.Type()

+	srcTyp := srcVal.Type()

+	if !dstTyp.AssignableTo(srcTyp) {

+		return fmt.Errorf("Type mismatch, can't assign '%v' to '%v'", srcTyp, dstTyp)

+	}

+

+	if dstVal.IsNil() {

+		if !dstVal.CanSet() {

+			return fmt.Errorf("Dst value is (not addressable) nil, pass a pointer instead")

+		}

+		dstVal.Set(reflect.MakeMap(dstTyp))

+	}

+

+	for _, k := range srcVal.MapKeys() {

+		if dstVal.MapIndex(k).IsValid() {

+			if flags&ErrorOnExistingDstKey != 0 {

+				return fmt.Errorf("ErrorOnExistingDstKey flag: Dst key already set to a different value, '%v'='%v'", k, dstVal.MapIndex(k))

+			}

+			if dstVal.MapIndex(k).String() != srcVal.MapIndex(k).String() {

+				if flags&ErrorOnDifferentDstKeyValue != 0 {

+					return fmt.Errorf("ErrorOnDifferentDstKeyValue flag: Dst key already set to a different value, '%v'='%v'", k, dstVal.MapIndex(k))

+				}

+				if flags&OverwriteExistingDstKey != 0 {

+					dstVal.SetMapIndex(k, srcVal.MapIndex(k))

+				}

+			}

+		} else {

+			dstVal.SetMapIndex(k, srcVal.MapIndex(k))

+		}

+	}

+

+	return nil

+}

new file mode 100644

@@ -0,0 +1,79 @@

+package util

+

+import (

+	"reflect"

+	"testing"

+)

+

+func TestMergeMaps(t *testing.T) {

+	testCases := []struct {

+		dst        interface{}

+		src        interface{}

+		flags      int

+		shouldPass bool

+		expected   interface{}

+	}{

+		{ // Test empty maps

+			map[int]int{},

+			map[int]int{},

+			0,

+			true,

+			map[int]int{},

+		},

+		{ // Test dst + src => expected

+			map[int]string{1: "foo"},

+			map[int]string{2: "bar"},

+			0,

+			true,

+			map[int]string{1: "foo", 2: "bar"},

+		},

+		{ // Test dst + src => expected, do not overwrite dst

+			map[string]string{"foo": "bar"},

+			map[string]string{"foo": ""},

+			0,

+			true,

+			map[string]string{"foo": "bar"},

+		},

+		{ // Test dst + src => expected, overwrite dst

+			map[string]string{"foo": "bar"},

+			map[string]string{"foo": ""},

+			OverwriteExistingDstKey,

+			true,

+			map[string]string{"foo": ""},

+		},

+		{ // Test dst + src => expected, error on existing key value

+			map[string]string{"foo": "bar"},

+			map[string]string{"foo": "bar"},

+			ErrorOnExistingDstKey | OverwriteExistingDstKey,

+			false,

+			map[string]string{"foo": "bar"},

+		},

+		{ // Test dst + src => expected, do not error on same key value

+			map[string]string{"foo": "bar"},

+			map[string]string{"foo": "bar"},

+			ErrorOnDifferentDstKeyValue | OverwriteExistingDstKey,

+			true,

+			map[string]string{"foo": "bar"},

+		},

+		{ // Test dst + src => expected, error on different key value

+			map[string]string{"foo": "bar"},

+			map[string]string{"foo": ""},

+			ErrorOnDifferentDstKeyValue | OverwriteExistingDstKey,

+			false,

+			map[string]string{"foo": "bar"},

+		},

+	}

+

+	for i, test := range testCases {

+		err := MergeInto(test.dst, test.src, test.flags)

+		if err != nil && test.shouldPass {

+			t.Errorf("Unexpected error while merging maps on testCase[%v].", i)

+		}

+		if err == nil && !test.shouldPass {

+			t.Errorf("Unexpected non-error while merging maps on testCase[%v].", i)

+		}

+		if !reflect.DeepEqual(test.dst, test.expected) {

+			t.Errorf("Unexpected map on testCase[%v]. Expected: %v, got: %v.", i, test.expected, test.dst)

+		}

+	}

+}