func main() {
flag.Parse()
if *broadcastAddress == "" {
hostname, err := os.Hostname()
if err != nil {
log.Fatal(err)
}
*broadcastAddress = hostname
}
if *showVersion {
fmt.Println(util.Version("nsqlookupd"))
return
}
signalChan := make(chan os.Signal, 1)
exitChan := make(chan int)
go func() {
<-signalChan
exitChan <- 1
}()
signal.Notify(signalChan, os.Interrupt)
tcpAddr, err := net.ResolveTCPAddr("tcp", *tcpAddress)
if err != nil {
log.Fatal(err)
}
httpAddr, err := net.ResolveTCPAddr("tcp", *httpAddress)
if err != nil {
log.Fatal(err)
}
log.Println(util.Version("nsqlookupd"))
nsqlookupd := NewNSQLookupd()
nsqlookupd.tcpAddr = tcpAddr
nsqlookupd.httpAddr = httpAddr
nsqlookupd.broadcastAddress = *broadcastAddress
nsqlookupd.inactiveProducerTimeout = *inactiveProducerTimeout
nsqlookupd.tombstoneLifetime = *tombstoneLifetime
nsqlookupd.Main()
<-exitChan
nsqlookupd.Exit()
}
func main() {
var waitGroup util.WaitGroupWrapper
flag.Parse()
if *showVersion {
fmt.Println(util.Version("nsqadmin"))
return
}
if *templateDir == "" {
for _, defaultPath := range []string{"templates", "/usr/local/share/nsqadmin/templates"} {
if info, err := os.Stat(defaultPath); err == nil && info.IsDir() {
*templateDir = defaultPath
break
}
}
}
if *templateDir == "" {
log.Fatalf("--template-dir must be specified (or install the templates to /usr/local/share/nsqadmin/templates)")
}
if len(nsqdHTTPAddrs) == 0 && len(lookupdHTTPAddrs) == 0 {
log.Fatalf("--nsqd-http-address or --lookupd-http-address required.")
}
if len(nsqdHTTPAddrs) != 0 && len(lookupdHTTPAddrs) != 0 {
log.Fatalf("use --nsqd-http-address or --lookupd-http-address not both")
}
log.Println(util.Version("nsqadmin"))
exitChan := make(chan int)
signalChan := make(chan os.Signal, 1)
go func() {
<-signalChan
exitChan <- 1
}()
signal.Notify(signalChan, os.Interrupt)
httpAddr, err := net.ResolveTCPAddr("tcp", *httpAddress)
if err != nil {
log.Fatal(err)
}
httpListener, err := net.Listen("tcp", httpAddr.String())
if err != nil {
log.Fatalf("FATAL: listen (%s) failed - %s", httpAddr, err.Error())
}
waitGroup.Wrap(func() { httpServer(httpListener) })
notifications = make(chan *AdminAction)
waitGroup.Wrap(func() { HandleAdminActions() })
<-exitChan
httpListener.Close()
close(notifications)
waitGroup.Wait()
}
func main() {
flag.Parse()
hostname, err := os.Hostname()
if err != nil {
log.Fatal(err)
}
if *showVersion {
fmt.Println(util.Version("nsqd"))
return
}
if *workerId == 0 {
h := md5.New()
io.WriteString(h, hostname)
*workerId = int64(crc32.ChecksumIEEE(h.Sum(nil)) % 1024)
}
tcpAddr, err := net.ResolveTCPAddr("tcp", *tcpAddress)
if err != nil {
log.Fatal(err)
}
httpAddr, err := net.ResolveTCPAddr("tcp", *httpAddress)
if err != nil {
log.Fatal(err)
}
if *broadcastAddress == "" {
*broadcastAddress = hostname
}
log.Println(util.Version("nsqd"))
log.Printf("worker id %d", *workerId)
exitChan := make(chan int)
signalChan := make(chan os.Signal, 1)
go func() {
<-signalChan
exitChan <- 1
}()
signal.Notify(signalChan, syscall.SIGINT, syscall.SIGTERM)
// flagToDuration will fatally error if it is invalid
msgTimeoutDuration := flagToDuration(*msgTimeout, time.Millisecond, "--msg-timeout")
if *maxDeflateLevel < 1 || *maxDeflateLevel > 9 {
log.Fatalf("--max-deflate-level must be [1,9]")
}
options := NewNsqdOptions()
options.maxRdyCount = *maxRdyCount
options.maxMessageSize = *maxMessageSize
options.maxBodySize = *maxBodySize
options.memQueueSize = *memQueueSize
options.dataPath = *dataPath
options.maxBytesPerFile = *maxBytesPerFile
options.syncEvery = *syncEvery
options.syncTimeout = *syncTimeout
options.msgTimeout = msgTimeoutDuration
options.maxMsgTimeout = *maxMsgTimeout
options.broadcastAddress = *broadcastAddress
options.maxHeartbeatInterval = *maxHeartbeatInterval
options.maxOutputBufferSize = *maxOutputBufferSize
options.maxOutputBufferTimeout = *maxOutputBufferTimeout
options.tlsCert = *tlsCert
options.tlsKey = *tlsKey
options.deflateEnabled = *deflateEnabled
options.maxDeflateLevel = *maxDeflateLevel
options.snappyEnabled = *snappyEnabled
options.e2eProcessingLatencyWindowTime = *e2eProcessingLatencyWindowTime
options.e2eProcessingLatencyPercentiles = e2eProcessingLatencyPercentiles
if *statsdAddress != "" {
// flagToDuration will fatally error if it is invalid
options.statsdInterval = flagToDuration(*statsdInterval, time.Second, "--statsd-interval")
statsdHostKey := util.StatsdHostKey(net.JoinHostPort(*broadcastAddress, strconv.Itoa(httpAddr.Port)))
prefixWithHost := strings.Replace(*statsdPrefix, "%s", statsdHostKey, -1)
if prefixWithHost[len(prefixWithHost)-1] != '.' {
prefixWithHost += "."
}
options.statsdPrefix = prefixWithHost
options.statsdAddress = *statsdAddress
}
nsqd := NewNSQd(*workerId, options)
nsqd.tcpAddr = tcpAddr
nsqd.httpAddr = httpAddr
nsqd.lookupdTCPAddrs = lookupdTCPAddrs
// Set the random seed
rand.Seed(time.Now().UTC().UnixNano())
nsqd.LoadMetadata()
err = nsqd.PersistMetadata()
if err != nil {
log.Fatalf("ERROR: failed to persist metadata - %s", err.Error())
}
nsqd.Main()
<-exitChan
nsqd.Exit()
}
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.Error())
util.ApiResponse(w, 500, "INVALID_REQUEST", nil)
return
}
formatString, _ := reqParams.Get("format")
jsonFormat := formatString == "json"
now := time.Now()
if !jsonFormat {
io.WriteString(w, fmt.Sprintf("%s\n", util.Version("nsqd")))
}
stats := s.context.nsqd.getStats()
if jsonFormat {
util.ApiResponse(w, 200, "OK", struct {
Topics []TopicStats `json:"topics"`
}{stats})
} else {
if len(stats) == 0 {
io.WriteString(w, "\nNO_TOPICS\n")
return
}
for _, t := range stats {
io.WriteString(w, fmt.Sprintf("\n[%-15s] depth: %-5d be-depth: %-5d msgs: %-8d e2e%%: %s\n",
t.TopicName,
t.Depth,
t.BackendDepth,
t.MessageCount,
t.E2eProcessingLatency))
for _, c := range t.Channels {
var pausedPrefix string
if c.Paused {
pausedPrefix = " *P "
} else {
pausedPrefix = " "
}
io.WriteString(w,
fmt.Sprintf("%s[%-25s] depth: %-5d be-depth: %-5d inflt: %-4d def: %-4d re-q: %-5d timeout: %-5d msgs: %-8d e2e%%: %s\n",
pausedPrefix,
c.ChannelName,
c.Depth,
c.BackendDepth,
c.InFlightCount,
c.DeferredCount,
c.RequeueCount,
c.TimeoutCount,
c.MessageCount,
c.E2eProcessingLatency))
for _, client := range c.Clients {
connectTime := time.Unix(client.ConnectTime, 0)
// truncate to the second
duration := time.Duration(int64(now.Sub(connectTime).Seconds())) * time.Second
_, port, _ := net.SplitHostPort(client.RemoteAddress)
io.WriteString(w, fmt.Sprintf(" [%s %-21s] state: %d inflt: %-4d rdy: %-4d fin: %-8d re-q: %-8d msgs: %-8d connected: %s\n",
client.Version,
fmt.Sprintf("%s:%s", client.Name, port),
client.State,
client.InFlightCount,
client.ReadyCount,
client.FinishCount,
client.RequeueCount,
client.MessageCount,
duration,
))
}
}
}
}
}