mirror of
https://github.com/hanzo-ml/kuberay.git
synced 2026-10-30 19:48:47 +00:00
180 lines
5.2 KiB
Go
180 lines
5.2 KiB
Go
package support
|
|
|
|
import (
|
|
"bytes"
|
|
"fmt"
|
|
"io"
|
|
"net/http"
|
|
"strings"
|
|
|
|
. "github.com/onsi/ginkgo/v2"
|
|
"github.com/onsi/gomega"
|
|
"github.com/stretchr/testify/require"
|
|
corev1 "k8s.io/api/core/v1"
|
|
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
|
|
clientgoscheme "k8s.io/client-go/kubernetes/scheme"
|
|
"k8s.io/client-go/tools/portforward"
|
|
"k8s.io/client-go/tools/remotecommand"
|
|
"k8s.io/client-go/transport/spdy"
|
|
)
|
|
|
|
func Pods(t Test, namespace string, options ...Option[*metav1.ListOptions]) func(g gomega.Gomega) []corev1.Pod {
|
|
return func(g gomega.Gomega) []corev1.Pod {
|
|
listOptions := &metav1.ListOptions{}
|
|
|
|
for _, option := range options {
|
|
g.Expect(option.applyTo(listOptions)).To(gomega.Succeed())
|
|
}
|
|
|
|
pods, err := t.Client().Core().CoreV1().Pods(namespace).List(t.Ctx(), *listOptions)
|
|
g.Expect(err).NotTo(gomega.HaveOccurred())
|
|
return pods.Items
|
|
}
|
|
}
|
|
|
|
func storeAllPodLogs(t Test, namespace *corev1.Namespace) {
|
|
t.T().Helper()
|
|
|
|
pods, err := t.Client().Core().CoreV1().Pods(namespace.Name).List(t.Ctx(), metav1.ListOptions{})
|
|
require.NoError(t.T(), err)
|
|
|
|
for _, pod := range pods.Items {
|
|
for _, container := range pod.Spec.Containers {
|
|
LogWithTimestamp(t.T(), "Retrieving Pod Container %s/%s/%s logs", pod.Namespace, pod.Name, container.Name)
|
|
storeContainerLog(t, namespace, pod.Name, container.Name)
|
|
}
|
|
}
|
|
}
|
|
|
|
func storeContainerLog(t Test, namespace *corev1.Namespace, podName, containerName string) {
|
|
t.T().Helper()
|
|
|
|
options := corev1.PodLogOptions{Container: containerName}
|
|
stream, err := t.Client().Core().CoreV1().Pods(namespace.Name).GetLogs(podName, &options).Stream(t.Ctx())
|
|
if err != nil {
|
|
LogWithTimestamp(t.T(), "Error getting logs from container %s/%s/%s", namespace.Name, podName, containerName)
|
|
return
|
|
}
|
|
require.NoError(t.T(), err)
|
|
|
|
defer func() {
|
|
require.NoError(t.T(), stream.Close())
|
|
}()
|
|
|
|
bytes, err := io.ReadAll(stream)
|
|
require.NoError(t.T(), err)
|
|
|
|
containerLogFileName := "pod-" + podName + "-" + containerName
|
|
WriteToOutputDir(t, containerLogFileName, Log, bytes)
|
|
}
|
|
|
|
func ExecPodCmd(t Test, pod *corev1.Pod, containerName string, cmd []string) (bytes.Buffer, bytes.Buffer) {
|
|
req := t.Client().Core().CoreV1().RESTClient().
|
|
Post().
|
|
Resource("pods").
|
|
Name(pod.Name).
|
|
Namespace(pod.Namespace).
|
|
SubResource("exec").
|
|
VersionedParams(&corev1.PodExecOptions{
|
|
Command: cmd,
|
|
Container: containerName,
|
|
Stdin: false,
|
|
Stdout: true,
|
|
Stderr: true,
|
|
TTY: false,
|
|
}, clientgoscheme.ParameterCodec)
|
|
|
|
LogWithTimestamp(t.T(), "Executing command: %s", cmd)
|
|
cfg := t.Client().Config()
|
|
exec, err := remotecommand.NewSPDYExecutor(&cfg, "POST", req.URL())
|
|
require.NoError(t.T(), err)
|
|
// Capture the output streams
|
|
var stdout, stderr bytes.Buffer
|
|
// Execute the command in the pod
|
|
err = exec.StreamWithContext(t.Ctx(), remotecommand.StreamOptions{
|
|
Stdin: nil,
|
|
Stdout: &stdout,
|
|
Stderr: &stderr,
|
|
Tty: false,
|
|
})
|
|
LogWithTimestamp(t.T(), "Command stdout: %s", stdout.String())
|
|
LogWithTimestamp(t.T(), "Command stderr: %s", stderr.String())
|
|
require.NoError(t.T(), err)
|
|
return stdout, stderr
|
|
}
|
|
|
|
func SetupPortForward(t Test, podName, namespace string, localPort, remotePort int) (chan struct{}, error) {
|
|
cfg := t.Client().Config()
|
|
|
|
req := t.Client().Core().CoreV1().RESTClient().
|
|
Post().
|
|
Resource("pods").
|
|
Namespace(namespace).
|
|
Name(podName).
|
|
SubResource("portforward")
|
|
|
|
transport, upgrader, err := spdy.RoundTripperFor(&cfg)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
stopChan := make(chan struct{}, 1)
|
|
readyChan := make(chan struct{}, 1)
|
|
out := new(strings.Builder)
|
|
errOut := new(strings.Builder)
|
|
|
|
// create port forward
|
|
forwarder, err := portforward.New(
|
|
spdy.NewDialer(upgrader, &http.Client{Transport: transport}, http.MethodPost, req.URL()),
|
|
[]string{fmt.Sprintf("%d:%d", localPort, remotePort)},
|
|
stopChan,
|
|
readyChan,
|
|
out,
|
|
errOut,
|
|
)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
// launch Port Forward
|
|
go func() {
|
|
defer GinkgoRecover()
|
|
err := forwarder.ForwardPorts()
|
|
require.NoError(t.T(), err)
|
|
}()
|
|
<-readyChan // wait for port forward to finish
|
|
|
|
return stopChan, nil
|
|
}
|
|
|
|
func CreateCurlPod(g *gomega.WithT, t Test, podName, containerName, namespace string) (*corev1.Pod, error) {
|
|
// Define the podSpec spec
|
|
podSpec := &corev1.Pod{
|
|
ObjectMeta: metav1.ObjectMeta{
|
|
Name: podName,
|
|
Namespace: namespace,
|
|
},
|
|
Spec: corev1.PodSpec{
|
|
Containers: []corev1.Container{
|
|
{
|
|
Name: containerName,
|
|
Image: "rancher/curl",
|
|
Command: []string{"/bin/sh", "-c", "tail -f /dev/null"},
|
|
},
|
|
},
|
|
},
|
|
}
|
|
|
|
curlPod, err := t.Client().Core().CoreV1().Pods(namespace).Create(t.Ctx(), podSpec, metav1.CreateOptions{})
|
|
g.Expect(err).NotTo(gomega.HaveOccurred())
|
|
// Wait until curl pod is created
|
|
g.Eventually(func(g gomega.Gomega) *corev1.Pod {
|
|
updatedCurlPod, err := t.Client().Core().CoreV1().Pods(curlPod.Namespace).Get(t.Ctx(), curlPod.Name, metav1.GetOptions{})
|
|
g.Expect(err).NotTo(gomega.HaveOccurred())
|
|
return updatedCurlPod
|
|
}, TestTimeoutShort).Should(gomega.WithTransform(IsPodRunningAndReady, gomega.BeTrue()))
|
|
|
|
LogWithTimestamp(t.T(), "Curl pod %s/%s is running and ready", curlPod.Namespace, curlPod.Name)
|
|
return t.Client().Core().CoreV1().Pods(curlPod.Namespace).Get(t.Ctx(), curlPod.Name, metav1.GetOptions{})
|
|
}
|