func main() { lbbroker := &lbbroker_t{} lbbroker.frontend, _ = zmq.NewSocket(zmq.ROUTER) lbbroker.backend, _ = zmq.NewSocket(zmq.ROUTER) defer lbbroker.frontend.Close() defer lbbroker.backend.Close() lbbroker.frontend.Bind("ipc://frontend.ipc") lbbroker.backend.Bind("ipc://backend.ipc") for client_nbr := 0; client_nbr < NBR_CLIENTS; client_nbr++ { go client_task() } for worker_nbr := 0; worker_nbr < NBR_WORKERS; worker_nbr++ { go worker_task() } // Queue of available workers lbbroker.workers = make([]string, 0, 10) // Prepare reactor and fire it up lbbroker.reactor = zmq.NewReactor() lbbroker.reactor.AddSocket(lbbroker.backend, zmq.POLLIN, func(e zmq.State) error { return handle_backend(lbbroker) }) lbbroker.reactor.Run(-1) }
func main() { // Connect to task ventilator receiver, _ := zmq.NewSocket(zmq.PULL) defer receiver.Close() receiver.Connect("tcp://localhost:5557") // Connect to weather server subscriber, _ := zmq.NewSocket(zmq.SUB) defer subscriber.Close() subscriber.Connect("tcp://localhost:5556") subscriber.SetSubscribe("10001 ") // Initialize poll set poller := zmq.NewPoller() poller.Add(receiver, zmq.POLLIN) poller.Add(subscriber, zmq.POLLIN) // Process messages from both sockets for { sockets, _ := poller.Poll(-1) for _, socket := range sockets { switch s := socket.Socket; s { case receiver: task, _ := s.Recv(0) // Process task fmt.Println("Got task:", task) case subscriber: update, _ := s.Recv(0) // Process weather update fmt.Println("Got weather update:", update) } } } }
func main() { // Socket to receive messages on receiver, _ := zmq.NewSocket(zmq.PULL) defer receiver.Close() receiver.Connect("tcp://localhost:5557") // Socket to send messages to sender, _ := zmq.NewSocket(zmq.PUSH) defer sender.Close() sender.Connect("tcp://localhost:5558") // Process tasks forever for { s, _ := receiver.Recv(0) // Simple progress indicator for the viewer fmt.Print(s + ".") // Do the work msec, _ := strconv.Atoi(s) time.Sleep(time.Duration(msec) * time.Millisecond) // Send results to sink sender.Send("", 0) } }
func main() { // Prepare our context and sockets publisher, _ := zmq.NewSocket(zmq.PUB) publisher.Bind("tcp://*:5557") sequence := int64(0) rand.Seed(time.Now().UnixNano()) // Start state manager and wait for synchronization signal updates, _ := zmq.NewSocket(zmq.PAIR) updates.Bind("inproc://pipe") go state_manager() updates.RecvMessage(0) // "READY" for { // Distribute as key-value message sequence++ kvmsg := kvsimple.NewKvmsg(sequence) kvmsg.SetKey(fmt.Sprint(rand.Intn(10000))) kvmsg.SetBody(fmt.Sprint(rand.Intn(1000000))) if kvmsg.Send(publisher) != nil { break } if kvmsg.Send(updates) != nil { break } } fmt.Printf("Interrupted\n%d messages out\n", sequence) }
func main() { // Start authentication engine zmq.AuthSetVerbose(true) zmq.AuthStart() zmq.AuthAllow("domain1", "127.0.0.1") // Tell the authenticator how to handle PLAIN requests zmq.AuthPlainAdd("domain1", "admin", "secret") // Create and bind server socket server, _ := zmq.NewSocket(zmq.PUSH) server.ServerAuthPlain("domain1") server.Bind("tcp://*:9000") // Create and connect client socket client, _ := zmq.NewSocket(zmq.PULL) client.SetPlainUsername("admin") client.SetPlainPassword("secret") client.Connect("tcp://127.0.0.1:9000") // Send a single message from server to client _, err := server.Send("Hello", 0) checkErr(err) message, err := client.Recv(0) checkErr(err) if message != "Hello" { log.Fatalln(message, "!= Hello") } zmq.AuthStop() fmt.Println("Woodhouse test OK") }
func main() { // Socket to receive messages on receiver, _ := zmq.NewSocket(zmq.PULL) defer receiver.Close() receiver.Bind("tcp://*:5558") // Socket for worker control controller, _ := zmq.NewSocket(zmq.PUB) defer controller.Close() controller.Bind("tcp://*:5559") // Wait for start of batch receiver.Recv(0) // Start our clock now start_time := time.Now() // Process 100 confirmations for task_nbr := 0; task_nbr < 100; task_nbr++ { receiver.Recv(0) if task_nbr%10 == 0 { fmt.Print(":") } else { fmt.Print(".") } } fmt.Println("\nTotal elapsed time:", time.Since(start_time)) // Send kill signal to workers controller.Send("KILL", 0) // Finished time.Sleep(time.Second) // Give 0MQ time to deliver }
func New(primary bool, local, remote string) (bstar *Bstar, err error) { bstar = &Bstar{} // Initialize the Binary Star bstar.Reactor = zmq.NewReactor() if primary { bstar.state = state_PRIMARY } else { bstar.state = state_BACKUP } // Create publisher for state going to peer bstar.statepub, err = zmq.NewSocket(zmq.PUB) bstar.statepub.Bind(local) // Create subscriber for state coming from peer bstar.statesub, err = zmq.NewSocket(zmq.SUB) bstar.statesub.SetSubscribe("") bstar.statesub.Connect(remote) // Set-up basic reactor events bstar.Reactor.AddChannelTime(time.Tick(bstar_HEARTBEAT), 1, func(i interface{}) error { return bstar.send_state() }) bstar.Reactor.AddSocket(bstar.statesub, zmq.POLLIN, func(e zmq.State) error { return bstar.recv_state() }) return }
func main() { srv := &clonesrv_t{ port: 5556, kvmap: make(map[string]*kvmsg.Kvmsg), } // Set up our clone server sockets srv.snapshot, _ = zmq.NewSocket(zmq.ROUTER) srv.snapshot.Bind(fmt.Sprint("tcp://*:", srv.port)) srv.publisher, _ = zmq.NewSocket(zmq.PUB) srv.publisher.Bind(fmt.Sprint("tcp://*:", srv.port+1)) srv.collector, _ = zmq.NewSocket(zmq.PULL) srv.collector.Bind(fmt.Sprint("tcp://*:", srv.port+2)) // Register our handlers with reactor reactor := zmq.NewReactor() reactor.AddSocket(srv.snapshot, zmq.POLLIN, func(e zmq.State) error { return snapshots(srv) }) reactor.AddSocket(srv.collector, zmq.POLLIN, func(e zmq.State) error { return collector(srv) }) reactor.AddChannelTime(time.Tick(1000*time.Millisecond), 1, func(v interface{}) error { return flush_ttl(srv) }) log.Println(reactor.Run(100 * time.Millisecond)) // precision: .1 seconds }
func main() { // Socket to send messages on sender, _ := zmq.NewSocket(zmq.PUSH) defer sender.Close() sender.Bind("tcp://*:5557") // Socket to send start of batch message on sink, _ := zmq.NewSocket(zmq.PUSH) defer sink.Close() sink.Connect("tcp://localhost:5558") fmt.Print("Press Enter when the workers are ready: ") var line string fmt.Scanln(&line) fmt.Println("Sending tasks to workers...") // The first message is "0" and signals start of batch sink.Send("0", 0) // Initialize random number generator rand.Seed(time.Now().UnixNano()) // Send 100 tasks total_msec := 0 for task_nbr := 0; task_nbr < 100; task_nbr++ { // Random workload from 1 to 100msecs workload := rand.Intn(100) + 1 total_msec += workload s := fmt.Sprintf("%d", workload) sender.Send(s, 0) } fmt.Println("Total expected cost:", time.Duration(total_msec)*time.Millisecond) time.Sleep(time.Second) // Give 0MQ time to deliver }
func BrokerTask() { // Prepare our sockets frontend, _ := zmq.NewSocket(zmq.DEALER) frontend.Bind("tcp://*:5555") backend, _ := zmq.NewSocket(zmq.DEALER) backend.Bind("tcp://*:5556") zmq.Proxy(frontend, backend, nil) }
func main() { frontend, _ := zmq.NewSocket(zmq.SUB) frontend.Bind("tcp://*:5557") backend, _ := zmq.NewSocket(zmq.XPUB) backend.Bind("tcp://*:5558") // Subscribe to every single topic from publisher frontend.SetSubscribe("") // Store last instance of each topic in a cache cache := make(map[string]string) // We route topic updates from frontend to backend, and // we handle subscriptions by sending whatever we cached, // if anything: poller := zmq.NewPoller() poller.Add(frontend, zmq.POLLIN) poller.Add(backend, zmq.POLLIN) LOOP: for { polled, err := poller.Poll(1000 * time.Millisecond) if err != nil { break // Interrupted } for _, item := range polled { switch socket := item.Socket; socket { case frontend: // Any new topic data we cache and then forward msg, err := frontend.RecvMessage(0) if err != nil { break LOOP } cache[msg[0]] = msg[1] backend.SendMessage(msg) case backend: // When we get a new subscription we pull data from the cache: msg, err := backend.RecvMessage(0) if err != nil { break LOOP } frame := msg[0] // Event is one byte 0=unsub or 1=sub, followed by topic if frame[0] == 1 { topic := frame[1:] fmt.Println("Sending cached topic", topic) previous, ok := cache[topic] if ok { backend.SendMessage(topic, previous) } } } } } }
func TestKvmsg(t *testing.T) { // Prepare our context and sockets output, err := zmq.NewSocket(zmq.DEALER) if err != nil { t.Error(err) } err = output.Bind("ipc://kvmsg_selftest.ipc") if err != nil { t.Error(err) } input, err := zmq.NewSocket(zmq.DEALER) if err != nil { t.Error(err) } err = input.Connect("ipc://kvmsg_selftest.ipc") if err != nil { t.Error(err) } kvmap := make(map[string]*Kvmsg) // Test send and receive of simple message kvmsg := NewKvmsg(1) kvmsg.SetKey("key") kvmsg.SetBody("body") kvmsg.Dump() err = kvmsg.Send(output) kvmsg.Store(kvmap) if err != nil { t.Error(err) } kvmsg, err = RecvKvmsg(input) if err != nil { t.Error(err) } kvmsg.Dump() key, err := kvmsg.GetKey() if err != nil { t.Error(err) } if key != "key" { t.Error("Expected \"key\", got \"" + key + "\"") } kvmsg.Store(kvmap) input.Close() output.Close() os.Remove("kvmsg_selftest.ipc") }
func Example_test_abstract_ipc() { addr := "ipc://@/tmp/tester" // This is Linux only if runtime.GOOS != "linux" { fmt.Printf("%q\n", addr) fmt.Println("Done") return } sb, err := zmq.NewSocket(zmq.PAIR) if checkErr(err) { return } err = sb.Bind(addr) if checkErr(err) { return } endpoint, err := sb.GetLastEndpoint() if checkErr(err) { return } fmt.Printf("%q\n", endpoint) sc, err := zmq.NewSocket(zmq.PAIR) if checkErr(err) { return } err = sc.Connect(addr) if checkErr(err) { return } bounce(sb, sc, false) err = sc.Close() if checkErr(err) { return } err = sb.Close() if checkErr(err) { return } fmt.Println("Done") // Output: // "ipc://@/tmp/tester" // Done }
func agent_new() (agent *agent_t) { agent = &agent_t{ servers: make(map[string]*server_t), actives: make([]*server_t, 0), request: make([]string, 0), reply: make([]string, 0), } agent.pipe, _ = zmq.NewSocket(zmq.PAIR) agent.pipe.Connect("inproc://pipe") agent.router, _ = zmq.NewSocket(zmq.ROUTER) return }
func main() { snapshot, _ := zmq.NewSocket(zmq.DEALER) snapshot.Connect("tcp://localhost:5556") subscriber, _ := zmq.NewSocket(zmq.SUB) subscriber.SetRcvhwm(100000) // or messages between snapshot and next are lost subscriber.SetSubscribe("") subscriber.Connect("tcp://localhost:5557") time.Sleep(time.Second) // or messages between snapshot and next are lost kvmap := make(map[string]*kvsimple.Kvmsg) // Get state snapshot sequence := int64(0) snapshot.SendMessage("ICANHAZ?") for { kvmsg, err := kvsimple.RecvKvmsg(snapshot) if err != nil { fmt.Println(err) break // Interrupted } if key, _ := kvmsg.GetKey(); key == "KTHXBAI" { sequence, _ = kvmsg.GetSequence() fmt.Printf("Received snapshot=%d\n", sequence) break // Done } kvmsg.Store(kvmap) } snapshot.Close() first := true // Now apply pending updates, discard out-of-sequence messages for { kvmsg, err := kvsimple.RecvKvmsg(subscriber) if err != nil { fmt.Println(err) break // Interrupted } if seq, _ := kvmsg.GetSequence(); seq > sequence { sequence, _ = kvmsg.GetSequence() kvmsg.Store(kvmap) if first { // Show what the first regular update is after the snapshot, // to see if we missed updates. first = false fmt.Println("Next:", sequence) } } } }
func server_new(address string, port int, subtree string) (server *server_t) { server = &server_t{} fmt.Printf("I: adding server %s:%d...\n", address, port) server.address = address server.port = port server.snapshot, _ = zmq.NewSocket(zmq.DEALER) server.snapshot.Connect(fmt.Sprintf("%s:%d", address, port)) server.subscriber, _ = zmq.NewSocket(zmq.SUB) server.subscriber.Connect(fmt.Sprintf("%s:%d", address, port+1)) server.subscriber.SetSubscribe(subtree) return }
func main() { // First argument is this broker's name // Other arguments are our peers' names // if len(os.Args) < 2 { fmt.Println("syntax: peering1 me {you}...") os.Exit(1) } self := os.Args[1] fmt.Printf("I: preparing broker at %s...\n", self) rand.Seed(time.Now().UnixNano()) // Bind state backend to endpoint statebe, _ := zmq.NewSocket(zmq.PUB) defer statebe.Close() statebe.Bind("ipc://" + self + "-state.ipc") // Connect statefe to all peers statefe, _ := zmq.NewSocket(zmq.SUB) defer statefe.Close() statefe.SetSubscribe("") for _, peer := range os.Args[2:] { fmt.Printf("I: connecting to state backend at '%s'\n", peer) statefe.Connect("ipc://" + peer + "-state.ipc") } // The main loop sends out status messages to peers, and collects // status messages back from peers. The zmq_poll timeout defines // our own heartbeat: poller := zmq.NewPoller() poller.Add(statefe, zmq.POLLIN) for { // Poll for activity, or 1 second timeout sockets, err := poller.Poll(time.Second) if err != nil { break } // Handle incoming status messages if len(sockets) == 1 { msg, _ := statefe.RecvMessage(0) peer_name := msg[0] available := msg[1] fmt.Printf("%s - %s workers free\n", peer_name, available) } else { statebe.SendMessage(self, rand.Intn(10)) } } }
func main() { // This is where the weather server sits frontend, _ := zmq.NewSocket(zmq.XSUB) defer frontend.Close() frontend.Connect("tcp://192.168.55.210:5556") // This is our public endpoint for subscribers backend, _ := zmq.NewSocket(zmq.XPUB) defer backend.Close() backend.Bind("tcp://10.1.1.0:8100") // Run the proxy until the user interrupts us err := zmq.Proxy(frontend, backend, nil) log.Fatalln("Proxy interrupted:", err) }
func worker_task() { worker, _ := zmq.NewSocket(zmq.DEALER) defer worker.Close() set_id(worker) // Set a printable identity worker.Connect("tcp://localhost:5671") total := 0 for { // Tell the broker we're ready for work worker.Send("", zmq.SNDMORE) worker.Send("Hi Boss", 0) // Get workload from broker, until finished worker.Recv(0) // Envelope delimiter workload, _ := worker.Recv(0) if workload == "Fired!" { fmt.Printf("Completed: %d tasks\n", total) break } total++ // Do some random work time.Sleep(time.Duration(rand.Intn(500)+1) * time.Millisecond) } }
func main() { if len(os.Args) < 2 { fmt.Printf("I: syntax: %s <endpoint>\n", os.Args[0]) return } server, _ := zmq.NewSocket(zmq.REP) server.Bind(os.Args[1]) fmt.Println("I: service is ready at", os.Args[1]) for { request, err := server.RecvMessage(0) if err != nil { break // Interrupted } // Fail nastily if run against wrong client if len(request) != 2 { panic("len(request) != 2") } identity := request[0] server.SendMessage(identity, "OK") } fmt.Println("W: interrupted") }
func main() { publisher, _ := zmq.NewSocket(zmq.PUB) if len(os.Args) == 2 { publisher.Connect(os.Args[1]) } else { publisher.Bind("tcp://*:5556") } // Ensure subscriber connection has time to complete time.Sleep(time.Second) // Send out all 1,000 topic messages for topic_nbr := 0; topic_nbr < 1000; topic_nbr++ { _, err := publisher.SendMessage(fmt.Sprintf("%03d", topic_nbr), "Save Roger") if err != nil { fmt.Println(err) } } // Send one random update per second rand.Seed(time.Now().UnixNano()) for { time.Sleep(time.Second) _, err := publisher.SendMessage(fmt.Sprintf("%03d", rand.Intn(1000)), "Off with his head!") if err != nil { fmt.Println(err) } } }
func Example_test_connect_resolve() { sock, err := zmq.NewSocket(zmq.PUB) if checkErr(err) { return } err = sock.Connect("tcp://localhost:1234") checkErr(err) err = sock.Connect("tcp://localhost:invalid") fmt.Println(e(err, true)) err = sock.Connect("tcp://in val id:1234") fmt.Println(e(err, true)) err = sock.Connect("invalid://localhost:1234") fmt.Println(e(err, true)) err = sock.Close() checkErr(err) fmt.Println("Done") // Output: // error // error // error // Done }
func Example_test_ctx_options() { i, err := zmq.GetMaxSockets() fmt.Println(i == zmq.MaxSocketsDflt, err) i, err = zmq.GetIoThreads() fmt.Println(i == zmq.IoThreadsDflt, err) b, err := zmq.GetIpv6() fmt.Println(b, err) zmq.SetIpv6(true) b, err = zmq.GetIpv6() fmt.Println(b, err) router, _ := zmq.NewSocket(zmq.ROUTER) b, err = router.GetIpv6() fmt.Println(b, err) fmt.Println(router.Close()) zmq.SetIpv6(false) fmt.Println("Done") // Output: // true <nil> // true <nil> // false <nil> // true <nil> // true <nil> // <nil> // Done }
func client_thread(pipe chan<- string) { dealer, _ := zmq.NewSocket(zmq.DEALER) dealer.Connect("tcp://127.0.0.1:6000") // Up to this many chunks in transit credit := PIPELINE total := 0 // Total bytes received chunks := 0 // Total chunks received offset := 0 // Offset of next chunk request for { for credit > 0 { // Ask for next chunk dealer.SendMessage("fetch", offset, CHUNK_SIZE) offset += CHUNK_SIZE credit-- } chunk, err := dealer.RecvBytes(0) if err != nil { break // Shutting down, quit } chunks++ credit++ size := len(chunk) total += size if size < CHUNK_SIZE { break // Last chunk received; exit } } fmt.Printf("%v chunks received, %v bytes\n", chunks, total) pipe <- "OK" }
// Connect or reconnect to broker. func (mdcli *Mdcli) ConnectToBroker() (err error) { if mdcli.client != nil { mdcli.client.Close() mdcli.client = nil } mdcli.client, err = zmq.NewSocket(zmq.REQ) if err != nil { if mdcli.verbose { log.Println("E: ConnectToBroker() creating socket failed") } return } mdcli.poller = zmq.NewPoller() mdcli.poller.Add(mdcli.client, zmq.POLLIN) if mdcli.verbose { log.Printf("I: connecting to broker at %s...", mdcli.broker) } err = mdcli.client.Connect(mdcli.broker) if err != nil && mdcli.verbose { log.Println("E: ConnectToBroker() failed to connect to broker", mdcli.broker) } return }
func main() { subscriber, _ := zmq.NewSocket(zmq.SUB) if len(os.Args) == 2 { subscriber.Connect(os.Args[1]) } else { subscriber.Connect("tcp://localhost:5556") } rand.Seed(time.Now().UnixNano()) subscription := fmt.Sprintf("%03d", rand.Intn(1000)) subscriber.SetSubscribe(subscription) for { msg, err := subscriber.RecvMessage(0) if err != nil { break } topic := msg[0] data := msg[1] if topic != subscription { panic("topic != subscription") } fmt.Println(data) } }
func main() { broker, _ := zmq.NewSocket(zmq.ROUTER) defer broker.Close() broker.Bind("tcp://*:5671") rand.Seed(time.Now().UnixNano()) for worker_nbr := 0; worker_nbr < NBR_WORKERS; worker_nbr++ { go worker_task() } // Run for five seconds and then tell workers to end start_time := time.Now() workers_fired := 0 for { // Next message gives us least recently used worker identity, _ := broker.Recv(0) broker.Send(identity, zmq.SNDMORE) broker.Recv(0) // Envelope delimiter broker.Recv(0) // Response from worker broker.Send("", zmq.SNDMORE) // Encourage workers until it's time to fire them if time.Since(start_time) < 5*time.Second { broker.Send("Work harder", 0) } else { broker.Send("Fired!", 0) workers_fired++ if workers_fired == NBR_WORKERS { break } } } time.Sleep(time.Second) }
func New() (flcliapi *Flcliapi) { flcliapi = &Flcliapi{} flcliapi.pipe, _ = zmq.NewSocket(zmq.PAIR) flcliapi.pipe.Bind("inproc://pipe") go flcliapi_agent() return }
func Example_socket_event() { // REP socket rep, err := zmq.NewSocket(zmq.REP) if checkErr(err) { return } // REP socket monitor, all events err = rep.Monitor("inproc://monitor.rep", zmq.EVENT_ALL) if checkErr(err) { rep.Close() return } go rep_socket_monitor("inproc://monitor.rep") time.Sleep(time.Second) // Generate an event rep.Bind("tcp://*:9689") if checkErr(err) { rep.Close() return } rep.Close() // Allow some time for event detection time.Sleep(time.Second) fmt.Println("Done") // Output: // EVENT_LISTENING tcp://0.0.0.0:9689 // EVENT_CLOSED tcp://0.0.0.0:9689 // Done }
func main() { // Socket to talk to server fmt.Println("Collecting updates from weather server...") subscriber, _ := zmq.NewSocket(zmq.SUB) defer subscriber.Close() subscriber.Connect("tcp://localhost:5556") // Subscribe to zipcode, default is NYC, 10001 filter := "10001 " if len(os.Args) > 1 { filter = os.Args[1] + " " } subscriber.SetSubscribe(filter) // Process 100 updates total_temp := 0 update_nbr := 0 for update_nbr < 100 { msg, _ := subscriber.Recv(0) if msgs := strings.Fields(msg); len(msgs) > 1 { if temperature, err := strconv.Atoi(msgs[1]); err == nil { total_temp += temperature update_nbr++ } } } fmt.Printf("Average temperature for zipcode '%s' was %dF \n\n", strings.TrimSpace(filter), total_temp/update_nbr) }