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 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 Example_multiple_contexts() { chQuit := make(chan interface{}) chReactor := make(chan bool) addr1 := "tcp://127.0.0.1:9997" addr2 := "tcp://127.0.0.1:9998" serv_ctx1, err := zmq.NewContext() if checkErr(err) { return } serv1, err := serv_ctx1.NewSocket(zmq.REP) if checkErr(err) { return } err = serv1.Bind(addr1) if checkErr(err) { return } defer func() { serv1.Close() serv_ctx1.Term() }() serv_ctx2, err := zmq.NewContext() if checkErr(err) { return } serv2, err := serv_ctx2.NewSocket(zmq.REP) if checkErr(err) { return } err = serv2.Bind(addr2) if checkErr(err) { return } defer func() { serv2.Close() serv_ctx2.Term() }() new_service := func(sock *zmq.Socket, addr string) { socket_handler := func(state zmq.State) error { msg, err := sock.RecvMessage(0) if checkErr(err) { return err } _, err = sock.SendMessage(addr, msg) if checkErr(err) { return err } return nil } quit_handler := func(interface{}) error { return errors.New("quit") } defer func() { chReactor <- true }() reactor := zmq.NewReactor() reactor.AddSocket(sock, zmq.POLLIN, socket_handler) reactor.AddChannel(chQuit, 1, quit_handler) err = reactor.Run(100 * time.Millisecond) fmt.Println(err) } go new_service(serv1, addr1) go new_service(serv2, addr2) time.Sleep(time.Second) // default context sock1, err := zmq.NewSocket(zmq.REQ) if checkErr(err) { return } sock2, err := zmq.NewSocket(zmq.REQ) if checkErr(err) { return } err = sock1.Connect(addr1) if checkErr(err) { return } err = sock2.Connect(addr2) if checkErr(err) { return } _, err = sock1.SendMessage(addr1) if checkErr(err) { return } _, err = sock2.SendMessage(addr2) if checkErr(err) { return } msg, err := sock1.RecvMessage(0) fmt.Println(err, msg) msg, err = sock2.RecvMessage(0) fmt.Println(err, msg) err = sock1.Close() if checkErr(err) { return } err = sock2.Close() if checkErr(err) { return } // non-default contexts ctx1, err := zmq.NewContext() if checkErr(err) { return } ctx2, err := zmq.NewContext() if checkErr(err) { return } sock1, err = ctx1.NewSocket(zmq.REQ) if checkErr(err) { return } sock2, err = ctx2.NewSocket(zmq.REQ) if checkErr(err) { return } err = sock1.Connect(addr1) if checkErr(err) { return } err = sock2.Connect(addr2) if checkErr(err) { return } _, err = sock1.SendMessage(addr1) if checkErr(err) { return } _, err = sock2.SendMessage(addr2) if checkErr(err) { return } msg, err = sock1.RecvMessage(0) fmt.Println(err, msg) msg, err = sock2.RecvMessage(0) fmt.Println(err, msg) err = sock1.Close() if checkErr(err) { return } err = sock2.Close() if checkErr(err) { return } err = ctx1.Term() if checkErr(err) { return } err = ctx2.Term() if checkErr(err) { return } // close(chQuit) doesn't work because the reactor removes closed channels, instead of acting on them chQuit <- true <-chReactor chQuit <- true <-chReactor fmt.Println("Done") // Output: // <nil> [tcp://127.0.0.1:9997 tcp://127.0.0.1:9997] // <nil> [tcp://127.0.0.1:9998 tcp://127.0.0.1:9998] // <nil> [tcp://127.0.0.1:9997 tcp://127.0.0.1:9997] // <nil> [tcp://127.0.0.1:9998 tcp://127.0.0.1:9998] // quit // quit // Done }
func Example_test_security_plain() { time.Sleep(100 * time.Millisecond) handler, err := zmq.NewSocket(zmq.REP) if checkErr(err) { return } err = handler.Bind("inproc://zeromq.zap.01") if checkErr(err) { return } doHandler := func(state zmq.State) error { msg, err := handler.RecvMessage(0) if err != nil { return err // Terminating } version := msg[0] sequence := msg[1] // domain := msg[2] // address := msg[3] identity := msg[4] mechanism := msg[5] username := msg[6] password := msg[7] if version != "1.0" { return errors.New("version != 1.0") } if mechanism != "PLAIN" { return errors.New("mechanism != PLAIN") } if identity != "IDENT" { return errors.New("identity != IDENT") } if username == "admin" && password == "password" { handler.SendMessage(version, sequence, "200", "OK", "anonymous", "") } else { handler.SendMessage(version, sequence, "400", "Invalid username or password", "", "") } return nil } doQuit := func(i interface{}) error { err := handler.Close() checkErr(err) fmt.Println("Handler closed") return errors.New("Quit") } quit := make(chan interface{}) reactor := zmq.NewReactor() reactor.AddSocket(handler, zmq.POLLIN, doHandler) reactor.AddChannel(quit, 0, doQuit) go func() { reactor.Run(100 * time.Millisecond) fmt.Println("Reactor finished") quit <- true }() defer func() { quit <- true <-quit close(quit) }() // Server socket will accept connections server, err := zmq.NewSocket(zmq.DEALER) if checkErr(err) { return } err = server.SetIdentity("IDENT") if checkErr(err) { return } err = server.SetPlainServer(1) if checkErr(err) { return } err = server.Bind("tcp://127.0.0.1:9998") if checkErr(err) { return } // Check PLAIN security with correct username/password client, err := zmq.NewSocket(zmq.DEALER) if checkErr(err) { return } err = client.SetPlainUsername("admin") if checkErr(err) { return } err = client.SetPlainPassword("password") if checkErr(err) { return } err = client.Connect("tcp://127.0.0.1:9998") if checkErr(err) { return } bounce(server, client, false) err = client.Close() if checkErr(err) { return } // Check PLAIN security with badly configured client (as_server) // This will be caught by the plain_server class, not passed to ZAP client, err = zmq.NewSocket(zmq.DEALER) if checkErr(err) { return } client.SetPlainServer(1) if checkErr(err) { return } err = client.Connect("tcp://127.0.0.1:9998") if checkErr(err) { return } err = client.SetRcvtimeo(time.Second) if checkErr(err) { return } err = server.SetRcvtimeo(time.Second) if checkErr(err) { return } bounce(server, client, true) client.SetLinger(0) err = client.Close() if checkErr(err) { return } err = server.Close() checkErr(err) fmt.Println("Done") // Output: // 5 error // Done // Handler closed // Reactor finished }
func Example_test_security_null() { time.Sleep(100 * time.Millisecond) handler, err := zmq.NewSocket(zmq.REP) if checkErr(err) { return } err = handler.Bind("inproc://zeromq.zap.01") if checkErr(err) { return } doHandler := func(state zmq.State) error { msg, err := handler.RecvMessage(0) if err != nil { return err // Terminating } version := msg[0] sequence := msg[1] domain := msg[2] // address := msg[3] // identity := msg[4] mechanism := msg[5] if version != "1.0" { return errors.New("version != 1.0") } if mechanism != "NULL" { return errors.New("mechanism != NULL") } if domain == "TEST" { handler.SendMessage(version, sequence, "200", "OK", "anonymous", "") } else { handler.SendMessage(version, sequence, "400", "BAD DOMAIN", "", "") } return nil } doQuit := func(i interface{}) error { err := handler.Close() checkErr(err) fmt.Println("Handler closed") return errors.New("Quit") } quit := make(chan interface{}) reactor := zmq.NewReactor() reactor.AddSocket(handler, zmq.POLLIN, doHandler) reactor.AddChannel(quit, 0, doQuit) go func() { reactor.Run(100 * time.Millisecond) fmt.Println("Reactor finished") quit <- true }() defer func() { quit <- true <-quit close(quit) }() // We bounce between a binding server and a connecting client server, err := zmq.NewSocket(zmq.DEALER) if checkErr(err) { return } client, err := zmq.NewSocket(zmq.DEALER) if checkErr(err) { return } // We first test client/server with no ZAP domain // Libzmq does not call our ZAP handler, the connect must succeed err = server.Bind("tcp://127.0.0.1:9683") if checkErr(err) { return } err = client.Connect("tcp://127.0.0.1:9683") if checkErr(err) { return } bounce(server, client, false) server.Unbind("tcp://127.0.0.1:9683") client.Disconnect("tcp://127.0.0.1:9683") // Now define a ZAP domain for the server; this enables // authentication. We're using the wrong domain so this test // must fail. err = server.SetZapDomain("WRONG") if checkErr(err) { return } err = server.Bind("tcp://127.0.0.1:9687") if checkErr(err) { return } err = client.Connect("tcp://127.0.0.1:9687") if checkErr(err) { return } err = client.SetRcvtimeo(time.Second) if checkErr(err) { return } err = server.SetRcvtimeo(time.Second) if checkErr(err) { return } bounce(server, client, true) server.Unbind("tcp://127.0.0.1:9687") client.Disconnect("tcp://127.0.0.1:9687") // Now use the right domain, the test must pass err = server.SetZapDomain("TEST") if checkErr(err) { return } err = server.Bind("tcp://127.0.0.1:9688") if checkErr(err) { return } err = client.Connect("tcp://127.0.0.1:9688") if checkErr(err) { return } bounce(server, client, false) server.Unbind("tcp://127.0.0.1:9688") client.Disconnect("tcp://127.0.0.1:9688") err = client.Close() checkErr(err) err = server.Close() checkErr(err) fmt.Println("Done") // Output: // 5 error // Done // Handler closed // Reactor finished }
func Example_test_security_curve() { time.Sleep(100 * time.Millisecond) // Generate new keypairs for this test client_public, client_secret, err := zmq.NewCurveKeypair() if checkErr(err) { return } server_public, server_secret, err := zmq.NewCurveKeypair() if checkErr(err) { return } handler, err := zmq.NewSocket(zmq.REP) if checkErr(err) { return } err = handler.Bind("inproc://zeromq.zap.01") if checkErr(err) { return } doHandler := func(state zmq.State) error { msg, err := handler.RecvMessage(0) if err != nil { return err // Terminating } version := msg[0] sequence := msg[1] // domain := msg[2] // address := msg[3] identity := msg[4] mechanism := msg[5] client_key := msg[6] client_key_text := zmq.Z85encode(client_key) if version != "1.0" { return errors.New("version != 1.0") } if mechanism != "CURVE" { return errors.New("mechanism != CURVE") } if identity != "IDENT" { return errors.New("identity != IDENT") } if client_key_text == client_public { handler.SendMessage(version, sequence, "200", "OK", "anonymous", "") } else { handler.SendMessage(version, sequence, "400", "Invalid client public key", "", "") } return nil } doQuit := func(i interface{}) error { err := handler.Close() checkErr(err) fmt.Println("Handler closed") return errors.New("Quit") } quit := make(chan interface{}) reactor := zmq.NewReactor() reactor.AddSocket(handler, zmq.POLLIN, doHandler) reactor.AddChannel(quit, 0, doQuit) go func() { reactor.Run(100 * time.Millisecond) fmt.Println("Reactor finished") quit <- true }() defer func() { quit <- true <-quit close(quit) }() // Server socket will accept connections server, err := zmq.NewSocket(zmq.DEALER) if checkErr(err) { return } err = server.SetCurveServer(1) if checkErr(err) { return } err = server.SetCurveSecretkey(server_secret) if checkErr(err) { return } err = server.SetIdentity("IDENT") if checkErr(err) { return } server.Bind("tcp://127.0.0.1:9998") if checkErr(err) { return } err = server.SetRcvtimeo(time.Second) if checkErr(err) { return } // Check CURVE security with valid credentials client, err := zmq.NewSocket(zmq.DEALER) if checkErr(err) { return } err = client.SetCurveServerkey(server_public) if checkErr(err) { return } err = client.SetCurvePublickey(client_public) if checkErr(err) { return } err = client.SetCurveSecretkey(client_secret) if checkErr(err) { return } err = client.Connect("tcp://127.0.0.1:9998") if checkErr(err) { return } bounce(server, client, false) err = client.Close() if checkErr(err) { return } time.Sleep(100 * time.Millisecond) // Check CURVE security with a garbage server key // This will be caught by the curve_server class, not passed to ZAP garbage_key := "0000111122223333444455556666777788889999" client, err = zmq.NewSocket(zmq.DEALER) if checkErr(err) { return } err = client.SetCurveServerkey(garbage_key) if checkErr(err) { return } err = client.SetCurvePublickey(client_public) if checkErr(err) { return } err = client.SetCurveSecretkey(client_secret) if checkErr(err) { return } err = client.Connect("tcp://127.0.0.1:9998") if checkErr(err) { return } err = client.SetRcvtimeo(time.Second) if checkErr(err) { return } bounce(server, client, true) client.SetLinger(0) err = client.Close() if checkErr(err) { return } time.Sleep(100 * time.Millisecond) // Check CURVE security with a garbage client secret key // This will be caught by the curve_server class, not passed to ZAP client, err = zmq.NewSocket(zmq.DEALER) if checkErr(err) { return } err = client.SetCurveServerkey(server_public) if checkErr(err) { return } err = client.SetCurvePublickey(garbage_key) if checkErr(err) { return } err = client.SetCurveSecretkey(client_secret) if checkErr(err) { return } err = client.Connect("tcp://127.0.0.1:9998") if checkErr(err) { return } err = client.SetRcvtimeo(time.Second) if checkErr(err) { return } bounce(server, client, true) client.SetLinger(0) err = client.Close() if checkErr(err) { return } time.Sleep(100 * time.Millisecond) // Check CURVE security with a garbage client secret key // This will be caught by the curve_server class, not passed to ZAP client, err = zmq.NewSocket(zmq.DEALER) if checkErr(err) { return } err = client.SetCurveServerkey(server_public) if checkErr(err) { return } err = client.SetCurvePublickey(client_public) if checkErr(err) { return } err = client.SetCurveSecretkey(garbage_key) if checkErr(err) { return } err = client.Connect("tcp://127.0.0.1:9998") if checkErr(err) { return } err = client.SetRcvtimeo(time.Second) if checkErr(err) { return } bounce(server, client, true) client.SetLinger(0) err = client.Close() if checkErr(err) { return } time.Sleep(100 * time.Millisecond) // Check CURVE security with bogus client credentials // This must be caught by the ZAP handler bogus_public, bogus_secret, _ := zmq.NewCurveKeypair() client, err = zmq.NewSocket(zmq.DEALER) if checkErr(err) { return } err = client.SetCurveServerkey(server_public) if checkErr(err) { return } err = client.SetCurvePublickey(bogus_public) if checkErr(err) { return } err = client.SetCurveSecretkey(bogus_secret) if checkErr(err) { return } err = client.Connect("tcp://127.0.0.1:9998") if checkErr(err) { return } err = client.SetRcvtimeo(time.Second) if checkErr(err) { return } bounce(server, client, true) client.SetLinger(0) err = client.Close() if checkErr(err) { return } // Shutdown err = server.Close() checkErr(err) fmt.Println("Done") // Output: // 5 error // 5 error // 5 error // 5 error // Done // Handler closed // Reactor finished }