Esempio n. 1
0
func main() {

	//  Socket to receive messages on
	receiver := goczmq.NewSock(goczmq.Pull)
	defer receiver.Destroy()
	receiver.Connect("tcp://localhost:5557")

	//  Socket to send messages to task sink
	sender := goczmq.NewSock(goczmq.Push)
	defer sender.Destroy()
	sender.Connect("tcp://localhost:5558")

	//  Process tasks forever
	for {
		msgbytes, _ := receiver.RecvMessage()
		fmt.Printf("%s.\n", string(msgbytes[0]))

		//  Do the work
		msec, _ := strconv.ParseInt(string(msgbytes[0]), 10, 64)
		time.Sleep(time.Duration(msec) * 1e6)

		//  Send results to sink
		sender.SendMessage([][]byte{[]byte("")})

	}
}
Esempio n. 2
0
func main() {
	var messageSize = flag.Int("message_size", 0, "size of message")
	var messageCount = flag.Int("message_count", 0, "number of messages")
	flag.Parse()

	pullSock := czmq.NewSock(czmq.Pull)
	defer pullSock.Destroy()

	_, err := pullSock.Bind("inproc://test")
	if err != nil {
		panic(err)
	}

	go func() {
		pushSock := czmq.NewSock(czmq.Push)
		defer pushSock.Destroy()
		err := pushSock.Connect("inproc://test")
		if err != nil {
			panic(err)
		}

		for i := 0; i < *messageCount; i++ {
			payload := make([]byte, *messageSize)
			err = pushSock.SendFrame(payload, 0)
			if err != nil {
				panic(err)
			}
		}
	}()

	startTime := time.Now()
	for i := 0; i < *messageCount; i++ {
		msg, _, err := pullSock.RecvFrame()
		if err != nil {
			panic(err)
		}
		if len(msg) != *messageSize {
			panic("msg too small")
		}
	}
	endTime := time.Now()
	elapsed := endTime.Sub(startTime)
	throughput := float64(*messageCount) / elapsed.Seconds()
	megabits := float64(throughput*float64(*messageSize)*8.0) / 1e6

	log.Printf("message size: %d", *messageSize)
	log.Printf("message count: %d", *messageCount)
	log.Printf("test time (seconds): %f", elapsed.Seconds())
	log.Printf("mean throughput: %f [msg/s]", throughput)
	log.Printf("mean throughput: %f [Mb/s]", megabits)
}
Esempio n. 3
0
func main() {

	//  Socket to receive messages on
	receiver := goczmq.NewSock(goczmq.Pull)
	defer receiver.Destroy()
	receiver.Bind("tcp://*:5558")

	//  Wait for start of batch
	msgbytes, _ := receiver.RecvMessage()
	fmt.Println("Received Start Msg ", string(msgbytes[0]))

	//  Start our clock now
	start_time := time.Now().UnixNano()

	//  Process 100 confirmations
	for i := 0; i < 100; i++ {
		msgbytes, _ = receiver.RecvMessage()
		fmt.Print(".")
	}

	//  Calculate and report duration of batch
	te := time.Now().UnixNano()
	fmt.Printf("Total elapsed time: %d msec\n", (te-start_time)/1e6)

}
Esempio n. 4
0
func main() {
	socket := goczmq.NewSock(goczmq.Sub)
	defer socket.Destroy()

	var temps []string
	var err error
	var temp int64
	total_temp := 0
	filter := "59937"

	// find zipcode
	if len(os.Args) > 1 { // ./wuclient 85678
		filter = string(os.Args[1])
	}

	//  Subscribe to just one zipcode (whitefish MT 59937)
	fmt.Printf("Collecting updates from weather server for %s…\n", filter)
	socket.SetSubscribe(filter)
	socket.Connect("tcp://localhost:5556")

	for i := 0; i < 101; i++ {
		// found temperature point
		datapt, _ := socket.RecvMessage()
		temps = strings.Split(string(datapt[0]), " ")
		temp, err = strconv.ParseInt(temps[1], 10, 64)
		if err == nil {
			// Invalid string
			total_temp += int(temp)
		}
	}

	fmt.Printf("Average temperature for zipcode %s was %dF \n\n", filter, total_temp/100)
}
Esempio n. 5
0
func main() {

	// Socket to send messages On
	sender := goczmq.NewSock(goczmq.Push)
	defer sender.Destroy()
	sender.Bind("tcp://*:5557")

	//  Socket to send start of batch message on
	sink := goczmq.NewSock(goczmq.Push)
	defer sink.Destroy()
	sink.Connect("tcp://localhost:5558")

	fmt.Print("Press Enter when the workers are ready: ")

	var line string
	fmt.Scanln(&line)

	fmt.Println("Sending tasks to workers…")

	sink.SendMessage([][]byte{[]byte("0")})

	// Seed the random number generator
	rand.Seed(time.Now().UnixNano())

	total_msec := 0

	for i := 0; i < 100; i++ {
		workload := rand.Intn(100)
		total_msec += workload
		msg := []byte(fmt.Sprintf("%d", workload))
		sender.SendMessage([][]byte{msg})
	}

	fmt.Printf("Total expected cost: %d msec\n", total_msec)

	time.Sleep(1e9) //  Give 0MQ time to deliver: one second ==  1e9 ns

}
Esempio n. 6
0
func main() {
	socket := goczmq.NewSock(goczmq.Req)
	defer socket.Destroy()

	fmt.Printf("Connecting to hello world server...")
	socket.Connect("tcp://localhost:5555")

	for i := 0; i < 10; i++ {
		// send hello
		msg := []byte(fmt.Sprintf("Hello %d", i))
		socket.SendMessage([][]byte{msg})
		println("Sending ", string(msg))

		// Wait for reply:
		reply, _ := socket.RecvMessage()
		println("Received ", string(reply[0]))
	}
}
Esempio n. 7
0
func main() {
	socket := goczmq.NewSock(goczmq.Rep)
	defer socket.Destroy()
	socket.Bind("tcp://*:5555")

	// Wait for messages
	for {
		msg, _ := socket.RecvMessage()
		println("Received ", string(msg[0]))

		// do some fake "work"
		time.Sleep(time.Second)

		// send reply back to client
		reply := []byte("World")
		socket.SendMessage([][]byte{reply})
	}
}
Esempio n. 8
0
func Setup() {
	config := config.Read()
	broadcastUri := fmt.Sprintf("tcp://%s:%d", config.Broadcaster.Host, config.Broadcaster.Port)

	var err error
	broadcaster, err = goczmq.NewPub(broadcastUri)
	if err != nil {
		panic(err)
	}
	log.Println("Broadcaster will start on", broadcastUri)

	pitcher = goczmq.NewSock(goczmq.Push)

	receiver, err = goczmq.NewPull("inproc://broadcast")
	if err != nil {
		panic(err)
	}

	helpers.ConnectToPeers(true, ConnectToBroadcatcher)
}
Esempio n. 9
0
func main() {
	socket := goczmq.NewSock(goczmq.Pub)
	defer socket.Destroy()
	socket.Bind("tcp://*:5556")
	socket.Bind("ipc://weather.ipc")

	// Seed the random number generator
	rand.Seed(time.Now().UnixNano())

	// loop for a while aparently
	for {

		//  make values that will fool the boss
		zipcode := rand.Intn(100000)
		temperature := rand.Intn(215) - 80
		relhumidity := rand.Intn(50) + 10

		msg := []byte(fmt.Sprintf("%d %d %d", zipcode, temperature, relhumidity))

		//  Send message to all subscribers
		socket.SendMessage([][]byte{msg})
	}
}
Esempio n. 10
0
// Yay! Test function.
func TestTypes(t *testing.T) {

	var (
		sndMsg    []byte
		rcvMsg    []byte
		rcvDigest string
		sndDigest string
	)

	// Create pair of sockets we can send through

	// Output socket
	output := goczmq.NewSock(goczmq.Dealer)
	defer output.Destroy()

	routingID := "Shout"
	output.SetIdentity(routingID)
	_, err := output.Bind("inproc://selftest-types")
	if err != nil {
		t.Fatal(err)
	}
	defer output.Unbind("inproc://selftest-types")

	// Input socket
	input := goczmq.NewSock(goczmq.Router)
	defer input.Destroy()

	err = input.Connect("inproc://selftest-types")
	if err != nil {
		t.Fatal(err)
	}
	defer input.Disconnect("inproc://selftest-types")

	// Create a Types message and send it through the wire
	types := NewTypes()
	types.sequence = 123
	types.ClientForename = "Lucius Junius"
	types.ClientSurname = "Brutus"
	types.ClientMobile = "01234567890"
	types.ClientEmail = "*****@*****.**"
	types.SupplierForename = "Leslie"
	types.SupplierSurname = "Lamport"
	types.SupplierMobile = "01987654321"
	types.SupplierEmail = "*****@*****.**"

	err = types.Send(output)
	if err != nil {
		t.Fatal(err)
	}

	sndMsg, err = types.Marshal()
	if err != nil {
		t.Fatal(err)
	}
	sndDigest = fmt.Sprintf("%x", sha1.Sum(sndMsg))
	if "dee674a1bcac455b7cd1801f4008c65d0a37b2ea" != sndDigest {
		fmt.Printf("sndMsg: %x\n", sndMsg)
		t.Fatalf("expected %q digest for types, got %s", "dee674a1bcac455b7cd1801f4008c65d0a37b2ea", sndDigest)
	}

	transit, err := Recv(input)
	if err != nil {
		t.Fatal(err)
	}

	tr := transit.(*Types)

	rcvMsg, err = tr.Marshal()
	if err != nil {
		t.Fatal(err)
	}
	rcvDigest = fmt.Sprintf("%x", sha1.Sum(rcvMsg))
	if sndDigest != rcvDigest {
		fmt.Printf("sndMsg: %x\n", sndMsg)
		fmt.Printf("rcvMsg: %x\n", rcvMsg)
		t.Fatalf("inconsistent digest after sending and after receiving msg: %q != %q", sndDigest, rcvDigest)
	}
	if "dee674a1bcac455b7cd1801f4008c65d0a37b2ea" != rcvDigest {
		t.Fatalf("expected %q digest for types, got %s", "dee674a1bcac455b7cd1801f4008c65d0a37b2ea", rcvDigest)
	}

	// Tests number
	if tr.sequence != 123 {
		t.Fatalf("expected %d, got %d", 123, tr.sequence)
	}
	// Tests string
	if tr.ClientForename != "Lucius Junius" {
		t.Fatalf("expected %s, got %s", "Lucius Junius", tr.ClientForename)
	}
	// Tests string
	if tr.ClientSurname != "Brutus" {
		t.Fatalf("expected %s, got %s", "Brutus", tr.ClientSurname)
	}
	// Tests string
	if tr.ClientMobile != "01234567890" {
		t.Fatalf("expected %s, got %s", "01234567890", tr.ClientMobile)
	}
	// Tests string
	if tr.ClientEmail != "*****@*****.**" {
		t.Fatalf("expected %s, got %s", "*****@*****.**", tr.ClientEmail)
	}
	// Tests string
	if tr.SupplierForename != "Leslie" {
		t.Fatalf("expected %s, got %s", "Leslie", tr.SupplierForename)
	}
	// Tests string
	if tr.SupplierSurname != "Lamport" {
		t.Fatalf("expected %s, got %s", "Lamport", tr.SupplierSurname)
	}
	// Tests string
	if tr.SupplierMobile != "01987654321" {
		t.Fatalf("expected %s, got %s", "01987654321", tr.SupplierMobile)
	}
	// Tests string
	if tr.SupplierEmail != "*****@*****.**" {
		t.Fatalf("expected %s, got %s", "*****@*****.**", tr.SupplierEmail)
	}
	err = tr.Send(input)
	if err != nil {
		t.Fatal(err)
	}

	transit, err = Recv(output)
	if err != nil {
		t.Fatal(err)
	}

	if routingID != string(tr.RoutingID()) {
		t.Fatalf("expected %s, got %s", routingID, string(tr.RoutingID()))
	}
}
Esempio n. 11
0
func TestNew(t *testing.T) {
	endpoints := []string{"inproc://test1"}
	topics := []string{"topic1", "topic2"}
	servercert := "./example_certs/example_curve_server_cert"
	clientcert := "./example_certs/example_curve_client_cert"

	auth := goczmq.NewAuth()
	defer auth.Destroy()

	clientCert, err := goczmq.NewCertFromFile(clientcert)
	if err != nil {
		t.Fatal(err)
	}
	defer clientCert.Destroy()

	server := goczmq.NewSock(goczmq.Pub)

	defer server.Destroy()
	server.SetZapDomain("global")

	serverCert, err := goczmq.NewCertFromFile(servercert)
	defer serverCert.Destroy()
	if err != nil {
		t.Fatal(err)
	}

	serverCert.Apply(server)
	server.SetCurveServer(1)

	err = auth.Curve("./example_certs/")
	if err != nil {
		t.Fatal(err)
	}

	server.Bind(endpoints[0])

	lt, err := New(endpoints, topics, servercert, clientcert)
	if err != nil {
		t.Errorf("NewLogTalez failed: %s", err)
	}

	server.SendFrame([]byte("topic1:hello world"), 0)

	buf := make([]byte, 65536)

	n, err := lt.Read(buf)
	if err != nil {
		t.Errorf("expected nil, got %s", err)
	}

	if string(buf[:n]) != "topic1:hello world" {
		t.Errorf("expected 'topic1:hello world', got '%s'", buf[:n])
	}

	server.SendFrame([]byte("topic2:hello again"), 0)

	n, err = lt.Read(buf)
	if err != nil {
		t.Errorf("expected nil, got %s", err)
	}

	if string(buf[:n]) != "topic2:hello again" {
		t.Errorf("expected 'topic2:hello again', got '%s'", buf[:n])
	}
}
Esempio n. 12
0
// Yay! Test function.
func TestLog(t *testing.T) {

	var (
		sndMsg    []byte
		rcvMsg    []byte
		rcvDigest string
		sndDigest string
	)

	// Create pair of sockets we can send through

	// Output socket
	output := goczmq.NewSock(goczmq.Dealer)
	defer output.Destroy()

	routingID := "Shout"
	output.SetIdentity(routingID)
	_, err := output.Bind("inproc://selftest-log")
	if err != nil {
		t.Fatal(err)
	}
	defer output.Unbind("inproc://selftest-log")

	// Input socket
	input := goczmq.NewSock(goczmq.Router)
	defer input.Destroy()

	err = input.Connect("inproc://selftest-log")
	if err != nil {
		t.Fatal(err)
	}
	defer input.Disconnect("inproc://selftest-log")

	// Create a Log message and send it through the wire
	log := NewLog()
	log.sequence = 123
	log.Level = 2
	log.Event = 3
	log.Node = 45536
	log.Peer = 65535
	log.Time = 1427261426
	log.Host = "localhost"
	log.Data = "This is the message to log"

	err = log.Send(output)
	if err != nil {
		t.Fatal(err)
	}

	sndMsg, err = log.Marshal()
	if err != nil {
		t.Fatal(err)
	}
	sndDigest = fmt.Sprintf("%x", sha1.Sum(sndMsg))
	if "b90f4926d4662b319c0ec113794b0f27d9336a23" != sndDigest {
		fmt.Printf("sndMsg: %x\n", sndMsg)
		t.Fatalf("expected %q digest for log, got %s", "b90f4926d4662b319c0ec113794b0f27d9336a23", sndDigest)
	}

	transit, err := Recv(input)
	if err != nil {
		t.Fatal(err)
	}

	tr := transit.(*Log)

	rcvMsg, err = tr.Marshal()
	if err != nil {
		t.Fatal(err)
	}
	rcvDigest = fmt.Sprintf("%x", sha1.Sum(rcvMsg))
	if sndDigest != rcvDigest {
		fmt.Printf("sndMsg: %x\n", sndMsg)
		fmt.Printf("rcvMsg: %x\n", rcvMsg)
		t.Fatalf("inconsistent digest after sending and after receiving msg: %q != %q", sndDigest, rcvDigest)
	}
	if "b90f4926d4662b319c0ec113794b0f27d9336a23" != rcvDigest {
		t.Fatalf("expected %q digest for log, got %s", "b90f4926d4662b319c0ec113794b0f27d9336a23", rcvDigest)
	}

	// Tests number
	if tr.sequence != 123 {
		t.Fatalf("expected %d, got %d", 123, tr.sequence)
	}
	// Tests number
	if tr.Level != 2 {
		t.Fatalf("expected %d, got %d", 2, tr.Level)
	}
	// Tests number
	if tr.Event != 3 {
		t.Fatalf("expected %d, got %d", 3, tr.Event)
	}
	// Tests number
	if tr.Node != 45536 {
		t.Fatalf("expected %d, got %d", 45536, tr.Node)
	}
	// Tests number
	if tr.Peer != 65535 {
		t.Fatalf("expected %d, got %d", 65535, tr.Peer)
	}
	// Tests number
	if tr.Time != 1427261426 {
		t.Fatalf("expected %d, got %d", 1427261426, tr.Time)
	}
	// Tests string
	if tr.Host != "localhost" {
		t.Fatalf("expected %s, got %s", "localhost", tr.Host)
	}
	// Tests longstr
	if tr.Data != "This is the message to log" {
		t.Fatalf("expected %s, got %s", "This is the message to log", tr.Data)
	}
	err = tr.Send(input)
	if err != nil {
		t.Fatal(err)
	}

	transit, err = Recv(output)
	if err != nil {
		t.Fatal(err)
	}

	if routingID != string(tr.RoutingID()) {
		t.Fatalf("expected %s, got %s", routingID, string(tr.RoutingID()))
	}
}
Esempio n. 13
0
// Yay! Test function.
func TestBinary(t *testing.T) {

	var (
		sndMsg    []byte
		rcvMsg    []byte
		rcvDigest string
		sndDigest string
	)

	// Create pair of sockets we can send through

	// Output socket
	output := goczmq.NewSock(goczmq.Dealer)
	defer output.Destroy()

	routingID := "Shout"
	output.SetIdentity(routingID)
	_, err := output.Bind("inproc://selftest-binary")
	if err != nil {
		t.Fatal(err)
	}
	defer output.Unbind("inproc://selftest-binary")

	// Input socket
	input := goczmq.NewSock(goczmq.Router)
	defer input.Destroy()

	err = input.Connect("inproc://selftest-binary")
	if err != nil {
		t.Fatal(err)
	}
	defer input.Disconnect("inproc://selftest-binary")

	// Create a Binary message and send it through the wire
	binary := NewBinary()
	binary.sequence = 123
	binary.Flags = []byte("b38c")
	binary.PublicKey = []byte("89f5ffe70d747869dfe8")
	binary.Identifier, _ = hex.DecodeString("3a60e6850a1e4cc15f3bfd4b42bc6b3e")
	binary.Address = []byte("0206f99f6137d9fe380f")
	binary.Content = []byte("728a92c6749235ba7002")

	err = binary.Send(output)
	if err != nil {
		t.Fatal(err)
	}

	sndMsg, err = binary.Marshal()
	if err != nil {
		t.Fatal(err)
	}
	sndDigest = fmt.Sprintf("%x", sha1.Sum(sndMsg))
	if "740caf04158436b4a81b844135a8a1dc9e4f8a54" != sndDigest {
		fmt.Printf("sndMsg: %x\n", sndMsg)
		t.Fatalf("expected %q digest for binary, got %s", "740caf04158436b4a81b844135a8a1dc9e4f8a54", sndDigest)
	}

	transit, err := Recv(input)
	if err != nil {
		t.Fatal(err)
	}

	tr := transit.(*Binary)

	rcvMsg, err = tr.Marshal()
	if err != nil {
		t.Fatal(err)
	}
	rcvDigest = fmt.Sprintf("%x", sha1.Sum(rcvMsg))
	if sndDigest != rcvDigest {
		fmt.Printf("sndMsg: %x\n", sndMsg)
		fmt.Printf("rcvMsg: %x\n", rcvMsg)
		t.Fatalf("inconsistent digest after sending and after receiving msg: %q != %q", sndDigest, rcvDigest)
	}
	if "740caf04158436b4a81b844135a8a1dc9e4f8a54" != rcvDigest {
		t.Fatalf("expected %q digest for binary, got %s", "740caf04158436b4a81b844135a8a1dc9e4f8a54", rcvDigest)
	}

	// Tests number
	if tr.sequence != 123 {
		t.Fatalf("expected %d, got %d", 123, tr.sequence)
	}
	// Tests octets
	if len(tr.Flags) != 4 {
		t.Fatalf("mismatch octets size for %s", "Flags")
	}
	for idx, b := range []byte("b38c") {
		if tr.Flags[idx] != b {
			t.Fatalf("mismatch octets value for %s", "Flags")
		}
	}
	// Tests chunk
	if string(tr.PublicKey) != "89f5ffe70d747869dfe8" {
		t.Fatalf("expected %s, got %s", "89f5ffe70d747869dfe8", tr.PublicKey)
	}
	// Tests uuid
	if hex.EncodeToString(tr.Identifier) != "3a60e6850a1e4cc15f3bfd4b42bc6b3e" {
		t.Fatalf("expected %s, got %s", "3a60e6850a1e4cc15f3bfd4b42bc6b3e", tr.Identifier)
	}
	// Tests frame
	if string(tr.Address) != "0206f99f6137d9fe380f" {
		t.Fatalf("expected %s, got %s", "0206f99f6137d9fe380f", tr.Address)
	}
	// Tests msg
	if string(tr.Content) != "728a92c6749235ba7002" {
		t.Fatalf("expected %s, got %s", "728a92c6749235ba7002", tr.Content)
	}
	err = tr.Send(input)
	if err != nil {
		t.Fatal(err)
	}

	transit, err = Recv(output)
	if err != nil {
		t.Fatal(err)
	}

	if routingID != string(tr.RoutingID()) {
		t.Fatalf("expected %s, got %s", routingID, string(tr.RoutingID()))
	}
}
Esempio n. 14
0
// Yay! Test function.
func TestStructures(t *testing.T) {

	var (
		sndMsg    []byte
		rcvMsg    []byte
		rcvDigest string
		sndDigest string
	)

	// Create pair of sockets we can send through

	// Output socket
	output := goczmq.NewSock(goczmq.Dealer)
	defer output.Destroy()

	routingID := "Shout"
	output.SetIdentity(routingID)
	_, err := output.Bind("inproc://selftest-structures")
	if err != nil {
		t.Fatal(err)
	}
	defer output.Unbind("inproc://selftest-structures")

	// Input socket
	input := goczmq.NewSock(goczmq.Router)
	defer input.Destroy()

	err = input.Connect("inproc://selftest-structures")
	if err != nil {
		t.Fatal(err)
	}
	defer input.Disconnect("inproc://selftest-structures")

	// Create a Structures message and send it through the wire
	structures := NewStructures()
	structures.sequence = 123
	structures.Aliases = []string{
		"First alias",
		"Second alias",
		"Third alias",
	}
	structures.Headers = map[string]string{"endpoint": "tcp://localhost:5665"}

	err = structures.Send(output)
	if err != nil {
		t.Fatal(err)
	}

	sndMsg, err = structures.Marshal()
	if err != nil {
		t.Fatal(err)
	}
	sndDigest = fmt.Sprintf("%x", sha1.Sum(sndMsg))
	if "52d9e295862bc3edad2841c412327a50d2c1b857" != sndDigest {
		fmt.Printf("sndMsg: %x\n", sndMsg)
		t.Fatalf("expected %q digest for structures, got %s", "52d9e295862bc3edad2841c412327a50d2c1b857", sndDigest)
	}

	transit, err := Recv(input)
	if err != nil {
		t.Fatal(err)
	}

	tr := transit.(*Structures)

	rcvMsg, err = tr.Marshal()
	if err != nil {
		t.Fatal(err)
	}
	rcvDigest = fmt.Sprintf("%x", sha1.Sum(rcvMsg))
	if sndDigest != rcvDigest {
		fmt.Printf("sndMsg: %x\n", sndMsg)
		fmt.Printf("rcvMsg: %x\n", rcvMsg)
		t.Fatalf("inconsistent digest after sending and after receiving msg: %q != %q", sndDigest, rcvDigest)
	}
	if "52d9e295862bc3edad2841c412327a50d2c1b857" != rcvDigest {
		t.Fatalf("expected %q digest for structures, got %s", "52d9e295862bc3edad2841c412327a50d2c1b857", rcvDigest)
	}

	// Tests number
	if tr.sequence != 123 {
		t.Fatalf("expected %d, got %d", 123, tr.sequence)
	}
	// Tests strings
	for idx, str := range []string{"First alias", "Second alias", "Third alias"} {
		if tr.Aliases[idx] != str {
			t.Fatalf("expected %s, got %s", str, tr.Aliases[idx])
		}
	}
	// Tests hash
	for key, val := range map[string]string{"endpoint": "tcp://localhost:5665"} {
		if tr.Headers[key] != val {
			t.Fatalf("expected %s, got %s", val, tr.Headers[key])
		}
	}
	err = tr.Send(input)
	if err != nil {
		t.Fatal(err)
	}

	transit, err = Recv(output)
	if err != nil {
		t.Fatal(err)
	}

	if routingID != string(tr.RoutingID()) {
		t.Fatalf("expected %s, got %s", routingID, string(tr.RoutingID()))
	}
}