Add glide.yaml and vendor deps

vendor/k8s.io/kubernetes/cmd/kube-dns/BUILD

@@ -0,0 +1,29 @@
+package(default_visibility = ["//visibility:public"])
+
+licenses(["notice"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_binary",
+    "go_library",
+    "go_test",
+    "cgo_library",
+)
+
+go_binary(
+    name = "kube-dns",
+    srcs = ["dns.go"],
+    tags = ["automanaged"],
+    deps = [
+        "//cmd/kube-dns/app:go_default_library",
+        "//cmd/kube-dns/app/options:go_default_library",
+        "//pkg/client/metrics/prometheus:go_default_library",
+        "//pkg/util/flag:go_default_library",
+        "//pkg/util/logs:go_default_library",
+        "//pkg/version:go_default_library",
+        "//pkg/version/prometheus:go_default_library",
+        "//pkg/version/verflag:go_default_library",
+        "//vendor:github.com/golang/glog",
+        "//vendor:github.com/spf13/pflag",
+    ],
+)

vendor/k8s.io/kubernetes/cmd/kube-dns/app/BUILD

@@ -0,0 +1,30 @@
+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 = ["server.go"],
+    tags = ["automanaged"],
+    deps = [
+        "//cmd/kube-dns/app/options:go_default_library",
+        "//pkg/client/clientset_generated/release_1_5:go_default_library",
+        "//pkg/client/restclient:go_default_library",
+        "//pkg/client/unversioned/clientcmd:go_default_library",
+        "//pkg/dns:go_default_library",
+        "//pkg/dns/config:go_default_library",
+        "//pkg/runtime/schema:go_default_library",
+        "//vendor:github.com/golang/glog",
+        "//vendor:github.com/skynetservices/skydns/metrics",
+        "//vendor:github.com/skynetservices/skydns/server",
+        "//vendor:github.com/spf13/pflag",
+    ],
+)

vendor/k8s.io/kubernetes/cmd/kube-dns/app/options/BUILD

@@ -0,0 +1,23 @@
+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 = ["options.go"],
+    tags = ["automanaged"],
+    deps = [
+        "//pkg/api:go_default_library",
+        "//pkg/dns/federation:go_default_library",
+        "//pkg/util/validation:go_default_library",
+        "//vendor:github.com/spf13/pflag",
+    ],
+)

vendor/k8s.io/kubernetes/cmd/kube-dns/app/options/options.go

@@ -0,0 +1,163 @@
+/*
+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 options contains flags for initializing a proxy.
+package options
+
+import (
+	"fmt"
+	_ "net/http/pprof"
+	"net/url"
+	"os"
+	"strings"
+
+	"github.com/spf13/pflag"
+	"k8s.io/kubernetes/pkg/api"
+	fed "k8s.io/kubernetes/pkg/dns/federation"
+	"k8s.io/kubernetes/pkg/util/validation"
+)
+
+type KubeDNSConfig struct {
+	ClusterDomain  string
+	KubeConfigFile string
+	KubeMasterURL  string
+
+	HealthzPort    int
+	DNSBindAddress string
+	DNSPort        int
+
+	Federations map[string]string
+
+	ConfigMapNs string
+	ConfigMap   string
+}
+
+func NewKubeDNSConfig() *KubeDNSConfig {
+	return &KubeDNSConfig{
+		ClusterDomain:  "cluster.local.",
+		HealthzPort:    8081,
+		DNSBindAddress: "0.0.0.0",
+		DNSPort:        53,
+
+		Federations: make(map[string]string),
+
+		ConfigMapNs: api.NamespaceSystem,
+		ConfigMap:   "", // default to using command line flags
+	}
+}
+
+type clusterDomainVar struct {
+	val *string
+}
+
+func (m clusterDomainVar) Set(v string) error {
+	v = strings.TrimSuffix(v, ".")
+	segments := strings.Split(v, ".")
+	for _, segment := range segments {
+		if errs := validation.IsDNS1123Label(segment); len(errs) > 0 {
+			return fmt.Errorf("Not a valid DNS label. %v", errs)
+		}
+	}
+	if !strings.HasSuffix(v, ".") {
+		v = fmt.Sprintf("%s.", v)
+	}
+	*m.val = v
+	return nil
+}
+
+func (m clusterDomainVar) String() string {
+	return *m.val
+}
+
+func (m clusterDomainVar) Type() string {
+	return "string"
+}
+
+type kubeMasterURLVar struct {
+	val *string
+}
+
+func (m kubeMasterURLVar) Set(v string) error {
+	parsedURL, err := url.Parse(os.ExpandEnv(v))
+	if err != nil {
+		return fmt.Errorf("failed to parse kube-master-url")
+	}
+	if parsedURL.Scheme == "" || parsedURL.Host == "" || parsedURL.Host == ":" {
+		return fmt.Errorf("invalid kube-master-url specified")
+	}
+	*m.val = v
+	return nil
+}
+
+func (m kubeMasterURLVar) String() string {
+	return *m.val
+}
+
+func (m kubeMasterURLVar) Type() string {
+	return "string"
+}
+
+type federationsVar struct {
+	nameDomainMap map[string]string
+}
+
+func (fv federationsVar) Set(keyVal string) error {
+	return fed.ParseFederationsFlag(keyVal, fv.nameDomainMap)
+}
+
+func (fv federationsVar) String() string {
+	var splits []string
+	for name, domain := range fv.nameDomainMap {
+		splits = append(splits, fmt.Sprintf("%s=%s", name, domain))
+	}
+	return strings.Join(splits, ",")
+}
+
+func (fv federationsVar) Type() string {
+	return "[]string"
+}
+
+func (s *KubeDNSConfig) AddFlags(fs *pflag.FlagSet) {
+	fs.Var(clusterDomainVar{&s.ClusterDomain}, "domain",
+		"domain under which to create names")
+
+	fs.StringVar(&s.KubeConfigFile, "kubecfg-file", s.KubeConfigFile,
+		"Location of kubecfg file for access to kubernetes master service;"+
+			" --kube-master-url overrides the URL part of this; if neither this nor"+
+			" --kube-master-url are provided, defaults to service account tokens")
+	fs.Var(kubeMasterURLVar{&s.KubeMasterURL}, "kube-master-url",
+		"URL to reach kubernetes master. Env variables in this flag will be expanded.")
+
+	fs.IntVar(&s.HealthzPort, "healthz-port", s.HealthzPort,
+		"port on which to serve a kube-dns HTTP readiness probe.")
+	fs.StringVar(&s.DNSBindAddress, "dns-bind-address", s.DNSBindAddress,
+		"address on which to serve DNS requests.")
+	fs.IntVar(&s.DNSPort, "dns-port", s.DNSPort, "port on which to serve DNS requests.")
+
+	fs.Var(federationsVar{s.Federations}, "federations",
+		"a comma separated list of the federation names and their corresponding"+
+			" domain names to which this cluster belongs. Example:"+
+			" \"myfederation1=example.com,myfederation2=example2.com,myfederation3=example.com\"."+
+			" It is an error to set both the federations and config-map flags.")
+	fs.MarkDeprecated("federations", "use config-map instead. Will be removed in future version")
+
+	fs.StringVar(&s.ConfigMapNs, "config-map-namespace", s.ConfigMapNs,
+		"namespace for the config-map")
+	fs.StringVar(&s.ConfigMap, "config-map", s.ConfigMap,
+		"config-map name. If empty, then the config-map will not used. Cannot be "+
+			" used in conjunction with federations flag. config-map contains "+
+			"dynamically adjustable configuration.")
+}

vendor/k8s.io/kubernetes/cmd/kube-dns/app/server.go

@@ -0,0 +1,171 @@
+/*
+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 app
+
+import (
+	"fmt"
+	"net/http"
+	"os"
+	"os/signal"
+	"syscall"
+
+	"github.com/golang/glog"
+	"github.com/skynetservices/skydns/metrics"
+	"github.com/skynetservices/skydns/server"
+	"github.com/spf13/pflag"
+
+	"k8s.io/kubernetes/cmd/kube-dns/app/options"
+	clientset "k8s.io/kubernetes/pkg/client/clientset_generated/release_1_5"
+	"k8s.io/kubernetes/pkg/client/restclient"
+	kclientcmd "k8s.io/kubernetes/pkg/client/unversioned/clientcmd"
+	kdns "k8s.io/kubernetes/pkg/dns"
+	dnsconfig "k8s.io/kubernetes/pkg/dns/config"
+	"k8s.io/kubernetes/pkg/runtime/schema"
+)
+
+type KubeDNSServer struct {
+	// DNS domain name.
+	domain         string
+	healthzPort    int
+	dnsBindAddress string
+	dnsPort        int
+	kd             *kdns.KubeDNS
+}
+
+func NewKubeDNSServerDefault(config *options.KubeDNSConfig) *KubeDNSServer {
+	ks := KubeDNSServer{domain: config.ClusterDomain}
+
+	kubeClient, err := newKubeClient(config)
+	if err != nil {
+		glog.Fatalf("Failed to create a kubernetes client: %v", err)
+	}
+
+	ks.healthzPort = config.HealthzPort
+	ks.dnsBindAddress = config.DNSBindAddress
+	ks.dnsPort = config.DNSPort
+
+	var configSync dnsconfig.Sync
+	if config.ConfigMap == "" {
+		glog.V(0).Infof("ConfigMap not configured, using values from command line flags")
+		configSync = dnsconfig.NewNopSync(
+			&dnsconfig.Config{Federations: config.Federations})
+	} else {
+		glog.V(0).Infof("Using configuration read from ConfigMap: %v:%v",
+			config.ConfigMapNs, config.ConfigMap)
+		configSync = dnsconfig.NewSync(
+			kubeClient, config.ConfigMapNs, config.ConfigMap)
+	}
+
+	ks.kd = kdns.NewKubeDNS(kubeClient, config.ClusterDomain, configSync)
+
+	return &ks
+}
+
+// TODO: evaluate using pkg/client/clientcmd
+func newKubeClient(dnsConfig *options.KubeDNSConfig) (clientset.Interface, error) {
+	var (
+		config *restclient.Config
+		err    error
+	)
+
+	if dnsConfig.KubeMasterURL != "" && dnsConfig.KubeConfigFile == "" {
+		// Only --kube-master-url was provided.
+		config = &restclient.Config{
+			Host:          dnsConfig.KubeMasterURL,
+			ContentConfig: restclient.ContentConfig{GroupVersion: &schema.GroupVersion{Version: "v1"}},
+		}
+	} else {
+		// We either have:
+		//  1) --kube-master-url and --kubecfg-file
+		//  2) just --kubecfg-file
+		//  3) neither flag
+		// In any case, the logic is the same.  If (3), this will automatically
+		// fall back on the service account token.
+		overrides := &kclientcmd.ConfigOverrides{}
+		overrides.ClusterInfo.Server = dnsConfig.KubeMasterURL                                // might be "", but that is OK
+		rules := &kclientcmd.ClientConfigLoadingRules{ExplicitPath: dnsConfig.KubeConfigFile} // might be "", but that is OK
+		if config, err = kclientcmd.NewNonInteractiveDeferredLoadingClientConfig(rules, overrides).ClientConfig(); err != nil {
+			return nil, err
+		}
+	}
+
+	glog.V(0).Infof("Using %v for kubernetes master, kubernetes API: %v",
+		config.Host, config.GroupVersion)
+	return clientset.NewForConfig(config)
+}
+
+func (server *KubeDNSServer) Run() {
+	pflag.VisitAll(func(flag *pflag.Flag) {
+		glog.V(0).Infof("FLAG: --%s=%q", flag.Name, flag.Value)
+	})
+	setupSignalHandlers()
+	server.startSkyDNSServer()
+	server.kd.Start()
+	server.setupHandlers()
+
+	glog.V(0).Infof("Status HTTP port %v", server.healthzPort)
+	glog.Fatal(http.ListenAndServe(fmt.Sprintf(":%d", server.healthzPort), nil))
+}
+
+// setupHealthzHandlers sets up a readiness and liveness endpoint for kube2sky.
+func (server *KubeDNSServer) setupHandlers() {
+	glog.V(0).Infof("Setting up Healthz Handler (/readiness)")
+	http.HandleFunc("/readiness", func(w http.ResponseWriter, req *http.Request) {
+		fmt.Fprintf(w, "ok\n")
+	})
+
+	glog.V(0).Infof("Setting up cache handler (/cache)")
+	http.HandleFunc("/cache", func(w http.ResponseWriter, req *http.Request) {
+		serializedJSON, err := server.kd.GetCacheAsJSON()
+		if err == nil {
+			fmt.Fprint(w, serializedJSON)
+		} else {
+			w.WriteHeader(http.StatusInternalServerError)
+			fmt.Fprint(w, err)
+		}
+	})
+}
+
+// setupSignalHandlers installs signal handler to ignore SIGINT and
+// SIGTERM. This daemon will be killed by SIGKILL after the grace
+// period to allow for some manner of graceful shutdown.
+func setupSignalHandlers() {
+	sigChan := make(chan os.Signal)
+	signal.Notify(sigChan, syscall.SIGINT, syscall.SIGTERM)
+	go func() {
+		glog.V(0).Infof("Ignoring signal %v (can only be terminated by SIGKILL)", <-sigChan)
+	}()
+}
+
+func (d *KubeDNSServer) startSkyDNSServer() {
+	glog.V(0).Infof("Starting SkyDNS server (%v:%v)", d.dnsBindAddress, d.dnsPort)
+	skydnsConfig := &server.Config{
+		Domain:  d.domain,
+		DnsAddr: fmt.Sprintf("%s:%d", d.dnsBindAddress, d.dnsPort),
+	}
+	server.SetDefaults(skydnsConfig)
+	s := server.New(d.kd, skydnsConfig)
+	if err := metrics.Metrics(); err != nil {
+		glog.Fatalf("Skydns metrics error: %s", err)
+	} else if metrics.Port != "" {
+		glog.V(0).Infof("Skydns metrics enabled (%v:%v)", metrics.Path, metrics.Port)
+	} else {
+		glog.V(0).Infof("Skydns metrics not enabled")
+	}
+
+	go s.Run()
+}

vendor/k8s.io/kubernetes/cmd/kube-dns/dns.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 main
+
+import (
+	"github.com/golang/glog"
+	"github.com/spf13/pflag"
+	"k8s.io/kubernetes/cmd/kube-dns/app"
+	"k8s.io/kubernetes/cmd/kube-dns/app/options"
+	_ "k8s.io/kubernetes/pkg/client/metrics/prometheus" // for client metric registration
+	"k8s.io/kubernetes/pkg/util/flag"
+	"k8s.io/kubernetes/pkg/util/logs"
+	"k8s.io/kubernetes/pkg/version"
+	_ "k8s.io/kubernetes/pkg/version/prometheus" // for version metric registration
+	"k8s.io/kubernetes/pkg/version/verflag"
+)
+
+func main() {
+	config := options.NewKubeDNSConfig()
+	config.AddFlags(pflag.CommandLine)
+
+	flag.InitFlags()
+	logs.InitLogs()
+	defer logs.FlushLogs()
+
+	verflag.PrintAndExitIfRequested()
+
+	glog.V(0).Infof("version: %+v", version.Get())
+
+	server := app.NewKubeDNSServerDefault(config)
+	server.Run()
+}