From daae0e6cecdff760865c02ce8d42514ca81ff6dc Mon Sep 17 00:00:00 2001 From: Rohit Ramkumar Date: Tue, 6 Feb 2018 08:26:17 -0800 Subject: [PATCH] Cleanup of ipvs utils --- pkg/util/ipvs/ipvs_linux.go | 128 +++++++++++++++---------------- pkg/util/ipvs/ipvs_linux_test.go | 78 +++++++++---------- 2 files changed, 103 insertions(+), 103 deletions(-) diff --git a/pkg/util/ipvs/ipvs_linux.go b/pkg/util/ipvs/ipvs_linux.go index 3652a95663..86c42730d2 100644 --- a/pkg/util/ipvs/ipvs_linux.go +++ b/pkg/util/ipvs/ipvs_linux.go @@ -25,83 +25,86 @@ import ( "strings" "syscall" - "github.com/docker/libnetwork/ipvs" + libipvs "github.com/docker/libnetwork/ipvs" "github.com/golang/glog" utilexec "k8s.io/utils/exec" ) -// runner implements Interface. +// runner implements ipvs.Interface. type runner struct { 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. func New(exec utilexec.Interface) Interface { - ihandle, err := ipvs.New("") + handle, err := libipvs.New("") if err != nil { glog.Errorf("IPVS interface can't be initialized, error: %v", err) return nil } return &runner{ exec: exec, - ipvsHandle: ihandle, + ipvsHandle: handle, } } -// AddVirtualServer is part of Interface. +// AddVirtualServer is part of ipvs.Interface. func (runner *runner) AddVirtualServer(vs *VirtualServer) error { - eSvc, err := toBackendService(vs) + svc, err := toIPVSService(vs) if err != nil { 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 { - bSvc, err := toBackendService(vs) + svc, err := toIPVSService(vs) if err != nil { 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 { - bSvc, err := toBackendService(vs) + svc, err := toIPVSService(vs) if err != nil { 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) { - bSvc, err := toBackendService(vs) + svc, err := toIPVSService(vs) if err != nil { return nil, err } - ipvsService, err := runner.ipvsHandle.GetService(bSvc) + ipvsSvc, err := runner.ipvsHandle.GetService(svc) if err != nil { return nil, err } - virtualServer, err := toVirtualServer(ipvsService) + vServ, err := toVirtualServer(ipvsSvc) if err != nil { 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) { - ipvsServices, err := runner.ipvsHandle.GetServices() + ipvsSvcs, err := runner.ipvsHandle.GetServices() if err != nil { return nil, err } vss := make([]*VirtualServer, 0) - for _, ipvsService := range ipvsServices { - vs, err := toVirtualServer(ipvsService) + for _, ipvsSvc := range ipvsSvcs { + vs, err := toVirtualServer(ipvsSvc) if err != nil { return nil, err } @@ -110,61 +113,61 @@ func (runner *runner) GetVirtualServers() ([]*VirtualServer, error) { 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 { return runner.ipvsHandle.Flush() } -// AddRealServer is part of Interface. +// AddRealServer is part of ipvs.Interface. func (runner *runner) AddRealServer(vs *VirtualServer, rs *RealServer) error { - bSvc, err := toBackendService(vs) + svc, err := toIPVSService(vs) if err != nil { return err } - bDst, err := toBackendDestination(rs) + dst, err := toIPVSDestination(rs) if err != nil { 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 { - bSvc, err := toBackendService(vs) + svc, err := toIPVSService(vs) if err != nil { return err } - bDst, err := toBackendDestination(rs) + dst, err := toIPVSDestination(rs) if err != nil { 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) { - bSvc, err := toBackendService(vs) + svc, err := toIPVSService(vs) if err != nil { return nil, err } - bDestinations, err := runner.ipvsHandle.GetDestinations(bSvc) + dsts, err := runner.ipvsHandle.GetDestinations(svc) if err != nil { return nil, err } - realServers := make([]*RealServer, 0) - for _, dest := range bDestinations { - dst, err := toRealServer(dest) + rss := make([]*RealServer, 0) + for _, dst := range dsts { + dst, err := toRealServer(dst) // TODO: aggregate errors? if err != nil { 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. -func toVirtualServer(svc *ipvs.Service) (*VirtualServer, error) { +// toVirtualServer converts an IPVS Service to the equivalent VirtualServer structure. +func toVirtualServer(svc *libipvs.Service) (*VirtualServer, error) { if svc == nil { return nil, errors.New("ipvs svc should not be empty") } @@ -172,7 +175,7 @@ func toVirtualServer(svc *ipvs.Service) (*VirtualServer, error) { Address: svc.Address, Port: svc.Port, Scheduler: svc.SchedName, - Protocol: protocolNumbeToString(ProtoType(svc.Protocol)), + Protocol: protocolToString(Protocol(svc.Protocol)), Timeout: svc.Timeout, } @@ -194,8 +197,8 @@ func toVirtualServer(svc *ipvs.Service) (*VirtualServer, error) { return vs, nil } -// toRealServer converts an IPVS destination representation to the equivalent real server structure. -func toRealServer(dst *ipvs.Destination) (*RealServer, error) { +// toRealServer converts an IPVS Destination to the equivalent RealServer structure. +func toRealServer(dst *libipvs.Destination) (*RealServer, error) { if dst == nil { return nil, errors.New("ipvs destination should not be empty") } @@ -206,14 +209,14 @@ func toRealServer(dst *ipvs.Destination) (*RealServer, error) { }, nil } -// toBackendService converts an IPVS real server representation to the equivalent "backend" service structure. -func toBackendService(vs *VirtualServer) (*ipvs.Service, error) { +// toIPVSService converts a VirtualServer to the equivalent IPVS Service structure. +func toIPVSService(vs *VirtualServer) (*libipvs.Service, error) { if vs == nil { return nil, errors.New("virtual server should not be empty") } - bakSvc := &ipvs.Service{ + ipvsSvc := &libipvs.Service{ Address: vs.Address, - Protocol: stringToProtocolNumber(vs.Protocol), + Protocol: stringToProtocol(vs.Protocol), Port: vs.Port, SchedName: vs.Scheduler, Flags: uint32(vs.Flags), @@ -221,29 +224,29 @@ func toBackendService(vs *VirtualServer) (*ipvs.Service, error) { } if ip4 := vs.Address.To4(); ip4 != nil { - bakSvc.AddressFamily = syscall.AF_INET - bakSvc.Netmask = 0xffffffff + ipvsSvc.AddressFamily = syscall.AF_INET + ipvsSvc.Netmask = 0xffffffff } else { - bakSvc.AddressFamily = syscall.AF_INET6 - bakSvc.Netmask = 128 + ipvsSvc.AddressFamily = syscall.AF_INET6 + ipvsSvc.Netmask = 128 } - return bakSvc, nil + return ipvsSvc, nil } -// toBackendDestination converts an IPVS real server representation to the equivalent "backend" destination structure. -func toBackendDestination(rs *RealServer) (*ipvs.Destination, error) { +// toIPVSDestination converts a RealServer to the equivalent IPVS Destination structure. +func toIPVSDestination(rs *RealServer) (*libipvs.Destination, error) { if rs == nil { return nil, errors.New("real server should not be empty") } - return &ipvs.Destination{ + return &libipvs.Destination{ Address: rs.Address, Port: rs.Port, Weight: rs.Weight, }, nil } -// stringToProtocolNumber returns the protocol value for the given name -func stringToProtocolNumber(protocol string) uint16 { +// stringToProtocolType returns the protocol type for the given name +func stringToProtocol(protocol string) uint16 { switch strings.ToLower(protocol) { case "tcp": return uint16(syscall.IPPROTO_TCP) @@ -253,8 +256,8 @@ func stringToProtocolNumber(protocol string) uint16 { return uint16(0) } -// protocolNumbeToString returns the name for the given protocol value. -func protocolNumbeToString(proto ProtoType) string { +// protocolTypeToString returns the name for the given protocol. +func protocolToString(proto Protocol) string { switch proto { case syscall.IPPROTO_TCP: return "TCP" @@ -263,6 +266,3 @@ func protocolNumbeToString(proto ProtoType) string { } return "" } - -// ProtoType is IPVS service protocol type -type ProtoType uint16 diff --git a/pkg/util/ipvs/ipvs_linux_test.go b/pkg/util/ipvs/ipvs_linux_test.go index 9e6743b87f..11f7be67c6 100644 --- a/pkg/util/ipvs/ipvs_linux_test.go +++ b/pkg/util/ipvs/ipvs_linux_test.go @@ -25,18 +25,18 @@ import ( "syscall" "testing" - "github.com/docker/libnetwork/ipvs" + libipvs "github.com/docker/libnetwork/ipvs" ) func Test_toVirtualServer(t *testing.T) { Tests := []struct { - ipvsService ipvs.Service + ipvsService libipvs.Service virtualServer VirtualServer expectError bool reason string }{ { - ipvs.Service{ + libipvs.Service{ Flags: 0x0, }, VirtualServer{}, @@ -44,7 +44,7 @@ func Test_toVirtualServer(t *testing.T) { fmt.Sprintf("IPVS Service Flags should be >= %d, got 0x0", FlagHashed), }, { - ipvs.Service{ + libipvs.Service{ Flags: 0x1, }, VirtualServer{}, @@ -52,7 +52,7 @@ func Test_toVirtualServer(t *testing.T) { fmt.Sprintf("IPVS Service Flags should be >= %d, got 0x1", FlagHashed), }, { - ipvs.Service{ + libipvs.Service{ Protocol: syscall.IPPROTO_TCP, Port: 80, FWMark: 0, @@ -76,7 +76,7 @@ func Test_toVirtualServer(t *testing.T) { "", }, { - ipvs.Service{ + libipvs.Service{ Protocol: syscall.IPPROTO_UDP, Port: 33434, FWMark: 0, @@ -100,7 +100,7 @@ func Test_toVirtualServer(t *testing.T) { "", }, { - ipvs.Service{ + libipvs.Service{ Protocol: 0, Port: 0, FWMark: 0, @@ -124,7 +124,7 @@ func Test_toVirtualServer(t *testing.T) { "", }, { - ipvs.Service{ + libipvs.Service{ Protocol: 0, Port: 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 { - ipvsService ipvs.Service + ipvsService libipvs.Service virtualServer VirtualServer }{ { - ipvs.Service{ + libipvs.Service{ Protocol: syscall.IPPROTO_TCP, Port: 80, FWMark: 0, @@ -193,7 +193,7 @@ func Test_toBackendService(t *testing.T) { }, }, { - ipvs.Service{ + libipvs.Service{ Protocol: syscall.IPPROTO_UDP, Port: 33434, FWMark: 0, @@ -215,7 +215,7 @@ func Test_toBackendService(t *testing.T) { }, }, { - ipvs.Service{ + libipvs.Service{ Protocol: 0, Port: 0, FWMark: 0, @@ -237,7 +237,7 @@ func Test_toBackendService(t *testing.T) { }, }, { - ipvs.Service{ + libipvs.Service{ Protocol: 0, Port: 0, FWMark: 0, @@ -261,7 +261,7 @@ func Test_toBackendService(t *testing.T) { } for i := range Tests { - got, err := toBackendService(&Tests[i].virtualServer) + got, err := toIPVSService(&Tests[i].virtualServer) if err != nil { 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 { - ipvsDestination ipvs.Destination + ipvsDestination libipvs.Destination realServer RealServer }{ { - ipvs.Destination{ + libipvs.Destination{ Port: 54321, ConnectionFlags: 0, Weight: 1, @@ -290,7 +290,7 @@ func Test_toFrontendDestination(t *testing.T) { }, }, { - ipvs.Destination{ + libipvs.Destination{ Port: 53, ConnectionFlags: 0, 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 { realServer RealServer - ipvsDestination ipvs.Destination + ipvsDestination libipvs.Destination }{ { RealServer{ @@ -325,7 +325,7 @@ func Test_toBackendDestination(t *testing.T) { Port: 54321, Weight: 1, }, - ipvs.Destination{ + libipvs.Destination{ Port: 54321, ConnectionFlags: 0, Weight: 1, @@ -338,7 +338,7 @@ func Test_toBackendDestination(t *testing.T) { Port: 53, Weight: 1, }, - ipvs.Destination{ + libipvs.Destination{ Port: 53, ConnectionFlags: 0, Weight: 1, @@ -347,44 +347,44 @@ func Test_toBackendDestination(t *testing.T) { }, } for i := range Tests { - got, err := toBackendDestination(&Tests[i].realServer) + got, err := toIPVSDestination(&Tests[i].realServer) if err != nil { t.Errorf("case %d unexpected error: %d", i, err) } 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{ "TCP", "UDP", "ICMP", } - expecteds := []uint16{ + expected := []uint16{ uint16(syscall.IPPROTO_TCP), uint16(syscall.IPPROTO_UDP), uint16(0), } for i := range tests { - got := stringToProtocolNumber(tests[i]) - if got != expecteds[i] { - t.Errorf("stringToProtocolNumber() failed - got %#v, want %#v", - got, expecteds[i]) + got := stringToProtocol(tests[i]) + if got != expected[i] { + t.Errorf("stringToProtocol() failed - got %#v, want %#v", + got, expected[i]) } } } -func Test_protocolNumberToString(t *testing.T) { - tests := []ProtoType{ - syscall.IPPROTO_TCP, syscall.IPPROTO_UDP, ProtoType(0), +func Test_protocolToString(t *testing.T) { + tests := []Protocol{ + syscall.IPPROTO_TCP, syscall.IPPROTO_UDP, Protocol(0), } - expecteds := []string{ + expected := []string{ "TCP", "UDP", "", } for i := range tests { - got := protocolNumbeToString(tests[i]) - if got != expecteds[i] { - t.Errorf("protocolNumbeToString() failed - got %#v, want %#v", - got, expecteds[i]) + got := protocolToString(tests[i]) + if got != expected[i] { + t.Errorf("protocolToString() failed - got %#v, want %#v", + got, expected[i]) } } }