Add glide.yaml and vendor deps

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

@@ -0,0 +1,62 @@
+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 = [
+        "dns.go",
+        "doc.go",
+    ],
+    tags = ["automanaged"],
+    deps = [
+        "//pkg/api/v1:go_default_library",
+        "//pkg/api/v1/endpoints: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/config:go_default_library",
+        "//pkg/dns/treecache:go_default_library",
+        "//pkg/dns/util:go_default_library",
+        "//pkg/runtime:go_default_library",
+        "//pkg/util/validation:go_default_library",
+        "//pkg/util/wait:go_default_library",
+        "//pkg/watch:go_default_library",
+        "//vendor:github.com/coreos/etcd/client",
+        "//vendor:github.com/golang/glog",
+        "//vendor:github.com/miekg/dns",
+        "//vendor:github.com/skynetservices/skydns/msg",
+    ],
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = ["dns_test.go"],
+    library = "go_default_library",
+    tags = ["automanaged"],
+    deps = [
+        "//pkg/api/v1:go_default_library",
+        "//pkg/api/v1/endpoints:go_default_library",
+        "//pkg/apis/meta/v1:go_default_library",
+        "//pkg/client/cache:go_default_library",
+        "//pkg/client/clientset_generated/release_1_5/fake:go_default_library",
+        "//pkg/dns/config:go_default_library",
+        "//pkg/dns/treecache:go_default_library",
+        "//pkg/dns/util:go_default_library",
+        "//pkg/util/sets:go_default_library",
+        "//vendor:github.com/coreos/etcd/client",
+        "//vendor:github.com/miekg/dns",
+        "//vendor:github.com/skynetservices/skydns/msg",
+        "//vendor:github.com/skynetservices/skydns/server",
+        "//vendor:github.com/stretchr/testify/assert",
+        "//vendor:github.com/stretchr/testify/require",
+    ],
+)

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
+}

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

@@ -0,0 +1,23 @@
+/*
+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 DNS provides a backend for the skydns DNS server started by the
+// kubedns cluster addon. It exposes the 2 interface method: Records and
+// ReverseRecord, which skydns invokes according to the DNS queries it
+// receives. It serves these records by consulting an in memory tree
+// populated with Kubernetes Services and Endpoints received from the Kubernetes
+// API server.
+package dns // import "k8s.io/kubernetes/pkg/dns"

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

@@ -0,0 +1,26 @@
+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 = ["federation.go"],
+    tags = ["automanaged"],
+    deps = ["//pkg/util/validation:go_default_library"],
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = ["federation_test.go"],
+    library = "go_default_library",
+    tags = ["automanaged"],
+    deps = ["//vendor:github.com/stretchr/testify/assert"],
+)

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

@@ -0,0 +1,75 @@
+/*
+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.
+*/
+
+// Fed contains federation specific DNS code.
+package fed
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+
+	"k8s.io/kubernetes/pkg/util/validation"
+)
+
+var ErrExpectedKeyEqualsValue = errors.New("invalid format, must be key=value")
+
+// ParseFederationsFlag parses the federations command line flag. The
+// flag is a comma-separated list of zero or more "name=label" pairs,
+// e.g. "a=b,c=d".
+func ParseFederationsFlag(str string, federations map[string]string) error {
+	if strings.TrimSpace(str) == "" {
+		return nil
+	}
+
+	for _, val := range strings.Split(str, ",") {
+		splits := strings.SplitN(strings.TrimSpace(val), "=", 2)
+		if len(splits) != 2 {
+			return ErrExpectedKeyEqualsValue
+		}
+
+		name := strings.TrimSpace(splits[0])
+		domain := strings.TrimSpace(splits[1])
+
+		if err := ValidateName(name); err != nil {
+			return err
+		}
+		if err := ValidateDomain(domain); err != nil {
+			return err
+		}
+		federations[name] = domain
+	}
+
+	return nil
+}
+
+// ValidateName checks the validity of a federation name.
+func ValidateName(name string) error {
+	if errs := validation.IsDNS1123Label(name); len(errs) != 0 {
+		return fmt.Errorf("%q not a valid federation name: %q", name, errs)
+	}
+	return nil
+}
+
+// ValidateDomain checks the validity of a federation label.
+func ValidateDomain(name string) error {
+	// The federation domain name need not strictly be domain names, we
+	// accept valid dns names with subdomain components.
+	if errs := validation.IsDNS1123Subdomain(name); len(errs) != 0 {
+		return fmt.Errorf("%q not a valid domain name: %q", name, errs)
+	}
+	return nil
+}

vendor/k8s.io/kubernetes/pkg/dns/federation/federation_test.go

@@ -0,0 +1,76 @@
+/*
+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 fed
+
+import (
+	"github.com/stretchr/testify/assert"
+
+	"reflect"
+	"testing"
+)
+
+func TestParseFederationsFlag(t *testing.T) {
+	type TestCase struct {
+		input    string
+		hasError bool
+		expected map[string]string
+	}
+
+	for _, testCase := range []TestCase{
+		{input: "", expected: make(map[string]string)},
+		{input: "a=b", expected: map[string]string{"a": "b"}},
+		{input: "a=b,cc=dd", expected: map[string]string{"a": "b", "cc": "dd"}},
+		{input: "abc=d.e.f", expected: map[string]string{"abc": "d.e.f"}},
+
+		{input: "ccdd", hasError: true},
+		{input: "a=b,ccdd", hasError: true},
+		{input: "-", hasError: true},
+		{input: "a.b.c=d.e.f", hasError: true},
+	} {
+		output := make(map[string]string)
+		err := ParseFederationsFlag(testCase.input, output)
+
+		if !testCase.hasError {
+			assert.Nil(t, err, "unexpected err", testCase)
+			assert.True(t, reflect.DeepEqual(
+				testCase.expected, output), output, testCase)
+		} else {
+			assert.NotNil(t, err, testCase)
+		}
+	}
+}
+
+func TestValidateName(t *testing.T) {
+	// More complete testing is done in validation.IsDNS1123Label. These
+	// tests are to catch issues specific to the implementation of
+	// kube-dns.
+	assert.NotNil(t, ValidateName(""))
+	assert.NotNil(t, ValidateName("."))
+	assert.NotNil(t, ValidateName("ab.cd"))
+	assert.Nil(t, ValidateName("abcd"))
+}
+
+func TestValidateDomain(t *testing.T) {
+	// More complete testing is done in
+	// validation.IsDNS1123Subdomain. These tests are to catch issues
+	// specific to the implementation of kube-dns.
+	assert.NotNil(t, ValidateDomain(""))
+	assert.NotNil(t, ValidateDomain("."))
+	assert.Nil(t, ValidateDomain("ab.cd"))
+	assert.Nil(t, ValidateDomain("abcd"))
+	assert.Nil(t, ValidateDomain("a.b.c.d"))
+}

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

@@ -0,0 +1,26 @@
+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 = ["treecache.go"],
+    tags = ["automanaged"],
+    deps = ["//vendor:github.com/skynetservices/skydns/msg"],
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = ["treecache_test.go"],
+    library = "go_default_library",
+    tags = ["automanaged"],
+    deps = ["//vendor:github.com/skynetservices/skydns/msg"],
+)

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

@@ -0,0 +1,213 @@
+/*
+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 treecache
+
+import (
+	"encoding/json"
+	"strings"
+
+	skymsg "github.com/skynetservices/skydns/msg"
+)
+
+type TreeCache interface {
+	// GetEntry with the given key for the given path.
+	GetEntry(key string, path ...string) (interface{}, bool)
+
+	// Get a list of values including wildcards labels (e.g. "*").
+	GetValuesForPathWithWildcards(path ...string) []*skymsg.Service
+
+	// SetEntry creates the entire path if it doesn't already exist in
+	// the cache, then sets the given service record under the given
+	// key. The path this entry would have occupied in an etcd datastore
+	// is computed from the given fqdn and stored as the "Key" of the
+	// skydns service; this is only required because skydns expects the
+	// service record to contain a key in a specific format (presumably
+	// for legacy compatibility). Note that the fqnd string typically
+	// contains both the key and all elements in the path.
+	SetEntry(key string, val *skymsg.Service, fqdn string, path ...string)
+
+	// SetSubCache inserts the given subtree under the given
+	// path:key. Usually the key is the name of a Kubernetes Service,
+	// and the path maps to the cluster subdomains matching the Service.
+	SetSubCache(key string, subCache TreeCache, path ...string)
+
+	// DeletePath removes all entries associated with a given path.
+	DeletePath(path ...string) bool
+
+	// Serialize dumps a JSON representation of the cache.
+	Serialize() (string, error)
+}
+
+type treeCache struct {
+	ChildNodes map[string]*treeCache
+	Entries    map[string]interface{}
+}
+
+func NewTreeCache() TreeCache {
+	return &treeCache{
+		ChildNodes: make(map[string]*treeCache),
+		Entries:    make(map[string]interface{}),
+	}
+}
+
+func (cache *treeCache) Serialize() (string, error) {
+	prettyJSON, err := json.MarshalIndent(cache, "", "\t")
+	if err != nil {
+		return "", err
+	}
+	return string(prettyJSON), nil
+}
+
+func (cache *treeCache) SetEntry(key string, val *skymsg.Service, fqdn string, path ...string) {
+	// TODO: Consolidate setEntry and setSubCache into a single method with a
+	// type switch.
+	// TODO: Instead of passing the fqdn as an argument, we can reconstruct
+	// it from the path, provided callers always pass the full path to the
+	// object. This is currently *not* the case, since callers first create
+	// a new, empty node, populate it, then parent it under the right path.
+	// So we don't know the full key till the final parenting operation.
+	node := cache.ensureChildNode(path...)
+
+	// This key is used to construct the "target" for SRV record lookups.
+	// For normal service/endpoint lookups, this will result in a key like:
+	// /skydns/local/cluster/svc/svcNS/svcName/record-hash
+	// but for headless services that govern pods requesting a specific
+	// hostname (as used by petset), this will end up being:
+	// /skydns/local/cluster/svc/svcNS/svcName/pod-hostname
+	val.Key = skymsg.Path(fqdn)
+	node.Entries[key] = val
+}
+
+func (cache *treeCache) getSubCache(path ...string) *treeCache {
+	childCache := cache
+	for _, subpath := range path {
+		childCache = childCache.ChildNodes[subpath]
+		if childCache == nil {
+			return nil
+		}
+	}
+	return childCache
+}
+
+func (cache *treeCache) SetSubCache(key string, subCache TreeCache, path ...string) {
+	node := cache.ensureChildNode(path...)
+	node.ChildNodes[key] = subCache.(*treeCache)
+}
+
+func (cache *treeCache) GetEntry(key string, path ...string) (interface{}, bool) {
+	childNode := cache.getSubCache(path...)
+	if childNode == nil {
+		return nil, false
+	}
+	val, ok := childNode.Entries[key]
+	return val, ok
+}
+
+func (cache *treeCache) GetValuesForPathWithWildcards(path ...string) []*skymsg.Service {
+	retval := []*skymsg.Service{}
+	nodesToExplore := []*treeCache{cache}
+	for idx, subpath := range path {
+		nextNodesToExplore := []*treeCache{}
+		if idx == len(path)-1 {
+			// if path ends on an entry, instead of a child node, add the entry
+			for _, node := range nodesToExplore {
+				if subpath == "*" {
+					nextNodesToExplore = append(nextNodesToExplore, node)
+				} else {
+					if val, ok := node.Entries[subpath]; ok {
+						retval = append(retval, val.(*skymsg.Service))
+					} else {
+						childNode := node.ChildNodes[subpath]
+						if childNode != nil {
+							nextNodesToExplore = append(nextNodesToExplore, childNode)
+						}
+					}
+				}
+			}
+			nodesToExplore = nextNodesToExplore
+			break
+		}
+
+		if subpath == "*" {
+			for _, node := range nodesToExplore {
+				for subkey, subnode := range node.ChildNodes {
+					if !strings.HasPrefix(subkey, "_") {
+						nextNodesToExplore = append(nextNodesToExplore, subnode)
+					}
+				}
+			}
+		} else {
+			for _, node := range nodesToExplore {
+				childNode := node.ChildNodes[subpath]
+				if childNode != nil {
+					nextNodesToExplore = append(nextNodesToExplore, childNode)
+				}
+			}
+		}
+		nodesToExplore = nextNodesToExplore
+	}
+
+	for _, node := range nodesToExplore {
+		for _, val := range node.Entries {
+			retval = append(retval, val.(*skymsg.Service))
+		}
+	}
+	return retval
+}
+
+func (cache *treeCache) DeletePath(path ...string) bool {
+	if len(path) == 0 {
+		return false
+	}
+	if parentNode := cache.getSubCache(path[:len(path)-1]...); parentNode != nil {
+		name := path[len(path)-1]
+		if _, ok := parentNode.ChildNodes[name]; ok {
+			delete(parentNode.ChildNodes, name)
+			return true
+		}
+		// ExternalName services are stored with their name as the leaf key
+		if _, ok := parentNode.Entries[name]; ok {
+			delete(parentNode.Entries, name)
+			return true
+		}
+	}
+	return false
+}
+
+func (cache *treeCache) appendValues(recursive bool, ref [][]interface{}) {
+	for _, value := range cache.Entries {
+		ref[0] = append(ref[0], value)
+	}
+	if recursive {
+		for _, node := range cache.ChildNodes {
+			node.appendValues(recursive, ref)
+		}
+	}
+}
+
+func (cache *treeCache) ensureChildNode(path ...string) *treeCache {
+	childNode := cache
+	for _, subpath := range path {
+		newNode, ok := childNode.ChildNodes[subpath]
+		if !ok {
+			newNode = NewTreeCache().(*treeCache)
+			childNode.ChildNodes[subpath] = newNode
+		}
+		childNode = newNode
+	}
+	return childNode
+}

vendor/k8s.io/kubernetes/pkg/dns/treecache/treecache_test.go

@@ -0,0 +1,161 @@
+/*
+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 treecache
+
+import (
+	"testing"
+
+	"github.com/skynetservices/skydns/msg"
+)
+
+func TestTreeCache(t *testing.T) {
+	tc := NewTreeCache()
+
+	{
+		_, ok := tc.GetEntry("key1", "p1", "p2")
+		if ok {
+			t.Errorf("key should not exist")
+		}
+	}
+
+	checkExists := func(key string, expectedSvc *msg.Service, path ...string) {
+		svc, ok := tc.GetEntry(key, path...)
+		if !ok {
+			t.Fatalf("key %v should exist", key)
+		}
+		if svc := svc.(*msg.Service); svc != nil {
+			if svc != expectedSvc {
+				t.Errorf("value is not correct (%v != %v)", svc, expectedSvc)
+			}
+		} else {
+			t.Errorf("entry is not of the right type: %T", svc)
+		}
+	}
+	setEntryTC := []struct {
+		key  string
+		svc  *msg.Service
+		fqdn string
+		path []string
+	}{
+		{"key1", &msg.Service{}, "key1.p2.p1.", []string{"p1", "p2"}},
+		{"key2", &msg.Service{}, "key2.p2.p1.", []string{"p1", "p2"}},
+		{"key3", &msg.Service{}, "key3.p2.p1.", []string{"p1", "p3"}},
+	}
+
+	for _, testCase := range setEntryTC {
+		tc.SetEntry(testCase.key, testCase.svc, testCase.fqdn, testCase.path...)
+		checkExists(testCase.key, testCase.svc, testCase.path...)
+	}
+
+	wildcardTC := []struct {
+		path  []string
+		count int
+	}{
+		{[]string{"p1"}, 0},
+		{[]string{"p1", "p2"}, 2},
+		{[]string{"p1", "p3"}, 1},
+		{[]string{"p1", "p2", "key1"}, 1},
+		{[]string{"p1", "p2", "key2"}, 1},
+		{[]string{"p1", "p2", "key3"}, 0},
+		{[]string{"p1", "p3", "key3"}, 1},
+		{[]string{"p1", "p2", "*"}, 2},
+		{[]string{"p1", "*", "*"}, 3},
+	}
+
+	for _, testCase := range wildcardTC {
+		services := tc.GetValuesForPathWithWildcards(testCase.path...)
+		if len(services) != testCase.count {
+			t.Fatalf("Expected %v services for path %v, got %v",
+				testCase.count, testCase.path, len(services))
+		}
+	}
+
+	// Delete some paths
+	if !tc.DeletePath("p1", "p2") {
+		t.Fatal("should delete path p2.p1.")
+	}
+	if _, ok := tc.GetEntry("key3", "p1", "p3"); !ok {
+		t.Error("should not affect p3.p1.")
+	}
+	if tc.DeletePath("p1", "p2") {
+		t.Fatalf("should not be able to delete p2.p1")
+	}
+	if !tc.DeletePath("p1", "p3") {
+		t.Fatalf("should be able to delete p3.p1")
+	}
+	if tc.DeletePath("p1", "p3") {
+		t.Fatalf("should not be able to delete p3.t1")
+	}
+
+	for _, testCase := range []struct {
+		k string
+		p []string
+	}{
+		{"key1", []string{"p1", "p2"}},
+		{"key2", []string{"p1", "p2"}},
+		{"key3", []string{"p1", "p3"}},
+	} {
+		if _, ok := tc.GetEntry(testCase.k, testCase.p...); ok {
+			t.Error("path should not exist")
+		}
+	}
+}
+
+func TestTreeCacheSetSubCache(t *testing.T) {
+	tc := NewTreeCache()
+
+	m := &msg.Service{}
+
+	branch := NewTreeCache()
+	branch.SetEntry("key1", m, "key", "p2")
+
+	tc.SetSubCache("p1", branch, "p0")
+
+	if _, ok := tc.GetEntry("key1", "p0", "p1", "p2"); !ok {
+		t.Errorf("should be able to get entry p0.p1.p2.key1")
+	}
+}
+
+func TestTreeCacheSerialize(t *testing.T) {
+	tc := NewTreeCache()
+	tc.SetEntry("key1", &msg.Service{}, "key1.p2.p1.", "p1", "p2")
+
+	const expected = `{
+	"ChildNodes": {
+		"p1": {
+			"ChildNodes": {
+				"p2": {
+					"ChildNodes": {},
+					"Entries": {
+						"key1": {}
+					}
+				}
+			},
+			"Entries": {}
+		}
+	},
+	"Entries": {}
+}`
+
+	actual, err := tc.Serialize()
+	if err != nil {
+	}
+
+	if actual != expected {
+		t.Errorf("expected %q, got %q", expected, actual)
+	}
+}

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

@@ -0,0 +1,21 @@
+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 = ["util.go"],
+    tags = ["automanaged"],
+    deps = [
+        "//vendor:github.com/golang/glog",
+        "//vendor:github.com/skynetservices/skydns/msg",
+    ],
+)

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

@@ -0,0 +1,89 @@
+/*
+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 util
+
+import (
+	"fmt"
+	"hash/fnv"
+	"strings"
+
+	"github.com/golang/glog"
+	"github.com/skynetservices/skydns/msg"
+)
+
+const (
+	// ArpaSuffix is the standard suffix for PTR IP reverse lookups.
+	ArpaSuffix = ".in-addr.arpa."
+	// defaultPriority used for service records
+	defaultPriority = 10
+	// defaultWeight used for service records
+	defaultWeight = 10
+	// defaultTTL used for service records
+	defaultTTL = 30
+)
+
+// extractIP turns a standard PTR reverse record lookup name
+// into an IP address
+func ExtractIP(reverseName string) (string, bool) {
+	if !strings.HasSuffix(reverseName, ArpaSuffix) {
+		return "", false
+	}
+	search := strings.TrimSuffix(reverseName, ArpaSuffix)
+
+	// reverse the segments and then combine them
+	segments := ReverseArray(strings.Split(search, "."))
+	return strings.Join(segments, "."), true
+}
+
+// ReverseArray reverses an array.
+func ReverseArray(arr []string) []string {
+	for i := 0; i < len(arr)/2; i++ {
+		j := len(arr) - i - 1
+		arr[i], arr[j] = arr[j], arr[i]
+	}
+	return arr
+}
+
+// Returns record in a format that SkyDNS understands.
+// Also return the hash of the record.
+func GetSkyMsg(ip string, port int) (*msg.Service, string) {
+	msg := NewServiceRecord(ip, port)
+	hash := HashServiceRecord(msg)
+	glog.V(5).Infof("Constructed new DNS record: %s, hash:%s",
+		fmt.Sprintf("%v", msg), hash)
+	return msg, fmt.Sprintf("%x", hash)
+}
+
+// NewServiceRecord creates a new service DNS message.
+func NewServiceRecord(ip string, port int) *msg.Service {
+	return &msg.Service{
+		Host:     ip,
+		Port:     port,
+		Priority: defaultPriority,
+		Weight:   defaultWeight,
+		Ttl:      defaultTTL,
+	}
+}
+
+// HashServiceRecord hashes the string representation of a DNS
+// message.
+func HashServiceRecord(msg *msg.Service) string {
+	s := fmt.Sprintf("%v", msg)
+	h := fnv.New32a()
+	h.Write([]byte(s))
+	return fmt.Sprintf("%x", h.Sum32())
+}