remove some cri-o container tests

Because we removed containernetworking-plugins, we can't run containers without ovn-kubernetes.

Author: bitoku

mantle/kola/tests/crio/crio.go

@@ -17,23 +17,12 @@ package crio
 import (
 	"encoding/json"
 	"fmt"
-	"os"
-	"path"
-	"strings"
-	"time"
-
-	"golang.org/x/crypto/ssh"
-	"golang.org/x/net/context"
 
 	"github.com/coreos/coreos-assembler/mantle/kola"
 	"github.com/coreos/coreos-assembler/mantle/kola/cluster"
 	"github.com/coreos/coreos-assembler/mantle/kola/register"
-	"github.com/coreos/coreos-assembler/mantle/kola/tests/util"
-	"github.com/coreos/coreos-assembler/mantle/lang/worker"
 	"github.com/coreos/coreos-assembler/mantle/platform"
 	"github.com/coreos/coreos-assembler/mantle/platform/conf"
-
-	"github.com/google/uuid"
 )
 
 // simplifiedCrioInfo represents the results from crio info
@@ -191,214 +180,18 @@ func init() {
 		Run:         crioBaseTests,
 		ClusterSize: 1,
 		Name:        `crio.base`,
-		Description: "Verify cri-o basic funcions work, include storage driver is overlay, storage root is /varlib/containers/storage, cgroup driver is systemd, and cri-o containers have reliable networking",
+		Description: "Verify cri-o basic funcions work, include storage driver is overlay, storage root is /varlib/containers/storage, cgroup driver is systemd",
 		Distros:     []string{"rhcos"},
 		UserData:    enableCrioIgn,
 		// crio pods require fetching a kubernetes pause image
 		Tags:        []string{"crio", kola.NeedsInternetTag},
 		RequiredTag: "openshift",
 	})
-	register.RegisterTest(&register.Test{
-		Run:         crioNetwork,
-		ClusterSize: 2,
-		Name:        "crio.network",
-		Description: "Verify crio containers can make network connections outside of the host.",
-		Distros:     []string{"rhcos"},
-		UserData:    enableCrioIgn,
-		// this test requires net connections outside the host
-		Tags:        []string{"crio", kola.NeedsInternetTag},
-		RequiredTag: "openshift",
-		// qemu machines cannot communicate between each other
-		ExcludePlatforms: []string{"qemu"},
-	})
 }
 
 // crioBaseTests executes multiple tests under the "base" name
 func crioBaseTests(c cluster.TestCluster) {
 	c.Run("crio-info", testCrioInfo)
-	c.Run("pod-continues-during-service-restart", crioPodContinuesDuringServiceRestart)
-	c.Run("networks-reliably", crioNetworksReliably)
-}
-
-// generateCrioConfig generates a crio pod/container configuration
-// based on the input name and arguments returning the path to the generated configs.
-func generateCrioConfig(podName, imageName string, command []string) (string, string, error) {
-	fileContentsPod := fmt.Sprintf(crioPodTemplate, podName, uuid.New().String(), imageName)
-
-	tmpFilePod, err := os.CreateTemp("", podName+"Pod")
-	if err != nil {
-		return "", "", err
-	}
-	defer tmpFilePod.Close()
-	if _, err = tmpFilePod.Write([]byte(fileContentsPod)); err != nil {
-		return "", "", err
-	}
-	cmd := strings.Join(command, " ")
-	fileContentsContainer := fmt.Sprintf(crioContainerTemplate, imageName, imageName, cmd)
-
-	tmpFileContainer, err := os.CreateTemp("", imageName+"Container")
-	if err != nil {
-		return "", "", err
-	}
-	defer tmpFileContainer.Close()
-	if _, err = tmpFileContainer.Write([]byte(fileContentsContainer)); err != nil {
-		return "", "", err
-	}
-
-	return tmpFilePod.Name(), tmpFileContainer.Name(), nil
-}
-
-// genContainer makes a container out of binaries on the host. This function uses podman to build.
-// The first string returned by this function is the pod config to be used with crictl runp. The second
-// string returned is the container config to be used with crictl create/exec. They will be dropped
-// on to all machines in the cluster as ~/$STRING_RETURNED_FROM_FUNCTION. Note that the string returned
-// here is just the name, not the full path on the cluster machine(s).
-func genContainer(c cluster.TestCluster, m platform.Machine, podName, imageName string, binnames []string, shellCommands []string) (string, string, error) {
-	configPathPod, configPathContainer, err := generateCrioConfig(podName, imageName, shellCommands)
-	if err != nil {
-		return "", "", err
-	}
-	if err = cluster.DropFile(c.Machines(), configPathPod); err != nil {
-		return "", "", err
-	}
-	if err = cluster.DropFile(c.Machines(), configPathContainer); err != nil {
-		return "", "", err
-	}
-	// Create the crio image used for testing, only if it doesn't exist already
-	output := c.MustSSH(m, "sudo podman images -n --format '{{.Repository}}'")
-	if !strings.Contains(string(output), "localhost/"+imageName) {
-		util.GenPodmanScratchContainer(c, m, imageName, binnames)
-	}
-
-	return path.Base(configPathPod), path.Base(configPathContainer), nil
-}
-
-// crioNetwork ensures that crio containers can make network connections outside of the host
-func crioNetwork(c cluster.TestCluster) {
-	machines := c.Machines()
-	src, dest := machines[0], machines[1]
-
-	c.Log("creating ncat containers")
-
-	// Since genContainer also generates crio pod/container configs,
-	// there will be a duplicate config file on each machine.
-	// Thus we only save one set for later use.
-	crioConfigPod, crioConfigContainer, err := genContainer(c, src, "ncat", "ncat", []string{"ncat", "echo"}, []string{"ncat"})
-	if err != nil {
-		c.Fatal(err)
-	}
-	_, _, err = genContainer(c, dest, "ncat", "ncat", []string{"ncat", "echo"}, []string{"ncat"})
-	if err != nil {
-		c.Fatal(err)
-	}
-
-	listener := func(ctx context.Context) error {
-		podID, err := c.SSHf(dest, "sudo crictl runp -T %s %s", overrideCrioOperationTimeoutSeconds, crioConfigPod)
-		if err != nil {
-			return err
-		}
-
-		containerID, err := c.SSHf(dest, "sudo crictl create -T %s --no-pull %s %s %s",
-			overrideCrioOperationTimeoutSeconds,
-			podID, crioConfigContainer, crioConfigPod)
-		if err != nil {
-			return err
-		}
-
-		// This command will block until a message is recieved
-		output, err := c.SSHf(dest, "sudo timeout 30 crictl exec %s echo 'HELLO FROM SERVER' | timeout 20 ncat --listen 0.0.0.0 9988 || echo 'LISTENER TIMEOUT'", containerID)
-		if err != nil {
-			return err
-		}
-		if string(output) != "HELLO FROM CLIENT" {
-			return fmt.Errorf("unexpected result from listener: %s", output)
-		}
-
-		return nil
-	}
-
-	talker := func(ctx context.Context) error {
-		// Wait until listener is ready before trying anything
-		for {
-			_, err := c.SSH(dest, "sudo ss -tulpn|grep 9988")
-			if err == nil {
-				break // socket is ready
-			}
-
-			exit, ok := err.(*ssh.ExitError)
-			if !ok || exit.Waitmsg.ExitStatus() != 1 { // 1 is the expected exit of grep -q
-				return err
-			}
-
-			select {
-			case <-ctx.Done():
-				return fmt.Errorf("timeout waiting for server")
-			default:
-				time.Sleep(100 * time.Millisecond)
-			}
-		}
-		podID, err := c.SSHf(src, "sudo crictl runp -T %s %s", overrideCrioOperationTimeoutSeconds, crioConfigPod)
-		if err != nil {
-			return err
-		}
-
-		containerID, err := c.SSHf(src, "sudo crictl create -T %s --no-pull %s %s %s",
-			overrideCrioOperationTimeoutSeconds,
-			podID, crioConfigContainer, crioConfigPod)
-		if err != nil {
-			return err
-		}
-
-		output, err := c.SSHf(src, "sudo crictl exec %s echo 'HELLO FROM CLIENT' | ncat %s 9988",
-			containerID, dest.PrivateIP())
-		if err != nil {
-			return err
-		}
-		if string(output) != "HELLO FROM SERVER" {
-			return fmt.Errorf(`unexpected result from listener: "%s"`, output)
-		}
-
-		return nil
-	}
-
-	ctx, cancel := context.WithTimeout(context.Background(), time.Minute)
-	defer cancel()
-
-	if err := worker.Parallel(ctx, listener, talker); err != nil {
-		c.Fatal(err)
-	}
-}
-
-// crioNetworksReliably verifies that crio containers have a reliable network
-func crioNetworksReliably(c cluster.TestCluster) {
-	m := c.Machines()[0]
-	hostIP := "127.0.0.1"
-
-	// Here we generate 10 pods, each will run a container responsible for
-	// pinging to host
-	output := ""
-	for x := 1; x <= 10; x++ {
-		// append int to name to avoid pod name collision
-		crioConfigPod, crioConfigContainer, err := genContainer(
-			c, m, fmt.Sprintf("ping%d", x), "ping", []string{"ping"},
-			[]string{"ping"})
-		if err != nil {
-			c.Fatal(err)
-		}
-
-		cmdCreatePod := fmt.Sprintf("sudo crictl runp -T %s %s", overrideCrioOperationTimeoutSeconds, crioConfigPod)
-		podID := c.MustSSH(m, cmdCreatePod)
-		containerID := c.MustSSH(m, fmt.Sprintf("sudo crictl create -T %s --no-pull %s %s %s",
-			overrideCrioOperationTimeoutSeconds,
-			podID, crioConfigContainer, crioConfigPod))
-		output = output + string(c.MustSSH(m, fmt.Sprintf("sudo crictl exec %s ping -i 0.2 %s -w 1 >/dev/null && echo PASS || echo FAIL", containerID, hostIP)))
-	}
-
-	numPass := strings.Count(string(output), "PASS")
-	if numPass != 10 {
-		c.Fatalf("Expected 10 passes, but received %d passes with output: %s", numPass, output)
-	}
-
 }
 
 // getCrioInfo parses and returns the information crio provides via socket
@@ -437,32 +230,3 @@ func testCrioInfo(c cluster.TestCluster) {
 	}
 
 }
-
-// crioPodContinuesDuringServiceRestart verifies that a crio pod does not
-// stop when the service is restarted
-func crioPodContinuesDuringServiceRestart(c cluster.TestCluster) {
-	m := c.Machines()[0]
-
-	crioConfigPod, crioConfigContainer, err := genContainer(
-		c, m, "restart-test", "sleep",
-		[]string{"bash", "sleep", "echo"}, []string{"bash"})
-	if err != nil {
-		c.Fatal(err)
-	}
-	cmdCreatePod := fmt.Sprintf("sudo crictl runp -T %s %s", overrideCrioOperationTimeoutSeconds, crioConfigPod)
-	podID := c.MustSSH(m, cmdCreatePod)
-	containerID := c.MustSSH(m, fmt.Sprintf("sudo crictl create -T %s --no-pull %s %s %s",
-		overrideCrioOperationTimeoutSeconds,
-		podID, crioConfigContainer, crioConfigPod))
-
-	cmd := fmt.Sprintf("sudo crictl exec %s bash -c \"sleep 25 && echo PASS > /tmp/test/restart-test\"", containerID)
-	c.RunCmdSync(m, cmd)
-	time.Sleep(3 * time.Second)
-	c.RunCmdSync(m, "sudo systemctl restart crio")
-	time.Sleep(25 * time.Second)
-	output := strings.TrimSuffix(string(c.MustSSH(m, "cat /tmp/test/restart-test")), "\n")
-
-	if output != "PASS" {
-		c.Fatalf("Pod did not continue during service restart. Output=%s, Command=%s", output, cmd)
-	}
-}