// this endpoint works by giving out an ID that maps to a stats dictionary
// The initial request is the number of messages processed since each nsqd started up.
// Subsequent requsts pass that ID and get an updated delta based on each individual channel/nsqd message count
// That ID must be re-requested or it will be expired.
func (s *httpServer) counterDataHandler(w http.ResponseWriter, req *http.Request) {
reqParams, err := http_api.NewReqParams(req)
if err != nil {
s.ctx.nsqadmin.logf("ERROR: failed to parse request params - %s", err)
http_api.Respond(w, 500, "INVALID_REQUEST", nil)
return
}
statsID, _ := reqParams.Get("id")
now := time.Now()
if statsID == "" {
// make a new one
statsID = fmt.Sprintf("%d.%d", now.Unix(), now.UnixNano())
}
stats, ok := s.counters[statsID]
if !ok {
stats = make(map[string]int64)
}
newStats := make(map[string]int64)
newStats["time"] = now.Unix()
producers, _ := lookupd.GetLookupdProducers(s.ctx.nsqadmin.opts.NSQLookupdHTTPAddresses)
addresses := make([]string, len(producers))
for i, p := range producers {
addresses[i] = p.HTTPAddress()
}
_, channelStats, _ := lookupd.GetNSQDStats(addresses, "")
var newMessages int64
var totalMessages int64
for _, channelStats := range channelStats {
for _, hostChannelStats := range channelStats.HostStats {
key := fmt.Sprintf("%s:%s:%s", channelStats.TopicName, channelStats.ChannelName, hostChannelStats.HostAddress)
d, ok := stats[key]
if ok && d <= hostChannelStats.MessageCount {
newMessages += (hostChannelStats.MessageCount - d)
}
totalMessages += hostChannelStats.MessageCount
newStats[key] = hostChannelStats.MessageCount
}
}
s.counters[statsID] = newStats
data := make(map[string]interface{})
data["new_messages"] = newMessages
data["total_messages"] = totalMessages
data["id"] = statsID
http_api.Respond(w, 200, "OK", data)
}
func (s *httpServer) ServeHTTP(w http.ResponseWriter, req *http.Request) {
if !s.tlsEnabled && s.tlsRequired {
http_api.Respond(w, 403, "TLS_REQUIRED", nil)
return
}
s.router.ServeHTTP(w, req)
}
func (s *httpServer) ServeHTTP(w http.ResponseWriter, req *http.Request) {
if !s.tlsEnabled && s.tlsRequired {
resp := fmt.Sprintf(`{"message": "TLS_REQUIRED", "https_port": %d}`,
s.ctx.nsqd.RealHTTPSAddr().Port)
http_api.Respond(w, 403, "", resp)
return
}
s.router.ServeHTTP(w, req)
}
func (s *httpServer) ServeHTTP(w http.ResponseWriter, req *http.Request) {
if !s.tlsEnabled && s.tlsRequired {
http_api.Respond(w, 403, "TLS_REQUIRED", nil)
return
}
err := s.v1Router(w, req)
if err == nil {
return
}
err = s.deprecatedRouter(w, req)
if err == nil {
return
}
err = s.debugRouter(w, req)
if err != nil {
s.ctx.nsqd.logf("ERROR: %s", err)
http_api.Respond(w, 404, "NOT_FOUND", nil)
}
}
func (s *httpServer) ServeHTTP(w http.ResponseWriter, req *http.Request) {
err := s.v1Router(w, req)
if err == nil {
return
}
err = s.deprecatedRouter(w, req)
if err == nil {
return
}
err = s.debugRouter(w, req)
if err != nil {
s.ctx.nsqlookupd.logf("ERROR: %s", err)
http_api.Respond(w, 404, "NOT_FOUND", nil)
}
}