lib/xdsserver/server.go

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