func main() {
configFile := flag.String("config", "agent.conf", "Agent Config file")
maxprocs := flag.Int("maxprocs", 1, "Go runtime MAXPROCS value")
poolSize := flag.Int("poolsize", 1000, "Pipeline pool size")
pprofName := flag.String("pprof", "", "Go profiler output file")
version := flag.Bool("version", false, "Output version and exit")
flag.Parse()
if *version {
fmt.Println(VERSION)
os.Exit(0)
}
runtime.GOMAXPROCS(*maxprocs)
if *pprofName != "" {
profFile, err := os.Create(*pprofName)
if err != nil {
log.Fatalln(err)
}
pprof.StartCPUProfile(profFile)
defer pprof.StopCPUProfile()
}
// Set up and load the pipeline configuration and start the daemon.
pipeconf := pipeline.NewPipelineConfig(*poolSize)
err := pipeconf.LoadFromConfigFile(*configFile)
if err != nil {
log.Fatal("Error reading config: ", err)
}
pipeline.Run(pipeconf)
}
func main() {
configFile := flag.String("config", "/etc/hekad.toml", "Config file")
maxprocs := flag.Int("maxprocs", 1, "Go runtime MAXPROCS value")
poolSize := flag.Int("poolsize", 100, "Pipeline pool size")
decoderPoolSize := flag.Int("decoder_poolsize", 4, "Decoder pool size")
chanSize := flag.Int("plugin_chansize", 50, "Plugin input channel buffer size")
cpuProfName := flag.String("cpuprof", "", "Go CPU profiler output file")
memProfName := flag.String("memprof", "", "Go memory profiler output file")
version := flag.Bool("version", false, "Output version and exit")
maxMsgLoops := flag.Uint("max_message_loops", 4, "Maximum number of times a message can pass thru the system")
flag.Parse()
if *version {
fmt.Println(VERSION)
os.Exit(0)
}
runtime.GOMAXPROCS(*maxprocs)
if *cpuProfName != "" {
profFile, err := os.Create(*cpuProfName)
if err != nil {
log.Fatalln(err)
}
pprof.StartCPUProfile(profFile)
defer pprof.StopCPUProfile()
}
if *memProfName != "" {
defer func() {
profFile, err := os.Create(*memProfName)
if err != nil {
log.Fatalln(err)
}
pprof.WriteHeapProfile(profFile)
profFile.Close()
}()
}
// Set up and load the pipeline configuration and start the daemon.
globals := pipeline.DefaultGlobals()
globals.PoolSize = *poolSize
globals.DecoderPoolSize = *decoderPoolSize
globals.PluginChanSize = *chanSize
globals.MaxMsgLoops = *maxMsgLoops
if globals.MaxMsgLoops == 0 {
globals.MaxMsgLoops = 1
}
pipeconf := pipeline.NewPipelineConfig(globals)
err := pipeconf.LoadFromConfigFile(*configFile)
if err != nil {
log.Fatal("Error reading config: ", err)
}
pipeline.Run(pipeconf)
}
func main() {
configPath := flag.String("config", filepath.FromSlash("/etc/hekad.toml"),
"Config file or directory. If directory is specified then all files "+
"in the directory will be loaded.")
version := flag.Bool("version", false, "Output version and exit")
flag.Parse()
config := &HekadConfig{}
var err error
var cpuProfName string
var memProfName string
if *version {
fmt.Println(VERSION)
os.Exit(0)
}
config, err = LoadHekadConfig(*configPath)
if err != nil {
pipeline.LogError.Fatal("Error reading config: ", err)
}
if config.SampleDenominator <= 0 {
pipeline.LogError.Fatalln("'sample_denominator' value must be greater than 0.")
}
globals, cpuProfName, memProfName := setGlobalConfigs(config)
if err = os.MkdirAll(globals.BaseDir, 0755); err != nil {
pipeline.LogError.Fatalf("Error creating 'base_dir' %s: %s", config.BaseDir, err)
}
if config.MaxMessageSize > 1024 {
message.SetMaxMessageSize(config.MaxMessageSize)
} else if config.MaxMessageSize > 0 {
pipeline.LogError.Fatalln("Error: 'max_message_size' setting must be greater than 1024.")
}
if config.PidFile != "" {
contents, err := ioutil.ReadFile(config.PidFile)
if err == nil {
pid, err := strconv.Atoi(strings.TrimSpace(string(contents)))
if err != nil {
pipeline.LogError.Fatalf("Error reading proccess id from pidfile '%s': %s",
config.PidFile, err)
}
process, err := os.FindProcess(pid)
// on Windows, err != nil if the process cannot be found
if runtime.GOOS == "windows" {
if err == nil {
pipeline.LogError.Fatalf("Process %d is already running.", pid)
}
} else if process != nil {
// err is always nil on POSIX, so we have to send the process
// a signal to check whether it exists
if err = process.Signal(syscall.Signal(0)); err == nil {
pipeline.LogError.Fatalf("Process %d is already running.", pid)
}
}
}
if err = ioutil.WriteFile(config.PidFile, []byte(strconv.Itoa(os.Getpid())),
0644); err != nil {
pipeline.LogError.Fatalf("Unable to write pidfile '%s': %s", config.PidFile, err)
}
pipeline.LogInfo.Printf("Wrote pid to pidfile '%s'", config.PidFile)
defer func() {
if err = os.Remove(config.PidFile); err != nil {
pipeline.LogError.Printf("Unable to remove pidfile '%s': %s", config.PidFile, err)
}
}()
}
if cpuProfName != "" {
profFile, err := os.Create(cpuProfName)
if err != nil {
pipeline.LogError.Fatalln(err)
}
pprof.StartCPUProfile(profFile)
defer func() {
pprof.StopCPUProfile()
profFile.Close()
}()
}
if memProfName != "" {
defer func() {
profFile, err := os.Create(memProfName)
if err != nil {
pipeline.LogError.Fatalln(err)
}
pprof.WriteHeapProfile(profFile)
profFile.Close()
}()
}
// Set up and load the pipeline configuration and start the daemon.
pipeconf := pipeline.NewPipelineConfig(globals)
if err = loadFullConfig(pipeconf, configPath); err != nil {
pipeline.LogError.Fatal("Error reading config: ", err)
}
pipeline.Run(pipeconf)
}
func main() {
configPath := flag.String("config", filepath.FromSlash("/etc/hekad.toml"),
"Config file or directory. If directory is specified then all files "+
"in the directory will be loaded.")
version := flag.Bool("version", false, "Output version and exit")
flag.Parse()
config := &HekadConfig{}
var err error
var cpuProfName string
var memProfName string
if flag.NFlag() == 0 {
flag.PrintDefaults()
os.Exit(0)
}
if *version {
fmt.Println(VERSION)
os.Exit(0)
}
config, err = LoadHekadConfig(*configPath)
if err != nil {
log.Fatal("Error reading config: ", err)
}
globals, cpuProfName, memProfName := setGlobalConfigs(config)
if err = os.MkdirAll(globals.BaseDir, 0755); err != nil {
log.Fatalf("Error creating base_dir %s: %s", config.BaseDir, err)
}
if cpuProfName != "" {
profFile, err := os.Create(cpuProfName)
if err != nil {
log.Fatalln(err)
}
profFile.Close()
pprof.StartCPUProfile(profFile)
defer pprof.StopCPUProfile()
}
if memProfName != "" {
defer func() {
profFile, err := os.Create(memProfName)
if err != nil {
log.Fatalln(err)
}
pprof.WriteHeapProfile(profFile)
profFile.Close()
}()
}
// Set up and load the pipeline configuration and start the daemon.
pipeconf := pipeline.NewPipelineConfig(globals)
p, err := os.Open(*configPath)
fi, err := p.Stat()
if fi.IsDir() {
files, _ := ioutil.ReadDir(*configPath)
for _, f := range files {
err = pipeconf.LoadFromConfigFile(filepath.Join(*configPath, f.Name()))
}
} else {
err = pipeconf.LoadFromConfigFile(*configPath)
}
if err != nil {
log.Fatal("Error reading config: ", err)
}
pipeline.Run(pipeconf)
}
func main() {
configFile := flag.String("config", "/etc/hekad.toml", "Config file")
version := flag.Bool("version", false, "Output version and exit")
flag.Parse()
if flag.NFlag() == 0 {
flag.PrintDefaults()
os.Exit(0)
}
if *version {
fmt.Println(VERSION)
os.Exit(0)
}
config, err := LoadHekadConfig(*configFile)
if err != nil {
log.Fatal("Error reading config: ", err)
}
maxprocs := config.Maxprocs
poolSize := config.PoolSize
decoderPoolSize := config.DecoderPoolSize
chanSize := config.ChanSize
cpuProfName := config.CpuProfName
memProfName := config.MemProfName
maxMsgLoops := config.MaxMsgLoops
maxMsgProcessInject := config.MaxMsgProcessInject
maxMsgTimerInject := config.MaxMsgTimerInject
runtime.GOMAXPROCS(maxprocs)
if cpuProfName != "" {
profFile, err := os.Create(cpuProfName)
if err != nil {
log.Fatalln(err)
}
profFile.Close()
pprof.StartCPUProfile(profFile)
defer pprof.StopCPUProfile()
}
if memProfName != "" {
defer func() {
profFile, err := os.Create(memProfName)
if err != nil {
log.Fatalln(err)
}
pprof.WriteHeapProfile(profFile)
profFile.Close()
}()
}
// Set up and load the pipeline configuration and start the daemon.
globals := pipeline.DefaultGlobals()
globals.PoolSize = poolSize
globals.DecoderPoolSize = decoderPoolSize
globals.PluginChanSize = chanSize
globals.MaxMsgLoops = maxMsgLoops
if globals.MaxMsgLoops == 0 {
globals.MaxMsgLoops = 1
}
globals.MaxMsgProcessInject = maxMsgProcessInject
globals.MaxMsgTimerInject = maxMsgTimerInject
pipeconf := pipeline.NewPipelineConfig(globals)
err = pipeconf.LoadFromConfigFile(*configFile)
if err != nil {
log.Fatal("Error reading config: ", err)
}
pipeline.Run(pipeconf)
}