lib/xdsserver/webserver.go

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