lib/agent/events.go

   1 package agent
   2
   3 import (
   4         "fmt"
   5         "time"
   6
   7         "github.com/iotbzh/xds-agent/lib/xaapiv1"
   8 )
   9
  10 // EventDef Definition on one event
  11 type EventDef struct {
  12         sids map[string]int
  13 }
  14
  15 // Events Hold registered events per context
  16 type Events struct {
  17         *Context
  18         eventsMap map[string]*EventDef
  19 }
  20
  21 // NewEvents creates an instance of Events
  22 func NewEvents(ctx *Context) *Events {
  23         evMap := make(map[string]*EventDef)
  24         for _, ev := range xaapiv1.EVTAllList {
  25                 evMap[ev] = &EventDef{
  26                         sids: make(map[string]int),
  27                 }
  28         }
  29         return &Events{
  30                 Context:   ctx,
  31                 eventsMap: evMap,
  32         }
  33 }
  34
  35 // GetList returns the list of all supported events
  36 func (e *Events) GetList() []string {
  37         return xaapiv1.EVTAllList
  38 }
  39
  40 // Register Used by a client/session to register to a specific (or all) event(s)
  41 func (e *Events) Register(evName, sessionID string) error {
  42         evs := xaapiv1.EVTAllList
  43         if evName != xaapiv1.EVTAll {
  44                 if _, ok := e.eventsMap[evName]; !ok {
  45                         return fmt.Errorf("Unsupported event type name")
  46                 }
  47                 evs = []string{evName}
  48         }
  49         for _, ev := range evs {
  50                 e.eventsMap[ev].sids[sessionID]++
  51         }
  52         return nil
  53 }
  54
  55 // UnRegister Used by a client/session to unregister event(s)
  56 func (e *Events) UnRegister(evName, sessionID string) error {
  57         evs := xaapiv1.EVTAllList
  58         if evName != xaapiv1.EVTAll {
  59                 if _, ok := e.eventsMap[evName]; !ok {
  60                         return fmt.Errorf("Unsupported event type name")
  61                 }
  62                 evs = []string{evName}
  63         }
  64         for _, ev := range evs {
  65                 if _, exist := e.eventsMap[ev].sids[sessionID]; exist {
  66                         delete(e.eventsMap[ev].sids, sessionID)
  67                         break
  68                 }
  69         }
  70         return nil
  71 }
  72
  73 // Emit Used to manually emit an event
  74 func (e *Events) Emit(evName string, data interface{},fromSid string) error {
  75         var firstErr error
  76
  77         if _, ok := e.eventsMap[evName]; !ok {
  78                 return fmt.Errorf("Unsupported event type")
  79         }
  80
  81         if e.LogLevelSilly {
  82                 e.Log.Debugf("Emit Event %s: %v", evName, data)
  83         }
  84
  85         firstErr = nil
  86         evm := e.eventsMap[evName]
  87         for sid := range evm.sids {
  88                 so := e.webServer.sessions.IOSocketGet(sid)
  89                 if so == nil {
  90                         if firstErr == nil {
  91                                 firstErr = fmt.Errorf("IOSocketGet return nil (SID=%v)", sid)
  92                         }
  93                         continue
  94                 }
  95                 msg := xaapiv1.EventMsg{
  96                         Time:          time.Now().String(),
  97                         FromSessionID: fromSid,
  98                         Type:          evName,
  99                         Data:          data,
 100                 }
 101                 e.Log.Debugf("Emit Event %s: %v", evName, sid)
 102                 if err := (*so).Emit(evName, msg); err != nil {
 103                         e.Log.Errorf("WS Emit %v error : %v", evName, err)
 104                         if firstErr == nil {
 105                                 firstErr = err
 106                         }
 107                 }
 108         }
 109
 110         return firstErr
 111 }