func (this *SkyOutput) Run(r engine.OutputRunner, h engine.PluginHelper) error {
var (
ok = true
pack *engine.PipelinePack
inChan = r.InChan()
globals = engine.Globals()
project = h.Project(this.project)
)
LOOP:
for ok {
select {
case pack, ok = <-inChan:
if !ok {
break LOOP
}
if globals.Debug {
globals.Println(*pack)
}
this.feedSky(project, pack)
pack.Recycle()
}
}
return nil
}
func (this *DebugOutput) Run(r engine.OutputRunner, h engine.PluginHelper) error {
var (
globals = engine.Globals()
pack *engine.PipelinePack
ok = true
inChan = r.InChan()
)
LOOP:
for ok {
select {
case pack, ok = <-inChan:
if !ok {
break LOOP
}
if !this.blackhole {
globals.Println(*pack)
}
pack.Recycle()
}
}
return nil
}
func (this *CardinalityOutput) Run(r engine.OutputRunner, h engine.PluginHelper) error {
var (
pack *engine.PipelinePack
ok = true
inChan = r.InChan()
)
h.RegisterHttpApi("/card/{key}", func(w http.ResponseWriter,
req *http.Request, params map[string]interface{}) (interface{}, error) {
return this.handleHttpRequest(w, req, params)
}).Methods("GET", "PUT")
LOOP:
for ok {
select {
case pack, ok = <-inChan:
if !ok {
break LOOP
}
if pack.CardinalityKey != "" && pack.CardinalityData != nil {
this.counters.Add(pack.CardinalityKey, pack.CardinalityData)
}
pack.Recycle()
}
}
// before we quit, dump counters
if this.checkpoint != "" {
this.counters.Dump(this.checkpoint)
}
return nil
}
func (this *AlarmOutput) Run(r engine.OutputRunner, h engine.PluginHelper) error {
var (
pack *engine.PipelinePack
reloadChan = make(chan interface{})
ok = true
inChan = r.InChan()
)
for name, project := range this.projects {
go this.runSendAlarmsWatchdog(h.Project(name), project)
}
// start all the workers
goAhead := make(chan bool)
for _, project := range this.projects {
for _, worker := range project.workers {
go worker.run(h, goAhead)
<-goAhead // in case of race condition with worker.inject
}
}
observer.Subscribe(engine.RELOAD, reloadChan)
LOOP:
for ok {
select {
case <-reloadChan:
// TODO
case pack, ok = <-inChan:
if !ok {
break LOOP
}
this.handlePack(pack, h)
pack.Recycle()
}
}
close(this.stopChan)
// all the workers cleanup
for _, project := range this.projects {
for _, worker := range project.workers {
worker.cleanup()
}
}
for _, project := range this.projects {
close(project.emailChan)
}
return nil
}
func (this *NetSenderOutput) Run(r engine.OutputRunner, h engine.PluginHelper) error {
var (
pack *engine.PipelinePack
ok = true
inChan = r.InChan()
)
LOOP:
for ok {
select {
case pack, ok = <-inChan:
if !ok {
break LOOP
}
this.target(pack).send(pack)
pack.Recycle()
}
}
return nil
}
func (this *EsOutput) Run(r engine.OutputRunner, h engine.PluginHelper) error {
var (
pack *engine.PipelinePack
reloadChan = make(chan interface{})
ok = true
globals = engine.Globals()
inChan = r.InChan()
reportTicker = time.NewTicker(this.reportInterval)
)
this.indexer = core.NewBulkIndexer(this.bulkMaxConn)
this.indexer.BulkMaxDocs = this.bulkMaxDocs
this.indexer.BulkMaxBuffer = this.bulkMaxBuffer
// start the bulk indexer
this.indexer.Run(this.stopChan)
defer reportTicker.Stop()
observer.Subscribe(engine.RELOAD, reloadChan)
LOOP:
for ok {
select {
case <-this.stopChan:
ok = false
case <-reportTicker.C:
this.showPeriodicalStats()
case <-reloadChan:
// TODO
case <-time.After(this.flushInterval):
this.indexer.Flush()
case pack, ok = <-inChan:
if !ok {
break LOOP
}
if globals.Debug {
globals.Println(*pack)
}
this.feedEs(h.Project(pack.Project), pack)
pack.Recycle()
}
}
engine.Globals().Printf("[%s]Total output to ES: %d", r.Name(), this.totalN)
// before shutdown, flush again
if globals.Verbose {
engine.Globals().Println("Waiting for ES flush...")
}
this.indexer.Flush()
if globals.Verbose {
engine.Globals().Println("ES flushed")
}
// let indexer stop
this.stopChan <- true
return nil
}