// PrepareSockets sets up the ZMQ sockets through which the kernel will communicate. func PrepareSockets(connInfo ConnectionInfo) (SocketGroup, error) { // Initialize the Socket Group. context, sg, err := createSockets() if err != nil { return sg, errors.Wrap(err, "Could not initialize context and Socket Group") } // Bind the sockets. address := fmt.Sprintf("%v://%v:%%v", connInfo.Transport, connInfo.IP) sg.ShellSocket.Bind(fmt.Sprintf(address, connInfo.ShellPort)) sg.ControlSocket.Bind(fmt.Sprintf(address, connInfo.ControlPort)) sg.StdinSocket.Bind(fmt.Sprintf(address, connInfo.StdinPort)) sg.IOPubSocket.Bind(fmt.Sprintf(address, connInfo.IOPubPort)) // Message signing key sg.Key = []byte(connInfo.Key) // Start the heartbeat device HBSocket, err := context.NewSocket(zmq.REP) if err != nil { return sg, errors.Wrap(err, "Could not get the Heartbeat device socket") } HBSocket.Bind(fmt.Sprintf(address, connInfo.HBPort)) go zmq.Device(zmq.FORWARDER, HBSocket, HBSocket) return sg, nil }
//--------------------------------------------------------------------------------------------------------------------- // // AT 용 ZMQ 프록시 서버 앱이다. // //--------------------------------------------------------------------------------------------------------------------- func main() { fmt.Println( "Proxy Start..." ) zmqContext, _ := zmq.NewContext() defer zmqContext.Close() sub, _ := zmqContext.NewSocket(zmq.SUB) defer sub.Close() pub, _ := zmqContext.NewSocket(zmq.PUB) defer pub.Close() // sub.Connect( "ipc:///tmp/at_frame_sub" ) // pub.Connect( "ipc:///tmp/at_frame_pub" ) pub.Bind( AF_ZMQ_PROXY_XPUB ) sub.Bind( AF_ZMQ_PROXY_XSUB ) sub.SetSubscribe("") zmq.Device(zmq.FORWARDER, sub, pub ) // for { // message, _ := sub.Recv(0) // fmt.Println( "Proxy Read Ok" ); // pub.Send(message, 0) // } }
func main() { context, _ := zmq.NewContext() defer context.Close() // Socket facing clients frontend, _ := context.NewSocket(zmq.ROUTER) defer frontend.Close() frontend.Bind("tcp://*:5559") // Socket facing services backend, _ := context.NewSocket(zmq.DEALER) defer backend.Close() backend.Bind("tcp://*:5560") // Start built-in device zmq.Device(zmq.QUEUE, frontend, backend) // We never get here... }
// PrepareSockets sets up the ZMQ sockets through which the kernel will communicate. func PrepareSockets(conn_info ConnectionInfo) (sg SocketGroup) { context, _ := zmq.NewContext() sg.Shell_socket, _ = context.NewSocket(zmq.ROUTER) sg.Control_socket, _ = context.NewSocket(zmq.ROUTER) sg.Stdin_socket, _ = context.NewSocket(zmq.ROUTER) sg.IOPub_socket, _ = context.NewSocket(zmq.PUB) address := fmt.Sprintf("%v://%v:%%v", conn_info.Transport, conn_info.IP) sg.Shell_socket.Bind(fmt.Sprintf(address, conn_info.Shell_port)) sg.Control_socket.Bind(fmt.Sprintf(address, conn_info.Control_port)) sg.Stdin_socket.Bind(fmt.Sprintf(address, conn_info.Stdin_port)) sg.IOPub_socket.Bind(fmt.Sprintf(address, conn_info.IOPub_port)) // Message signing key sg.Key = []byte(conn_info.Key) // Start the heartbeat device HB_socket, _ := context.NewSocket(zmq.REP) HB_socket.Bind(fmt.Sprintf(address, conn_info.HB_port)) go zmq.Device(zmq.FORWARDER, HB_socket, HB_socket) return }
func builtinDevice(dev *DeviceContext) { var ( typ zmq.DeviceType back, front zmq.Socket err error ) switch dev.Type() { case "zmq_forwarder": typ = zmq.FORWARDER case "zmq_streamer": typ = zmq.STREAMER case "zmq_queue": typ = zmq.QUEUE default: panic(fmt.Sprintf("device has unknown type: %s.", dev.Type())) } back = dev.MustOpen("backend") front = dev.MustOpen("frontend") err = zmq.Device(typ, front, back) //err = zmq.Proxy( front, back, capture) if err != nil { } }
func main() { args := parseArgs() done := make(chan bool, 1) context, _ := zmq.NewContext() defer context.Close() for _, arg := range args { go func(arg Arguments) { in, _ := context.NewSocket(zmq.XSUB) out, _ := context.NewSocket(zmq.XPUB) defer in.Close() defer out.Close() in.Connect("ipc://" + arg.Src) out.Connect("ipc://" + arg.Dest) zmq.Device(zmq.FORWARDER, in, out) }(arg) } <-done }
func main() { // Launch pool of worker threads for i := 0; i != 5; i = i + 1 { go worker() } // Prepare our context and sockets context, _ := zmq.NewContext() defer context.Close() // Socket to talk to clients clients, _ := context.NewSocket(zmq.ROUTER) defer clients.Close() clients.Bind("tcp://*:5555") // Socket to talk to workers workers, _ := context.NewSocket(zmq.DEALER) defer workers.Close() workers.Bind("ipc://workers.ipc") // connect work threads to client threads via a queue zmq.Device(zmq.QUEUE, clients, workers) }
func (b *Forwarder) Run() error { return zmq.Device(zmq.FORWARDER, b.frontend, b.backend) }