func NewTableOrFatal(tb testing.TB, spool_dir, cmd string) *tbl.Table {
table := tbl.New(spool_dir)
fatal := func(err error) {
tb.Fatal(err)
}
if cmd != "" {
err := imperatives.Apply(table, cmd)
if err != nil {
fatal(err)
}
}
return table
}
func main() {
flag.Usage = usage
flag.Parse()
runtime.SetBlockProfileRate(*blockProfileRate)
runtime.MemProfileRate = *memProfileRate
// validation defaults
config.Validation_level_legacy.Level = m20.MediumLegacy
config.Validation_level_m20.Level = m20.MediumM20
config_file = "/etc/carbon-relay-ng.ini"
if 1 == flag.NArg() {
config_file = flag.Arg(0)
}
if _, err := toml.DecodeFile(config_file, &config); err != nil {
log.Error("Cannot use config file '%s':\n", config_file)
log.Error(err.Error())
usage()
return
}
//runtime.SetBlockProfileRate(1) // to enable block profiling. in my experience, adds 35% overhead.
levels := map[string]logging.Level{
"critical": logging.CRITICAL,
"error": logging.ERROR,
"warning": logging.WARNING,
"notice": logging.NOTICE,
"info": logging.INFO,
"debug": logging.DEBUG,
}
level, ok := levels[config.Log_level]
if !ok {
log.Error("unrecognized log level '%s'\n", config.Log_level)
return
}
logging.SetLevel(level, "carbon-relay-ng")
if *cpuprofile != "" {
f, err := os.Create(*cpuprofile)
if err != nil {
log.Fatal(err)
}
pprof.StartCPUProfile(f)
defer pprof.StopCPUProfile()
}
if len(config.Instance) == 0 {
log.Error("instance identifier cannot be empty")
os.Exit(1)
}
runtime.GOMAXPROCS(config.Max_procs)
log.Notice("===== carbon-relay-ng instance '%s' starting. =====\n", config.Instance)
stats.New(config.Instance)
if config.Pid_file != "" {
f, err := os.Create(config.Pid_file)
if err != nil {
fmt.Println("error creating pidfile:", err.Error())
os.Exit(1)
}
_, err = f.Write([]byte(strconv.Itoa(os.Getpid())))
if err != nil {
fmt.Println("error writing to pidfile:", err.Error())
os.Exit(1)
}
f.Close()
}
if config.Instrumentation.Graphite_addr != "" {
addr, err := net.ResolveTCPAddr("tcp", config.Instrumentation.Graphite_addr)
if err != nil {
log.Fatal(err)
}
go metrics.Graphite(metrics.DefaultRegistry, time.Duration(config.Instrumentation.Graphite_interval)*time.Millisecond, "", addr)
}
log.Notice("creating routing table...")
maxAge, err := time.ParseDuration(config.Bad_metrics_max_age)
if err != nil {
log.Error("could not parse badMetrics max age")
log.Error(err.Error())
os.Exit(1)
}
badMetrics = badmetrics.New(maxAge)
table = tbl.New(config.Spool_dir)
log.Notice("initializing routing table...")
for i, cmd := range config.Init {
log.Notice("applying: %s", cmd)
err = imperatives.Apply(table, cmd)
if err != nil {
log.Error("could not apply init cmd #%d", i+1)
log.Error(err.Error())
os.Exit(1)
}
}
tablePrinted := table.Print()
log.Notice("===========================")
log.Notice("========== TABLE ==========")
log.Notice("===========================")
for _, line := range strings.Split(tablePrinted, "\n") {
log.Notice(line)
}
if config.Listen_addr != "" {
_, err = input.NewPlain(config, config.Listen_addr, table, badMetrics)
if err != nil {
log.Error(err.Error())
os.Exit(1)
}
}
if config.Pickle_addr != "" {
_, err = input.NewPickle(config, config.Pickle_addr, table, badMetrics)
if err != nil {
log.Error(err.Error())
os.Exit(1)
}
}
if config.Admin_addr != "" {
go func() {
err := telnet.Start(config.Admin_addr, table)
if err != nil {
fmt.Println("Error listening:", err.Error())
os.Exit(1)
}
}()
}
if config.Http_addr != "" {
go web.Start(config.Http_addr, config, table, badMetrics)
}
select {}
}
func TestScanner(t *testing.T) {
cases := []struct {
cmd string
exp []toki.Token
}{
{
"addBlack prefix collectd.localhost",
[]toki.Token{addBlack, word, word},
},
{
`addBlack regex ^foo\..*\.cpu+`,
[]toki.Token{addBlack, word, word},
},
{
`addAgg sum ^stats\.timers\.(app|proxy|static)[0-9]+\.requests\.(.*) stats.timers._sum_$1.requests.$2 10 20`,
[]toki.Token{addAgg, sumFn, word, word, num, num},
},
{
`addAgg avg ^stats\.timers\.(app|proxy|static)[0-9]+\.requests\.(.*) stats.timers._avg_$1.requests.$2 5 10`,
[]toki.Token{addAgg, avgFn, word, word, num, num},
},
{
"addRoute sendAllMatch carbon-default 127.0.0.1:2005 spool=true pickle=false",
[]toki.Token{addRouteSendAllMatch, word, sep, word, optSpool, optTrue, optPickle, optFalse},
},
{
"addRoute sendAllMatch carbon-tagger sub== 127.0.0.1:2006",
[]toki.Token{addRouteSendAllMatch, word, optSub, word, sep, word},
},
{
"addRoute sendFirstMatch analytics regex=(Err/s|wait_time|logger) graphite.prod:2003 prefix=prod. spool=true pickle=true graphite.staging:2003 prefix=staging. spool=true pickle=true",
[]toki.Token{addRouteSendFirstMatch, word, optRegex, word, sep, word, optPrefix, word, optSpool, optTrue, optPickle, optTrue, sep, word, optPrefix, word, optSpool, optTrue, optPickle, optTrue},
},
//{ disabled cause tries to read the schemas.conf file
// "addRoute grafanaNet grafanaNet http://localhost:8081/metrics your-grafana.net-api-key /path/to/storage-schemas.conf",
// []toki.Token{addRouteGrafanaNet, word, sep, word, word},
//},
}
for i, c := range cases {
s := toki.NewScanner(tokens)
s.SetInput(strings.Replace(c.cmd, " ", " ## ", -1))
for j, e := range c.exp {
r := s.Next()
if e != r.Token {
t.Fatalf("case %d pos %d - expected %v, got %v", i, j, e, r.Token)
}
}
}
table := tbl.New("")
for _, c := range cases {
err := Apply(table, c.cmd)
if err != nil {
t.Fatalf("could not apply init cmd %q: %s", c.cmd, err)
}
}
tablePrinted := table.Print()
t.Log("===========================")
t.Log("========== TABLE ==========")
t.Log("===========================")
for _, line := range strings.Split(tablePrinted, "\n") {
t.Logf(line)
}
}
