Skip to content

Commit

Permalink
Windows VMI - adding bridge binding test to validate ip address
Browse files Browse the repository at this point in the history 
Signed-off-by: Diana Teplits <dteplits@redhat.com>
  • Loading branch information
@dteplits
dteplits committed Dec 20, 2021
1 parent d6cbbc3 commit 8e95405
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 8e95405

Please sign in to comment.