func (config *KubeProxyTestConfig) dialFromNode(protocol, targetIP string, targetPort, tries, expectedCount int) { var cmd string if protocol == "udp" { cmd = fmt.Sprintf("echo 'hostName' | timeout -t 3 nc -w 1 -u %s %d", targetIP, targetPort) } else { cmd = fmt.Sprintf("curl -s --connect-timeout 1 http://%s:%d/hostName", targetIP, targetPort) } // TODO: This simply tells us that we can reach the endpoints. Check that // the probability of hitting a specific endpoint is roughly the same as // hitting any other. forLoop := fmt.Sprintf("for i in $(seq 1 %d); do %s; echo; sleep %v; done | grep -v '^\\s*$' |sort | uniq -c | wc -l", tries, cmd, hitEndpointRetryDelay) By(fmt.Sprintf("Dialing from node. command:%s", forLoop)) stdout := framework.RunHostCmdOrDie(config.f.Namespace.Name, config.hostTestContainerPod.Name, forLoop) Expect(strconv.Atoi(strings.TrimSpace(stdout))).To(BeNumerically("==", expectedCount)) }
func (config *PrivilegedPodTestConfig) dialFromContainer(containerIP string, containerHttpPort int) map[string]string { v := url.Values{} v.Set("shellCommand", "ip link add dummy1 type dummy") cmd := fmt.Sprintf("curl -q 'http://%s:%d/shell?%s'", containerIP, containerHttpPort, v.Encode()) By(fmt.Sprintf("Exec-ing into container over http. Running command:%s", cmd)) stdout := framework.RunHostCmdOrDie(config.hostExecPod.Namespace, config.hostExecPod.Name, cmd) var output map[string]string err := json.Unmarshal([]byte(stdout), &output) Expect(err).NotTo(HaveOccurred(), fmt.Sprintf("Could not unmarshal curl response: %s", stdout)) framework.Logf("Deserialized output is %v", stdout) return output }
func (config *KubeProxyTestConfig) dialFromContainer(protocol, containerIP, targetIP string, containerHttpPort, targetPort, tries, expectedCount int) { cmd := fmt.Sprintf("curl -q 'http://%s:%d/dial?request=hostName&protocol=%s&host=%s&port=%d&tries=%d'", containerIP, containerHttpPort, protocol, targetIP, targetPort, tries) By(fmt.Sprintf("Dialing from container. Running command:%s", cmd)) stdout := framework.RunHostCmdOrDie(config.f.Namespace.Name, config.hostTestContainerPod.Name, cmd) var output map[string][]string err := json.Unmarshal([]byte(stdout), &output) Expect(err).NotTo(HaveOccurred(), fmt.Sprintf("Could not unmarshal curl response: %s", stdout)) hostNamesMap := array2map(output["responses"]) Expect(len(hostNamesMap)).To(BeNumerically("==", expectedCount), fmt.Sprintf("Response was:%v", output)) }
options := nat.CloseWaitClientOptions{ RemoteAddr: fmt.Sprintf("%v:%v", serverNodeInfo.nodeIp, testDaemonTcpPort), TimeoutSeconds: timeoutSeconds, PostFinTimeoutSeconds: 0, LeakConnection: true, } jsonBytes, err := json.Marshal(options) cmd := fmt.Sprintf( `curl -X POST http://localhost:%v/run/nat-closewait-client -d `+ `'%v' 2>/dev/null`, testDaemonHttpPort, string(jsonBytes)) framework.RunHostCmdOrDie(fr.Namespace.Name, "e2e-net-client", cmd) <-time.After(time.Duration(1) * time.Second) By("Checking /proc/net/nf_conntrack for the timeout") // If test flakes occur here, then this check should be performed // in a loop as there may be a race with the client connecting. framework.IssueSSHCommandWithResult( fmt.Sprintf("sudo cat /proc/net/ip_conntrack | grep 'dport=%v'", testDaemonTcpPort), framework.TestContext.Provider, clientNodeInfo.node) // Timeout in seconds is available as the third column from // /proc/net/ip_conntrack. result, err := framework.IssueSSHCommandWithResult(
// GetSelfURL executes a curl against the given path via kubectl exec into a // test container running with host networking, and fails if the output // doesn't match the expected string. func (config *NetworkingTestConfig) GetSelfURL(path string, expected string) { cmd := fmt.Sprintf("curl -q -s --connect-timeout 1 http://localhost:10249%s", path) By(fmt.Sprintf("Getting kube-proxy self URL %s", path)) stdout := framework.RunHostCmdOrDie(config.Namespace, config.HostTestContainerPod.Name, cmd) Expect(strings.Contains(stdout, expected)).To(BeTrue()) }