kettle/htp/server.go

package htp

import (
	"context"
	"fmt"
	"net/http"
	"time"

	"github.com/gin-contrib/cors"
	"github.com/gin-gonic/gin"
)

/**
GinServer is used for simplifies the usage of gin package.

Example:
	see test file
*/

type FnSetupRoutes func(*gin.Engine)

// GinServer option type
type GinServerOptions func(*GinServer)

type GinServer struct {
	cors    bool
	debug   bool
	running bool
	addr    string
	name    string // sometime we need a name for the server
	server  *http.Server
}

func GinServerWithDebug(enabled bool) GinServerOptions {
	return func(s *GinServer) {
		s.debug = enabled
	}
}

func GinServerWithCors(enabled bool) GinServerOptions {
	return func(s *GinServer) {
		s.cors = enabled
	}
}

func GinServerWithName(name string) GinServerOptions {
	return func(s *GinServer) {
		s.name = name
	}
}

func NewGinServer(addr string, opts ...GinServerOptions) *GinServer {
	s := &GinServer{
		debug:   false,
		running: false,
		addr:    addr,
	}

	for _, opt := range opts {
		opt(s)
	}

	return s
}

func (self *GinServer) Start(fnSetup FnSetupRoutes) error {
	// running mode
	if self.debug {
		gin.SetMode(gin.DebugMode)
	} else {
		gin.SetMode(gin.ReleaseMode)
	}

	r := gin.Default()

	// cors
	if self.cors {
		r.Use(cors.Default())
	}

	// setup routers
	if fnSetup != nil {
		fnSetup(r)
	}

	// boot service
	self.server = &http.Server{
		Addr:    self.addr,
		Handler: r,
	}

	go func() {
		if err := self.server.ListenAndServe(); err != nil && err != http.ErrServerClosed {
			panic(err)
		}
	}()

	return nil
}

func (self *GinServer) Stop() error {
	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
	defer cancel()

	if err := self.server.Shutdown(ctx); err != nil {
		return err
	}

	select {
	case <-ctx.Done():
		fmt.Println(self.name + " timeout and quit")
	}
	return nil
}