Integration of ARPC with Gin

main.go

package main

import (
	"github.com/gin-gonic/gin"
	"go.uber.org/zap"
)

func main() {
  router := gin.New()
  logger := zap.NewNoOp() //replace with your logger
  wss := RegisterWebsocketServer(hostPort, router, logger)
  defer wss.Stop()
 
  // register your arpc handlers normally.
  wss.svr.Handler.Handle("/route/sub", func(ctx *arpc.Context) {
      // arpc handling things
  })
  
  logger.Info("Starting server", zap.String("hostport", hostPort))
  wss.Start()
  router.Run(hostPort)
  logger.Info("server stopping...")
}

func RegisterWebsocketServer(hostPort string, r *gin.Engine, logger *zap.Logger) *stream.WebSocketServer {
	wssGroup := r.Group("/ws", wsAuthorizedMiddleware)
	return stream.NewWebSocketServer(hostPort, wssGroup, logger)
}

websocket_server.go

package stream

import (
	"net"
	"net/http"

	"github.com/gin-gonic/gin"
	"github.com/lesismal/arpc"
	"github.com/lesismal/arpc/extension/protocol/websocket"
	"go.uber.org/zap"
)

type WebSocketServer struct {
	HostPort string
	Logger   *zap.Logger
	svr      *arpc.Server
	ln       net.Listener
}

func (wss *WebSocketServer) Start() {
	go wss.svr.Serve(wss.ln)
}

func (wss *WebSocketServer) Stop() error {
	err := wss.svr.Stop()

	if err != nil {
		wss.Logger.Error("websocket server stop error", zap.Error(err))
	}

	return err
}

func NewWebSocketServer(hostPort string, r *gin.RouterGroup, logger *zap.Logger) *WebSocketServer {

	ln, err := websocket.Listen(hostPort, nil)
	if err != nil {
		logger.Fatal("websocket could not listen on given port", zap.String("hostPort", hostPort))
	}

	//register web socket route with arpc listener - note the  router group group needs to be registered to  `/ws`
	r.GET("", netHttpToGinAdapter(ln.(*websocket.Listener).Handler))

	logger.Debug("websocket server starting", zap.String("hostPort", hostPort))
	svr := arpc.NewServer()

	wss := WebSocketServer{
		HostPort: hostPort,
		Logger:   logger,
		svr:      svr,
		ln:       ln,
	}

	svr.Handler.HandleConnected(func(c *arpc.Client) {
		client := NewArpcClient(c, logger)
		logger.Debug("websocket server client connected", zap.String("client-id", client.Id()))
	})

	svr.Handler.HandleDisconnected(func(c *arpc.Client) {
		client := NewArpcClient(c, logger)
		logger.Debug("websocket server client disconnected", zap.String("client-id", client.Id()))
	})

	return &wss
}

func netHttpToGinAdapter(handler http.HandlerFunc) gin.HandlerFunc {
	return func(c *gin.Context) {
		handler(c.Writer, c.Request)
	}
}