func TestReadChildren(t *testing.T) { client := new(ApiClient) client.Init() project := new(types.Project) project.SetFQName("domain", []string{"default-domain", "p1"}) assert.NoError(t, client.Create(project)) net := new(types.VirtualNetwork) net.SetFQName("project", []string{"default-domain", "p1", "n1"}) assert.NoError(t, client.Create(net)) vmi1 := new(types.VirtualMachineInterface) vmi1.SetFQName("project", []string{"default-domain", "p1", "port1"}) vmi1.AddVirtualNetwork(net) assert.NoError(t, client.Create(vmi1)) vmi2 := new(types.VirtualMachineInterface) vmi2.SetFQName("project", []string{"default-domain", "p1", "port2"}) vmi2.AddVirtualNetwork(net) assert.NoError(t, client.Create(vmi2)) refs, err := project.GetVirtualMachineInterfaces() assert.NoError(t, err) assert.Len(t, refs, 2) }
func (m *ApiClient) Init() { m.db = NewInMemDatabase() m.updater = NewObjectUpdater(m.db) domain := new(types.Domain) domain.SetName("default-domain") err := m.Create(domain) if err != nil { panic(err.Error()) } project := new(types.Project) project.SetFQName("domain", []string{"default-domain", "default-project"}) err = m.Create(project) if err != nil { panic(err.Error()) } ipam := new(types.NetworkIpam) ipam.SetFQName("project", []string{"default-domain", "default-project", "default-network-ipam"}) err = m.Create(ipam) if err != nil { panic(err.Error()) } }
func TestConsistencyStaleVM(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()) p2 := new(types.Project) p2.SetFQName("domain", []string{"default-domain", "p2"}) assert.NoError(t, client.Create(p2)) vm := new(types.VirtualMachine) vm.SetFQName("project", []string{"default-domain", "p2", "x"}) assert.NoError(t, client.Create(vm)) assert.False(t, env.checker.Check()) assert.NoError(t, client.Delete(vm)) assert.True(t, env.checker.Check()) vm = new(types.VirtualMachine) vm.SetFQName("project", []string{"default-domain", "testns", "pod03"}) assert.NoError(t, client.Create(vm)) assert.False(t, env.checker.Check()) }
func TestListByParent(t *testing.T) { client := new(ApiClient) client.Init() projectNames := []string{"p1", "p2", "p3"} vmNames := []string{"a", "b", "c", "d"} for _, projectName := range projectNames { project := new(types.Project) project.SetFQName("domain", []string{"default-domain", projectName}) assert.NoError(t, client.Create(project)) for _, vmName := range vmNames { vm := new(types.VirtualMachine) vm.SetFQName("project", []string{"default-domain", projectName, vmName}) assert.NoError(t, client.Create(vm)) } } elements, err := client.ListByParent("virtual-machine", "default-domain:p2") assert.NoError(t, err) for _, element := range elements { assert.Equal(t, "p2", element.Fq_name[1]) } }
func TestNamespaceDelete(t *testing.T) { client := new(contrail_mocks.ApiClient) client.Init() allocator := new(mocks.AddressAllocator) networkMgr := new(mocks.NetworkManager) controller := NewTestController(nil, client, allocator, networkMgr) namespace := &api.Namespace{ ObjectMeta: api.ObjectMeta{ Name: "netns", UID: kubetypes.UID(uuid.New()), }, } project := new(types.Project) project.SetFQName("domain", []string{DefaultDomain, "netns"}) project.SetUuid(string(namespace.ObjectMeta.UID)) client.Create(project) shutdown := make(chan struct{}) go controller.Run(shutdown) controller.DeleteNamespace(namespace) time.Sleep(100 * time.Millisecond) type shutdownMsg struct { } shutdown <- shutdownMsg{} _, err := client.FindByUuid("project", string(namespace.ObjectMeta.UID)) assert.NotNil(t, err) }
func TestConsistencyStaleInterface(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 := new(types.VirtualMachineInterface) vmi.SetFQName("project", []string{"default-domain", "testns", "pod03"}) assert.NoError(t, client.Create(vmi)) assert.False(t, checker.Check()) }
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 TestPodUsesNonExistingService(t *testing.T) { kube := mocks.NewKubeClient() client := new(contrail_mocks.ApiClient) client.Init() client.AddInterceptor("virtual-machine-interface", &VmiInterceptor{}) client.AddInterceptor("virtual-network", &NetworkInterceptor{}) allocator := new(mocks.AddressAllocator) controller := NewTestController(kube, client, allocator, nil) pod1 := &api.Pod{ ObjectMeta: api.ObjectMeta{ Name: "test-xz1", Namespace: "testns", UID: kubetypes.UID(uuid.New()), Labels: map[string]string{ "name": "testpod", "uses": "nonexisting", }, }, } netnsProject := new(types.Project) netnsProject.SetFQName("", []string{"default-domain", "testns"}) client.Create(netnsProject) allocator.On("LocateIpAddress", string(pod1.ObjectMeta.UID)).Return("10.0.0.1", nil) allocator.On("ReleaseIpAddress", string(pod1.ObjectMeta.UID)).Return() kube.PodInterface.On("Update", pod1).Return(pod1, nil) shutdown := make(chan struct{}) go controller.Run(shutdown) controller.AddPod(pod1) time.Sleep(100 * time.Millisecond) _, err := types.NetworkPolicyByName(client, "default-domain:testns:nonexisting") assert.NoError(t, err) _, err = types.VirtualNetworkByName(client, "default-domain:testns:testpod") assert.NoError(t, err) controller.DeletePod(pod1) time.Sleep(100 * time.Millisecond) type shutdownMsg struct { } shutdown <- shutdownMsg{} _, err = types.VirtualNetworkByName(client, "default-domain:testns:testpod") assert.Error(t, err) _, err = types.NetworkPolicyByName(client, "default-domain:testns:nonexisting") assert.Error(t, err) allocator.AssertExpectations(t) }
func (t *TestFramework) SetUp(publicSubnet string) { t.client = new(contrail_mocks.ApiClient) t.client.Init() t.client.AddInterceptor("virtual-machine-interface", &VmiInterceptor{}) t.client.AddInterceptor("virtual-network", &NetworkInterceptor{}) t.client.AddInterceptor("instance-ip", &IpInterceptor{}) t.client.AddInterceptor("floating-ip", &FloatingIpInterceptor{}) t.podStore = new(mocks.Store) t.serviceStore = new(mocks.Store) t.kubeMock = mocks.NewKubeClient() t.config = NewConfig() t.config.PublicSubnet = publicSubnet t.controller = makeSyncController(t.kubeMock, t.config) t.controller.SetPodStore(t.podStore) t.controller.SetServiceStore(t.serviceStore) t.controller.initComponents(t.client) t.checker = t.controller.newConsistencyChecker() for _, projectName := range testProjects { project := new(types.Project) project.SetFQName("domain", []string{t.config.DefaultDomain, projectName}) t.client.Create(project) } t.state = make(map[string]*TestGroupState, 0) t.clusterIPs = make(map[int]string, 0) t.keyList = make([]string, 0) t.shutdown = make(chan struct{}) keysCall := t.podStore.On("ListKeys").Return() keysCall.Run(func(arg mock.Arguments) { keysCall.Return(t.keyList) }) listCall := t.serviceStore.On("List").Return() listCall.Run(func(arg mock.Arguments) { serviceList := make([]interface{}, 0) for _, v := range t.state { for _, svc := range v.Services { serviceList = append(serviceList, svc) } } listCall.Return(serviceList) }) }
func TestPodCreate(t *testing.T) { kube := mocks.NewKubeClient() client := new(contrail_mocks.ApiClient) client.Init() client.AddInterceptor("virtual-machine-interface", &VmiInterceptor{}) allocator := new(mocks.AddressAllocator) networkMgr := new(mocks.NetworkManager) controller := NewTestController(kube, client, allocator, networkMgr) pod := &api.Pod{ ObjectMeta: api.ObjectMeta{ Name: "test", Namespace: "testns", UID: kubetypes.UID(uuid.New()), Labels: map[string]string{ "name": "testnet", }, }, } netnsProject := new(types.Project) netnsProject.SetUuid(uuid.New()) netnsProject.SetFQName("", []string{"default-domain", "testns"}) client.Create(netnsProject) testnet := new(types.VirtualNetwork) testnet.SetFQName("project", []string{"default-domain", "testns", "testnet"}) client.Create(testnet) allocator.On("LocateIpAddress", string(pod.ObjectMeta.UID)).Return("10.0.0.42", nil) networkMgr.On("LocateNetwork", "testns", "testnet", controller.config.PrivateSubnet).Return(testnet, nil) networkMgr.On("GetGatewayAddress", testnet).Return("10.0.255.254", nil) kube.PodInterface.On("Update", pod).Return(pod, nil) shutdown := make(chan struct{}) go controller.Run(shutdown) controller.AddPod(pod) time.Sleep(100 * time.Millisecond) type shutdownMsg struct { } shutdown <- shutdownMsg{} kube.PodInterface.AssertExpectations(t) }
func (m *NamespaceManager) LocateNamespace(name, uid string) *types.Project { fqn := []string{DefaultDomain, name} obj, err := m.client.FindByName("project", strings.Join(fqn, ":")) if err == nil { return obj.(*types.Project) } project := new(types.Project) project.SetFQName("domain", fqn) project.SetUuid(uid) err = m.client.Create(project) if err != nil { glog.Errorf("Create project %s: %v", name, err) } return project }
func TestReadModifiedPolicy(t *testing.T) { client := new(ApiClient) client.Init() project := new(types.Project) project.SetFQName("domain", []string{"default-domain", "p1"}) assert.NoError(t, client.Create(project)) policy := new(types.NetworkPolicy) policy.SetFQName("project", []string{"default-domain", "p1", "x"}) assert.NoError(t, client.Create(policy)) net1 := new(types.VirtualNetwork) net1.SetFQName("project", []string{"default-domain", "p1", "n1"}) net1.AddNetworkPolicy(policy, types.VirtualNetworkPolicyType{ Sequence: &types.SequenceType{10, 0}, }) assert.NoError(t, client.Create(net1)) net2 := new(types.VirtualNetwork) net2.SetFQName("project", []string{"default-domain", "p1", "n2"}) net2.AddNetworkPolicy(policy, types.VirtualNetworkPolicyType{ Sequence: &types.SequenceType{10, 0}, }) assert.NoError(t, client.Create(net2)) refs, err := policy.GetVirtualNetworkBackRefs() assert.NoError(t, err) assert.Len(t, refs, 2) assert.NoError(t, client.Delete(net1)) refs, err = policy.GetVirtualNetworkBackRefs() assert.NoError(t, err) assert.Len(t, refs, 1) assert.NoError(t, client.Delete(net2)) refs, err = policy.GetVirtualNetworkBackRefs() assert.NoError(t, err) assert.Len(t, refs, 0) }
func TestNetworkLocate(t *testing.T) { client := new(contrail_mocks.ApiClient) client.Init() config := new(Config) config.PublicNetwork = "default-domain:default-project:Public" netman := NewNetworkManager(client, config) project := new(types.Project) project.SetUuid(uuid.New()) project.SetFQName("", []string{config.DefaultDomain, "p1"}) client.Create(project) network, err := netman.LocateNetwork("p1", "n1", "10.0.1.0/24") assert.NoError(t, err, "LocateNetwork") n2, err := netman.LocateNetwork("p1", "n1", "10.0.1.0/24") assert.NoError(t, err, "LocateNetwork -- exists") assert.Equal(t, network, n2) }
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 TestUpdateClearVM(t *testing.T) { client := new(ApiClient) client.Init() project := new(types.Project) project.SetFQName("domain", []string{"default-domain", "tenant"}) assert.NoError(t, client.Create(project)) vm := new(types.VirtualMachine) vm.SetFQName("project", []string{"default-domain", "tenant", "instance"}) assert.NoError(t, client.Create(vm)) vmi := new(types.VirtualMachineInterface) vmi.SetFQName("project", []string{"default-domain", "tenant", "instance"}) vmi.AddVirtualMachine(vm) assert.NoError(t, client.Create(vmi)) vmi.ClearVirtualMachine() assert.NoError(t, client.Update(vmi)) assert.NoError(t, client.Delete(vm)) }
func TestReadRefs(t *testing.T) { client := new(ApiClient) client.Init() project := new(types.Project) project.SetFQName("domain", []string{"default-domain", "p1"}) assert.NoError(t, client.Create(project)) net := new(types.VirtualNetwork) net.SetFQName("project", []string{"default-domain", "p1", "n1"}) assert.NoError(t, client.Create(net)) vmi1 := new(types.VirtualMachineInterface) vmi1.SetFQName("project", []string{"default-domain", "p1", "port1"}) vmi1.AddVirtualNetwork(net) assert.NoError(t, client.Create(vmi1)) refs, err := vmi1.GetVirtualNetworkRefs() assert.NoError(t, err) assert.Len(t, refs, 1) assert.Equal(t, net.GetUuid(), refs[0].Uuid) }
func TestReadBackRefs(t *testing.T) { client := new(ApiClient) client.Init() project := new(types.Project) project.SetFQName("domain", []string{"default-domain", "p1"}) assert.NoError(t, client.Create(project)) net := new(types.VirtualNetwork) net.SetFQName("project", []string{"default-domain", "p1", "n1"}) props := new(types.VirtualNetworkType) props.ForwardingMode = "turbo" net.SetVirtualNetworkProperties(props) assert.NoError(t, client.Create(net)) vmi1 := new(types.VirtualMachineInterface) vmi1.SetFQName("project", []string{"default-domain", "p1", "port1"}) vmi1.AddVirtualNetwork(net) assert.NoError(t, client.Create(vmi1)) vmi2 := new(types.VirtualMachineInterface) vmi2.SetFQName("project", []string{"default-domain", "p1", "port2"}) vmi2.AddVirtualNetwork(net) assert.NoError(t, client.Create(vmi2)) refs, err := net.GetVirtualMachineInterfaceBackRefs() assert.NoError(t, err) assert.Len(t, refs, 2) idList := make([]string, len(refs)) for i, ref := range refs { idList[i] = ref.Uuid } assert.Contains(t, idList, vmi1.GetUuid()) assert.Contains(t, idList, vmi2.GetUuid()) rProps := net.GetVirtualNetworkProperties() assert.Equal(t, "turbo", rProps.ForwardingMode) }
func TestGlobalNetworkConsistencyUpdateNetwork(t *testing.T) { env := new(TestFramework) env.SetUp("192.0.2.0/24") config := env.config config.GlobalNetworks = []string{"default-domain:cluster:global"} pod1 := &api.Pod{ ObjectMeta: api.ObjectMeta{ Name: "test-xz1", Namespace: "testns", UID: kubetypes.UID(uuid.New()), Labels: map[string]string{ "Name": "server", config.NetworkTag: "backend", }, }, } pod2 := &api.Pod{ ObjectMeta: api.ObjectMeta{ Name: "test-xz2", Namespace: "testns", UID: kubetypes.UID(uuid.New()), Labels: map[string]string{ "Name": "client", config.NetworkTag: "client", config.NetworkAccessTag: "svc", }, }, } pod3 := &api.Pod{ ObjectMeta: api.ObjectMeta{ Name: "gPod", Namespace: "cluster", UID: kubetypes.UID(uuid.New()), Labels: map[string]string{ "Name": "global", config.NetworkTag: "global", }, }, } service := &api.Service{ ObjectMeta: api.ObjectMeta{ Name: "s1", Namespace: "testns", Labels: map[string]string{ config.NetworkTag: "svc", }, }, Spec: api.ServiceSpec{ Selector: map[string]string{ "Name": "server", }, ClusterIP: "10.254.42.42", }, } clusterProject := new(types.Project) clusterProject.SetFQName("", []string{"default-domain", "cluster"}) require.NoError(t, env.client.Create(clusterProject)) netnsProject := new(types.Project) netnsProject.SetFQName("", []string{"default-domain", "testns"}) require.NoError(t, env.client.Create(netnsProject)) env.Start() env.AddPod(pod1) env.AddPod(pod2) env.AddPod(pod3) env.AddService(service, "server") env.SyncBarrier() // This connects the global-network policy with the respective network which is created after // the policy. assert.False(t, env.checker.Check()) // It should be ok now. assert.True(t, env.checker.Check()) policyName := makeGlobalNetworkPolicyName(config, []string{"default-domain", "cluster", "global"}) policy, err := types.NetworkPolicyByName(env.client, strings.Join(policyName, ":")) require.NoError(t, err) netRefs, err := policy.GetVirtualNetworkBackRefs() require.NoError(t, err) assert.Len(t, netRefs, 3) assert.Len(t, policy.GetNetworkPolicyEntries().PolicyRule, 2) env.DeletePod(pod1) env.DeletePod(pod2) env.DeleteService(service, "server") env.SyncBarrier() _, err = types.NetworkPolicyByName(env.client, strings.Join(policyName, ":")) assert.Error(t, err) assert.True(t, env.checker.Check()) env.Shutdown() }
func TestPodAddWithService(t *testing.T) { kube := mocks.NewKubeClient() client := new(contrail_mocks.ApiClient) client.Init() client.AddInterceptor("virtual-machine-interface", &VmiInterceptor{}) client.AddInterceptor("virtual-network", &NetworkInterceptor{}) allocator := new(mocks.AddressAllocator) controller := NewTestController(kube, client, allocator, nil) pod := &api.Pod{ ObjectMeta: api.ObjectMeta{ Name: "test", Namespace: "testns", UID: kubetypes.UID(uuid.New()), Labels: map[string]string{ "name": "testpod", }, }, } service := &api.Service{ ObjectMeta: api.ObjectMeta{ Name: "s1", Namespace: "testns", Labels: map[string]string{ "name": "x1", }, }, Spec: api.ServiceSpec{ Selector: map[string]string{ "name": "testpod", }, ClusterIP: "10.254.42.42", }, } netnsProject := new(types.Project) netnsProject.SetFQName("", []string{"default-domain", "testns"}) client.Create(netnsProject) allocator.On("LocateIpAddress", string(pod.ObjectMeta.UID)).Return("10.0.0.1", nil) kube.PodInterface.On("Update", pod).Return(pod, nil) shutdown := make(chan struct{}) go controller.Run(shutdown) controller.serviceStore.Add(service) controller.AddPod(pod) time.Sleep(100 * time.Millisecond) type shutdownMsg struct { } shutdown <- shutdownMsg{} kube.PodInterface.AssertExpectations(t) obj, err := client.FindByName("virtual-network", "default-domain:testns:service-x1") assert.NoError(t, err) serviceNet := obj.(*types.VirtualNetwork) sip, err := controller.networkMgr.LocateFloatingIp(serviceNet, service.Name, service.Spec.ClusterIP) assert.NoError(t, err) refList, err := sip.GetVirtualMachineInterfaceRefs() assert.Nil(t, err) assert.NotEmpty(t, refList) }
func TestConsistencyConnectionsDelete(t *testing.T) { podStore := new(mocks.Store) serviceStore := new(mocks.Store) kube := mocks.NewKubeClient() client := createTestClient() controller := NewTestController(kube, client, nil, nil) config := controller.config controller.SetPodStore(podStore) controller.SetServiceStore(serviceStore) checker := NewConsistencyChecker(client, controller.config, podStore, serviceStore, controller.serviceMgr) controller.config.ClusterServices = []string{"kube-system/dns", "kube-system/monitoring"} // 2 client pods in network "private" pod1 := &api.Pod{ ObjectMeta: api.ObjectMeta{ Name: "pod01", Namespace: "testns", UID: kubetypes.UID(uuid.New()), Labels: map[string]string{ config.NetworkTag: "private", config.NetworkAccessTag: "tagA", }, }, } pod2 := &api.Pod{ ObjectMeta: api.ObjectMeta{ Name: "pod02", Namespace: "testns", UID: kubetypes.UID(uuid.New()), Labels: map[string]string{ config.NetworkTag: "private", config.NetworkAccessTag: "tagB", }, }, } // The service pods for service tagA and tagB respectivly. pod3 := &api.Pod{ ObjectMeta: api.ObjectMeta{ Name: "pod03", Namespace: "testns", UID: kubetypes.UID(uuid.New()), Labels: map[string]string{ config.NetworkTag: "svc-backend", "app": "provider01", }, }, } pod4 := &api.Pod{ ObjectMeta: api.ObjectMeta{ Name: "pod04", Namespace: "testns", UID: kubetypes.UID(uuid.New()), Labels: map[string]string{ config.NetworkTag: "svc-backend", "app": "provider02", }, }, } // And the services service1 := &api.Service{ ObjectMeta: api.ObjectMeta{ Name: "service1", Namespace: "testns", Labels: map[string]string{ config.NetworkTag: "tagA", }, }, Spec: api.ServiceSpec{ Selector: map[string]string{ "app": "provider01", }, ClusterIP: "10.254.42.42", Type: api.ServiceTypeClusterIP, }, } service2 := &api.Service{ ObjectMeta: api.ObjectMeta{ Name: "service1", Namespace: "testns", Labels: map[string]string{ config.NetworkTag: "tagB", }, }, Spec: api.ServiceSpec{ Selector: map[string]string{ "app": "provider02", }, ClusterIP: "10.254.42.43", Type: api.ServiceTypeClusterIP, }, } netnsProject := new(types.Project) netnsProject.SetFQName("domain", []string{"default-domain", "testns"}) client.Create(netnsProject) sysProject := new(types.Project) sysProject.SetFQName("domain", []string{"default-domain", "kube-system"}) client.Create(sysProject) keys := make([]string, 0) addPod(pod1, kube.PodInterface, podStore, &keys) addPod(pod2, kube.PodInterface, podStore, &keys) addPod(pod3, kube.PodInterface, podStore, &keys) addPod(pod4, kube.PodInterface, podStore, &keys) podStore.On("ListKeys").Return(keys).Once() serviceStore.On("List").Return([]interface{}{service1, service2}) s1Pods := makeListOptSelector(map[string]string{"app": "provider01"}) kube.PodInterface.On("List", s1Pods).Return(&api.PodList{Items: []api.Pod{*pod3}}, nil) s2Pods := makeListOptSelector(map[string]string{"app": "provider02"}) kube.PodInterface.On("List", s2Pods).Return(&api.PodList{Items: []api.Pod{*pod4}}, nil) kube.ServiceInterface.On("Update", service1).Return(service1, nil) kube.ServiceInterface.On("Update", service2).Return(service2, nil) shutdown := make(chan struct{}) go controller.Run(shutdown) controller.AddPod(pod1) controller.AddPod(pod2) controller.AddPod(pod3) controller.AddPod(pod4) controller.AddService(service1) controller.AddService(service2) time.Sleep(100 * time.Millisecond) assert.True(t, checker.Check()) controller.DeletePod(pod2) time.Sleep(100 * time.Millisecond) keys = append(keys[0:1], keys[2:]...) podStore.On("ListKeys").Return(keys) assert.False(t, checker.Check()) assert.False(t, checker.Check()) assert.True(t, checker.Check()) config.ClusterServices = []string{"kube-system/dns"} assert.False(t, checker.Check()) assert.False(t, checker.Check()) assert.True(t, checker.Check()) type shutdownMsg struct { } shutdown <- shutdownMsg{} }
func TestServiceDeleteWithPod(t *testing.T) { kube := mocks.NewKubeClient() client := new(contrail_mocks.ApiClient) client.Init() client.AddInterceptor("virtual-machine-interface", &VmiInterceptor{}) client.AddInterceptor("virtual-network", &NetworkInterceptor{}) allocator := new(mocks.AddressAllocator) controller := NewTestController(kube, client, allocator, nil) pod1 := &api.Pod{ ObjectMeta: api.ObjectMeta{ Name: "test-xz1", Namespace: "testns", UID: kubetypes.UID(uuid.New()), Labels: map[string]string{ "name": "testpod", }, }, } pod2 := &api.Pod{ ObjectMeta: api.ObjectMeta{ Name: "test-xz2", Namespace: "testns", UID: kubetypes.UID(uuid.New()), Labels: map[string]string{ "name": "testpod", }, }, } service := &api.Service{ ObjectMeta: api.ObjectMeta{ Name: "s1", Namespace: "testns", Labels: map[string]string{ "name": "x1", }, }, Spec: api.ServiceSpec{ Selector: map[string]string{ "name": "testpod", }, ClusterIP: "10.254.42.42", }, } netnsProject := new(types.Project) netnsProject.SetFQName("", []string{"default-domain", "testns"}) client.Create(netnsProject) allocator.On("LocateIpAddress", string(pod1.ObjectMeta.UID)).Return("10.0.0.1", nil) allocator.On("LocateIpAddress", string(pod2.ObjectMeta.UID)).Return("10.0.0.2", nil) 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, *pod2}}, nil) shutdown := make(chan struct{}) go controller.Run(shutdown) controller.AddPod(pod1) controller.AddPod(pod2) controller.AddService(service) time.Sleep(100 * time.Millisecond) obj, err := client.FindByName("virtual-network", "default-domain:testns:service-x1") assert.NoError(t, err) serviceNet := obj.(*types.VirtualNetwork) sip, err := controller.networkMgr.LocateFloatingIp(serviceNet, service.Name, service.Spec.ClusterIP) sipName := sip.GetFQName() assert.NoError(t, err) refList, err := sip.GetVirtualMachineInterfaceRefs() assert.Nil(t, err) assert.NotEmpty(t, refList) obj, err = client.FindByName("network-policy", "default-domain:testns:x1") assert.NoError(t, err) controller.DeleteService(service) time.Sleep(100 * time.Millisecond) type shutdownMsg struct { } shutdown <- shutdownMsg{} obj, err = client.FindByName("virtual-network", "default-domain:testns:service-x1") assert.Error(t, err) obj, err = client.FindByName("floating-ip", strings.Join(sipName, ":")) assert.Error(t, err) obj, err = client.FindByName("network-policy", "default-domain:testns:x1") assert.Error(t, err) }
func TestServiceDeleteConnections(t *testing.T) { client := new(contrail_mocks.ApiClient) client.Init() config := NewConfig() networkMgr := NewNetworkManager(client, config) serviceMgr := NewServiceManager(client, config, networkMgr) netnsProject := new(types.Project) netnsProject.SetFQName("", []string{"default-domain", "testns"}) client.Create(netnsProject) globalProject := new(types.Project) globalProject.SetFQName("", []string{"default-domain", "global"}) client.Create(globalProject) network, err := networkMgr.LocateNetwork("testns", "client", config.PrivateSubnet) services := []string{ "testns/s1", "testns/s2", "global/s3", "global/s4", } for _, svc := range services { parts := strings.Split(svc, "/") namespace := parts[0] svcName := parts[1] err := serviceMgr.Create(namespace, svcName) if err != nil { t.Error(err) continue } err = serviceMgr.Connect(namespace, svcName, network) if err != nil { t.Error(err) } } serviceList := MakeServiceIdList() serviceList.Add("testns", "s1") serviceList.Add("global", "s3") purgeList := make([]string, 0) policyRefs, err := network.GetNetworkPolicyRefs() require.NoError(t, err) for _, ref := range policyRefs { require.Len(t, ref.To, 3) svcName, err := serviceNameFromPolicyName(ref.To[2]) require.NoError(t, err) if serviceList.Contains(ref.To[1], svcName) { continue } purgeList = append(purgeList, ref.Uuid) } err = serviceMgr.DeleteConnections(network, purgeList) if err != nil { t.Fatal(err) } refs, err := network.GetNetworkPolicyRefs() if err != nil { t.Fatal(err) } if len(refs) != len(serviceList) { t.Errorf("expected %d policy refs, got %d", len(serviceList), len(refs)) } actual := make([]string, 0) for _, ref := range refs { svc, err := serviceNameFromPolicyName(ref.To[2]) if err != nil { continue } actual = append(actual, ref.To[1]+"/"+svc) } assert.EqualValues(t, []string{"testns/s1", "global/s3"}, actual) }
func TestGlobalNetworkConsistencyConfigChange(t *testing.T) { env := new(TestFramework) env.SetUp("192.0.2.0/24") config := env.config config.GlobalNetworks = []string{"default-domain:cluster:global"} pod1 := &api.Pod{ ObjectMeta: api.ObjectMeta{ Name: "test-xz1", Namespace: "testns", UID: kubetypes.UID(uuid.New()), Labels: map[string]string{ "Name": "server", config.NetworkTag: "backend", }, }, } pod2 := &api.Pod{ ObjectMeta: api.ObjectMeta{ Name: "test-xz2", Namespace: "testns", UID: kubetypes.UID(uuid.New()), Labels: map[string]string{ "Name": "client", config.NetworkTag: "client", config.NetworkAccessTag: "svc", }, }, } pod3 := &api.Pod{ ObjectMeta: api.ObjectMeta{ Name: "gPod", Namespace: "cluster", UID: kubetypes.UID(uuid.New()), Labels: map[string]string{ "Name": "global", config.NetworkTag: "global", }, }, } service := &api.Service{ ObjectMeta: api.ObjectMeta{ Name: "s1", Namespace: "testns", Labels: map[string]string{ config.NetworkTag: "svc", }, }, Spec: api.ServiceSpec{ Selector: map[string]string{ "Name": "server", }, ClusterIP: "10.254.42.42", }, } clusterProject := new(types.Project) clusterProject.SetFQName("", []string{"default-domain", "cluster"}) require.NoError(t, env.client.Create(clusterProject)) netnsProject := new(types.Project) netnsProject.SetFQName("", []string{"default-domain", "testns"}) require.NoError(t, env.client.Create(netnsProject)) env.Start() env.AddPod(pod3) env.AddPod(pod1) env.AddPod(pod2) env.AddService(service, "server") env.SyncBarrier() assert.True(t, env.checker.Check()) config.GlobalNetworks = []string{} for i := 0; i < 2; i++ { assert.False(t, env.checker.Check()) } assert.True(t, env.checker.Check()) policyName := makeGlobalNetworkPolicyName(config, []string{"default-domain", "cluster", "global"}) _, err := types.NetworkPolicyByName(env.client, strings.Join(policyName, ":")) require.Error(t, err) env.DeletePod(pod1) env.DeletePod(pod2) env.DeletePod(pod3) env.DeleteService(service, "server") env.SyncBarrier() env.Shutdown() assert.True(t, env.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) { 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 TestConsistencyPodUpdateRemovePrev(t *testing.T) { env := new(TestFramework) env.SetUp("192.0.2.0/24") client := env.client config := env.config pod1 := &api.Pod{ ObjectMeta: api.ObjectMeta{ Name: "x-1", Namespace: "testns", UID: kubetypes.UID(uuid.New()), Labels: map[string]string{ "Name": "client", config.NetworkTag: "client", config.NetworkAccessTag: "red", }, }, } pod2 := &api.Pod{ ObjectMeta: api.ObjectMeta{ Name: "x-2", Namespace: "testns", UID: kubetypes.UID(uuid.New()), Labels: map[string]string{ "Name": "client", config.NetworkTag: "client", config.NetworkAccessTag: "red", }, }, } pod3 := &api.Pod{ ObjectMeta: api.ObjectMeta{ Name: "redPod", Namespace: "testns", UID: kubetypes.UID(uuid.New()), Labels: map[string]string{ "Name": "red", config.NetworkTag: "redPrivate", }, }, } pod4 := &api.Pod{ ObjectMeta: api.ObjectMeta{ Name: "bluePod", Namespace: "testns", UID: kubetypes.UID(uuid.New()), Labels: map[string]string{ "Name": "blue", config.NetworkTag: "bluePrivate", }, }, } redService := &api.Service{ ObjectMeta: api.ObjectMeta{ Name: "red", Namespace: "testns", Labels: map[string]string{ config.NetworkTag: "red", }, }, Spec: api.ServiceSpec{ Selector: map[string]string{ "Name": "red", }, ClusterIP: "10.254.42.42", }, } blueService := &api.Service{ ObjectMeta: api.ObjectMeta{ Name: "blue", Namespace: "testns", Labels: map[string]string{ config.NetworkTag: "blue", }, }, Spec: api.ServiceSpec{ Selector: map[string]string{ "Name": "blue", }, ClusterIP: "10.254.42.43", }, } netnsProject := new(types.Project) netnsProject.SetFQName("", []string{"default-domain", "testns"}) client.Create(netnsProject) env.Start() env.AddPod(pod1) env.AddService(redService, "red") env.AddPod(pod2) env.AddPod(pod3) env.AddPod(pod4) env.AddService(blueService, "blue") env.SyncBarrier() serviceConnections := getNetworkServiceConnections(t, client, config, "testns", "client") assert.EqualValues(t, []string{"default", "red"}, serviceConnections) assert.True(t, env.checker.Check()) policyName := makeServicePolicyName(config, "testns", "red") _, err := types.NetworkPolicyByName(client, strings.Join(policyName, ":")) assert.NoError(t, err) clonePodAndUpdateAccessTag := func(pod *api.Pod, color string) *api.Pod { newPod := new(api.Pod) *newPod = *pod newPod.Labels = make(map[string]string, 0) for k, v := range pod.Labels { newPod.Labels[k] = v } newPod.Labels[config.NetworkAccessTag] = color return newPod } // Update connections on pod1 nPod1 := clonePodAndUpdateAccessTag(pod1, "blue") env.UpdatePod(pod1, nPod1) env.SyncBarrier() serviceConnections = getNetworkServiceConnections(t, client, config, "testns", "client") assert.EqualValues(t, []string{"default", "red", "blue"}, serviceConnections) assert.True(t, env.checker.Check(), "red and blue present") // Update connections on pod2 // This will leave a stale connection to network red. nPod2 := clonePodAndUpdateAccessTag(pod2, "blue") env.UpdatePod(pod2, nPod2) env.SyncBarrier() serviceConnections = getNetworkServiceConnections(t, client, config, "testns", "client") assert.EqualValues(t, []string{"default", "red", "blue"}, serviceConnections) assert.False(t, env.checker.Check()) env.DeleteService(redService, "red") env.SyncBarrier() // The second pass will delete the connection to network red. assert.False(t, env.checker.Check()) serviceConnections = getNetworkServiceConnections(t, client, config, "testns", "client") assert.EqualValues(t, []string{"default", "blue"}, serviceConnections) assert.True(t, env.checker.Check()) env.Shutdown() _, err = types.NetworkPolicyByName(client, strings.Join(policyName, ":")) assert.Error(t, err) }
func TestConsistencyConnectionsDelete(t *testing.T) { env := new(TestFramework) env.SetUp("192.0.2.0/24") client := env.client config := env.config config.ClusterServices = []string{"kube-system/dns", "kube-system/monitoring"} // 2 client pods in network "private" pod1 := &api.Pod{ ObjectMeta: api.ObjectMeta{ Name: "pod01", Namespace: "testns", UID: kubetypes.UID(uuid.New()), Labels: map[string]string{ "Name": "private", config.NetworkTag: "private", config.NetworkAccessTag: "tagA", }, }, } pod2 := &api.Pod{ ObjectMeta: api.ObjectMeta{ Name: "pod02", Namespace: "testns", UID: kubetypes.UID(uuid.New()), Labels: map[string]string{ "Name": "private", config.NetworkTag: "private", config.NetworkAccessTag: "tagB", }, }, } // The service pods for service tagA and tagB respectivly. pod3 := &api.Pod{ ObjectMeta: api.ObjectMeta{ Name: "pod03", Namespace: "testns", UID: kubetypes.UID(uuid.New()), Labels: map[string]string{ "Name": "provider01", config.NetworkTag: "svc-backend", "app": "provider01", }, }, } pod4 := &api.Pod{ ObjectMeta: api.ObjectMeta{ Name: "pod04", Namespace: "testns", UID: kubetypes.UID(uuid.New()), Labels: map[string]string{ "Name": "provider02", config.NetworkTag: "svc-backend", "app": "provider02", }, }, } // And the services service1 := &api.Service{ ObjectMeta: api.ObjectMeta{ Name: "service1", Namespace: "testns", Labels: map[string]string{ config.NetworkTag: "tagA", }, }, Spec: api.ServiceSpec{ Selector: map[string]string{ "app": "provider01", }, ClusterIP: "10.254.42.42", Type: api.ServiceTypeClusterIP, }, } service2 := &api.Service{ ObjectMeta: api.ObjectMeta{ Name: "service1", Namespace: "testns", Labels: map[string]string{ config.NetworkTag: "tagB", }, }, Spec: api.ServiceSpec{ Selector: map[string]string{ "app": "provider02", }, ClusterIP: "10.254.42.43", Type: api.ServiceTypeClusterIP, }, } netnsProject := new(types.Project) netnsProject.SetFQName("domain", []string{"default-domain", "testns"}) client.Create(netnsProject) sysProject := new(types.Project) sysProject.SetFQName("domain", []string{"default-domain", "kube-system"}) client.Create(sysProject) env.Start() env.AddPod(pod1) env.AddPod(pod2) env.AddPod(pod3) env.AddPod(pod4) env.AddService(service1, "provider01") env.AddService(service2, "provider02") env.SyncBarrier() assert.True(t, env.checker.Check()) env.DeletePod(pod2) env.SyncBarrier() assert.False(t, env.checker.Check()) assert.False(t, env.checker.Check()) assert.True(t, env.checker.Check()) config.ClusterServices = []string{"kube-system/dns"} assert.False(t, env.checker.Check()) assert.False(t, env.checker.Check()) assert.True(t, env.checker.Check()) env.Shutdown() }
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 TestPodDelete(t *testing.T) { client := new(contrail_mocks.ApiClient) client.Init() allocator := new(mocks.AddressAllocator) networkMgr := new(mocks.NetworkManager) controller := NewTestController(nil, client, allocator, networkMgr) pod := &api.Pod{ ObjectMeta: api.ObjectMeta{ Name: "test", Namespace: "testns", UID: kubetypes.UID(uuid.New()), Labels: map[string]string{ "name": "testnet", }, }, } netnsProject := new(types.Project) netnsProject.SetUuid(uuid.New()) netnsProject.SetFQName("", []string{"default-domain", "testns"}) assert.NoError(t, client.Create(netnsProject)) instance := new(types.VirtualMachine) fqn := []string{"default-domain", "testns", "test"} instance.SetFQName("project", fqn) instance.SetUuid(string(pod.ObjectMeta.UID)) assert.NoError(t, client.Create(instance)) vmi := new(types.VirtualMachineInterface) vmi.SetFQName("project", fqn) vmi.AddVirtualMachine(instance) assert.NoError(t, client.Create(vmi)) ipObj := new(types.InstanceIp) ipObj.SetName("testns_test") assert.NoError(t, client.Create(ipObj)) allocator.On("ReleaseIpAddress", string(pod.ObjectMeta.UID)).Return() networkMgr.On("ReleaseNetworkIfEmpty", "testns", "testnet").Return(true, nil) shutdown := make(chan struct{}) go controller.Run(shutdown) controller.DeletePod(pod) time.Sleep(100 * time.Millisecond) type shutdownMsg struct { } shutdown <- shutdownMsg{} if obj, err := client.FindByName("virtual-machine", strings.Join(fqn, ":")); err == nil { t.Errorf("virtual-machine object still present %s", obj.GetUuid()) } if obj, err := client.FindByUuid("virtual-machine-interface", vmi.GetUuid()); err == nil { t.Errorf("virtual-machine-interface object still present %s", obj.GetUuid()) } if obj, err := client.FindByUuid("instance-ip", ipObj.GetUuid()); err == nil { t.Errorf("instance-ip object still present %s", obj.GetUuid()) } allocator.AssertExpectations(t) }
func TestServiceWithMultipleUsers(t *testing.T) { kube := mocks.NewKubeClient() client := new(contrail_mocks.ApiClient) client.Init() client.AddInterceptor("virtual-machine-interface", &VmiInterceptor{}) client.AddInterceptor("virtual-network", &NetworkInterceptor{}) allocator := new(mocks.AddressAllocator) controller := NewTestController(kube, client, allocator, nil) pod1 := &api.Pod{ ObjectMeta: api.ObjectMeta{ Name: "test-server", Namespace: "testns", UID: kubetypes.UID(uuid.New()), Labels: map[string]string{ "name": "server", }, }, } pod2 := &api.Pod{ ObjectMeta: api.ObjectMeta{ Name: "test-xz1", Namespace: "testns", UID: kubetypes.UID(uuid.New()), Labels: map[string]string{ "name": "client1", "uses": "x1", }, }, } pod3 := &api.Pod{ ObjectMeta: api.ObjectMeta{ Name: "test-xz2", Namespace: "testns", UID: kubetypes.UID(uuid.New()), Labels: map[string]string{ "name": "client1", "uses": "x1", }, }, } pod4 := &api.Pod{ ObjectMeta: api.ObjectMeta{ Name: "test-xz3", Namespace: "testns", UID: kubetypes.UID(uuid.New()), Labels: map[string]string{ "name": "client2", "uses": "x1", }, }, } service := &api.Service{ ObjectMeta: api.ObjectMeta{ Name: "s1", Namespace: "testns", Labels: map[string]string{ "name": "x1", }, }, Spec: api.ServiceSpec{ Selector: map[string]string{ "name": "server", }, ClusterIP: "10.254.42.42", }, } netnsProject := new(types.Project) netnsProject.SetFQName("", []string{"default-domain", "testns"}) client.Create(netnsProject) allocator.On("LocateIpAddress", string(pod1.ObjectMeta.UID)).Return("10.0.0.1", nil) allocator.On("LocateIpAddress", string(pod2.ObjectMeta.UID)).Return("10.0.0.2", nil) allocator.On("LocateIpAddress", string(pod3.ObjectMeta.UID)).Return("10.0.0.3", nil) allocator.On("LocateIpAddress", string(pod4.ObjectMeta.UID)).Return("10.0.0.4", nil) allocator.On("ReleaseIpAddress", string(pod1.ObjectMeta.UID)).Return() allocator.On("ReleaseIpAddress", string(pod2.ObjectMeta.UID)).Return() allocator.On("ReleaseIpAddress", string(pod3.ObjectMeta.UID)).Return() allocator.On("ReleaseIpAddress", string(pod4.ObjectMeta.UID)).Return() kube.PodInterface.On("Update", pod1).Return(pod1, nil) kube.PodInterface.On("Update", pod2).Return(pod2, nil) kube.PodInterface.On("Update", pod3).Return(pod3, nil) kube.PodInterface.On("Update", pod4).Return(pod4, nil) kube.PodInterface.On("List", mock.Anything, mock.Anything).Return(&api.PodList{Items: []api.Pod{*pod1}}, nil) shutdown := make(chan struct{}) go controller.Run(shutdown) controller.AddPod(pod1) controller.AddService(service) controller.AddPod(pod2) controller.AddPod(pod3) controller.AddPod(pod4) time.Sleep(100 * time.Millisecond) policy, err := types.NetworkPolicyByName(client, "default-domain:testns:x1") assert.NoError(t, err) if err == nil { assert.Len(t, policy.GetNetworkPolicyEntries().PolicyRule, 2) assert.True(t, policyHasRule(policy, "default-domain:testns:client1", "default-domain:testns:service-x1")) assert.True(t, policyHasRule(policy, "default-domain:testns:client2", "default-domain:testns:service-x1")) } _, err = types.VirtualNetworkByName(client, "default-domain:testns:client2") assert.NoError(t, err) controller.DeletePod(pod3) time.Sleep(100 * time.Millisecond) policy, err = types.NetworkPolicyByName(client, "default-domain:testns:x1") assert.NoError(t, err) if err == nil { assert.Len(t, policy.GetNetworkPolicyEntries().PolicyRule, 2) } controller.DeletePod(pod4) time.Sleep(100 * time.Millisecond) _, err = types.VirtualNetworkByName(client, "default-domain:testns:client2") assert.Error(t, err) policy, err = types.NetworkPolicyByName(client, "default-domain:testns:x1") assert.NoError(t, err) if err == nil { assert.Len(t, policy.GetNetworkPolicyEntries().PolicyRule, 1) assert.True(t, policyHasRule(policy, "default-domain:testns:client1", "default-domain:testns:service-x1")) } controller.DeletePod(pod2) time.Sleep(100 * time.Millisecond) policy, err = types.NetworkPolicyByName(client, "default-domain:testns:x1") assert.NoError(t, err) if err == nil { assert.Len(t, policy.GetNetworkPolicyEntries().PolicyRule, 0) } controller.DeletePod(pod1) controller.DeleteService(service) time.Sleep(100 * time.Millisecond) type shutdownMsg struct { } shutdown <- shutdownMsg{} policy, err = types.NetworkPolicyByName(client, "default-domain:testns:x1") assert.Error(t, err) }