gitee.com/woood2/luca@v1.0.4/cmd/backend/main.go

package main

import (
	"context"
	"fmt"
	_ "gitee.com/woood2/luca/cmd/backend/docs"
	"gitee.com/woood2/luca/cmd/backend/internal/assembly"
	"gitee.com/woood2/luca/internal/cache"
	"gitee.com/woood2/luca/internal/conf"
	"gitee.com/woood2/luca/internal/db"
	"gitee.com/woood2/luca/internal/discovery"
	"gitee.com/woood2/luca/internal/errcode"
	myLog "gitee.com/woood2/luca/internal/log"
	"gitee.com/woood2/luca/internal/producer"
	"gitee.com/woood2/luca/internal/status"
	"gitee.com/woood2/luca/internal/trace"
	"github.com/gin-contrib/cors"
	"github.com/gin-gonic/gin"
	"github.com/go-kit/kit/sd"
	opzipkin "github.com/openzipkin/zipkin-go"
	swaggerFiles "github.com/swaggo/files"
	ginSwagger "github.com/swaggo/gin-swagger"
	"go.uber.org/zap"
	"log"
	"net"
	"net/http"
	"net/http/httputil"
	"os"
	"os/signal"
	"runtime/debug"
	"strconv"
	"strings"
	"syscall"
	"time"
)

const entrance = "backend"

// @title Luca APIs
// @version 1.0
// @description 基于Gin封装的demo项目
// @securityDefinitions.apikey ApiKeyAuth
// @in header
// @name token
// @BasePath /
func main() {
	//config
	attr := conf.Load("application.yml", "configs/application.yml")
	//consul
	client, consulClient := discovery.Client(attr.Consul.Host, attr.Consul.Port)
	conf.MergeConsul(attr, consulClient)
	//zap logger
	logger := myLog.Build(attr.Env, attr.Project, entrance, attr.Host, attr.ConsoleLog)
	defer logger.Sync()
	//gorm & mongo & redis & kafka
	gormDB := db.NewGormDB(attr.Env, attr.Mysql, logger)
	db.SetGlobalGormDB(gormDB)
	mongoDB := db.NewMongoDB(attr.Mongo)
	db.SetMongoDB(mongoDB)
	redisCache := cache.NewRedis(attr.Redis)
	cache.SetRedis(redisCache)
	p := producer.New(attr.Kafka, logger)
	defer p.Close()
	producer.SetG(p)
	//zipkin
	trace.Open(attr.Zipkin)
	defer trace.Close()
	//sdk
	assembly.SetupSDK(client, logger)
	//register
	var registar sd.Registrar
	if attr.Backend.Register {
		ho := strings.Split(attr.Backend.Addr, ":")
		if port, err := strconv.Atoi(ho[1]); err != nil {
			log.Panicf("attr.Backend.Addr error: %s\n", err)
		} else {
			registar = discovery.RegisterRestful(client, attr.Project+"_"+entrance, attr.Host, port)
			registar.Register()
		}
	}
	//gin
	if conf.IsPro(attr.Env) {
		gin.SetMode(gin.ReleaseMode)
	}
	r := gin.New()
	r.Use(loggerWithZap(logger, time.RFC3339, false))
	r.Use(recoveryWithZap(logger, true, attr.Env))
	config := cors.DefaultConfig()
	config.AllowOrigins = attr.Backend.AllowOrigins
	r.Use(cors.New(config))
	//Pprof & prometheus & hystrix
	go status.Pprof(attr.Pprof, attr.Env, attr.Backend.PprofAddr)
	go status.Prometheus(attr.Backend.MetricsAddr)
	go status.Hystrix(attr.Backend.HystrixPort)
	//swagger
	if !conf.IsPro(attr.Env) {
		url := ginSwagger.URL("http://" + attr.Host + attr.Backend.Addr + "/swagger/doc.json")
		r.GET("/swagger/*any", ginSwagger.WrapHandler(swaggerFiles.Handler, url))
	}
	//handler
	assembly.RegisterHandler(attr.Project, entrance, attr.Env, r, logger, gormDB)
	//run
	srv := &http.Server{
		Addr:    attr.Backend.Addr,
		Handler: r,
	}
	go func() {
		if err := srv.ListenAndServe(); err != nil && err != http.ErrServerClosed {
			log.Panicf("listen: %s\n", err)
		}
	}()
	//graceful shutdown
	quit := make(chan os.Signal)
	signal.Notify(quit, syscall.SIGHUP, syscall.SIGINT, syscall.SIGTERM, syscall.SIGQUIT, syscall.SIGUSR1, syscall.SIGUSR2)
	<-quit
	log.Println("Shutting down server...")
	if attr.Backend.Register {
		registar.Deregister()       //gray release
		time.Sleep(1 * time.Second) //make sure
	}
	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
	defer cancel()
	if err := srv.Shutdown(ctx); err != nil {
		log.Panicln("Server forced to shutdown:", err)
	}
	log.Println("Server exiting")
}

func loggerWithZap(logger *zap.Logger, timeFormat string, utc bool) gin.HandlerFunc {
	return func(c *gin.Context) {
		start := time.Now()
		// some evil middlewares modify this values
		path := c.Request.URL.Path
		query := c.Request.URL.RawQuery
		c.Next()

		end := time.Now()
		latency := end.Sub(start)
		if utc {
			end = end.UTC()
		}

		if len(c.Errors) > 0 {
			// Append error field if this is an erroneous request.
			for _, e := range c.Errors.Errors() {
				logger.Error(e)
			}
		} else {
			traceID := "-"
			if s, ok := c.Keys[trace.SpanKey()]; ok {
				span := s.(opzipkin.Span)
				traceID = span.Context().TraceID.String()
			}

			logger.Info(path,
				zap.Int("status", c.Writer.Status()),
				zap.String("method", c.Request.Method),
				zap.String("path", path),
				zap.String("traceID", traceID),
				zap.String("query", query),
				zap.String("ip", c.ClientIP()),
				zap.String("user-agent", c.Request.UserAgent()),
				zap.String("time", end.Format(timeFormat)),
				zap.Duration("latency", latency),
			)
		}
	}
}

func recoveryWithZap(logger *zap.Logger, stack bool, env string) gin.HandlerFunc {
	return func(c *gin.Context) {
		defer func() {
			if err := recover(); err != nil {
				// Check for a broken connection, as it is not really a
				// condition that warrants a panic stack trace.
				var brokenPipe bool
				if ne, ok := err.(*net.OpError); ok {
					if se, ok := ne.Err.(*os.SyscallError); ok {
						if strings.Contains(strings.ToLower(se.Error()), "broken pipe") || strings.Contains(strings.ToLower(se.Error()), "connection reset by peer") {
							brokenPipe = true
						}
					}
				}

				httpRequest, _ := httputil.DumpRequest(c.Request, false)
				if brokenPipe {
					logger.Error(c.Request.URL.Path,
						zap.Any("error", err),
						zap.String("request", string(httpRequest)),
					)
					// If the connection is dead, we can't write a status to it.
					c.Error(err.(error)) // nolint: errcheck
					c.Abort()
					return
				}

				traceID := "-"
				if s, ok := c.Keys[trace.SpanKey()]; ok {
					span := s.(opzipkin.Span)
					traceID = span.Context().TraceID.String()
				}

				detail := string(debug.Stack())
				if stack {
					logger.Error("[Recovery from panic]",
						zap.Time("time", time.Now()),
						zap.Any("error", err),
						zap.String("traceID", traceID),
						zap.String("request", string(httpRequest)),
						zap.String("stack", detail),
					)
				} else {
					logger.Error("[Recovery from panic]",
						zap.Time("time", time.Now()),
						zap.Any("error", err),
						zap.String("traceID", traceID),
						zap.String("request", string(httpRequest)),
					)
				}
				resp := &errcode.Resp{
					ErrCode: errcode.RestfulErrCode[errcode.ServerErr],
					ErrMsg:  errcode.ServerErr.Error(),
					Data:    nil,
					TraceID: traceID,
				}
				if !conf.IsPro(env) && stack {
					resp.Stack = fmt.Sprintf("Recovery from panic: %+v", err)
					resp.Stack += "\n" + detail
				}
				c.JSON(500, resp)
				c.Abort()
			}
		}()
		c.Next()
	}
}