func main() { flag.Parse() var sock mangos.Socket var err error if sock, err = pub.NewSocket(); err != nil { die("can't get new pub socket: %s", err) } sock.AddTransport(ipc.NewTransport()) sock.AddTransport(tcp.NewTransport()) if err = sock.Listen("tcp://127.0.0.1:55555"); err != nil { die("can't listen on pub socket: %s", err.Error()) } //sub var subscriber mangos.Socket if subscriber, err = sub.NewSocket(); err != nil { die("can't get new sub socket: %s", err.Error()) } subscriber.AddTransport(ipc.NewTransport()) subscriber.AddTransport(tcp.NewTransport()) if err = subscriber.Dial("tcp://127.0.0.1:55555"); err != nil { die("can't dial on sub socket: %s", err.Error()) } // Empty byte array effectively subscribes to everything err = subscriber.SetOption(mangos.OptionSubscribe, []byte("")) start := time.Now() //var msg []byte for i := 1; i <= *numbPtr; i++ { //conn.Publish("test", []byte(randSeq(320))) sock.Send([]byte(randSeq(320))) if _, err = subscriber.Recv(); err != nil { die("Cannot recv: %s", err.Error()) } //log.Println(string(msg)) /* runtime.Gosched() atomic.AddUint64(&ops, 1) if ops == uint64(*numbPtr) { elapsed := time.Since(start) log.Printf("Time took %s", elapsed) } */ } elapsed := time.Since(start) log.Printf("Time took %s", elapsed) defer sock.Close() fmt.Scanln() }
func server(url string) { var sock mangos.Socket var err error var msg []byte if sock, err = surveyor.NewSocket(); err != nil { die("can't get new surveyor socket: %s", err) } sock.AddTransport(ipc.NewTransport()) sock.AddTransport(tcp.NewTransport()) if err = sock.Listen(url); err != nil { die("can't listen on surveyor socket: %s", err.Error()) } err = sock.SetOption(mangos.OptionSurveyTime, time.Second*2) if err != nil { die("SetOption(): %s", err.Error()) } for { fmt.Println("SERVER: SENDING DATE SURVEY REQUEST") if err = sock.Send([]byte("DATE")); err != nil { die("Failed sending survey: %s", err.Error()) } for { if msg, err = sock.Recv(); err != nil { break } fmt.Printf("SERVER: RECEIVED \"%s\" SURVEY RESPONSE\n", string(msg)) } } }
func client(url string, name string) { var sock mangos.Socket var err error var msg []byte if sock, err = respondent.NewSocket(); err != nil { die("can't get new respondent socket: %s", err.Error()) } sock.AddTransport(ipc.NewTransport()) sock.AddTransport(tcp.NewTransport()) if err = sock.Dial(url); err != nil { die("can't dial on respondent socket: %s", err.Error()) } for { if msg, err = sock.Recv(); err != nil { die("Cannot recv: %s", err.Error()) } fmt.Printf("CLIENT(%s): RECEIVED \"%s\" SURVEY REQUEST\n", name, string(msg)) d := date() fmt.Printf("CLIENT(%s): SENDING DATE SURVEY RESPONSE\n", name) if err = sock.Send([]byte(d)); err != nil { die("Cannot send: %s", err.Error()) } } }
func NewPublisher(ctx context.Context, url string) (*Publisher, error) { var sock mangos.Socket var err error sock, err = pub.NewSocket() if err != nil { return nil, err } sock.AddTransport(ipc.NewTransport()) sock.AddTransport(tcp.NewTransport()) err = sock.Listen(url) if err != nil { return nil, err } publiser := &Publisher{ ctx: ctx, url: url, sock: sock, publishCh: make(chan []string), } go publiser.run() return publiser, nil }
func testDevLoop(t *testing.T, addr string) { s1, err := pair.NewSocket() if err != nil { t.Errorf("Failed to open S1: %v", err) return } defer s1.Close() s1.AddTransport(tcp.NewTransport()) s1.AddTransport(ipc.NewTransport()) s1.AddTransport(inproc.NewTransport()) s1.AddTransport(tlstcp.NewTransport()) s1.AddTransport(ws.NewTransport()) s1.AddTransport(wss.NewTransport()) options := make(map[string]interface{}) if strings.HasPrefix(addr, "wss://") || strings.HasPrefix(addr, "tls+tcp://") { options[mangos.OptionTlsConfig] = srvCfg } if err := s1.ListenOptions(addr, options); err != nil { t.Errorf("Failed listening to %s: %v", addr, err) return } if err := mangos.Device(s1, s1); err != nil { t.Errorf("Device failed: %v", err) return } RunTests(t, addr, deviceCaseClient()) }
func client(url string, name string) { var sock mangos.Socket var err error var msg []byte if sock, err = sub.NewSocket(); err != nil { die("can't get new sub socket: %s", err.Error()) } sock.AddTransport(ipc.NewTransport()) sock.AddTransport(tcp.NewTransport()) if err = sock.Dial(url); err != nil { die("can't dial on sub socket: %s", err.Error()) } // Empty byte array effectively subscribes to everything err = sock.SetOption(mangos.OptionSubscribe, []byte("")) if err != nil { die("cannot subscribe: %s", err.Error()) } for { if msg, err = sock.Recv(); err != nil { die("Cannot recv: %s", err.Error()) } fmt.Printf("CLIENT(%s): RECEIVED %s\n", name, string(msg)) } }
func NewSubscriber(ctx context.Context, url string) (*Subscriber, error) { var sock mangos.Socket var err error sock, err = sub.NewSocket() if err != nil { return nil, err } sock.AddTransport(ipc.NewTransport()) sock.AddTransport(tcp.NewTransport()) err = sock.Dial(url) if err != nil { return nil, err } // subscribes to everything err = sock.SetOption(mangos.OptionSubscribe, []byte("")) if err != nil { return nil, err } subscriber := &Subscriber{ url: url, ctx: ctx, sock: sock, changes: make(chan []string, 8), } go subscriber.run() return subscriber, nil }
func server(url string, nworkers int) { var sock mangos.Socket var err error var wg sync.WaitGroup rand.Seed(time.Now().UnixNano()) if sock, err = rep.NewSocket(); err != nil { die("can't get new rep socket: %s", err) } if err = sock.SetOption(mangos.OptionRaw, true); err != nil { die("can't set raw mode: %s", err) } sock.AddTransport(ipc.NewTransport()) sock.AddTransport(tcp.NewTransport()) if err = sock.Listen(url); err != nil { die("can't listen on rep socket: %s", err.Error()) } wg.Add(nworkers) fmt.Printf("Starting %d workers\n", nworkers) for id := 0; id < nworkers; id++ { go func(id int) { defer wg.Done() serverWorker(sock, id) }(id) } wg.Wait() }
func node0(url string) { var sock mangos.Socket var err error var msg []byte if sock, err = rep.NewSocket(); err != nil { die("can't get new rep socket: %s", err) } sock.AddTransport(ipc.NewTransport()) sock.AddTransport(tcp.NewTransport()) if err = sock.Listen(url); err != nil { die("can't listen on rep socket: %s", err.Error()) } for { // Could also use sock.RecvMsg to get header msg, err = sock.Recv() if string(msg) == "DATE" { // no need to terminate fmt.Println("NODE0: RECEIVED DATE REQUEST") d := date() fmt.Printf("NODE0: SENDING DATE %s\n", d) err = sock.Send([]byte(d)) if err != nil { die("can't send reply: %s", err.Error()) } } } }
// AddTransports adds all known transports to the given socket. func AddTransports(sock mangos.Socket) { sock.AddTransport(tcp.NewTransport()) sock.AddTransport(inproc.NewTransport()) sock.AddTransport(ipc.NewTransport()) sock.AddTransport(tlstcp.NewTransport()) sock.AddTransport(ws.NewTransport()) sock.AddTransport(wss.NewTransport()) }
func testDevChain(t *testing.T, addr1 string, addr2 string, addr3 string) { // This tests using multiple devices across a few transports. // It looks like this: addr1->addr2->addr3 <==> addr3->addr2->addr1 var err error s := make([]mangos.Socket, 5) for i := 0; i < 5; i++ { if s[i], err = pair.NewSocket(); err != nil { t.Errorf("Failed to open S1_1: %v", err) return } defer s[i].Close() s[i].AddTransport(tcp.NewTransport()) s[i].AddTransport(inproc.NewTransport()) s[i].AddTransport(tlstcp.NewTransport()) s[i].AddTransport(ipc.NewTransport()) s[i].AddTransport(ws.NewTransport()) } if err = s[0].Listen(addr1); err != nil { t.Errorf("s[0] Listen: %v", err) return } if err = s[1].Dial(addr2); err != nil { t.Errorf("s[1] Dial: %v", err) return } if err = s[2].Listen(addr2); err != nil { t.Errorf("s[2] Listen: %v", err) return } if err = s[3].Dial(addr3); err != nil { t.Errorf("s[3] Dial: %v", err) return } if err = s[4].Listen(addr3); err != nil { t.Errorf("s[4] Listen: %v", err) return } if err = mangos.Device(s[0], s[1]); err != nil { t.Errorf("s[0],s[1] Device: %v", err) return } if err = mangos.Device(s[2], s[3]); err != nil { t.Errorf("s[2],s[3] Device: %v", err) return } if err = mangos.Device(s[4], nil); err != nil { t.Errorf("s[4] Device: %v", err) return } RunTests(t, addr1, deviceCaseClient()) }
func node0(url string) { var sock mangos.Socket var err error if sock, err = pair.NewSocket(); err != nil { die("can't get new pair socket: %s", err) } sock.AddTransport(ipc.NewTransport()) sock.AddTransport(tcp.NewTransport()) if err = sock.Listen(url); err != nil { die("can't listen on pair socket: %s", err.Error()) } send_recv(sock, "node0") }
func Server(urlServer string, urlPubSub string, opt Options) (*DiscoveryServer, error) { var sock mangos.Socket var err error var publisher *Publisher ctx, cancel := context.WithCancel(context.Background()) sock, err = surveyor.NewSocket() if err != nil { return nil, err } sock.AddTransport(ipc.NewTransport()) sock.AddTransport(tcp.NewTransport()) err = sock.Listen(urlServer) if err != nil { return nil, err } err = sock.SetOption(mangos.OptionSurveyTime, opt.SurveyTime) if err != nil { return nil, err } err = sock.SetOption(mangos.OptionRecvDeadline, opt.RecvDeadline) if err != nil { return nil, err } pubCtx, pubCancel := context.WithCancel(ctx) publisher, err = NewPublisher(pubCtx, urlPubSub) if err != nil { pubCancel() return nil, err } services := NewServices(publisher) server := &DiscoveryServer{ services: services, urlServer: urlServer, urlPubSub: urlPubSub, opt: opt, ctx: ctx, cancel: cancel, sock: sock, } go server.run() return server, nil }
func node1(url string) { var sock mangos.Socket var err error if sock, err = pair.NewSocket(); err != nil { die("can't get new pair socket: %s", err.Error()) } sock.AddTransport(ipc.NewTransport()) sock.AddTransport(tcp.NewTransport()) if err = sock.Dial(url); err != nil { die("can't dial on pair socket: %s", err.Error()) } sendRecv(sock, "node1") }
func node0(url string) { var sock mangos.Socket var err error var msg []byte if sock, err = pull.NewSocket(); err != nil { die("can't get new pull socket: %s", err) } sock.AddTransport(ipc.NewTransport()) sock.AddTransport(tcp.NewTransport()) if err = sock.Listen(url); err != nil { die("can't listen on pull socket: %s", err.Error()) } for { // Could also use sock.RecvMsg to get header msg, err = sock.Recv() fmt.Printf("NODE0: RECEIVED \"%s\"\n", msg) } }
func node1(url string, msg string) { var sock mangos.Socket var err error if sock, err = push.NewSocket(); err != nil { die("can't get new push socket: %s", err.Error()) } sock.AddTransport(ipc.NewTransport()) sock.AddTransport(tcp.NewTransport()) if err = sock.Dial(url); err != nil { die("can't dial on push socket: %s", err.Error()) } fmt.Printf("NODE1: SENDING \"%s\"\n", msg) if err = sock.Send([]byte(msg)); err != nil { die("can't send message on push socket: %s", err.Error()) } sock.Close() }
func main() { how_rand := flag.Bool("rand", false, "") flag.Parse() if flag.NArg() < 1 { log.Fatal("Missing arguments: at least one endpoint to bind to") } var err error var out mangos.Socket if out, err = push.NewSocket(); err != nil { log.Fatal("Nanomsg socket creation failure: ", err) } else { defer out.Close() out.AddTransport(ipc.NewTransport()) out.AddTransport(tcp.NewTransport()) out.SetOption(mangos.OptionWriteQLen, 16) out.SetOption(mangos.OptionRetryTime, 0) for i := 0; i < flag.NArg(); i++ { if err := out.Listen(flag.Arg(i)); err != nil { log.Fatal("Nanomsg listen() error: ", err) } } } switch { case *how_rand: Gen(out, func(tab []string) string { if len(tab) <= 0 { return "" } return tab[rand.Intn(len(tab))] }) default: i := 0 Gen(out, func(tab []string) string { if len(tab) <= 0 { return "" } i = (i + 1) % len(tab) return tab[i] }) } }
func MakeFront(server *Server, concurrency int, config string) (*Front, error) { tokens := strings.Split(config, ",") if len(tokens) < 2 { return nil, BadFront } self := &Front{} // Prepare the front TCP socket if url, err := net.ResolveTCPAddr("tcp", tokens[0]); err != nil { return nil, err } else if ep, err := net.ListenTCP("tcp", url); err != nil { return nil, err } else { self.endpoint = ep } // Prepare the Nanomsg feeder if nn, err := pull.NewSocket(); err != nil { self.endpoint.Close() return nil, err } else { self.feeder = nn self.feeder.AddTransport(ipc.NewTransport()) self.feeder.AddTransport(tcp.NewTransport()) self.feeder.SetOption(mangos.OptionReadQLen, 16) } for i := 1; i < len(tokens); i++ { self.feeder.Dial(tokens[i]) } // Eventually, finalize the structure self.server = server self.tokens = make(chan bool, concurrency) for ; concurrency > 0; concurrency-- { self.tokens <- true } return self, nil }
func server(url string) { var sock mangos.Socket var err error if sock, err = pub.NewSocket(); err != nil { die("can't get new pub socket: %s", err) } sock.AddTransport(ipc.NewTransport()) sock.AddTransport(tcp.NewTransport()) if err = sock.Listen(url); err != nil { die("can't listen on pub socket: %s", err.Error()) } for { // Could also use sock.RecvMsg to get header d := date() fmt.Printf("SERVER: PUBLISHING DATE %s\n", d) if err = sock.Send([]byte(d)); err != nil { die("Failed publishing: %s", err.Error()) } time.Sleep(time.Second) } }
func ClientWithSub(urlServer string, urlPubSub string, service string) (*DiscoveryClient, error) { var sock mangos.Socket var err error var subscriber *Subscriber ctx, cancel := context.WithCancel(context.Background()) if urlPubSub != "" { subCtx, _ := context.WithCancel(ctx) subscriber, err = NewSubscriber(subCtx, urlPubSub) if err != nil { return nil, err } } sock, err = respondent.NewSocket() if err != nil { return nil, err } sock.AddTransport(ipc.NewTransport()) sock.AddTransport(tcp.NewTransport()) err = sock.Dial(urlServer) if err != nil { return nil, err } client := &DiscoveryClient{ urlServer: urlServer, urlPubSub: urlPubSub, service: service, ctx: ctx, cancel: cancel, sock: sock, subscriber: subscriber, } go client.run() return client, nil }
func node(args []string) { var sock mangos.Socket var err error var msg []byte var x int if sock, err = bus.NewSocket(); err != nil { die("bus.NewSocket: %s", err) } sock.AddTransport(ipc.NewTransport()) sock.AddTransport(tcp.NewTransport()) if err = sock.Listen(args[2]); err != nil { die("sock.Listen: %s", err.Error()) } // wait for everyone to start listening time.Sleep(time.Second) for x = 3; x < len(args); x++ { if err = sock.Dial(args[x]); err != nil { die("socket.Dial: %s", err.Error()) } } // wait for everyone to join time.Sleep(time.Second) fmt.Printf("%s: SENDING '%s' ONTO BUS\n", args[1], args[1]) if err = sock.Send([]byte(args[1])); err != nil { die("sock.Send: %s", err.Error()) } for { if msg, err = sock.Recv(); err != nil { die("sock.Recv: %s", err.Error()) } fmt.Printf("%s: RECEIVED \"%s\" FROM BUS\n", args[1], string(msg)) } }
func (receiver *SPReceiver) Receive(address string) error { var sock mangos.Socket var err error if sock, err = rep.NewSocket(); err != nil { return err } sock.AddTransport(ipc.NewTransport()) sock.AddTransport(tcp.NewTransport()) if err := sock.Listen(address); err != nil { return err } for { if _, err := sock.Recv(); err != nil { return err } } return nil }
func clientWorker(url string, id int) { var sock mangos.Socket var m *mangos.Message var err error if sock, err = req.NewSocket(); err != nil { die("can't get new req socket: %s", err.Error()) } // Leave this in Cooked mode! sock.AddTransport(ipc.NewTransport()) sock.AddTransport(tcp.NewTransport()) if err = sock.Dial(url); err != nil { die("can't dial on req socket: %s", err.Error()) } // send an empty messsage m = mangos.NewMessage(1) if err = sock.SendMsg(m); err != nil { die("can't send request: %s", err.Error()) } if m, err = sock.RecvMsg(); err != nil { die("can't recv reply: %s", err.Error()) } sock.Close() if len(m.Body) != 4 { die("bad response len: %d", len(m.Body)) } worker := binary.BigEndian.Uint32(m.Body[0:]) L.Lock() fmt.Printf("Client: %4d Server: %4d\n", id, worker) L.Unlock() }
func node1(url string) { var sock mangos.Socket var err error var msg []byte if sock, err = req.NewSocket(); err != nil { die("can't get new req socket: %s", err.Error()) } sock.AddTransport(ipc.NewTransport()) sock.AddTransport(tcp.NewTransport()) if err = sock.Dial(url); err != nil { die("can't dial on req socket: %s", err.Error()) } fmt.Printf("NODE1: SENDING DATE REQUEST %s\n", "DATE") if err = sock.Send([]byte("DATE")); err != nil { die("can't send message on push socket: %s", err.Error()) } if msg, err = sock.Recv(); err != nil { die("can't receive date: %s", err.Error()) } fmt.Printf("NODE1: RECEIVED DATE %s\n", string(msg)) sock.Close() }