func (s *Sidecar) run() {
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
}()
}
ch := make(chan os.Signal, 1)
signal.Notify(ch, syscall.SIGTERM, syscall.SIGINT, syscall.SIGKILL)
<-ch
}
func (h *httpBroker) Subscribe(topic string, handler Handler, opts ...SubscribeOption) (Subscriber, error) {
opt := newSubscribeOptions(opts...)
// parse address for host, port
parts := strings.Split(h.Address(), ":")
host := strings.Join(parts[:len(parts)-1], ":")
port, _ := strconv.Atoi(parts[len(parts)-1])
id := uuid.NewUUID().String()
var secure bool
if h.opts.Secure || h.opts.TLSConfig != nil {
secure = true
}
// register service
node := ®istry.Node{
Id: h.id + "." + id,
Address: host,
Port: port,
Metadata: map[string]string{
"secure": fmt.Sprintf("%t", secure),
},
}
version := opt.Queue
if len(version) == 0 {
version = broadcastVersion
}
service := ®istry.Service{
Name: "topic:" + topic,
Version: version,
Nodes: []*registry.Node{node},
}
subscriber := &httpSubscriber{
opts: opt,
id: h.id + "." + id,
topic: topic,
ch: h.unsubscribe,
fn: handler,
svc: service,
}
if err := registry.Register(service); err != nil {
return nil, err
}
h.Lock()
h.subscribers[topic] = append(h.subscribers[topic], subscriber)
h.Unlock()
return subscriber, nil
}
func registerService(c *cli.Context) {
if len(c.Args()) != 1 {
fmt.Println("require service definition")
return
}
var service *registry.Service
if err := json.Unmarshal([]byte(c.Args().First()), &service); err != nil {
fmt.Println(err.Error())
return
}
if err := registry.Register(service); err != nil {
fmt.Println(err.Error())
return
}
}
func addService(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.Register(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 *service) register() error {
if s.srv == nil {
return nil
}
return registry.Register(s.srv, registry.RegisterTTL(s.opts.RegisterTTL))
}