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 TestWebsockPath( //"github.com/gdamore/mangos/test" t *testing.T) { sockReq, _ := req.NewSocket() sockRep, _ := rep.NewSocket() tran := NewTransport() l, e := tran.NewListener("ws://127.0.0.1:3335/mysock", sockReq) if e != nil { t.Errorf("Failed new Listener: %v", e) return } d, e := tran.NewDialer("ws://127.0.0.1:3335/boguspath", sockRep) if e != nil { t.Errorf("Failed new Dialer: %v", e) return } if e = l.Listen(); e != nil { t.Errorf("Listen failed") return } defer l.Close() p, e := d.Dial() if p != nil { defer p.Close() } if e == nil { t.Errorf("Dial passed, when should not have!") return } t.Logf("Got expected error %v", e) }
func TestWebsockMux(t *testing.T) { sockReq, _ := req.NewSocket() sockRep, _ := rep.NewSocket() tran := NewTransport() l, e := tran.NewListener("ws://127.0.0.1:3336/mysock", sockReq) if e != nil { t.Errorf("Failed new Listener: %v", e) return } muxi, e := l.GetOption(OptionWebSocketMux) if e != nil { t.Errorf("Failed get mux: %v", e) } mux := muxi.(*http.ServeMux) mux.HandleFunc("/bogus", bogusHandler) d, e := tran.NewDialer("ws://127.0.0.1:3336/bogus", sockRep) if e != nil { t.Errorf("Failed new Dialer: %v", e) return } if e = l.Listen(); e != nil { t.Errorf("Listen failed") return } defer l.Close() p, e := d.Dial() if p != nil { defer p.Close() } if e == nil { t.Errorf("Dial passed, when should not have!") return } t.Logf("Got expected error %v", e) // Now let's try to use http client. resp, err := http.Get("http://127.0.0.1:3336/bogus") if err != nil { t.Errorf("Get of boguspath failed: %v", err) return } if resp.StatusCode != 200 { t.Errorf("Response code wrong: %d", resp.StatusCode) return } body, err := ioutil.ReadAll(resp.Body) if err != nil { t.Errorf("ReadAll Failed: %v", err) return } if string(body) != bogusstr { t.Errorf("Results mismatch: %s != %s", string(body), bogusstr) } t.Logf("Got body: %s", string(body)) }
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()) } } } }
func (rt *repTest) Init(t *testing.T, addr string) bool { var err error if rt.Sock, err = rep.NewSocket(); err != nil { rt.Errorf("NewSocket(): %v", err) return false } return rt.T.Init(t, addr) }
// NewTranTest creates a TranTest. func NewTranTest(tran mangos.Transport, addr string) *TranTest { tt := &TranTest{addr: addr, tran: tran} if strings.HasPrefix(tt.addr, "tls+tcp://") || strings.HasPrefix(tt.addr, "wss://") { tt.cliCfg, _ = GetTLSConfig(false) tt.srvCfg, _ = GetTLSConfig(true) } tt.sockRep, _ = rep.NewSocket() tt.sockReq, _ = req.NewSocket() return tt }
func TestDeviceReqRep(t *testing.T) { s1, err := req.NewSocket() if err != nil { t.Errorf("Failed to open S1: %v", err) return } defer s1.Close() s2, err := rep.NewSocket() if err != nil { t.Errorf("Failed to open S2: %v", err) return } defer s2.Close() switch err := mangos.Device(s1, s2); err { case nil: t.Logf("Matching req/rep ok!") return default: t.Errorf("Got unexpected err: %v", err) return } }
func benchmarkReq(t *testing.B, url string, size int) { if strings.HasPrefix(url, "ipc://") && runtime.GOOS == "windows" { t.Skip("IPC not supported on Windows") return } srvopts := make(map[string]interface{}) cliopts := make(map[string]interface{}) if strings.HasPrefix(url, "wss://") || strings.HasPrefix(url, "tls+tcp://") { srvopts[mangos.OptionTLSConfig] = srvCfg cliopts[mangos.OptionTLSConfig] = cliCfg } srvrdy := make(chan struct{}) srvsock, err := rep.NewSocket() if err != nil || srvsock == nil { t.Errorf("Failed creating server socket: %v", err) return } defer srvsock.Close() all.AddTransports(srvsock) clisock, err := req.NewSocket() if err != nil || clisock == nil { t.Errorf("Failed creating client socket: %v", err) return } defer clisock.Close() all.AddTransports(clisock) go func() { var err error var msg *mangos.Message if err = srvsock.ListenOptions(url, srvopts); err != nil { t.Errorf("Server listen failed: %v", err) return } close(srvrdy) // echo server for { if msg, err = srvsock.RecvMsg(); err != nil { return } if err = srvsock.SendMsg(msg); err != nil { t.Errorf("Server send failed: %v", err) return } } }() if err = clisock.DialOptions(url, cliopts); err != nil { t.Errorf("Client dial failed: %v", err) return } <-srvrdy time.Sleep(time.Millisecond * 1000) t.ResetTimer() msg := make([]byte, size) for i := 0; i < t.N; i++ { if err = clisock.Send(msg); err != nil { t.Errorf("Client send failed: %v", err) return } if msg, err = clisock.Recv(); err != nil { t.Errorf("Client receive failed: %v", err) return } } if size > 128 { t.SetBytes(int64(size)) } t.StopTimer() }
// This test verifies that we can use stock http server instances with // our own websocket handler. func TestWebsockHandler(t *testing.T) { sockReq, _ := req.NewSocket() sockRep, _ := rep.NewSocket() tran := NewTransport() l, e := tran.NewListener("ws://127.0.0.1:3337/mysock", sockReq) if e != nil { t.Errorf("Failed new Listener: %v", e) return } hi, e := l.GetOption(OptionWebSocketHandler) if e != nil { t.Errorf("Failed get WebSocketHandler: %v", e) } handler := hi.(http.Handler) mux := http.NewServeMux() mux.HandleFunc("/bogus", bogusHandler) mux.Handle("/mysock", handler) // Note that we are *counting* on this to die gracefully when our // program exits. There appears to be no way to shutdown http // instances gracefully. go http.ListenAndServe("127.0.0.1:3337", mux) d, e := tran.NewDialer("ws://127.0.0.1:3337/bogus", sockRep) if e != nil { t.Errorf("Failed new Dialer: %v", e) return } defer l.Close() p, e := d.Dial() if p != nil { defer p.Close() } if e == nil { t.Errorf("Dial passed, when should not have!") return } t.Logf("Got expected error %v", e) // Now let's try to use http client. resp, err := http.Get("http://127.0.0.1:3337/bogus") if err != nil { t.Errorf("Get of boguspath failed: %v", err) return } if resp.StatusCode != 200 { t.Errorf("Response code wrong: %d", resp.StatusCode) return } body, err := ioutil.ReadAll(resp.Body) if err != nil { t.Errorf("ReadAll Failed: %v", err) return } if string(body) != bogusstr { t.Errorf("Results mismatch: %s != %s", string(body), bogusstr) } t.Logf("Got body: %s", string(body)) }
func TestPortHook(t *testing.T) { t.Logf("Testing Add Hook") srvtest := &hooktest{allow: true, t: t} clitest := &hooktest{allow: true, t: t} addr := AddrTestTCP srvtest.expect = []hookinfo{{ action: mangos.PortActionAdd, addr: addr, server: true, isopen: true, }, { action: mangos.PortActionRemove, addr: addr, server: true, isopen: false, }} clitest.expect = []hookinfo{{ action: mangos.PortActionAdd, addr: addr, server: false, isopen: true, }, { action: mangos.PortActionRemove, addr: addr, server: false, isopen: false, }} sockreq, err := req.NewSocket() if err != nil { t.Errorf("NewSocket failed: %v", err) return } defer sockreq.Close() sockreq.AddTransport(tcp.NewTransport()) if sockreq.SetPortHook(clitest.Hook) != nil { t.Errorf("SetPortHook result not nil!") return } d, err := sockreq.NewDialer(addr, nil) if err != nil { t.Errorf("NewDialer failed: %v", err) return } sockrep, err := rep.NewSocket() if err != nil { t.Errorf("NewSocket failed: %v", err) return } defer sockrep.Close() sockrep.AddTransport(tcp.NewTransport()) if sockrep.SetPortHook(srvtest.Hook) != nil { t.Errorf("SetPortHook result not nil!") return } l, err := sockrep.NewListener(addr, nil) if err != nil { t.Errorf("NewListener failed: %v", err) return } if err := l.Listen(); err != nil { t.Errorf("Listen failed: %v", err) return } if err := d.Dial(); err != nil { t.Errorf("Dial failed: %v", err) return } // wait a second for connection to establish // could also issue a req/rep... t.Logf("Waiting a bit...") time.Sleep(100 * time.Millisecond) d.Close() l.Close() // shut down the server sockrep.Close() sockreq.Close() time.Sleep(100 * time.Millisecond) clitest.Lock() defer clitest.Unlock() srvtest.Lock() defer srvtest.Unlock() for i, info := range clitest.expect { t.Logf("Exp C[%d]: %s", i, info.String()) } for i, info := range clitest.calls { t.Logf("Got C[%d]: %s", i, info.String()) } for i, info := range srvtest.expect { t.Logf("Exp S[%d]: %s", i, info.String()) } for i, info := range srvtest.calls { t.Logf("Got S[%d]: %s", i, info.String()) } if len(srvtest.calls) != len(srvtest.expect) { t.Errorf("Server got wrong # calls, %d != %d", len(srvtest.calls), len(srvtest.expect)) return } for i := range srvtest.calls { if srvtest.calls[i].String() != srvtest.expect[i].String() { t.Errorf("Server hook %d wrong: %s != %s", i, srvtest.calls[i].String(), srvtest.expect[i].String()) } } if len(clitest.calls) != len(clitest.expect) { t.Errorf("Client got wrong # calls, %d != %d", len(clitest.calls), len(clitest.expect)) return } for i := range clitest.calls { if clitest.calls[i].String() != clitest.expect[i].String() { t.Errorf("Server hook %d wrong: %s != %s", i, clitest.calls[i].String(), clitest.expect[i].String()) } } }