func TestConsistencyMissingInterface(t *testing.T) {
env := new(TestFramework)
env.SetUp("192.0.2.0/24")
client := env.client
netnsProject := new(types.Project)
netnsProject.SetFQName("domain", []string{"default-domain", "testns"})
client.Create(netnsProject)
env.Start()
installPods(env, "testns", 3)
env.SyncBarrier()
env.Shutdown()
assert.True(t, env.checker.Check())
vmi, err := types.VirtualMachineInterfaceByName(client, "default-domain:testns:pod01")
assert.NoError(t, err)
refs, err := vmi.GetInstanceIpBackRefs()
for _, ref := range refs {
ip, err := types.InstanceIpByUuid(client, ref.Uuid)
assert.NoError(t, err)
ip.ClearVirtualMachineInterface()
assert.NoError(t, client.Update(ip))
}
assert.NoError(t, client.Delete(vmi))
assert.False(t, env.checker.Check())
}
func TestConsistencyMissingInterface(t *testing.T) {
client := createTestClient()
podStore := new(mocks.Store)
serviceStore := new(mocks.Store)
checker := NewConsistencyChecker(client, NewConfig(), podStore, serviceStore, nil)
kube := mocks.NewKubeClient()
controller := NewTestController(kube, client, nil, nil)
netnsProject := new(types.Project)
netnsProject.SetFQName("domain", []string{"default-domain", "testns"})
client.Create(netnsProject)
installPods(controller, &kube.PodInterface.Mock, &podStore.Mock, "testns", 3)
shutdown := make(chan struct{})
go controller.Run(shutdown)
time.Sleep(100 * time.Millisecond)
type shutdownMsg struct {
}
shutdown <- shutdownMsg{}
time.Sleep(100 * time.Millisecond)
serviceStore.On("List").Return([]interface{}{})
assert.True(t, checker.Check())
vmi, err := types.VirtualMachineInterfaceByName(client, "default-domain:testns:pod01")
assert.NoError(t, err)
refs, err := vmi.GetInstanceIpBackRefs()
for _, ref := range refs {
ip, err := types.InstanceIpByUuid(client, ref.Uuid)
assert.NoError(t, err)
ip.ClearVirtualMachineInterface()
assert.NoError(t, client.Update(ip))
}
assert.NoError(t, client.Delete(vmi))
assert.False(t, checker.Check())
}
func TestConsistencyMissingVM(t *testing.T) {
client := createTestClient()
podStore := new(mocks.Store)
serviceStore := new(mocks.Store)
checker := NewConsistencyChecker(client, NewConfig(), podStore, serviceStore, nil, nil)
pod1 := &api.Pod{
ObjectMeta: api.ObjectMeta{
Name: "test-sv1",
Namespace: "testns",
UID: kubetypes.UID(uuid.New()),
},
}
pod2 := &api.Pod{
ObjectMeta: api.ObjectMeta{
Name: "test-sv2",
Namespace: "testns",
UID: kubetypes.UID(uuid.New()),
},
}
kube := mocks.NewKubeClient()
controller := NewTestController(kube, client, nil, nil)
netnsProject := new(types.Project)
netnsProject.SetFQName("domain", []string{"default-domain", "testns"})
client.Create(netnsProject)
kube.Pods("testns").(*mocks.KubePodInterface).On("Update", pod1).Return(pod1, nil)
kube.Pods("testns").(*mocks.KubePodInterface).On("Update", pod2).Return(pod2, nil)
podStore.On("ListKeys").Return([]string{"testns/test-sv1", "testns/test-sv2"})
podStore.On("GetByKey", "testns/test-sv1").Return(pod1, true, nil)
podStore.On("GetByKey", "testns/test-sv2").Return(pod2, true, nil)
serviceStore.On("List").Return([]interface{}{})
shutdown := make(chan struct{})
go controller.Run(shutdown)
controller.AddPod(pod1)
controller.AddPod(pod2)
time.Sleep(100 * time.Millisecond)
type shutdownMsg struct {
}
shutdown <- shutdownMsg{}
assert.True(t, checker.Check())
vmi, err := types.VirtualMachineInterfaceByName(client, "default-domain:testns:test-sv1")
assert.NoError(t, err)
if err == nil {
vmi.ClearVirtualMachine()
err = client.Update(vmi)
assert.NoError(t, err)
}
vm, err := types.VirtualMachineByName(client, "default-domain:testns:test-sv1")
assert.NoError(t, err)
if err == nil {
err = client.Delete(vm)
assert.NoError(t, err)
}
assert.False(t, checker.Check())
}
func TestConsistencyServiceIp(t *testing.T) {
env := new(TestFramework)
env.SetUp("192.0.2.0/24")
config := env.config
client := env.client
netnsProject := new(types.Project)
netnsProject.SetFQName("domain", []string{"default-domain", "testns"})
client.Create(netnsProject)
service1 := &api.Service{
ObjectMeta: api.ObjectMeta{
Name: "s1",
Namespace: "testns",
Labels: map[string]string{
config.NetworkTag: "services",
},
},
Spec: api.ServiceSpec{
Selector: map[string]string{
"Name": "pod01",
},
ClusterIP: "10.254.42.42",
Type: api.ServiceTypeLoadBalancer,
},
}
service2 := &api.Service{
ObjectMeta: api.ObjectMeta{
Name: "s2",
Namespace: "testns",
Labels: map[string]string{
config.NetworkTag: "services",
},
},
Spec: api.ServiceSpec{
Selector: map[string]string{
"Name": "pod02",
},
ClusterIP: "10.254.42.43",
ExternalIPs: []string{"10.1.4.89"},
},
}
service3 := &api.Service{
ObjectMeta: api.ObjectMeta{
Name: "s3",
Namespace: "testns",
Labels: map[string]string{
config.NetworkTag: "services",
},
},
Spec: api.ServiceSpec{
Selector: map[string]string{
"Name": "pod01",
},
ClusterIP: "10.254.42.44",
},
}
env.Start()
installPods(env, "testns", 3)
env.AddService(service1, "pod01")
env.AddService(service2, "pod02")
env.AddService(service3, "pod01")
env.SyncBarrier()
env.Shutdown()
assert.True(t, env.checker.Check())
pool, err := types.FloatingIpPoolByName(client, "default-domain:testns:service-services:service-services")
assert.NoError(t, err)
vmi, err := types.VirtualMachineInterfaceByName(client, "default-domain:testns:pod01")
assert.NoError(t, err)
vip := new(types.FloatingIp)
fqn := make([]string, len(pool.GetFQName())+1)
copy(fqn, pool.GetFQName())
fqn[len(pool.GetFQName())] = "s4"
vip.SetFQName(vip.GetDefaultParentType(), fqn)
vip.AddVirtualMachineInterface(vmi)
assert.NoError(t, client.Create(vip))
assert.False(t, env.checker.Check())
assert.NoError(t, client.Delete(vip))
assert.True(t, env.checker.Check())
vip, err = types.FloatingIpByName(client, "default-domain:testns:service-services:service-services:s3")
assert.NoError(t, err)
assert.NoError(t, client.Delete(vip))
assert.False(t, env.checker.Check())
}
func TestConsistencyServiceIp(t *testing.T) {
client := createTestClient()
podStore := new(mocks.Store)
serviceStore := new(mocks.Store)
checker := NewConsistencyChecker(client, NewConfig(), podStore, serviceStore, nil)
kube := mocks.NewKubeClient()
controller := NewTestController(kube, client, nil, nil)
config := controller.config
netnsProject := new(types.Project)
netnsProject.SetFQName("domain", []string{"default-domain", "testns"})
client.Create(netnsProject)
installPods(controller, &kube.PodInterface.Mock, &podStore.Mock, "testns", 3)
service1 := &api.Service{
ObjectMeta: api.ObjectMeta{
Name: "s1",
Namespace: "testns",
Labels: map[string]string{
config.NetworkTag: "services",
},
},
Spec: api.ServiceSpec{
Selector: map[string]string{
"app": "pod01",
},
ClusterIP: "10.254.42.42",
Type: api.ServiceTypeLoadBalancer,
},
}
service2 := &api.Service{
ObjectMeta: api.ObjectMeta{
Name: "s2",
Namespace: "testns",
Labels: map[string]string{
config.NetworkTag: "services",
},
},
Spec: api.ServiceSpec{
Selector: map[string]string{
"app": "pod02",
},
ClusterIP: "10.254.42.43",
ExternalIPs: []string{"10.1.4.89"},
},
}
service3 := &api.Service{
ObjectMeta: api.ObjectMeta{
Name: "s3",
Namespace: "testns",
Labels: map[string]string{
config.NetworkTag: "services",
},
},
Spec: api.ServiceSpec{
Selector: map[string]string{
"app": "pod01",
},
ClusterIP: "10.254.42.44",
},
}
kube.ServiceInterface.On("Update", service1).Return(service1, nil)
shutdown := make(chan struct{})
go controller.Run(shutdown)
controller.AddService(service1)
controller.AddService(service2)
controller.AddService(service3)
serviceStore.On("List").Return([]interface{}{service1, service2, service3})
time.Sleep(100 * time.Millisecond)
type shutdownMsg struct {
}
shutdown <- shutdownMsg{}
time.Sleep(100 * time.Millisecond)
assert.True(t, checker.Check())
pool, err := types.FloatingIpPoolByName(client, "default-domain:testns:service-services:service-services")
assert.NoError(t, err)
vmi, err := types.VirtualMachineInterfaceByName(client, "default-domain:testns:pod01")
assert.NoError(t, err)
vip := new(types.FloatingIp)
fqn := make([]string, len(pool.GetFQName())+1)
copy(fqn, pool.GetFQName())
fqn[len(pool.GetFQName())] = "s4"
vip.SetFQName(vip.GetDefaultParentType(), fqn)
vip.AddVirtualMachineInterface(vmi)
assert.NoError(t, client.Create(vip))
assert.False(t, checker.Check())
assert.NoError(t, client.Delete(vip))
assert.True(t, checker.Check())
vip, err = types.FloatingIpByName(client, "default-domain:testns:service-services:service-services:s3")
assert.NoError(t, err)
assert.NoError(t, client.Delete(vip))
assert.False(t, checker.Check())
}
func TestServiceWithMultipleBackends(t *testing.T) {
kube := mocks.NewKubeClient()
client := new(contrail_mocks.ApiClient)
client.Init()
client.AddInterceptor("virtual-machine-interface", &VmiInterceptor{})
client.AddInterceptor("virtual-network", &NetworkInterceptor{})
client.AddInterceptor("instance-ip", &IpInterceptor{})
controller := NewTestController(kube, client, nil, nil)
pod1 := &api.Pod{
ObjectMeta: api.ObjectMeta{
Name: "test-sv1",
Namespace: "testns",
UID: kubetypes.UID(uuid.New()),
Labels: map[string]string{
"name": "backend",
},
},
}
pod2 := &api.Pod{
ObjectMeta: api.ObjectMeta{
Name: "test-sv2",
Namespace: "testns",
UID: kubetypes.UID(uuid.New()),
Labels: map[string]string{
"name": "backend",
},
},
}
service := &api.Service{
ObjectMeta: api.ObjectMeta{
Name: "service",
Namespace: "testns",
Labels: map[string]string{
"name": "svc",
},
},
Spec: api.ServiceSpec{
Selector: map[string]string{
"name": "backend",
},
ClusterIP: "10.254.42.42",
},
}
netnsProject := new(types.Project)
netnsProject.SetFQName("", []string{"default-domain", "testns"})
client.Create(netnsProject)
store := new(mocks.Store)
controller.SetServiceStore(store)
kube.PodInterface.On("Update", pod1).Return(pod1, nil)
kube.PodInterface.On("Update", pod2).Return(pod2, nil)
kube.PodInterface.On("List", mock.Anything, mock.Anything).Return(&api.PodList{Items: []api.Pod{*pod1}}, nil)
store.On("List").Return([]interface{}{service})
shutdown := make(chan struct{})
go controller.Run(shutdown)
controller.AddPod(pod1)
controller.AddService(service)
time.Sleep(100 * time.Millisecond)
controller.AddPod(pod2)
time.Sleep(100 * time.Millisecond)
fip, err := types.FloatingIpByName(client, "default-domain:testns:service-svc:service-svc:service")
assert.NoError(t, err)
if err == nil {
refs, err := fip.GetVirtualMachineInterfaceRefs()
assert.NoError(t, err)
assert.Len(t, refs, 2)
}
controller.DeletePod(pod1)
time.Sleep(100 * time.Millisecond)
fip, err = types.FloatingIpByName(client, "default-domain:testns:service-svc:service-svc:service")
assert.NoError(t, err)
if err == nil {
refs, err := fip.GetVirtualMachineInterfaceRefs()
assert.NoError(t, err)
assert.Len(t, refs, 1)
var uids []string
for _, ref := range refs {
uids = append(uids, ref.Uuid)
}
vmi, err := types.VirtualMachineInterfaceByName(client, "default-domain:testns:test-sv2")
assert.NoError(t, err)
if err == nil {
assert.Contains(t, uids, vmi.GetUuid())
}
}
controller.AddPod(pod1)
time.Sleep(100 * time.Millisecond)
fip, err = types.FloatingIpByName(client, "default-domain:testns:service-svc:service-svc:service")
assert.NoError(t, err)
if err == nil {
refs, err := fip.GetVirtualMachineInterfaceRefs()
assert.NoError(t, err)
assert.Len(t, refs, 2)
}
controller.DeletePod(pod1)
controller.DeletePod(pod2)
time.Sleep(100 * time.Millisecond)
fip, err = types.FloatingIpByName(client, "default-domain:testns:service-svc:service-svc:service")
assert.NoError(t, err)
if err == nil {
refs, err := fip.GetVirtualMachineInterfaceRefs()
assert.NoError(t, err)
assert.Len(t, refs, 0)
}
controller.DeleteService(service)
time.Sleep(100 * time.Millisecond)
type shutdownMsg struct {
}
shutdown <- shutdownMsg{}
_, err = types.FloatingIpByName(client, "default-domain:testns:service-svc:service-svc:service")
assert.Error(t, err)
}