kettle/htp/server.go

package htp

import (
	"context"
	"fmt"
	"github.com/gin-gonic/gin"
	"github.com/gin-contrib/cors"
	"net/http"
	"time"
)

/**
	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 WithDebug(enabled bool) GinServerOptions {
	return func(s *GinServer) {
		s.debug = enabled
	}
}

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

func WithName(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
}