Exemple #1
0
func main() {
	frontend, _ := zmq.NewSocket(zmq.ROUTER)
	backend, _ := zmq.NewSocket(zmq.ROUTER)
	defer frontend.Close()
	defer backend.Close()
	frontend.Bind("tcp://*:5555") //  For clients
	backend.Bind("tcp://*:5556")  //  For workers

	//  Queue of available workers
	workers := make([]string, 0)

	poller1 := zmq.NewPoller()
	poller1.Add(backend, zmq.POLLIN)
	poller2 := zmq.NewPoller()
	poller2.Add(backend, zmq.POLLIN)
	poller2.Add(frontend, zmq.POLLIN)

	//  The body of this example is exactly the same as lbbroker2.
LOOP:
	for {
		//  Poll frontend only if we have available workers
		var sockets []zmq.Polled
		var err error
		if len(workers) > 0 {
			sockets, err = poller2.Poll(-1)
		} else {
			sockets, err = poller1.Poll(-1)
		}
		if err != nil {
			break //  Interrupted
		}
		for _, socket := range sockets {
			switch s := socket.Socket; s {
			case backend: //  Handle worker activity on backend
				//  Use worker identity for load-balancing
				msg, err := s.RecvMessage(0)
				if err != nil {
					break LOOP //  Interrupted
				}
				var identity string
				identity, msg = unwrap(msg)
				workers = append(workers, identity)

				//  Forward message to client if it's not a READY
				if msg[0] != WORKER_READY {
					frontend.SendMessage(msg)
				}

			case frontend:
				//  Get client request, route to first available worker
				msg, err := s.RecvMessage(0)
				if err == nil {
					backend.SendMessage(workers[0], "", msg)
					workers = workers[1:]
				}
			}
		}
	}
}
Exemple #2
0
//  Connect or reconnect to broker.
func (mdcli *Mdcli) ConnectToBroker() (err error) {
	if mdcli.client != nil {
		mdcli.client.Close()
		mdcli.client = nil
	}
	mdcli.client, err = zmq.NewSocket(zmq.REQ)
	if err != nil {
		if mdcli.verbose {
			log.Println("E: ConnectToBroker() creating socket failed")
		}
		return
	}
	mdcli.poller = zmq.NewPoller()
	mdcli.poller.Add(mdcli.client, zmq.POLLIN)

	if mdcli.verbose {
		log.Printf("I: connecting to broker at %s...", mdcli.broker)
	}
	err = mdcli.client.Connect(mdcli.broker)
	if err != nil && mdcli.verbose {
		log.Println("E: ConnectToBroker() failed to connect to broker", mdcli.broker)
	}

	return
}
Exemple #3
0
func main() {

	//  Connect to task ventilator
	receiver, _ := zmq.NewSocket(zmq.PULL)
	defer receiver.Close()
	receiver.Connect("tcp://localhost:5557")

	//  Connect to weather server
	subscriber, _ := zmq.NewSocket(zmq.SUB)
	defer subscriber.Close()
	subscriber.Connect("tcp://localhost:5556")
	subscriber.SetSubscribe("10001 ")

	//  Initialize poll set
	poller := zmq.NewPoller()
	poller.Add(receiver, zmq.POLLIN)
	poller.Add(subscriber, zmq.POLLIN)
	//  Process messages from both sockets
	for {
		sockets, _ := poller.Poll(-1)
		for _, socket := range sockets {
			switch s := socket.Socket; s {
			case receiver:
				task, _ := s.Recv(0)
				//  Process task
				fmt.Println("Got task:", task)
			case subscriber:
				update, _ := s.Recv(0)
				//  Process weather update
				fmt.Println("Got weather update:", update)
			}
		}
	}
}
Exemple #4
0
func (k *kernelRunner) loop() error {

	poller := zmq.NewPoller()
	poller.Add(k.sockets.Shell, zmq.POLLIN)
	poller.Add(k.sockets.Stdin, zmq.POLLIN)
	poller.Add(k.sockets.Control, zmq.POLLIN)

	for !k.shutdown {
		polled, err := poller.Poll(-1)
		if err != nil {
			return fmt.Errorf("poll failed: %v", err)
		}
		for _, polled := range polled {
			msg, ids, err := k.readMessage(polled.Socket)
			if err != nil {
				return fmt.Errorf("reading message: %v", err)
			}
			switch polled.Socket {
			case k.sockets.Shell, k.sockets.Control:
				err := k.handleShellOrControl(msg, ids, polled.Socket)
				if err != nil {
					log.Printf("handling request: %v", err)
				}
			case k.sockets.Stdin:
				if err := k.handleStdin(msg, ids); err != nil {
					log.Printf("handling stdin: %v", err)
				}
			}
			if k.shutdown {
				break
			}
		}
	}
	return nil
}
Exemple #5
0
func (i *Incoming) listen() {
	poller := zmq4.NewPoller()
	poller.Add(i.skt, zmq4.POLLIN)

	for {
		i.m.Lock()
		if i.stopped {
			i.m.Unlock()

			return
		}
		sockets, err := poller.Poll(100 * time.Millisecond)
		if err != nil {
			continue
		}
		for range sockets {

			msg, err := i.skt.RecvMessage(0)
			if err == nil {
				i.in.Add(Message{i.addr, msg})
			}
		}
		i.m.Unlock()
	}
}
// ZmqPubSubProxy Implements a many-to-many device on a zmq PUB-SUB connection
func ZmqPubSubProxy(host string, portIn int, portOut int, logger *log.Logger) {
	xsub, _ := zmq.NewSocket(zmq.SUB)
	xpub, _ := zmq.NewSocket(zmq.PUB)

	defer xsub.Close()
	defer xpub.Close()

	addrIn := fmt.Sprintf("tcp://*:%d", portIn)
	addrOut := fmt.Sprintf("tcp://*:%d", portOut)

	logger.Println("ZMQ XSUB on", addrIn)
	xsub.Bind(addrIn)
	xsub.SetSubscribe("")

	logger.Println("ZMQ XPUB on", addrOut)
	xpub.Bind(addrOut)

	poller := zmq.NewPoller()
	poller.Add(xsub, zmq.POLLIN)

	for {
		// keep looping
		sockets, _ := poller.Poll(5 * time.Second)
		for _, socket := range sockets {
			switch s := socket.Socket; s {
			case xsub:
				ZmqSendMulti(xpub, ZmqRecvMulti(s))
			}
		}
	}
}
Exemple #7
0
func (pcli *PigatoClient) ConnectToBroker() (err error) {
	if pcli.ctx.client != nil {
		pcli.ctx.client.Close()
		pcli.ctx.client = nil
	}
	pcli.ctx.client, err = zmq.NewSocket(zmq.DEALER)
	pcli.identity = randSeq()
	pcli.ctx.client.SetIdentity(pcli.identity)

	if err != nil {
		if pcli.verbose {
			log.Println("E: ConnectToBroker() creating socket failed")
		}
		return
	}
	pcli.ctx.poller = zmq.NewPoller()
	pcli.ctx.poller.Add(pcli.ctx.client, zmq.POLLIN)

	if pcli.verbose {
		log.Printf("I: connecting to broker at %s...", pcli.broker)
	}
	err = pcli.ctx.client.Connect(pcli.broker)
	if err != nil && pcli.verbose {
		log.Println("E: ConnectToBroker() failed to connect to broker", pcli.broker)
	}

	return
}
Exemple #8
0
// run zmq event loop
func zmqMsgHandler() {
	subscriber := setupSocket()
	defer subscriber.Close()

	poller := zmq.NewPoller()
	poller.Add(subscriber, zmq.POLLIN)

	for !interrupted {
		sockets, _ := poller.Poll(1 * time.Second)
		for _, socket := range sockets {
			s := socket.Socket
			msg, _ := s.RecvMessage(0)
			if len(msg) != 2 {
				logError("got invalid message: %v", msg)
				continue
			}
			var app_env, data = msg[0], msg[1]
			var msgType int
			if strings.Contains(data, "total_time") {
				msgType = perfMsg
			} else {
				msgType = errorMsg
			}
			zmq_channel <- &ZmqMsg{msgType: msgType, app_env: app_env, data: data}
		}
	}
}
Exemple #9
0
func main() {
	//  Initialize polling
	poller = zmq.NewPoller()

	//  Prepare our frontend sockets
	frontend, _ := zmq.NewSocket(zmq.ROUTER)
	defer frontend.Close()
	address = "tcp://*:5559"
	frontend.Bind(address)
	//  Initialize frontend poll set
	poller.Add(frontend, zmq.POLLIN)

	//  Load Service List
	getServiceList()
	//Make sure all services in list are closed at end of execution
	for _, service := range services {
		defer service.Backend.Close()
	}
	//  Initialize polling and binding to addresses
	initializeServices()

	fmt.Println("Broker at ", address, " waiting for connection...")
	//  List available services
	listServices()

	//  Switch messages between sockets
	for {
		sockets, _ := poller.Poll(-1)
		for _, socket := range sockets {
			switch s := socket.Socket; s {
			case frontend:
				backend := serveFrontend(s)
				//  (For newly registered services)
				//  Make sure socket is closed at end of execution
				if backend != nil {
					defer backend.Close()
					backend = nil
				}

			//  All services fall under default
			default:
				//fmt.Println("Receiving message from service...")
				for {
					msg, _ := s.Recv(0)
					//fmt.Printf("\tIn-->%s\n", msg)
					if more, _ := s.GetRcvmore(); more {
						//fmt.Printf("\tForwarding to client: %s\n", msg)
						frontend.Send(msg, zmq.SNDMORE)
					} else {
						//fmt.Printf("\tForwarding to client: %s\n", msg)
						frontend.Send(msg, 0)
						//fmt.Println("\tDone")
						break
					}
				} //end for (receive message from service)
			} //end switch (sockets polled)
		} //end for(sockets polled)
	} //end for(forever)
}
Exemple #10
0
func main() {

	//config := ReadConfig("")
	//  Prepare our sockets
	frontend, _ := zmq.NewSocket(zmq.ROUTER)
	defer frontend.Close()
	backend, _ := zmq.NewSocket(zmq.DEALER)
	defer backend.Close()
	frontend.Bind(frontend_url_port)
	backend.Bind(backend_url_port)

	//  Initialize poll set
	poller := zmq.NewPoller()
	poller.Add(frontend, zmq.POLLIN)
	poller.Add(backend, zmq.POLLIN)

	log.Println("0MQ broker started!")
	log.Println("Frontend protocl/url/port:", frontend_url_port)
	log.Println("Backend protocol/url/port:", backend_url_port)

	//  Switch messages between sockets
	for {
		sockets, _ := poller.Poll(-1)
		for _, socket := range sockets {
			switch s := socket.Socket; s {
			case frontend:
				for {
					msg, _ := s.Recv(0)
					if more, _ := s.GetRcvmore(); more {
						backend.Send(msg, zmq.SNDMORE)
					} else {
						backend.Send(msg, 0)
						break
					}
					if debug {
						log.Printf("relayed request: [%s]\n", msg)
					}

				}
			case backend:
				for {
					msg, _ := s.Recv(0)
					if more, _ := s.GetRcvmore(); more {
						frontend.Send(msg, zmq.SNDMORE)
					} else {
						frontend.Send(msg, 0)
						break
					}
					if debug {
						log.Printf("relayed reply: [%s]\n", msg)
					}
				}

			}
		}
	}
	//log.Fatalln("Proxy interrupted:", err)
}
Exemple #11
0
func flcliapi_agent() {

	agent := agent_new()

	poller := zmq.NewPoller()
	poller.Add(agent.pipe, zmq.POLLIN)
	poller.Add(agent.router, zmq.POLLIN)
	for {
		//  Calculate tickless timer, up to 1 hour
		tickless := time.Now().Add(time.Hour)
		if len(agent.request) > 0 && tickless.After(agent.expires) {
			tickless = agent.expires
		}
		for key := range agent.servers {
			tickless = agent.servers[key].tickless(tickless)
		}

		polled, err := poller.Poll(tickless.Sub(time.Now()))
		if err != nil {
			break //  Context has been shut down
		}

		for _, item := range polled {
			switch item.Socket {
			case agent.pipe:
				agent.control_message()
			case agent.router:
				agent.router_message()
			}
		}

		//  If we're processing a request, dispatch to next server
		if len(agent.request) > 0 {
			if time.Now().After(agent.expires) {
				//  Request expired, kill it
				agent.pipe.SendMessage("FAILED")
				agent.request = agent.request[0:0]
			} else {
				//  Find server to talk to, remove any expired ones
				for len(agent.actives) > 0 {
					server := agent.actives[0]
					if time.Now().After(server.expires) {
						agent.actives = agent.actives[1:]
						server.alive = false
					} else {
						agent.router.SendMessage(server.endpoint, agent.request)
						break
					}
				}
			}
		}
		//  --(Disconnect and delete any expired servers)--
		//  Send heartbeats to idle servers if needed
		for key := range agent.servers {
			agent.servers[key].ping(agent.router)
		}
	}
}
Exemple #12
0
func main() {
	frontend, _ := zmq.NewSocket(zmq.SUB)
	frontend.Bind("tcp://*:5557")
	backend, _ := zmq.NewSocket(zmq.XPUB)
	backend.Bind("tcp://*:5558")

	//  Subscribe to every single topic from publisher
	frontend.SetSubscribe("")

	//  Store last instance of each topic in a cache
	cache := make(map[string]string)

	//  We route topic updates from frontend to backend, and
	//  we handle subscriptions by sending whatever we cached,
	//  if anything:
	poller := zmq.NewPoller()
	poller.Add(frontend, zmq.POLLIN)
	poller.Add(backend, zmq.POLLIN)
LOOP:
	for {
		polled, err := poller.Poll(1000 * time.Millisecond)
		if err != nil {
			break //  Interrupted
		}

		for _, item := range polled {
			switch socket := item.Socket; socket {
			case frontend:
				//  Any new topic data we cache and then forward
				msg, err := frontend.RecvMessage(0)
				if err != nil {
					break LOOP
				}
				cache[msg[0]] = msg[1]
				backend.SendMessage(msg)
			case backend:
				//  When we get a new subscription we pull data from the cache:
				msg, err := backend.RecvMessage(0)
				if err != nil {
					break LOOP
				}
				frame := msg[0]
				//  Event is one byte 0=unsub or 1=sub, followed by topic
				if frame[0] == 1 {
					topic := frame[1:]
					fmt.Println("Sending cached topic", topic)
					previous, ok := cache[topic]
					if ok {
						backend.SendMessage(topic, previous)
					}
				}
			}
		}
	}
}
Exemple #13
0
func main() {
	verbose := false
	if len(os.Args) > 1 && os.Args[1] == "-v" {
		verbose = true
	}

	broker, _ := NewBroker(verbose)
	broker.Bind("tcp://*:5555")

	poller := zmq.NewPoller()
	poller.Add(broker.socket, zmq.POLLIN)

	//  Get and process messages forever or until interrupted
	for {
		polled, err := poller.Poll(HEARTBEAT_INTERVAL)
		if err != nil {
			break //  Interrupted
		}

		//  Process next input message, if any
		if len(polled) > 0 {
			msg, err := broker.socket.RecvMessage(0)
			if err != nil {
				break //  Interrupted
			}
			if broker.verbose {
				log.Printf("I: received message: %q\n", msg)
			}
			sender, msg := popStr(msg)
			_, msg = popStr(msg)
			header, msg := popStr(msg)

			switch header {
			case mdapi.MDPC_CLIENT:
				broker.ClientMsg(sender, msg)
			case mdapi.MDPW_WORKER:
				broker.WorkerMsg(sender, msg)
			default:
				log.Printf("E: invalid message: %q\n", msg)
			}
		}
		//  Disconnect and delete any expired workers
		//  Send heartbeats to idle workers if needed
		if time.Now().After(broker.heartbeat_at) {
			broker.Purge()
			for _, worker := range broker.waiting {
				worker.Send(mdapi.MDPW_HEARTBEAT, "", []string{})
			}
			broker.heartbeat_at = time.Now().Add(HEARTBEAT_INTERVAL)
		}
	}
	log.Println("W: interrupt received, shutting down...")
}
Exemple #14
0
func request(t string, m string) (r string, err error) {
	sck, err := newSocket(zmq4.REQ, 5555)
	defer sck.Close()

	sck.SetLinger(0)

	if err != nil {
		err = ErrConnectionFailed
		return
	}

	if _, err = sck.Send(t+" "+m, 0); err != nil {
		err = ErrConnectionFailed
		return
	}

	poller := zmq4.NewPoller()
	poller.Add(sck, zmq4.POLLIN)

	sockets, err := poller.Poll(requestTimeout)

	if err != nil {
		err = ErrConnectionFailed
		return
	}

	if len(sockets) < 1 {
		err = ErrConnectionFailed
		return
	}

	r, err = sck.Recv(0)

	if err != nil {
		err = ErrConnectionFailed
		return
	}

	if strings.Contains(r, "ERROR") {
		parts := strings.Split(r, "|")

		if len(parts) > 1 {
			err = errors.New(parts[1])
		} else {
			err = errors.New("Unknown")
		}

		return
	}

	return
}
Exemple #15
0
func s_worker_socket() (*zmq.Socket, *zmq.Poller) {
	worker, _ := zmq.NewSocket(zmq.DEALER)
	worker.Connect("tcp://localhost:5556")

	//  Tell queue we're ready for work
	fmt.Println("I: worker ready")
	worker.Send(PPP_READY, 0)

	poller := zmq.NewPoller()
	poller.Add(worker, zmq.POLLIN)

	return worker, poller
}
Exemple #16
0
/* {{{ func (m *MQPool) Get(key string) (mq *msgqueue, err error) {
 * 获取相关key的队列
 */
func (m *MQPool) Get(key string) (mq *msgqueue, err error) {
	// hash key
	hk := fmt.Sprintf("%x", md5.Sum([]byte(key)))
	now := time.Now()
	expire := now.Add(m.life)
	if _, ok := m.Pool[hk]; ok {
		mq = m.Pool[hk]
	} else {
		if len(m.Pool) >= m.max { //达到最大数,清理
			for k, queue := range m.Pool {
				if now.After(queue.expire) { //过期,死亡
					m.remove(k)
				}
			}
		}
		if len(m.Pool) < m.max {
			mq = &msgqueue{
				pusher:  NewSocket(zmq.DEALER, 1000),
				queuer:  NewSocket(zmq.DEALER, 1000),
				iPoller: zmq.NewPoller(), //in
				oPoller: zmq.NewPoller(), //out
				expire:  expire,
			}
			//建立连接
			mq.pusher.Bind(fmt.Sprint("inproc://", hk))
			mq.queuer.Connect(fmt.Sprint("inproc://", hk))
			mq.oPoller.Add(mq.pusher.soc, zmq.POLLOUT)
			mq.iPoller.Add(mq.queuer.soc, zmq.POLLIN)
			m.Pool[hk] = mq
		} else {
			// pool 满了, 婉拒
			err = fmt.Errorf("pool space full: %d", m.max)
		}
	}
	if err == nil {
		mq.expire = expire
	}
	return
}
Exemple #17
0
func main() {
	//  First argument is this broker's name
	//  Other arguments are our peers' names
	//
	if len(os.Args) < 2 {
		fmt.Println("syntax: peering1 me {you}...")
		os.Exit(1)
	}
	self := os.Args[1]
	fmt.Printf("I: preparing broker at %s...\n", self)
	rand.Seed(time.Now().UnixNano())

	//  Bind state backend to endpoint
	statebe, _ := zmq.NewSocket(zmq.PUB)
	defer statebe.Close()
	statebe.Bind("ipc://" + self + "-state.ipc")

	//  Connect statefe to all peers
	statefe, _ := zmq.NewSocket(zmq.SUB)
	defer statefe.Close()
	statefe.SetSubscribe("")
	for _, peer := range os.Args[2:] {
		fmt.Printf("I: connecting to state backend at '%s'\n", peer)
		statefe.Connect("ipc://" + peer + "-state.ipc")
	}

	//  The main loop sends out status messages to peers, and collects
	//  status messages back from peers. The zmq_poll timeout defines
	//  our own heartbeat:

	poller := zmq.NewPoller()
	poller.Add(statefe, zmq.POLLIN)
	for {
		//  Poll for activity, or 1 second timeout
		sockets, err := poller.Poll(time.Second)
		if err != nil {
			break
		}

		//  Handle incoming status messages
		if len(sockets) == 1 {
			msg, _ := statefe.RecvMessage(0)
			peer_name := msg[0]
			available := msg[1]
			fmt.Printf("%s - %s workers free\n", peer_name, available)
		} else {
			statebe.SendMessage(self, rand.Intn(10))
		}
	}
}
Exemple #18
0
func New(addr string) (*Router, error) {
	ctx, err := zmq.NewContext()
	if err != nil {
		return nil, err
	}
	router := &Router{
		ctx:       ctx,
		receivers: make(map[*zmq.Socket]*receiver),
		poller:    zmq.NewPoller(),
		addr:      addr,
	}

	return router, nil
}
Exemple #19
0
func main() {
	//  Socket to receive messages on
	receiver, _ := zmq.NewSocket(zmq.PULL)
	defer receiver.Close()
	receiver.Connect("tcp://localhost:5557")

	//  Socket to send messages to
	sender, _ := zmq.NewSocket(zmq.PUSH)
	defer sender.Close()
	sender.Connect("tcp://localhost:5558")

	//  Socket for control input
	controller, _ := zmq.NewSocket(zmq.SUB)
	defer controller.Close()
	controller.Connect("tcp://localhost:5559")
	controller.SetSubscribe("")

	//  Process messages from receiver and controller
	poller := zmq.NewPoller()
	poller.Add(receiver, zmq.POLLIN)
	poller.Add(controller, zmq.POLLIN)
	//  Process messages from both sockets
LOOP:
	for {
		sockets, _ := poller.Poll(-1)
		for _, socket := range sockets {
			switch s := socket.Socket; s {
			case receiver:
				msg, _ := s.Recv(0)

				//  Do the work
				t, _ := strconv.Atoi(msg)
				time.Sleep(time.Duration(t) * time.Millisecond)

				//  Send results to sink
				sender.Send(msg, 0)

				//  Simple progress indicator for the viewer
				fmt.Printf(".")
			case controller:
				//  Any controller command acts as 'KILL'
				break LOOP //  Exit loop
			}
		}
	}
	fmt.Println()
}
Exemple #20
0
func BrokerStart(verbose bool) {
	broker, _ := NewBroker(verbose)
	broker.Bind("tcp://*:55555")

	poller := zmq.NewPoller()
	poller.Add(broker.socket, zmq.POLLIN)

	//  Get and process messages forever or until interrupted
	for {
		polled, err := poller.Poll(HEARTBEAT_INTERVAL)
		if err != nil {
			break //  Interrupted
		}

		//  Process next input message, if any
		if len(polled) > 0 {
			msg, err := broker.socket.RecvMessage(0)
			if err != nil {
				break //  Interrupted
			}
			if broker.verbose {
				log.Printf("I: received message: %q\n", msg)
			}
			sender, msg := pgtlib.PopStr(msg)
			header, msg := pgtlib.PopStr(msg)

			switch header {
			case pgtlib.C_CLIENT:
				broker.ClientMsg(sender, msg)
			case pgtlib.W_WORKER:
				broker.WorkerMsg(sender, msg)
			default:
				log.Printf("E: invalid message (sender=%s, header=%s): %q\n", sender, header, msg)
			}
		}
		//  Disconnect and delete any expired workers
		//  Send heartbeats to idle workers if needed

		if time.Now().After(broker.heartbeat_at) {
			broker.Purge()
			for _, worker := range broker.waiting {
				worker.Send(pgtlib.W_HEARTBEAT, []string{})
			}
			broker.heartbeat_at = time.Now().Add(HEARTBEAT_INTERVAL)
		}
	}
}
Exemple #21
0
func (iface *Intface) agent() {
	//  Create agent instance to pass around
	agent := new_agent()

	//  Send first beacon immediately
	ping_at := time.Now()

	poller := zmq.NewPoller()
	poller.Add(agent.pipe, zmq.POLLIN)
	poller.Add(agent.udp, zmq.POLLIN)

	bcast := &net.UDPAddr{Port: PING_PORT_NUMBER, IP: net.IPv4bcast}
	for {
		timeout := ping_at.Add(time.Millisecond).Sub(time.Now())
		if timeout < 0 {
			timeout = 0
		}
		polled, err := poller.Poll(timeout)
		if err != nil {
			break
		}

		for _, item := range polled {
			switch socket := item.Socket; socket {
			case agent.pipe:
				//  If we had activity on the pipe, go handle the control
				//  message. Current code never sends control messages.
				agent.control_message()

			case agent.udp:
				//  If we had input on the UDP socket, go process that
				agent.handle_beacon()
			}
		}

		//  If we passed the 1-second mark, broadcast our beacon
		now := time.Now()
		if now.After(ping_at) {
			agent.conn.WriteTo(agent.uuid_bytes, bcast)
			ping_at = now.Add(PING_INTERVAL)
		}
		//  Delete and report any expired peers
		for _, peer := range agent.peers {
			agent.reap_peer(peer)
		}
	}
}
Exemple #22
0
/* {{{ func RequestAndReply(soc *zmq.Socket, msg interface{}) (reply []string, err error) {
 * 支持超时时间,但要注意如果一个socket失败之后,因为req严格同步,连接池模式下这个socket最好销毁
 */
func RequestAndReply(soc *zmq.Socket, timeout time.Duration, msg ...interface{}) (reply []string, err error) {
	poller := zmq.NewPoller()
	poller.Add(soc, zmq.POLLIN)
	if _, err := soc.SendMessage(msg...); err != nil {
		return nil, err
	}

	if sockets, err := poller.Poll(timeout); err != nil {
		return nil, err
	} else if len(sockets) == 1 {
		return soc.RecvMessage(zmq.DONTWAIT)
	} else {
		return nil, fmt.Errorf("time out!")
	}

	return
}
Exemple #23
0
func try_request(endpoint string, request []string) (reply []string, err error) {
	fmt.Printf("I: trying echo service at %s...\n", endpoint)
	client, _ := zmq.NewSocket(zmq.REQ)
	client.Connect(endpoint)

	//  Send request, wait safely for reply
	client.SendMessage(request)
	poller := zmq.NewPoller()
	poller.Add(client, zmq.POLLIN)
	polled, err := poller.Poll(REQUEST_TIMEOUT)
	reply = []string{}
	if len(polled) == 1 {
		reply, err = client.RecvMessage(0)
	} else {
		err = errors.New("Time out")
	}
	return
}
Exemple #24
0
func openPorts() {
	// Data
	dataports := strings.Split(*dataEndpoint, ",")
	if len(dataports) == 0 {
		flag.Usage()
		os.Exit(1)
	}

	dataPortsArray = []*zmq.Socket{}
	poller = zmq.NewPoller()

	for i, endpoint := range dataports {
		endpoint = strings.TrimSpace(endpoint)
		log.Printf("Connecting DATA[%v]=%s", i, endpoint)
		port, err := utils.CreateInputPort(fmt.Sprintf("context.data-%s", i), endpoint, inCh)
		utils.AssertError(err)

		dataPortsArray = append(dataPortsArray, port)
		poller.Add(port, zmq.POLLIN)
	}

	// Template
	tmplPort, err = utils.CreateInputPort("context.tmpl", *templateEndpoint, nil)
	utils.AssertError(err)

	// Update
	if *updatedEndpoint != "" {
		updPort, err = utils.CreateOutputPort("context.update", *updatedEndpoint, outCh)
		utils.AssertError(err)
	}

	// Match
	if *matchedEndpoint != "" {
		matchPort, err = utils.CreateOutputPort("context.match", *matchedEndpoint, outCh)
		utils.AssertError(err)
	}

	// Error
	if *errorEndpoint != "" {
		errPort, err = utils.CreateOutputPort("context.err", *errorEndpoint, nil)
		utils.AssertError(err)
	}
}
Exemple #25
0
/* {{{ func connectPub() (*zmq.Socket, *zmq.Poller)
 *  Helper function that returns a new configured socket
 *  connected to the Paranoid Pirate queue
 */
func (w *OmqWorker) connectPub() (*zmq.Socket, *zmq.Poller) {
	soc, _ := zmq.NewSocket(zmq.SUB)

	//get identity
	identity, _ := utils.GetLocalIdentity(fmt.Sprint(basePort)) //防止同一台机器得到相同的identity
	soc.SetIdentity(identity)

	soc.SetRcvhwm(50000)
	soc.SetSubscribe("")

	remotePub := fmt.Sprint("tcp://", pubAddr, ":", remotePort+1)
	soc.Connect(remotePub)
	w.Debug("identity(%s) connect remote pub: %v", identity, remotePub)

	poller := zmq.NewPoller()
	poller.Add(soc, zmq.POLLIN)

	return soc, poller
}
// Run method: Listen to keep-alive messages sent via ZeroMQ and forward them to a channel
func (handler *JobqueueKeepAliveHandler) Run(keepalives chan<- KeepAlive) {
	if handler.Logger == nil {
		handler.Logger = log.New(os.Stdout, "[KeepAliveHandler] ", log.Ldate|log.Ltime)
	}
	receiver, _ := zmq.NewSocket(zmq.SUB)
	defer receiver.Close()

	addr := fmt.Sprintf("tcp://%s:%d", handler.Host, handler.Port)
	handler.Logger.Println("ZMQ SUB on", addr, handler.Topic)
	receiver.Connect(addr)
	receiver.SetSubscribe(handler.Topic)

	poller := zmq.NewPoller()
	poller.Add(receiver, zmq.POLLIN)

	// shut down cleanly when the keep-alive channel is closed
	defer func() {
		if r := recover(); r != nil {
			handler.Logger.Println("Recovering from panic (likely: trying to send msg on closed keep-alive channel)", r)
		}
	}()
	// at the end, close the channel to indicate that's all the work we have.
	defer close(keepalives)

	handler.Logger.Println("waiting for message for topic", handler.Topic)
	for {
		sockets, _ := poller.Poll(5 * time.Second)
		for _, socket := range sockets {
			switch s := socket.Socket; s {
			case receiver:
				msg := wpmutils.ZmqRecvMulti(s)
				var keepalive KeepAlive
				err := json.Unmarshal([]byte(msg[1]), &keepalive)
				if err != nil {
					handler.Logger.Println("Error decoding json string:", err)
					continue
				}
				//log.Println("[KeepAliveHandler] sending to channel ", keepalive)
				keepalives <- keepalive
			}
		}
	}
}
Exemple #27
0
func main() {
	//  Prepare our sockets
	frontend, _ := zmq.NewSocket(zmq.ROUTER)
	defer frontend.Close()
	backend, _ := zmq.NewSocket(zmq.DEALER)
	defer backend.Close()
	frontend.Bind("tcp://*:5559")
	backend.Bind("tcp://*:5560")

	//  Initialize poll set
	poller := zmq.NewPoller()
	poller.Add(frontend, zmq.POLLIN)
	poller.Add(backend, zmq.POLLIN)

	//  Switch messages between sockets
	for {
		sockets, _ := poller.Poll(-1)
		for _, socket := range sockets {
			switch s := socket.Socket; s {
			case frontend:
				for {
					msg, _ := s.Recv(0)
					if more, _ := s.GetRcvmore(); more {
						backend.Send(msg, zmq.SNDMORE)
					} else {
						backend.Send(msg, 0)
						break
					}
				}
			case backend:
				for {
					msg, _ := s.Recv(0)
					if more, _ := s.GetRcvmore(); more {
						frontend.Send(msg, zmq.SNDMORE)
					} else {
						frontend.Send(msg, 0)
						break
					}
				}
			}
		}
	}
}
Exemple #28
0
func client_task(i int) {
	client, _ := zmq.NewSocket(zmq.REQ)
	defer client.Close()
	client.Connect("ipc://" + self + "-localfe.ipc")
	monitor, _ := zmq.NewSocket(zmq.PUSH)
	defer monitor.Close()
	monitor.Connect("ipc://" + self + "-monitor.ipc")

	poller := zmq.NewPoller()
	poller.Add(client, zmq.POLLIN)
	for {
		time.Sleep(time.Duration(rand.Intn(5000)) * time.Millisecond)
		for burst := rand.Intn(15); burst > 0; burst-- {
			task_id := fmt.Sprintf("%04X-%s-%d", rand.Intn(0x10000), self, i)

			//  Send request with random hex ID
			client.Send(task_id, 0)

			//  Wait max ten seconds for a reply, then complain
			sockets, err := poller.Poll(10 * time.Second)
			if err != nil {
				break //  Interrupted
			}

			if len(sockets) == 1 {
				reply, err := client.Recv(0)
				if err != nil {
					break //  Interrupted
				}
				//  Worker is supposed to answer us with our task id
				id := strings.Fields(reply)[0]
				if id != task_id {
					panic("id != task_id")
				}
				monitor.Send(reply, 0)
			} else {
				monitor.Send("E: CLIENT EXIT - lost task "+task_id, 0)
				return
			}
		}
	}
}
Exemple #29
0
//  Connect or reconnect to broker.
func (mdwrk *Mdwrk) ConnectToBroker() (err error) {
	if mdwrk.worker != nil {
		mdwrk.worker.Close()
		mdwrk.worker = nil
	}
	mdwrk.worker, err = zmq.NewSocket(zmq.DEALER)
	err = mdwrk.worker.Connect(mdwrk.broker)
	if mdwrk.verbose {
		log.Printf("I: connecting to broker at %s...\n", mdwrk.broker)
	}
	mdwrk.poller = zmq.NewPoller()
	mdwrk.poller.Add(mdwrk.worker, zmq.POLLIN)

	//  Register service with broker
	err = mdwrk.SendToBroker(MDPW_READY, mdwrk.service, []string{})

	//  If liveness hits zero, queue is considered disconnected
	mdwrk.liveness = heartbeat_liveness
	mdwrk.heartbeat_at = time.Now().Add(mdwrk.heartbeat)

	return
}
func (i *Incoming) listen() {
	poller := zmq4.NewPoller()
	poller.Add(i.skt, zmq4.POLLIN)

	for {
		if i.close.Completed() {
			err := i.skt.Close()
			i.in.Close()
			i.closed.Complete(err)
			return
		}
		sockets, err := poller.Poll(100 * time.Millisecond)
		if err != nil {
			continue
		}
		for range sockets {
			msg, err := i.skt.RecvMessage(0)
			if err == nil && !i.in.Closed().Completed() {
				i.in.Add(Message{i.addr, config.UUID(msg[0]), msg[1:]})
			}
		}
	}
}