lib/xdsserver/apiv1-events.go

   1 /*
   2  * Copyright (C) 2017 "IoT.bzh"
   3  * Author Sebastien Douheret <sebastien@iot.bzh>
   4  *
   5  * Licensed under the Apache License, Version 2.0 (the "License");
   6  * you may not use this file except in compliance with the License.
   7  * You may obtain a copy of the License at
   8  *
   9  *   http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  * Unless required by applicable law or agreed to in writing, software
  12  * distributed under the License is distributed on an "AS IS" BASIS,
  13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  * See the License for the specific language governing permissions and
  15  * limitations under the License.
  16  */
  17
  18 package xdsserver
  19
  20 import (
  21         "net/http"
  22         "strings"
  23         "time"
  24
  25         "github.com/gin-gonic/gin"
  26         common "github.com/iotbzh/xds-common/golib"
  27         "github.com/iotbzh/xds-server/lib/xsapiv1"
  28 )
  29
  30 // eventsList Registering for events that will be send over a WS
  31 func (s *APIService) eventsList(c *gin.Context) {
  32
  33 }
  34
  35 // eventsRegister Registering for events that will be send over a WS
  36 func (s *APIService) eventsRegister(c *gin.Context) {
  37         var args xsapiv1.EventRegisterArgs
  38
  39         if c.BindJSON(&args) != nil {
  40                 common.APIError(c, "Invalid arguments")
  41                 return
  42         }
  43
  44         sess := s.sessions.Get(c)
  45         if sess == nil {
  46                 common.APIError(c, "Unknown sessions")
  47                 return
  48         }
  49
  50         evType := strings.TrimPrefix(xsapiv1.EVTFolderStateChange, xsapiv1.EventTypePrefix)
  51         if args.Name != evType {
  52                 common.APIError(c, "Unsupported event name")
  53                 return
  54         }
  55
  56         /* XXX - to be removed if no plan to support "generic" event
  57         var cbFunc st.EventsCB
  58         cbFunc = func(ev st.Event, data *st.EventsCBData) {
  59
  60                 evid, _ := strconv.Atoi((*data)["id"].(string))
  61                 ssid := (*data)["sid"].(string)
  62                 so := s.sessions.IOSocketGet(ssid)
  63                 if so == nil {
  64                         s.log.Infof("Event %s not emitted - sid: %s", ev.Type, ssid)
  65
  66                         // Consider that client disconnected, so unregister this event
  67                         s.mfolders.SThg.Events.UnRegister(ev.Type, evid)
  68                         return
  69                 }
  70
  71                 msg := EventMsg{
  72                         Time: ev.Time,
  73                         Type: ev.Type,
  74                         Data: ev.Data,
  75                 }
  76
  77                 if err := (*so).Emit(EVTAll, msg); err != nil {
  78                         s.log.Errorf("WS Emit Event : %v", err)
  79                 }
  80
  81                 if err := (*so).Emit(EventTypePrefix+ev.Type, msg); err != nil {
  82                         s.log.Errorf("WS Emit Event : %v", err)
  83                 }
  84         }
  85
  86         data := make(st.EventsCBData)
  87         data["sid"] = sess.ID
  88
  89         id, err := s.mfolders.SThg.Events.Register(args.Name, cbFunc, args.ProjectID, &data)
  90         */
  91
  92         var cbFunc FolderEventCB
  93         cbFunc = func(cfg *xsapiv1.FolderConfig, data *FolderEventCBData) {
  94                 ssid := (*data)["sid"].(string)
  95                 so := s.sessions.IOSocketGet(ssid)
  96                 if so == nil {
  97                         //s.log.Infof("Event %s not emitted - sid: %s", ev.Type, ssid)
  98
  99                         // Consider that client disconnected, so unregister this event
 100                         // SEB FIXMEs.mfolders.RegisterEventChange(ev.Type)
 101                         return
 102                 }
 103
 104                 msg := xsapiv1.EventMsg{
 105                         Time:   time.Now().String(),
 106                         Type:   evType,
 107                         Folder: *cfg,
 108                 }
 109
 110                 s.Log.Debugf("WS Emit %s - Status=%10s, IsInSync=%6v, ID=%s",
 111                         xsapiv1.EventTypePrefix+evType, cfg.Status, cfg.IsInSync, cfg.ID)
 112
 113                 if err := (*so).Emit(xsapiv1.EventTypePrefix+evType, msg); err != nil {
 114                         s.Log.Errorf("WS Emit Folder StateChanged event : %v", err)
 115                 }
 116         }
 117         data := make(FolderEventCBData)
 118         data["sid"] = sess.ID
 119
 120         prjID, err := s.mfolders.ResolveID(args.ProjectID)
 121         if err != nil {
 122                 common.APIError(c, err.Error())
 123                 return
 124         }
 125         if err = s.mfolders.RegisterEventChange(prjID, &cbFunc, &data); err != nil {
 126                 common.APIError(c, err.Error())
 127                 return
 128         }
 129
 130         c.JSON(http.StatusOK, gin.H{"status": "OK"})
 131 }
 132
 133 // eventsRegister Registering for events that will be send over a WS
 134 func (s *APIService) eventsUnRegister(c *gin.Context) {
 135         var args xsapiv1.EventUnRegisterArgs
 136
 137         if c.BindJSON(&args) != nil || args.Name == "" || args.ID < 0 {
 138                 common.APIError(c, "Invalid arguments")
 139                 return
 140         }
 141         /* TODO
 142         if err := s.mfolders.SThg.Events.UnRegister(args.Name, args.ID); err != nil {
 143                 common.APIError(c, err.Error())
 144                 return
 145         }
 146         c.JSON(http.StatusOK, gin.H{"status": "OK"})
 147         */
 148         common.APIError(c, "Not implemented yet")
 149 }