server-go/fasthttp/websocket/server.go

195 lines
4.2 KiB
Go
Raw Normal View History

2018-04-04 04:01:26 +00:00
package websocket
import (
"context"
"fmt"
"net"
"net/http"
"sync"
"git.loafle.net/commons/logging-go"
"git.loafle.net/commons/server-go"
"github.com/valyala/fasthttp"
)
type Server struct {
ServerHandler ServerHandler
2018-04-04 13:28:35 +00:00
ctx server.ServerCtx
stopChan chan struct{}
stopWg sync.WaitGroup
srwch server.ServerRWCHandler
2018-04-04 04:01:26 +00:00
hs *fasthttp.Server
upgrader *Upgrader
}
func (s *Server) ListenAndServe() error {
var (
err error
listener net.Listener
)
if nil == s.ServerHandler {
return fmt.Errorf("Server: server handler must be specified")
}
s.ServerHandler.Validate()
if s.stopChan != nil {
return fmt.Errorf(s.serverMessage("already running. Stop it before starting it again"))
}
s.ctx = s.ServerHandler.ServerCtx()
if nil == s.ctx {
return fmt.Errorf(s.serverMessage("ServerCtx is nil"))
}
s.hs = &fasthttp.Server{
Handler: s.httpHandler,
Name: s.ServerHandler.GetName(),
Concurrency: s.ServerHandler.GetConcurrency(),
ReadBufferSize: s.ServerHandler.GetReadBufferSize(),
WriteBufferSize: s.ServerHandler.GetWriteBufferSize(),
ReadTimeout: s.ServerHandler.GetReadTimeout(),
WriteTimeout: s.ServerHandler.GetWriteTimeout(),
}
s.upgrader = &Upgrader{
HandshakeTimeout: s.ServerHandler.GetHandshakeTimeout(),
ReadBufferSize: s.ServerHandler.GetReadBufferSize(),
WriteBufferSize: s.ServerHandler.GetWriteBufferSize(),
2018-04-04 13:28:35 +00:00
CheckOrigin: s.ServerHandler.(ServerHandler).CheckOrigin,
2018-04-04 04:01:26 +00:00
Error: s.onError,
EnableCompression: s.ServerHandler.IsEnableCompression(),
}
if err = s.ServerHandler.Init(s.ctx); nil != err {
return err
}
if listener, err = s.ServerHandler.Listener(s.ctx); nil != err {
return err
}
s.stopChan = make(chan struct{})
2018-04-04 13:28:35 +00:00
s.srwch.ReadwriteHandler = s.ServerHandler
s.srwch.ServerStopChan = s.stopChan
s.srwch.ServerStopWg = &s.stopWg
2018-04-04 04:01:26 +00:00
s.stopWg.Add(1)
return s.handleServer(listener)
}
func (s *Server) Shutdown(ctx context.Context) error {
if s.stopChan == nil {
2018-04-04 13:28:35 +00:00
return fmt.Errorf("server must be started before stopping it")
2018-04-04 04:01:26 +00:00
}
close(s.stopChan)
s.stopWg.Wait()
s.ServerHandler.Destroy(s.ctx)
s.stopChan = nil
return nil
}
func (s *Server) serverMessage(msg string) string {
return fmt.Sprintf("Server[%s]: %s", s.ServerHandler.GetName(), msg)
}
func (s *Server) handleServer(listener net.Listener) error {
var (
err error
)
errChan := make(chan error)
defer func() {
if nil != listener {
listener.Close()
}
s.stopWg.Done()
}()
go func() {
if err := s.hs.Serve(listener); nil != err {
errChan <- err
return
}
close(errChan)
}()
select {
case err, _ := <-errChan:
if nil != err {
return err
}
}
defer func() {
s.ServerHandler.OnStop(s.ctx)
logging.Logger().Infof(s.serverMessage("Stopped"))
}()
if err = s.ServerHandler.OnStart(s.ctx); nil != err {
return err
}
logging.Logger().Infof(s.serverMessage("Started"))
select {
case <-s.stopChan:
listener.Close()
listener = nil
}
return nil
}
func (s *Server) httpHandler(ctx *fasthttp.RequestCtx) {
path := string(ctx.Path())
var (
servlet Servlet
err error
)
if 0 < s.ServerHandler.GetConcurrency() {
2018-04-04 13:28:35 +00:00
sz := s.srwch.ConnectionSize()
2018-04-04 04:01:26 +00:00
if sz >= s.ServerHandler.GetConcurrency() {
logging.Logger().Warnf(s.serverMessage(fmt.Sprintf("max connections size %d, refuse", sz)))
s.onError(ctx, fasthttp.StatusServiceUnavailable, err)
return
}
}
2018-04-04 13:28:35 +00:00
if servlet = s.ServerHandler.(ServerHandler).Servlet(path); nil == servlet {
2018-04-04 04:01:26 +00:00
s.onError(ctx, fasthttp.StatusInternalServerError, err)
return
}
var responseHeader *fasthttp.ResponseHeader
servletCtx := servlet.ServletCtx(s.ctx)
if responseHeader, err = servlet.Handshake(servletCtx, ctx); nil != err {
s.onError(ctx, http.StatusNotAcceptable, fmt.Errorf("Handshake err: %v", err))
return
}
2018-04-04 05:47:10 +00:00
s.upgrader.Upgrade(ctx, responseHeader, func(conn *server.Conn, err error) {
2018-04-04 04:01:26 +00:00
if err != nil {
s.onError(ctx, fasthttp.StatusInternalServerError, err)
return
}
s.stopWg.Add(1)
2018-04-04 13:28:35 +00:00
go s.srwch.HandleConnection(servlet, servletCtx, conn)
2018-04-04 08:36:23 +00:00
})
2018-04-04 04:01:26 +00:00
}
func (s *Server) onError(ctx *fasthttp.RequestCtx, status int, reason error) {
2018-04-04 13:28:35 +00:00
s.ServerHandler.(ServerHandler).OnError(s.ctx, ctx, status, reason)
2018-04-04 04:01:26 +00:00
}