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 opts []registry.RegisterOption // parse ttl if ttl := r.Form.Get("ttl"); len(ttl) > 0 { d, err := time.ParseDuration(ttl) if err == nil { opts = append(opts, registry.RegisterTTL(d)) } } var service *registry.Service err = json.Unmarshal(b, &service) if err != nil { http.Error(w, err.Error(), 500) return } err = (*cmd.DefaultOptions().Registry).Register(service, opts...) if err != nil { http.Error(w, err.Error(), 500) return } }
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]) addr, err := extractAddress(host) if err != nil { return nil, err } 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: addr, 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 := h.r.Register(service, registry.RegisterTTL(registerTTL)); err != nil { return nil, err } h.Lock() h.subscribers[topic] = append(h.subscribers[topic], subscriber) h.Unlock() return subscriber, nil }
func (h *httpServer) Register() error { h.Lock() opts := h.opts h.Unlock() service := serviceDef(opts) rOpts := []registry.RegisterOption{ registry.RegisterTTL(opts.RegisterTTL), } return opts.Registry.Register(service, rOpts...) }
func (h *httpBroker) run(l net.Listener) { t := time.NewTicker(registerInterval) defer t.Stop() for { select { // heartbeat for each subscriber case <-t.C: h.RLock() for _, subs := range h.subscribers { for _, sub := range subs { h.r.Register(sub.svc, registry.RegisterTTL(registerTTL)) } } h.RUnlock() // received exit signal case ch := <-h.exit: ch <- l.Close() h.Lock() h.running = false h.Unlock() return // unsubscribe subscriber case subscriber := <-h.unsubscribe: h.Lock() var subscribers []*httpSubscriber for _, sub := range h.subscribers[subscriber.topic] { if sub.id == subscriber.id { h.r.Deregister(sub.svc) } subscribers = append(subscribers, sub) } h.subscribers[subscriber.topic] = subscribers h.Unlock() } } }
func (s *rpcServer) Register() error { // parse address for host, port config := s.Options() var advt, host string var port int // check the advertise address first // if it exists then use it, otherwise // use the address if len(config.Advertise) > 0 { advt = config.Advertise } else { advt = config.Address } parts := strings.Split(advt, ":") if len(parts) > 1 { host = strings.Join(parts[:len(parts)-1], ":") port, _ = strconv.Atoi(parts[len(parts)-1]) } else { host = parts[0] } addr, err := extractAddress(host) if err != nil { return err } // register service node := ®istry.Node{ Id: config.Name + "-" + config.Id, Address: addr, Port: port, Metadata: config.Metadata, } node.Metadata["transport"] = config.Transport.String() node.Metadata["broker"] = config.Broker.String() node.Metadata["server"] = s.String() node.Metadata["registry"] = config.Registry.String() s.RLock() var endpoints []*registry.Endpoint for _, e := range s.handlers { // Only advertise non internal handlers if !e.Options().Internal { endpoints = append(endpoints, e.Endpoints()...) } } for e, _ := range s.subscribers { // Only advertise non internal subscribers if !e.Options().Internal { endpoints = append(endpoints, e.Endpoints()...) } } s.RUnlock() service := ®istry.Service{ Name: config.Name, Version: config.Version, Nodes: []*registry.Node{node}, Endpoints: endpoints, } s.Lock() registered := s.registered s.Unlock() if !registered { log.Printf("Registering node: %s", node.Id) } // create registry options rOpts := []registry.RegisterOption{registry.RegisterTTL(config.RegisterTTL)} if err := config.Registry.Register(service, rOpts...); err != nil { return err } // already registered? don't need to register subscribers if registered { return nil } s.Lock() defer s.Unlock() s.registered = true for sb, _ := range s.subscribers { handler := s.createSubHandler(sb, s.opts) var opts []broker.SubscribeOption if queue := sb.Options().Queue; len(queue) > 0 { opts = append(opts, broker.Queue(queue)) } sub, err := config.Broker.Subscribe(sb.Topic(), handler, opts...) if err != nil { return err } s.subscribers[sb] = []broker.Subscriber{sub} } return nil }
func (s *service) register() error { if s.srv == nil { return nil } return registry.Register(s.srv, registry.RegisterTTL(s.opts.RegisterTTL)) }