gistfile1.go

package main

import (
  "./msg"
  "code.google.com/p/goprotobuf/proto"
  "fmt"
  "io/ioutil"
  "log"
  "net/http"
  "time"
)

type Bidder struct {
  Name string
  Host string
  Port int
}

type BidderResponse struct {
  Resp *msg.BidResponse
  Err  error
}

type Server struct {
  Channel chan BidderResponse
}

func NewServer(c chan BidderResponse) *Server {
  return &Server{c}
}

func setupBidders () []Bidder {
  bidders := make([]Bidder, 0)
  bidders = append(bidders, Bidder{"Videologie", "localhost", 8085})
  bidders = append(bidders, Bidder{"TapAd", "localhost", 8086})
  bidders = append(bidders, Bidder{"Vistar Media", "localhost", 8087})
  return bidders
}

func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) {
  bidRes := &msg.BidResponse{}
  bytes, err := ioutil.ReadAll(r.Body)
  r.Body.Close()

  err = proto.Unmarshal(bytes, bidRes)
  if err != nil {
    s.Channel <- BidderResponse{nil, err}
    log.Printf(err.Error())
    http.Error(w, err.Error(), 400)
  }

  s.Channel <- BidderResponse{bidRes, nil}
}

func spawnServer(port int, c chan BidderResponse) {
  portStr := fmt.Sprintf("%d", port)
  server := NewServer(c)
  err := http.ListenAndServe(":" + portStr, server)
  if err != nil {
    log.Fatalf("Error starting server: %s", err.Error())
  }
}

func spawnAllServers(c chan BidderResponse) {
  bidders := setupBidders()
  for _, bidder := range bidders {
    go spawnServer(bidder.Port, c)
  }

  responses := make([]BidderResponse, 0)
  timeout := time.After(20 * time.Second)

  for len(responses) < len(bidders) {
    select {
      case result := <-c:
        responses = append(responses, result)
      case <-timeout:
        fmt.Print("Timed out\n")
        return
    }
  }

  for _, resp := range responses {
    log.Printf("Response: %s", resp.Resp.DebugString)
  }
}

func main() {
  c := make(chan BidderResponse)
  spawnAllServers(c)
}