lib/xdsserver/apiv1-events.go

   1 package xdsserver
   2
   3 import (
   4         "net/http"
   5         "strings"
   6         "time"
   7
   8         "github.com/gin-gonic/gin"
   9         common "github.com/iotbzh/xds-common/golib"
  10         "github.com/iotbzh/xds-server/lib/xsapiv1"
  11 )
  12
  13 // eventsList Registering for events that will be send over a WS
  14 func (s *APIService) eventsList(c *gin.Context) {
  15
  16 }
  17
  18 // eventsRegister Registering for events that will be send over a WS
  19 func (s *APIService) eventsRegister(c *gin.Context) {
  20         var args xsapiv1.EventRegisterArgs
  21
  22         if c.BindJSON(&args) != nil {
  23                 common.APIError(c, "Invalid arguments")
  24                 return
  25         }
  26
  27         sess := s.sessions.Get(c)
  28         if sess == nil {
  29                 common.APIError(c, "Unknown sessions")
  30                 return
  31         }
  32
  33         evType := strings.TrimPrefix(xsapiv1.EVTFolderStateChange, xsapiv1.EventTypePrefix)
  34         if args.Name != evType {
  35                 common.APIError(c, "Unsupported event name")
  36                 return
  37         }
  38
  39         /* XXX - to be removed if no plan to support "generic" event
  40         var cbFunc st.EventsCB
  41         cbFunc = func(ev st.Event, data *st.EventsCBData) {
  42
  43                 evid, _ := strconv.Atoi((*data)["id"].(string))
  44                 ssid := (*data)["sid"].(string)
  45                 so := s.sessions.IOSocketGet(ssid)
  46                 if so == nil {
  47                         s.log.Infof("Event %s not emitted - sid: %s", ev.Type, ssid)
  48
  49                         // Consider that client disconnected, so unregister this event
  50                         s.mfolders.SThg.Events.UnRegister(ev.Type, evid)
  51                         return
  52                 }
  53
  54                 msg := EventMsg{
  55                         Time: ev.Time,
  56                         Type: ev.Type,
  57                         Data: ev.Data,
  58                 }
  59
  60                 if err := (*so).Emit(EVTAll, msg); err != nil {
  61                         s.log.Errorf("WS Emit Event : %v", err)
  62                 }
  63
  64                 if err := (*so).Emit(EventTypePrefix+ev.Type, msg); err != nil {
  65                         s.log.Errorf("WS Emit Event : %v", err)
  66                 }
  67         }
  68
  69         data := make(st.EventsCBData)
  70         data["sid"] = sess.ID
  71
  72         id, err := s.mfolders.SThg.Events.Register(args.Name, cbFunc, args.ProjectID, &data)
  73         */
  74
  75         var cbFunc FolderEventCB
  76         cbFunc = func(cfg *xsapiv1.FolderConfig, data *FolderEventCBData) {
  77                 ssid := (*data)["sid"].(string)
  78                 so := s.sessions.IOSocketGet(ssid)
  79                 if so == nil {
  80                         //s.log.Infof("Event %s not emitted - sid: %s", ev.Type, ssid)
  81
  82                         // Consider that client disconnected, so unregister this event
  83                         // SEB FIXMEs.mfolders.RegisterEventChange(ev.Type)
  84                         return
  85                 }
  86
  87                 msg := xsapiv1.EventMsg{
  88                         Time:   time.Now().String(),
  89                         Type:   evType,
  90                         Folder: *cfg,
  91                 }
  92
  93                 s.Log.Debugf("WS Emit %s - Status=%10s, IsInSync=%6v, ID=%s",
  94                         xsapiv1.EventTypePrefix+evType, cfg.Status, cfg.IsInSync, cfg.ID)
  95
  96                 if err := (*so).Emit(xsapiv1.EventTypePrefix+evType, msg); err != nil {
  97                         s.Log.Errorf("WS Emit Folder StateChanged event : %v", err)
  98                 }
  99         }
 100         data := make(FolderEventCBData)
 101         data["sid"] = sess.ID
 102
 103         prjID, err := s.mfolders.ResolveID(args.ProjectID)
 104         if err != nil {
 105                 common.APIError(c, err.Error())
 106                 return
 107         }
 108         if err = s.mfolders.RegisterEventChange(prjID, &cbFunc, &data); err != nil {
 109                 common.APIError(c, err.Error())
 110                 return
 111         }
 112
 113         c.JSON(http.StatusOK, gin.H{"status": "OK"})
 114 }
 115
 116 // eventsRegister Registering for events that will be send over a WS
 117 func (s *APIService) eventsUnRegister(c *gin.Context) {
 118         var args xsapiv1.EventUnRegisterArgs
 119
 120         if c.BindJSON(&args) != nil || args.Name == "" || args.ID < 0 {
 121                 common.APIError(c, "Invalid arguments")
 122                 return
 123         }
 124         /* TODO
 125         if err := s.mfolders.SThg.Events.UnRegister(args.Name, args.ID); err != nil {
 126                 common.APIError(c, err.Error())
 127                 return
 128         }
 129         c.JSON(http.StatusOK, gin.H{"status": "OK"})
 130         */
 131         common.APIError(c, "Not implemented yet")
 132 }