func (self *json_outstream) Initialize() kernel.Error {
self.MsgDebug("== initialize ==\n")
if !self.Algorithm.Initialize().IsSuccess() {
self.MsgError("could not initialize base-class\n")
return kernel.StatusCode(1)
}
self.item_names = self.GetProperty("Items").([]string)
fname := self.GetProperty("Output").(string)
self.MsgInfo("output file: [%v]\n", fname)
self.MsgInfo("items: %v\n", self.item_names)
svcloc := kernel.GetSvcLocator()
if svcloc == nil {
self.MsgError("could not retrieve service locator !\n")
return kernel.StatusCode(1)
}
svc := svcloc.GetService("outstreamsvc").(kernel.IOutputStreamSvc)
if svc == nil {
self.MsgError("could not retrieve [outstreamsvc] !\n")
return kernel.StatusCode(1)
}
self.handle = svc.NewOutputStream(fname)
if self.handle == nil {
self.MsgError("could not retrieve json output stream [%s] !\n", fname)
return kernel.StatusCode(1)
}
return kernel.StatusCode(0)
}
func (self *alg1) Initialize() kernel.Error {
self.MsgInfo("== initialize ==\n")
if !self.Algorithm.Initialize().IsSuccess() {
self.MsgError("could not initialize base-class\n")
return kernel.StatusCode(1)
}
return kernel.StatusCode(0)
}
func (self *svc2) InitializeSvc() kernel.Error {
self.MsgInfo("~~ initialize ~~\n")
if !self.Service.InitializeSvc().IsSuccess() {
self.MsgError("could not initialize base-class\n")
return kernel.StatusCode(1)
}
return kernel.StatusCode(0)
}
func (self *tool1) InitializeTool() kernel.Error {
self.MsgInfo("~~ initialize ~~\n")
if !self.AlgTool.InitializeTool().IsSuccess() {
self.MsgError("could not initialize base-class\n")
return kernel.StatusCode(1)
}
return kernel.StatusCode(0)
}
func (self *evtproc) mp_NextEvent(evtmax int) kernel.Error {
handle := func(evt *evtstate, out_queue chan<- *evtstate) {
self.MsgInfo("nextEvent[%v]...\n", evt.idx)
evt.sc = self.ExecuteEvent(evt)
out_queue <- evt
}
serve_evts := func(in_evt_queue <-chan *evtstate, out_evt_queue chan<- *evtstate, quit <-chan bool) {
for {
select {
case ievt := <-in_evt_queue:
go handle(ievt, out_evt_queue)
case <-quit:
//println("quit requested !")
return
}
}
}
start_evt_server := func(nworkers int) (in_evt_queue,
out_evt_queue chan *evtstate,
quit chan bool) {
in_evt_queue = make(chan *evtstate, nworkers)
out_evt_queue = make(chan *evtstate)
quit = make(chan bool)
go serve_evts(in_evt_queue, out_evt_queue, quit)
return in_evt_queue, out_evt_queue, quit
}
in_evt_queue, out_evt_queue, quit := start_evt_server(self.nworkers)
//self.MsgInfo("sending requests...\n")
for i := 0; i < evtmax; i++ {
in_evt_queue <- new_evtstate(i)
}
//self.MsgInfo("sending requests... [done]\n")
n_fails := 0
n_processed := 0
for evt := range out_evt_queue {
//self.MsgDebug("out-evt-queue: %v %v\n",evt.idx, evt.sc)
if !evt.sc.IsSuccess() {
n_fails++
}
n_processed++
if n_processed == evtmax {
quit <- true
close(out_evt_queue)
//self.MsgDebug("closing evt server...\n")
break
}
}
if n_fails != 0 {
return kernel.StatusCode(1)
}
return kernel.StatusCode(0)
}
func (self *json_outstream_svc) InitializeSvc() kernel.Error {
self.MsgDebug("== initialize ==\n")
if !self.Service.InitializeSvc().IsSuccess() {
self.MsgError("could not initialize base-class\n")
return kernel.StatusCode(1)
}
return kernel.StatusCode(0)
}
func (self *evtproc) seq_NextEvent(evtmax int) kernel.Error {
self.MsgInfo("nextEvent[%v]...\n", evtmax)
for i := 0; i < evtmax; i++ {
ctx := new_evtstate(i)
if !self.ExecuteEvent(ctx).IsSuccess() {
self.MsgError("failed to execute evt idx %03v\n", i)
return kernel.StatusCode(1)
}
}
return kernel.StatusCode(0)
}
func (self *alg_dumper) Initialize() kernel.Error {
self.MsgInfo("== initialize ==\n")
if !self.Algorithm.Initialize().IsSuccess() {
self.MsgError("could not initialize base-class\n")
return kernel.StatusCode(1)
}
self.njets_key = self.GetProperty("NbrJets").(string)
self.ptjets_key = self.GetProperty("PtJets").(string)
self.cnt_key = self.GetProperty("SimpleCounter").(string)
self.cnt_val = self.GetProperty("ExpectedValue").(int)
return kernel.StatusCode(0)
}
func (self *evtproc) ExecuteEvent(ictx kernel.IEvtCtx) kernel.Error {
ctx := ictx.Idx()
self.MsgDebug("executing event [%v]... (#algs: %v)\n", ctx, len(self.algs))
for i, alg := range self.algs {
self.MsgDebug("-- ctx:%03v --> [%s]...\n", ctx, alg.CompName())
if !alg.Execute(ictx).IsSuccess() {
self.MsgError("pb executing alg #%v (%s) for ctx:%v\n",
i, alg.CompName(), ictx.Idx())
return kernel.StatusCode(1)
}
}
self.MsgDebug("data: %v\n", ictx.Store())
return kernel.StatusCode(0)
}
func (self *alg_adder) Initialize() kernel.Error {
self.MsgInfo("== initialize ==\n")
if !self.Algorithm.Initialize().IsSuccess() {
self.MsgError("could not initialize base-class\n")
return kernel.StatusCode(1)
}
self.MsgInfo("--> val: %v\n", self.val)
self.val = self.GetProperty("Val").(float64)
self.MsgInfo("--> val: %v\n", self.val)
self.cnt_key = self.GetProperty("SimpleCounter").(string)
self.MsgInfo("--> cnt: %v\n", self.cnt_key)
return kernel.StatusCode(0)
}
func new_evtstate(idx int) *evtstate {
self := &evtstate{}
self.idx = idx
self.sc = kernel.StatusCode(0)
self.data = make(kernel.DataStore)
return self
}
func (self *json_outstream_handle) Close() kernel.Error {
self.quit <- true
msg := self.svc.(kernel.IMessager)
msg.MsgDebug("--> closing json-handle [%v]\n", self.w.Name())
// _,ok = <-self.quit
// if ok {
// self.quit <- true
// }
close(self.quit)
close(self.errs)
close(self.data)
fd := self.w.Fd()
if fd >= 0 {
fname := self.w.Name()
err := self.w.Close()
if err != nil {
msg.MsgError("closing fd: [%v] name [%v]. err: %v\n",
fd, fname, err)
return kernel.StatusCodeWithErr(1, err)
}
}
return kernel.StatusCode(0)
}
func (self *alg_adder) Execute(ctx kernel.IEvtCtx) kernel.Error {
self.MsgDebug("== execute == [%v]\n", ctx.Idx())
njets := 1 + ctx.Idx()
val := self.val + 1
store := self.EvtStore(ctx)
if store.Has("njets") {
njets += store.Get("njets").(int)
}
store.Put("njets", njets)
if store.Has("ptjets") {
val += store.Get("ptjets").(float64)
}
store.Put("ptjets", val)
cnt := &simple_counter{0}
if store.Has(self.cnt_key) {
cnt = store.Get(self.cnt_key).(*simple_counter)
}
cnt.Cnt += 1
store.Put(self.cnt_key, cnt)
return kernel.StatusCode(0)
}
func (self *json_outstream_handle) Write(data interface{}) kernel.Error {
/* // FIXME: how to get the error back ??
err := self.enc.Encode(data)
if err != nil {
return kernel.StatusCodeWithErr(1, err)
}
*/
self.data <- data
select {
case err := <-self.errs:
if err != nil {
msg := self.svc.(kernel.IMessager)
msg.MsgError("--> write got: %v\n", err)
return kernel.StatusCodeWithErr(1, err)
}
default:
return kernel.StatusCode(0)
}
return kernel.StatusCode(0)
}
func (self *gob_outstream) Execute(ctx kernel.IEvtCtx) kernel.Error {
self.MsgDebug("== execute ==\n")
store := self.EvtStore(ctx)
if store == nil {
self.MsgError("could not retrieve evt-store\n")
}
var err error
allgood := true
for _, k := range self.item_names {
err = self.enc.Encode(store.Get(k))
if err != nil {
self.MsgError("error while writing store content at [%v]: %v\n",
k, err)
allgood = false
}
}
/*
hdr_offset := 1
val := make([]interface{}, len(self.item_names)+hdr_offset)
val[0] = ctx.Idx()
for i,k := range self.item_names {
val[i+hdr_offset] = store.Get(k)
}
for idx,v := range val {
err = self.enc.Encode(val)
if err != nil {
self.MsgError("error while encoding data [%v|%v]: %v\n",
idx, v, err)
allgood = false
}
}
*/
if !allgood {
return kernel.StatusCode(1)
}
return kernel.StatusCode(0)
}
func (self *gob_outstream) Initialize() kernel.Error {
self.MsgDebug("== initialize ==\n")
if !self.Algorithm.Initialize().IsSuccess() {
self.MsgError("could not initialize base-class\n")
return kernel.StatusCode(1)
}
self.item_names = self.GetProperty("Items").([]string)
fname := self.GetProperty("Output").(string)
self.MsgInfo("output file: [%v]\n", fname)
self.MsgInfo("items: %v\n", self.item_names)
w, err := os.Create(fname)
if err != nil {
self.MsgError("problem while opening file [%v]: %v\n", fname, err)
return kernel.StatusCode(1)
}
self.w = w
self.enc = gob.NewEncoder(self.w)
return kernel.StatusCode(0)
}
func (self *evtproc) InitializeSvc() kernel.Error {
sc := self.Service.InitializeSvc()
if !sc.IsSuccess() {
return sc
}
self.nworkers = self.GetProperty("NbrWorkers").(int)
//self.nworkers = 2
self.MsgInfo("n-workers: %v\n", self.nworkers)
svcloc := kernel.GetSvcLocator()
if svcloc == nil {
self.MsgError("could not retrieve ISvcLocator !\n")
return kernel.StatusCode(1)
}
appmgr := svcloc.(kernel.IComponentMgr).GetComp("app-mgr")
if appmgr == nil {
self.MsgError("could not retrieve 'app-mgr'\n")
}
propmgr := appmgr.(kernel.IProperty)
alg_names := propmgr.GetProperty("Algs").([]string)
self.MsgInfo("got alg-names: %v\n", len(alg_names))
if len(alg_names) > 0 {
comp_mgr := appmgr.(kernel.IComponentMgr)
self.algs = make([]kernel.IAlgorithm, len(alg_names))
for i, alg_name := range alg_names {
ialg, isalg := comp_mgr.GetComp(alg_name).(kernel.IAlgorithm)
if isalg {
self.algs[i] = ialg
}
}
}
self.MsgInfo("got alg-list: %v\n", len(self.algs))
return kernel.StatusCode(0)
}
func (self *evtproc) test_0() {
handle := func(queue <-chan int) kernel.Error {
sc := kernel.StatusCode(0)
for i := range queue {
ctx := new_evtstate(i)
self.MsgInfo(" --> handling [%i]...\n", i)
sc = self.ExecuteEvent(ctx)
}
return sc
}
max_in_flight := 4
serve := func(queue <-chan int, quit <-chan bool) kernel.Error {
for i := 0; i < max_in_flight; i++ {
go handle(queue)
}
<-quit // wait to be told to exit
return kernel.StatusCode(0)
}
quit := make(chan bool)
self.MsgInfo("-- filling the event queue...\n")
queue := make(chan int)
go func() {
for i := 0; i < 20; i++ {
queue <- i
}
}()
self.MsgInfo("-- starting to serve 20 events...\n")
go serve(queue, quit)
self.MsgInfo("-- requests sent...\n")
time.Sleep(2000000000)
quit <- true
self.MsgInfo("-- done.\n")
}
func (self *json_outstream_svc) FinalizeSvc() kernel.Error {
self.MsgDebug("== finalize ==\n")
if !self.Service.FinalizeSvc().IsSuccess() {
self.MsgError("could not finalize base-class\n")
return kernel.StatusCode(1)
}
self.MsgDebug("== closing output streams...\n")
allgood := true
for n, stream := range self.streams {
self.MsgDebug("-- closing [%s]...\n", n)
sc := stream.Close()
if !sc.IsSuccess() {
self.MsgError("problem closing stream [%s]: %v\n", n, sc)
allgood = false
}
}
if !allgood {
return kernel.StatusCode(1)
}
return kernel.StatusCode(0)
}
func (self *alg_dumper) Execute(ctx kernel.IEvtCtx) kernel.Error {
self.MsgDebug("== execute == [%v]\n", ctx.Idx())
store := self.EvtStore(ctx)
njets := store.Get(self.njets_key).(int)
ptjets := store.Get(self.ptjets_key).(float64)
cnt := store.Get(self.cnt_key).(*simple_counter)
if self.cnt_val == cnt.Cnt {
self.MsgDebug("[ctx:%03v] njets: %03v ptjets: %8.3v [OK]\n",
ctx.Idx(), njets, ptjets)
} else {
self.MsgError("[ctx:%03v] njets: %03v ptjets: %8.3v (%v|%v) [ERR]\n",
ctx.Idx(), njets, ptjets, self.cnt_val, cnt.Cnt)
panic("race condition detected in evt-store")
}
// simulate a cpu-burning algorithm
time.Sleep(3 * 10e6) // 3ms
return kernel.StatusCode(0)
}
func (self *evtproc) StopRun() kernel.Error {
self.MsgInfo("stopping run...\n")
return kernel.StatusCode(0)
}
func (self *gob_outstream) Finalize() kernel.Error {
self.MsgDebug("== finalize ==\n")
//self.w.Close()
return kernel.StatusCode(0)
}
func (self *svc2) FinalizeSvc() kernel.Error {
self.MsgInfo("~~ finalize ~~\n")
return kernel.StatusCode(0)
}
func (self *datastore) ClearStore() kernel.Error {
for k, _ := range self.store {
delete(self.store, k)
}
return kernel.StatusCode(0)
}
func (self *alg1) Finalize() kernel.Error {
self.MsgInfo("== finalize ==\n")
return kernel.StatusCode(0)
}
func (self *alg1) Execute(ctx kernel.IEvtCtx) kernel.Error {
self.MsgDebug("== execute == [%v]\n", ctx.Idx())
return kernel.StatusCode(0)
}
func (self *datastoresvc) FinalizeSvc() kernel.Error {
self.MsgInfo("~~ finalize [datastore svc] ~~\n")
return kernel.StatusCode(0)
}
func (self *alg1) Execute(ctx kernel.IEvtCtx) kernel.Error {
self.MsgDebug("== execute == [ctx:%v]\n", ctx.Idx())
detstore := self.DetStore(ctx)
self.MsgDebug("det-store: %v\n", detstore)
return kernel.StatusCode(0)
}
func (self *alg2) Execute(ctx kernel.IEvtCtx) kernel.Error {
self.MsgDebug("~~ execute ~~ [ctx:%v]\n", ctx.Idx())
return kernel.StatusCode(0)
}
func (self *tool1) FinalizeTool() kernel.Error {
self.MsgInfo("~~ finalize ~~\n")
return kernel.StatusCode(0)
}