5a6acf85fa
Align the behavior of HTTP-based lifecycle handlers and HTTP-based probers, converging on the probers implementation. This fixes multiple deficiencies in the current implementation of lifecycle handlers surrounding what functionality is available. The functionality is gated by the features.ConsistentHTTPGetHandlers feature gate.
591 lines
16 KiB
Go
591 lines
16 KiB
Go
/*
|
|
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 (
|
|
"bytes"
|
|
"fmt"
|
|
"net"
|
|
"net/http"
|
|
"net/http/httptest"
|
|
"net/url"
|
|
"os"
|
|
"sort"
|
|
"strconv"
|
|
"strings"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/stretchr/testify/assert"
|
|
"github.com/stretchr/testify/require"
|
|
"k8s.io/apimachinery/pkg/util/wait"
|
|
"k8s.io/kubernetes/pkg/probe"
|
|
)
|
|
|
|
const FailureCode int = -1
|
|
|
|
func setEnv(key, value string) func() {
|
|
originalValue := os.Getenv(key)
|
|
os.Setenv(key, value)
|
|
if len(originalValue) > 0 {
|
|
return func() {
|
|
os.Setenv(key, originalValue)
|
|
}
|
|
}
|
|
return func() {}
|
|
}
|
|
|
|
func unsetEnv(key string) func() {
|
|
originalValue := os.Getenv(key)
|
|
os.Unsetenv(key)
|
|
if len(originalValue) > 0 {
|
|
return func() {
|
|
os.Setenv(key, originalValue)
|
|
}
|
|
}
|
|
return func() {}
|
|
}
|
|
|
|
func TestHTTPProbeProxy(t *testing.T) {
|
|
res := "welcome to http probe proxy"
|
|
|
|
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
fmt.Fprint(w, res)
|
|
}))
|
|
defer server.Close()
|
|
|
|
localProxy := server.URL
|
|
|
|
defer setEnv("http_proxy", localProxy)()
|
|
defer setEnv("HTTP_PROXY", localProxy)()
|
|
defer unsetEnv("no_proxy")()
|
|
defer unsetEnv("NO_PROXY")()
|
|
|
|
followNonLocalRedirects := true
|
|
prober := New(followNonLocalRedirects)
|
|
|
|
// take some time to wait server boot
|
|
time.Sleep(2 * time.Second)
|
|
url, err := url.Parse("http://example.com")
|
|
if err != nil {
|
|
t.Errorf("proxy test unexpected error: %v", err)
|
|
}
|
|
|
|
req, err := NewProbeRequest(url, http.Header{})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
_, response, _ := prober.Probe(req, time.Second*3)
|
|
|
|
if response == res {
|
|
t.Errorf("proxy test unexpected error: the probe is using proxy")
|
|
}
|
|
}
|
|
|
|
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))
|
|
}
|
|
|
|
// Handler that returns the number of request headers in the body
|
|
headerCounterHandler := func(w http.ResponseWriter, r *http.Request) {
|
|
w.WriteHeader(200)
|
|
w.Write([]byte(strconv.Itoa(len(r.Header))))
|
|
}
|
|
|
|
// Handler that returns the keys of request headers in the body
|
|
headerKeysNamesHandler := func(w http.ResponseWriter, r *http.Request) {
|
|
w.WriteHeader(200)
|
|
keys := make([]string, 0, len(r.Header))
|
|
for k := range r.Header {
|
|
keys = append(keys, k)
|
|
}
|
|
sort.Strings(keys)
|
|
|
|
w.Write([]byte(strings.Join(keys, "\n")))
|
|
}
|
|
|
|
redirectHandler := func(s int, bad bool) func(w http.ResponseWriter, r *http.Request) {
|
|
return func(w http.ResponseWriter, r *http.Request) {
|
|
if r.URL.Path == "/" {
|
|
http.Redirect(w, r, "/new", s)
|
|
} else if bad && r.URL.Path == "/new" {
|
|
http.Error(w, "", http.StatusInternalServerError)
|
|
}
|
|
}
|
|
}
|
|
|
|
redirectHandlerWithBody := func(s int, body string) func(w http.ResponseWriter, r *http.Request) {
|
|
return func(w http.ResponseWriter, r *http.Request) {
|
|
if r.URL.Path == "/" {
|
|
http.Redirect(w, r, "/new", s)
|
|
} else if r.URL.Path == "/new" {
|
|
w.WriteHeader(s)
|
|
w.Write([]byte(body))
|
|
}
|
|
}
|
|
}
|
|
|
|
followNonLocalRedirects := true
|
|
prober := New(followNonLocalRedirects)
|
|
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: headerCounterHandler,
|
|
reqHeaders: http.Header{},
|
|
health: probe.Success,
|
|
accBody: "3",
|
|
},
|
|
{
|
|
handler: headerKeysNamesHandler,
|
|
reqHeaders: http.Header{},
|
|
health: probe.Success,
|
|
accBody: "Accept\nConnection\nUser-Agent",
|
|
},
|
|
{
|
|
handler: headerEchoHandler,
|
|
reqHeaders: http.Header{
|
|
"Accept-Encoding": {"gzip"},
|
|
},
|
|
health: probe.Success,
|
|
accBody: "Accept-Encoding: gzip",
|
|
},
|
|
{
|
|
handler: headerEchoHandler,
|
|
reqHeaders: http.Header{
|
|
"Accept-Encoding": {"foo"},
|
|
},
|
|
health: probe.Success,
|
|
accBody: "Accept-Encoding: foo",
|
|
},
|
|
{
|
|
handler: headerEchoHandler,
|
|
reqHeaders: http.Header{
|
|
"Accept-Encoding": {""},
|
|
},
|
|
health: probe.Success,
|
|
accBody: "Accept-Encoding: \n",
|
|
},
|
|
{
|
|
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/",
|
|
},
|
|
{
|
|
handler: headerEchoHandler,
|
|
reqHeaders: http.Header{
|
|
"User-Agent": {"foo/1.0"},
|
|
"Accept": {"text/html"},
|
|
},
|
|
health: probe.Success,
|
|
accBody: "Accept: text/html",
|
|
},
|
|
{
|
|
handler: headerEchoHandler,
|
|
reqHeaders: http.Header{
|
|
"User-Agent": {"foo/1.0"},
|
|
"Accept": {"foo/*"},
|
|
},
|
|
health: probe.Success,
|
|
accBody: "User-Agent: foo/1.0",
|
|
},
|
|
{
|
|
handler: headerEchoHandler,
|
|
reqHeaders: http.Header{
|
|
"X-Muffins-Or-Cupcakes": {"muffins"},
|
|
"Accept": {"foo/*"},
|
|
},
|
|
health: probe.Success,
|
|
accBody: "X-Muffins-Or-Cupcakes: muffins",
|
|
},
|
|
{
|
|
handler: headerEchoHandler,
|
|
reqHeaders: http.Header{
|
|
"Accept": {"foo/*"},
|
|
},
|
|
health: probe.Success,
|
|
accBody: "Accept: foo/*",
|
|
},
|
|
{
|
|
handler: headerEchoHandler,
|
|
reqHeaders: http.Header{
|
|
"Accept": {""},
|
|
},
|
|
health: probe.Success,
|
|
notBody: "Accept:",
|
|
},
|
|
{
|
|
handler: headerEchoHandler,
|
|
reqHeaders: http.Header{
|
|
"User-Agent": {"foo/1.0"},
|
|
"Accept": {""},
|
|
},
|
|
health: probe.Success,
|
|
notBody: "Accept:",
|
|
},
|
|
{
|
|
handler: headerEchoHandler,
|
|
reqHeaders: http.Header{},
|
|
health: probe.Success,
|
|
accBody: "Accept: */*",
|
|
},
|
|
{
|
|
// 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,
|
|
},
|
|
{
|
|
handler: redirectHandler(http.StatusMovedPermanently, false), // 301
|
|
health: probe.Success,
|
|
},
|
|
{
|
|
handler: redirectHandler(http.StatusMovedPermanently, true), // 301
|
|
health: probe.Failure,
|
|
},
|
|
{
|
|
handler: redirectHandler(http.StatusFound, false), // 302
|
|
health: probe.Success,
|
|
},
|
|
{
|
|
handler: redirectHandler(http.StatusFound, true), // 302
|
|
health: probe.Failure,
|
|
},
|
|
{
|
|
handler: redirectHandler(http.StatusTemporaryRedirect, false), // 307
|
|
health: probe.Success,
|
|
},
|
|
{
|
|
handler: redirectHandler(http.StatusTemporaryRedirect, true), // 307
|
|
health: probe.Failure,
|
|
},
|
|
{
|
|
handler: redirectHandler(http.StatusPermanentRedirect, false), // 308
|
|
health: probe.Success,
|
|
},
|
|
{
|
|
handler: redirectHandler(http.StatusPermanentRedirect, true), // 308
|
|
health: probe.Failure,
|
|
},
|
|
{
|
|
handler: redirectHandlerWithBody(http.StatusPermanentRedirect, ""), // redirect with empty body
|
|
health: probe.Warning,
|
|
accBody: "Probe terminated redirects, Response body:",
|
|
},
|
|
{
|
|
handler: redirectHandlerWithBody(http.StatusPermanentRedirect, "ok body"), // redirect with body
|
|
health: probe.Warning,
|
|
accBody: "Probe terminated redirects, Response body: ok body",
|
|
},
|
|
}
|
|
for i, test := range testCases {
|
|
t.Run(fmt.Sprintf("case-%2d", i), func(t *testing.T) {
|
|
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)
|
|
}
|
|
req, err := NewProbeRequest(u, test.reqHeaders)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
health, output, err := prober.Probe(req, 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)
|
|
}
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestHTTPProbeChecker_NonLocalRedirects(t *testing.T) {
|
|
handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
switch r.URL.Path {
|
|
case "/redirect":
|
|
loc, _ := url.QueryUnescape(r.URL.Query().Get("loc"))
|
|
http.Redirect(w, r, loc, http.StatusFound)
|
|
case "/loop":
|
|
http.Redirect(w, r, "/loop", http.StatusFound)
|
|
case "/success":
|
|
w.WriteHeader(http.StatusOK)
|
|
default:
|
|
http.Error(w, "", http.StatusInternalServerError)
|
|
}
|
|
})
|
|
server := httptest.NewServer(handler)
|
|
defer server.Close()
|
|
|
|
newportServer := httptest.NewServer(handler)
|
|
defer newportServer.Close()
|
|
|
|
testCases := map[string]struct {
|
|
redirect string
|
|
expectLocalResult probe.Result
|
|
expectNonLocalResult probe.Result
|
|
}{
|
|
"local success": {"/success", probe.Success, probe.Success},
|
|
"local fail": {"/fail", probe.Failure, probe.Failure},
|
|
"newport success": {newportServer.URL + "/success", probe.Success, probe.Success},
|
|
"newport fail": {newportServer.URL + "/fail", probe.Failure, probe.Failure},
|
|
"bogus nonlocal": {"http://0.0.0.0/fail", probe.Warning, probe.Failure},
|
|
"redirect loop": {"/loop", probe.Failure, probe.Failure},
|
|
}
|
|
for desc, test := range testCases {
|
|
t.Run(desc+"-local", func(t *testing.T) {
|
|
followNonLocalRedirects := false
|
|
prober := New(followNonLocalRedirects)
|
|
target, err := url.Parse(server.URL + "/redirect?loc=" + url.QueryEscape(test.redirect))
|
|
require.NoError(t, err)
|
|
req, err := NewProbeRequest(target, nil)
|
|
require.NoError(t, err)
|
|
result, _, _ := prober.Probe(req, wait.ForeverTestTimeout)
|
|
assert.Equal(t, test.expectLocalResult, result)
|
|
})
|
|
t.Run(desc+"-nonlocal", func(t *testing.T) {
|
|
followNonLocalRedirects := true
|
|
prober := New(followNonLocalRedirects)
|
|
target, err := url.Parse(server.URL + "/redirect?loc=" + url.QueryEscape(test.redirect))
|
|
require.NoError(t, err)
|
|
req, err := NewProbeRequest(target, nil)
|
|
require.NoError(t, err)
|
|
result, _, _ := prober.Probe(req, wait.ForeverTestTimeout)
|
|
assert.Equal(t, test.expectNonLocalResult, result)
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestHTTPProbeChecker_HostHeaderPreservedAfterRedirect(t *testing.T) {
|
|
successHostHeader := "www.success.com"
|
|
failHostHeader := "www.fail.com"
|
|
|
|
handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
switch r.URL.Path {
|
|
case "/redirect":
|
|
http.Redirect(w, r, "/success", http.StatusFound)
|
|
case "/success":
|
|
if r.Host == successHostHeader {
|
|
w.WriteHeader(http.StatusOK)
|
|
} else {
|
|
http.Error(w, "", http.StatusBadRequest)
|
|
}
|
|
default:
|
|
http.Error(w, "", http.StatusInternalServerError)
|
|
}
|
|
})
|
|
server := httptest.NewServer(handler)
|
|
defer server.Close()
|
|
|
|
testCases := map[string]struct {
|
|
hostHeader string
|
|
expectedResult probe.Result
|
|
}{
|
|
"success": {successHostHeader, probe.Success},
|
|
"fail": {failHostHeader, probe.Failure},
|
|
}
|
|
for desc, test := range testCases {
|
|
headers := http.Header{}
|
|
headers.Add("Host", test.hostHeader)
|
|
t.Run(desc+"local", func(t *testing.T) {
|
|
followNonLocalRedirects := false
|
|
prober := New(followNonLocalRedirects)
|
|
target, err := url.Parse(server.URL + "/redirect")
|
|
require.NoError(t, err)
|
|
req, err := NewProbeRequest(target, headers)
|
|
require.NoError(t, err)
|
|
result, _, _ := prober.Probe(req, wait.ForeverTestTimeout)
|
|
assert.Equal(t, test.expectedResult, result)
|
|
})
|
|
t.Run(desc+"nonlocal", func(t *testing.T) {
|
|
followNonLocalRedirects := true
|
|
prober := New(followNonLocalRedirects)
|
|
target, err := url.Parse(server.URL + "/redirect")
|
|
require.NoError(t, err)
|
|
req, err := NewProbeRequest(target, headers)
|
|
require.NoError(t, err)
|
|
result, _, _ := prober.Probe(req, wait.ForeverTestTimeout)
|
|
assert.Equal(t, test.expectedResult, result)
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestHTTPProbeChecker_PayloadTruncated(t *testing.T) {
|
|
successHostHeader := "www.success.com"
|
|
oversizePayload := bytes.Repeat([]byte("a"), maxRespBodyLength+1)
|
|
truncatedPayload := bytes.Repeat([]byte("a"), maxRespBodyLength)
|
|
|
|
handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
switch r.URL.Path {
|
|
case "/success":
|
|
if r.Host == successHostHeader {
|
|
w.WriteHeader(http.StatusOK)
|
|
w.Write(oversizePayload)
|
|
} else {
|
|
http.Error(w, "", http.StatusBadRequest)
|
|
}
|
|
default:
|
|
http.Error(w, "", http.StatusInternalServerError)
|
|
}
|
|
})
|
|
server := httptest.NewServer(handler)
|
|
defer server.Close()
|
|
|
|
headers := http.Header{}
|
|
headers.Add("Host", successHostHeader)
|
|
t.Run("truncated payload", func(t *testing.T) {
|
|
prober := New(false)
|
|
target, err := url.Parse(server.URL + "/success")
|
|
require.NoError(t, err)
|
|
req, err := NewProbeRequest(target, headers)
|
|
require.NoError(t, err)
|
|
result, body, err := prober.Probe(req, wait.ForeverTestTimeout)
|
|
assert.NoError(t, err)
|
|
assert.Equal(t, probe.Success, result)
|
|
assert.Equal(t, string(truncatedPayload), body)
|
|
})
|
|
}
|
|
|
|
func TestHTTPProbeChecker_PayloadNormal(t *testing.T) {
|
|
successHostHeader := "www.success.com"
|
|
normalPayload := bytes.Repeat([]byte("a"), maxRespBodyLength-1)
|
|
|
|
handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
switch r.URL.Path {
|
|
case "/success":
|
|
if r.Host == successHostHeader {
|
|
w.WriteHeader(http.StatusOK)
|
|
w.Write(normalPayload)
|
|
} else {
|
|
http.Error(w, "", http.StatusBadRequest)
|
|
}
|
|
default:
|
|
http.Error(w, "", http.StatusInternalServerError)
|
|
}
|
|
})
|
|
server := httptest.NewServer(handler)
|
|
defer server.Close()
|
|
|
|
headers := http.Header{}
|
|
headers.Add("Host", successHostHeader)
|
|
t.Run("normal payload", func(t *testing.T) {
|
|
prober := New(false)
|
|
target, err := url.Parse(server.URL + "/success")
|
|
require.NoError(t, err)
|
|
req, err := NewProbeRequest(target, headers)
|
|
require.NoError(t, err)
|
|
result, body, err := prober.Probe(req, wait.ForeverTestTimeout)
|
|
assert.NoError(t, err)
|
|
assert.Equal(t, probe.Success, result)
|
|
assert.Equal(t, string(normalPayload), body)
|
|
})
|
|
}
|