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() {
// 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() {
// 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() {
// 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 main() {
// Start authentication engine
zmq.AuthSetVerbose(true)
zmq.AuthStart()
zmq.AuthAllow("domain1", "127.0.0.1")
// Tell the authenticator how to handle PLAIN requests
zmq.AuthPlainAdd("domain1", "admin", "secret")
// Create and bind server socket
server, _ := zmq.NewSocket(zmq.PUSH)
server.ServerAuthPlain("domain1")
server.Bind("tcp://*:9000")
// Create and connect client socket
client, _ := zmq.NewSocket(zmq.PULL)
client.SetPlainUsername("admin")
client.SetPlainPassword("secret")
client.Connect("tcp://127.0.0.1:9000")
// Send a single message from server to client
_, err := server.Send("Hello", 0)
checkErr(err)
message, err := client.Recv(0)
checkErr(err)
if message != "Hello" {
log.Fatalln(message, "!= Hello")
}
zmq.AuthStop()
fmt.Println("Woodhouse test OK")
}
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 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() {
// 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 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() {
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 Example_test_abstract_ipc() {
addr := "ipc://@/tmp/tester"
// This is Linux only
if runtime.GOOS != "linux" {
fmt.Printf("%q\n", addr)
fmt.Println("Done")
return
}
sb, err := zmq.NewSocket(zmq.PAIR)
if checkErr(err) {
return
}
err = sb.Bind(addr)
if checkErr(err) {
return
}
endpoint, err := sb.GetLastEndpoint()
if checkErr(err) {
return
}
fmt.Printf("%q\n", endpoint)
sc, err := zmq.NewSocket(zmq.PAIR)
if checkErr(err) {
return
}
err = sc.Connect(addr)
if checkErr(err) {
return
}
bounce(sb, sc, false)
err = sc.Close()
if checkErr(err) {
return
}
err = sb.Close()
if checkErr(err) {
return
}
fmt.Println("Done")
// Output:
// "ipc://@/tmp/tester"
// Done
}
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.SetRcvhwm(100000) // or messages between snapshot and next are lost
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 worker_task() {
worker, _ := zmq.NewSocket(zmq.DEALER)
defer worker.Close()
set_id(worker) // Set a printable identity
worker.Connect("tcp://localhost:5671")
total := 0
for {
// Tell the broker we're ready for work
worker.Send("", zmq.SNDMORE)
worker.Send("Hi Boss", 0)
// Get workload from broker, until finished
worker.Recv(0) // Envelope delimiter
workload, _ := worker.Recv(0)
if workload == "Fired!" {
fmt.Printf("Completed: %d tasks\n", total)
break
}
total++
// Do some random work
time.Sleep(time.Duration(rand.Intn(500)+1) * time.Millisecond)
}
}
func main() {
if len(os.Args) < 2 {
fmt.Printf("I: syntax: %s <endpoint>\n", os.Args[0])
return
}
server, _ := zmq.NewSocket(zmq.REP)
server.Bind(os.Args[1])
fmt.Println("I: service is ready at", os.Args[1])
for {
request, err := server.RecvMessage(0)
if err != nil {
break // Interrupted
}
// Fail nastily if run against wrong client
if len(request) != 2 {
panic("len(request) != 2")
}
identity := request[0]
server.SendMessage(identity, "OK")
}
fmt.Println("W: interrupted")
}
func main() {
publisher, _ := zmq.NewSocket(zmq.PUB)
if len(os.Args) == 2 {
publisher.Connect(os.Args[1])
} else {
publisher.Bind("tcp://*:5556")
}
// Ensure subscriber connection has time to complete
time.Sleep(time.Second)
// Send out all 1,000 topic messages
for topic_nbr := 0; topic_nbr < 1000; topic_nbr++ {
_, err := publisher.SendMessage(fmt.Sprintf("%03d", topic_nbr), "Save Roger")
if err != nil {
fmt.Println(err)
}
}
// Send one random update per second
rand.Seed(time.Now().UnixNano())
for {
time.Sleep(time.Second)
_, err := publisher.SendMessage(fmt.Sprintf("%03d", rand.Intn(1000)), "Off with his head!")
if err != nil {
fmt.Println(err)
}
}
}
func Example_test_connect_resolve() {
sock, err := zmq.NewSocket(zmq.PUB)
if checkErr(err) {
return
}
err = sock.Connect("tcp://localhost:1234")
checkErr(err)
err = sock.Connect("tcp://localhost:invalid")
fmt.Println(e(err, true))
err = sock.Connect("tcp://in val id:1234")
fmt.Println(e(err, true))
err = sock.Connect("invalid://localhost:1234")
fmt.Println(e(err, true))
err = sock.Close()
checkErr(err)
fmt.Println("Done")
// Output:
// error
// error
// error
// Done
}
func Example_test_ctx_options() {
i, err := zmq.GetMaxSockets()
fmt.Println(i == zmq.MaxSocketsDflt, err)
i, err = zmq.GetIoThreads()
fmt.Println(i == zmq.IoThreadsDflt, err)
b, err := zmq.GetIpv6()
fmt.Println(b, err)
zmq.SetIpv6(true)
b, err = zmq.GetIpv6()
fmt.Println(b, err)
router, _ := zmq.NewSocket(zmq.ROUTER)
b, err = router.GetIpv6()
fmt.Println(b, err)
fmt.Println(router.Close())
zmq.SetIpv6(false)
fmt.Println("Done")
// Output:
// true <nil>
// true <nil>
// false <nil>
// true <nil>
// true <nil>
// <nil>
// Done
}
func client_thread(pipe chan<- string) {
dealer, _ := zmq.NewSocket(zmq.DEALER)
dealer.Connect("tcp://127.0.0.1:6000")
// Up to this many chunks in transit
credit := PIPELINE
total := 0 // Total bytes received
chunks := 0 // Total chunks received
offset := 0 // Offset of next chunk request
for {
for credit > 0 {
// Ask for next chunk
dealer.SendMessage("fetch", offset, CHUNK_SIZE)
offset += CHUNK_SIZE
credit--
}
chunk, err := dealer.RecvBytes(0)
if err != nil {
break // Shutting down, quit
}
chunks++
credit++
size := len(chunk)
total += size
if size < CHUNK_SIZE {
break // Last chunk received; exit
}
}
fmt.Printf("%v chunks received, %v bytes\n", chunks, total)
pipe <- "OK"
}
// 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() {
subscriber, _ := zmq.NewSocket(zmq.SUB)
if len(os.Args) == 2 {
subscriber.Connect(os.Args[1])
} else {
subscriber.Connect("tcp://localhost:5556")
}
rand.Seed(time.Now().UnixNano())
subscription := fmt.Sprintf("%03d", rand.Intn(1000))
subscriber.SetSubscribe(subscription)
for {
msg, err := subscriber.RecvMessage(0)
if err != nil {
break
}
topic := msg[0]
data := msg[1]
if topic != subscription {
panic("topic != subscription")
}
fmt.Println(data)
}
}
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 New() (flcliapi *Flcliapi) {
flcliapi = &Flcliapi{}
flcliapi.pipe, _ = zmq.NewSocket(zmq.PAIR)
flcliapi.pipe.Bind("inproc://pipe")
go flcliapi_agent()
return
}
func Example_socket_event() {
// REP socket
rep, err := zmq.NewSocket(zmq.REP)
if checkErr(err) {
return
}
// REP socket monitor, all events
err = rep.Monitor("inproc://monitor.rep", zmq.EVENT_ALL)
if checkErr(err) {
rep.Close()
return
}
go rep_socket_monitor("inproc://monitor.rep")
time.Sleep(time.Second)
// Generate an event
rep.Bind("tcp://*:9689")
if checkErr(err) {
rep.Close()
return
}
rep.Close()
// Allow some time for event detection
time.Sleep(time.Second)
fmt.Println("Done")
// Output:
// EVENT_LISTENING tcp://0.0.0.0:9689
// EVENT_CLOSED tcp://0.0.0.0:9689
// Done
}
func main() {
// Socket to talk to server
fmt.Println("Collecting updates from weather server...")
subscriber, _ := zmq.NewSocket(zmq.SUB)
defer subscriber.Close()
subscriber.Connect("tcp://localhost:5556")
// Subscribe to zipcode, default is NYC, 10001
filter := "10001 "
if len(os.Args) > 1 {
filter = os.Args[1] + " "
}
subscriber.SetSubscribe(filter)
// Process 100 updates
total_temp := 0
update_nbr := 0
for update_nbr < 100 {
msg, _ := subscriber.Recv(0)
if msgs := strings.Fields(msg); len(msgs) > 1 {
if temperature, err := strconv.Atoi(msgs[1]); err == nil {
total_temp += temperature
update_nbr++
}
}
}
fmt.Printf("Average temperature for zipcode '%s' was %dF \n\n", strings.TrimSpace(filter), total_temp/update_nbr)
}
