func (s *httpServer) indexHandler(w http.ResponseWriter, req *http.Request) {
reqParams, err := util.NewReqParams(req)
if err != nil {
log.Printf("ERROR: failed to parse request params - %s", err.Error())
http.Error(w, "INVALID_REQUEST", 500)
return
}
var topics []string
if len(s.context.nsqadmin.options.NSQLookupdHTTPAddresses) != 0 {
topics, _ = lookupd.GetLookupdTopics(s.context.nsqadmin.options.NSQLookupdHTTPAddresses)
} else {
topics, _ = lookupd.GetNSQDTopics(s.context.nsqadmin.options.NSQDHTTPAddresses)
}
p := struct {
Title string
GraphOptions *GraphOptions
Topics Topics
Version string
}{
Title: "NSQ",
GraphOptions: NewGraphOptions(w, req, reqParams, s.context),
Topics: TopicsFromStrings(topics),
Version: util.BINARY_VERSION,
}
err = templates.T.ExecuteTemplate(w, "index.html", p)
if err != nil {
log.Printf("Template Error %s", err.Error())
http.Error(w, "Template Error", 500)
}
}
func nodesHandler(w http.ResponseWriter, req *http.Request) {
reqParams, err := util.NewReqParams(req)
if err != nil {
log.Printf("ERROR: failed to parse request params - %s", err.Error())
http.Error(w, "INVALID_REQUEST", 500)
return
}
producers, _ := getLookupdProducers(lookupdHTTPAddrs)
p := struct {
Title string
Version string
GraphOptions *GraphOptions
Producers []*Producer
}{
Title: "NSQ Nodes",
Version: util.BINARY_VERSION,
GraphOptions: NewGraphOptions(w, req, reqParams),
Producers: producers,
}
err = templates.ExecuteTemplate(w, "nodes.html", p)
if err != nil {
log.Printf("Template Error %s", err.Error())
http.Error(w, "Template Error", 500)
}
}
func (s *httpServer) doTombstoneTopicProducer(req *http.Request) (interface{}, error) {
reqParams, err := util.NewReqParams(req)
if err != nil {
return nil, util.HTTPError{400, "INVALID_REQUEST"}
}
topicName, err := reqParams.Get("topic")
if err != nil {
return nil, util.HTTPError{400, "MISSING_ARG_TOPIC"}
}
node, err := reqParams.Get("node")
if err != nil {
return nil, util.HTTPError{400, "MISSING_ARG_NODE"}
}
log.Printf("DB: setting tombstone for producer@%s of topic(%s)", node, topicName)
producers := s.context.nsqlookupd.DB.FindProducers("topic", topicName, "")
for _, p := range producers {
thisNode := fmt.Sprintf("%s:%d", p.peerInfo.BroadcastAddress, p.peerInfo.HttpPort)
if thisNode == node {
p.Tombstone()
}
}
return nil, nil
}
func (s *httpServer) statsHandler(w http.ResponseWriter, req *http.Request) {
reqParams, err := util.NewReqParams(req)
if err != nil {
log.Printf("ERROR: failed to parse request params - %s", err)
if acceptVersion(req) == 1 {
util.V1ApiResponse(w, 400, "INVALID_REQUEST")
} else {
// this handler always returns 500 for backwards compatibility
util.ApiResponse(w, 500, "INVALID_REQUEST", nil)
}
return
}
formatString, _ := reqParams.Get("format")
jsonFormat := formatString == "json"
stats := s.context.nsqd.GetStats()
if !jsonFormat {
s.doTextStats(stats, w)
return
}
if acceptVersion(req) == 1 {
util.V1ApiResponse(w, 200, struct {
Version string `json:"version"`
Topics []TopicStats `json:"topics"`
}{util.BINARY_VERSION, stats})
} else {
util.ApiResponse(w, 200, "OK", struct {
Version string `json:"version"`
Topics []TopicStats `json:"topics"`
}{util.BINARY_VERSION, stats})
}
}
func (s *httpServer) doLookup(req *http.Request) (interface{}, error) {
reqParams, err := util.NewReqParams(req)
if err != nil {
return nil, util.HTTPError{400, "INVALID_REQUEST"}
}
topicName, err := reqParams.Get("topic")
if err != nil {
return nil, util.HTTPError{400, "MISSING_ARG_TOPIC"}
}
registration := s.context.nsqlookupd.DB.FindRegistrations("topic", topicName, "")
if len(registration) == 0 {
return nil, util.HTTPError{404, "TOPIC_NOT_FOUND"}
}
channels := s.context.nsqlookupd.DB.FindRegistrations("channel", topicName, "*").SubKeys()
producers := s.context.nsqlookupd.DB.FindProducers("topic", topicName, "")
producers = producers.FilterByActive(s.context.nsqlookupd.options.InactiveProducerTimeout,
s.context.nsqlookupd.options.TombstoneLifetime)
return map[string]interface{}{
"channels": channels,
"producers": producers.PeerInfo(),
}, nil
}
func tombstoneTopicProducerHandler(w http.ResponseWriter, req *http.Request) {
reqParams, err := util.NewReqParams(req)
if err != nil {
util.ApiResponse(w, 500, "INVALID_REQUEST", nil)
return
}
topicName, err := reqParams.Get("topic")
if err != nil {
util.ApiResponse(w, 500, "MISSING_ARG_TOPIC", nil)
return
}
node, err := reqParams.Get("node")
if err != nil {
util.ApiResponse(w, 500, "MISSING_ARG_NODE", nil)
return
}
log.Printf("DB: setting tombstone for producer@%s of topic(%s)", node, topicName)
producers := lookupd.DB.FindProducers("topic", topicName, "")
for _, p := range producers {
thisNode := fmt.Sprintf("%s:%d", p.peerInfo.BroadcastAddress, p.peerInfo.HttpPort)
if thisNode == node {
p.Tombstone()
}
}
util.ApiResponse(w, 200, "OK", nil)
}
func (s *httpServer) doPauseTopic(req *http.Request) error {
reqParams, err := util.NewReqParams(req)
if err != nil {
log.Printf("ERROR: failed to parse request params - %s", err)
return httpError{400, "INVALID_REQUEST"}
}
topicName, err := reqParams.Get("topic")
if err != nil {
return httpError{400, "MISSING_ARG_TOPIC"}
}
topic, err := s.context.nsqd.GetExistingTopic(topicName)
if err != nil {
return httpError{404, "TOPIC_NOT_FOUND"}
}
if strings.Contains(req.URL.Path, "unpause") {
err = topic.UnPause()
} else {
err = topic.Pause()
}
if err != nil {
log.Printf("ERROR: failure in %s - %s", req.URL.Path, err)
return httpError{500, "INTERNAL_ERROR"}
}
return nil
}
func deleteChannelHandler(w http.ResponseWriter, req *http.Request) {
reqParams, err := util.NewReqParams(req)
if err != nil {
util.ApiResponse(w, 500, "INVALID_REQUEST", nil)
return
}
topicName, channelName, err := util.GetTopicChannelArgs(reqParams)
if err != nil {
util.ApiResponse(w, 500, err.Error(), nil)
return
}
registrations := lookupd.DB.FindRegistrations("channel", topicName, channelName)
if len(registrations) == 0 {
util.ApiResponse(w, 404, "NOT_FOUND", nil)
return
}
log.Printf("DB: removing channel(%s) from topic(%s)", channelName, topicName)
for _, registration := range registrations {
lookupd.DB.RemoveRegistration(*registration)
}
util.ApiResponse(w, 200, "OK", nil)
}
func (s *httpServer) doEmptyTopic(req *http.Request) error {
reqParams, err := util.NewReqParams(req)
if err != nil {
log.Printf("ERROR: failed to parse request params - %s", err)
return httpError{400, "INVALID_REQUEST"}
}
topicName, err := reqParams.Get("topic")
if err != nil {
return httpError{400, "MISSING_ARG_TOPIC"}
}
if !util.IsValidTopicName(topicName) {
return httpError{400, "INVALID_TOPIC"}
}
topic, err := s.context.nsqd.GetExistingTopic(topicName)
if err != nil {
return httpError{404, "TOPIC_NOT_FOUND"}
}
err = topic.Empty()
if err != nil {
return httpError{500, "INTERNAL_ERROR"}
}
return nil
}
func putHandler(w http.ResponseWriter, req *http.Request) {
reqParams, err := util.NewReqParams(req)
if err != nil {
log.Printf("ERROR: failed to parse request params - %s", err.Error())
util.ApiResponse(w, 500, "INVALID_REQUEST", nil)
return
}
topicName, err := reqParams.Get("topic")
if err != nil {
util.ApiResponse(w, 500, "MISSING_ARG_TOPIC", nil)
return
}
if !nsq.IsValidTopicName(topicName) {
util.ApiResponse(w, 500, "INVALID_ARG_TOPIC", nil)
return
}
if int64(len(reqParams.Body)) > nsqd.options.maxMessageSize {
util.ApiResponse(w, 500, "MSG_TOO_BIG", nil)
return
}
topic := nsqd.GetTopic(topicName)
msg := nsq.NewMessage(<-nsqd.idChan, reqParams.Body)
err = topic.PutMessage(msg)
if err != nil {
util.ApiResponse(w, 500, "NOK", nil)
return
}
w.Header().Set("Content-Length", "2")
io.WriteString(w, "OK")
}
func emptyChannelHandler(w http.ResponseWriter, req *http.Request) {
reqParams, err := util.NewReqParams(req)
if err != nil {
log.Printf("ERROR: failed to parse request params - %s", err.Error())
util.ApiResponse(w, 500, "INVALID_REQUEST", nil)
return
}
topicName, channelName, err := util.GetTopicChannelArgs(reqParams)
if err != nil {
util.ApiResponse(w, 500, err.Error(), nil)
return
}
topic, err := nsqd.GetExistingTopic(topicName)
if err != nil {
util.ApiResponse(w, 500, "INVALID_TOPIC", nil)
return
}
channel, err := topic.GetExistingChannel(channelName)
if err != nil {
util.ApiResponse(w, 500, "INVALID_CHANNEL", nil)
return
}
err = channel.Empty()
if err != nil {
util.ApiResponse(w, 500, "INTERNAL_ERROR", nil)
return
}
util.ApiResponse(w, 200, "OK", nil)
}
func (s *httpServer) pauseTopicHandler(w http.ResponseWriter, req *http.Request) {
reqParams, err := util.NewReqParams(req)
if err != nil {
log.Printf("ERROR: failed to parse request params - %s", err.Error())
util.ApiResponse(w, 500, "INVALID_REQUEST", nil)
return
}
topicName, err := reqParams.Get("topic")
if err != nil {
util.ApiResponse(w, 500, "MISSING_ARG_TOPIC", nil)
return
}
topic, err := s.context.nsqd.GetExistingTopic(topicName)
if err != nil {
util.ApiResponse(w, 500, "INVALID_TOPIC", nil)
return
}
if strings.HasPrefix(req.URL.Path, "/pause") {
err = topic.Pause()
} else {
err = topic.UnPause()
}
if err != nil {
log.Printf("ERROR: failure in %s - %s", req.URL.Path, err.Error())
}
util.ApiResponse(w, 200, "OK", nil)
}
func (s *httpServer) nodesHandler(w http.ResponseWriter, req *http.Request) {
reqParams, err := util.NewReqParams(req)
if err != nil {
log.Printf("ERROR: failed to parse request params - %s", err.Error())
http.Error(w, "INVALID_REQUEST", 500)
return
}
producers, _ := lookupd.GetLookupdProducers(s.context.nsqadmin.options.NSQLookupdHTTPAddresses)
p := struct {
Title string
Version string
GraphOptions *GraphOptions
Producers []*lookupd.Producer
Lookupd []string
}{
Title: "NSQ Nodes",
Version: util.BINARY_VERSION,
GraphOptions: NewGraphOptions(w, req, reqParams, s.context),
Producers: producers,
Lookupd: s.context.nsqadmin.options.NSQLookupdHTTPAddresses,
}
err = templates.T.ExecuteTemplate(w, "nodes.html", p)
if err != nil {
log.Printf("Template Error %s", err.Error())
http.Error(w, "Template Error", 500)
}
}
func deleteTopicHandler(w http.ResponseWriter, req *http.Request) {
reqParams, err := util.NewReqParams(req)
if err != nil {
util.ApiResponse(w, 500, "INVALID_REQUEST", nil)
return
}
topicName, err := reqParams.Get("topic")
if err != nil {
util.ApiResponse(w, 500, "MISSING_ARG_TOPIC", nil)
return
}
registrations := lookupd.DB.FindRegistrations("channel", topicName, "*")
for _, registration := range registrations {
log.Printf("DB: removing channel(%s) from topic(%s)", registration.SubKey, topicName)
lookupd.DB.RemoveRegistration(*registration)
}
registrations = lookupd.DB.FindRegistrations("topic", topicName, "")
for _, registration := range registrations {
log.Printf("DB: removing topic(%s)", topicName)
lookupd.DB.RemoveRegistration(*registration)
}
util.ApiResponse(w, 200, "OK", nil)
}
func (s *httpServer) doDeleteTopic(req *http.Request) (interface{}, error) {
reqParams, err := util.NewReqParams(req)
if err != nil {
return nil, util.HTTPError{400, "INVALID_REQUEST"}
}
topicName, err := reqParams.Get("topic")
if err != nil {
return nil, util.HTTPError{400, "MISSING_ARG_TOPIC"}
}
registrations := s.context.nsqlookupd.DB.FindRegistrations("channel", topicName, "*")
for _, registration := range registrations {
log.Printf("DB: removing channel(%s) from topic(%s)", registration.SubKey, topicName)
s.context.nsqlookupd.DB.RemoveRegistration(registration)
}
registrations = s.context.nsqlookupd.DB.FindRegistrations("topic", topicName, "")
for _, registration := range registrations {
log.Printf("DB: removing topic(%s)", topicName)
s.context.nsqlookupd.DB.RemoveRegistration(registration)
}
return nil, nil
}
func lookupHandler(w http.ResponseWriter, req *http.Request) {
reqParams, err := util.NewReqParams(req)
if err != nil {
util.ApiResponse(w, 500, "INVALID_REQUEST", nil)
return
}
topicName, err := reqParams.Get("topic")
if err != nil {
util.ApiResponse(w, 500, "MISSING_ARG_TOPIC", nil)
return
}
registration := lookupd.DB.FindRegistrations("topic", topicName, "")
if len(registration) == 0 {
util.ApiResponse(w, 500, "INVALID_ARG_TOPIC", nil)
return
}
channels := lookupd.DB.FindRegistrations("channel", topicName, "*").SubKeys()
producers := lookupd.DB.FindProducers("topic", topicName, "")
producers = producers.FilterByActive(lookupd.inactiveProducerTimeout, lookupd.tombstoneLifetime)
data := make(map[string]interface{})
data["channels"] = channels
data["producers"] = producers.PeerInfo()
util.ApiResponse(w, 200, "OK", data)
}
func (s *httpServer) pauseChannelHandler(w http.ResponseWriter, req *http.Request) {
reqParams, err := util.NewReqParams(req)
if err != nil {
log.Printf("ERROR: failed to parse request params - %s", err.Error())
util.ApiResponse(w, 500, "INVALID_REQUEST", nil)
return
}
topicName, channelName, err := util.GetTopicChannelArgs(reqParams)
if err != nil {
util.ApiResponse(w, 500, err.Error(), nil)
return
}
topic, err := s.context.nsqd.GetExistingTopic(topicName)
if err != nil {
util.ApiResponse(w, 500, "INVALID_TOPIC", nil)
return
}
channel, err := topic.GetExistingChannel(channelName)
if err != nil {
util.ApiResponse(w, 500, "INVALID_CHANNEL", nil)
return
}
if strings.HasPrefix(req.URL.Path, "/pause") {
channel.Pause()
} else {
channel.UnPause()
}
util.ApiResponse(w, 200, "OK", nil)
}
func (s *httpServer) deleteChannelHandler(w http.ResponseWriter, req *http.Request) {
reqParams, err := util.NewReqParams(req)
if err != nil {
log.Printf("ERROR: failed to parse request params - %s", err.Error())
util.ApiResponse(w, 500, "INVALID_REQUEST", nil)
return
}
topicName, channelName, err := util.GetTopicChannelArgs(reqParams)
if err != nil {
util.ApiResponse(w, 500, err.Error(), nil)
return
}
topic, err := s.context.nsqd.GetExistingTopic(topicName)
if err != nil {
util.ApiResponse(w, 500, "INVALID_TOPIC", nil)
return
}
err = topic.DeleteExistingChannel(channelName)
if err != nil {
util.ApiResponse(w, 500, "INVALID_CHANNEL", nil)
return
}
util.ApiResponse(w, 200, "OK", nil)
}
func (s *httpServer) emptyTopicHandler(w http.ResponseWriter, req *http.Request) {
reqParams, err := util.NewReqParams(req)
if err != nil {
log.Printf("ERROR: failed to parse request params - %s", err.Error())
util.ApiResponse(w, 500, "INVALID_REQUEST", nil)
return
}
topicName, err := reqParams.Get("topic")
if err != nil {
util.ApiResponse(w, 500, "MISSING_ARG_TOPIC", nil)
return
}
if !nsq.IsValidTopicName(topicName) {
util.ApiResponse(w, 500, "INVALID_TOPIC", nil)
return
}
topic, err := s.context.nsqd.GetExistingTopic(topicName)
if err != nil {
util.ApiResponse(w, 500, "INVALID_TOPIC", nil)
return
}
err = topic.Empty()
if err != nil {
util.ApiResponse(w, 500, "INTERNAL_ERROR", nil)
return
}
util.ApiResponse(w, 200, "OK", nil)
}
func (s *httpServer) graphiteDataHandler(w http.ResponseWriter, req *http.Request) {
reqParams, err := util.NewReqParams(req)
if err != nil {
log.Printf("ERROR: failed to parse request params - %s", err.Error())
http.Error(w, "INVALID_REQUEST", 500)
return
}
metric, err := reqParams.Get("metric")
if err != nil {
log.Printf("ERROR: missing metric param - %s", err.Error())
http.Error(w, "MISSING_METRIC_PARAM", 500)
return
}
target, err := reqParams.Get("target")
if err != nil {
log.Printf("ERROR: missing target param - %s", err.Error())
http.Error(w, "MISSING_TARGET_PARAM", 500)
return
}
var queryFunc func(string) string
var formatJsonResponseFunc func([]byte) ([]byte, error)
switch metric {
case "rate":
queryFunc = rateQuery
formatJsonResponseFunc = parseRateResponse
default:
log.Printf("ERROR: unknown metric value %s", metric)
http.Error(w, "INVALID_METRIC_PARAM", 500)
return
}
query := queryFunc(target)
url := s.context.nsqadmin.options.GraphiteURL + query
log.Printf("GRAPHITE: %s", url)
response, err := GraphiteGet(url)
if err != nil {
log.Printf("ERROR: graphite request failed %s", err.Error())
http.Error(w, "GRAPHITE_FAILED", 500)
return
}
resp, err := formatJsonResponseFunc(response)
if err != nil {
log.Printf("ERROR: response formating failed - %s", err.Error())
http.Error(w, "INVALID_GRAPHITE_RESPONSE", 500)
return
}
w.Header().Set("Content-Type", "application/json")
w.Write(resp)
return
}
func (s *httpServer) channelHandler(w http.ResponseWriter, req *http.Request, topicName string, channelName string) {
reqParams, err := util.NewReqParams(req)
if err != nil {
s.ctx.nsqadmin.logf("ERROR: failed to parse request params - %s", err)
http.Error(w, "INVALID_REQUEST", 500)
return
}
producers := s.getProducers(topicName)
_, allChannelStats, _ := lookupd.GetNSQDStats(producers, topicName)
channelStats, ok := allChannelStats[channelName]
if !ok {
s.ctx.nsqadmin.logf("ERROR: channel stats do not exist")
http.Error(w, "INVALID_REQUEST", 500)
return
}
hasE2eLatency := channelStats.E2eProcessingLatency != nil &&
len(channelStats.E2eProcessingLatency.Percentiles) > 0
var firstHost *lookupd.ChannelStats
if len(channelStats.HostStats) > 0 {
firstHost = channelStats.HostStats[0]
}
p := struct {
Title string
GraphOptions *GraphOptions
Version string
Topic string
Channel string
TopicProducers []string
ChannelStats *lookupd.ChannelStats
FirstHost *lookupd.ChannelStats
HasE2eLatency bool
}{
Title: fmt.Sprintf("NSQ %s / %s", topicName, channelName),
GraphOptions: NewGraphOptions(w, req, reqParams, s.ctx),
Version: util.BINARY_VERSION,
Topic: topicName,
Channel: channelName,
TopicProducers: producers,
ChannelStats: channelStats,
FirstHost: firstHost,
HasE2eLatency: hasE2eLatency,
}
err = templates.T.ExecuteTemplate(w, "channel.html", p)
if err != nil {
s.ctx.nsqadmin.logf("Template Error %s", err)
http.Error(w, "Template Error", 500)
}
}
// 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 := util.NewReqParams(req)
if err != nil {
log.Printf("ERROR: failed to parse request params - %s", err.Error())
util.ApiResponse(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.context.nsqadmin.options.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
util.ApiResponse(w, 200, "OK", data)
}
func (s *httpServer) doChannels(req *http.Request) (interface{}, error) {
reqParams, err := util.NewReqParams(req)
if err != nil {
return nil, util.HTTPError{400, "INVALID_REQUEST"}
}
topicName, err := reqParams.Get("topic")
if err != nil {
return nil, util.HTTPError{400, "MISSING_ARG_TOPIC"}
}
channels := s.context.nsqlookupd.DB.FindRegistrations("channel", topicName, "*").SubKeys()
return map[string]interface{}{
"channels": channels,
}, nil
}
func channelsHandler(w http.ResponseWriter, req *http.Request) {
reqParams, err := util.NewReqParams(req)
if err != nil {
util.ApiResponse(w, 500, "INVALID_REQUEST", nil)
return
}
topicName, err := reqParams.Get("topic")
if err != nil {
util.ApiResponse(w, 500, "MISSING_ARG_TOPIC", nil)
return
}
channels := lookupd.DB.FindRegistrations("channel", topicName, "*").SubKeys()
data := make(map[string]interface{})
data["channels"] = channels
util.ApiResponse(w, 200, "OK", data)
}
func (s *httpServer) mputHandler(w http.ResponseWriter, req *http.Request) {
if req.Method != "POST" {
util.ApiResponse(w, 500, "INVALID_REQUEST", nil)
return
}
reqParams, err := util.NewReqParams(req)
if err != nil {
log.Printf("ERROR: failed to parse request params - %s", err.Error())
util.ApiResponse(w, 500, "INVALID_REQUEST", nil)
return
}
topicName, err := reqParams.Get("topic")
if err != nil {
util.ApiResponse(w, 500, "MISSING_ARG_TOPIC", nil)
return
}
if !nsq.IsValidTopicName(topicName) {
util.ApiResponse(w, 500, "INVALID_ARG_TOPIC", nil)
return
}
topic := s.context.nsqd.GetTopic(topicName)
for _, block := range bytes.Split(reqParams.Body, []byte("\n")) {
if len(block) != 0 {
if int64(len(reqParams.Body)) > s.context.nsqd.options.maxMessageSize {
util.ApiResponse(w, 500, "MSG_TOO_BIG", nil)
return
}
msg := nsq.NewMessage(<-s.context.nsqd.idChan, block)
err := topic.PutMessage(msg)
if err != nil {
util.ApiResponse(w, 500, "NOK", nil)
return
}
}
}
w.Header().Set("Content-Length", "2")
io.WriteString(w, "OK")
}
func (s *httpServer) doStats(req *http.Request) (interface{}, error) {
reqParams, err := util.NewReqParams(req)
if err != nil {
log.Printf("ERROR: failed to parse request params - %s", err)
return nil, util.HTTPError{400, "INVALID_REQUEST"}
}
formatString, _ := reqParams.Get("format")
jsonFormat := formatString == "json"
stats := s.context.nsqd.GetStats()
if !jsonFormat {
return s.printStats(stats), nil
}
return struct {
Version string `json:"version"`
Topics []TopicStats `json:"topics"`
}{util.BINARY_VERSION, stats}, nil
}
func (s *httpServer) getExistingTopicFromQuery(req *http.Request) (*util.ReqParams, *Topic, string, error) {
reqParams, err := util.NewReqParams(req)
if err != nil {
log.Printf("ERROR: failed to parse request params - %s", err)
return nil, nil, "", httpError{400, "INVALID_REQUEST"}
}
topicName, channelName, err := util.GetTopicChannelArgs(reqParams)
if err != nil {
return nil, nil, "", httpError{400, err.Error()}
}
topic, err := s.context.nsqd.GetExistingTopic(topicName)
if err != nil {
return nil, nil, "", httpError{404, "TOPIC_NOT_FOUND"}
}
return reqParams, topic, channelName, err
}
func (s *httpServer) doDeleteTopic(req *http.Request) error {
reqParams, err := util.NewReqParams(req)
if err != nil {
log.Printf("ERROR: failed to parse request params - %s", err)
return httpError{400, "INVALID_REQUEST"}
}
topicName, err := reqParams.Get("topic")
if err != nil {
return httpError{400, "MISSING_ARG_TOPIC"}
}
err = s.context.nsqd.DeleteExistingTopic(topicName)
if err != nil {
return httpError{404, "TOPIC_NOT_FOUND"}
}
return nil
}
func channelHandler(w http.ResponseWriter, req *http.Request, topicName string, channelName string) {
reqParams, err := util.NewReqParams(req)
if err != nil {
log.Printf("ERROR: failed to parse request params - %s", err.Error())
http.Error(w, "INVALID_REQUEST", 500)
return
}
var producers []string
if len(lookupdHTTPAddrs) != 0 {
producers, _ = getLookupdTopicProducers(topicName, lookupdHTTPAddrs)
} else {
producers, _ = getNSQDTopicProducers(topicName, nsqdHTTPAddrs)
}
_, allChannelStats, _ := getNSQDStats(producers, topicName)
channelStats := allChannelStats[channelName]
p := struct {
Title string
GraphOptions *GraphOptions
Version string
Topic string
Channel string
TopicProducers []string
ChannelStats *ChannelStats
}{
Title: fmt.Sprintf("NSQ %s / %s", topicName, channelName),
GraphOptions: NewGraphOptions(w, req, reqParams),
Version: util.BINARY_VERSION,
Topic: topicName,
Channel: channelName,
TopicProducers: producers,
ChannelStats: channelStats,
}
err = templates.ExecuteTemplate(w, "channel.html", p)
if err != nil {
log.Printf("Template Error %s", err.Error())
http.Error(w, "Template Error", 500)
}
}
func (s *httpServer) doCreateChannel(req *http.Request) (interface{}, error) {
reqParams, err := util.NewReqParams(req)
if err != nil {
return nil, util.HTTPError{400, "INVALID_REQUEST"}
}
topicName, channelName, err := util.GetTopicChannelArgs(reqParams)
if err != nil {
return nil, util.HTTPError{400, err.Error()}
}
log.Printf("DB: adding channel(%s) in topic(%s)", channelName, topicName)
key := Registration{"channel", topicName, channelName}
s.context.nsqlookupd.DB.AddRegistration(key)
log.Printf("DB: adding topic(%s)", topicName)
key = Registration{"topic", topicName, ""}
s.context.nsqlookupd.DB.AddRegistration(key)
return nil, nil
}