lib/xdsserver/server.go

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