Skip to content

Commit

Permalink
tests, windows: Add bridge binding test to verify IPv4 address is val…
Browse files Browse the repository at this point in the history 
…id and matches Pod IP address.

In case of bridge binding on Windows VM, DHCP server must provide IPv4 address in proper v4 format otherwise it will be parsed incorrectly by the VM
and as a result Windows VM will become invisible on cluster network.
This problem was fixed by issue#6448.
Current test is responsible to make sure that IP address of Windows VM matches relevant Pod IP address and can be recognized by other components in the same cluster.

Signed-off-by: Diana Teplits <dteplits@redhat.com>
  • Loading branch information
@dteplits
dteplits committed Dec 21, 2021
1 parent d6cbbc3 commit 3d6ee98
Showing 1 changed file with 255 additions and 2 deletions.
257 changes: 255 additions & 2 deletions tests/windows_test.go
View file
Original file line number Diff line number Diff line change
Expand Up @@ -35,14 +35,14 @@ import (
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"k8s.io/apimachinery/pkg/types"

"kubevirt.io/kubevirt/tests/util"

v1 "kubevirt.io/api/core/v1"
"kubevirt.io/client-go/kubecli"
"kubevirt.io/kubevirt/pkg/network/dns"
"kubevirt.io/kubevirt/pkg/testutils"
"kubevirt.io/kubevirt/tests"
"kubevirt.io/kubevirt/tests/flags"
"kubevirt.io/kubevirt/tests/libnet"
"kubevirt.io/kubevirt/tests/util"
)

const (
Expand Down Expand Up @@ -116,6 +116,180 @@ var getWindowsVMISpec = func() v1.VirtualMachineInstanceSpec {

}

//////////////////////////////////////////////////////////////////////////////////////////////////////
/*
var _ = FDescribe("Windows VirtualMachineInstance - LOCAL TEST", func() {
var err error
var virtClient kubecli.KubevirtClient
var windowsVMI *v1.VirtualMachineInstance
BeforeEach(func() {
virtClient, err = kubecli.GetKubevirtClient()
util.PanicOnError(err)
tests.BeforeTestCleanup()
})
Context("with bridge binding", func() {
var winrmcliPod *k8sv1.Pod
var cli []string
var output string
var winVmiIp string
var winPodIp string
//var testVmiIp string
fmt.Println("---------------------------- 1")
BeforeEach(func() {
windowsVMI, err = virtClient.VirtualMachineInstance("default").Get("vmi-windows-example", &metav1.GetOptions{})
tests.WaitForSuccessfulVMIStartWithTimeout(windowsVMI, 360)
//fmt.Println("---------------------------- 2")
//
//windowsVMI.Spec.Domain.Devices.Interfaces = []v1.Interface{
// v1.Interface{
// Name: "default",
// InterfaceBindingMethod: v1.InterfaceBindingMethod{
// Bridge: &v1.InterfaceBridge{},
// },
// },
//}
})
It("should have ip value equal to matching pod ip", func() {
fmt.Println("---------------------------- 6")
winVmiIp = windowsVMI.Status.Interfaces[0].IP
winVmiPod := tests.GetRunningPodByVirtualMachineInstance(windowsVMI, windowsVMI.Namespace)
winPodIp = winVmiPod.Status.PodIP
fmt.Printf("---------------------------- 7, winVmiIp=%s, winPodIp=%s", winVmiIp, winPodIp)
Expect(winVmiIp).To(Equal(winPodIp))
})
It("should recognize and be recognized by other pods via ping command", func() {
/////////////// from cirros to win
//fmt.Println("---------------------------- 8")
//
//testVMI := libvmi.NewCirros()
//
//fmt.Println("---------------------------- 9")
//
//By("Creating and starting the VMI")
//testVMI, err := virtClient.VirtualMachineInstance("default").Create(testVMI)
//Expect(err).ToNot(HaveOccurred())
//tests.WaitUntilVMIReady(testVMI, console.LoginToCirros)
//
//testVMI, err = virtClient.VirtualMachineInstance(testVMI.Namespace).Get(testVMI.Name, &metav1.GetOptions{})
//Expect(err).ToNot(HaveOccurred())
//testVMI, err := virtClient.VirtualMachineInstance("default").Get("testvmi-txhzt", &metav1.GetOptions{})
//Expect(err).ToNot(HaveOccurred())
//
//testVmiIp = testVMI.Status.Interfaces[0].IP
//
//fmt.Println("---------------------------- 10, testVMIIP=", testVmiIp)
//
//err = libnet.PingFromVMConsole(testVMI, winVmiIp)
//Expect(err).ToNot(HaveOccurred())
//////////////// from win to cirros
fmt.Println("---------------------------- 3")
By("Creating winrm-cli pod for the future use")
winrmcliPod = &k8sv1.Pod{
ObjectMeta: metav1.ObjectMeta{GenerateName: winrmCli},
Spec: k8sv1.PodSpec{
Containers: []k8sv1.Container{
{
Name: winrmCli,
Image: fmt.Sprintf("%s/%s:%s", flags.KubeVirtUtilityRepoPrefix, winrmCli, flags.KubeVirtUtilityVersionTag),
Command: []string{"sleep"},
Args: []string{"3600"},
},
},
},
}
winrmcliPod, err = virtClient.CoreV1().Pods("default").Create(context.Background(), winrmcliPod, metav1.CreateOptions{})
Expect(err).ToNot(HaveOccurred())
fmt.Println("---------------------------- 5")
cli = winrnLoginCommand(virtClient, windowsVMI)
////// ipconfig command
//command1 := append(cli, fmt.Sprintf("ipconfig"))
//
//fmt.Println("---------------------------- 11, command=", command1)
//
//By(fmt.Sprintf("Running \"%s\" command via winrm-cli", command1))
//Eventually(func() error {
// output, err = tests.ExecuteCommandOnPod(
// virtClient,
// winrmcliPod,
// winrmcliPod.Spec.Containers[0].Name,
// command1,
// )
// return err
//}, time.Minute*1, time.Second*15).ShouldNot(HaveOccurred())
//Expect(output).NotTo(BeNil())
//
//fmt.Println("---------------------------- output", output)
//////// approach virt-handler pod
getVirtHandlerPod := func() (*k8sv1.Pod, error) {
node := windowsVMI.Status.NodeName
pod, err := kubecli.NewVirtHandlerClient(virtClient).Namespace(flags.KubeVirtInstallNamespace).ForNode(node).Pod()
if err != nil {
return nil, fmt.Errorf("failed to get virt-handler pod on node %s: %v", node, err)
}
return pod, nil
}
fmt.Println("---------------------------- 8")
virtHandlerPod, err := getVirtHandlerPod()
Expect(err).ToNot(HaveOccurred())
By("Check connectivity")
podIP := libnet.GetPodIpByFamily(virtHandlerPod, k8sv1.IPv4Protocol)
////// ping command
command := append(cli, fmt.Sprintf("ping %s", podIP)) //testVmiIp))
fmt.Println("---------------------------- 12, command=", command)
By(fmt.Sprintf("Running \"%s\" command via winrm-cli", command))
Eventually(func() error {
output, err = tests.ExecuteCommandOnPod(
virtClient,
winrmcliPod,
winrmcliPod.Spec.Containers[0].Name,
command,
)
return err
}, time.Minute*1, time.Second*15).ShouldNot(HaveOccurred())
Expect(output).NotTo(BeNil())
fmt.Println("---------------------------- output", output)
}, 360)
})
})
*/
//////////////////////////////////////////////////////////////////////////////////////////////////////

var _ = Describe("[Serial][sig-compute]Windows VirtualMachineInstance", func() {
var err error
var virtClient kubecli.KubevirtClient
Expand Down Expand Up @@ -255,6 +429,85 @@ var _ = Describe("[Serial][sig-compute]Windows VirtualMachineInstance", func() {
`DNSDomain[\n\r\t ]+`+expectedSearchDomain+`[\n\r\t ]+`)
}, 360)
})

Context("with bridge binding", func() {
BeforeEach(func() {
windowsVMI.Spec.Domain.Devices.Interfaces = []v1.Interface{
{
Name: "default",
InterfaceBindingMethod: v1.InterfaceBindingMethod{
Bridge: &v1.InterfaceBridge{},
},
},
}

By("Starting Windows VirtualMachineInstance with bridge binding")
windowsVMI, err = virtClient.VirtualMachineInstance(util.NamespaceTestDefault).Create(windowsVMI)
Expect(err).ToNot(HaveOccurred())
tests.WaitForSuccessfulVMIStartWithTimeout(windowsVMI, 420)

cli = winrnLoginCommand(virtClient, windowsVMI)
})

It("should have ip address equal to matching pod ip address", func() {
windowsVMI, err = virtClient.VirtualMachineInstance(windowsVMI.Namespace).Get(windowsVMI.Name, &metav1.GetOptions{})
Expect(err).ToNot(HaveOccurred())

Eventually(func() int {
return len(windowsVMI.Status.Interfaces)
}, time.Minute*1, time.Second*15).Should(BeNumerically("==", 1))

winVmiIp := windowsVMI.Status.Interfaces[0].IP
winVmiPod := tests.GetRunningPodByVirtualMachineInstance(windowsVMI, windowsVMI.Namespace)
winPodIp := winVmiPod.Status.PodIP

Expect(winVmiIp).To(Equal(winPodIp))
})

It("should recognize other pods via ping command", func() {

//time.Sleep(time.Minute * 1)

windowsVMI, err := virtClient.VirtualMachineInstance(windowsVMI.Namespace).Get(windowsVMI.Name, &metav1.GetOptions{})
Expect(err).ToNot(HaveOccurred())

getVirtHandlerPod := func() (*k8sv1.Pod, error) {
Eventually(func() int {
return len(windowsVMI.Status.NodeName)
}, time.Minute*1, time.Second*15).Should(BeNumerically(">", 0))

node := windowsVMI.Status.NodeName
fmt.Println("---------------------------- nodeName len", len(node))
fmt.Printf("---------------------------- nodeName=/%s/", node)

Expect(len(windowsVMI.Status.NodeName)).To(BeNumerically(">", 0))

pod, err := kubecli.NewVirtHandlerClient(virtClient).Namespace(flags.KubeVirtInstallNamespace).ForNode(node).Pod()
if err != nil {
return nil, fmt.Errorf("failed to get virt-handler pod on node %s: %v", node, err)
}
return pod, nil
}

virtHandlerPod, err := getVirtHandlerPod()
Expect(err).ToNot(HaveOccurred())

podIP := libnet.GetPodIpByFamily(virtHandlerPod, k8sv1.IPv4Protocol)

command := append(cli, fmt.Sprintf("ping %s", podIP))

By(fmt.Sprintf("Running \"%s\" command via winrm-cli", command))
Eventually(func() error {
output, err = tests.ExecuteCommandOnPod(
virtClient,
winrmcliPod,
winrmcliPod.Spec.Containers[0].Name,
command,
)
return err
}, time.Minute*1, time.Second*15).ShouldNot(HaveOccurred())
}, 360)
})
})

Context("[ref_id:142]with kubectl command", func() {
Expand Down

0 comments on commit 3d6ee98

Please sign in to comment.