lib/agent/events.go

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