func main() { flag.Parse() if *cpuprofile != "" { f, err := os.Create(*cpuprofile) if err != nil { log.Fatal(err) } pprof.StartCPUProfile(f) defer pprof.StopCPUProfile() } h := bh.NewHive() openflow.StartOpenFlow(h) controller.RegisterNOMController(h) discovery.RegisterDiscovery(h) // Register a switch: // switching.RegisterSwitch(h, bh.Persistent(1)) // or a hub: // switching.RegisterHub(h, bh.NonTransactional()) if *controllertype == "master" { routing.InstallMasterC(h, bh.Persistent(1)) } else if *controllertype == "area1" { routing.InstallR1(h, bh.Persistent(1)) } else { routing.InstallR2(h, bh.Persistent(1)) } // routing.InstallLoadBalancer(h, bh.Persistent(1)) // routing.InstallRouterIP(h, bh.Persistent(1)) h.Start() }
func main() { flag.Parse() rand.Seed(time.Now().UnixNano()) if *quiet { log.SetOutput(ioutil.Discard) } if *cpuprofile != "" { f, err := os.Create(*cpuprofile) if err != nil { glog.Fatal(err) } pprof.StartCPUProfile(f) defer pprof.StopCPUProfile() } opts := []bh.AppOption{bh.Persistent(*replFactor)} if *random { rp := bh.RandomPlacement{ Rand: rand.New(rand.NewSource(time.Now().UnixNano())), } opts = append(opts, bh.Placement(rp)) } a := bh.NewApp("kvstore", opts...) kv := &store.KVStore{ Hive: bh.DefaultHive, Buckets: uint64(*buckets), } a.Handle(store.Put{}, kv) a.Handle(store.Get(""), kv) a.Handle(store.Del(""), kv) a.HandleHTTP("/{key}", kv) bh.Start() }
// RegisterTaskQ registers the TaskQ application and all its handler in the // hive. func RegisterTaskQ(h beehive.Hive, opts ...Option) error { if !flag.Parsed() { flag.Parse() } proto, err := NewProtoHandler(addr.Get(opts)) if err != nil { return err } r := rate.Get(opts) taskq := h.NewApp("taskq", beehive.Persistent(repl.Get(opts)), beehive.OutRate(bucket.Rate(r), 2*r)) taskq.Handle(Enque{}, EnQHandler{}) taskq.Handle(Deque{}, DeQHandler{}) taskq.Handle(Ack{}, AckHandler{}) taskq.Handle(Timeout{}, TimeoutHandler{ ExpDur: 60 * time.Second, }) ah := &AckHTTPHandler{Hive: h} taskq.HandleHTTP("/{queue}/tasks/{id:[0-9]+}", ah).Methods("DELETE") dh := &DeQHTTPHandler{Hive: h} taskq.HandleHTTP("/{queue}/tasks/deque", dh).Methods("POST") eh := &EnQHTTPHandler{Hive: h} taskq.HandleHTTP("/{queue}/tasks", eh).Methods("POST") taskq.Detached(beehive.NewTimer(30*time.Second, func() { h.Emit(Timeout(time.Now())) })) taskq.Detached(proto) return nil }
func Example_hTTP() { // Create the hello world application and make sure . app := beehive.NewApp("hello-world", beehive.Persistent(1)) // Register the handler for Hello messages. app.HandleFunc(HelloHTTP{}, beehive.RuntimeMap(RcvfHTTP), RcvfHTTP) // Register the HTTP handler for the hello world application. app.HandleHTTP("/{name}", &HelloHTTPHandler{}).Methods("POST") // Start the DefaultHive. beehive.Start() }
func Example_detached() { // Create the hello world application and make sure . app := beehive.NewApp("hello-world", beehive.Persistent(1)) // Register the handler for Hello messages. app.HandleFunc(HelloDetached{}, beehive.RuntimeMap(RcvfDetached), RcvfDetached) // Register the detached handler for the hello world listener. app.Detached(NewHelloListener()) // Start the DefaultHive. beehive.Start() }
func main() { shouldPing := flag.Bool("ping", false, "Whether to ping.") shouldPong := flag.Bool("pong", false, "Whether to pong.") pingApp := bh.NewApp("Ping", bh.Persistent(2)) pingApp.Handle(pong{}, &pinger{}) pongApp := bh.NewApp("Pong", bh.Persistent(2)) pongApp.Handle(ping{}, &ponger{}) if *shouldPing { bh.Emit(ping{}) } if *shouldPong { bh.Emit(pong{}) } bh.Start() }
func main() { app := bh.NewApp("HelloWorld", bh.Persistent(1)) app.HandleFunc(string(""), mapf, rcvf) name1 := "1st name" name2 := "2nd name" for i := 0; i < 3; i++ { go bh.Emit(name1) go bh.Emit(name2) } bh.Start() }
func Example() { // Create the hello world application and make sure . app := beehive.NewApp("hello-world", beehive.Persistent(1)) // Register the handler for Hello messages. app.HandleFunc(Hello{}, beehive.RuntimeMap(Rcvf), Rcvf) // Emit simply emits a message, here a // string of your name. go beehive.Emit(Hello{Name: "your name"}) // Emit another message with the same name // to test the counting feature. go beehive.Emit(Hello{Name: "your name"}) // Start the DefualtHive. beehive.Start() }
func main() { logger.InitDefault() logger.Trace.Println("[main] Init beehive app") // Create the application and beehiveApp := beehive.NewApp("beehive-app", beehive.Persistent(0)) // Register the handler for MessageToBee messages. beehiveApp.HandleFunc( MessageToBee{}, beehive.RuntimeMap(BeeHandler), BeeHandler) initHTTPHandler(beehiveApp) logger.Trace.Println("[main] Start beehive") beehive.Start() }
func BenchmarkThroughput(b *testing.B) { hive := bh.NewHive() defer os.RemoveAll(hive.Config().StatePath) if b.N < 1024 { return } b.StopTimer() app := hive.NewApp("kvstore", bh.Persistent(1)) store := &KVStore{ Hive: hive, Buckets: bees, } app.Handle(Put{}, store) app.Handle(Get(""), store) go hive.Start() keys := make([]string, 64) for i, _ := range keys { keys[i] = fmt.Sprintf("%dkeys%d", i, i) } val := "val" for _, k := range keys { hive.Emit(Put{Key: k, Val: val}) hive.Sync(context.Background(), Get(k)) } b.StartTimer() for i := 0; i < b.N; i++ { for _, k := range keys { hive.Emit(Put{Key: k, Val: val}) i++ } } for _, k := range keys { hive.Sync(context.Background(), Get(k)) } b.StopTimer() hive.Stop() }
func Example_reply() { // Create the hello world application and make sure . app := beehive.NewApp("hello-world", beehive.Persistent(1)) // Register the handler for Hello messages. app.HandleFunc(HelloReply{}, beehive.RuntimeMap(RcvfReply), RcvfReply) // Start the default hive. go beehive.Start() defer beehive.Stop() name := "your name" for i := 0; i < 2; i++ { // Sync sends the Hello message and waits until it receives the reply. res, err := beehive.Sync(context.TODO(), HelloReply{Name: name}) if err != nil { glog.Fatalf("error in sending Hello: %v", err) } cnt := res.(int) fmt.Printf("hello %s (%d)!\n", name, cnt) } }
func RegisterNOMController(h bh.Hive) { app := h.NewApp("NOMController", bh.Persistent(3)) app.Handle(nom.NodeConnected{}, nodeConnectedHandler{}) app.Handle(nom.NodeDisconnected{}, nodeDisconnectedHandler{}) app.Handle(nom.PortStatusChanged{}, portStatusHandler{}) app.Handle(nom.AddFlowEntry{}, addFlowHandler{}) app.Handle(nom.DelFlowEntry{}, delFlowHandler{}) app.Handle(nom.FlowStatsQuery{}, queryHandler{}) app.Handle(nom.PacketOut{}, pktOutHandler{}) app.Handle(nom.AddTrigger{}, addTriggerHandler{}) app.Handle(nom.FlowStatsQueryResult{}, Consolidator{}) app.Handle(nom.Pong{}, HealthChecker{}) app.Handle(poll{}, Poller{}) app.Detached(bh.NewTimer(1*time.Second, func() { h.Emit(poll{}) })) }
func main() { flag.Parse() rand.Seed(time.Now().UnixNano()) if *quiet { log.SetOutput(ioutil.Discard) } if *cpuprofile != "" { f, err := os.Create(*cpuprofile) if err != nil { panic(err) } pprof.StartCPUProfile(f) defer pprof.StopCPUProfile() } hive := bh.NewHive() os.RemoveAll(hive.Config().StatePath) app := hive.NewApp("kvstore", bh.Persistent(*replFactor)) kvs := &store.KVStore{ Hive: hive, Buckets: uint64(*buckets), } app.Handle(store.Put{}, kvs) app.Handle(store.Get(""), kvs) go hive.Start() time.Sleep(4 * time.Minute) keys := make([]string, *numkeys) reqs := make([]interface{}, *numkeys) val := "val" for i, _ := range keys { keys[i] = fmt.Sprintf("%dkeys%d", i, i) if *get { reqs[i] = store.Get(keys[i]) } else { reqs[i] = store.Put{Key: keys[i], Val: val} } } for _, k := range keys { hive.Emit(store.Put{Key: k, Val: val}) hive.Sync(context.Background(), store.Get(k)) } ts := make([]time.Duration, *rounds) for i := 0; i < *rounds; i++ { start := time.Now() for j := 0; j < *tries; j++ { for _, r := range reqs { hive.Emit(r) } } for _, k := range keys { hive.Sync(context.Background(), store.Get(k)) } ts[i] = time.Since(start) } hive.Stop() f, err := os.Create(*output) if err != nil { panic(err) } defer f.Close() w := bufio.NewWriter(f) for _, t := range ts { fmt.Fprintf(w, "%v\n", uint64(t)) } w.Flush() }