github/kubernetes
1
0
Fork 0
mirror of https://github.com/k3s-io/kubernetes.git synced 2025-07-28 05:57:25 +00:00
Code Issues Projects Releases Wiki Activity

Merge pull request #81973 from oomichi/replace-e2elog-framework-r-p

Browse Source 
Use log functions of core framework on sub [p-s]
This commit is contained in:
Kubernetes Prow Robot 2019-08-29 07:28:09 -07:00 committed by GitHub
commit fd6c380047
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
13 changed files with 128 additions and 139 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
test/e2e/framework/profile_gatherer.go
View File

@ -26,7 +26,6 @@ import (
"sync" "sync"
"time" "time"
e2elog "k8s.io/kubernetes/test/e2e/framework/log"
e2essh "k8s.io/kubernetes/test/e2e/framework/ssh" e2essh "k8s.io/kubernetes/test/e2e/framework/ssh"
) )
@ -182,7 +181,7 @@ func GatherCPUProfileForSeconds(componentName string, profileBaseName string, se
defer wg.Done() defer wg.Done()
} }
if err := gatherProfile(componentName, profileBaseName, fmt.Sprintf("profile?seconds=%v", seconds)); err != nil { if err := gatherProfile(componentName, profileBaseName, fmt.Sprintf("profile?seconds=%v", seconds)); err != nil {
e2elog.Logf("Failed to gather %v CPU profile: %v", componentName, err) Logf("Failed to gather %v CPU profile: %v", componentName, err)
} }
} }
@ -192,7 +191,7 @@ func GatherMemoryProfile(componentName string, profileBaseName string, wg *sync.
defer wg.Done() defer wg.Done()
} }
if err := gatherProfile(componentName, profileBaseName, "heap"); err != nil { if err := gatherProfile(componentName, profileBaseName, "heap"); err != nil {
e2elog.Logf("Failed to gather %v memory profile: %v", componentName, err) Logf("Failed to gather %v memory profile: %v", componentName, err)
} }
} }

1
test/e2e/framework/replicaset/BUILD
View File

@ -18,7 +18,6 @@ go_library(
"//staging/src/k8s.io/client-go/kubernetes:go_default_library", "//staging/src/k8s.io/client-go/kubernetes:go_default_library",
"//staging/src/k8s.io/client-go/kubernetes/typed/apps/v1:go_default_library", "//staging/src/k8s.io/client-go/kubernetes/typed/apps/v1:go_default_library",
"//test/e2e/framework:go_default_library", "//test/e2e/framework:go_default_library",
"//test/e2e/framework/log:go_default_library",
"//test/utils:go_default_library", "//test/utils:go_default_library",
"//vendor/github.com/onsi/ginkgo:go_default_library", "//vendor/github.com/onsi/ginkgo:go_default_library",
], ],

3
test/e2e/framework/replicaset/rest.go
View File

@ -24,13 +24,12 @@ import (
clientset "k8s.io/client-go/kubernetes" clientset "k8s.io/client-go/kubernetes"
deploymentutil "k8s.io/kubernetes/pkg/controller/deployment/util" deploymentutil "k8s.io/kubernetes/pkg/controller/deployment/util"
"k8s.io/kubernetes/test/e2e/framework" "k8s.io/kubernetes/test/e2e/framework"
e2elog "k8s.io/kubernetes/test/e2e/framework/log"
testutils "k8s.io/kubernetes/test/utils" testutils "k8s.io/kubernetes/test/utils"
) )
// UpdateReplicaSetWithRetries updates replicaset template with retries. // UpdateReplicaSetWithRetries updates replicaset template with retries.
func UpdateReplicaSetWithRetries(c clientset.Interface, namespace, name string, applyUpdate testutils.UpdateReplicaSetFunc) (*appsv1.ReplicaSet, error) { func UpdateReplicaSetWithRetries(c clientset.Interface, namespace, name string, applyUpdate testutils.UpdateReplicaSetFunc) (*appsv1.ReplicaSet, error) {
return testutils.UpdateReplicaSetWithRetries(c, namespace, name, applyUpdate, e2elog.Logf, framework.Poll, framework.PollShortTimeout) return testutils.UpdateReplicaSetWithRetries(c, namespace, name, applyUpdate, framework.Logf, framework.Poll, framework.PollShortTimeout)
} }
// CheckNewRSAnnotations check if the new RS's annotation is as expected // CheckNewRSAnnotations check if the new RS's annotation is as expected

1
test/e2e/framework/service/BUILD
View File

@ -36,7 +36,6 @@ go_library(
"//staging/src/k8s.io/client-go/util/retry:go_default_library", "//staging/src/k8s.io/client-go/util/retry:go_default_library",
"//staging/src/k8s.io/cloud-provider/service/helpers:go_default_library", "//staging/src/k8s.io/cloud-provider/service/helpers:go_default_library",
"//test/e2e/framework:go_default_library", "//test/e2e/framework:go_default_library",
"//test/e2e/framework/log:go_default_library",
"//test/e2e/framework/node:go_default_library", "//test/e2e/framework/node:go_default_library",
"//test/e2e/framework/pod:go_default_library", "//test/e2e/framework/pod:go_default_library",
"//test/e2e/framework/ssh:go_default_library", "//test/e2e/framework/ssh:go_default_library",

8
test/e2e/framework/service/affinity_checker.go
View File

@ -17,7 +17,7 @@ limitations under the License.
package service package service
import ( import (
e2elog "k8s.io/kubernetes/test/e2e/framework/log" "k8s.io/kubernetes/test/e2e/framework"
) )
// affinityTracker tracks the destination of a request for the affinity tests. // affinityTracker tracks the destination of a request for the affinity tests.
@ -28,7 +28,7 @@ type affinityTracker struct {
// Record the response going to a given host. // Record the response going to a given host.
func (at *affinityTracker) recordHost(host string) { func (at *affinityTracker) recordHost(host string) {
at.hostTrace = append(at.hostTrace, host) at.hostTrace = append(at.hostTrace, host)
e2elog.Logf("Received response from host: %s", host) framework.Logf("Received response from host: %s", host)
} }
// Check that we got a constant count requests going to the same host. // Check that we got a constant count requests going to the same host.
@ -51,6 +51,6 @@ func (at *affinityTracker) checkHostTrace(count int) (fulfilled, affinityHolds b
} }
func checkAffinityFailed(tracker affinityTracker, err string) { func checkAffinityFailed(tracker affinityTracker, err string) {
e2elog.Logf("%v", tracker.hostTrace) framework.Logf("%v", tracker.hostTrace)
e2elog.Failf(err) framework.Failf(err)
} }

17
test/e2e/framework/service/hostname.go
View File

@ -30,7 +30,6 @@ import (
"k8s.io/apimachinery/pkg/util/sets" "k8s.io/apimachinery/pkg/util/sets"
clientset "k8s.io/client-go/kubernetes" clientset "k8s.io/client-go/kubernetes"
"k8s.io/kubernetes/test/e2e/framework" "k8s.io/kubernetes/test/e2e/framework"
e2elog "k8s.io/kubernetes/test/e2e/framework/log"
e2epod "k8s.io/kubernetes/test/e2e/framework/pod" e2epod "k8s.io/kubernetes/test/e2e/framework/pod"
e2essh "k8s.io/kubernetes/test/e2e/framework/ssh" e2essh "k8s.io/kubernetes/test/e2e/framework/ssh"
testutils "k8s.io/kubernetes/test/utils" testutils "k8s.io/kubernetes/test/utils"
@ -118,22 +117,22 @@ func VerifyServeHostnameServiceUp(c clientset.Interface, ns, host string, expect
// verify service from node // verify service from node
func() string { func() string {
cmd := "set -e; " + buildCommand("wget -q --timeout=0.2 --tries=1 -O -") cmd := "set -e; " + buildCommand("wget -q --timeout=0.2 --tries=1 -O -")
e2elog.Logf("Executing cmd %q on host %v", cmd, host) framework.Logf("Executing cmd %q on host %v", cmd, host)
result, err := e2essh.SSH(cmd, host, framework.TestContext.Provider) result, err := e2essh.SSH(cmd, host, framework.TestContext.Provider)
if err != nil || result.Code != 0 { if err != nil || result.Code != 0 {
e2essh.LogResult(result) e2essh.LogResult(result)
e2elog.Logf("error while SSH-ing to node: %v", err) framework.Logf("error while SSH-ing to node: %v", err)
} }
return result.Stdout return result.Stdout
}, },
// verify service from pod // verify service from pod
func() string { func() string {
cmd := buildCommand("wget -q -T 1 -O -") cmd := buildCommand("wget -q -T 1 -O -")
e2elog.Logf("Executing cmd %q in pod %v/%v", cmd, ns, execPod.Name) framework.Logf("Executing cmd %q in pod %v/%v", cmd, ns, execPod.Name)
// TODO: Use exec-over-http via the netexec pod instead of kubectl exec. // TODO: Use exec-over-http via the netexec pod instead of kubectl exec.
output, err := framework.RunHostCmd(ns, execPod.Name, cmd) output, err := framework.RunHostCmd(ns, execPod.Name, cmd)
if err != nil { if err != nil {
e2elog.Logf("error while kubectl execing %q in pod %v/%v: %v\nOutput: %v", cmd, ns, execPod.Name, err, output) framework.Logf("error while kubectl execing %q in pod %v/%v: %v\nOutput: %v", cmd, ns, execPod.Name, err, output)
} }
return output return output
}, },
@ -159,12 +158,12 @@ func VerifyServeHostnameServiceUp(c clientset.Interface, ns, host string, expect
// and we need a better way to track how often it occurs. // and we need a better way to track how often it occurs.
if gotEndpoints.IsSuperset(expectedEndpoints) { if gotEndpoints.IsSuperset(expectedEndpoints) {
if !gotEndpoints.Equal(expectedEndpoints) { if !gotEndpoints.Equal(expectedEndpoints) {
e2elog.Logf("Ignoring unexpected output wgetting endpoints of service %s: %v", serviceIP, gotEndpoints.Difference(expectedEndpoints)) framework.Logf("Ignoring unexpected output wgetting endpoints of service %s: %v", serviceIP, gotEndpoints.Difference(expectedEndpoints))
} }
passed = true passed = true
break break
} }
e2elog.Logf("Unable to reach the following endpoints of service %s: %v", serviceIP, expectedEndpoints.Difference(gotEndpoints)) framework.Logf("Unable to reach the following endpoints of service %s: %v", serviceIP, expectedEndpoints.Difference(gotEndpoints))
} }
if !passed { if !passed {
// Sort the lists so they're easier to visually diff. // Sort the lists so they're easier to visually diff.
@ -191,12 +190,12 @@ func VerifyServeHostnameServiceDown(c clientset.Interface, host string, serviceI
result, err := e2essh.SSH(command, host, framework.TestContext.Provider) result, err := e2essh.SSH(command, host, framework.TestContext.Provider)
if err != nil { if err != nil {
e2essh.LogResult(result) e2essh.LogResult(result)
e2elog.Logf("error while SSH-ing to node: %v", err) framework.Logf("error while SSH-ing to node: %v", err)
} }
if result.Code != 99 { if result.Code != 99 {
return nil return nil
} }
e2elog.Logf("service still alive - still waiting") framework.Logf("service still alive - still waiting")
} }
return fmt.Errorf("waiting for service to be down timed out") return fmt.Errorf("waiting for service to be down timed out")
} }

113
test/e2e/framework/service/jig.go
View File

@ -46,7 +46,6 @@ import (
api "k8s.io/kubernetes/pkg/apis/core" api "k8s.io/kubernetes/pkg/apis/core"
"k8s.io/kubernetes/pkg/registry/core/service/portallocator" "k8s.io/kubernetes/pkg/registry/core/service/portallocator"
"k8s.io/kubernetes/test/e2e/framework" "k8s.io/kubernetes/test/e2e/framework"
e2elog "k8s.io/kubernetes/test/e2e/framework/log"
e2enode "k8s.io/kubernetes/test/e2e/framework/node" e2enode "k8s.io/kubernetes/test/e2e/framework/node"
e2epod "k8s.io/kubernetes/test/e2e/framework/pod" e2epod "k8s.io/kubernetes/test/e2e/framework/pod"
testutils "k8s.io/kubernetes/test/utils" testutils "k8s.io/kubernetes/test/utils"
@ -111,7 +110,7 @@ func (j *TestJig) CreateTCPServiceWithPort(namespace string, tweak func(svc *v1.
} }
result, err := j.Client.CoreV1().Services(namespace).Create(svc) result, err := j.Client.CoreV1().Services(namespace).Create(svc)
if err != nil { if err != nil {
e2elog.Failf("Failed to create TCP Service %q: %v", svc.Name, err) framework.Failf("Failed to create TCP Service %q: %v", svc.Name, err)
} }
return result return result
} }
@ -126,7 +125,7 @@ func (j *TestJig) CreateTCPServiceOrFail(namespace string, tweak func(svc *v1.Se
} }
result, err := j.Client.CoreV1().Services(namespace).Create(svc) result, err := j.Client.CoreV1().Services(namespace).Create(svc)
if err != nil { if err != nil {
e2elog.Failf("Failed to create TCP Service %q: %v", svc.Name, err) framework.Failf("Failed to create TCP Service %q: %v", svc.Name, err)
} }
return result return result
} }
@ -141,7 +140,7 @@ func (j *TestJig) CreateUDPServiceOrFail(namespace string, tweak func(svc *v1.Se
} }
result, err := j.Client.CoreV1().Services(namespace).Create(svc) result, err := j.Client.CoreV1().Services(namespace).Create(svc)
if err != nil { if err != nil {
e2elog.Failf("Failed to create UDP Service %q: %v", svc.Name, err) framework.Failf("Failed to create UDP Service %q: %v", svc.Name, err)
} }
return result return result
} }
@ -166,7 +165,7 @@ func (j *TestJig) CreateExternalNameServiceOrFail(namespace string, tweak func(s
} }
result, err := j.Client.CoreV1().Services(namespace).Create(svc) result, err := j.Client.CoreV1().Services(namespace).Create(svc)
if err != nil { if err != nil {
e2elog.Failf("Failed to create ExternalName Service %q: %v", svc.Name, err) framework.Failf("Failed to create ExternalName Service %q: %v", svc.Name, err)
} }
return result return result
} }
@ -274,10 +273,10 @@ func (j *TestJig) GetEndpointNodes(svc *v1.Service) map[string][]string {
nodes := j.GetNodes(MaxNodesForEndpointsTests) nodes := j.GetNodes(MaxNodesForEndpointsTests)
endpoints, err := j.Client.CoreV1().Endpoints(svc.Namespace).Get(svc.Name, metav1.GetOptions{}) endpoints, err := j.Client.CoreV1().Endpoints(svc.Namespace).Get(svc.Name, metav1.GetOptions{})
if err != nil { if err != nil {
e2elog.Failf("Get endpoints for service %s/%s failed (%s)", svc.Namespace, svc.Name, err) framework.Failf("Get endpoints for service %s/%s failed (%s)", svc.Namespace, svc.Name, err)
} }
if len(endpoints.Subsets) == 0 { if len(endpoints.Subsets) == 0 {
e2elog.Failf("Endpoint has no subsets, cannot determine node addresses.") framework.Failf("Endpoint has no subsets, cannot determine node addresses.")
} }
epNodes := sets.NewString() epNodes := sets.NewString()
for _, ss := range endpoints.Subsets { for _, ss := range endpoints.Subsets {
@ -322,22 +321,22 @@ func (j *TestJig) WaitForEndpointOnNode(namespace, serviceName, nodeName string)
err := wait.PollImmediate(framework.Poll, LoadBalancerCreateTimeoutDefault, func() (bool, error) { err := wait.PollImmediate(framework.Poll, LoadBalancerCreateTimeoutDefault, func() (bool, error) {
endpoints, err := j.Client.CoreV1().Endpoints(namespace).Get(serviceName, metav1.GetOptions{}) endpoints, err := j.Client.CoreV1().Endpoints(namespace).Get(serviceName, metav1.GetOptions{})
if err != nil { if err != nil {
e2elog.Logf("Get endpoints for service %s/%s failed (%s)", namespace, serviceName, err) framework.Logf("Get endpoints for service %s/%s failed (%s)", namespace, serviceName, err)
return false, nil return false, nil
} }
if len(endpoints.Subsets) == 0 { if len(endpoints.Subsets) == 0 {
e2elog.Logf("Expect endpoints with subsets, got none.") framework.Logf("Expect endpoints with subsets, got none.")
return false, nil return false, nil
} }
// TODO: Handle multiple endpoints // TODO: Handle multiple endpoints
if len(endpoints.Subsets[0].Addresses) == 0 { if len(endpoints.Subsets[0].Addresses) == 0 {
e2elog.Logf("Expected Ready endpoints - found none") framework.Logf("Expected Ready endpoints - found none")
return false, nil return false, nil
} }
epHostName := *endpoints.Subsets[0].Addresses[0].NodeName epHostName := *endpoints.Subsets[0].Addresses[0].NodeName
e2elog.Logf("Pod for service %s/%s is on node %s", namespace, serviceName, epHostName) framework.Logf("Pod for service %s/%s is on node %s", namespace, serviceName, epHostName)
if epHostName != nodeName { if epHostName != nodeName {
e2elog.Logf("Found endpoint on wrong node, expected %v, got %v", nodeName, epHostName) framework.Logf("Found endpoint on wrong node, expected %v, got %v", nodeName, epHostName)
return false, nil return false, nil
} }
return true, nil return true, nil
@ -398,19 +397,19 @@ func (j *TestJig) WaitForAvailableEndpoint(namespace, serviceName string, timeou
// SanityCheckService performs sanity checks on the given service // SanityCheckService performs sanity checks on the given service
func (j *TestJig) SanityCheckService(svc *v1.Service, svcType v1.ServiceType) { func (j *TestJig) SanityCheckService(svc *v1.Service, svcType v1.ServiceType) {
if svc.Spec.Type != svcType { if svc.Spec.Type != svcType {
e2elog.Failf("unexpected Spec.Type (%s) for service, expected %s", svc.Spec.Type, svcType) framework.Failf("unexpected Spec.Type (%s) for service, expected %s", svc.Spec.Type, svcType)
} }
if svcType != v1.ServiceTypeExternalName { if svcType != v1.ServiceTypeExternalName {
if svc.Spec.ExternalName != "" { if svc.Spec.ExternalName != "" {
e2elog.Failf("unexpected Spec.ExternalName (%s) for service, expected empty", svc.Spec.ExternalName) framework.Failf("unexpected Spec.ExternalName (%s) for service, expected empty", svc.Spec.ExternalName)
} }
if svc.Spec.ClusterIP != api.ClusterIPNone && svc.Spec.ClusterIP == "" { if svc.Spec.ClusterIP != api.ClusterIPNone && svc.Spec.ClusterIP == "" {
e2elog.Failf("didn't get ClusterIP for non-ExternamName service") framework.Failf("didn't get ClusterIP for non-ExternamName service")
} }
} else { } else {
if svc.Spec.ClusterIP != "" { if svc.Spec.ClusterIP != "" {
e2elog.Failf("unexpected Spec.ClusterIP (%s) for ExternamName service, expected empty", svc.Spec.ClusterIP) framework.Failf("unexpected Spec.ClusterIP (%s) for ExternamName service, expected empty", svc.Spec.ClusterIP)
} }
} }
@ -421,11 +420,11 @@ func (j *TestJig) SanityCheckService(svc *v1.Service, svcType v1.ServiceType) {
for i, port := range svc.Spec.Ports { for i, port := range svc.Spec.Ports {
hasNodePort := (port.NodePort != 0) hasNodePort := (port.NodePort != 0)
if hasNodePort != expectNodePorts { if hasNodePort != expectNodePorts {
e2elog.Failf("unexpected Spec.Ports[%d].NodePort (%d) for service", i, port.NodePort) framework.Failf("unexpected Spec.Ports[%d].NodePort (%d) for service", i, port.NodePort)
} }
if hasNodePort { if hasNodePort {
if !NodePortRange.Contains(int(port.NodePort)) { if !NodePortRange.Contains(int(port.NodePort)) {
e2elog.Failf("out-of-range nodePort (%d) for service", port.NodePort) framework.Failf("out-of-range nodePort (%d) for service", port.NodePort)
} }
} }
} }
@ -435,12 +434,12 @@ func (j *TestJig) SanityCheckService(svc *v1.Service, svcType v1.ServiceType) {
} }
hasIngress := len(svc.Status.LoadBalancer.Ingress) != 0 hasIngress := len(svc.Status.LoadBalancer.Ingress) != 0
if hasIngress != expectIngress { if hasIngress != expectIngress {
e2elog.Failf("unexpected number of Status.LoadBalancer.Ingress (%d) for service", len(svc.Status.LoadBalancer.Ingress)) framework.Failf("unexpected number of Status.LoadBalancer.Ingress (%d) for service", len(svc.Status.LoadBalancer.Ingress))
} }
if hasIngress { if hasIngress {
for i, ing := range svc.Status.LoadBalancer.Ingress { for i, ing := range svc.Status.LoadBalancer.Ingress {
if ing.IP == "" && ing.Hostname == "" { if ing.IP == "" && ing.Hostname == "" {
e2elog.Failf("unexpected Status.LoadBalancer.Ingress[%d] for service: %#v", i, ing) framework.Failf("unexpected Status.LoadBalancer.Ingress[%d] for service: %#v", i, ing)
} }
} }
} }
@ -473,14 +472,14 @@ func (j *TestJig) UpdateService(namespace, name string, update func(*v1.Service)
func (j *TestJig) UpdateServiceOrFail(namespace, name string, update func(*v1.Service)) *v1.Service { func (j *TestJig) UpdateServiceOrFail(namespace, name string, update func(*v1.Service)) *v1.Service {
svc, err := j.UpdateService(namespace, name, update) svc, err := j.UpdateService(namespace, name, update)
if err != nil { if err != nil {
e2elog.Failf(err.Error()) framework.Failf(err.Error())
} }
return svc return svc
} }
// WaitForNewIngressIPOrFail waits for the given service to get a new ingress IP, or fails after the given timeout // WaitForNewIngressIPOrFail waits for the given service to get a new ingress IP, or fails after the given timeout
func (j *TestJig) WaitForNewIngressIPOrFail(namespace, name, existingIP string, timeout time.Duration) *v1.Service { func (j *TestJig) WaitForNewIngressIPOrFail(namespace, name, existingIP string, timeout time.Duration) *v1.Service {
e2elog.Logf("Waiting up to %v for service %q to get a new ingress IP", timeout, name) framework.Logf("Waiting up to %v for service %q to get a new ingress IP", timeout, name)
service := j.waitForConditionOrFail(namespace, name, timeout, "have a new ingress IP", func(svc *v1.Service) bool { service := j.waitForConditionOrFail(namespace, name, timeout, "have a new ingress IP", func(svc *v1.Service) bool {
if len(svc.Status.LoadBalancer.Ingress) == 0 { if len(svc.Status.LoadBalancer.Ingress) == 0 {
return false return false
@ -506,21 +505,21 @@ func (j *TestJig) ChangeServiceNodePortOrFail(namespace, name string, initial in
s.Spec.Ports[0].NodePort = int32(newPort) s.Spec.Ports[0].NodePort = int32(newPort)
}) })
if err != nil && strings.Contains(err.Error(), portallocator.ErrAllocated.Error()) { if err != nil && strings.Contains(err.Error(), portallocator.ErrAllocated.Error()) {
e2elog.Logf("tried nodePort %d, but it is in use, will try another", newPort) framework.Logf("tried nodePort %d, but it is in use, will try another", newPort)
continue continue
} }
// Otherwise err was nil or err was a real error // Otherwise err was nil or err was a real error
break break
} }
if err != nil { if err != nil {
e2elog.Failf("Could not change the nodePort: %v", err) framework.Failf("Could not change the nodePort: %v", err)
} }
return service return service
} }
// WaitForLoadBalancerOrFail waits the given service to have a LoadBalancer, or fails after the given timeout // WaitForLoadBalancerOrFail waits the given service to have a LoadBalancer, or fails after the given timeout
func (j *TestJig) WaitForLoadBalancerOrFail(namespace, name string, timeout time.Duration) *v1.Service { func (j *TestJig) WaitForLoadBalancerOrFail(namespace, name string, timeout time.Duration) *v1.Service {
e2elog.Logf("Waiting up to %v for service %q to have a LoadBalancer", timeout, name) framework.Logf("Waiting up to %v for service %q to have a LoadBalancer", timeout, name)
service := j.waitForConditionOrFail(namespace, name, timeout, "have a load balancer", func(svc *v1.Service) bool { service := j.waitForConditionOrFail(namespace, name, timeout, "have a load balancer", func(svc *v1.Service) bool {
return len(svc.Status.LoadBalancer.Ingress) > 0 return len(svc.Status.LoadBalancer.Ingress) > 0
}) })
@ -532,11 +531,11 @@ func (j *TestJig) WaitForLoadBalancerDestroyOrFail(namespace, name string, ip st
// TODO: once support ticket 21807001 is resolved, reduce this timeout back to something reasonable // TODO: once support ticket 21807001 is resolved, reduce this timeout back to something reasonable
defer func() { defer func() {
if err := framework.EnsureLoadBalancerResourcesDeleted(ip, strconv.Itoa(port)); err != nil { if err := framework.EnsureLoadBalancerResourcesDeleted(ip, strconv.Itoa(port)); err != nil {
e2elog.Logf("Failed to delete cloud resources for service: %s %d (%v)", ip, port, err) framework.Logf("Failed to delete cloud resources for service: %s %d (%v)", ip, port, err)
} }
}() }()
e2elog.Logf("Waiting up to %v for service %q to have no LoadBalancer", timeout, name) framework.Logf("Waiting up to %v for service %q to have no LoadBalancer", timeout, name)
service := j.waitForConditionOrFail(namespace, name, timeout, "have no load balancer", func(svc *v1.Service) bool { service := j.waitForConditionOrFail(namespace, name, timeout, "have no load balancer", func(svc *v1.Service) bool {
return len(svc.Status.LoadBalancer.Ingress) == 0 return len(svc.Status.LoadBalancer.Ingress) == 0
}) })
@ -557,7 +556,7 @@ func (j *TestJig) waitForConditionOrFail(namespace, name string, timeout time.Du
return false, nil return false, nil
} }
if err := wait.PollImmediate(framework.Poll, timeout, pollFunc); err != nil { if err := wait.PollImmediate(framework.Poll, timeout, pollFunc); err != nil {
e2elog.Failf("Timed out waiting for service %q to %s", name, message) framework.Failf("Timed out waiting for service %q to %s", name, message)
} }
return service return service
} }
@ -632,10 +631,10 @@ func (j *TestJig) CreatePDBOrFail(namespace string, rc *v1.ReplicationController
pdb := j.newPDBTemplate(namespace, rc) pdb := j.newPDBTemplate(namespace, rc)
newPdb, err := j.Client.PolicyV1beta1().PodDisruptionBudgets(namespace).Create(pdb) newPdb, err := j.Client.PolicyV1beta1().PodDisruptionBudgets(namespace).Create(pdb)
if err != nil { if err != nil {
e2elog.Failf("Failed to create PDB %q %v", pdb.Name, err) framework.Failf("Failed to create PDB %q %v", pdb.Name, err)
} }
if err := j.waitForPdbReady(namespace); err != nil { if err := j.waitForPdbReady(namespace); err != nil {
e2elog.Failf("Failed waiting for PDB to be ready: %v", err) framework.Failf("Failed waiting for PDB to be ready: %v", err)
} }
return newPdb return newPdb
@ -672,14 +671,14 @@ func (j *TestJig) RunOrFail(namespace string, tweak func(rc *v1.ReplicationContr
} }
result, err := j.Client.CoreV1().ReplicationControllers(namespace).Create(rc) result, err := j.Client.CoreV1().ReplicationControllers(namespace).Create(rc)
if err != nil { if err != nil {
e2elog.Failf("Failed to create RC %q: %v", rc.Name, err) framework.Failf("Failed to create RC %q: %v", rc.Name, err)
} }
pods, err := j.waitForPodsCreated(namespace, int(*(rc.Spec.Replicas))) pods, err := j.waitForPodsCreated(namespace, int(*(rc.Spec.Replicas)))
if err != nil { if err != nil {
e2elog.Failf("Failed to create pods: %v", err) framework.Failf("Failed to create pods: %v", err)
} }
if err := j.waitForPodsReady(namespace, pods); err != nil { if err := j.waitForPodsReady(namespace, pods); err != nil {
e2elog.Failf("Failed waiting for pods to be running: %v", err) framework.Failf("Failed waiting for pods to be running: %v", err)
} }
return result return result
} }
@ -689,20 +688,20 @@ func (j *TestJig) Scale(namespace string, replicas int) {
rc := j.Name rc := j.Name
scale, err := j.Client.CoreV1().ReplicationControllers(namespace).GetScale(rc, metav1.GetOptions{}) scale, err := j.Client.CoreV1().ReplicationControllers(namespace).GetScale(rc, metav1.GetOptions{})
if err != nil { if err != nil {
e2elog.Failf("Failed to get scale for RC %q: %v", rc, err) framework.Failf("Failed to get scale for RC %q: %v", rc, err)
} }
scale.Spec.Replicas = int32(replicas) scale.Spec.Replicas = int32(replicas)
_, err = j.Client.CoreV1().ReplicationControllers(namespace).UpdateScale(rc, scale) _, err = j.Client.CoreV1().ReplicationControllers(namespace).UpdateScale(rc, scale)
if err != nil { if err != nil {
e2elog.Failf("Failed to scale RC %q: %v", rc, err) framework.Failf("Failed to scale RC %q: %v", rc, err)
} }
pods, err := j.waitForPodsCreated(namespace, replicas) pods, err := j.waitForPodsCreated(namespace, replicas)
if err != nil { if err != nil {
e2elog.Failf("Failed waiting for pods: %v", err) framework.Failf("Failed waiting for pods: %v", err)
} }
if err := j.waitForPodsReady(namespace, pods); err != nil { if err := j.waitForPodsReady(namespace, pods); err != nil {
e2elog.Failf("Failed waiting for pods to be running: %v", err) framework.Failf("Failed waiting for pods to be running: %v", err)
} }
} }
@ -725,7 +724,7 @@ func (j *TestJig) waitForPodsCreated(namespace string, replicas int) ([]string,
timeout := 2 * time.Minute timeout := 2 * time.Minute
// List the pods, making sure we observe all the replicas. // List the pods, making sure we observe all the replicas.
label := labels.SelectorFromSet(labels.Set(j.Labels)) label := labels.SelectorFromSet(labels.Set(j.Labels))
e2elog.Logf("Waiting up to %v for %d pods to be created", timeout, replicas) framework.Logf("Waiting up to %v for %d pods to be created", timeout, replicas)
for start := time.Now(); time.Since(start) < timeout; time.Sleep(2 * time.Second) { for start := time.Now(); time.Since(start) < timeout; time.Sleep(2 * time.Second) {
options := metav1.ListOptions{LabelSelector: label.String()} options := metav1.ListOptions{LabelSelector: label.String()}
pods, err := j.Client.CoreV1().Pods(namespace).List(options) pods, err := j.Client.CoreV1().Pods(namespace).List(options)
@ -741,10 +740,10 @@ func (j *TestJig) waitForPodsCreated(namespace string, replicas int) ([]string,
found = append(found, pod.Name) found = append(found, pod.Name)
} }
if len(found) == replicas { if len(found) == replicas {
e2elog.Logf("Found all %d pods", replicas) framework.Logf("Found all %d pods", replicas)
return found, nil return found, nil
} }
e2elog.Logf("Found %d/%d pods - will retry", len(found), replicas) framework.Logf("Found %d/%d pods - will retry", len(found), replicas)
} }
return nil, fmt.Errorf("timeout waiting for %d pods to be created", replicas) return nil, fmt.Errorf("timeout waiting for %d pods to be created", replicas)
} }
@ -777,7 +776,7 @@ func testReachabilityOverNodePorts(nodes *v1.NodeList, sp v1.ServicePort, pod *v
// If the node's internal address points to localhost, then we are not // If the node's internal address points to localhost, then we are not
// able to test the service reachability via that address // able to test the service reachability via that address
if isInvalidOrLocalhostAddress(internalAddr) { if isInvalidOrLocalhostAddress(internalAddr) {
e2elog.Logf("skipping testEndpointReachability() for internal adddress %s", internalAddr) framework.Logf("skipping testEndpointReachability() for internal adddress %s", internalAddr)
continue continue
} }
testEndpointReachability(internalAddr, sp.NodePort, sp.Protocol, pod) testEndpointReachability(internalAddr, sp.NodePort, sp.Protocol, pod)
@ -809,12 +808,12 @@ func testEndpointReachability(endpoint string, port int32, protocol v1.Protocol,
case v1.ProtocolUDP: case v1.ProtocolUDP:
cmd = fmt.Sprintf("nc -zv -u -w 2 %s %v", endpoint, port) cmd = fmt.Sprintf("nc -zv -u -w 2 %s %v", endpoint, port)
default: default:
e2elog.Failf("Service reachablity check is not supported for %v", protocol) framework.Failf("Service reachablity check is not supported for %v", protocol)
} }
if cmd != "" { if cmd != "" {
err := wait.PollImmediate(1*time.Second, ServiceReachabilityShortPollTimeout, func() (bool, error) { err := wait.PollImmediate(1*time.Second, ServiceReachabilityShortPollTimeout, func() (bool, error) {
if _, err := framework.RunHostCmd(execPod.Namespace, execPod.Name, cmd); err != nil { if _, err := framework.RunHostCmd(execPod.Namespace, execPod.Name, cmd); err != nil {
e2elog.Logf("Service reachability failing with error: %v\nRetrying...", err) framework.Logf("Service reachability failing with error: %v\nRetrying...", err)
return false, nil return false, nil
} }
return true, nil return true, nil
@ -881,7 +880,7 @@ func (j *TestJig) CheckServiceReachability(namespace string, svc *v1.Service, po
case v1.ServiceTypeExternalName: case v1.ServiceTypeExternalName:
j.checkExternalServiceReachability(svc, pod) j.checkExternalServiceReachability(svc, pod)
default: default:
e2elog.Failf("Unsupported service type \"%s\" to verify service reachability for \"%s\" service. This may due to diverse implementation of the service type.", svcType, svc.Name) framework.Failf("Unsupported service type \"%s\" to verify service reachability for \"%s\" service. This may due to diverse implementation of the service type.", svcType, svc.Name)
} }
} }
@ -906,9 +905,9 @@ func (j *TestJig) TestReachableHTTPWithRetriableErrorCodes(host string, port int
if err := wait.PollImmediate(framework.Poll, timeout, pollfn); err != nil { if err := wait.PollImmediate(framework.Poll, timeout, pollfn); err != nil {
if err == wait.ErrWaitTimeout { if err == wait.ErrWaitTimeout {
e2elog.Failf("Could not reach HTTP service through %v:%v after %v", host, port, timeout) framework.Failf("Could not reach HTTP service through %v:%v after %v", host, port, timeout)
} else { } else {
e2elog.Failf("Failed to reach HTTP service through %v:%v: %v", host, port, err) framework.Failf("Failed to reach HTTP service through %v:%v: %v", host, port, err)
} }
} }
} }
@ -924,7 +923,7 @@ func (j *TestJig) TestNotReachableHTTP(host string, port int, timeout time.Durat
} }
if err := wait.PollImmediate(framework.Poll, timeout, pollfn); err != nil { if err := wait.PollImmediate(framework.Poll, timeout, pollfn); err != nil {
e2elog.Failf("HTTP service %v:%v reachable after %v: %v", host, port, timeout, err) framework.Failf("HTTP service %v:%v reachable after %v: %v", host, port, timeout, err)
} }
} }
@ -939,7 +938,7 @@ func (j *TestJig) TestRejectedHTTP(host string, port int, timeout time.Duration)
} }
if err := wait.PollImmediate(framework.Poll, timeout, pollfn); err != nil { if err := wait.PollImmediate(framework.Poll, timeout, pollfn); err != nil {
e2elog.Failf("HTTP service %v:%v not rejected: %v", host, port, err) framework.Failf("HTTP service %v:%v not rejected: %v", host, port, err)
} }
} }
@ -957,7 +956,7 @@ func (j *TestJig) TestReachableUDP(host string, port int, timeout time.Duration)
} }
if err := wait.PollImmediate(framework.Poll, timeout, pollfn); err != nil { if err := wait.PollImmediate(framework.Poll, timeout, pollfn); err != nil {
e2elog.Failf("Could not reach UDP service through %v:%v after %v: %v", host, port, timeout, err) framework.Failf("Could not reach UDP service through %v:%v after %v: %v", host, port, timeout, err)
} }
} }
@ -971,7 +970,7 @@ func (j *TestJig) TestNotReachableUDP(host string, port int, timeout time.Durati
return false, nil // caller can retry return false, nil // caller can retry
} }
if err := wait.PollImmediate(framework.Poll, timeout, pollfn); err != nil { if err := wait.PollImmediate(framework.Poll, timeout, pollfn); err != nil {
e2elog.Failf("UDP service %v:%v reachable after %v: %v", host, port, timeout, err) framework.Failf("UDP service %v:%v reachable after %v: %v", host, port, timeout, err)
} }
} }
@ -985,7 +984,7 @@ func (j *TestJig) TestRejectedUDP(host string, port int, timeout time.Duration)
return false, nil // caller can retry return false, nil // caller can retry
} }
if err := wait.PollImmediate(framework.Poll, timeout, pollfn); err != nil { if err := wait.PollImmediate(framework.Poll, timeout, pollfn); err != nil {
e2elog.Failf("UDP service %v:%v not rejected: %v", host, port, err) framework.Failf("UDP service %v:%v not rejected: %v", host, port, err)
} }
} }
@ -1000,7 +999,7 @@ func (j *TestJig) GetHTTPContent(host string, port int, timeout time.Duration, u
} }
return false, nil return false, nil
}); pollErr != nil { }); pollErr != nil {
e2elog.Failf("Could not reach HTTP service through %v:%v%v after %v: %v", host, port, url, timeout, pollErr) framework.Failf("Could not reach HTTP service through %v:%v%v after %v: %v", host, port, url, timeout, pollErr)
} }
return body return body
} }
@ -1060,7 +1059,7 @@ func (j *TestJig) CheckAffinity(execPod *v1.Pod, targetIP string, targetPort int
if execPod != nil { if execPod != nil {
stdout, err := framework.RunHostCmd(execPod.Namespace, execPod.Name, cmd) stdout, err := framework.RunHostCmd(execPod.Namespace, execPod.Name, cmd)
if err != nil { if err != nil {
e2elog.Logf("Failed to get response from %s. Retry until timeout", targetIPPort) framework.Logf("Failed to get response from %s. Retry until timeout", targetIPPort)
return false, nil return false, nil
} }
tracker.recordHost(stdout) tracker.recordHost(stdout)
@ -1099,18 +1098,18 @@ func testHTTPHealthCheckNodePort(ip string, port int, request string) (bool, err
ipPort := net.JoinHostPort(ip, strconv.Itoa(port)) ipPort := net.JoinHostPort(ip, strconv.Itoa(port))
url := fmt.Sprintf("http://%s%s", ipPort, request) url := fmt.Sprintf("http://%s%s", ipPort, request)
if ip == "" || port == 0 { if ip == "" || port == 0 {
e2elog.Failf("Got empty IP for reachability check (%s)", url) framework.Failf("Got empty IP for reachability check (%s)", url)
return false, fmt.Errorf("invalid input ip or port") return false, fmt.Errorf("invalid input ip or port")
} }
e2elog.Logf("Testing HTTP health check on %v", url) framework.Logf("Testing HTTP health check on %v", url)
resp, err := httpGetNoConnectionPoolTimeout(url, 5*time.Second) resp, err := httpGetNoConnectionPoolTimeout(url, 5*time.Second)
if err != nil { if err != nil {
e2elog.Logf("Got error testing for reachability of %s: %v", url, err) framework.Logf("Got error testing for reachability of %s: %v", url, err)
return false, err return false, err
} }
defer resp.Body.Close() defer resp.Body.Close()
if err != nil { if err != nil {
e2elog.Logf("Got error reading response from %s: %v", url, err) framework.Logf("Got error reading response from %s: %v", url, err)
return false, err return false, err
} }
// HealthCheck responder returns 503 for no local endpoints // HealthCheck responder returns 503 for no local endpoints

5
test/e2e/framework/service/resource.go
View File

@ -26,7 +26,6 @@ import (
clientset "k8s.io/client-go/kubernetes" clientset "k8s.io/client-go/kubernetes"
restclient "k8s.io/client-go/rest" restclient "k8s.io/client-go/rest"
"k8s.io/kubernetes/test/e2e/framework" "k8s.io/kubernetes/test/e2e/framework"
e2elog "k8s.io/kubernetes/test/e2e/framework/log"
) )
// GetServicesProxyRequest returns a request for a service proxy. // GetServicesProxyRequest returns a request for a service proxy.
@ -103,10 +102,10 @@ func EnableAndDisableInternalLB() (enable func(svc *v1.Service), disable func(sv
// DescribeSvc logs the output of kubectl describe svc for the given namespace // DescribeSvc logs the output of kubectl describe svc for the given namespace
func DescribeSvc(ns string) { func DescribeSvc(ns string) {
e2elog.Logf("\nOutput of kubectl describe svc:\n") framework.Logf("\nOutput of kubectl describe svc:\n")
desc, _ := framework.RunKubectl( desc, _ := framework.RunKubectl(
"describe", "svc", fmt.Sprintf("--namespace=%v", ns)) "describe", "svc", fmt.Sprintf("--namespace=%v", ns))
e2elog.Logf(desc) framework.Logf(desc)
} }
// GetServiceLoadBalancerCreationTimeout returns a timeout value for creating a load balancer of a service. // GetServiceLoadBalancerCreationTimeout returns a timeout value for creating a load balancer of a service.

23
test/e2e/framework/service/wait.go
View File

@ -26,7 +26,6 @@ import (
clientset "k8s.io/client-go/kubernetes" clientset "k8s.io/client-go/kubernetes"
servicehelper "k8s.io/cloud-provider/service/helpers" servicehelper "k8s.io/cloud-provider/service/helpers"
"k8s.io/kubernetes/test/e2e/framework" "k8s.io/kubernetes/test/e2e/framework"
e2elog "k8s.io/kubernetes/test/e2e/framework/log"
"github.com/onsi/ginkgo" "github.com/onsi/ginkgo"
) )
@ -38,7 +37,7 @@ func WaitForServiceResponding(c clientset.Interface, ns, name string) error {
return wait.PollImmediate(framework.Poll, RespondingTimeout, func() (done bool, err error) { return wait.PollImmediate(framework.Poll, RespondingTimeout, func() (done bool, err error) {
proxyRequest, errProxy := GetServicesProxyRequest(c, c.CoreV1().RESTClient().Get()) proxyRequest, errProxy := GetServicesProxyRequest(c, c.CoreV1().RESTClient().Get())
if errProxy != nil { if errProxy != nil {
e2elog.Logf("Failed to get services proxy request: %v:", errProxy) framework.Logf("Failed to get services proxy request: %v:", errProxy)
return false, nil return false, nil
} }
@ -52,18 +51,18 @@ func WaitForServiceResponding(c clientset.Interface, ns, name string) error {
Raw() Raw()
if err != nil { if err != nil {
if ctx.Err() != nil { if ctx.Err() != nil {
e2elog.Failf("Failed to GET from service %s: %v", name, err) framework.Failf("Failed to GET from service %s: %v", name, err)
return true, err return true, err
} }
e2elog.Logf("Failed to GET from service %s: %v:", name, err) framework.Logf("Failed to GET from service %s: %v:", name, err)
return false, nil return false, nil
} }
got := string(body) got := string(body)
if len(got) == 0 { if len(got) == 0 {
e2elog.Logf("Service %s: expected non-empty response", name) framework.Logf("Service %s: expected non-empty response", name)
return false, err // stop polling return false, err // stop polling
} }
e2elog.Logf("Service %s: found nonempty answer: %s", name, got) framework.Logf("Service %s: found nonempty answer: %s", name, got)
return true, nil return true, nil
}) })
} }
@ -72,7 +71,7 @@ func WaitForServiceResponding(c clientset.Interface, ns, name string) error {
func WaitForServiceDeletedWithFinalizer(cs clientset.Interface, namespace, name string) { func WaitForServiceDeletedWithFinalizer(cs clientset.Interface, namespace, name string) {
ginkgo.By("Delete service with finalizer") ginkgo.By("Delete service with finalizer")
if err := cs.CoreV1().Services(namespace).Delete(name, nil); err != nil { if err := cs.CoreV1().Services(namespace).Delete(name, nil); err != nil {
e2elog.Failf("Failed to delete service %s/%s", namespace, name) framework.Failf("Failed to delete service %s/%s", namespace, name)
} }
ginkgo.By("Wait for service to disappear") ginkgo.By("Wait for service to disappear")
@ -80,15 +79,15 @@ func WaitForServiceDeletedWithFinalizer(cs clientset.Interface, namespace, name
svc, err := cs.CoreV1().Services(namespace).Get(name, metav1.GetOptions{}) svc, err := cs.CoreV1().Services(namespace).Get(name, metav1.GetOptions{})
if err != nil { if err != nil {
if apierrors.IsNotFound(err) { if apierrors.IsNotFound(err) {
e2elog.Logf("Service %s/%s is gone.", namespace, name) framework.Logf("Service %s/%s is gone.", namespace, name)
return true, nil return true, nil
} }
return false, err return false, err
} }
e2elog.Logf("Service %s/%s still exists with finalizers: %v", namespace, name, svc.Finalizers) framework.Logf("Service %s/%s still exists with finalizers: %v", namespace, name, svc.Finalizers)
return false, nil return false, nil
}); pollErr != nil { }); pollErr != nil {
e2elog.Failf("Failed to wait for service to disappear: %v", pollErr) framework.Failf("Failed to wait for service to disappear: %v", pollErr)
} }
} }
@ -108,11 +107,11 @@ func WaitForServiceUpdatedWithFinalizer(cs clientset.Interface, namespace, name
} }
} }
if foundFinalizer != hasFinalizer { if foundFinalizer != hasFinalizer {
e2elog.Logf("Service %s/%s hasFinalizer=%t, want %t", namespace, name, foundFinalizer, hasFinalizer) framework.Logf("Service %s/%s hasFinalizer=%t, want %t", namespace, name, foundFinalizer, hasFinalizer)
return false, nil return false, nil
} }
return true, nil return true, nil
}); pollErr != nil { }); pollErr != nil {
e2elog.Failf("Failed to wait for service to hasFinalizer=%t: %v", hasFinalizer, pollErr) framework.Failf("Failed to wait for service to hasFinalizer=%t: %v", hasFinalizer, pollErr)
} }
} }

1
test/e2e/framework/statefulset/BUILD
View File

@ -23,7 +23,6 @@ go_library(
"//staging/src/k8s.io/apimachinery/pkg/util/wait:go_default_library", "//staging/src/k8s.io/apimachinery/pkg/util/wait:go_default_library",
"//staging/src/k8s.io/client-go/kubernetes:go_default_library", "//staging/src/k8s.io/client-go/kubernetes:go_default_library",
"//test/e2e/framework:go_default_library", "//test/e2e/framework:go_default_library",
"//test/e2e/framework/log:go_default_library",
"//test/e2e/manifest:go_default_library", "//test/e2e/manifest:go_default_library",
"//test/utils/image:go_default_library", "//test/utils/image:go_default_library",
], ],

11
test/e2e/framework/statefulset/fixtures.go
View File

@ -31,7 +31,6 @@ import (
clientset "k8s.io/client-go/kubernetes" clientset "k8s.io/client-go/kubernetes"
podutil "k8s.io/kubernetes/pkg/api/v1/pod" podutil "k8s.io/kubernetes/pkg/api/v1/pod"
e2efwk "k8s.io/kubernetes/test/e2e/framework" e2efwk "k8s.io/kubernetes/test/e2e/framework"
e2elog "k8s.io/kubernetes/test/e2e/framework/log"
imageutils "k8s.io/kubernetes/test/utils/image" imageutils "k8s.io/kubernetes/test/utils/image"
) )
@ -157,7 +156,7 @@ func BreakPodHTTPProbe(ss *appsv1.StatefulSet, pod *v1.Pod) error {
// Ignore 'mv' errors to make this idempotent. // Ignore 'mv' errors to make this idempotent.
cmd := fmt.Sprintf("mv -v /usr/local/apache2/htdocs%v /tmp/ || true", path) cmd := fmt.Sprintf("mv -v /usr/local/apache2/htdocs%v /tmp/ || true", path)
stdout, err := e2efwk.RunHostCmdWithRetries(pod.Namespace, pod.Name, cmd, StatefulSetPoll, StatefulPodTimeout) stdout, err := e2efwk.RunHostCmdWithRetries(pod.Namespace, pod.Name, cmd, StatefulSetPoll, StatefulPodTimeout)
e2elog.Logf("stdout of %v on %v: %v", cmd, pod.Name, stdout) e2efwk.Logf("stdout of %v on %v: %v", cmd, pod.Name, stdout)
return err return err
} }
@ -181,7 +180,7 @@ func RestorePodHTTPProbe(ss *appsv1.StatefulSet, pod *v1.Pod) error {
// Ignore 'mv' errors to make this idempotent. // Ignore 'mv' errors to make this idempotent.
cmd := fmt.Sprintf("mv -v /tmp%v /usr/local/apache2/htdocs/ || true", path) cmd := fmt.Sprintf("mv -v /tmp%v /usr/local/apache2/htdocs/ || true", path)
stdout, err := e2efwk.RunHostCmdWithRetries(pod.Namespace, pod.Name, cmd, StatefulSetPoll, StatefulPodTimeout) stdout, err := e2efwk.RunHostCmdWithRetries(pod.Namespace, pod.Name, cmd, StatefulSetPoll, StatefulPodTimeout)
e2elog.Logf("stdout of %v on %v: %v", cmd, pod.Name, stdout) e2efwk.Logf("stdout of %v on %v: %v", cmd, pod.Name, stdout)
return err return err
} }
@ -243,17 +242,17 @@ func ResumeNextPod(c clientset.Interface, ss *appsv1.StatefulSet) {
resumedPod := "" resumedPod := ""
for _, pod := range podList.Items { for _, pod := range podList.Items {
if pod.Status.Phase != v1.PodRunning { if pod.Status.Phase != v1.PodRunning {
e2elog.Failf("Found pod in phase %q, cannot resume", pod.Status.Phase) e2efwk.Failf("Found pod in phase %q, cannot resume", pod.Status.Phase)
} }
if podutil.IsPodReady(&pod) || !hasPauseProbe(&pod) { if podutil.IsPodReady(&pod) || !hasPauseProbe(&pod) {
continue continue
} }
if resumedPod != "" { if resumedPod != "" {
e2elog.Failf("Found multiple paused stateful pods: %v and %v", pod.Name, resumedPod) e2efwk.Failf("Found multiple paused stateful pods: %v and %v", pod.Name, resumedPod)
} }
_, err := e2efwk.RunHostCmdWithRetries(pod.Namespace, pod.Name, "dd if=/dev/zero of=/data/statefulset-continue bs=1 count=1 conv=fsync", StatefulSetPoll, StatefulPodTimeout) _, err := e2efwk.RunHostCmdWithRetries(pod.Namespace, pod.Name, "dd if=/dev/zero of=/data/statefulset-continue bs=1 count=1 conv=fsync", StatefulSetPoll, StatefulPodTimeout)
e2efwk.ExpectNoError(err) e2efwk.ExpectNoError(err)
e2elog.Logf("Resumed pod %v", pod.Name) e2efwk.Logf("Resumed pod %v", pod.Name)
resumedPod = pod.Name resumedPod = pod.Name
} }
} }

37
test/e2e/framework/statefulset/rest.go
View File

@ -32,7 +32,6 @@ import (
clientset "k8s.io/client-go/kubernetes" clientset "k8s.io/client-go/kubernetes"
podutil "k8s.io/kubernetes/pkg/api/v1/pod" podutil "k8s.io/kubernetes/pkg/api/v1/pod"
e2efwk "k8s.io/kubernetes/test/e2e/framework" e2efwk "k8s.io/kubernetes/test/e2e/framework"
e2elog "k8s.io/kubernetes/test/e2e/framework/log"
"k8s.io/kubernetes/test/e2e/manifest" "k8s.io/kubernetes/test/e2e/manifest"
) )
@ -42,18 +41,18 @@ func CreateStatefulSet(c clientset.Interface, manifestPath, ns string) *appsv1.S
return filepath.Join(manifestPath, file) return filepath.Join(manifestPath, file)
} }
e2elog.Logf("Parsing statefulset from %v", mkpath("statefulset.yaml")) e2efwk.Logf("Parsing statefulset from %v", mkpath("statefulset.yaml"))
ss, err := manifest.StatefulSetFromManifest(mkpath("statefulset.yaml"), ns) ss, err := manifest.StatefulSetFromManifest(mkpath("statefulset.yaml"), ns)
e2efwk.ExpectNoError(err) e2efwk.ExpectNoError(err)
e2elog.Logf("Parsing service from %v", mkpath("service.yaml")) e2efwk.Logf("Parsing service from %v", mkpath("service.yaml"))
svc, err := manifest.SvcFromManifest(mkpath("service.yaml")) svc, err := manifest.SvcFromManifest(mkpath("service.yaml"))
e2efwk.ExpectNoError(err) e2efwk.ExpectNoError(err)
e2elog.Logf(fmt.Sprintf("creating " + ss.Name + " service")) e2efwk.Logf(fmt.Sprintf("creating " + ss.Name + " service"))
_, err = c.CoreV1().Services(ns).Create(svc) _, err = c.CoreV1().Services(ns).Create(svc)
e2efwk.ExpectNoError(err) e2efwk.ExpectNoError(err)
e2elog.Logf(fmt.Sprintf("creating statefulset %v/%v with %d replicas and selector %+v", ss.Namespace, ss.Name, *(ss.Spec.Replicas), ss.Spec.Selector)) e2efwk.Logf(fmt.Sprintf("creating statefulset %v/%v with %d replicas and selector %+v", ss.Namespace, ss.Name, *(ss.Spec.Replicas), ss.Spec.Selector))
_, err = c.AppsV1().StatefulSets(ns).Create(ss) _, err = c.AppsV1().StatefulSets(ns).Create(ss)
e2efwk.ExpectNoError(err) e2efwk.ExpectNoError(err)
WaitForRunningAndReady(c, *ss.Spec.Replicas, ss) WaitForRunningAndReady(c, *ss.Spec.Replicas, ss)
@ -74,7 +73,7 @@ func DeleteStatefulPodAtIndex(c clientset.Interface, index int, ss *appsv1.State
name := getStatefulSetPodNameAtIndex(index, ss) name := getStatefulSetPodNameAtIndex(index, ss)
noGrace := int64(0) noGrace := int64(0)
if err := c.CoreV1().Pods(ss.Namespace).Delete(name, &metav1.DeleteOptions{GracePeriodSeconds: &noGrace}); err != nil { if err := c.CoreV1().Pods(ss.Namespace).Delete(name, &metav1.DeleteOptions{GracePeriodSeconds: &noGrace}); err != nil {
e2elog.Failf("Failed to delete stateful pod %v for StatefulSet %v/%v: %v", name, ss.Namespace, ss.Name, err) e2efwk.Failf("Failed to delete stateful pod %v for StatefulSet %v/%v: %v", name, ss.Namespace, ss.Name, err)
} }
} }
@ -93,7 +92,7 @@ func DeleteAllStatefulSets(c clientset.Interface, ns string) {
errList = append(errList, fmt.Sprintf("%v", err)) errList = append(errList, fmt.Sprintf("%v", err))
} }
WaitForStatusReplicas(c, ss, 0) WaitForStatusReplicas(c, ss, 0)
e2elog.Logf("Deleting statefulset %v", ss.Name) e2efwk.Logf("Deleting statefulset %v", ss.Name)
// Use OrphanDependents=false so it's deleted synchronously. // Use OrphanDependents=false so it's deleted synchronously.
// We already made sure the Pods are gone inside Scale(). // We already made sure the Pods are gone inside Scale().
if err := c.AppsV1().StatefulSets(ss.Namespace).Delete(ss.Name, &metav1.DeleteOptions{OrphanDependents: new(bool)}); err != nil { if err := c.AppsV1().StatefulSets(ss.Namespace).Delete(ss.Name, &metav1.DeleteOptions{OrphanDependents: new(bool)}); err != nil {
@ -107,13 +106,13 @@ func DeleteAllStatefulSets(c clientset.Interface, ns string) {
pvcPollErr := wait.PollImmediate(StatefulSetPoll, StatefulSetTimeout, func() (bool, error) { pvcPollErr := wait.PollImmediate(StatefulSetPoll, StatefulSetTimeout, func() (bool, error) {
pvcList, err := c.CoreV1().PersistentVolumeClaims(ns).List(metav1.ListOptions{LabelSelector: labels.Everything().String()}) pvcList, err := c.CoreV1().PersistentVolumeClaims(ns).List(metav1.ListOptions{LabelSelector: labels.Everything().String()})
if err != nil { if err != nil {
e2elog.Logf("WARNING: Failed to list pvcs, retrying %v", err) e2efwk.Logf("WARNING: Failed to list pvcs, retrying %v", err)
return false, nil return false, nil
} }
for _, pvc := range pvcList.Items { for _, pvc := range pvcList.Items {
pvNames.Insert(pvc.Spec.VolumeName) pvNames.Insert(pvc.Spec.VolumeName)
// TODO: Double check that there are no pods referencing the pvc // TODO: Double check that there are no pods referencing the pvc
e2elog.Logf("Deleting pvc: %v with volume %v", pvc.Name, pvc.Spec.VolumeName) e2efwk.Logf("Deleting pvc: %v with volume %v", pvc.Name, pvc.Spec.VolumeName)
if err := c.CoreV1().PersistentVolumeClaims(ns).Delete(pvc.Name, nil); err != nil { if err := c.CoreV1().PersistentVolumeClaims(ns).Delete(pvc.Name, nil); err != nil {
return false, nil return false, nil
} }
@ -127,7 +126,7 @@ func DeleteAllStatefulSets(c clientset.Interface, ns string) {
pollErr := wait.PollImmediate(StatefulSetPoll, StatefulSetTimeout, func() (bool, error) { pollErr := wait.PollImmediate(StatefulSetPoll, StatefulSetTimeout, func() (bool, error) {
pvList, err := c.CoreV1().PersistentVolumes().List(metav1.ListOptions{LabelSelector: labels.Everything().String()}) pvList, err := c.CoreV1().PersistentVolumes().List(metav1.ListOptions{LabelSelector: labels.Everything().String()})
if err != nil { if err != nil {
e2elog.Logf("WARNING: Failed to list pvs, retrying %v", err) e2efwk.Logf("WARNING: Failed to list pvs, retrying %v", err)
return false, nil return false, nil
} }
waitingFor := []string{} waitingFor := []string{}
@ -139,7 +138,7 @@ func DeleteAllStatefulSets(c clientset.Interface, ns string) {
if len(waitingFor) == 0 { if len(waitingFor) == 0 {
return true, nil return true, nil
} }
e2elog.Logf("Still waiting for pvs of statefulset to disappear:\n%v", strings.Join(waitingFor, "\n")) e2efwk.Logf("Still waiting for pvs of statefulset to disappear:\n%v", strings.Join(waitingFor, "\n"))
return false, nil return false, nil
}) })
if pollErr != nil { if pollErr != nil {
@ -161,7 +160,7 @@ func UpdateStatefulSetWithRetries(c clientset.Interface, namespace, name string,
// Apply the update, then attempt to push it to the apiserver. // Apply the update, then attempt to push it to the apiserver.
applyUpdate(statefulSet) applyUpdate(statefulSet)
if statefulSet, err = statefulSets.Update(statefulSet); err == nil { if statefulSet, err = statefulSets.Update(statefulSet); err == nil {
e2elog.Logf("Updating stateful set %s", name) e2efwk.Logf("Updating stateful set %s", name)
return true, nil return true, nil
} }
updateErr = err updateErr = err
@ -178,7 +177,7 @@ func Scale(c clientset.Interface, ss *appsv1.StatefulSet, count int32) (*appsv1.
name := ss.Name name := ss.Name
ns := ss.Namespace ns := ss.Namespace
e2elog.Logf("Scaling statefulset %s to %d", name, count) e2efwk.Logf("Scaling statefulset %s to %d", name, count)
ss = update(c, ns, name, func(ss *appsv1.StatefulSet) { *(ss.Spec.Replicas) = count }) ss = update(c, ns, name, func(ss *appsv1.StatefulSet) { *(ss.Spec.Replicas) = count })
var statefulPodList *v1.PodList var statefulPodList *v1.PodList
@ -223,7 +222,7 @@ func Restart(c clientset.Interface, ss *appsv1.StatefulSet) {
func GetStatefulSet(c clientset.Interface, namespace, name string) *appsv1.StatefulSet { func GetStatefulSet(c clientset.Interface, namespace, name string) *appsv1.StatefulSet {
ss, err := c.AppsV1().StatefulSets(namespace).Get(name, metav1.GetOptions{}) ss, err := c.AppsV1().StatefulSets(namespace).Get(name, metav1.GetOptions{})
if err != nil { if err != nil {
e2elog.Failf("Failed to get StatefulSet %s/%s: %v", namespace, name, err) e2efwk.Failf("Failed to get StatefulSet %s/%s: %v", namespace, name, err)
} }
return ss return ss
} }
@ -263,7 +262,7 @@ func CheckMount(c clientset.Interface, ss *appsv1.StatefulSet, mountPath string)
// CheckServiceName asserts that the ServiceName for ss is equivalent to expectedServiceName. // CheckServiceName asserts that the ServiceName for ss is equivalent to expectedServiceName.
func CheckServiceName(ss *appsv1.StatefulSet, expectedServiceName string) error { func CheckServiceName(ss *appsv1.StatefulSet, expectedServiceName string) error {
e2elog.Logf("Checking if statefulset spec.serviceName is %s", expectedServiceName) e2efwk.Logf("Checking if statefulset spec.serviceName is %s", expectedServiceName)
if expectedServiceName != ss.Spec.ServiceName { if expectedServiceName != ss.Spec.ServiceName {
return fmt.Errorf("wrong service name governing statefulset. Expected %s got %s", return fmt.Errorf("wrong service name governing statefulset. Expected %s got %s",
@ -278,7 +277,7 @@ func ExecInStatefulPods(c clientset.Interface, ss *appsv1.StatefulSet, cmd strin
podList := GetPodList(c, ss) podList := GetPodList(c, ss)
for _, statefulPod := range podList.Items { for _, statefulPod := range podList.Items {
stdout, err := e2efwk.RunHostCmdWithRetries(statefulPod.Namespace, statefulPod.Name, cmd, StatefulSetPoll, StatefulPodTimeout) stdout, err := e2efwk.RunHostCmdWithRetries(statefulPod.Namespace, statefulPod.Name, cmd, StatefulSetPoll, StatefulPodTimeout)
e2elog.Logf("stdout of %v on %v: %v", cmd, statefulPod.Name, stdout) e2efwk.Logf("stdout of %v on %v: %v", cmd, statefulPod.Name, stdout)
if err != nil { if err != nil {
return err return err
} }
@ -304,7 +303,7 @@ func update(c clientset.Interface, ns, name string, update func(ss *appsv1.State
for i := 0; i < 3; i++ { for i := 0; i < 3; i++ {
ss, err := c.AppsV1().StatefulSets(ns).Get(name, metav1.GetOptions{}) ss, err := c.AppsV1().StatefulSets(ns).Get(name, metav1.GetOptions{})
if err != nil { if err != nil {
e2elog.Failf("failed to get statefulset %q: %v", name, err) e2efwk.Failf("failed to get statefulset %q: %v", name, err)
} }
update(ss) update(ss)
ss, err = c.AppsV1().StatefulSets(ns).Update(ss) ss, err = c.AppsV1().StatefulSets(ns).Update(ss)
@ -312,10 +311,10 @@ func update(c clientset.Interface, ns, name string, update func(ss *appsv1.State
return ss return ss
} }
if !apierrs.IsConflict(err) && !apierrs.IsServerTimeout(err) { if !apierrs.IsConflict(err) && !apierrs.IsServerTimeout(err) {
e2elog.Failf("failed to update statefulset %q: %v", name, err) e2efwk.Failf("failed to update statefulset %q: %v", name, err)
} }
} }
e2elog.Failf("too many retries draining statefulset %q", name) e2efwk.Failf("too many retries draining statefulset %q", name)
return nil return nil
} }

42
test/e2e/framework/statefulset/wait.go
View File

@ -25,7 +25,7 @@ import (
"k8s.io/apimachinery/pkg/util/wait" "k8s.io/apimachinery/pkg/util/wait"
clientset "k8s.io/client-go/kubernetes" clientset "k8s.io/client-go/kubernetes"
podutil "k8s.io/kubernetes/pkg/api/v1/pod" podutil "k8s.io/kubernetes/pkg/api/v1/pod"
e2elog "k8s.io/kubernetes/test/e2e/framework/log" "k8s.io/kubernetes/test/e2e/framework"
) )
// WaitForPartitionedRollingUpdate waits for all Pods in set to exist and have the correct revision. set must have // WaitForPartitionedRollingUpdate waits for all Pods in set to exist and have the correct revision. set must have
@ -35,13 +35,13 @@ import (
func WaitForPartitionedRollingUpdate(c clientset.Interface, set *appsv1.StatefulSet) (*appsv1.StatefulSet, *v1.PodList) { func WaitForPartitionedRollingUpdate(c clientset.Interface, set *appsv1.StatefulSet) (*appsv1.StatefulSet, *v1.PodList) {
var pods *v1.PodList var pods *v1.PodList
if set.Spec.UpdateStrategy.Type != appsv1.RollingUpdateStatefulSetStrategyType { if set.Spec.UpdateStrategy.Type != appsv1.RollingUpdateStatefulSetStrategyType {
e2elog.Failf("StatefulSet %s/%s attempt to wait for partitioned update with updateStrategy %s", framework.Failf("StatefulSet %s/%s attempt to wait for partitioned update with updateStrategy %s",
set.Namespace, set.Namespace,
set.Name, set.Name,
set.Spec.UpdateStrategy.Type) set.Spec.UpdateStrategy.Type)
} }
if set.Spec.UpdateStrategy.RollingUpdate == nil || set.Spec.UpdateStrategy.RollingUpdate.Partition == nil { if set.Spec.UpdateStrategy.RollingUpdate == nil || set.Spec.UpdateStrategy.RollingUpdate.Partition == nil {
e2elog.Failf("StatefulSet %s/%s attempt to wait for partitioned update with nil RollingUpdate or nil Partition", framework.Failf("StatefulSet %s/%s attempt to wait for partitioned update with nil RollingUpdate or nil Partition",
set.Namespace, set.Namespace,
set.Name) set.Name)
} }
@ -53,14 +53,14 @@ func WaitForPartitionedRollingUpdate(c clientset.Interface, set *appsv1.Stateful
return false, nil return false, nil
} }
if partition <= 0 && set.Status.UpdateRevision != set.Status.CurrentRevision { if partition <= 0 && set.Status.UpdateRevision != set.Status.CurrentRevision {
e2elog.Logf("Waiting for StatefulSet %s/%s to complete update", framework.Logf("Waiting for StatefulSet %s/%s to complete update",
set.Namespace, set.Namespace,
set.Name, set.Name,
) )
SortStatefulPods(pods) SortStatefulPods(pods)
for i := range pods.Items { for i := range pods.Items {
if pods.Items[i].Labels[appsv1.StatefulSetRevisionLabel] != set.Status.UpdateRevision { if pods.Items[i].Labels[appsv1.StatefulSetRevisionLabel] != set.Status.UpdateRevision {
e2elog.Logf("Waiting for Pod %s/%s to have revision %s update revision %s", framework.Logf("Waiting for Pod %s/%s to have revision %s update revision %s",
pods.Items[i].Namespace, pods.Items[i].Namespace,
pods.Items[i].Name, pods.Items[i].Name,
set.Status.UpdateRevision, set.Status.UpdateRevision,
@ -71,7 +71,7 @@ func WaitForPartitionedRollingUpdate(c clientset.Interface, set *appsv1.Stateful
} }
for i := int(*set.Spec.Replicas) - 1; i >= partition; i-- { for i := int(*set.Spec.Replicas) - 1; i >= partition; i-- {
if pods.Items[i].Labels[appsv1.StatefulSetRevisionLabel] != set.Status.UpdateRevision { if pods.Items[i].Labels[appsv1.StatefulSetRevisionLabel] != set.Status.UpdateRevision {
e2elog.Logf("Waiting for Pod %s/%s to have revision %s update revision %s", framework.Logf("Waiting for Pod %s/%s to have revision %s update revision %s",
pods.Items[i].Namespace, pods.Items[i].Namespace,
pods.Items[i].Name, pods.Items[i].Name,
set.Status.UpdateRevision, set.Status.UpdateRevision,
@ -92,7 +92,7 @@ func WaitForRunning(c clientset.Interface, numPodsRunning, numPodsReady int32, s
podList := GetPodList(c, ss) podList := GetPodList(c, ss)
SortStatefulPods(podList) SortStatefulPods(podList)
if int32(len(podList.Items)) < numPodsRunning { if int32(len(podList.Items)) < numPodsRunning {
e2elog.Logf("Found %d stateful pods, waiting for %d", len(podList.Items), numPodsRunning) framework.Logf("Found %d stateful pods, waiting for %d", len(podList.Items), numPodsRunning)
return false, nil return false, nil
} }
if int32(len(podList.Items)) > numPodsRunning { if int32(len(podList.Items)) > numPodsRunning {
@ -102,7 +102,7 @@ func WaitForRunning(c clientset.Interface, numPodsRunning, numPodsReady int32, s
shouldBeReady := getStatefulPodOrdinal(&p) < int(numPodsReady) shouldBeReady := getStatefulPodOrdinal(&p) < int(numPodsReady)
isReady := podutil.IsPodReady(&p) isReady := podutil.IsPodReady(&p)
desiredReadiness := shouldBeReady == isReady desiredReadiness := shouldBeReady == isReady
e2elog.Logf("Waiting for pod %v to enter %v - Ready=%v, currently %v - Ready=%v", p.Name, v1.PodRunning, shouldBeReady, p.Status.Phase, isReady) framework.Logf("Waiting for pod %v to enter %v - Ready=%v, currently %v - Ready=%v", p.Name, v1.PodRunning, shouldBeReady, p.Status.Phase, isReady)
if p.Status.Phase != v1.PodRunning || !desiredReadiness { if p.Status.Phase != v1.PodRunning || !desiredReadiness {
return false, nil return false, nil
} }
@ -110,7 +110,7 @@ func WaitForRunning(c clientset.Interface, numPodsRunning, numPodsReady int32, s
return true, nil return true, nil
}) })
if pollErr != nil { if pollErr != nil {
e2elog.Failf("Failed waiting for pods to enter running: %v", pollErr) framework.Failf("Failed waiting for pods to enter running: %v", pollErr)
} }
} }
@ -126,7 +126,7 @@ func WaitForState(c clientset.Interface, ss *appsv1.StatefulSet, until func(*app
return until(ssGet, podList) return until(ssGet, podList)
}) })
if pollErr != nil { if pollErr != nil {
e2elog.Failf("Failed waiting for state update: %v", pollErr) framework.Failf("Failed waiting for state update: %v", pollErr)
} }
} }
@ -185,7 +185,7 @@ func WaitForPodNotReady(c clientset.Interface, set *appsv1.StatefulSet, podName
func WaitForRollingUpdate(c clientset.Interface, set *appsv1.StatefulSet) (*appsv1.StatefulSet, *v1.PodList) { func WaitForRollingUpdate(c clientset.Interface, set *appsv1.StatefulSet) (*appsv1.StatefulSet, *v1.PodList) {
var pods *v1.PodList var pods *v1.PodList
if set.Spec.UpdateStrategy.Type != appsv1.RollingUpdateStatefulSetStrategyType { if set.Spec.UpdateStrategy.Type != appsv1.RollingUpdateStatefulSetStrategyType {
e2elog.Failf("StatefulSet %s/%s attempt to wait for rolling update with updateStrategy %s", framework.Failf("StatefulSet %s/%s attempt to wait for rolling update with updateStrategy %s",
set.Namespace, set.Namespace,
set.Name, set.Name,
set.Spec.UpdateStrategy.Type) set.Spec.UpdateStrategy.Type)
@ -197,14 +197,14 @@ func WaitForRollingUpdate(c clientset.Interface, set *appsv1.StatefulSet) (*apps
return false, nil return false, nil
} }
if set.Status.UpdateRevision != set.Status.CurrentRevision { if set.Status.UpdateRevision != set.Status.CurrentRevision {
e2elog.Logf("Waiting for StatefulSet %s/%s to complete update", framework.Logf("Waiting for StatefulSet %s/%s to complete update",
set.Namespace, set.Namespace,
set.Name, set.Name,
) )
SortStatefulPods(pods) SortStatefulPods(pods)
for i := range pods.Items { for i := range pods.Items {
if pods.Items[i].Labels[appsv1.StatefulSetRevisionLabel] != set.Status.UpdateRevision { if pods.Items[i].Labels[appsv1.StatefulSetRevisionLabel] != set.Status.UpdateRevision {
e2elog.Logf("Waiting for Pod %s/%s to have revision %s update revision %s", framework.Logf("Waiting for Pod %s/%s to have revision %s update revision %s",
pods.Items[i].Namespace, pods.Items[i].Namespace,
pods.Items[i].Name, pods.Items[i].Name,
set.Status.UpdateRevision, set.Status.UpdateRevision,
@ -225,7 +225,7 @@ func WaitForRunningAndNotReady(c clientset.Interface, numStatefulPods int32, ss
// WaitForStatusReadyReplicas waits for the ss.Status.ReadyReplicas to be equal to expectedReplicas // WaitForStatusReadyReplicas waits for the ss.Status.ReadyReplicas to be equal to expectedReplicas
func WaitForStatusReadyReplicas(c clientset.Interface, ss *appsv1.StatefulSet, expectedReplicas int32) { func WaitForStatusReadyReplicas(c clientset.Interface, ss *appsv1.StatefulSet, expectedReplicas int32) {
e2elog.Logf("Waiting for statefulset status.replicas updated to %d", expectedReplicas) framework.Logf("Waiting for statefulset status.replicas updated to %d", expectedReplicas)
ns, name := ss.Namespace, ss.Name ns, name := ss.Namespace, ss.Name
pollErr := wait.PollImmediate(StatefulSetPoll, StatefulSetTimeout, pollErr := wait.PollImmediate(StatefulSetPoll, StatefulSetTimeout,
@ -238,19 +238,19 @@ func WaitForStatusReadyReplicas(c clientset.Interface, ss *appsv1.StatefulSet, e
return false, nil return false, nil
} }
if ssGet.Status.ReadyReplicas != expectedReplicas { if ssGet.Status.ReadyReplicas != expectedReplicas {
e2elog.Logf("Waiting for stateful set status.readyReplicas to become %d, currently %d", expectedReplicas, ssGet.Status.ReadyReplicas) framework.Logf("Waiting for stateful set status.readyReplicas to become %d, currently %d", expectedReplicas, ssGet.Status.ReadyReplicas)
return false, nil return false, nil
} }
return true, nil return true, nil
}) })
if pollErr != nil { if pollErr != nil {
e2elog.Failf("Failed waiting for stateful set status.readyReplicas updated to %d: %v", expectedReplicas, pollErr) framework.Failf("Failed waiting for stateful set status.readyReplicas updated to %d: %v", expectedReplicas, pollErr)
} }
} }
// WaitForStatusReplicas waits for the ss.Status.Replicas to be equal to expectedReplicas // WaitForStatusReplicas waits for the ss.Status.Replicas to be equal to expectedReplicas
func WaitForStatusReplicas(c clientset.Interface, ss *appsv1.StatefulSet, expectedReplicas int32) { func WaitForStatusReplicas(c clientset.Interface, ss *appsv1.StatefulSet, expectedReplicas int32) {
e2elog.Logf("Waiting for statefulset status.replicas updated to %d", expectedReplicas) framework.Logf("Waiting for statefulset status.replicas updated to %d", expectedReplicas)
ns, name := ss.Namespace, ss.Name ns, name := ss.Namespace, ss.Name
pollErr := wait.PollImmediate(StatefulSetPoll, StatefulSetTimeout, pollErr := wait.PollImmediate(StatefulSetPoll, StatefulSetTimeout,
@ -263,13 +263,13 @@ func WaitForStatusReplicas(c clientset.Interface, ss *appsv1.StatefulSet, expect
return false, nil return false, nil
} }
if ssGet.Status.Replicas != expectedReplicas { if ssGet.Status.Replicas != expectedReplicas {
e2elog.Logf("Waiting for stateful set status.replicas to become %d, currently %d", expectedReplicas, ssGet.Status.Replicas) framework.Logf("Waiting for stateful set status.replicas to become %d, currently %d", expectedReplicas, ssGet.Status.Replicas)
return false, nil return false, nil
} }
return true, nil return true, nil
}) })
if pollErr != nil { if pollErr != nil {
e2elog.Failf("Failed waiting for stateful set status.replicas updated to %d: %v", expectedReplicas, pollErr) framework.Failf("Failed waiting for stateful set status.replicas updated to %d: %v", expectedReplicas, pollErr)
} }
} }
@ -277,9 +277,9 @@ func WaitForStatusReplicas(c clientset.Interface, ss *appsv1.StatefulSet, expect
func Saturate(c clientset.Interface, ss *appsv1.StatefulSet) { func Saturate(c clientset.Interface, ss *appsv1.StatefulSet) {
var i int32 var i int32
for i = 0; i < *(ss.Spec.Replicas); i++ { for i = 0; i < *(ss.Spec.Replicas); i++ {
e2elog.Logf("Waiting for stateful pod at index %v to enter Running", i) framework.Logf("Waiting for stateful pod at index %v to enter Running", i)
WaitForRunning(c, i+1, i, ss) WaitForRunning(c, i+1, i, ss)
e2elog.Logf("Resuming stateful pod at index %v", i) framework.Logf("Resuming stateful pod at index %v", i)
ResumeNextPod(c, ss) ResumeNextPod(c, ss)
} }
} }