// IPVSGetServices gets the currently configured services from the IPVS table.
func (ncc *SeesawNCC) IPVSGetServices(in int, s *ncctypes.IPVSServices) error {
ipvsMutex.Lock()
defer ipvsMutex.Unlock()
svcs, err := ipvs.GetServices()
if err != nil {
return err
}
s.Services = nil
for _, svc := range svcs {
s.Services = append(s.Services, svc)
}
return nil
}
func (ipvs *Ipvs) getCurrentServicesSet() (mapset.Set, error) {
svcs, err := gipvs.GetServices()
if err != nil {
return nil, err
}
currentSet := mapset.NewSet()
for _, s := range svcs {
currentSet.Add(FromService(s))
}
return currentSet, nil
}
// testIPVS adds all of the services and destinations provided via the testing
// table, then gets all of the services and destinations from IPVS before
// comparing and reporting on the result. If everything worked correctly we
// should end up with an exact match between what we added and what we got back
// from IPVS.
func testIPVS() {
log.Println("Testing IPVS...")
// Make sure we have a clean slate.
if err := ipvs.Flush(); err != nil {
log.Fatalf("Failed to flush IPVS table: %v\n", err)
}
// Add the test services and destinations to IPVS.
log.Println("Adding services and destinations...")
for _, test := range ipvsTests {
svc := test.service
log.Println(test.desc)
log.Printf("=> Adding service %s\n", svc)
svc.Destinations = nil
for i := range test.destinations {
dst := &test.destinations[i]
log.Printf("--> Destination %s\n", dst)
svc.Destinations = append(svc.Destinations, dst)
}
if err := ipvs.AddService(svc); err != nil {
log.Fatalf("ipvs.AddService() failed: %v\n", err)
}
}
// Get the services from IPVS and compare to what we added. Note that
// the order of the returned services and destinations are not
// guaranteed to match the order in which they were added.
log.Println("Getting services from IPVS...")
svcs, err := ipvs.GetServices()
if err != nil {
log.Fatalf("ipvs.GetServices() failed: %v\n", err)
}
if len(ipvsTests) != len(svcs) {
log.Printf("ERROR: Added %d services but got %d!\n",
len(ipvsTests), len(svcs))
}
for _, test := range ipvsTests {
svc := compareSvc(&test.service, svcs)
if svc == nil {
continue
}
if len(test.destinations) != len(svc.Destinations) {
log.Printf("ERROR: Added %d destinations by got %d!\n",
len(test.destinations), len(svc.Destinations))
}
for _, testDst := range test.destinations {
compareDst(&testDst, svc.Destinations)
}
}
}
func (m Metrics) collect() error {
services, err := ipvs.GetServices()
if err != nil {
return errors.Wrap(err, "ipvs.GetServices() failed when collecting metrics")
}
for _, s := range services {
if err := m.publisher.PublishServiceStats(s); err != nil {
return err
}
}
return nil
}
func GetIPVSStats() (vips []*VirtualIPPoint, err error) {
svcs, err := ipvs.GetServices()
if err != nil {
return nil, err
}
var vip *VirtualIPPoint
var ActiveConns uint32
var InactiveConns uint32
var RsNum int
//var PersistConns uint32
for _, svc := range svcs {
ActiveConns = 0
InactiveConns = 0
RsNum = len(svc.Destinations)
for _, dest := range svc.Destinations {
ActiveConns += dest.Statistics.ActiveConns
InactiveConns += dest.Statistics.InactiveConns
//PersistConns += dest.Statistics.PersistConns
}
ipstr := fmt.Sprintf("%v", svc.Address)
vip = &VirtualIPPoint{
IP: ipstr,
Port: int(svc.Port),
ActiveConns: ActiveConns,
InactiveConns: InactiveConns,
RealServerNum: RsNum,
Connections: svc.Statistics.Connections,
PacketsIn: svc.Statistics.PacketsIn,
PacketsOut: svc.Statistics.PacketsOut,
BytesIn: svc.Statistics.BytesIn,
BytesOut: svc.Statistics.BytesOut,
}
vips = append(vips, vip)
}
return vips, nil
}
func TestIpvsSync(t *testing.T) {
svc := types.Service{
Name: "",
Address: "10.0.1.1",
Port: 80,
Scheduler: "lc",
Protocol: "tcp",
}
dst := types.Destination{
Name: "host1",
Address: "192.168.1.1",
Port: 80,
Mode: "nat",
Weight: 1,
ServiceId: "service1",
}
dst2 := types.Destination{
Name: "host2",
Address: "192.168.1.2",
Port: 80,
Mode: "nat",
Weight: 1,
ServiceId: "service1",
}
state := &mocks.State{}
state.On("GetServices").Return([]types.Service{svc})
state.On("GetDestinations", &svc).Return([]types.Destination{dst})
ipvsMngr, err := ipvs.New()
assert.Nil(t, err)
// Testing Services and destinations addition
ipvsMngr.Sync(state)
svcs, err := gipvs.GetServices()
assert.Nil(t, err)
// Asserting Services
assert.Equal(t, svc.Address, svcs[0].Address.String())
assert.Equal(t, svc.Port, svcs[0].Port)
// Asserting Destinations
assert.Equal(t, dst.Address, svcs[0].Destinations[0].Address.String())
assert.Equal(t, dst.Port, svcs[0].Destinations[0].Port)
// Updating destinations
state = &mocks.State{}
state.On("GetServices").Return([]types.Service{svc})
state.On("GetDestinations", &svc).Return([]types.Destination{dst2})
ipvsMngr.Sync(state)
svcs, err = gipvs.GetServices()
assert.Nil(t, err)
assert.Equal(t, dst2.Address, svcs[0].Destinations[0].Address.String())
assert.Equal(t, dst2.Port, svcs[0].Destinations[0].Port)
// Testing Services and Destinations deletion
state = &mocks.State{}
state.On("GetServices").Return([]types.Service{})
ipvsMngr.Sync(state)
svcs, err = gipvs.GetServices()
assert.Nil(t, err)
assert.Len(t, svcs, 0)
ipvsMngr.Flush()
}
// testIPVSModification adds, updates and deletes services and destinations
// from the test configurations. At each step the service or destination is
// retrieved from IPVS and compared against what should be configured.
func testIPVSModification() {
log.Println("Testing IPVS modifications...")
// Make sure we have a clean slate.
if err := ipvs.Flush(); err != nil {
log.Fatalf("Failed to flush IPVS table: %v\n", err)
}
for _, test := range ipvsTests {
var svc *ipvs.Service
var err error
testSvc := test.service
testDst := test.destinations[0]
// Add service.
log.Printf("=> Adding service %s\n", testSvc)
if err = ipvs.AddService(testSvc); err != nil {
log.Fatalf("ipvs.AddService() failed: %v\n", err)
}
if svc, err = ipvs.GetService(&testSvc); err != nil {
log.Fatalf("ipvs.GetService() failed: %v\n", err)
}
compareSvc(&testSvc, []*ipvs.Service{svc})
// Add destination.
log.Printf("--> Adding destination %s\n", testDst)
if err = ipvs.AddDestination(testSvc, testDst); err != nil {
log.Fatalf("ipvs.AddDestination() failed: %v\n", err)
}
if svc, err = ipvs.GetService(&testSvc); err != nil {
log.Fatalf("ipvs.GetService() failed: %v\n", err)
}
compareSvc(&testSvc, []*ipvs.Service{svc})
compareDst(&testDst, svc.Destinations)
// Update service.
testSvc.Scheduler = "lc"
if err = ipvs.UpdateService(testSvc); err != nil {
log.Fatalf("ipvs.UpdateService() failed: %v\n", err)
}
if svc, err = ipvs.GetService(&testSvc); err != nil {
log.Fatalf("ipvs.GetService() failed: %v\n", err)
}
compareSvc(&testSvc, []*ipvs.Service{svc})
compareDst(&testDst, svc.Destinations)
// Update destination.
testDst.Weight = 1000
if err = ipvs.UpdateDestination(testSvc, testDst); err != nil {
log.Fatalf("ipvs.UpdateDestination() failed: %v\n", err)
}
if svc, err = ipvs.GetService(&testSvc); err != nil {
log.Fatalf("ipvs.GetService() failed: %v\n", err)
}
compareSvc(&testSvc, []*ipvs.Service{svc})
compareDst(&testDst, svc.Destinations)
// Delete destination.
if err = ipvs.DeleteDestination(testSvc, testDst); err != nil {
log.Fatalf("ipvs.DeleteDestination() failed: %v\n", err)
}
if svc, err = ipvs.GetService(&testSvc); err != nil {
log.Fatalf("ipvs.GetService() failed: %v\n", err)
}
if len(svc.Destinations) != 0 {
log.Printf("ERROR: Service still has destinations\n")
}
// Delete service.
if err = ipvs.DeleteService(testSvc); err != nil {
log.Fatalf("ipvs.DeleteService() failed: %v\n", err)
}
// Make sure there is nothing left behind.
svcs, err := ipvs.GetServices()
if err != nil {
log.Fatalf("ipvs.GetServices() failed: %v\n", err)
}
if len(svcs) != 0 {
log.Printf("ERROR: IPVS services still exist!\n")
for _, svc = range svcs {
log.Printf("=> Got service %s\n", svc)
}
}
}
}