vendor files

vendor/k8s.io/kubernetes/pkg/util/ipvs/testing/BUILD

@@ -0,0 +1,35 @@
+package(default_visibility = ["//visibility:public"])
+
+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/ipvs/testing",
+    deps = ["//pkg/util/ipvs:go_default_library"],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = ["fake_test.go"],
+    importpath = "k8s.io/kubernetes/pkg/util/ipvs/testing",
+    library = ":go_default_library",
+    deps = ["//pkg/util/ipvs:go_default_library"],
+)

vendor/k8s.io/kubernetes/pkg/util/ipvs/testing/fake.go

@@ -0,0 +1,177 @@
+/*
+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 (
+	"fmt"
+
+	utilipvs "k8s.io/kubernetes/pkg/util/ipvs"
+)
+
+//FakeIPVS no-op implementation of ipvs Interface
+type FakeIPVS struct {
+	Scheduler    string
+	Services     map[serviceKey]*utilipvs.VirtualServer
+	Destinations map[serviceKey][]*utilipvs.RealServer
+}
+
+type serviceKey struct {
+	IP       string
+	Port     uint16
+	Protocol string
+}
+
+func (s *serviceKey) String() string {
+	return fmt.Sprintf("%s:%d/%s", s.IP, s.Port, s.Protocol)
+}
+
+//NewFake creates a fake ipvs implementation - a cache store.
+func NewFake() *FakeIPVS {
+	return &FakeIPVS{
+		Services:     make(map[serviceKey]*utilipvs.VirtualServer),
+		Destinations: make(map[serviceKey][]*utilipvs.RealServer),
+	}
+}
+
+func toServiceKey(serv *utilipvs.VirtualServer) serviceKey {
+	return serviceKey{
+		IP:       serv.Address.String(),
+		Port:     serv.Port,
+		Protocol: serv.Protocol,
+	}
+}
+
+//AddVirtualServer is a fake implementation, it simply adds the VirtualServer into the cache store.
+func (f *FakeIPVS) AddVirtualServer(serv *utilipvs.VirtualServer) error {
+	if serv == nil {
+		return fmt.Errorf("Failed to add virtual server, error: virtual server can't be nil")
+	}
+	key := toServiceKey(serv)
+	f.Services[key] = serv
+	// make sure no destination present when creating new service
+	f.Destinations[key] = make([]*utilipvs.RealServer, 0)
+	return nil
+}
+
+//UpdateVirtualServer is a fake implementation, it updates the VirtualServer in the cache store.
+func (f *FakeIPVS) UpdateVirtualServer(serv *utilipvs.VirtualServer) error {
+	if serv == nil {
+		return fmt.Errorf("Failed to update service, service can't be nil")
+	}
+	key := toServiceKey(serv)
+	f.Services[key] = serv
+	return nil
+}
+
+//DeleteVirtualServer is a fake implementation, it simply deletes the VirtualServer from the cache store.
+func (f *FakeIPVS) DeleteVirtualServer(serv *utilipvs.VirtualServer) error {
+	if serv == nil {
+		return fmt.Errorf("Failed to delete service: service can't be nil")
+	}
+	key := toServiceKey(serv)
+	delete(f.Services, key)
+	// clear specific destinations as well
+	f.Destinations[key] = nil
+	return nil
+}
+
+//GetVirtualServer is a fake implementation, it tries to find a specific VirtualServer from the cache store.
+func (f *FakeIPVS) GetVirtualServer(serv *utilipvs.VirtualServer) (*utilipvs.VirtualServer, error) {
+	if serv == nil {
+		return nil, fmt.Errorf("Failed to get service: service can't be nil")
+	}
+	key := toServiceKey(serv)
+	svc, found := f.Services[key]
+	if found {
+		return svc, nil
+	}
+	return nil, fmt.Errorf("Not found serv: %v", key.String())
+}
+
+//GetVirtualServers is a fake implementation, it simply returns all VirtualServers in the cache store.
+func (f *FakeIPVS) GetVirtualServers() ([]*utilipvs.VirtualServer, error) {
+	res := make([]*utilipvs.VirtualServer, 0)
+	for _, svc := range f.Services {
+		res = append(res, svc)
+	}
+	return res, nil
+}
+
+//Flush is a fake implementation, it simply clears the cache store.
+func (f *FakeIPVS) Flush() error {
+	// directly drop old data
+	f.Services = nil
+	f.Destinations = nil
+	return nil
+}
+
+//AddRealServer is a fake implementation, it simply creates a RealServer for a VirtualServer in the cache store.
+func (f *FakeIPVS) AddRealServer(serv *utilipvs.VirtualServer, dest *utilipvs.RealServer) error {
+	if serv == nil || dest == nil {
+		return fmt.Errorf("Failed to add destination for service, neither service nor destination shouldn't be nil")
+	}
+	key := toServiceKey(serv)
+	if _, ok := f.Services[key]; !ok {
+		return fmt.Errorf("Failed to add destination for service %v, service not found", key.String())
+	}
+	dests := f.Destinations[key]
+	if dests == nil {
+		dests = make([]*utilipvs.RealServer, 0)
+		f.Destinations[key] = dests
+	}
+	f.Destinations[key] = append(f.Destinations[key], dest)
+	return nil
+}
+
+//GetRealServers is a fake implementation, it simply returns all RealServers in the cache store.
+func (f *FakeIPVS) GetRealServers(serv *utilipvs.VirtualServer) ([]*utilipvs.RealServer, error) {
+	if serv == nil {
+		return nil, fmt.Errorf("Failed to get destination for nil service")
+	}
+	key := toServiceKey(serv)
+	if _, ok := f.Services[key]; !ok {
+		return nil, fmt.Errorf("Failed to get destinations for service %v, service not found", key.String())
+	}
+	return f.Destinations[key], nil
+}
+
+//DeleteRealServer is a fake implementation, it deletes the real server in the cache store.
+func (f *FakeIPVS) DeleteRealServer(serv *utilipvs.VirtualServer, dest *utilipvs.RealServer) error {
+	if serv == nil || dest == nil {
+		return fmt.Errorf("Failed to delete destination, neither service nor destination can't be nil")
+	}
+	key := toServiceKey(serv)
+	if _, ok := f.Services[key]; !ok {
+		return fmt.Errorf("Failed to delete destination for service %v, service not found", key.String())
+	}
+	dests := f.Destinations[key]
+	var i int
+	for i = range dests {
+		if dests[i].Equal(dest) {
+			break
+		}
+	}
+	// Not Found
+	if i >= len(f.Destinations[key]) {
+		return fmt.Errorf("Failed to delete real server for service %v, real server not found", key.String())
+	}
+	// Delete one element
+	f.Destinations[key] = append(f.Destinations[key][:i], f.Destinations[key][i+1:]...)
+	return nil
+}
+
+var _ = utilipvs.Interface(&FakeIPVS{})

vendor/k8s.io/kubernetes/pkg/util/ipvs/testing/fake_test.go

@@ -0,0 +1,166 @@
+/*
+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 (
+	"net"
+	"testing"
+
+	utilipvs "k8s.io/kubernetes/pkg/util/ipvs"
+)
+
+func TestVirtualServer(t *testing.T) {
+	// Initialize
+	fake := NewFake()
+	// Add a virtual server
+	vs1 := &utilipvs.VirtualServer{
+		Address:  net.ParseIP("1.2.3.4"),
+		Port:     uint16(80),
+		Protocol: string("TCP"),
+		Flags:    utilipvs.FlagHashed,
+	}
+	err := fake.AddVirtualServer(vs1)
+	if err != nil {
+		t.Errorf("Fail to add virutal server, error: %v", err)
+	}
+	// Get a specific virtual server
+	got1, err := fake.GetVirtualServer(vs1)
+	if err != nil {
+		t.Errorf("Fail to get virutal server, error: %v", err)
+	}
+	if !vs1.Equal(got1) {
+		t.Errorf("Expect virtual server: %v, got: %v", vs1, got1)
+	}
+	// Update virtual server
+	vs12 := &utilipvs.VirtualServer{
+		Address:  net.ParseIP("1.2.3.4"),
+		Port:     uint16(80),
+		Protocol: string("TCP"),
+		Flags:    utilipvs.FlagPersistent,
+	}
+	err = fake.UpdateVirtualServer(vs12)
+	if err != nil {
+		t.Errorf("Fail to update virutal server, error: %v", err)
+	}
+	// Check the updated virtual server
+	got12, err := fake.GetVirtualServer(vs1)
+	if !got12.Equal(vs12) {
+		t.Errorf("Expect virutal server: %v, got: %v", vs12, got12)
+	}
+	// Add another virtual server
+	vs2 := &utilipvs.VirtualServer{
+		Address:  net.ParseIP("10::40"),
+		Port:     uint16(8080),
+		Protocol: string("UDP"),
+	}
+	err = fake.AddVirtualServer(vs2)
+	if err != nil {
+		t.Errorf("Unexpected error when add virutal server, error: %v", err)
+	}
+	// List all virtual servers
+	list, err := fake.GetVirtualServers()
+	if err != nil {
+		t.Errorf("Fail to list virutal servers, error: %v", err)
+	}
+	if len(list) != 2 {
+		t.Errorf("Expect 2 virutal servers, got: %d", len(list))
+	}
+	// Delete a virtual server
+	err = fake.DeleteVirtualServer(vs1)
+	if err != nil {
+		t.Errorf("Fail to delete virutal server: %v, error: %v", vs1, err)
+	}
+	// Check the deleted virtual server no longer exists
+	got, _ := fake.GetVirtualServer(vs1)
+	if got != nil {
+		t.Errorf("Expect nil, got: %v", got)
+	}
+	// Flush all virtual servers
+	err = fake.Flush()
+	if err != nil {
+		t.Errorf("Fail to flush virutal servers, error: %v", err)
+	}
+	// List all virtual servers
+	list, err = fake.GetVirtualServers()
+	if err != nil {
+		t.Errorf("Fail to list virutal servers, error: %v", err)
+	}
+	if len(list) != 0 {
+		t.Errorf("Expect 0 virutal servers, got: %d", len(list))
+	}
+}
+
+func TestRealServer(t *testing.T) {
+	// Initialize
+	fake := NewFake()
+	// Add a virtual server
+	vs := &utilipvs.VirtualServer{
+		Address:  net.ParseIP("10.20.30.40"),
+		Port:     uint16(80),
+		Protocol: string("TCP"),
+	}
+	err := fake.AddVirtualServer(vs)
+	if err != nil {
+		t.Errorf("Fail to add virutal server, error: %v", err)
+	}
+	// Add a real server to the virtual server
+	rs1 := &utilipvs.RealServer{
+		Address: net.ParseIP("172.16.2.1"),
+		Port:    uint16(8080),
+		Weight:  1,
+	}
+	err = fake.AddRealServer(vs, rs1)
+	if err != nil {
+		t.Errorf("Fail to add real server, error: %v", err)
+	}
+	// Add another real server to the virtual server
+	rs2 := &utilipvs.RealServer{
+		Address: net.ParseIP("172.16.3.2"),
+		Port:    uint16(8080),
+		Weight:  2,
+	}
+	err = fake.AddRealServer(vs, rs2)
+	if err != nil {
+		t.Errorf("Fail to add real server, error: %v", err)
+	}
+	// List all real servers of the virtual server
+	list, err := fake.GetRealServers(vs)
+	if err != nil {
+		t.Errorf("Fail to get real servers of the virtual server, error: %v", err)
+	}
+	if len(list) != 2 {
+		t.Errorf("Expect 2 virutal servers, got: %d", len(list))
+	}
+	// Delete a real server of the virtual server
+	err = fake.DeleteRealServer(vs, rs2)
+	list, err = fake.GetRealServers(vs)
+	if err != nil {
+		t.Errorf("Fail to get real servers of the virtual server, error: %v", err)
+	}
+	if len(list) != 1 {
+		t.Errorf("Expect 1 real server, got: %d", len(list))
+	}
+	// Delete the virtual server
+	err = fake.DeleteVirtualServer(vs)
+	if err != nil {
+		t.Errorf("Fail to delete virtual server, error: %v", err)
+	}
+	_, err = fake.GetRealServers(vs)
+	if err == nil {
+		t.Errorf("Expect error, got nil")
+	}
+}