lib/webserver/server.go

   1 package webserver
   2
   3 import (
   4         "net/http"
   5         "os"
   6
   7         "path"
   8
   9         "github.com/Sirupsen/logrus"
  10         "github.com/gin-contrib/static"
  11         "github.com/gin-gonic/gin"
  12         "github.com/googollee/go-socket.io"
  13         "github.com/iotbzh/xds-server/lib/apiv1"
  14         "github.com/iotbzh/xds-server/lib/model"
  15         "github.com/iotbzh/xds-server/lib/session"
  16         "github.com/iotbzh/xds-server/lib/xdsconfig"
  17 )
  18
  19 // ServerService .
  20 type ServerService struct {
  21         router    *gin.Engine
  22         api       *apiv1.APIService
  23         sIOServer *socketio.Server
  24         webApp    *gin.RouterGroup
  25         cfg       *xdsconfig.Config
  26         sessions  *session.Sessions
  27         mfolder   *model.Folder
  28         log       *logrus.Logger
  29         stop      chan struct{} // signals intentional stop
  30 }
  31
  32 const indexFilename = "index.html"
  33 const cookieMaxAge = "3600"
  34
  35 // NewServer creates an instance of ServerService
  36 func NewServer(cfg *xdsconfig.Config, mfolder *model.Folder, log *logrus.Logger) *ServerService {
  37
  38         // Setup logging for gin router
  39         if cfg.Log.Level == logrus.DebugLevel {
  40                 gin.SetMode(gin.DebugMode)
  41         } else {
  42                 gin.SetMode(gin.ReleaseMode)
  43         }
  44
  45         // TODO
  46         //  - try to bind gin DefaultWriter & DefaultErrorWriter to logrus logger
  47         //  - try to fix pb about isTerminal=false when out is in VSC Debug Console
  48         //gin.DefaultWriter = ??
  49         //gin.DefaultErrorWriter = ??
  50
  51         // Creates gin router
  52         r := gin.New()
  53
  54         svr := &ServerService{
  55                 router:    r,
  56                 api:       nil,
  57                 sIOServer: nil,
  58                 webApp:    nil,
  59                 cfg:       cfg,
  60                 log:       log,
  61                 sessions:  nil,
  62                 mfolder:   mfolder,
  63                 stop:      make(chan struct{}),
  64         }
  65
  66         return svr
  67 }
  68
  69 // Serve starts a new instance of the Web Server
  70 func (s *ServerService) Serve() error {
  71         var err error
  72
  73         // Setup middlewares
  74         s.router.Use(gin.Logger())
  75         s.router.Use(gin.Recovery())
  76         s.router.Use(s.middlewareXDSDetails())
  77         s.router.Use(s.middlewareCORS())
  78
  79         // Sessions manager
  80         s.sessions = session.NewClientSessions(s.router, s.log, cookieMaxAge)
  81
  82         // Create REST API
  83         s.api = apiv1.New(s.sessions, s.cfg, s.mfolder, s.router)
  84
  85         // Websocket routes
  86         s.sIOServer, err = socketio.NewServer(nil)
  87         if err != nil {
  88                 s.log.Fatalln(err)
  89         }
  90
  91         s.router.GET("/socket.io/", s.socketHandler)
  92         s.router.POST("/socket.io/", s.socketHandler)
  93         /* TODO: do we want to support ws://...  ?
  94         s.router.Handle("WS", "/socket.io/", s.socketHandler)
  95         s.router.Handle("WSS", "/socket.io/", s.socketHandler)
  96         */
  97
  98         // Web Application (serve on / )
  99         idxFile := path.Join(s.cfg.WebAppDir, indexFilename)
 100         if _, err := os.Stat(idxFile); err != nil {
 101                 s.log.Fatalln("Web app directory not found, check/use webAppDir setting in config file: ", idxFile)
 102         }
 103         s.log.Infof("Serve WEB app dir: %s", s.cfg.WebAppDir)
 104         s.router.Use(static.Serve("/", static.LocalFile(s.cfg.WebAppDir, true)))
 105         s.webApp = s.router.Group("/", s.serveIndexFile)
 106         {
 107                 s.webApp.GET("/")
 108         }
 109
 110         // Serve in the background
 111         serveError := make(chan error, 1)
 112         go func() {
 113                 serveError <- http.ListenAndServe(":"+s.cfg.HTTPPort, s.router)
 114         }()
 115
 116         // Wait for stop, restart or error signals
 117         select {
 118         case <-s.stop:
 119                 // Shutting down permanently
 120                 s.sessions.Stop()
 121                 s.log.Infoln("shutting down (stop)")
 122         case err = <-serveError:
 123                 // Error due to listen/serve failure
 124                 s.log.Errorln(err)
 125         }
 126
 127         return nil
 128 }
 129
 130 // Stop web server
 131 func (s *ServerService) Stop() {
 132         close(s.stop)
 133 }
 134
 135 // serveIndexFile provides initial file (eg. index.html) of webapp
 136 func (s *ServerService) serveIndexFile(c *gin.Context) {
 137         c.HTML(200, indexFilename, gin.H{})
 138 }
 139
 140 // Add details in Header
 141 func (s *ServerService) middlewareXDSDetails() gin.HandlerFunc {
 142         return func(c *gin.Context) {
 143                 c.Header("XDS-Version", s.cfg.Version)
 144                 c.Header("XDS-API-Version", s.cfg.APIVersion)
 145                 c.Next()
 146         }
 147 }
 148
 149 // CORS middleware
 150 func (s *ServerService) middlewareCORS() gin.HandlerFunc {
 151         return func(c *gin.Context) {
 152
 153                 if c.Request.Method == "OPTIONS" {
 154                         c.Header("Access-Control-Allow-Origin", "*")
 155                         c.Header("Access-Control-Allow-Headers", "Content-Type")
 156                         c.Header("Access-Control-Allow-Methods", "POST, DELETE, GET, PUT")
 157                         c.Header("Content-Type", "application/json")
 158                         c.Header("Access-Control-Max-Age", cookieMaxAge)
 159                         c.AbortWithStatus(204)
 160                         return
 161                 }
 162
 163                 c.Next()
 164         }
 165 }
 166
 167 // socketHandler is the handler for the "main" websocket connection
 168 func (s *ServerService) socketHandler(c *gin.Context) {
 169
 170         // Retrieve user session
 171         sess := s.sessions.Get(c)
 172         if sess == nil {
 173                 c.JSON(500, gin.H{"error": "Cannot retrieve session"})
 174                 return
 175         }
 176
 177         s.sIOServer.On("connection", func(so socketio.Socket) {
 178                 s.log.Debugf("WS Connected (SID=%v)", so.Id())
 179                 s.sessions.UpdateIOSocket(sess.ID, &so)
 180
 181                 so.On("disconnection", func() {
 182                         s.log.Debugf("WS disconnected (SID=%v)", so.Id())
 183                         s.sessions.UpdateIOSocket(sess.ID, nil)
 184                 })
 185         })
 186
 187         s.sIOServer.On("error", func(so socketio.Socket, err error) {
 188                 s.log.Errorf("WS SID=%v Error : %v", so.Id(), err.Error())
 189         })
 190
 191         s.sIOServer.ServeHTTP(c.Writer, c.Request)
 192 }