func main() {
go func() {
for {
time.Sleep(time.Duration(1) * time.Second)
ob.Publish("foo", time.Now().Unix())
}
}()
eventCh1 := make(chan interface{})
ob.Subscribe("foo", eventCh1)
go func() {
for {
data := <-eventCh1
fmt.Printf("sub1: %#v\n", data)
}
}()
eventCh2 := make(chan interface{})
ob.Subscribe("foo", eventCh2)
go func() {
for {
data := <-eventCh2
fmt.Printf("sub2: %v\n", data)
}
}()
<-time.After(6 * time.Second)
// Output:
}
func (config *Controller) Merge(request Transaction) {
// configure observer
observation := make(chan interface{})
observationActive := true
observer.Subscribe(EVENT_DELETE_INTERFACE, observation)
// event handler
go func() {
for observationActive == true {
interfaceName := <-observation
if interfaceName == nil {
continue
}
Trace.Printf("remove interface: %#v\n", interfaceName)
config.RemoveInterface(interfaceName.(string))
}
}()
// act
config.Model.Merge(request.Config.Model)
// clean up observer
observer.UnSubscribe(EVENT_DELETE_INTERFACE, observation)
observationActive = false
}
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 *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
}