func (n Node) Target(key string) (string, string) {
target := fmt.Sprintf("%%snsq.%s.mem.%s", util.StatsdHostKey(string(n)), key)
if key == "gc_runs" {
target = fmt.Sprintf("movingAverage(%s,45)", target)
}
return target, "red,green,blue,purple"
}
func NewNSQD(options *nsqdOptions) *NSQD {
var tlsConfig *tls.Config
if options.MaxDeflateLevel < 1 || options.MaxDeflateLevel > 9 {
log.Fatalf("--max-deflate-level must be [1,9]")
}
tcpAddr, err := net.ResolveTCPAddr("tcp", options.TCPAddress)
if err != nil {
log.Fatal(err)
}
httpAddr, err := net.ResolveTCPAddr("tcp", options.HTTPAddress)
if err != nil {
log.Fatal(err)
}
if options.StatsdPrefix != "" {
statsdHostKey := util.StatsdHostKey(net.JoinHostPort(options.BroadcastAddress,
strconv.Itoa(httpAddr.Port)))
prefixWithHost := strings.Replace(options.StatsdPrefix, "%s", statsdHostKey, -1)
if prefixWithHost[len(prefixWithHost)-1] != '.' {
prefixWithHost += "."
}
options.StatsdPrefix = prefixWithHost
}
if options.TLSCert != "" || options.TLSKey != "" {
cert, err := tls.LoadX509KeyPair(options.TLSCert, options.TLSKey)
if err != nil {
log.Fatalf("ERROR: failed to LoadX509KeyPair %s", err.Error())
}
tlsConfig = &tls.Config{
Certificates: []tls.Certificate{cert},
ClientAuth: tls.VerifyClientCertIfGiven,
}
tlsConfig.BuildNameToCertificate()
}
n := &NSQD{
options: options,
tcpAddr: tcpAddr,
httpAddr: httpAddr,
topicMap: make(map[string]*Topic),
idChan: make(chan nsq.MessageID, 4096),
exitChan: make(chan int),
notifyChan: make(chan interface{}),
tlsConfig: tlsConfig,
}
n.waitGroup.Wrap(func() { n.idPump() })
return n
}
func (t *TopicStats) Target(key string) (string, string) {
h := util.StatsdHostKey(t.HostAddress)
if t.Aggregate {
h = "*"
}
color := "blue"
if key == "depth" || key == "deferred_count" {
color = "red"
}
target := fmt.Sprintf("sumSeries(%%snsq.%s.topic.%s.%s)", h, t.TopicName, key)
return target, color
}
func (c *ChannelStats) Target(key string) (string, string) {
h := "*"
if len(c.HostStats) == 0 {
h = util.StatsdHostKey(c.HostAddress)
}
color := "blue"
if key == "depth" || key == "deferred_count" {
color = "red"
}
target := fmt.Sprintf("sumSeries(%%snsq.%s.topic.%s.channel.%s.%s)", h, c.TopicName, c.ChannelName, key)
return target, color
}
func NewNSQD(options *nsqdOptions) *NSQD {
var httpsAddr *net.TCPAddr
if options.MaxDeflateLevel < 1 || options.MaxDeflateLevel > 9 {
log.Fatalf("--max-deflate-level must be [1,9]")
}
tcpAddr, err := net.ResolveTCPAddr("tcp", options.TCPAddress)
if err != nil {
log.Fatal(err)
}
httpAddr, err := net.ResolveTCPAddr("tcp", options.HTTPAddress)
if err != nil {
log.Fatal(err)
}
if options.HTTPSAddress != "" {
httpsAddr, err = net.ResolveTCPAddr("tcp", options.HTTPSAddress)
if err != nil {
log.Fatal(err)
}
}
if options.StatsdPrefix != "" {
statsdHostKey := util.StatsdHostKey(net.JoinHostPort(options.BroadcastAddress,
strconv.Itoa(httpAddr.Port)))
prefixWithHost := strings.Replace(options.StatsdPrefix, "%s", statsdHostKey, -1)
if prefixWithHost[len(prefixWithHost)-1] != '.' {
prefixWithHost += "."
}
options.StatsdPrefix = prefixWithHost
}
n := &NSQD{
options: options,
tcpAddr: tcpAddr,
httpAddr: httpAddr,
httpsAddr: httpsAddr,
topicMap: make(map[string]*Topic),
idChan: make(chan nsq.MessageID, 4096),
exitChan: make(chan int),
notifyChan: make(chan interface{}),
tlsConfig: buildTLSConfig(options),
}
n.waitGroup.Wrap(func() { n.idPump() })
return n
}
func (g *GraphOptions) Prefix(host string, metricType string) string {
prefix := ""
statsdHostKey := util.StatsdHostKey(host)
prefixWithHost := strings.Replace(g.context.nsqadmin.options.StatsdPrefix, "%s", statsdHostKey, -1)
if prefixWithHost[len(prefixWithHost)-1] != '.' {
prefixWithHost += "."
}
if g.context.nsqadmin.options.UseStatsdPrefixes && metricType == "counter" {
prefix += "stats_counts."
} else if g.context.nsqadmin.options.UseStatsdPrefixes && metricType == "gauge" {
prefix += "stats.gauges."
}
prefix += prefixWithHost
return prefix
}
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
if *statsdAddress != "" {
// flagToDuration will fatally error if it is invalid
options.statsdInterval = flagToDuration(*statsdInterval, time.Second, "--statsd-interval")
options.statsdPrefix = fmt.Sprintf("nsq.%s.", util.StatsdHostKey(net.JoinHostPort(*broadcastAddress, strconv.Itoa(httpAddr.Port))))
options.statsdAddress = *statsdAddress
}
nsqd := NewNSQd(*workerId, options)
nsqd.tcpAddr = tcpAddr
nsqd.httpAddr = httpAddr
nsqd.lookupdTCPAddrs = lookupdTCPAddrs
nsqd.LoadMetadata()
err = nsqd.PersistMetadata()
if err != nil {
log.Fatalf("ERROR: failed to persist metadata - %s", err.Error())
}
nsqd.Main()
<-exitChan
nsqd.Exit()
}
func NewNSQD(opts *nsqdOptions) *NSQD {
n := &NSQD{
opts: opts,
healthy: 1,
topicMap: make(map[string]*Topic),
idChan: make(chan MessageID, 4096),
exitChan: make(chan int),
notifyChan: make(chan interface{}),
}
if opts.MaxDeflateLevel < 1 || opts.MaxDeflateLevel > 9 {
n.logf("FATAL: --max-deflate-level must be [1,9]")
os.Exit(1)
}
if opts.ID < 0 || opts.ID >= 4096 {
n.logf("FATAL: --worker-id must be [0,4096)")
os.Exit(1)
}
tcpAddr, err := net.ResolveTCPAddr("tcp", opts.TCPAddress)
if err != nil {
n.logf("FATAL: failed to resolve TCP address (%s) - %s", opts.TCPAddress, err)
os.Exit(1)
}
n.tcpAddr = tcpAddr
httpAddr, err := net.ResolveTCPAddr("tcp", opts.HTTPAddress)
if err != nil {
n.logf("FATAL: failed to resolve HTTP address (%s) - %s", opts.HTTPAddress, err)
os.Exit(1)
}
n.httpAddr = httpAddr
if opts.HTTPSAddress != "" {
httpsAddr, err := net.ResolveTCPAddr("tcp", opts.HTTPSAddress)
if err != nil {
n.logf("FATAL: failed to resolve HTTPS address (%s) - %s", opts.HTTPSAddress, err)
os.Exit(1)
}
n.httpsAddr = httpsAddr
}
if opts.StatsdPrefix != "" {
statsdHostKey := util.StatsdHostKey(net.JoinHostPort(opts.BroadcastAddress,
strconv.Itoa(httpAddr.Port)))
prefixWithHost := strings.Replace(opts.StatsdPrefix, "%s", statsdHostKey, -1)
if prefixWithHost[len(prefixWithHost)-1] != '.' {
prefixWithHost += "."
}
opts.StatsdPrefix = prefixWithHost
}
if opts.TLSClientAuthPolicy != "" {
opts.TLSRequired = true
}
tlsConfig, err := buildTLSConfig(opts)
if err != nil {
n.logf("FATAL: failed to build TLS config - %s", err)
os.Exit(1)
}
if tlsConfig == nil && n.opts.TLSRequired {
n.logf("FATAL: cannot require TLS client connections without TLS key and cert")
os.Exit(1)
}
n.tlsConfig = tlsConfig
n.waitGroup.Wrap(func() { n.idPump() })
n.logf(util.Version("nsqd"))
n.logf("ID: %d", n.opts.ID)
return n
}
