func (h *httpBroker) start() error {
h.Lock()
defer h.Unlock()
if h.running {
return nil
}
l, err := net.Listen("tcp", h.address)
if err != nil {
return err
}
log.Infof("Broker Listening on %s", l.Addr().String())
h.address = l.Addr().String()
go http.Serve(l, h)
go func() {
for {
select {
case ch := <-h.exit:
ch <- l.Close()
h.Lock()
h.running = false
h.Unlock()
return
case subscriber := <-h.unsubscribe:
h.Lock()
var subscribers []*httpSubscriber
for _, sub := range h.subscribers[subscriber.topic] {
if sub.id == subscriber.id {
registry.Deregister(sub.svc)
}
subscribers = append(subscribers, sub)
}
h.subscribers[subscriber.topic] = subscribers
h.Unlock()
}
}
}()
h.running = true
return nil
}
func delService(w http.ResponseWriter, r *http.Request) {
r.ParseForm()
b, err := ioutil.ReadAll(r.Body)
if err != nil {
http.Error(w, err.Error(), 500)
return
}
defer r.Body.Close()
var service *registry.Service
err = json.Unmarshal(b, &service)
if err != nil {
http.Error(w, err.Error(), 500)
return
}
err = registry.Deregister(service)
if err != nil {
http.Error(w, err.Error(), 500)
return
}
}
func (s *Sidecar) hcLoop(service *registry.Service, exitCh chan bool) {
tick := time.NewTicker(time.Second * 30)
registered := true
for {
select {
case <-tick.C:
_, err := s.hc()
if err != nil && registered {
log.Infof("Healthcheck error. Deregistering %v", service.Nodes[0].Id)
registry.Deregister(service)
registered = false
} else if err == nil && !registered {
log.Infof("Healthcheck success. Registering %v", service.Nodes[0].Id)
registry.Register(service)
registered = true
}
case <-exitCh:
return
}
}
}
func (s *Sidecar) Run() error {
parts := strings.Split(s.address, ":")
host := strings.Join(parts[:len(parts)-1], ":")
port, _ := strconv.Atoi(parts[len(parts)-1])
id := s.name + "-" + uuid.NewUUID().String()
node := ®istry.Node{
Id: id,
Address: host,
Port: port,
}
service := ®istry.Service{
Name: s.name,
Nodes: []*registry.Node{node},
}
log.Infof("Registering %s", node.Id)
registry.Register(service)
if len(s.hcUrl) > 0 {
log.Info("Starting sidecar healthchecker")
exitCh := make(chan bool, 1)
go s.hcLoop(service, exitCh)
defer func() {
exitCh <- true
}()
}
go s.serve()
ch := make(chan os.Signal, 1)
signal.Notify(ch, syscall.SIGTERM, syscall.SIGINT, syscall.SIGKILL)
log.Infof("Received signal %s", <-ch)
log.Infof("Deregistering %s", node.Id)
registry.Deregister(service)
return nil
}
