lib/apiv1/events.go

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