Add glide.yaml and vendor deps

vendor/k8s.io/kubernetes/pkg/dns/config/BUILD

@@ -0,0 +1,42 @@
+package(default_visibility = ["//visibility:public"])
+
+licenses(["notice"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_binary",
+    "go_library",
+    "go_test",
+    "cgo_library",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "config.go",
+        "mocksync.go",
+        "nopsync.go",
+        "sync.go",
+    ],
+    tags = ["automanaged"],
+    deps = [
+        "//pkg/api/v1:go_default_library",
+        "//pkg/apis/meta/v1:go_default_library",
+        "//pkg/client/cache:go_default_library",
+        "//pkg/client/clientset_generated/release_1_5:go_default_library",
+        "//pkg/dns/federation:go_default_library",
+        "//pkg/fields:go_default_library",
+        "//pkg/runtime:go_default_library",
+        "//pkg/watch:go_default_library",
+        "//vendor:github.com/golang/glog",
+        "//vendor:k8s.io/client-go/pkg/util/wait",
+    ],
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = ["config_test.go"],
+    library = "go_default_library",
+    tags = ["automanaged"],
+    deps = ["//vendor:github.com/stretchr/testify/assert"],
+)

vendor/k8s.io/kubernetes/pkg/dns/config/config.go

@@ -0,0 +1,65 @@
+/*
+Copyright 2016 The Kubernetes Authors.
+
+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 config
+
+import (
+	types "k8s.io/kubernetes/pkg/apis/meta/v1"
+	fed "k8s.io/kubernetes/pkg/dns/federation"
+)
+
+// Config populated either from the configuration source (command
+// line flags or via the config map mechanism).
+type Config struct {
+	// The inclusion of TypeMeta is to ensure future compatibility if the
+	// Config object was populated directly via a Kubernetes API mechanism.
+	//
+	// For example, instead of the custom implementation here, the
+	// configuration could be obtained from an API that unifies
+	// command-line flags, config-map, etc mechanisms.
+	types.TypeMeta
+
+	// Map of federation names that the cluster in which this kube-dns
+	// is running belongs to, to the corresponding domain names.
+	Federations map[string]string `json:"federations"`
+}
+
+func NewDefaultConfig() *Config {
+	return &Config{
+		Federations: make(map[string]string),
+	}
+}
+
+// IsValid returns whether or not the configuration is valid.
+func (config *Config) Validate() error {
+	if err := config.validateFederations(); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (config *Config) validateFederations() error {
+	for name, domain := range config.Federations {
+		if err := fed.ValidateName(name); err != nil {
+			return err
+		}
+		if err := fed.ValidateDomain(domain); err != nil {
+			return err
+		}
+	}
+	return nil
+}

vendor/k8s.io/kubernetes/pkg/dns/config/config_test.go

@@ -0,0 +1,56 @@
+/*
+Copyright 2016 The Kubernetes Authors.
+
+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 config
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestValidate(t *testing.T) {
+	for _, testCase := range []struct {
+		config   *Config
+		hasError bool
+	}{
+		{
+			config: &Config{Federations: map[string]string{}},
+		},
+		{
+			config: &Config{
+				Federations: map[string]string{
+					"abc": "d.e.f",
+				},
+			},
+		},
+		{
+			config: &Config{
+				Federations: map[string]string{
+					"a.b": "cdef",
+				},
+			},
+			hasError: true,
+		},
+	} {
+		err := testCase.config.Validate()
+		if !testCase.hasError {
+			assert.Nil(t, err, "should be valid", testCase)
+		} else {
+			assert.NotNil(t, err, "should not be valid", testCase)
+		}
+	}
+}

vendor/k8s.io/kubernetes/pkg/dns/config/mocksync.go

@@ -0,0 +1,46 @@
+/*
+Copyright 2016 The Kubernetes Authors.
+
+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 config
+
+// MockSync is a testing mock.
+type MockSync struct {
+	// Config that will be returned from Once().
+	Config *Config
+	// Error that will be returned from Once().
+	Error error
+
+	// Chan to send new configurations on.
+	Chan chan *Config
+}
+
+var _ Sync = (*MockSync)(nil)
+
+func NewMockSync(config *Config, error error) *MockSync {
+	return &MockSync{
+		Config: config,
+		Error:  error,
+		Chan:   make(chan *Config),
+	}
+}
+
+func (sync *MockSync) Once() (*Config, error) {
+	return sync.Config, sync.Error
+}
+
+func (sync *MockSync) Periodic() <-chan *Config {
+	return sync.Chan
+}

vendor/k8s.io/kubernetes/pkg/dns/config/nopsync.go

@@ -0,0 +1,37 @@
+/*
+Copyright 2016 The Kubernetes Authors.
+
+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 config
+
+// nopSync does no synchronization, used when the DNS server is
+// started without a ConfigMap configured.
+type nopSync struct {
+	config *Config
+}
+
+var _ Sync = (*nopSync)(nil)
+
+func NewNopSync(config *Config) Sync {
+	return &nopSync{config: config}
+}
+
+func (sync *nopSync) Once() (*Config, error) {
+	return sync.config, nil
+}
+
+func (sync *nopSync) Periodic() <-chan *Config {
+	return make(chan *Config)
+}

vendor/k8s.io/kubernetes/pkg/dns/config/sync.go

@@ -0,0 +1,201 @@
+/*
+Copyright 2016 The Kubernetes Authors.
+
+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 config
+
+import (
+	"k8s.io/client-go/pkg/util/wait"
+	"k8s.io/kubernetes/pkg/api/v1"
+	"k8s.io/kubernetes/pkg/client/cache"
+	clientset "k8s.io/kubernetes/pkg/client/clientset_generated/release_1_5"
+	fed "k8s.io/kubernetes/pkg/dns/federation"
+	"k8s.io/kubernetes/pkg/fields"
+	"k8s.io/kubernetes/pkg/runtime"
+	"k8s.io/kubernetes/pkg/watch"
+
+	"time"
+
+	"github.com/golang/glog"
+)
+
+// Sync manages synchronization of the config map.
+type Sync interface {
+	// Once does a blocking synchronization of the config map. If the
+	// ConfigMap fails to validate, this method will return nil, err.
+	Once() (*Config, error)
+
+	// Start a periodic synchronization of the configuration map. When a
+	// successful configuration map update is detected, the
+	// configuration will be sent to the channel.
+	//
+	// It is an error to call this more than once.
+	Periodic() <-chan *Config
+}
+
+// NewSync for ConfigMap from namespace `ns` and `name`.
+func NewSync(client clientset.Interface, ns string, name string) Sync {
+	sync := &kubeSync{
+		ns:      ns,
+		name:    name,
+		client:  client,
+		channel: make(chan *Config),
+	}
+
+	listWatch := &cache.ListWatch{
+		ListFunc: func(options v1.ListOptions) (runtime.Object, error) {
+			options.FieldSelector = fields.Set{"metadata.name": name}.AsSelector().String()
+			return client.Core().ConfigMaps(ns).List(options)
+		},
+		WatchFunc: func(options v1.ListOptions) (watch.Interface, error) {
+			options.FieldSelector = fields.Set{"metadata.name": name}.AsSelector().String()
+			return client.Core().ConfigMaps(ns).Watch(options)
+		},
+	}
+
+	store, controller := cache.NewInformer(
+		listWatch,
+		&v1.ConfigMap{},
+		time.Duration(0),
+		cache.ResourceEventHandlerFuncs{
+			AddFunc:    sync.onAdd,
+			DeleteFunc: sync.onDelete,
+			UpdateFunc: sync.onUpdate,
+		})
+
+	sync.store = store
+	sync.controller = controller
+
+	return sync
+}
+
+// kubeSync implements Sync for the Kubernetes API.
+type kubeSync struct {
+	ns   string
+	name string
+
+	client     clientset.Interface
+	store      cache.Store
+	controller *cache.Controller
+
+	channel chan *Config
+
+	latestVersion string
+}
+
+var _ Sync = (*kubeSync)(nil)
+
+func (sync *kubeSync) Once() (*Config, error) {
+	cm, err := sync.client.Core().ConfigMaps(sync.ns).Get(sync.name)
+
+	if err != nil {
+		glog.Errorf("Error getting ConfigMap %v:%v err: %v",
+			sync.ns, sync.name, err)
+		return nil, err
+	}
+
+	config, _, err := sync.processUpdate(cm)
+	return config, err
+}
+
+func (sync *kubeSync) Periodic() <-chan *Config {
+	go sync.controller.Run(wait.NeverStop)
+	return sync.channel
+}
+
+func (sync *kubeSync) toConfigMap(obj interface{}) *v1.ConfigMap {
+	cm, ok := obj.(*v1.ConfigMap)
+	if !ok {
+		glog.Fatalf("Expected ConfigMap, got %T", obj)
+	}
+	return cm
+}
+
+func (sync *kubeSync) onAdd(obj interface{}) {
+	cm := sync.toConfigMap(obj)
+
+	glog.V(2).Infof("ConfigMap %s:%s was created", sync.ns, sync.name)
+
+	config, updated, err := sync.processUpdate(cm)
+	if updated && err == nil {
+		sync.channel <- config
+	}
+}
+
+func (sync *kubeSync) onDelete(_ interface{}) {
+	glog.V(2).Infof("ConfigMap %s:%s was deleted, reverting to default configuration",
+		sync.ns, sync.name)
+
+	sync.latestVersion = ""
+	sync.channel <- NewDefaultConfig()
+}
+
+func (sync *kubeSync) onUpdate(_, obj interface{}) {
+	cm := sync.toConfigMap(obj)
+
+	glog.V(2).Infof("ConfigMap %s:%s was updated", sync.ns, sync.name)
+
+	config, changed, err := sync.processUpdate(cm)
+
+	if changed && err == nil {
+		sync.channel <- config
+	}
+}
+
+func (sync *kubeSync) processUpdate(cm *v1.ConfigMap) (config *Config, changed bool, err error) {
+	glog.V(4).Infof("processUpdate ConfigMap %+v", *cm)
+
+	if cm.ObjectMeta.ResourceVersion != sync.latestVersion {
+		glog.V(3).Infof("Updating config to version %v (was %v)",
+			cm.ObjectMeta.ResourceVersion, sync.latestVersion)
+		changed = true
+		sync.latestVersion = cm.ObjectMeta.ResourceVersion
+	} else {
+		glog.V(4).Infof("Config was unchanged (version %v)", sync.latestVersion)
+		return
+	}
+
+	config = &Config{}
+
+	if err = sync.updateFederations(cm, config); err != nil {
+		glog.Errorf("Invalid configuration, ignoring update")
+		return
+	}
+
+	if err = config.Validate(); err != nil {
+		glog.Errorf("Invalid onfiguration: %v (value was %+v), ignoring update",
+			err, config)
+		config = nil
+		return
+	}
+
+	return
+}
+
+func (sync *kubeSync) updateFederations(cm *v1.ConfigMap, config *Config) (err error) {
+	if flagValue, ok := cm.Data["federations"]; ok {
+		config.Federations = make(map[string]string)
+		if err = fed.ParseFederationsFlag(flagValue, config.Federations); err != nil {
+			glog.Errorf("Invalid federations value: %v (value was %q)",
+				err, cm.Data["federations"])
+			return
+		}
+		glog.V(2).Infof("Updated federations to %v", config.Federations)
+	} else {
+		glog.V(2).Infof("No federations present")
+	}
+
+	return
+}