lib/agent/events.go

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