vendor files

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

@@ -0,0 +1,33 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "doc.go",
+        "probe.go",
+    ],
+    importpath = "k8s.io/kubernetes/pkg/probe",
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [
+        ":package-srcs",
+        "//pkg/probe/exec:all-srcs",
+        "//pkg/probe/http:all-srcs",
+        "//pkg/probe/tcp:all-srcs",
+    ],
+    tags = ["automanaged"],
+)

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

@@ -0,0 +1,18 @@
+/*
+Copyright 2015 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 probe contains utilities for health probing, as well as health status information.
+package probe // import "k8s.io/kubernetes/pkg/probe"

vendor/k8s.io/kubernetes/pkg/probe/exec/BUILD

@@ -0,0 +1,39 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+    "go_test",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["exec.go"],
+    importpath = "k8s.io/kubernetes/pkg/probe/exec",
+    deps = [
+        "//pkg/probe:go_default_library",
+        "//vendor/github.com/golang/glog:go_default_library",
+        "//vendor/k8s.io/utils/exec:go_default_library",
+    ],
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = ["exec_test.go"],
+    importpath = "k8s.io/kubernetes/pkg/probe/exec",
+    library = ":go_default_library",
+    deps = ["//pkg/probe:go_default_library"],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+)

vendor/k8s.io/kubernetes/pkg/probe/exec/exec.go

@@ -0,0 +1,51 @@
+/*
+Copyright 2015 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 exec
+
+import (
+	"k8s.io/kubernetes/pkg/probe"
+	"k8s.io/utils/exec"
+
+	"github.com/golang/glog"
+)
+
+func New() ExecProber {
+	return execProber{}
+}
+
+type ExecProber interface {
+	Probe(e exec.Cmd) (probe.Result, string, error)
+}
+
+type execProber struct{}
+
+func (pr execProber) Probe(e exec.Cmd) (probe.Result, string, error) {
+	data, err := e.CombinedOutput()
+	glog.V(4).Infof("Exec probe response: %q", string(data))
+	if err != nil {
+		exit, ok := err.(exec.ExitError)
+		if ok {
+			if exit.ExitStatus() == 0 {
+				return probe.Success, string(data), nil
+			} else {
+				return probe.Failure, string(data), nil
+			}
+		}
+		return probe.Unknown, "", err
+	}
+	return probe.Success, string(data), nil
+}

vendor/k8s.io/kubernetes/pkg/probe/exec/exec_test.go

@@ -0,0 +1,113 @@
+/*
+Copyright 2015 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 exec
+
+import (
+	"fmt"
+	"io"
+	"testing"
+
+	"k8s.io/kubernetes/pkg/probe"
+)
+
+type FakeCmd struct {
+	out    []byte
+	stdout []byte
+	err    error
+}
+
+func (f *FakeCmd) Run() error {
+	return nil
+}
+
+func (f *FakeCmd) CombinedOutput() ([]byte, error) {
+	return f.out, f.err
+}
+
+func (f *FakeCmd) Output() ([]byte, error) {
+	return f.stdout, f.err
+}
+
+func (f *FakeCmd) SetDir(dir string) {}
+
+func (f *FakeCmd) SetStdin(in io.Reader) {}
+
+func (f *FakeCmd) SetStdout(out io.Writer) {}
+
+func (f *FakeCmd) SetStderr(out io.Writer) {}
+
+func (f *FakeCmd) Stop() {}
+
+type fakeExitError struct {
+	exited     bool
+	statusCode int
+}
+
+func (f *fakeExitError) String() string {
+	return f.Error()
+}
+
+func (f *fakeExitError) Error() string {
+	return "fake exit"
+}
+
+func (f *fakeExitError) Exited() bool {
+	return f.exited
+}
+
+func (f *fakeExitError) ExitStatus() int {
+	return f.statusCode
+}
+
+func TestExec(t *testing.T) {
+	prober := New()
+
+	tests := []struct {
+		expectedStatus probe.Result
+		expectError    bool
+		output         string
+		err            error
+	}{
+		// Ok
+		{probe.Success, false, "OK", nil},
+		// Ok
+		{probe.Success, false, "OK", &fakeExitError{true, 0}},
+		// Run returns error
+		{probe.Unknown, true, "", fmt.Errorf("test error")},
+		// Unhealthy
+		{probe.Failure, false, "Fail", &fakeExitError{true, 1}},
+	}
+	for i, test := range tests {
+		fake := FakeCmd{
+			out: []byte(test.output),
+			err: test.err,
+		}
+		status, output, err := prober.Probe(&fake)
+		if status != test.expectedStatus {
+			t.Errorf("[%d] expected %v, got %v", i, test.expectedStatus, status)
+		}
+		if err != nil && test.expectError == false {
+			t.Errorf("[%d] unexpected error: %v", i, err)
+		}
+		if err == nil && test.expectError == true {
+			t.Errorf("[%d] unexpected non-error", i)
+		}
+		if test.output != output {
+			t.Errorf("[%d] expected %s, got %s", i, test.output, output)
+		}
+	}
+}

vendor/k8s.io/kubernetes/pkg/probe/http/BUILD

@@ -0,0 +1,40 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+    "go_test",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["http.go"],
+    importpath = "k8s.io/kubernetes/pkg/probe/http",
+    deps = [
+        "//pkg/probe:go_default_library",
+        "//pkg/version:go_default_library",
+        "//vendor/github.com/golang/glog:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/util/net:go_default_library",
+    ],
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = ["http_test.go"],
+    importpath = "k8s.io/kubernetes/pkg/probe/http",
+    library = ":go_default_library",
+    deps = ["//pkg/probe:go_default_library"],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+)

vendor/k8s.io/kubernetes/pkg/probe/http/http.go

@@ -0,0 +1,101 @@
+/*
+Copyright 2015 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 http
+
+import (
+	"crypto/tls"
+	"fmt"
+	"io/ioutil"
+	"net/http"
+	"net/url"
+	"time"
+
+	utilnet "k8s.io/apimachinery/pkg/util/net"
+	"k8s.io/kubernetes/pkg/probe"
+	"k8s.io/kubernetes/pkg/version"
+
+	"github.com/golang/glog"
+)
+
+func New() HTTPProber {
+	tlsConfig := &tls.Config{InsecureSkipVerify: true}
+	return NewWithTLSConfig(tlsConfig)
+}
+
+// NewWithTLSConfig takes tls config as parameter.
+func NewWithTLSConfig(config *tls.Config) HTTPProber {
+	transport := utilnet.SetTransportDefaults(&http.Transport{TLSClientConfig: config, DisableKeepAlives: true})
+	return httpProber{transport}
+}
+
+type HTTPProber interface {
+	Probe(url *url.URL, headers http.Header, timeout time.Duration) (probe.Result, string, error)
+}
+
+type httpProber struct {
+	transport *http.Transport
+}
+
+// Probe returns a ProbeRunner capable of running an http check.
+func (pr httpProber) Probe(url *url.URL, headers http.Header, timeout time.Duration) (probe.Result, string, error) {
+	return DoHTTPProbe(url, headers, &http.Client{Timeout: timeout, Transport: pr.transport})
+}
+
+type HTTPGetInterface interface {
+	Do(req *http.Request) (*http.Response, error)
+}
+
+// DoHTTPProbe checks if a GET request to the url succeeds.
+// If the HTTP response code is successful (i.e. 400 > code >= 200), it returns Success.
+// If the HTTP response code is unsuccessful or HTTP communication fails, it returns Failure.
+// This is exported because some other packages may want to do direct HTTP probes.
+func DoHTTPProbe(url *url.URL, headers http.Header, client HTTPGetInterface) (probe.Result, string, error) {
+	req, err := http.NewRequest("GET", url.String(), nil)
+	if err != nil {
+		// Convert errors into failures to catch timeouts.
+		return probe.Failure, err.Error(), nil
+	}
+	if _, ok := headers["User-Agent"]; !ok {
+		if headers == nil {
+			headers = http.Header{}
+		}
+		// explicitly set User-Agent so it's not set to default Go value
+		v := version.Get()
+		headers.Set("User-Agent", fmt.Sprintf("kube-probe/%s.%s", v.Major, v.Minor))
+	}
+	req.Header = headers
+	if headers.Get("Host") != "" {
+		req.Host = headers.Get("Host")
+	}
+	res, err := client.Do(req)
+	if err != nil {
+		// Convert errors into failures to catch timeouts.
+		return probe.Failure, err.Error(), nil
+	}
+	defer res.Body.Close()
+	b, err := ioutil.ReadAll(res.Body)
+	if err != nil {
+		return probe.Failure, "", err
+	}
+	body := string(b)
+	if res.StatusCode >= http.StatusOK && res.StatusCode < http.StatusBadRequest {
+		glog.V(4).Infof("Probe succeeded for %s, Response: %v", url.String(), *res)
+		return probe.Success, body, nil
+	}
+	glog.V(4).Infof("Probe failed for %s with request headers %v, response body: %v", url.String(), headers, body)
+	return probe.Failure, fmt.Sprintf("HTTP probe failed with statuscode: %d", res.StatusCode), nil
+}

vendor/k8s.io/kubernetes/pkg/probe/http/http_test.go

@@ -0,0 +1,164 @@
+/*
+Copyright 2015 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 http
+
+import (
+	"fmt"
+	"net"
+	"net/http"
+	"net/http/httptest"
+	"net/url"
+	"strconv"
+	"strings"
+	"testing"
+	"time"
+
+	"k8s.io/kubernetes/pkg/probe"
+)
+
+const FailureCode int = -1
+
+func TestHTTPProbeChecker(t *testing.T) {
+	handleReq := func(s int, body string) func(w http.ResponseWriter, r *http.Request) {
+		return func(w http.ResponseWriter, r *http.Request) {
+			w.WriteHeader(s)
+			w.Write([]byte(body))
+		}
+	}
+
+	// Echo handler that returns the contents of request headers in the body
+	headerEchoHandler := func(w http.ResponseWriter, r *http.Request) {
+		w.WriteHeader(200)
+		output := ""
+		for k, arr := range r.Header {
+			for _, v := range arr {
+				output += fmt.Sprintf("%s: %s\n", k, v)
+			}
+		}
+		w.Write([]byte(output))
+	}
+
+	prober := New()
+	testCases := []struct {
+		handler    func(w http.ResponseWriter, r *http.Request)
+		reqHeaders http.Header
+		health     probe.Result
+		accBody    string
+		notBody    string
+	}{
+		// The probe will be filled in below.  This is primarily testing that an HTTP GET happens.
+		{
+			handler: handleReq(http.StatusOK, "ok body"),
+			health:  probe.Success,
+			accBody: "ok body",
+		},
+		{
+			handler: headerEchoHandler,
+			reqHeaders: http.Header{
+				"X-Muffins-Or-Cupcakes": {"muffins"},
+			},
+			health:  probe.Success,
+			accBody: "X-Muffins-Or-Cupcakes: muffins",
+		},
+		{
+			handler: headerEchoHandler,
+			reqHeaders: http.Header{
+				"User-Agent": {"foo/1.0"},
+			},
+			health:  probe.Success,
+			accBody: "User-Agent: foo/1.0",
+		},
+		{
+			handler: headerEchoHandler,
+			reqHeaders: http.Header{
+				"User-Agent": {""},
+			},
+			health:  probe.Success,
+			notBody: "User-Agent",
+		},
+		{
+			handler:    headerEchoHandler,
+			reqHeaders: http.Header{},
+			health:     probe.Success,
+			accBody:    "User-Agent: kube-probe/",
+		},
+		{
+			// Echo handler that returns the contents of Host in the body
+			handler: func(w http.ResponseWriter, r *http.Request) {
+				w.WriteHeader(200)
+				w.Write([]byte(r.Host))
+			},
+			reqHeaders: http.Header{
+				"Host": {"muffins.cupcakes.org"},
+			},
+			health:  probe.Success,
+			accBody: "muffins.cupcakes.org",
+		},
+		{
+			handler: handleReq(FailureCode, "fail body"),
+			health:  probe.Failure,
+		},
+		{
+			handler: handleReq(http.StatusInternalServerError, "fail body"),
+			health:  probe.Failure,
+		},
+		{
+			handler: func(w http.ResponseWriter, r *http.Request) {
+				time.Sleep(3 * time.Second)
+			},
+			health: probe.Failure,
+		},
+	}
+	for i, test := range testCases {
+		func() {
+			server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+				test.handler(w, r)
+			}))
+			defer server.Close()
+			u, err := url.Parse(server.URL)
+			if err != nil {
+				t.Errorf("case %d: unexpected error: %v", i, err)
+			}
+			_, port, err := net.SplitHostPort(u.Host)
+			if err != nil {
+				t.Errorf("case %d: unexpected error: %v", i, err)
+			}
+			_, err = strconv.Atoi(port)
+			if err != nil {
+				t.Errorf("case %d: unexpected error: %v", i, err)
+			}
+			health, output, err := prober.Probe(u, test.reqHeaders, 1*time.Second)
+			if test.health == probe.Unknown && err == nil {
+				t.Errorf("case %d: expected error", i)
+			}
+			if test.health != probe.Unknown && err != nil {
+				t.Errorf("case %d: unexpected error: %v", i, err)
+			}
+			if health != test.health {
+				t.Errorf("case %d: expected %v, got %v", i, test.health, health)
+			}
+			if health != probe.Failure && test.health != probe.Failure {
+				if !strings.Contains(output, test.accBody) {
+					t.Errorf("Expected response body to contain %v, got %v", test.accBody, output)
+				}
+				if test.notBody != "" && strings.Contains(output, test.notBody) {
+					t.Errorf("Expected response not to contain %v, got %v", test.notBody, output)
+				}
+			}
+		}()
+	}
+}

vendor/k8s.io/kubernetes/pkg/probe/probe.go

@@ -0,0 +1,25 @@
+/*
+Copyright 2015 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 probe
+
+type Result string
+
+const (
+	Success Result = "success"
+	Failure Result = "failure"
+	Unknown Result = "unknown"
+)

vendor/k8s.io/kubernetes/pkg/probe/tcp/BUILD

@@ -0,0 +1,38 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+    "go_test",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["tcp.go"],
+    importpath = "k8s.io/kubernetes/pkg/probe/tcp",
+    deps = [
+        "//pkg/probe:go_default_library",
+        "//vendor/github.com/golang/glog:go_default_library",
+    ],
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = ["tcp_test.go"],
+    importpath = "k8s.io/kubernetes/pkg/probe/tcp",
+    library = ":go_default_library",
+    deps = ["//pkg/probe:go_default_library"],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+)

vendor/k8s.io/kubernetes/pkg/probe/tcp/tcp.go

@@ -0,0 +1,58 @@
+/*
+Copyright 2015 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 tcp
+
+import (
+	"net"
+	"strconv"
+	"time"
+
+	"k8s.io/kubernetes/pkg/probe"
+
+	"github.com/golang/glog"
+)
+
+func New() TCPProber {
+	return tcpProber{}
+}
+
+type TCPProber interface {
+	Probe(host string, port int, timeout time.Duration) (probe.Result, string, error)
+}
+
+type tcpProber struct{}
+
+func (pr tcpProber) Probe(host string, port int, timeout time.Duration) (probe.Result, string, error) {
+	return DoTCPProbe(net.JoinHostPort(host, strconv.Itoa(port)), timeout)
+}
+
+// DoTCPProbe checks that a TCP socket to the address can be opened.
+// If the socket can be opened, it returns Success
+// If the socket fails to open, it returns Failure.
+// This is exported because some other packages may want to do direct TCP probes.
+func DoTCPProbe(addr string, timeout time.Duration) (probe.Result, string, error) {
+	conn, err := net.DialTimeout("tcp", addr, timeout)
+	if err != nil {
+		// Convert errors to failures to handle timeouts.
+		return probe.Failure, err.Error(), nil
+	}
+	err = conn.Close()
+	if err != nil {
+		glog.Errorf("Unexpected error closing TCP probe socket: %v (%#v)", err, err)
+	}
+	return probe.Success, "", nil
+}

vendor/k8s.io/kubernetes/pkg/probe/tcp/tcp_test.go

@@ -0,0 +1,68 @@
+/*
+Copyright 2015 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 tcp
+
+import (
+	"net"
+	"net/http"
+	"net/http/httptest"
+	"strconv"
+	"testing"
+	"time"
+
+	"k8s.io/kubernetes/pkg/probe"
+)
+
+func TestTcpHealthChecker(t *testing.T) {
+	// Setup a test server that responds to probing correctly
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.WriteHeader(http.StatusOK)
+	}))
+	defer server.Close()
+	tHost, tPortStr, err := net.SplitHostPort(server.Listener.Addr().String())
+	if err != nil {
+		t.Errorf("unexpected error: %v", err)
+	}
+	tPort, err := strconv.Atoi(tPortStr)
+	if err != nil {
+		t.Errorf("unexpected error: %v", err)
+	}
+
+	tests := []struct {
+		host string
+		port int
+
+		expectedStatus probe.Result
+		expectedError  error
+	}{
+		// A connection is made and probing would succeed
+		{tHost, tPort, probe.Success, nil},
+		// No connection can be made and probing would fail
+		{tHost, -1, probe.Failure, nil},
+	}
+
+	prober := New()
+	for i, tt := range tests {
+		status, _, err := prober.Probe(tt.host, tt.port, 1*time.Second)
+		if status != tt.expectedStatus {
+			t.Errorf("#%d: expected status=%v, get=%v", i, tt.expectedStatus, status)
+		}
+		if err != tt.expectedError {
+			t.Errorf("#%d: expected error=%v, get=%v", i, tt.expectedError, err)
+		}
+	}
+}