github
/
k3s
mirror of https://github.com/k3s-io/k3s
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Merge pull request #57438 from m1093782566/ipset-util-test 

Automatic merge from submit-queue (batch tested with PRs 57292, 56274, 57435, 57438, 57429). If you want to cherry-pick this change to another branch, please follow the instructions <a href="https://github.com/kubernetes/community/blob/master/contributors/devel/cherry-picks.md">here</a>.

Implement FakeIPSet so that can add tests in IPVS proxier

**What this PR does / why we need it**:

Implement FakeIPSet so that can add tests in IPVS proxier - the tests can run everywhere(linux, mac, windows...).

**Which issue(s) this PR fixes**:
Fixes #57439

**Special notes for your reviewer**:

**Release note**:

```release-note
NONE
```

/assign @thockin @brendandburns
pull/6/head
Kubernetes Submit Queue 2017-12-20 22:16:49 -08:00 committed by GitHub
parent 4caedcf3be 0f201037bd
commit 070f946476
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
5 changed files with 396 additions and 38 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

133
pkg/proxy/ipvs/ipset_test.go
View File

@ -18,6 +18,9 @@ package ipvs
import (
"testing"
utilipset "k8s.io/kubernetes/pkg/util/ipset"
fakeipset "k8s.io/kubernetes/pkg/util/ipset/testing"
)
func TestCheckIPSetVersion(t *testing.T) {
@ -47,3 +50,133 @@ func TestCheckIPSetVersion(t *testing.T) {
}
}
}
const testIPSetVersion = "v6.19"
func TestSyncIPSetEntries(t *testing.T) {
testCases := []struct {
setName string
setType utilipset.Type
ipv6 bool
activeEntries []string
currentEntries []string
expectedEntries []string
}{
{ // case 0
setName: "foo",
setType: utilipset.HashIPPort,
ipv6: false,
activeEntries: []string{"172.17.0.4,tcp:80"},
currentEntries: nil,
expectedEntries: []string{"172.17.0.4,tcp:80"},
},
{ // case 1
setName: "abz",
setType: utilipset.HashIPPort,
ipv6: true,
activeEntries: []string{"FE80::0202:B3FF:FE1E:8329,tcp:80"},
currentEntries: []string{"FE80::0202:B3FF:FE1E:8329,tcp:80"},
expectedEntries: []string{"FE80::0202:B3FF:FE1E:8329,tcp:80"},
},
{ // case 2
setName: "bca",
setType: utilipset.HashIPPort,
ipv6: false,
activeEntries: []string{"172.17.0.4,tcp:80", "172.17.0.5,tcp:80"},
currentEntries: []string{"172.17.0.5,udp:53"},
expectedEntries: []string{"172.17.0.4,tcp:80", "172.17.0.5,tcp:80"},
},
{ // case 3
setName: "bar",
setType: utilipset.HashIPPortIP,
ipv6: false,
activeEntries: []string{"172.17.0.4,tcp:80:172.17.0.4"},
currentEntries: []string{"172.17.0.4,tcp:80:172.17.0.4"},
expectedEntries: []string{"172.17.0.4,tcp:80:172.17.0.4"},
},
{ // case 4
setName: "baz",
setType: utilipset.HashIPPortIP,
ipv6: true,
activeEntries: []string{"FE80:0000:0000:0000:0202:B3FF:FE1E:8329,tcp:8080:FE80:0000:0000:0000:0202:B3FF:FE1E:8329"},
currentEntries: []string{"1111:0000:0000:0000:0202:B3FF:FE1E:8329,tcp:8081:1111:0000:0000:0000:0202:B3FF:FE1E:8329:8081"},
expectedEntries: []string{"FE80:0000:0000:0000:0202:B3FF:FE1E:8329,tcp:8080:FE80:0000:0000:0000:0202:B3FF:FE1E:8329"},
},
{ // case 5
setName: "NOPE",
setType: utilipset.HashIPPortIP,
ipv6: false,
activeEntries: []string{"172.17.0.4,tcp:80,172.17.0.9", "172.17.0.5,tcp:80,172.17.0.10"},
currentEntries: nil,
expectedEntries: []string{"172.17.0.4,tcp:80,172.17.0.9", "172.17.0.5,tcp:80,172.17.0.10"},
},
{ // case 6
setName: "ABC-DEF",
setType: utilipset.HashIPPortNet,
ipv6: false,
activeEntries: []string{"172.17.0.4,tcp:80,172.17.0.0/16", "172.17.0.5,tcp:80,172.17.0.0/16"},
currentEntries: nil,
expectedEntries: []string{"172.17.0.4,tcp:80,172.17.0.0/16", "172.17.0.5,tcp:80,172.17.0.0/16"},
},
{ // case 7
setName: "zar",
setType: utilipset.HashIPPortNet,
ipv6: true,
activeEntries: []string{"FE80::8329,tcp:8800,2001:db8::/32"},
currentEntries: []string{"FE80::8329,tcp:8800,2001:db8::/32"},
expectedEntries: []string{"FE80::8329,tcp:8800,2001:db8::/32"},
},
{ // case 8
setName: "bbb",
setType: utilipset.HashIPPortNet,
ipv6: true,
activeEntries: nil,
currentEntries: []string{"FE80::8329,udp:8801,2001:db8::/32"},
expectedEntries: nil,
},
{ // case 9
setName: "AAA",
setType: utilipset.BitmapPort,
activeEntries: nil,
currentEntries: []string{"80"},
expectedEntries: nil,
},
{ // case 10
setName: "c-c-c",
setType: utilipset.BitmapPort,
activeEntries: []string{"8080", "9090"},
currentEntries: []string{"80"},
expectedEntries: []string{"8080", "9090"},
},
{ // case 11
setName: "NODE-PORT",
setType: utilipset.BitmapPort,
activeEntries: []string{"8080"},
currentEntries: []string{"80", "9090", "8081", "8082"},
expectedEntries: []string{"8080"},
},
}
for i := range testCases {
set := NewIPSet(fakeipset.NewFake(testIPSetVersion), testCases[i].setName, testCases[i].setType, testCases[i].ipv6)
if err := set.handle.CreateSet(&set.IPSet, true); err != nil {
t.Errorf("Unexpected error: %v", err)
}
for _, entry := range testCases[i].expectedEntries {
set.handle.AddEntry(entry, testCases[i].setName, true)
}
set.activeEntries.Insert(testCases[i].activeEntries...)
set.syncIPSetEntries()
for _, entry := range testCases[i].expectedEntries {
found, err := set.handle.TestEntry(entry, testCases[i].setName)
if err != nil {
t.Errorf("Unexpected error: %v", err)
}
if !found {
t.Errorf("Unexpected entry 172.17.0.4,tcp:80 not found in set foo")
}
}
}
}

31
pkg/proxy/ipvs/proxier_test.go
View File

@ -344,7 +344,7 @@ func TestGetNodeIPs(t *testing.T) {
func TestNodePort(t *testing.T) {
ipt := iptablestest.NewFake()
ipvs := ipvstest.NewFake()
ipset := ipsettest.NewFake()
ipset := ipsettest.NewFake(testIPSetVersion)
nodeIPv4 := net.ParseIP("100.101.102.103")
nodeIPv6 := net.ParseIP("2001:db8::1:1")
nodeIPs := sets.NewString(nodeIPv4.String(), nodeIPv6.String())
@ -422,7 +422,7 @@ func TestNodePort(t *testing.T) {
func TestNodePortNoEndpoint(t *testing.T) {
ipt := iptablestest.NewFake()
ipvs := ipvstest.NewFake()
ipset := ipsettest.NewFake()
ipset := ipsettest.NewFake(testIPSetVersion)
nodeIP := net.ParseIP("100.101.102.103")
fp := NewFakeProxier(ipt, ipvs, ipset, []net.IP{nodeIP})
svcIP := "10.20.30.41"
@ -476,7 +476,7 @@ func TestNodePortNoEndpoint(t *testing.T) {
func TestClusterIPNoEndpoint(t *testing.T) {
ipt := iptablestest.NewFake()
ipvs := ipvstest.NewFake()
ipset := ipsettest.NewFake()
ipset := ipsettest.NewFake(testIPSetVersion)
fp := NewFakeProxier(ipt, ipvs, ipset, nil)
svcIP := "10.20.30.41"
svcPort := 80
@ -520,7 +520,7 @@ func TestClusterIPNoEndpoint(t *testing.T) {
func TestClusterIP(t *testing.T) {
ipt := iptablestest.NewFake()
ipvs := ipvstest.NewFake()
ipset := ipsettest.NewFake()
ipset := ipsettest.NewFake(testIPSetVersion)
fp := NewFakeProxier(ipt, ipvs, ipset, nil)
svcIPv4 := "10.20.30.41"
@ -627,7 +627,7 @@ func TestClusterIP(t *testing.T) {
func TestExternalIPsNoEndpoint(t *testing.T) {
ipt := iptablestest.NewFake()
ipvs := ipvstest.NewFake()
ipset := ipsettest.NewFake()
ipset := ipsettest.NewFake(testIPSetVersion)
fp := NewFakeProxier(ipt, ipvs, ipset, nil)
svcIP := "10.20.30.41"
svcPort := 80
@ -682,7 +682,7 @@ func TestExternalIPsNoEndpoint(t *testing.T) {
func TestExternalIPs(t *testing.T) {
ipt := iptablestest.NewFake()
ipvs := ipvstest.NewFake()
ipset := ipsettest.NewFake()
ipset := ipsettest.NewFake(testIPSetVersion)
fp := NewFakeProxier(ipt, ipvs, ipset, nil)
svcIP := "10.20.30.41"
svcPort := 80
@ -752,7 +752,7 @@ func TestExternalIPs(t *testing.T) {
func TestLoadBalancer(t *testing.T) {
ipt := iptablestest.NewFake()
ipvs := ipvstest.NewFake()
ipset := ipsettest.NewFake()
ipset := ipsettest.NewFake(testIPSetVersion)
fp := NewFakeProxier(ipt, ipvs, ipset, nil)
svcIP := "10.20.30.41"
svcPort := 80
@ -804,7 +804,7 @@ func strPtr(s string) *string {
func TestOnlyLocalNodePorts(t *testing.T) {
ipt := iptablestest.NewFake()
ipvs := ipvstest.NewFake()
ipset := ipsettest.NewFake()
ipset := ipsettest.NewFake(testIPSetVersion)
nodeIP := net.ParseIP("100.101.102.103")
fp := NewFakeProxier(ipt, ipvs, ipset, []net.IP{nodeIP})
svcIP := "10.20.30.41"
@ -882,11 +882,10 @@ func TestOnlyLocalNodePorts(t *testing.T) {
}
}
// NO help
func TestOnlyLocalLoadBalancing(t *testing.T) {
ipt := iptablestest.NewFake()
ipvs := ipvstest.NewFake()
ipset := ipsettest.NewFake()
ipset := ipsettest.NewFake(testIPSetVersion)
fp := NewFakeProxier(ipt, ipvs, ipset, nil)
svcIP := "10.20.30.41"
svcPort := 80
@ -951,7 +950,7 @@ func addTestPort(array []api.ServicePort, name string, protocol api.Protocol, po
func TestBuildServiceMapAddRemove(t *testing.T) {
ipt := iptablestest.NewFake()
ipvs := ipvstest.NewFake()
ipset := ipsettest.NewFake()
ipset := ipsettest.NewFake(testIPSetVersion)
fp := NewFakeProxier(ipt, ipvs, ipset, nil)
services := []*api.Service{
@ -1057,7 +1056,7 @@ func TestBuildServiceMapAddRemove(t *testing.T) {
func TestBuildServiceMapServiceHeadless(t *testing.T) {
ipt := iptablestest.NewFake()
ipvs := ipvstest.NewFake()
ipset := ipsettest.NewFake()
ipset := ipsettest.NewFake(testIPSetVersion)
fp := NewFakeProxier(ipt, ipvs, ipset, nil)
makeServiceMap(fp,
@ -1091,7 +1090,7 @@ func TestBuildServiceMapServiceHeadless(t *testing.T) {
func TestBuildServiceMapServiceTypeExternalName(t *testing.T) {
ipt := iptablestest.NewFake()
ipvs := ipvstest.NewFake()
ipset := ipsettest.NewFake()
ipset := ipsettest.NewFake(testIPSetVersion)
fp := NewFakeProxier(ipt, ipvs, ipset, nil)
makeServiceMap(fp,
@ -1119,7 +1118,7 @@ func TestBuildServiceMapServiceTypeExternalName(t *testing.T) {
func TestBuildServiceMapServiceUpdate(t *testing.T) {
ipt := iptablestest.NewFake()
ipvs := ipvstest.NewFake()
ipset := ipsettest.NewFake()
ipset := ipsettest.NewFake(testIPSetVersion)
fp := NewFakeProxier(ipt, ipvs, ipset, nil)
servicev1 := makeTestService("somewhere", "some-service", func(svc *api.Service) {
@ -1202,7 +1201,7 @@ func TestBuildServiceMapServiceUpdate(t *testing.T) {
func TestSessionAffinity(t *testing.T) {
ipt := iptablestest.NewFake()
ipvs := ipvstest.NewFake()
ipset := ipsettest.NewFake()
ipset := ipsettest.NewFake(testIPSetVersion)
nodeIP := net.ParseIP("100.101.102.103")
fp := NewFakeProxier(ipt, ipvs, ipset, []net.IP{nodeIP})
svcIP := "10.20.30.41"
@ -2066,7 +2065,7 @@ func Test_updateEndpointsMap(t *testing.T) {
for tci, tc := range testCases {
ipt := iptablestest.NewFake()
ipvs := ipvstest.NewFake()
ipset := ipsettest.NewFake()
ipset := ipsettest.NewFake(testIPSetVersion)
fp := NewFakeProxier(ipt, ipvs, ipset, nil)
fp.hostname = nodeName

18
pkg/util/ipset/testing/BUILD
View File

@ -1,11 +1,14 @@
load("@io_bazel_rules_go//go:def.bzl", "go_library")
load("@io_bazel_rules_go//go:def.bzl", "go_library", "go_test")
go_library(
name = "go_default_library",
srcs = ["fake.go"],
importpath = "k8s.io/kubernetes/pkg/util/ipset/testing",
visibility = ["//visibility:public"],
deps = ["//pkg/util/ipset:go_default_library"],
deps = [
"//pkg/util/ipset:go_default_library",
"//vendor/k8s.io/apimachinery/pkg/util/sets:go_default_library",
],
)
filegroup(
@ -21,3 +24,14 @@ filegroup(
tags = ["automanaged"],
visibility = ["//visibility:public"],
)
go_test(
name = "go_default_test",
srcs = ["fake_test.go"],
importpath = "k8s.io/kubernetes/pkg/util/ipset/testing",
library = ":go_default_library",
deps = [
"//pkg/util/ipset:go_default_library",
"//vendor/k8s.io/apimachinery/pkg/util/sets:go_default_library",
],
)

100
pkg/util/ipset/testing/fake.go
View File

@ -17,67 +17,127 @@ limitations under the License.
package testing
import (
"fmt"
"k8s.io/apimachinery/pkg/util/sets"
"k8s.io/kubernetes/pkg/util/ipset"
)
// FakeIPSet is a no-op implementation of ipset Interface
type FakeIPSet struct {
Lines []byte
// version of ipset util
Version string
// The key of Sets map is the ip set name
Sets map[string]*ipset.IPSet
// The key of Entries map is the ip set name where the entries exists
Entries map[string]sets.String
}
// NewFake create a new fake ipset interface.
func NewFake() *FakeIPSet {
return &FakeIPSet{}
// NewFake create a new fake ipset interface - it initialize the FakeIPSet.
func NewFake(version string) *FakeIPSet {
return &FakeIPSet{
Version: version,
Sets: make(map[string]*ipset.IPSet),
Entries: make(map[string]sets.String),
}
}
// GetVersion is part of interface.
func (*FakeIPSet) GetVersion() (string, error) {
return "0.0", nil
func (f *FakeIPSet) GetVersion() (string, error) {
return f.Version, nil
}
// FlushSet is part of interface.
func (*FakeIPSet) FlushSet(set string) error {
// FlushSet is part of interface. It deletes all entries from a named set but keeps the set itself.
func (f *FakeIPSet) FlushSet(set string) error {
if f.Entries == nil {
return fmt.Errorf("entries map can't be nil")
}
// delete all entry elements
for true {
if _, has := f.Entries[set].PopAny(); has {
continue
}
break
}
return nil
}
// DestroySet is part of interface.
func (*FakeIPSet) DestroySet(set string) error {
// DestroySet is part of interface. It deletes both the entries and the set itself.
func (f *FakeIPSet) DestroySet(set string) error {
delete(f.Sets, set)
delete(f.Entries, set)
return nil
}
// DestroyAllSets is part of interface.
func (*FakeIPSet) DestroyAllSets() error {
func (f *FakeIPSet) DestroyAllSets() error {
f.Sets = nil
f.Entries = nil
return nil
}
// CreateSet is part of interface.
func (*FakeIPSet) CreateSet(set *ipset.IPSet, ignoreExistErr bool) error {
func (f *FakeIPSet) CreateSet(set *ipset.IPSet, ignoreExistErr bool) error {
if f.Sets[set.Name] != nil {
if !ignoreExistErr {
// already exists
return fmt.Errorf("Set cannot be created: set with the same name already exists")
}
return nil
}
f.Sets[set.Name] = set
// initialize entry map
f.Entries[set.Name] = sets.NewString()
return nil
}
// AddEntry is part of interface.
func (*FakeIPSet) AddEntry(entry string, set string, ignoreExistErr bool) error {
func (f *FakeIPSet) AddEntry(entry string, set string, ignoreExistErr bool) error {
if f.Entries[set].Has(entry) {
if !ignoreExistErr {
// already exists
return fmt.Errorf("Element cannot be added to the set: it's already added")
}
return nil
}
f.Entries[set].Insert(entry)
return nil
}
// DelEntry is part of interface.
func (*FakeIPSet) DelEntry(entry string, set string) error {
func (f *FakeIPSet) DelEntry(entry string, set string) error {
if f.Entries == nil {
return fmt.Errorf("entries map can't be nil")
}
f.Entries[set].Delete(entry)
return nil
}
// TestEntry is part of interface.
func (*FakeIPSet) TestEntry(entry string, set string) (bool, error) {
return true, nil
func (f *FakeIPSet) TestEntry(entry string, set string) (bool, error) {
if f.Entries == nil {
return false, fmt.Errorf("entries map can't be nil")
}
found := f.Entries[set].Has(entry)
return found, nil
}
// ListEntries is part of interface.
func (*FakeIPSet) ListEntries(set string) ([]string, error) {
return nil, nil
func (f *FakeIPSet) ListEntries(set string) ([]string, error) {
if f.Entries == nil {
return nil, fmt.Errorf("entries map can't be nil")
}
return f.Entries[set].UnsortedList(), nil
}
// ListSets is part of interface.
func (*FakeIPSet) ListSets() ([]string, error) {
return nil, nil
func (f *FakeIPSet) ListSets() ([]string, error) {
res := []string{}
for set := range f.Sets {
res = append(res, set)
}
return res, nil
}
var _ = ipset.Interface(&FakeIPSet{})

152
pkg/util/ipset/testing/fake_test.go Normal file
View File

@ -0,0 +1,152 @@
/*
Copyright 2017 The Kubernetes Authors.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package testing
import (
"testing"
"k8s.io/apimachinery/pkg/util/sets"
"k8s.io/kubernetes/pkg/util/ipset"
)
const testVersion = "v6.19"
func TestSetEntry(t *testing.T) {
fake := NewFake(testVersion)
version, err := fake.GetVersion()
if err != nil {
t.Errorf("Unexpected error: %v", err)
}
if version != testVersion {
t.Errorf("Unexpected version mismatch, expected: %s, got: %s", testVersion, version)
}
// create a set
set := &ipset.IPSet{
Name: "foo",
SetType: ipset.HashIPPort,
HashFamily: ipset.ProtocolFamilyIPV4,
}
if err := fake.CreateSet(set, true); err != nil {
t.Errorf("Unexpected error: %v", err)
}
// add two entries
fake.AddEntry("192.168.1.1,tcp:8080", set.Name, true)
fake.AddEntry("192.168.1.2,tcp:8081", set.Name, true)
entries, err := fake.ListEntries(set.Name)
if err != nil {
t.Errorf("Unexpected error: %v", err)
}
if len(entries) != 2 {
t.Errorf("Expected 2 entries, got %d", len(entries))
}
expectedEntries := sets.NewString("192.168.1.1,tcp:8080", "192.168.1.2,tcp:8081")
if !expectedEntries.Equal(sets.NewString(entries...)) {
t.Errorf("Unexpected entries mismatch, expected: %v, got: %v", expectedEntries, entries)
}
// test entries
found, err := fake.TestEntry("192.168.1.1,tcp:8080", set.Name)
if err != nil {
t.Errorf("Unexpected error: %v", err)
}
if !found {
t.Errorf("Unexpected entry 192.168.1.1,tcp:8080 not found")
}
found, err = fake.TestEntry("192.168.1.2,tcp:8081", set.Name)
if err != nil {
t.Errorf("Unexpected error: %v", err)
}
if !found {
t.Errorf("Unexpected entry 192.168.1.2,tcp:8081 not found")
}
// delete entry from a given set
if err := fake.DelEntry("192.168.1.1,tcp:8080", set.Name); err != nil {
t.Errorf("Unexpected error: %v", err)
}
entries, err = fake.ListEntries(set.Name)
if err != nil {
t.Errorf("Unexpected error: %v", err)
}
if len(entries) != 1 {
t.Errorf("Expected 1 entries, got %d", len(entries))
}
expectedEntries = sets.NewString("192.168.1.2,tcp:8081")
if !expectedEntries.Equal(sets.NewString(entries...)) {
t.Errorf("Unexpected entries mismatch, expected: %v, got: %v", expectedEntries, entries)
}
// Flush set
if err := fake.FlushSet(set.Name); err != nil {
t.Errorf("Unexpected error: %v", err)
}
entries, err = fake.ListEntries(set.Name)
if err != nil {
t.Errorf("Unexpected error: %v", err)
}
if len(entries) != 0 {
t.Errorf("Expected 0 entries, got %d, entries: %v", len(entries), entries)
}
// create another set
set2 := &ipset.IPSet{
Name: "bar",
SetType: ipset.HashIPPortIP,
HashFamily: ipset.ProtocolFamilyIPV6,
}
if err := fake.CreateSet(set2, true); err != nil {
t.Errorf("Unexpected error: %v", err)
}
setList, err := fake.ListSets()
if err != nil {
t.Errorf("Unexpected error: %v", err)
}
if len(setList) != 2 {
t.Errorf("Expected 2 sets, got %d", len(setList))
}
expectedSets := sets.NewString("foo", "bar")
if !expectedSets.Equal(sets.NewString(setList...)) {
t.Errorf("Unexpected sets mismatch, expected: %v, got: %v", expectedSets, setList)
}
// Destroy a given set
if err := fake.DestroySet(set.Name); err != nil {
t.Errorf("Unexpected error: %v", err)
}
if fake.Sets[set.Name] != nil {
t.Errorf("Unexpected set: %v", fake.Sets[set.Name])
}
if fake.Entries[set.Name] != nil {
t.Errorf("Unexpected entries: %v", fake.Entries[set.Name])
}
// Destroy all sets
if err := fake.DestroyAllSets(); err != nil {
t.Errorf("Unexpected error: %v", err)
}
if len(fake.Sets) != 0 {
t.Errorf("Expected 0 sets, got %d, sets: %v", len(fake.Sets), fake.Sets)
}
if len(fake.Entries) != 0 {
t.Errorf("Expected 0 entries, got %d, entries: %v", len(fake.Entries), fake.Entries)
}
}
// TODO: Test ignoreExistErr=false