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

Merge pull request #59429 from rramkumar1/ipvs-cleanup 

Automatic merge from submit-queue. 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>.

Cleanup of ipvs utils

**What this PR does / why we need it**:
This PR is a small cleanup of pkg/util/ipvs.

The changes are as follows:

1. Rename toBackendService -> toIPVSService and toBackendDestination -> toIPVSDestination. The use of the term 'backend' makes things really confusing and this renamig makes it more explicit about what we are doing.

2. Give the libnetwork/ipvs package the name libipvs. This makes it less confusing since the package these files are in is also ipvs.

3. Some variable naming cleanup to make things easier to read.

/assign @m1093782566 

**Release note**:

```release-note
None
```
pull/6/head
Kubernetes Submit Queue 2018-02-07 18:07:35 -08:00 committed by GitHub
parent 8992aa0f06 daae0e6cec
commit 07e849c986
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
2 changed files with 103 additions and 103 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

128
pkg/util/ipvs/ipvs_linux.go
View File

@ -25,83 +25,86 @@ import (
"strings" "strings"
"syscall" "syscall"
"github.com/docker/libnetwork/ipvs" libipvs "github.com/docker/libnetwork/ipvs"
"github.com/golang/glog" "github.com/golang/glog"
utilexec "k8s.io/utils/exec" utilexec "k8s.io/utils/exec"
) )
// runner implements Interface. // runner implements ipvs.Interface.
type runner struct { type runner struct {
exec utilexec.Interface exec utilexec.Interface
ipvsHandle *ipvs.Handle ipvsHandle *libipvs.Handle
} }
// Protocol is the IPVS service protocol type
type Protocol uint16
// New returns a new Interface which will call ipvs APIs. // New returns a new Interface which will call ipvs APIs.
func New(exec utilexec.Interface) Interface { func New(exec utilexec.Interface) Interface {
ihandle, err := ipvs.New("") handle, err := libipvs.New("")
if err != nil { if err != nil {
glog.Errorf("IPVS interface can't be initialized, error: %v", err) glog.Errorf("IPVS interface can't be initialized, error: %v", err)
return nil return nil
} }
return &runner{ return &runner{
exec: exec, exec: exec,
ipvsHandle: ihandle, ipvsHandle: handle,
} }
} }
// AddVirtualServer is part of Interface. // AddVirtualServer is part of ipvs.Interface.
func (runner *runner) AddVirtualServer(vs *VirtualServer) error { func (runner *runner) AddVirtualServer(vs *VirtualServer) error {
eSvc, err := toBackendService(vs) svc, err := toIPVSService(vs)
if err != nil { if err != nil {
return err return err
} }
return runner.ipvsHandle.NewService(eSvc) return runner.ipvsHandle.NewService(svc)
} }
// UpdateVirtualServer is part of Interface. // UpdateVirtualServer is part of ipvs.Interface.
func (runner *runner) UpdateVirtualServer(vs *VirtualServer) error { func (runner *runner) UpdateVirtualServer(vs *VirtualServer) error {
bSvc, err := toBackendService(vs) svc, err := toIPVSService(vs)
if err != nil { if err != nil {
return err return err
} }
return runner.ipvsHandle.UpdateService(bSvc) return runner.ipvsHandle.UpdateService(svc)
} }
// DeleteVirtualServer is part of Interface. // DeleteVirtualServer is part of ipvs.Interface.
func (runner *runner) DeleteVirtualServer(vs *VirtualServer) error { func (runner *runner) DeleteVirtualServer(vs *VirtualServer) error {
bSvc, err := toBackendService(vs) svc, err := toIPVSService(vs)
if err != nil { if err != nil {
return err return err
} }
return runner.ipvsHandle.DelService(bSvc) return runner.ipvsHandle.DelService(svc)
} }
// GetVirtualServer is part of Interface. // GetVirtualServer is part of ipvs.Interface.
func (runner *runner) GetVirtualServer(vs *VirtualServer) (*VirtualServer, error) { func (runner *runner) GetVirtualServer(vs *VirtualServer) (*VirtualServer, error) {
bSvc, err := toBackendService(vs) svc, err := toIPVSService(vs)
if err != nil { if err != nil {
return nil, err return nil, err
} }
ipvsService, err := runner.ipvsHandle.GetService(bSvc) ipvsSvc, err := runner.ipvsHandle.GetService(svc)
if err != nil { if err != nil {
return nil, err return nil, err
} }
virtualServer, err := toVirtualServer(ipvsService) vServ, err := toVirtualServer(ipvsSvc)
if err != nil { if err != nil {
return nil, err return nil, err
} }
return virtualServer, nil return vServ, nil
} }
// GetVirtualServers is part of Interface. // GetVirtualServers is part of ipvs.Interface.
func (runner *runner) GetVirtualServers() ([]*VirtualServer, error) { func (runner *runner) GetVirtualServers() ([]*VirtualServer, error) {
ipvsServices, err := runner.ipvsHandle.GetServices() ipvsSvcs, err := runner.ipvsHandle.GetServices()
if err != nil { if err != nil {
return nil, err return nil, err
} }
vss := make([]*VirtualServer, 0) vss := make([]*VirtualServer, 0)
for _, ipvsService := range ipvsServices { for _, ipvsSvc := range ipvsSvcs {
vs, err := toVirtualServer(ipvsService) vs, err := toVirtualServer(ipvsSvc)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -110,61 +113,61 @@ func (runner *runner) GetVirtualServers() ([]*VirtualServer, error) {
return vss, nil return vss, nil
} }
// Flush is part of Interface. Currently we delete IPVS services one by one // Flush is part of ipvs.Interface. Currently we delete IPVS services one by one
func (runner *runner) Flush() error { func (runner *runner) Flush() error {
return runner.ipvsHandle.Flush() return runner.ipvsHandle.Flush()
} }
// AddRealServer is part of Interface. // AddRealServer is part of ipvs.Interface.
func (runner *runner) AddRealServer(vs *VirtualServer, rs *RealServer) error { func (runner *runner) AddRealServer(vs *VirtualServer, rs *RealServer) error {
bSvc, err := toBackendService(vs) svc, err := toIPVSService(vs)
if err != nil { if err != nil {
return err return err
} }
bDst, err := toBackendDestination(rs) dst, err := toIPVSDestination(rs)
if err != nil { if err != nil {
return err return err
} }
return runner.ipvsHandle.NewDestination(bSvc, bDst) return runner.ipvsHandle.NewDestination(svc, dst)
} }
// DeleteRealServer is part of Interface. // DeleteRealServer is part of ipvs.Interface.
func (runner *runner) DeleteRealServer(vs *VirtualServer, rs *RealServer) error { func (runner *runner) DeleteRealServer(vs *VirtualServer, rs *RealServer) error {
bSvc, err := toBackendService(vs) svc, err := toIPVSService(vs)
if err != nil { if err != nil {
return err return err
} }
bDst, err := toBackendDestination(rs) dst, err := toIPVSDestination(rs)
if err != nil { if err != nil {
return err return err
} }
return runner.ipvsHandle.DelDestination(bSvc, bDst) return runner.ipvsHandle.DelDestination(svc, dst)
} }
// GetRealServers is part of Interface. // GetRealServers is part of ipvs.Interface.
func (runner *runner) GetRealServers(vs *VirtualServer) ([]*RealServer, error) { func (runner *runner) GetRealServers(vs *VirtualServer) ([]*RealServer, error) {
bSvc, err := toBackendService(vs) svc, err := toIPVSService(vs)
if err != nil { if err != nil {
return nil, err return nil, err
} }
bDestinations, err := runner.ipvsHandle.GetDestinations(bSvc) dsts, err := runner.ipvsHandle.GetDestinations(svc)
if err != nil { if err != nil {
return nil, err return nil, err
} }
realServers := make([]*RealServer, 0) rss := make([]*RealServer, 0)
for _, dest := range bDestinations { for _, dst := range dsts {
dst, err := toRealServer(dest) dst, err := toRealServer(dst)
// TODO: aggregate errors? // TODO: aggregate errors?
if err != nil { if err != nil {
return nil, err return nil, err
} }
realServers = append(realServers, dst) rss = append(rss, dst)
} }
return realServers, nil return rss, nil
} }
// toVirtualServer converts an IPVS service representation to the equivalent virtual server structure. // toVirtualServer converts an IPVS Service to the equivalent VirtualServer structure.
func toVirtualServer(svc *ipvs.Service) (*VirtualServer, error) { func toVirtualServer(svc *libipvs.Service) (*VirtualServer, error) {
if svc == nil { if svc == nil {
return nil, errors.New("ipvs svc should not be empty") return nil, errors.New("ipvs svc should not be empty")
} }
@ -172,7 +175,7 @@ func toVirtualServer(svc *ipvs.Service) (*VirtualServer, error) {
Address: svc.Address, Address: svc.Address,
Port: svc.Port, Port: svc.Port,
Scheduler: svc.SchedName, Scheduler: svc.SchedName,
Protocol: protocolNumbeToString(ProtoType(svc.Protocol)), Protocol: protocolToString(Protocol(svc.Protocol)),
Timeout: svc.Timeout, Timeout: svc.Timeout,
} }
@ -194,8 +197,8 @@ func toVirtualServer(svc *ipvs.Service) (*VirtualServer, error) {
return vs, nil return vs, nil
} }
// toRealServer converts an IPVS destination representation to the equivalent real server structure. // toRealServer converts an IPVS Destination to the equivalent RealServer structure.
func toRealServer(dst *ipvs.Destination) (*RealServer, error) { func toRealServer(dst *libipvs.Destination) (*RealServer, error) {
if dst == nil { if dst == nil {
return nil, errors.New("ipvs destination should not be empty") return nil, errors.New("ipvs destination should not be empty")
} }
@ -206,14 +209,14 @@ func toRealServer(dst *ipvs.Destination) (*RealServer, error) {
}, nil }, nil
} }
// toBackendService converts an IPVS real server representation to the equivalent "backend" service structure. // toIPVSService converts a VirtualServer to the equivalent IPVS Service structure.
func toBackendService(vs *VirtualServer) (*ipvs.Service, error) { func toIPVSService(vs *VirtualServer) (*libipvs.Service, error) {
if vs == nil { if vs == nil {
return nil, errors.New("virtual server should not be empty") return nil, errors.New("virtual server should not be empty")
} }
bakSvc := &ipvs.Service{ ipvsSvc := &libipvs.Service{
Address: vs.Address, Address: vs.Address,
Protocol: stringToProtocolNumber(vs.Protocol), Protocol: stringToProtocol(vs.Protocol),
Port: vs.Port, Port: vs.Port,
SchedName: vs.Scheduler, SchedName: vs.Scheduler,
Flags: uint32(vs.Flags), Flags: uint32(vs.Flags),
@ -221,29 +224,29 @@ func toBackendService(vs *VirtualServer) (*ipvs.Service, error) {
} }
if ip4 := vs.Address.To4(); ip4 != nil { if ip4 := vs.Address.To4(); ip4 != nil {
bakSvc.AddressFamily = syscall.AF_INET ipvsSvc.AddressFamily = syscall.AF_INET
bakSvc.Netmask = 0xffffffff ipvsSvc.Netmask = 0xffffffff
} else { } else {
bakSvc.AddressFamily = syscall.AF_INET6 ipvsSvc.AddressFamily = syscall.AF_INET6
bakSvc.Netmask = 128 ipvsSvc.Netmask = 128
} }
return bakSvc, nil return ipvsSvc, nil
} }
// toBackendDestination converts an IPVS real server representation to the equivalent "backend" destination structure. // toIPVSDestination converts a RealServer to the equivalent IPVS Destination structure.
func toBackendDestination(rs *RealServer) (*ipvs.Destination, error) { func toIPVSDestination(rs *RealServer) (*libipvs.Destination, error) {
if rs == nil { if rs == nil {
return nil, errors.New("real server should not be empty") return nil, errors.New("real server should not be empty")
} }
return &ipvs.Destination{ return &libipvs.Destination{
Address: rs.Address, Address: rs.Address,
Port: rs.Port, Port: rs.Port,
Weight: rs.Weight, Weight: rs.Weight,
}, nil }, nil
} }
// stringToProtocolNumber returns the protocol value for the given name // stringToProtocolType returns the protocol type for the given name
func stringToProtocolNumber(protocol string) uint16 { func stringToProtocol(protocol string) uint16 {
switch strings.ToLower(protocol) { switch strings.ToLower(protocol) {
case "tcp": case "tcp":
return uint16(syscall.IPPROTO_TCP) return uint16(syscall.IPPROTO_TCP)
@ -253,8 +256,8 @@ func stringToProtocolNumber(protocol string) uint16 {
return uint16(0) return uint16(0)
} }
// protocolNumbeToString returns the name for the given protocol value. // protocolTypeToString returns the name for the given protocol.
func protocolNumbeToString(proto ProtoType) string { func protocolToString(proto Protocol) string {
switch proto { switch proto {
case syscall.IPPROTO_TCP: case syscall.IPPROTO_TCP:
return "TCP" return "TCP"
@ -263,6 +266,3 @@ func protocolNumbeToString(proto ProtoType) string {
} }
return "" return ""
} }
// ProtoType is IPVS service protocol type
type ProtoType uint16

78
pkg/util/ipvs/ipvs_linux_test.go
View File

@ -25,18 +25,18 @@ import (
"syscall" "syscall"
"testing" "testing"
"github.com/docker/libnetwork/ipvs" libipvs "github.com/docker/libnetwork/ipvs"
) )
func Test_toVirtualServer(t *testing.T) { func Test_toVirtualServer(t *testing.T) {
Tests := []struct { Tests := []struct {
ipvsService ipvs.Service ipvsService libipvs.Service
virtualServer VirtualServer virtualServer VirtualServer
expectError bool expectError bool
reason string reason string
}{ }{
{ {
ipvs.Service{ libipvs.Service{
Flags: 0x0, Flags: 0x0,
}, },
VirtualServer{}, VirtualServer{},
@ -44,7 +44,7 @@ func Test_toVirtualServer(t *testing.T) {
fmt.Sprintf("IPVS Service Flags should be >= %d, got 0x0", FlagHashed), fmt.Sprintf("IPVS Service Flags should be >= %d, got 0x0", FlagHashed),
}, },
{ {
ipvs.Service{ libipvs.Service{
Flags: 0x1, Flags: 0x1,
}, },
VirtualServer{}, VirtualServer{},
@ -52,7 +52,7 @@ func Test_toVirtualServer(t *testing.T) {
fmt.Sprintf("IPVS Service Flags should be >= %d, got 0x1", FlagHashed), fmt.Sprintf("IPVS Service Flags should be >= %d, got 0x1", FlagHashed),
}, },
{ {
ipvs.Service{ libipvs.Service{
Protocol: syscall.IPPROTO_TCP, Protocol: syscall.IPPROTO_TCP,
Port: 80, Port: 80,
FWMark: 0, FWMark: 0,
@ -76,7 +76,7 @@ func Test_toVirtualServer(t *testing.T) {
"", "",
}, },
{ {
ipvs.Service{ libipvs.Service{
Protocol: syscall.IPPROTO_UDP, Protocol: syscall.IPPROTO_UDP,
Port: 33434, Port: 33434,
FWMark: 0, FWMark: 0,
@ -100,7 +100,7 @@ func Test_toVirtualServer(t *testing.T) {
"", "",
}, },
{ {
ipvs.Service{ libipvs.Service{
Protocol: 0, Protocol: 0,
Port: 0, Port: 0,
FWMark: 0, FWMark: 0,
@ -124,7 +124,7 @@ func Test_toVirtualServer(t *testing.T) {
"", "",
}, },
{ {
ipvs.Service{ libipvs.Service{
Protocol: 0, Protocol: 0,
Port: 0, Port: 0,
FWMark: 0, FWMark: 0,
@ -165,13 +165,13 @@ func Test_toVirtualServer(t *testing.T) {
} }
} }
func Test_toBackendService(t *testing.T) { func Test_toIPVSService(t *testing.T) {
Tests := []struct { Tests := []struct {
ipvsService ipvs.Service ipvsService libipvs.Service
virtualServer VirtualServer virtualServer VirtualServer
}{ }{
{ {
ipvs.Service{ libipvs.Service{
Protocol: syscall.IPPROTO_TCP, Protocol: syscall.IPPROTO_TCP,
Port: 80, Port: 80,
FWMark: 0, FWMark: 0,
@ -193,7 +193,7 @@ func Test_toBackendService(t *testing.T) {
}, },
}, },
{ {
ipvs.Service{ libipvs.Service{
Protocol: syscall.IPPROTO_UDP, Protocol: syscall.IPPROTO_UDP,
Port: 33434, Port: 33434,
FWMark: 0, FWMark: 0,
@ -215,7 +215,7 @@ func Test_toBackendService(t *testing.T) {
}, },
}, },
{ {
ipvs.Service{ libipvs.Service{
Protocol: 0, Protocol: 0,
Port: 0, Port: 0,
FWMark: 0, FWMark: 0,
@ -237,7 +237,7 @@ func Test_toBackendService(t *testing.T) {
}, },
}, },
{ {
ipvs.Service{ libipvs.Service{
Protocol: 0, Protocol: 0,
Port: 0, Port: 0,
FWMark: 0, FWMark: 0,
@ -261,7 +261,7 @@ func Test_toBackendService(t *testing.T) {
} }
for i := range Tests { for i := range Tests {
got, err := toBackendService(&Tests[i].virtualServer) got, err := toIPVSService(&Tests[i].virtualServer)
if err != nil { if err != nil {
t.Errorf("case: %d, unexpected error: %v", i, err) t.Errorf("case: %d, unexpected error: %v", i, err)
} }
@ -271,13 +271,13 @@ func Test_toBackendService(t *testing.T) {
} }
} }
func Test_toFrontendDestination(t *testing.T) { func Test_toRealServer(t *testing.T) {
Tests := []struct { Tests := []struct {
ipvsDestination ipvs.Destination ipvsDestination libipvs.Destination
realServer RealServer realServer RealServer
}{ }{
{ {
ipvs.Destination{ libipvs.Destination{
Port: 54321, Port: 54321,
ConnectionFlags: 0, ConnectionFlags: 0,
Weight: 1, Weight: 1,
@ -290,7 +290,7 @@ func Test_toFrontendDestination(t *testing.T) {
}, },
}, },
{ {
ipvs.Destination{ libipvs.Destination{
Port: 53, Port: 53,
ConnectionFlags: 0, ConnectionFlags: 0,
Weight: 1, Weight: 1,
@ -314,10 +314,10 @@ func Test_toFrontendDestination(t *testing.T) {
} }
} }
func Test_toBackendDestination(t *testing.T) { func Test_toIPVSDestination(t *testing.T) {
Tests := []struct { Tests := []struct {
realServer RealServer realServer RealServer
ipvsDestination ipvs.Destination ipvsDestination libipvs.Destination
}{ }{
{ {
RealServer{ RealServer{
@ -325,7 +325,7 @@ func Test_toBackendDestination(t *testing.T) {
Port: 54321, Port: 54321,
Weight: 1, Weight: 1,
}, },
ipvs.Destination{ libipvs.Destination{
Port: 54321, Port: 54321,
ConnectionFlags: 0, ConnectionFlags: 0,
Weight: 1, Weight: 1,
@ -338,7 +338,7 @@ func Test_toBackendDestination(t *testing.T) {
Port: 53, Port: 53,
Weight: 1, Weight: 1,
}, },
ipvs.Destination{ libipvs.Destination{
Port: 53, Port: 53,
ConnectionFlags: 0, ConnectionFlags: 0,
Weight: 1, Weight: 1,
@ -347,44 +347,44 @@ func Test_toBackendDestination(t *testing.T) {
}, },
} }
for i := range Tests { for i := range Tests {
got, err := toBackendDestination(&Tests[i].realServer) got, err := toIPVSDestination(&Tests[i].realServer)
if err != nil { if err != nil {
t.Errorf("case %d unexpected error: %d", i, err) t.Errorf("case %d unexpected error: %d", i, err)
} }
if !reflect.DeepEqual(*got, Tests[i].ipvsDestination) { if !reflect.DeepEqual(*got, Tests[i].ipvsDestination) {
t.Errorf("case %d Failed to translate Destination - got %#v, want %#v", i, *got, Tests[i].ipvsDestination) t.Errorf("case %d failed to translate Destination - got %#v, want %#v", i, *got, Tests[i].ipvsDestination)
} }
} }
} }
func Test_stringToProtocolNumber(t *testing.T) { func Test_stringToProtocol(t *testing.T) {
tests := []string{ tests := []string{
"TCP", "UDP", "ICMP", "TCP", "UDP", "ICMP",
} }
expecteds := []uint16{ expected := []uint16{
uint16(syscall.IPPROTO_TCP), uint16(syscall.IPPROTO_UDP), uint16(0), uint16(syscall.IPPROTO_TCP), uint16(syscall.IPPROTO_UDP), uint16(0),
} }
for i := range tests { for i := range tests {
got := stringToProtocolNumber(tests[i]) got := stringToProtocol(tests[i])
if got != expecteds[i] { if got != expected[i] {
t.Errorf("stringToProtocolNumber() failed - got %#v, want %#v", t.Errorf("stringToProtocol() failed - got %#v, want %#v",
got, expecteds[i]) got, expected[i])
} }
} }
} }
func Test_protocolNumberToString(t *testing.T) { func Test_protocolToString(t *testing.T) {
tests := []ProtoType{ tests := []Protocol{
syscall.IPPROTO_TCP, syscall.IPPROTO_UDP, ProtoType(0), syscall.IPPROTO_TCP, syscall.IPPROTO_UDP, Protocol(0),
} }
expecteds := []string{ expected := []string{
"TCP", "UDP", "", "TCP", "UDP", "",
} }
for i := range tests { for i := range tests {
got := protocolNumbeToString(tests[i]) got := protocolToString(tests[i])
if got != expecteds[i] { if got != expected[i] {
t.Errorf("protocolNumbeToString() failed - got %#v, want %#v", t.Errorf("protocolToString() failed - got %#v, want %#v",
got, expecteds[i]) got, expected[i])
} }
} }
} }