Exemple #1
0
func main() {
	context, _ := zmq.NewContext()
	defer context.Close()

	sink, _ := context.Socket(zmq.Router)
	defer sink.Close()

	sink.Bind("inproc://example")

	// First allow 0MQ to set the identity
	anonymous, _ := context.Socket(zmq.Req)
	defer anonymous.Close()

	anonymous.Connect("inproc://example")
	anonymous.SendPart([]byte("ROUTER uses a generated UUID"), false)
	helpers.Dump(sink)

	// Then set the identity ourselves
	identified, _ := context.Socket(zmq.Req)
	defer identified.Close()

	identified.SetIdentitiy([]byte("PEER2"))
	identified.Connect("inproc://example")
	identified.SendPart([]byte("ROUTER socket uses REQ's socket identity"), false)
	helpers.Dump(sink)
}
Exemple #2
0
func workerTask() {

	context, _ := zmq.NewContext()
	defer context.Close()

	worker, _ := context.Socket(zmq.Dealer)
	defer worker.Close()

	// Set a printable identity
	helpers.SetId(worker)
	worker.Connect("tcp://localhost:5671")

	var total int
	for {
		// Tell the broker we're ready for work
		worker.SendPart([]byte(""), true)
		worker.SendPart([]byte("Hi Boss"), false)

		// Get workload from broker, until finished
		worker.RecvPart() // Envelope delimiter
		workload, _, _ := worker.RecvPart()
		finished := bytes.Equal(workload, []byte("Fired!"))
		if finished {
			fmt.Printf("Completed: %d tasks\n", total)
		}
		total++

		// Do some random work
		rand.Seed(time.Now().UnixNano())
		r := rand.Intn(500)
		time.Sleep(time.Duration(r) * time.Millisecond)
	}
}
Exemple #3
0
func main() {

	fmt.Printf("Connecting to hello world server...")

	context, _ := zmq.NewContext()
	defer context.Close()

	requester, _ := context.Socket(zmq.Req)
	defer requester.Close()

	requester.Connect("tcp://localhost:5555")

	for request := 0; request != 10; request++ {

		fmt.Printf("Sending request %d...\n", request)
		requester.SendPart([]byte("Hello"), false)

		reply, _, _ := requester.RecvPart()
		fmt.Printf("Received reply %d: [%s]\n", request, string(reply))
	}
}
Exemple #4
0
func main() {
	// Socket to talk to clients
	context, _ := zmq.NewContext()
	defer context.Close()

	responder, _ := zmq.NewSocket(zmq.Rep)
	defer responder.Close()

	responder.Bind("tcp://*:5555")

	for {
		// Wait for next request from client
		request, _, _ := responder.RecvPart()
		fmt.Printf("Received request: [%s]\n", string(request))

		// Do some 'work'
		time.Sleep(1 * time.Second)

		// Send reply back to client
		responder.SendPart([]byte("World"), false)
	}
}
Exemple #5
0
// While this example runs in a single process, that is only to make
// it easier to start and stop the example. Each go routine has its own
// context and conceptually acts as a separate process.
func main() {
	context, _ := zmq.NewContext()
	defer context.Close()

	broker, _ := context.Socket(zmq.Router)
	defer broker.Close()

	broker.Bind("tcp://*:5671")

	for w := 0; w < nbrWorkers; w++ {
		go workerTask()
	}

	// Run for five seconds and then tell workers to end
	endTime := time.Now().Unix() + 5
	workersFired := 0
	for {
		// Next message gives us least recently used worker
		identity, _, _ := broker.RecvPart()
		broker.SendPart(identity, true)
		broker.RecvPart() // Envelope delimiter
		broker.RecvPart() // Response from worker
		broker.SendPart([]byte(""), true)

		// Encourage workers until it's time to fire them
		if time.Now().Unix() < endTime {
			broker.SendPart([]byte("Work harder"), false)
		} else {
			broker.SendPart([]byte("Fired!"), false)
			workersFired++
			if workersFired == nbrWorkers {
				break
			}
		}
	}
}