func snapshots(socket *zmq.Socket, srv *clonesrv_t) (err error) {
msg, err := socket.RecvMessage(0)
if err != nil {
return
}
identity := msg[0]
// Request is in second frame of message
request := msg[1]
if request != "ICANHAZ?" {
err = errors.New("E: bad request, aborting")
return
}
subtree := msg[2]
// Send state socket to client
for _, kvmsg := range srv.kvmap {
if key, _ := kvmsg.GetKey(); strings.HasPrefix(key, subtree) {
socket.Send(identity, zmq.SNDMORE)
kvmsg.Send(socket)
}
}
// Now send END message with sequence number
log.Println("I: sending shapshot =", srv.sequence)
socket.Send(identity, zmq.SNDMORE)
kvmsg := kvmsg.NewKvmsg(srv.sequence)
kvmsg.SetKey("KTHXBAI")
kvmsg.SetBody(subtree)
kvmsg.Send(socket)
return
}
func Example_test_hwm() {
MAX_SENDS := 10000
BIND_FIRST := 1
CONNECT_FIRST := 2
test_defaults := func() int {
// Set up bind socket
bind_socket, err := zmq.NewSocket(zmq.PULL)
if checkErr(err) {
return 0
}
defer func() {
err := bind_socket.Close()
checkErr(err)
}()
err = bind_socket.Bind("inproc://a")
if checkErr(err) {
return 0
}
// Set up connect socket
connect_socket, err := zmq.NewSocket(zmq.PUSH)
if checkErr(err) {
return 0
}
defer func() {
err := connect_socket.Close()
checkErr(err)
}()
err = connect_socket.Connect("inproc://a")
if checkErr(err) {
return 0
}
// Send until we block
send_count := 0
for send_count < MAX_SENDS {
_, err := connect_socket.Send("", zmq.DONTWAIT)
if err != nil {
break
}
send_count++
}
// Now receive all sent messages
recv_count := 0
for {
_, err := bind_socket.Recv(zmq.DONTWAIT)
if err != nil {
break
}
recv_count++
}
fmt.Println("send_count == recv_count:", send_count == recv_count)
return send_count
}
count_msg := func(send_hwm, recv_hwm, testType int) int {
var bind_socket, connect_socket *zmq.Socket
var err error
if testType == BIND_FIRST {
// Set up bind socket
bind_socket, err = zmq.NewSocket(zmq.PULL)
if checkErr(err) {
return 0
}
defer func() {
err := bind_socket.Close()
checkErr(err)
}()
err = bind_socket.SetRcvhwm(recv_hwm)
if checkErr(err) {
return 0
}
err = bind_socket.Bind("inproc://a")
if checkErr(err) {
return 0
}
// Set up connect socket
connect_socket, err = zmq.NewSocket(zmq.PUSH)
if checkErr(err) {
return 0
}
defer func() {
err := connect_socket.Close()
checkErr(err)
}()
err = connect_socket.SetSndhwm(send_hwm)
if checkErr(err) {
return 0
}
err = connect_socket.Connect("inproc://a")
if checkErr(err) {
return 0
}
} else {
// Set up connect socket
connect_socket, err = zmq.NewSocket(zmq.PUSH)
if checkErr(err) {
return 0
}
defer func() {
err := connect_socket.Close()
checkErr(err)
}()
err = connect_socket.SetSndhwm(send_hwm)
if checkErr(err) {
return 0
}
err = connect_socket.Connect("inproc://a")
if checkErr(err) {
return 0
}
// Set up bind socket
bind_socket, err = zmq.NewSocket(zmq.PULL)
if checkErr(err) {
return 0
}
defer func() {
err := bind_socket.Close()
checkErr(err)
}()
err = bind_socket.SetRcvhwm(recv_hwm)
if checkErr(err) {
return 0
}
err = bind_socket.Bind("inproc://a")
if checkErr(err) {
return 0
}
}
// Send until we block
send_count := 0
for send_count < MAX_SENDS {
_, err := connect_socket.Send("", zmq.DONTWAIT)
if err != nil {
break
}
send_count++
}
// Now receive all sent messages
recv_count := 0
for {
_, err := bind_socket.Recv(zmq.DONTWAIT)
if err != nil {
break
}
recv_count++
}
fmt.Println("send_count == recv_count:", send_count == recv_count)
// Now it should be possible to send one more.
_, err = connect_socket.Send("", 0)
if checkErr(err) {
return 0
}
// Consume the remaining message.
_, err = bind_socket.Recv(0)
checkErr(err)
return send_count
}
test_inproc_bind_first := func(send_hwm, recv_hwm int) int {
return count_msg(send_hwm, recv_hwm, BIND_FIRST)
}
test_inproc_connect_first := func(send_hwm, recv_hwm int) int {
return count_msg(send_hwm, recv_hwm, CONNECT_FIRST)
}
test_inproc_connect_and_close_first := func(send_hwm, recv_hwm int) int {
// Set up connect socket
connect_socket, err := zmq.NewSocket(zmq.PUSH)
if checkErr(err) {
return 0
}
err = connect_socket.SetSndhwm(send_hwm)
if checkErr(err) {
connect_socket.Close()
return 0
}
err = connect_socket.Connect("inproc://a")
if checkErr(err) {
connect_socket.Close()
return 0
}
// Send until we block
send_count := 0
for send_count < MAX_SENDS {
_, err := connect_socket.Send("", zmq.DONTWAIT)
if err != nil {
break
}
send_count++
}
// Close connect
err = connect_socket.Close()
if checkErr(err) {
return 0
}
// Set up bind socket
bind_socket, err := zmq.NewSocket(zmq.PULL)
if checkErr(err) {
return 0
}
defer func() {
err := bind_socket.Close()
checkErr(err)
}()
err = bind_socket.SetRcvhwm(recv_hwm)
if checkErr(err) {
return 0
}
err = bind_socket.Bind("inproc://a")
if checkErr(err) {
return 0
}
// Now receive all sent messages
recv_count := 0
for {
_, err := bind_socket.Recv(zmq.DONTWAIT)
if err != nil {
break
}
recv_count++
}
fmt.Println("send_count == recv_count:", send_count == recv_count)
return send_count
}
// Default values are 1000 on send and 1000 one receive, so 2000 total
fmt.Println("Default values")
count := test_defaults()
fmt.Println("count:", count)
time.Sleep(100 * time.Millisecond)
// Infinite send and receive buffer
fmt.Println("\nInfinite send and receive")
count = test_inproc_bind_first(0, 0)
fmt.Println("count:", count)
time.Sleep(100 * time.Millisecond)
count = test_inproc_connect_first(0, 0)
fmt.Println("count:", count)
time.Sleep(100 * time.Millisecond)
// Infinite send buffer
fmt.Println("\nInfinite send buffer")
count = test_inproc_bind_first(1, 0)
fmt.Println("count:", count)
time.Sleep(100 * time.Millisecond)
count = test_inproc_connect_first(1, 0)
fmt.Println("count:", count)
time.Sleep(100 * time.Millisecond)
// Infinite receive buffer
fmt.Println("\nInfinite receive buffer")
count = test_inproc_bind_first(0, 1)
fmt.Println("count:", count)
time.Sleep(100 * time.Millisecond)
count = test_inproc_connect_first(0, 1)
fmt.Println("count:", count)
time.Sleep(100 * time.Millisecond)
// Send and recv buffers hwm 1, so total that can be queued is 2
fmt.Println("\nSend and recv buffers hwm 1")
count = test_inproc_bind_first(1, 1)
fmt.Println("count:", count)
time.Sleep(100 * time.Millisecond)
count = test_inproc_connect_first(1, 1)
fmt.Println("count:", count)
time.Sleep(100 * time.Millisecond)
// Send hwm of 1, send before bind so total that can be queued is 1
fmt.Println("\nSend hwm of 1, send before bind")
count = test_inproc_connect_and_close_first(1, 0)
fmt.Println("count:", count)
time.Sleep(100 * time.Millisecond)
fmt.Println("\nDone")
// Output:
// Default values
// send_count == recv_count: true
// count: 2000
//
// Infinite send and receive
// send_count == recv_count: true
// count: 10000
// send_count == recv_count: true
// count: 10000
//
// Infinite send buffer
// send_count == recv_count: true
// count: 10000
// send_count == recv_count: true
// count: 10000
//
// Infinite receive buffer
// send_count == recv_count: true
// count: 10000
// send_count == recv_count: true
// count: 10000
//
// Send and recv buffers hwm 1
// send_count == recv_count: true
// count: 2
// send_count == recv_count: true
// count: 2
//
// Send hwm of 1, send before bind
// send_count == recv_count: true
// count: 1
//
// Done
}
func bounce(server, client *zmq.Socket, willfail bool) {
content := "12345678ABCDEFGH12345678abcdefgh"
// Send message from client to server
rc, err := client.Send(content, zmq.SNDMORE|zmq.DONTWAIT)
if checkErr0(err, 1) {
return
}
if rc != 32 {
checkErr0(errors.New("rc != 32"), 2)
}
rc, err = client.Send(content, zmq.DONTWAIT)
if checkErr0(err, 3) {
return
}
if rc != 32 {
checkErr0(errors.New("rc != 32"), 4)
}
// Receive message at server side
msg, err := server.Recv(0)
if checkErr0(e(err, willfail), 5) {
return
}
// Check that message is still the same
if msg != content {
checkErr0(errors.New(fmt.Sprintf("%q != %q", msg, content)), 6)
}
rcvmore, err := server.GetRcvmore()
if checkErr0(err, 7) {
return
}
if !rcvmore {
checkErr0(errors.New(fmt.Sprint("rcvmore ==", rcvmore)), 8)
return
}
// Receive message at server side
msg, err = server.Recv(0)
if checkErr0(err, 9) {
return
}
// Check that message is still the same
if msg != content {
checkErr0(errors.New(fmt.Sprintf("%q != %q", msg, content)), 10)
}
rcvmore, err = server.GetRcvmore()
if checkErr0(err, 11) {
return
}
if rcvmore {
checkErr0(errors.New(fmt.Sprint("rcvmore == ", rcvmore)), 12)
return
}
// The same, from server back to client
// Send message from server to client
rc, err = server.Send(content, zmq.SNDMORE)
if checkErr0(err, 13) {
return
}
if rc != 32 {
checkErr0(errors.New("rc != 32"), 14)
}
rc, err = server.Send(content, 0)
if checkErr0(err, 15) {
return
}
if rc != 32 {
checkErr0(errors.New("rc != 32"), 16)
}
// Receive message at client side
msg, err = client.Recv(0)
if checkErr0(err, 17) {
return
}
// Check that message is still the same
if msg != content {
checkErr0(errors.New(fmt.Sprintf("%q != %q", msg, content)), 18)
}
rcvmore, err = client.GetRcvmore()
if checkErr0(err, 19) {
return
}
if !rcvmore {
checkErr0(errors.New(fmt.Sprint("rcvmore ==", rcvmore)), 20)
return
}
// Receive message at client side
msg, err = client.Recv(0)
if checkErr0(err, 21) {
return
}
// Check that message is still the same
if msg != content {
checkErr0(errors.New(fmt.Sprintf("%q != %q", msg, content)), 22)
}
rcvmore, err = client.GetRcvmore()
if checkErr0(err, 23) {
return
}
if rcvmore {
checkErr0(errors.New(fmt.Sprint("rcvmore == ", rcvmore)), 24)
return
}
}
