// NewSocket allocates a new Socket. The Socket is the handle used to // access the underlying library. func NewSocket(d Domain, p Protocol) (*Socket, error) { var s Socket var err error s.proto = p s.dom = d switch p { case PUB: s.sock, err = pub.NewSocket() case SUB: s.sock, err = sub.NewSocket() case PUSH: s.sock, err = push.NewSocket() case PULL: s.sock, err = pull.NewSocket() case REQ: s.sock, err = req.NewSocket() case REP: s.sock, err = rep.NewSocket() case SURVEYOR: s.sock, err = surveyor.NewSocket() case RESPONDENT: s.sock, err = respondent.NewSocket() case PAIR: s.sock, err = pair.NewSocket() case BUS: s.sock, err = bus.NewSocket() default: err = mangos.ErrBadProto } if err != nil { return nil, err } switch d { case AF_SP: case AF_SP_RAW: err = s.sock.SetOption(mangos.OptionRaw, true) default: err = errBadDomain } if err != nil { s.sock.Close() return nil, err } // Compat mode sockets should timeout on send if we don't have any pipes if err = s.sock.SetOption(mangos.OptionWriteQLen, 0); err != nil { s.sock.Close() return nil, err } s.rto = -1 s.sto = -1 all.AddTransports(s.sock) return &s, nil }
func newEvtChannel(addr string) (mangos.Socket, error) { socket, err := sub.NewSocket() if err != nil { return nil, err } //if err := socket.SetOption(mangos.OptionRecvDeadline,time.Second * 30); err != nil { // socket.Close() // return nil,err //} //socket.AddTransport(ipc.NewTransport()) socket.AddTransport(tcp.NewTransport()) if err := socket.Dial(addr); err != nil { socket.Close() return nil, err } err = socket.SetOption(mangos.OptionSubscribe, []byte("")) if err != nil { return nil, err } return socket, nil }
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 (st *subTest) Init(t *testing.T, addr string) bool { var err error if st.Sock, err = sub.NewSocket(); err != nil { st.Errorf("NewSocket(): %v", err) return false } rv := st.T.Init(t, addr) // We have to subscribe to the START message! if !rv { return false } err = st.Sock.SetOption(mangos.OptionSubscribe, []byte("START")) if err != nil { st.Errorf("Failed subscription to START: %v", err) return false } err = st.Sock.SetOption(mangos.OptionSubscribe, []byte("END")) if err != nil { st.Errorf("Failed to subscribe to END: %v", err) return false } err = st.Sock.SetOption(mangos.OptionSubscribe, []byte("/rain")) if err != nil { st.Errorf("Failed subscribing to the rain: %v", err) return false } return true }
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 run(endpoint string, filter string, connect bool, ch chan *pubsub.Event) { sock, err := sub.NewSocket() if err != nil { log.Fatalln("sub.NewSocket error:", err) } sock.AddTransport(inproc.NewTransport()) sock.AddTransport(tcp.NewTransport()) defer sock.Close() if connect { err = sock.Dial(endpoint) } else { err = sock.Listen(endpoint) } if err != nil { log.Fatalln("sock connect failed:", err) } err = sock.SetOption(mangos.OptionSubscribe, []byte(filter)) if err != nil { log.Fatalln("sock SetOption failed:", err) } for { msg, e := sock.Recv() if e != nil { log.Fatal("error:", e) } event := ParseMsg(string(msg)) if event != nil { ch <- event } } }
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 (c *Context) Run(name string) { push, _ := push.NewSocket() push.AddTransport(tcp.NewTransport()) push.Dial("tcp://127.0.0.1:5006") pull, _ := sub.NewSocket() pull.AddTransport(tcp.NewTransport()) pull.Dial("tcp://127.0.0.1:5005") pull.SetOption(mangos.OptionSubscribe, []byte("")) for { var protocol [4][]byte bytes, _ := pull.Recv() msgpack.Unmarshal(bytes, &protocol) if string(protocol[1]) != "*" && string(protocol[1]) != name { continue } if string(protocol[2]) == "message" { var message [5][]byte msgpack.Unmarshal(protocol[3], &message) for _, f := range c.messages { result := f(Message{ string(message[0]), string(message[1]), string(message[2]), string(message[3]), string(message[4]), }) if result != "" { packed, _ := msgpack.Marshal([5]string{ string(message[0]), string(message[2]), string(message[1]), result, string(message[4]), }) output, _ := msgpack.Marshal([4]string{ name, "protocol." + string(message[0]), "message", string(packed), }) push.Send(output) } } } if string(protocol[2]) == "command" { var message [2]interface{} msgpack.Unmarshal(protocol[3], &message) var embed [5][]byte msgpack.Unmarshal([]byte(message[0].(string)), &embed) orig, _ := message[0].(string) line, _ := message[1].([]interface{})[0].(string) command := strings.SplitN(line, " ", 2) f := c.commands[strings.TrimPrefix(command[0], ".")] result := f(Command{ strings.TrimPrefix(command[0], "."), command[1], Message{ string(embed[0]), string(embed[1]), string(embed[2]), string(embed[3]), string(embed[4]), }, }) if result != "" { new_messages := message[1].([]interface{}) new_messages = append([]interface{}{result}, new_messages[1:]...) packed, _ := msgpack.Marshal([2]interface{}{ orig, new_messages, }) output, _ := msgpack.Marshal([4]string{ name, string(protocol[0]), "response", string(packed), }) push.Send(output) } } } }