func InMultiTenantContext(body func()) {
Context("when using a multi-tenant plugin", func() {
BeforeEach(func() {
if !pluginIsolatesNamespaces() {
e2e.Skipf("Not a multi-tenant plugin.")
}
})
body()
})
}
func InSingleTenantContext(body func()) {
Context("when using a single-tenant plugin", func() {
BeforeEach(func() {
if pluginIsolatesNamespaces() {
e2e.Skipf("Not a single-tenant plugin.")
}
})
body()
})
}
// Detects whether the federation namespace exists in the underlying cluster
func SkipUnlessFederated(c clientset.Interface) {
federationNS := os.Getenv("FEDERATION_NAMESPACE")
if federationNS == "" {
federationNS = federationapi.FederationNamespaceSystem
}
_, err := c.Core().Namespaces().Get(federationNS, metav1.GetOptions{})
if err != nil {
if apierrors.IsNotFound(err) {
framework.Skipf("Could not find federation namespace %s: skipping federated test", federationNS)
} else {
framework.Failf("Unexpected error getting namespace: %v", err)
}
}
}
func checkPodIsolation(f1, f2 *e2e.Framework, nodeType NodeType) error {
nodes := e2e.GetReadySchedulableNodesOrDie(f1.Client)
var serverNode, clientNode *api.Node
serverNode = &nodes.Items[0]
if nodeType == DIFFERENT_NODE {
if len(nodes.Items) == 1 {
e2e.Skipf("Only one node is available in this environment")
}
clientNode = &nodes.Items[1]
} else {
clientNode = serverNode
}
podName := "isolation-webserver"
defer f1.Client.Pods(f1.Namespace.Name).Delete(podName, nil)
ip := e2e.LaunchWebserverPod(f1, podName, serverNode.Name)
return checkConnectivityToHost(f2, clientNode.Name, "isolation-wget", ip, 10)
}
func checkServiceConnectivity(serverFramework, clientFramework *e2e.Framework, numNodes int) error {
nodes := e2e.GetReadySchedulableNodesOrDie(serverFramework.Client)
var serverNode, clientNode *api.Node
serverNode = &nodes.Items[0]
if numNodes == 2 {
if len(nodes.Items) == 1 {
e2e.Skipf("Only one node is available in this environment")
}
clientNode = &nodes.Items[1]
} else {
clientNode = serverNode
}
podName := "service-webserver"
defer serverFramework.Client.Pods(serverFramework.Namespace.Name).Delete(podName, nil)
ip := launchWebserverService(serverFramework, podName, serverNode.Name)
return checkConnectivityToHost(clientFramework, clientNode.Name, "service-wget", ip, 10)
}
func checkServiceConnectivity(serverFramework, clientFramework *e2e.Framework, nodeType NodeType) error {
nodes := e2e.GetReadySchedulableNodesOrDie(serverFramework.Client)
var serverNode, clientNode *api.Node
serverNode = &nodes.Items[0]
if nodeType == DIFFERENT_NODE {
if len(nodes.Items) == 1 {
e2e.Skipf("Only one node is available in this environment")
}
clientNode = &nodes.Items[1]
} else {
clientNode = serverNode
}
podName := api.SimpleNameGenerator.GenerateName(fmt.Sprintf("service-"))
defer serverFramework.Client.Pods(serverFramework.Namespace.Name).Delete(podName, nil)
defer serverFramework.Client.Services(serverFramework.Namespace.Name).Delete(podName)
ip := launchWebserverService(serverFramework, podName, serverNode.Name)
return checkConnectivityToHost(clientFramework, clientNode.Name, "service-wget", ip, 10)
}
func checkPodIsolation(f1, f2 *e2e.Framework, numNodes int) error {
nodes, err := e2e.GetReadyNodes(f1)
if err != nil {
e2e.Failf("Failed to list nodes: %v", err)
}
var serverNode, clientNode *api.Node
serverNode = &nodes.Items[0]
if numNodes == 2 {
if len(nodes.Items) == 1 {
e2e.Skipf("Only one node is available in this environment")
}
clientNode = &nodes.Items[1]
} else {
clientNode = serverNode
}
podName := "isolation-webserver"
defer f1.Client.Pods(f1.Namespace.Name).Delete(podName, nil)
ip := e2e.LaunchWebserverPod(f1, podName, serverNode.Name)
return checkConnectivityToHost(f2, clientNode.Name, "isolation-wget", ip, 10)
}
const (
testDaemonHttpPort = 11301
testDaemonTcpPort = 11302
timeoutSeconds = 10
postFinTimeoutSeconds = 5
)
fr := framework.NewDefaultFramework("network")
It("should set TCP CLOSE_WAIT timeout", func() {
nodes := framework.GetReadySchedulableNodesOrDie(fr.ClientSet)
ips := collectAddresses(nodes, api.NodeInternalIP)
if len(nodes.Items) < 2 {
framework.Skipf(
"Test requires >= 2 Ready nodes, but there are only %v nodes",
len(nodes.Items))
}
type NodeInfo struct {
node *api.Node
name string
nodeIp string
}
clientNodeInfo := NodeInfo{
node: &nodes.Items[0],
name: nodes.Items[0].Name,
nodeIp: ips[0],
}
Value: "1",
},
})
pod.Spec.Containers[0].Command = []string{"/bin/sysctl", "kernel.shm_rmid_forced"}
By("Creating a pod with the kernel.shm_rmid_forced sysctl")
pod = podClient.Create(pod)
By("Watching for error events or started pod")
// watch for events instead of termination of pod because the kubelet deletes
// failed pods without running containers. This would create a race as the pod
// might have already been deleted here.
ev, err := waitForPodErrorEventOrStarted(pod)
Expect(err).NotTo(HaveOccurred())
if ev != nil && ev.Reason == sysctl.UnsupportedReason {
framework.Skipf("No sysctl support in Docker <1.12")
}
Expect(ev).To(BeNil())
By("Waiting for pod completion")
err = f.WaitForPodNoLongerRunning(pod.Name)
Expect(err).NotTo(HaveOccurred())
pod, err = podClient.Get(pod.Name, metav1.GetOptions{})
Expect(err).NotTo(HaveOccurred())
By("Checking that the pod succeeded")
Expect(pod.Status.Phase).To(Equal(v1.PodSucceeded))
By("Getting logs from the pod")
log, err := framework.GetPodLogs(f.ClientSet, f.Namespace.Name, pod.Name, pod.Spec.Containers[0].Name)
Expect(err).NotTo(HaveOccurred())
. "github.com/onsi/gomega"
)
var _ = framework.KubeDescribe("Kubernetes Dashboard", func() {
const (
uiServiceName = "kubernetes-dashboard"
uiAppName = uiServiceName
uiNamespace = api.NamespaceSystem
serverStartTimeout = 1 * time.Minute
)
f := framework.NewDefaultFramework(uiServiceName)
It("should check that the kubernetes-dashboard instance is alive", func() {
framework.Skipf("UI is disabled")
By("Checking whether the kubernetes-dashboard service exists.")
err := framework.WaitForService(f.Client, uiNamespace, uiServiceName, true, framework.Poll, framework.ServiceStartTimeout)
Expect(err).NotTo(HaveOccurred())
By("Checking to make sure the kubernetes-dashboard pods are running")
selector := labels.SelectorFromSet(labels.Set(map[string]string{"k8s-app": uiAppName}))
err = framework.WaitForPodsWithLabelRunning(f.Client, uiNamespace, selector)
Expect(err).NotTo(HaveOccurred())
By("Checking to make sure we get a response from the kubernetes-dashboard.")
err = wait.Poll(framework.Poll, serverStartTimeout, func() (bool, error) {
var status int
proxyRequest, errProxy := framework.GetServicesProxyRequest(f.Client, f.Client.Get())
if errProxy != nil {
framework.Logf("Get services proxy request failed: %v", errProxy)
f := framework.NewDefaultFramework("kubelet-eviction-manager")
var podClient *framework.PodClient
var c clientset.Interface
BeforeEach(func() {
podClient = f.PodClient()
c = f.ClientSet
})
Describe("hard eviction test", func() {
Context("pod using the most disk space gets evicted when the node disk usage is above the eviction hard threshold", func() {
var busyPodName, idlePodName, verifyPodName string
BeforeEach(func() {
if !isImageSupported() {
framework.Skipf("test skipped because the image is not supported by the test")
}
if !evictionOptionIsSet() {
framework.Skipf("test skipped because eviction option is not set")
}
busyPodName = "to-evict" + string(uuid.NewUUID())
idlePodName = "idle" + string(uuid.NewUUID())
verifyPodName = "verify" + string(uuid.NewUUID())
createIdlePod(idlePodName, podClient)
podClient.Create(&api.Pod{
ObjectMeta: api.ObjectMeta{
Name: busyPodName,
},
Spec: api.PodSpec{
RestartPolicy: api.RestartPolicyNever,
framework.RunKubectlOrDie("create", "-f", adminServiceYaml, nsFlag)
framework.RunKubectlOrDie("create", "-f", adminPodYaml, nsFlag)
err = framework.WaitForPodNameRunningInNamespace(c, "rethinkdb-admin", ns)
Expect(err).NotTo(HaveOccurred())
checkDbInstances()
content, err := makeHttpRequestToService(c, ns, "rethinkdb-admin", "/", framework.EndpointRegisterTimeout)
Expect(err).NotTo(HaveOccurred())
if !strings.Contains(content, "<title>RethinkDB Administration Console</title>") {
framework.Failf("RethinkDB console is not running")
}
})
})
framework.KubeDescribe("Hazelcast", func() {
It("should create and scale hazelcast", func() {
framework.Skipf("Skipping because of upstream race condition. Remove Skip when https://github.com/pires/hazelcast-kubernetes-bootstrapper/issues/9 is fixed")
mkpath := func(file string) string {
return filepath.Join(framework.TestContext.RepoRoot, "examples/storage/hazelcast", file)
}
serviceYaml := mkpath("hazelcast-service.yaml")
controllerYaml := mkpath("hazelcast-controller.yaml")
nsFlag := fmt.Sprintf("--namespace=%v", ns)
By("starting hazelcast")
framework.RunKubectlOrDie("create", "-f", serviceYaml, nsFlag)
framework.RunKubectlOrDie("create", "-f", controllerYaml, nsFlag)
label := labels.SelectorFromSet(labels.Set(map[string]string{"name": "hazelcast"}))
err := framework.WaitForPodsWithLabelRunning(c, ns, label)
Expect(err).NotTo(HaveOccurred())
forEachPod("name", "hazelcast", func(pod api.Pod) {
}
// These tests need privileged containers, which are disabled by default. Run
// the test with "go run hack/e2e.go ... --ginkgo.focus=[Feature:Volumes]"
var _ = framework.KubeDescribe("GCP Volumes", func() {
f := framework.NewDefaultFramework("gcp-volume")
// If 'false', the test won't clear its volumes upon completion. Useful for debugging,
// note that namespace deletion is handled by delete-namespace flag
clean := true
// filled in BeforeEach
var namespace *v1.Namespace
BeforeEach(func() {
if !isTestEnabled(f.ClientSet) {
framework.Skipf("NFS tests are not supported for this distro")
}
namespace = f.Namespace
})
////////////////////////////////////////////////////////////////////////
// NFS
////////////////////////////////////////////////////////////////////////
framework.KubeDescribe("NFSv4", func() {
It("should be mountable for NFSv4 [Volume]", func() {
config := VolumeTestConfig{
namespace: namespace.Name,
prefix: "nfs",
serverImage: "gcr.io/google_containers/volume-nfs:0.8",
serverPorts: []int{2049},
// How long to wait for a scheduledjob
scheduledJobTimeout = 5 * time.Minute
)
var _ = framework.KubeDescribe("ScheduledJob", func() {
options := framework.FrameworkOptions{
ClientQPS: 20,
ClientBurst: 50,
GroupVersion: &unversioned.GroupVersion{Group: batch.GroupName, Version: "v2alpha1"},
}
f := framework.NewFramework("scheduledjob", options, nil)
BeforeEach(func() {
if _, err := f.Client.Batch().ScheduledJobs(f.Namespace.Name).List(api.ListOptions{}); err != nil {
if apierrs.IsNotFound(err) {
framework.Skipf("Could not find ScheduledJobs resource, skipping test: %#v", err)
}
}
})
// multiple jobs running at once
It("should schedule multiple jobs concurrently", func() {
By("Creating a scheduledjob")
scheduledJob := newTestScheduledJob("concurrent", "*/1 * * * ?", batch.AllowConcurrent, true)
scheduledJob, err := createScheduledJob(f.Client, f.Namespace.Name, scheduledJob)
Expect(err).NotTo(HaveOccurred())
By("Ensuring more than one job is running at a time")
err = waitForActiveJobs(f.Client, f.Namespace.Name, scheduledJob.Name, 2)
Expect(err).NotTo(HaveOccurred())
defer f.Client.Pods(f.Namespace.Name).Delete(podName, nil)
ip := framework.LaunchWebserverPod(f, podName, node.Name)
By("Checking that the webserver is accessible from a pod on the same node")
framework.ExpectNoError(framework.CheckConnectivityToHost(f, node.Name, "same-node-wget", ip, connectivityTimeout))
})
It("should function for pod communication between nodes", func() {
podClient := f.Client.Pods(f.Namespace.Name)
By("Picking multiple nodes")
nodes := framework.GetReadySchedulableNodesOrDie(f.Client)
if len(nodes.Items) == 1 {
framework.Skipf("The test requires two Ready nodes on %s, but found just one.", framework.TestContext.Provider)
}
node1 := nodes.Items[0]
node2 := nodes.Items[1]
By("Creating a webserver pod")
podName := "different-node-webserver"
defer podClient.Delete(podName, nil)
ip := framework.LaunchWebserverPod(f, podName, node1.Name)
By("Checking that the webserver is accessible from a pod on a different node")
framework.ExpectNoError(framework.CheckConnectivityToHost(f, node2.Name, "different-node-wget", ip, connectivityTimeout))
})
})
})