func main() { flag.Parse() // Connect to the NCC component. ncc := client.NewNCC(*nccSocket) if err := ncc.Dial(); err != nil { log.Fatalf("Failed to connect to NCC: %v", err) } switch strings.ToLower(*testClass) { case "arp": log.Print("Starting ARP tests...") arpTests(ncc) case "bgp": log.Print("Starting BGP tests...") bgpTests(ncc) case "interface": log.Print("Starting interface tests...") interfaceTests(ncc) case "ipvs": log.Print("Starting IPVS tests...") ipvsTests(ncc) case "route": log.Print("Starting route tests...") routeTests(ncc) case "vserver": log.Print("Starting vserver tests...") vserverTests(ncc) default: log.Fatal("Test class must be one of arp, bgp, interface, ipvs, route or vserver") } ncc.Close() log.Print("Done!") }
func ipvsAddService(done chan bool, service, dests int) { ncc := client.NewNCC(*nccSocket) if err := ncc.Dial(); err != nil { log.Fatalf("Failed to connect to NCC: %v", err) } defer ncc.Close() svc := &ipvs.Service{ Address: net.IPv4(1, 1, 1, 1), Protocol: syscall.IPPROTO_TCP, Port: uint16(10000 + service), Scheduler: "wlc", } if err := ncc.IPVSAddService(svc); err != nil { log.Fatalf("Failed to add IPVS service: %v", err) } for i := 0; i < dests; i++ { dst := &ipvs.Destination{ Address: net.IPv4(1, 1, 1, byte(i+2)), Port: uint16(10000 + service), Flags: ipvs.DFForwardRoute, Weight: 1, } if err := ncc.IPVSAddDestination(svc, dst); err != nil { log.Fatalf("Failed to add IPVS destination: %v", err) } } done <- true }
// NewEngine returns an initialised Engine struct. func NewEngine(cfg *config.EngineConfig) *Engine { if cfg == nil { defaultCfg := config.DefaultEngineConfig() cfg = &defaultCfg } // TODO(jsing): Validate node, peer and cluster IP configuration. engine := &Engine{ config: cfg, fwmAlloc: newMarkAllocator(fwmAllocBase, fwmAllocSize), ncc: ncclient.NewNCC(cfg.NCCSocket), overrides: make(map[string]seesaw.Override), overrideChan: make(chan seesaw.Override), vlans: make(map[uint16]*seesaw.VLAN), vservers: make(map[string]*vserver), shutdown: make(chan bool), shutdownARP: make(chan bool), shutdownIPC: make(chan bool), shutdownRPC: make(chan bool), vserverSnapshots: make(map[string]*seesaw.Vserver), vserverChan: make(chan *seesaw.Vserver, 1000), } engine.bgpManager = newBGPManager(engine, cfg.BGPUpdateInterval) engine.haManager = newHAManager(engine, cfg.HAStateTimeout) engine.hcManager = newHealthcheckManager(engine) engine.syncClient = newSyncClient(engine) engine.syncServer = newSyncServer(engine) return engine }
// newHealthcheckManager creates a new healthcheckManager. func newHealthcheckManager(e *Engine) *healthcheckManager { return &healthcheckManager{ engine: e, marks: make(map[seesaw.IP]uint32), markAlloc: newMarkAllocator(dsrMarkBase, dsrMarkSize), ncc: ncclient.NewNCC(e.config.NCCSocket), next: healthcheck.Id((uint64(os.Getpid()) & 0xFFFF) << 48), vserverChecks: make(map[string]map[checkKey]*check), quit: make(chan bool), stopped: make(chan bool), vcc: make(chan vserverChecks, 100), } }
// newVserver returns an initialised vserver struct. func newVserver(e *Engine) *vserver { return &vserver{ engine: e, ncc: ncclient.NewNCC(e.config.NCCSocket), fwm: make(map[seesaw.AF]uint32), active: make(map[seesaw.IP]bool), lbVservers: make(map[seesaw.IP]*seesaw.Vserver), vips: make(map[seesaw.VIP]bool), overrideChan: make(chan seesaw.Override, 5), notify: make(chan *checkNotification, 20), update: make(chan *config.Vserver, 1), quit: make(chan bool, 1), stopped: make(chan bool, 1), } }
func ipvsGetServices(quit chan bool, count chan int) { ncc := client.NewNCC(*nccSocket) if err := ncc.Dial(); err != nil { log.Fatalf("Failed to connect to NCC: %v", err) } defer ncc.Close() i := 0 for { select { case <-quit: count <- i return default: } if _, err := ncc.IPVSGetServices(); err != nil { log.Fatalf("Failed to get IPVS services: %v", err) } i++ } }