zDWSI/defaultFrontend/server.go

package main

import (
	"fmt"
	"github.com/gin-contrib/gzip"
	"github.com/gin-gonic/gin"
	"github.com/yhat/wsutil"
	"net/http"
	"net/http/httputil"
	"net/url"
	"os"
	"path"
	"strings"
)

var ServerEngine *gin.Engine
var StaticFileSystem http.FileSystem
var FileServer http.Handler
var ReverseProxyRemote *url.URL

func StartServer() {
	ErrorLog.Emit(LogLv_INFO, "Server", "HTTP Server Starting...")
	ServerEngine = gin.New()
	if ConfigData.CommonConfig.IsDebugModeOn {
		gin.SetMode(gin.DebugMode)
	} else {
		gin.SetMode(gin.ReleaseMode)
	}
	if ConfigData.CommonConfig.UseGZip {
		ServerEngine.Use(gzip.Gzip(gzip.DefaultCompression))
	}
	ServerEngine.Use(CustomRecoveryMidware(ErrorLog, ConfigData.CommonConfig.IsDebugModeOn))
	ServerEngine.Use(CustomAccessLogMidware(AccessLog, ErrorLog))
	ErrorLog.Emit(LogLv_INFO, "Server", "Loading URL Router...")
	StaticFileSystem = http.Dir(WWWRootPath)
	FileServer = http.FileServer(StaticFileSystem)
	var err error
	if ConfigData.CommonConfig.IsBackendProxyEnable {
		ReverseProxyRemote, err = url.Parse(BackendTarget)
		if err != nil {
			emsg := fmt.Sprintf("Fatal Error! Backend Proxy URL Error: %s", err.Error())
			ErrorLog.Emit(LogLv_FATAL, "Server", emsg)
			fmt.Println(emsg)
		}
	}
	ServerEngine.Any("/*reqpath", FrontendRouter)
	ErrorLog.Emit(LogLv_INFO, "Server", "Start Listening...")
	err = ServerEngine.Run(ListenAddress)
	if err != nil {
		emsg := fmt.Sprintf("Fatal Error! Server Couldn't Start: %s", err.Error())
		ErrorLog.Emit(LogLv_FATAL, "Server", emsg)
		fmt.Println(emsg)
	}
	ErrorLog.Emit(LogLv_INFO, "Server", "Server Ready.")
}

func FrontendRouter(ctx *gin.Context) {
	rpath := ctx.Param("reqpath")
	if strings.HasPrefix(rpath, "/"+BackendPrefix) {
		APIReverseProxy(ctx)
	} else {
		StaticFilesHandler(rpath, ctx)
	}
}

func NotFoundHandler(ctx *gin.Context) {
	if ConfigData.CommonConfig.RedirectWhen404 {
		ctx.Redirect(302, ConfigData.CommonConfig.RedirectURL)
	} else {
		ctx.Writer.WriteString("404 not found")
		ctx.Status(404)
	}
}

func ForbiddenHandler(ctx *gin.Context) {
	ctx.Writer.WriteString("403 forbidden")
	ctx.Status(403)
}

func StaticFilesHandler(url string, ctx *gin.Context) {
	finf, err := StaticFileSystem.Open(path.Clean(url))
	if os.IsNotExist(err) {
		if ConfigData.CommonConfig.VueHistoryMode {
			VueHistoryModeHandler(ctx)
			return
		} else {
			NotFoundHandler(ctx)
			return
		}
	}
	fst, err := finf.Stat()
	if err != nil {
		if ConfigData.CommonConfig.VueHistoryMode {
			VueHistoryModeHandler(ctx)
			return
		} else {
			NotFoundHandler(ctx)
			return
		}
	}
	if fst.IsDir() {
		_, err := StaticFileSystem.Open(path.Clean(path.Join(url, "index.html")))
		if os.IsNotExist(err) {
			if ConfigData.CommonConfig.VueHistoryMode {
				VueHistoryModeHandler(ctx)
				return
			} else {
				ForbiddenHandler(ctx)
				return
			}
		}
	}
	ctx.Request.URL.Path = url
	FileServer.ServeHTTP(ctx.Writer, ctx.Request)
}

func VueHistoryModeHandler(ctx *gin.Context) {
	http.ServeFile(ctx.Writer, ctx.Request, path.Join(WWWRootPath, "index.html"))
}

func APIReverseProxy(context *gin.Context) {
	if !ConfigData.CommonConfig.IsBackendProxyEnable {
		NotFoundHandler(context)
	}
	if context.IsWebsocket() {
		proxy := wsutil.NewSingleHostReverseProxy(ReverseProxyRemote)
		proxy.ServeHTTP(context.Writer, context.Request)
	} else {
		proxy := httputil.NewSingleHostReverseProxy(ReverseProxyRemote)
		proxy.ServeHTTP(context.Writer, context.Request)
	}
}