lib/apiv1/events.go

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