func TestPodUsesServiceCreatedAfter(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": "client",
"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": "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)
allocator.On("ReleaseIpAddress", string(pod1.ObjectMeta.UID)).Return()
allocator.On("ReleaseIpAddress", string(pod2.ObjectMeta.UID)).Return()
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)
shutdown := make(chan struct{})
go controller.Run(shutdown)
controller.AddPod(pod2)
time.Sleep(100 * time.Millisecond)
policy, err := types.NetworkPolicyByName(client, "default-domain:testns:x1")
assert.NoError(t, err)
clientNet, err := types.VirtualNetworkByName(client, "default-domain:testns:client")
assert.NoError(t, err)
clientRefs, err := clientNet.GetNetworkPolicyRefs()
assert.NoError(t, err)
assert.NotEmpty(t, clientRefs)
assert.Equal(t, policy.GetUuid(), clientRefs[0].Uuid)
controller.AddPod(pod1)
controller.AddService(service)
time.Sleep(100 * time.Millisecond)
serviceNet, err := types.VirtualNetworkByName(client, "default-domain:testns:service-x1")
assert.NoError(t, err)
poRefs, err := serviceNet.GetNetworkPolicyRefs()
assert.NoError(t, err)
assert.NotEmpty(t, poRefs)
assert.Equal(t, policy.GetUuid(), poRefs[0].Uuid)
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:client", "default-domain:testns:service-x1"))
}
controller.DeletePod(pod1)
controller.DeletePod(pod2)
controller.DeleteService(service)
time.Sleep(100 * time.Millisecond)
type shutdownMsg struct {
}
shutdown <- shutdownMsg{}
_, err = client.FindByName("virtual-network", "default-domain:testns:service-x1")
assert.Error(t, err)
_, err = client.FindByName("network-policy", "default-domain:testns:x1")
assert.Error(t, err)
allocator.AssertExpectations(t)
}
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 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 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)
}