func main() {
// Socket to send messages on
sender, _ := zmq.NewSocket(zmq.PUSH)
defer sender.Close()
sender.Bind("tcp://*:5557")
// Socket to send start of batch message on
sink, _ := zmq.NewSocket(zmq.PUSH)
defer sink.Close()
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...")
// The first message is "0" and signals start of batch
sink.Send("0", 0)
// Initialize random number generator
rand.Seed(time.Now().UnixNano())
// Send 100 tasks
total_msec := 0
for task_nbr := 0; task_nbr < 100; task_nbr++ {
// Random workload from 1 to 100msecs
workload := rand.Intn(100) + 1
total_msec += workload
s := fmt.Sprintf("%d", workload)
sender.Send(s, 0)
}
fmt.Println("Total expected cost:", time.Duration(total_msec)*time.Millisecond)
time.Sleep(time.Second) // Give 0MQ time to deliver
}
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")
// Process tasks forever
for {
s, _ := receiver.Recv(0)
// Simple progress indicator for the viewer
fmt.Print(s + ".")
// Do the work
msec, _ := strconv.Atoi(s)
time.Sleep(time.Duration(msec) * time.Millisecond)
// Send results to sink
sender.Send("", 0)
}
}
func main() {
lbbroker := &lbbroker_t{}
lbbroker.frontend, _ = zmq.NewSocket(zmq.ROUTER)
lbbroker.backend, _ = zmq.NewSocket(zmq.ROUTER)
defer lbbroker.frontend.Close()
defer lbbroker.backend.Close()
lbbroker.frontend.Bind("ipc://frontend.ipc")
lbbroker.backend.Bind("ipc://backend.ipc")
for client_nbr := 0; client_nbr < NBR_CLIENTS; client_nbr++ {
go client_task()
}
for worker_nbr := 0; worker_nbr < NBR_WORKERS; worker_nbr++ {
go worker_task()
}
// Queue of available workers
lbbroker.workers = make([]string, 0, 10)
// Prepare reactor and fire it up
lbbroker.reactor = zmq.NewReactor()
lbbroker.reactor.AddSocket(lbbroker.backend, zmq.POLLIN,
func(e zmq.State) error { return handle_backend(lbbroker) })
lbbroker.reactor.Run(-1)
}
func main() {
// Socket to receive messages on
receiver, _ := zmq.NewSocket(zmq.PULL)
defer receiver.Close()
receiver.Bind("tcp://*:5558")
// Socket for worker control
controller, _ := zmq.NewSocket(zmq.PUB)
defer controller.Close()
controller.Bind("tcp://*:5559")
// Wait for start of batch
receiver.Recv(0)
// Start our clock now
start_time := time.Now()
// Process 100 confirmations
for task_nbr := 0; task_nbr < 100; task_nbr++ {
receiver.Recv(0)
if task_nbr%10 == 0 {
fmt.Print(":")
} else {
fmt.Print(".")
}
}
fmt.Println("\nTotal elapsed time:", time.Since(start_time))
// Send kill signal to workers
controller.Send("KILL", 0)
// Finished
time.Sleep(time.Second) // Give 0MQ time to deliver
}
func main() {
// Prepare our context and sockets
publisher, _ := zmq.NewSocket(zmq.PUB)
publisher.Bind("tcp://*:5557")
sequence := int64(0)
rand.Seed(time.Now().UnixNano())
// Start state manager and wait for synchronization signal
updates, _ := zmq.NewSocket(zmq.PAIR)
updates.Bind("inproc://pipe")
go state_manager()
updates.RecvMessage(0) // "READY"
for {
// Distribute as key-value message
sequence++
kvmsg := kvsimple.NewKvmsg(sequence)
kvmsg.SetKey(fmt.Sprint(rand.Intn(10000)))
kvmsg.SetBody(fmt.Sprint(rand.Intn(1000000)))
if kvmsg.Send(publisher) != nil {
break
}
if kvmsg.Send(updates) != nil {
break
}
}
fmt.Printf("Interrupted\n%d messages out\n", sequence)
}
func New(primary bool, local, remote string) (bstar *Bstar, err error) {
bstar = &Bstar{}
// Initialize the Binary Star
bstar.Reactor = zmq.NewReactor()
if primary {
bstar.state = state_PRIMARY
} else {
bstar.state = state_BACKUP
}
// Create publisher for state going to peer
bstar.statepub, err = zmq.NewSocket(zmq.PUB)
bstar.statepub.Bind(local)
// Create subscriber for state coming from peer
bstar.statesub, err = zmq.NewSocket(zmq.SUB)
bstar.statesub.SetSubscribe("")
bstar.statesub.Connect(remote)
// Set-up basic reactor events
bstar.Reactor.AddChannelTime(time.Tick(bstar_HEARTBEAT), 1,
func(i interface{}) error { return bstar.send_state() })
bstar.Reactor.AddSocket(bstar.statesub, zmq.POLLIN,
func(e zmq.State) error { return bstar.recv_state() })
return
}
func main() {
srv := &clonesrv_t{
port: 5556,
kvmap: make(map[string]*kvmsg.Kvmsg),
}
// Set up our clone server sockets
srv.snapshot, _ = zmq.NewSocket(zmq.ROUTER)
srv.snapshot.Bind(fmt.Sprint("tcp://*:", srv.port))
srv.publisher, _ = zmq.NewSocket(zmq.PUB)
srv.publisher.Bind(fmt.Sprint("tcp://*:", srv.port+1))
srv.collector, _ = zmq.NewSocket(zmq.PULL)
srv.collector.Bind(fmt.Sprint("tcp://*:", srv.port+2))
// Register our handlers with reactor
reactor := zmq.NewReactor()
reactor.AddSocket(srv.snapshot, zmq.POLLIN,
func(e zmq.State) error { return snapshots(srv) })
reactor.AddSocket(srv.collector, zmq.POLLIN,
func(e zmq.State) error { return collector(srv) })
reactor.AddChannelTime(time.Tick(1000*time.Millisecond), 1,
func(v interface{}) error { return flush_ttl(srv) })
log.Println(reactor.Run(100 * time.Millisecond)) // precision: .1 seconds
}
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)
}
}
}
}
func main() {
var configfile string
flag.StringVar(&configfile, "config", "./broker.json", "Broker JSON config file")
flag.Parse()
file, err := ioutil.ReadFile(configfile)
if err != nil {
panic("could not read config file: " + err.Error())
}
f := ConfigData{}
err = json.Unmarshal(file, &f)
pubsocket, _ := zmq.NewSocket(zmq.PUB)
repsocket, _ := zmq.NewSocket(zmq.REP)
defer pubsocket.Close()
defer repsocket.Close()
pubsocket.Bind(f.PubSocket)
repsocket.Bind(f.RepSocket)
var e envelope
for {
msg, _ := repsocket.Recv(0)
json.Unmarshal([]byte(msg), &e)
pubsocket.Send(e.Address, zmq.SNDMORE)
pubsocket.Send(e.Content, 0)
repsocket.Send("published", 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:]
}
}
}
}
}
func BrokerTask() {
// Prepare our sockets
frontend, _ := zmq.NewSocket(zmq.DEALER)
frontend.Bind("tcp://*:5555")
backend, _ := zmq.NewSocket(zmq.DEALER)
backend.Bind("tcp://*:5556")
zmq.Proxy(frontend, backend, nil)
}
func main() {
log.SetLevel(log.InfoLevel)
var configfile string
flag.StringVar(&configfile, "config", "./broker.json", "Broker JSON config file")
flag.Parse()
file, err := ioutil.ReadFile(configfile)
if err != nil {
log.Fatal("could not read config file: " + err.Error())
}
f := ConfigData{}
err = json.Unmarshal(file, &f)
if err != nil {
log.Fatal("could not parse config file: " + err.Error())
}
var c config
err = envconfig.Process("broker", &c)
if err != nil {
log.Fatal(err.Error())
}
// defaults to INFO
if c.LogLevel == "DEBUG" {
log.SetLevel(log.DebugLevel)
}
if c.LogLevel == "WARN" {
log.SetLevel(log.WarnLevel)
}
if c.LogLevel == "ERROR" {
log.SetLevel(log.ErrorLevel)
}
if c.LogLevel == "FATAL" {
log.SetLevel(log.FatalLevel)
}
pubsocket, _ := zmq.NewSocket(zmq.PUB)
repsocket, _ := zmq.NewSocket(zmq.REP)
defer pubsocket.Close()
defer repsocket.Close()
pubsocket.Bind(f.PubSocket)
repsocket.Bind(f.RepSocket)
log.Info("listening on ZMQ sockets")
var e envelope
for {
msg, _ := repsocket.Recv(0)
json.Unmarshal([]byte(msg), &e)
pubsocket.Send(e.Address, zmq.SNDMORE)
pubsocket.Send(e.Content, 0)
repsocket.Send("published", 0)
log.Debug("published message")
}
}
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)
}
}
}
}
}
}
func TestKvmsg(t *testing.T) {
// Prepare our context and sockets
output, err := zmq.NewSocket(zmq.DEALER)
if err != nil {
t.Error(err)
}
err = output.Bind("ipc://kvmsg_selftest.ipc")
if err != nil {
t.Error(err)
}
input, err := zmq.NewSocket(zmq.DEALER)
if err != nil {
t.Error(err)
}
err = input.Connect("ipc://kvmsg_selftest.ipc")
if err != nil {
t.Error(err)
}
kvmap := make(map[string]*Kvmsg)
// Test send and receive of simple message
kvmsg := NewKvmsg(1)
kvmsg.SetKey("key")
kvmsg.SetBody("body")
kvmsg.Dump()
err = kvmsg.Send(output)
kvmsg.Store(kvmap)
if err != nil {
t.Error(err)
}
kvmsg, err = RecvKvmsg(input)
if err != nil {
t.Error(err)
}
kvmsg.Dump()
key, err := kvmsg.GetKey()
if err != nil {
t.Error(err)
}
if key != "key" {
t.Error("Expected \"key\", got \"" + key + "\"")
}
kvmsg.Store(kvmap)
input.Close()
output.Close()
os.Remove("kvmsg_selftest.ipc")
}
func agent_new() (agent *agent_t) {
agent = &agent_t{
servers: make(map[string]*server_t),
actives: make([]*server_t, 0),
request: make([]string, 0),
reply: make([]string, 0),
}
agent.pipe, _ = zmq.NewSocket(zmq.PAIR)
agent.pipe.Connect("inproc://pipe")
agent.router, _ = zmq.NewSocket(zmq.ROUTER)
return
}
func main() {
snapshot, _ := zmq.NewSocket(zmq.DEALER)
snapshot.Connect("tcp://localhost:5556")
subscriber, _ := zmq.NewSocket(zmq.SUB)
subscriber.SetSubscribe("")
subscriber.Connect("tcp://localhost:5557")
time.Sleep(time.Second) // or messages between snapshot and next are lost
kvmap := make(map[string]*kvsimple.Kvmsg)
// Get state snapshot
sequence := int64(0)
snapshot.SendMessage("ICANHAZ?")
for {
kvmsg, err := kvsimple.RecvKvmsg(snapshot)
if err != nil {
fmt.Println(err)
break // Interrupted
}
if key, _ := kvmsg.GetKey(); key == "KTHXBAI" {
sequence, _ = kvmsg.GetSequence()
fmt.Printf("Received snapshot=%d\n", sequence)
break // Done
}
kvmsg.Store(kvmap)
}
snapshot.Close()
first := true
// Now apply pending updates, discard out-of-sequence messages
for {
kvmsg, err := kvsimple.RecvKvmsg(subscriber)
if err != nil {
fmt.Println(err)
break // Interrupted
}
if seq, _ := kvmsg.GetSequence(); seq > sequence {
sequence, _ = kvmsg.GetSequence()
kvmsg.Store(kvmap)
if first {
// Show what the first regular update is after the snapshot,
// to see if we missed updates.
first = false
fmt.Println("Next:", sequence)
}
}
}
}
func server_new(address string, port int, subtree string) (server *server_t) {
server = &server_t{}
fmt.Printf("I: adding server %s:%d...\n", address, port)
server.address = address
server.port = port
server.snapshot, _ = zmq.NewSocket(zmq.DEALER)
server.snapshot.Connect(fmt.Sprintf("%s:%d", address, port))
server.subscriber, _ = zmq.NewSocket(zmq.SUB)
server.subscriber.Connect(fmt.Sprintf("%s:%d", address, port+1))
server.subscriber.SetSubscribe(subtree)
return
}
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))
}
}
}
func main() {
// This is where the weather server sits
frontend, _ := zmq.NewSocket(zmq.XSUB)
defer frontend.Close()
frontend.Connect("tcp://192.168.55.210:5556")
// This is our public endpoint for subscribers
backend, _ := zmq.NewSocket(zmq.XPUB)
defer backend.Close()
backend.Bind("tcp://10.1.1.0:8100")
// Run the proxy until the user interrupts us
err := zmq.Proxy(frontend, backend, nil)
log.Fatalln("Proxy interrupted:", err)
}
func main() {
worker, _ := zmq.NewSocket(zmq.REQ)
defer worker.Close()
// Set random identity to make tracing easier
rand.Seed(time.Now().UnixNano())
identity := fmt.Sprintf("%04X-%04X", rand.Intn(0x10000), rand.Intn(0x10000))
worker.SetIdentity(identity)
worker.Connect("tcp://localhost:5556")
// Tell broker we're ready for work
fmt.Printf("I: (%s) worker ready\n", identity)
worker.Send(WORKER_READY, 0)
for cycles := 0; true; {
msg, err := worker.RecvMessage(0)
if err != nil {
break // Interrupted
}
// Simulate various problems, after a few cycles
cycles++
if cycles > 3 && rand.Intn(5) == 0 {
fmt.Printf("I: (%s) simulating a crash\n", identity)
break
} else if cycles > 3 && rand.Intn(5) == 0 {
fmt.Printf("I: (%s) simulating CPU overload\n", identity)
time.Sleep(3 * time.Second)
}
fmt.Printf("I: (%s) normal reply\n", identity)
time.Sleep(time.Second) // Do some heavy work
worker.SendMessage(msg)
}
}
func ClientTask(pipe chan<- bool) {
client, _ := zmq.NewSocket(zmq.DEALER)
client.Connect("tcp://localhost:5555")
fmt.Println("Setting up test...")
time.Sleep(100 * time.Millisecond)
fmt.Println("Synchronous round-trip test...")
start := time.Now()
var requests int
for requests = 0; requests < 10000; requests++ {
client.Send("hello", 0)
client.Recv(0)
}
fmt.Println(requests, "calls in", time.Since(start))
fmt.Println("Asynchronous round-trip test...")
start = time.Now()
for requests = 0; requests < 100000; requests++ {
client.Send("hello", 0)
}
for requests = 0; requests < 100000; requests++ {
client.Recv(0)
}
fmt.Println(requests, "calls in", time.Since(start))
pipe <- true
}
func main() {
// Socket to talk to server
fmt.Println("Connecting to hello world server…")
client, _ := zmq.NewSocket(zmq.REQ)
defer client.Close()
client.Connect("tcp://localhost:5555")
// Without signal handling, Go will exit on signal, even if the signal was caught by ZeroMQ
chSignal := make(chan os.Signal, 1)
signal.Notify(chSignal, syscall.SIGHUP, syscall.SIGINT, syscall.SIGQUIT, syscall.SIGTERM)
LOOP:
for {
client.Send("HELLO", 0)
reply, err := client.Recv(0)
if err != nil {
// signal was caught by 0MQ
log.Println("Client Recv:", err)
break
}
fmt.Println("Client:", reply)
time.Sleep(time.Second)
select {
case sig := <-chSignal:
// signal was caught by Go
log.Println("Signal:", sig)
break LOOP
default:
}
}
}
func client_task() {
var mu sync.Mutex
client, _ := zmq.NewSocket(zmq.DEALER)
defer client.Close()
// Set random identity to make tracing easier
set_id(client)
client.Connect("tcp://localhost:5570")
go func() {
for request_nbr := 1; true; request_nbr++ {
time.Sleep(time.Second)
mu.Lock()
client.SendMessage(fmt.Sprintf("request #%d", request_nbr))
mu.Unlock()
}
}()
for {
time.Sleep(10 * time.Millisecond)
mu.Lock()
msg, err := client.RecvMessage(zmq.NOBLOCK)
if err == nil {
id, _ := client.GetIdentity()
fmt.Println(msg[0], id)
}
mu.Unlock()
}
}
// 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
}
func main() {
broker, _ := zmq.NewSocket(zmq.ROUTER)
defer broker.Close()
broker.Bind("tcp://*:5671")
rand.Seed(time.Now().UnixNano())
for worker_nbr := 0; worker_nbr < NBR_WORKERS; worker_nbr++ {
go worker_task()
}
// Run for five seconds and then tell workers to end
start_time := time.Now()
workers_fired := 0
for {
// Next message gives us least recently used worker
identity, _ := broker.Recv(0)
broker.Send(identity, zmq.SNDMORE)
broker.Recv(0) // Envelope delimiter
broker.Recv(0) // Response from worker
broker.Send("", zmq.SNDMORE)
// Encourage workers until it's time to fire them
if time.Since(start_time) < 5*time.Second {
broker.Send("Work harder", 0)
} else {
broker.Send("Fired!", 0)
workers_fired++
if workers_fired == NBR_WORKERS {
break
}
}
}
time.Sleep(time.Second)
}
func worker_task() {
worker, _ := zmq.NewSocket(zmq.REQ)
defer worker.Close()
// set_id(worker)
worker.Connect("ipc://backend.ipc")
// Tell broker we're ready for work
worker.Send("READY", 0)
for {
// Read and save all frames until we get an empty frame
// In this example there is only 1 but it could be more
identity, _ := worker.Recv(0)
empty, _ := worker.Recv(0)
if empty != "" {
panic(fmt.Sprintf("empty is not \"\": %q", empty))
}
// Get request, send reply
request, _ := worker.Recv(0)
fmt.Println("Worker:", request)
worker.Send(identity, zmq.SNDMORE)
worker.Send("", zmq.SNDMORE)
worker.Send("OK", 0)
}
}
func main() {
// Prepare our socket
receiver, _ := zmq.NewSocket(zmq.PULL)
defer receiver.Close()
receiver.Bind("tcp://*:5558")
// Wait for start of batch
receiver.Recv(0)
// Start our clock now
start_time := time.Now()
// Process 100 confirmations
for task_nbr := 0; task_nbr < 100; task_nbr++ {
receiver.Recv(0)
if task_nbr%10 == 0 {
fmt.Print(":")
} else {
fmt.Print(".")
}
}
// Calculate and report duration of batch
fmt.Println("\nTotal elapsed time:", time.Since(start_time))
}
func TestIncre2(t *testing.T) {
// INCR using the same key and checks if the value increments properly
// value is an int array
// Socket connection setup
socket, _ := zmq.NewSocket(zmq.PUSH)
err := socket.Connect("tcp://localhost:" + strconv.Itoa(tcp_port))
defer socket.Close()
SocketFailHandler(err, t)
// Wait till the leaf under key is deleted by GC
key := "cart.seafood.basket1.item4"
WaitIfExists(key, t)
now := time.Now().Unix()
total := 0
for i := 0; i < 3; i++ {
// inserting leaf
msg := fmt.Sprintf("INCR %s %s %d", strconv.FormatInt(now, 10), key, i)
_, err = socket.SendBytes([]byte(msg), 0)
SocketSendFailHandler(err, t)
fmt.Printf("Sending %s...", msg)
total += i
// checking output
output_get, err_get := ReadGetServer(key, t)
FailHandler((err_get != nil || int(output_get[key].(float64)) != total), t)
}
}
func TestDuplicatesAppend(t *testing.T) {
// APPEND the same value to the same key
// Socket connection setup
socket, _ := zmq.NewSocket(zmq.PUSH)
err := socket.Connect("tcp://localhost:" + strconv.Itoa(tcp_port))
defer socket.Close()
SocketFailHandler(err, t)
// Wait till the leaf under key is deleted by GC
key := "cart.seafood.basket1.item8"
WaitIfExists(key, t)
now := time.Now().Unix()
value := []int{5}
msg := fmt.Sprintf("APPEND %s %s %d", strconv.FormatInt(now, 10), key, value)
for i := 0; i < 2; i++ {
// Inserting leaf
_, err = socket.SendBytes([]byte(msg), 0)
SocketSendFailHandler(err, t)
fmt.Printf("Sending %s...", msg)
// Checking output
output_get, _ := ReadGetServer(key, t)
output_value := fmt.Sprintf("%v", output_get[key])
if i == 0 {
FailHandler((output_value != "[5]"), t)
}
if i == 1 {
FailHandler((output_value != "[5 5]"), t)
}
}
}
func TestParamI(t *testing.T) {
// Testing the "i" parameter by querying i=2...
// Socket connection setup
socket, _ := zmq.NewSocket(zmq.PUSH)
err := socket.Connect("tcp://localhost:" + strconv.Itoa(tcp_port))
defer socket.Close()
SocketFailHandler(err, t)
// Wait till the leaf under key is deleted by GC
key := "cart.seafood.basket1.item10"
WaitIfExists(key, t)
now := time.Now().Unix()
for i := 0; i < 2; i++ {
// inserting leaf
msg := fmt.Sprintf("INCR %s %s %d", strconv.FormatInt(now+int64(i), 10), key, i)
_, err = socket.SendBytes([]byte(msg), 0)
SocketSendFailHandler(err, t)
fmt.Printf("Sending %s...(GOOD)\n", msg)
}
// checking output
key = key + "&i=2"
output_get, err_get := ReadGetServer(key, t)
fmt.Printf("Verifying output of i=2...")
FailHandler((err_get != nil || output_get[key].(float64) != 0.25), t)
}
