lib/xdsserver/webserver.go

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