server added
This commit is contained in:
@@ -0,0 +1,3 @@
|
||||
*~
|
||||
path.go
|
||||
user.go
|
||||
@@ -0,0 +1,97 @@
|
||||
package config
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"os"
|
||||
"path/filepath"
|
||||
//"errors"
|
||||
"flag"
|
||||
|
||||
"github.com/go-yaml/yaml"
|
||||
)
|
||||
|
||||
const (
|
||||
defaultPort int = 9001
|
||||
)
|
||||
|
||||
type ServiceConfig struct {
|
||||
PortNum int `json:"port" yaml:"port"`
|
||||
WebDir string `json:"webdir" yaml:"webdir"`
|
||||
AccessPath string `json:"accessLog" yaml:"accessLog"`
|
||||
}
|
||||
|
||||
type Config struct {
|
||||
Service ServiceConfig `json:"service" yaml:"service"`
|
||||
LogPath string `json:"logfile" yaml:"logfile"`
|
||||
RunPath string `json:"runfile" yaml:"runfile"`
|
||||
Daemon bool `json:"daemon" yaml:"daemon"`
|
||||
User string `yaml:"user" json:"user"`
|
||||
Group string `yaml:"group" json:"group"`
|
||||
Debug bool `yaml:"debug" json:"debug"`
|
||||
}
|
||||
|
||||
func NewConfig() *Config {
|
||||
conf := &Config{
|
||||
Service: ServiceConfig{
|
||||
PortNum: defaultPort,
|
||||
WebDir: webdir,
|
||||
},
|
||||
LogPath: logPath,
|
||||
RunPath: runPath,
|
||||
User: user,
|
||||
Group: group,
|
||||
}
|
||||
return conf
|
||||
}
|
||||
|
||||
func (conf *Config) ReadFile() error {
|
||||
var err error
|
||||
|
||||
confBytes, err := os.ReadFile(configPath)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
err = yaml.Unmarshal(confBytes, conf)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
return err
|
||||
}
|
||||
|
||||
func (conf *Config) ReadEnv() error {
|
||||
var err error
|
||||
return err
|
||||
}
|
||||
|
||||
func (conf *Config) ReadOpts() error {
|
||||
var err error
|
||||
|
||||
exeName := filepath.Base(os.Args[0])
|
||||
|
||||
flag.IntVar(&conf.Service.PortNum, "port", conf.Service.PortNum, "listen port")
|
||||
flag.BoolVar(&conf.Daemon, "daemon", conf.Daemon, "run as daemon")
|
||||
|
||||
help := func() {
|
||||
fmt.Println("")
|
||||
fmt.Printf("Usage: %s [option]\n", exeName)
|
||||
fmt.Println("")
|
||||
fmt.Println("Options:")
|
||||
flag.PrintDefaults()
|
||||
fmt.Println("")
|
||||
}
|
||||
flag.Usage = help
|
||||
flag.Parse()
|
||||
|
||||
return err
|
||||
}
|
||||
|
||||
func (conf *Config) Yaml() (string, error) {
|
||||
var err error
|
||||
var res string
|
||||
yamlBytes, err := yaml.Marshal(conf)
|
||||
if err != nil {
|
||||
return res, err
|
||||
}
|
||||
res = string(yamlBytes)
|
||||
return res, err
|
||||
}
|
||||
@@ -0,0 +1,9 @@
|
||||
package config
|
||||
|
||||
|
||||
const (
|
||||
webdir = "@srv_sharedir@"
|
||||
configPath = "@srv_confdir@/@srv_name@d.yaml"
|
||||
runPath = "@srv_rundir@/@srv_name@.pid"
|
||||
logPath = "@srv_logdir@/common.log"
|
||||
)
|
||||
@@ -0,0 +1,6 @@
|
||||
package config
|
||||
|
||||
const (
|
||||
user = "@srv_user@"
|
||||
group = "@srv_group@"
|
||||
)
|
||||
@@ -0,0 +1,74 @@
|
||||
package handler
|
||||
|
||||
import (
|
||||
"engine/internal/iotype"
|
||||
"engine/internal/logger"
|
||||
"engine/internal/logic"
|
||||
"engine/pkg/auxtool/auxhttp"
|
||||
|
||||
"github.com/gin-gonic/gin"
|
||||
)
|
||||
|
||||
type HandlerConfig struct {
|
||||
Logic *logic.Logic
|
||||
}
|
||||
|
||||
type Handler struct {
|
||||
log *logger.Logger
|
||||
lg *logic.Logic
|
||||
}
|
||||
|
||||
func NewHandler(conf *HandlerConfig) (*Handler, error) {
|
||||
var err error
|
||||
hand := &Handler{
|
||||
log: logger.NewLogger("handler"),
|
||||
lg: conf.Logic,
|
||||
}
|
||||
return hand, err
|
||||
}
|
||||
|
||||
func (hand *Handler) GetHealth(gctx *gin.Context) {
|
||||
var err error
|
||||
nReq := &iotype.GetHealthRequest{}
|
||||
// Bind request
|
||||
err = gctx.ShouldBind(nReq)
|
||||
if err != nil {
|
||||
hand.log.Errorf("Cannot bind: %v", err)
|
||||
auxhttp.SendError(gctx, err)
|
||||
return
|
||||
}
|
||||
// Call logic
|
||||
ctx := gctx.Request.Context()
|
||||
lgRes, err := hand.lg.GetHealth(ctx, nReq)
|
||||
if err != nil {
|
||||
hand.log.Errorf("Get error: %v", err)
|
||||
auxhttp.SendError(gctx, err)
|
||||
return
|
||||
}
|
||||
// Send result
|
||||
nRes := lgRes
|
||||
auxhttp.SendResult(gctx, nRes)
|
||||
}
|
||||
|
||||
func (hand *Handler) CreateSession(gctx *gin.Context) {
|
||||
var err error
|
||||
nReq := &iotype.CreateSessionRequest{}
|
||||
// Bind request
|
||||
err = gctx.ShouldBind(nReq)
|
||||
if err != nil {
|
||||
hand.log.Errorf("Cannot bind: %v", err)
|
||||
auxhttp.SendError(gctx, err)
|
||||
return
|
||||
}
|
||||
// Call logic
|
||||
ctx := gctx.Request.Context()
|
||||
lgRes, err := hand.lg.CreateSession(ctx, nReq)
|
||||
if err != nil {
|
||||
hand.log.Errorf("Get error: %v", err)
|
||||
auxhttp.SendError(gctx, err)
|
||||
return
|
||||
}
|
||||
// Send result
|
||||
nRes := lgRes
|
||||
auxhttp.SendResult(gctx, nRes)
|
||||
}
|
||||
@@ -0,0 +1,13 @@
|
||||
package iotype
|
||||
|
||||
type GetHealthRequest struct{}
|
||||
type GetHealthResult struct{}
|
||||
|
||||
type CreateSessionRequest struct{
|
||||
Username string `json:"username"`
|
||||
Password string `json:"password"`
|
||||
}
|
||||
type CreateSessionResult struct{
|
||||
Token string `json:"token"`
|
||||
Expire int64 `json:"expire"`
|
||||
}
|
||||
@@ -0,0 +1,60 @@
|
||||
package logger
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"os"
|
||||
"time"
|
||||
|
||||
"github.com/sirupsen/logrus"
|
||||
)
|
||||
|
||||
type LogFormatter struct {
|
||||
}
|
||||
|
||||
func (lf *LogFormatter) Format(entry *logrus.Entry) ([]byte, error) {
|
||||
var err error
|
||||
timeStamp := time.Now().Format(time.RFC3339)
|
||||
levelString := entry.Level.String()
|
||||
labelString := ""
|
||||
for key, value := range entry.Data {
|
||||
labelString += fmt.Sprintf("<%s:%v>", key, value)
|
||||
}
|
||||
if labelString != "" {
|
||||
message := fmt.Sprintf("%s %s %s [%s]\n", timeStamp, levelString, labelString, entry.Message)
|
||||
return []byte(message), err
|
||||
}
|
||||
message := fmt.Sprintf("%s %s [%s]\n", timeStamp, levelString, entry.Message)
|
||||
return []byte(message), err
|
||||
}
|
||||
|
||||
func init() {
|
||||
logrus.SetOutput(os.Stdout)
|
||||
logrus.SetFormatter(&LogFormatter{})
|
||||
logrus.SetLevel(logrus.DebugLevel)
|
||||
}
|
||||
|
||||
type Logger struct {
|
||||
logrus *logrus.Entry
|
||||
}
|
||||
|
||||
func NewLogger(label string) *Logger {
|
||||
return &Logger{
|
||||
logrus: logrus.WithField("object", label),
|
||||
}
|
||||
}
|
||||
|
||||
func (log *Logger) Errorf(format string, args ...any) {
|
||||
log.logrus.Errorf(format, args...)
|
||||
}
|
||||
|
||||
func (log *Logger) Debugf(format string, args ...any) {
|
||||
log.logrus.Debugf(format, args...)
|
||||
}
|
||||
|
||||
func (log *Logger) Warningf(format string, args ...any) {
|
||||
log.logrus.Warningf(format, args...)
|
||||
}
|
||||
|
||||
func (log *Logger) Infof(format string, args ...any) {
|
||||
log.logrus.Infof(format, args...)
|
||||
}
|
||||
@@ -0,0 +1,56 @@
|
||||
package logic
|
||||
|
||||
import (
|
||||
"context"
|
||||
|
||||
"engine/internal/iotype"
|
||||
"engine/internal/logger"
|
||||
"engine/pkg/auxtool/auxjwt"
|
||||
|
||||
)
|
||||
|
||||
type LogicConfig struct {
|
||||
}
|
||||
|
||||
type Logic struct {
|
||||
log *logger.Logger
|
||||
}
|
||||
|
||||
func NewLogic(conf *LogicConfig) (*Logic, error) {
|
||||
var err error
|
||||
srv := &Logic{
|
||||
log: logger.NewLogger("server"),
|
||||
}
|
||||
return srv, err
|
||||
}
|
||||
|
||||
const (
|
||||
tokenIssuer = "ENGINE"
|
||||
tokenSubject = "WEB"
|
||||
sessionID = 0
|
||||
tokenLifetime = 3600
|
||||
tokenSecret = "TW9uIEp1bCAzMSAxODox"
|
||||
)
|
||||
|
||||
func (lg *Logic) CreateSession(ctx context.Context, nReq *iotype.CreateSessionRequest) (*iotype.CreateSessionResult, error) {
|
||||
var err error
|
||||
nRes := &iotype.CreateSessionResult{}
|
||||
|
||||
//expireJWT := time.Now().Add(tokenLifetime)
|
||||
//expireUnix := expireJWT.Unix()
|
||||
|
||||
secret := []byte(tokenSecret)
|
||||
tokenBytes, expireToken, err := auxjwt.MakeJWTToken(tokenIssuer, tokenSubject, sessionID, tokenLifetime, secret)
|
||||
if err != nil {
|
||||
return nRes, err
|
||||
}
|
||||
nRes.Token = string(tokenBytes)
|
||||
nRes.Expire = expireToken
|
||||
return nRes, err
|
||||
}
|
||||
|
||||
func (lg *Logic) GetHealth(ctx context.Context, nReq *iotype.GetHealthRequest) (*iotype.GetHealthResult, error) {
|
||||
var err error
|
||||
nRes := &iotype.GetHealthResult{}
|
||||
return nRes, err
|
||||
}
|
||||
@@ -0,0 +1,266 @@
|
||||
package server
|
||||
|
||||
import (
|
||||
"context"
|
||||
//"syscall"
|
||||
//"os"
|
||||
//"os/signal"
|
||||
|
||||
//"errors"
|
||||
//"flag"
|
||||
//"fmt"
|
||||
"os"
|
||||
"os/signal"
|
||||
"os/user"
|
||||
"path/filepath"
|
||||
"strconv"
|
||||
"syscall"
|
||||
|
||||
"engine/internal/config"
|
||||
"engine/internal/handler"
|
||||
"engine/internal/logger"
|
||||
"engine/internal/logic"
|
||||
"engine/internal/service"
|
||||
)
|
||||
|
||||
type Server struct {
|
||||
conf *config.Config
|
||||
svc *service.Service
|
||||
lg *logic.Logic
|
||||
hand *handler.Handler
|
||||
ctx context.Context
|
||||
canc context.CancelFunc
|
||||
log *logger.Logger
|
||||
}
|
||||
|
||||
func NewServer() (*Server, error) {
|
||||
var err error
|
||||
srv := &Server{
|
||||
log: logger.NewLogger("server"),
|
||||
}
|
||||
srv.ctx, srv.canc = context.WithCancel(context.Background())
|
||||
return srv, err
|
||||
}
|
||||
|
||||
func (srv *Server) Configure() error {
|
||||
var err error
|
||||
srv.log.Infof("Configure server")
|
||||
srv.conf = config.NewConfig()
|
||||
err = srv.conf.ReadFile()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
err = srv.conf.ReadEnv()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
err = srv.conf.ReadOpts()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
yamlConfig, err := srv.conf.Yaml()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
srv.log.Debugf("Server configuration: \n%s\n", yamlConfig)
|
||||
return err
|
||||
}
|
||||
|
||||
func (srv *Server) PseudoFork() error {
|
||||
const successExit int = 0
|
||||
var keyEnv string = "IMX0LTSELMRF8K"
|
||||
var err error
|
||||
|
||||
_, isChild := os.LookupEnv(keyEnv)
|
||||
switch {
|
||||
case !isChild:
|
||||
os.Setenv(keyEnv, "TRUE")
|
||||
|
||||
procAttr := syscall.ProcAttr{}
|
||||
cwd, err := os.Getwd()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
var sysFiles = make([]uintptr, 3)
|
||||
sysFiles[0] = uintptr(syscall.Stdin)
|
||||
sysFiles[1] = uintptr(syscall.Stdout)
|
||||
sysFiles[2] = uintptr(syscall.Stderr)
|
||||
|
||||
procAttr.Files = sysFiles
|
||||
procAttr.Env = os.Environ()
|
||||
procAttr.Dir = cwd
|
||||
|
||||
_, err = syscall.ForkExec(os.Args[0], os.Args, &procAttr)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
os.Exit(successExit)
|
||||
case isChild:
|
||||
_, err = syscall.Setsid()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
os.Unsetenv(keyEnv)
|
||||
return err
|
||||
}
|
||||
|
||||
func (srv *Server) Daemonize() error {
|
||||
var err error
|
||||
if srv.conf.Daemon {
|
||||
srv.log.Debugf("Running server as daemon")
|
||||
// Restart process process
|
||||
err = srv.PseudoFork()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
currUser, err := user.Current()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
currID, err := strconv.Atoi(currUser.Uid)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if currID == 0 {
|
||||
// Change GID
|
||||
sysGroup, err := user.LookupGroup(srv.conf.Group)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
gid, err := strconv.Atoi(sysGroup.Gid)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
err = syscall.Setgid(gid)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
// Change UID
|
||||
sysUser, err := user.Lookup(srv.conf.User)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
uid, err := strconv.Atoi(sysUser.Uid)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
err = syscall.Setuid(uid)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
// Redirect stdin
|
||||
nullFile, err := os.OpenFile("/dev/null", os.O_RDWR, 0)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
err = syscall.Dup2(int(nullFile.Fd()), int(os.Stdin.Fd()))
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
// Redirect stderr and stout
|
||||
logdir := filepath.Dir(srv.conf.LogPath)
|
||||
err = os.MkdirAll(logdir, 0750)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
logFile, err := os.OpenFile(srv.conf.LogPath, os.O_WRONLY|os.O_CREATE|os.O_APPEND, 0640)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
err = syscall.Dup2(int(logFile.Fd()), int(os.Stdout.Fd()))
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
err = syscall.Dup2(int(logFile.Fd()), int(os.Stderr.Fd()))
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
// Write process ID
|
||||
rundir := filepath.Dir(srv.conf.RunPath)
|
||||
err = os.MkdirAll(rundir, 0750)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
pidFile, err := os.OpenFile(srv.conf.RunPath, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0640)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
defer pidFile.Close()
|
||||
currPid := os.Getpid()
|
||||
_, err = pidFile.WriteString(strconv.Itoa(currPid))
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
return err
|
||||
}
|
||||
|
||||
func (srv *Server) Build() error {
|
||||
var err error
|
||||
srv.log.Infof("Build server")
|
||||
|
||||
// Create logic
|
||||
logicConfig := &logic.LogicConfig{}
|
||||
srv.lg, err = logic.NewLogic(logicConfig)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
// Create handler
|
||||
handlerConfig := &handler.HandlerConfig{
|
||||
Logic: srv.lg,
|
||||
}
|
||||
srv.hand, err = handler.NewHandler(handlerConfig)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
// Create service
|
||||
serviceConfig := &service.ServiceConfig{
|
||||
PortNum: srv.conf.Service.PortNum,
|
||||
WebDir: srv.conf.Service.WebDir,
|
||||
Handler: srv.hand,
|
||||
}
|
||||
srv.svc, err = service.NewService(serviceConfig)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
err = srv.svc.Build()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
return err
|
||||
}
|
||||
|
||||
func (srv *Server) Run() error {
|
||||
var err error
|
||||
srv.log.Infof("Running server")
|
||||
|
||||
sigs := make(chan os.Signal, 1)
|
||||
done := make(chan error, 1)
|
||||
|
||||
startService := func(svc *service.Service, done chan error) {
|
||||
err = svc.Run()
|
||||
if err != nil {
|
||||
srv.log.Errorf("Service error: %v", err)
|
||||
done <- err
|
||||
}
|
||||
}
|
||||
go startService(srv.svc, done)
|
||||
|
||||
signal.Notify(sigs, syscall.SIGINT, syscall.SIGTERM, syscall.SIGHUP)
|
||||
var signal os.Signal
|
||||
select {
|
||||
case signal = <-sigs:
|
||||
srv.log.Infof("Services stopped by signal: %v", signal)
|
||||
srv.svc.Stop()
|
||||
case err = <-done:
|
||||
srv.log.Infof("Service stopped by error: %v", err)
|
||||
srv.svc.Stop()
|
||||
}
|
||||
if signal == syscall.SIGHUP {
|
||||
//srv.PseudoFork()
|
||||
}
|
||||
return err
|
||||
}
|
||||
@@ -0,0 +1,31 @@
|
||||
package service
|
||||
|
||||
import (
|
||||
"net/http"
|
||||
"strings"
|
||||
|
||||
"github.com/gin-gonic/gin"
|
||||
)
|
||||
|
||||
func CorsMiddleware() gin.HandlerFunc {
|
||||
|
||||
headers := []string{"Content-Type", "Content-Length", "Accept-Encoding", "X-CSRF-Token", "Authorization"}
|
||||
headerList := strings.Join(headers, ",")
|
||||
|
||||
methods := []string{"POST", "GET", "OPTIONS", "PUT", "DELETE", "UPDATE"}
|
||||
methodList := strings.Join(methods, ",")
|
||||
|
||||
return func(gctx *gin.Context) {
|
||||
gctx.Writer.Header().Set("Access-Control-Allow-Origin", "*")
|
||||
gctx.Writer.Header().Set("Access-Control-Max-Age", "86400")
|
||||
gctx.Writer.Header().Set("Access-Control-Allow-Methods", methodList)
|
||||
gctx.Writer.Header().Set("Access-Control-Allow-Headers", headerList)
|
||||
gctx.Writer.Header().Set("Access-Control-Allow-Credentials", "true")
|
||||
|
||||
if gctx.Request.Method == "OPTIONS" {
|
||||
gctx.AbortWithStatus(http.StatusOK)
|
||||
} else {
|
||||
gctx.Next()
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,59 @@
|
||||
package service
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"fmt"
|
||||
"time"
|
||||
|
||||
"github.com/gin-gonic/gin"
|
||||
"github.com/sirupsen/logrus"
|
||||
)
|
||||
|
||||
func LogMiddleware() gin.HandlerFunc {
|
||||
return func(ctx *gin.Context) {
|
||||
|
||||
start := time.Now()
|
||||
|
||||
ctx.Next()
|
||||
|
||||
var reqSize int64
|
||||
var method string
|
||||
var reqURI string
|
||||
if ctx.Request != nil {
|
||||
reqSize = ctx.Request.ContentLength
|
||||
method = ctx.Request.Method
|
||||
reqURI = ctx.Request.RequestURI
|
||||
}
|
||||
|
||||
duration := time.Since(start).Microseconds()
|
||||
remAddr := ctx.RemoteIP()
|
||||
|
||||
var resCode int
|
||||
var resSize int
|
||||
if ctx.Writer != nil {
|
||||
resCode = ctx.Writer.Status()
|
||||
resSize = ctx.Writer.Size()
|
||||
}
|
||||
|
||||
logString := fmt.Sprintf("%s %s %s in=%d out=%d res=%d %dms",
|
||||
remAddr, method, reqURI, reqSize, resSize, resCode, duration)
|
||||
|
||||
logger := logrus.WithField("object", "accesslog")
|
||||
logger.Infoln(logString)
|
||||
}
|
||||
}
|
||||
|
||||
type LogWriter struct {
|
||||
gin.ResponseWriter
|
||||
body *bytes.Buffer
|
||||
}
|
||||
|
||||
func (lw LogWriter) Write(data []byte) (int, error) {
|
||||
lw.body.Write(data)
|
||||
return lw.ResponseWriter.Write(data)
|
||||
}
|
||||
|
||||
func (lw LogWriter) WriteString(data string) (int, error) {
|
||||
lw.body.WriteString(data)
|
||||
return lw.ResponseWriter.WriteString(data)
|
||||
}
|
||||
@@ -0,0 +1,139 @@
|
||||
package service
|
||||
|
||||
import (
|
||||
"context"
|
||||
"crypto/tls"
|
||||
"fmt"
|
||||
"net/http"
|
||||
"path/filepath"
|
||||
"time"
|
||||
"strings"
|
||||
|
||||
"engine/internal/handler"
|
||||
"engine/internal/logger"
|
||||
"engine/pkg/auxtool/aux509"
|
||||
"engine/pkg/auxtool/auxhttp"
|
||||
|
||||
"github.com/gin-gonic/gin"
|
||||
)
|
||||
|
||||
const (
|
||||
httpTimeout = 360
|
||||
)
|
||||
|
||||
type ServiceConfig struct {
|
||||
Handler *handler.Handler
|
||||
PortNum int
|
||||
WebDir string
|
||||
}
|
||||
|
||||
type Service struct {
|
||||
hand *handler.Handler
|
||||
hsrv *http.Server
|
||||
log *logger.Logger
|
||||
engine *gin.Engine
|
||||
|
||||
portnum int
|
||||
webdir string
|
||||
}
|
||||
|
||||
func NewService(conf *ServiceConfig) (*Service, error) {
|
||||
var err error
|
||||
svc := &Service{
|
||||
hand: conf.Handler,
|
||||
portnum: conf.PortNum,
|
||||
webdir: conf.WebDir,
|
||||
}
|
||||
svc.log = logger.NewLogger("service")
|
||||
return svc, err
|
||||
}
|
||||
|
||||
func (svc *Service) Build() error {
|
||||
var err error
|
||||
svc.log.Debugf("Build service")
|
||||
|
||||
gin.SetMode(gin.ReleaseMode)
|
||||
gin.DisableConsoleColor()
|
||||
|
||||
svc.engine = gin.New()
|
||||
svc.engine.Use(gin.Recovery())
|
||||
svc.engine.Use(CorsMiddleware())
|
||||
svc.engine.Use(LogMiddleware())
|
||||
|
||||
rootPath := filepath.Join(svc.webdir)
|
||||
cssPath := filepath.Join(rootPath, "css")
|
||||
fontsPath := filepath.Join(rootPath, "fonts")
|
||||
jsPath := filepath.Join(rootPath, "js")
|
||||
indexPath := filepath.Join(rootPath, "index.html")
|
||||
|
||||
svc.engine.Use(Serve("/", LocalFile(rootPath, false)))
|
||||
svc.engine.Static("/css", cssPath)
|
||||
svc.engine.Static("/fonts", fontsPath)
|
||||
svc.engine.Static("/js", jsPath)
|
||||
|
||||
apiGroup := svc.engine.Group("api")
|
||||
v1Group := apiGroup.Group("v1")
|
||||
{
|
||||
sessionGroup := v1Group.Group("session")
|
||||
sessionGroup.POST("create", svc.hand.CreateSession)
|
||||
|
||||
healthGroup := v1Group.Group("health")
|
||||
healthGroup.POST("get", svc.hand.GetHealth)
|
||||
|
||||
}
|
||||
svc.engine.StaticFile("/", indexPath)
|
||||
|
||||
noRouteFunc := func(gctx *gin.Context) {
|
||||
contentType := gctx.GetHeader("Content-Type")
|
||||
contentType = strings.ToLower(contentType)
|
||||
if strings.Contains(contentType, "application/json") {
|
||||
err := fmt.Errorf("No route")
|
||||
auxhttp.SendError(gctx, err)
|
||||
|
||||
} else {
|
||||
gctx.Redirect(301, "/")
|
||||
}
|
||||
}
|
||||
svc.engine.NoRoute(noRouteFunc)
|
||||
|
||||
cert, err := aux509.GetTLSCert("WEB", "ENGINE")
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
tlsConfig := tls.Config{
|
||||
Certificates: []tls.Certificate{cert},
|
||||
ClientAuth: tls.NoClientCert,
|
||||
InsecureSkipVerify: true,
|
||||
}
|
||||
listenAddr := fmt.Sprintf(":%d", svc.portnum)
|
||||
svc.hsrv = &http.Server{
|
||||
Addr: listenAddr,
|
||||
Handler: svc.engine,
|
||||
TLSConfig: &tlsConfig,
|
||||
}
|
||||
return err
|
||||
}
|
||||
|
||||
|
||||
|
||||
func (svc *Service) Run() error {
|
||||
var err error
|
||||
for _, route := range svc.engine.Routes() {
|
||||
svc.log.Debugf("The route is registered: %s %s", route.Method, route.Path)
|
||||
}
|
||||
svc.log.Infof("Service listening at %d port", svc.portnum)
|
||||
err = svc.hsrv.ListenAndServeTLS("", "")
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
return err
|
||||
}
|
||||
|
||||
func (svc *Service) Stop() {
|
||||
svc.log.Infof("Stopping service")
|
||||
if svc.hsrv != nil {
|
||||
downWaiting := 5 * time.Second
|
||||
ctx, _ := context.WithTimeout(context.Background(), downWaiting)
|
||||
svc.hsrv.Shutdown(ctx)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,58 @@
|
||||
package service
|
||||
|
||||
import (
|
||||
"net/http"
|
||||
"os"
|
||||
"path"
|
||||
"strings"
|
||||
|
||||
"github.com/gin-gonic/gin"
|
||||
)
|
||||
|
||||
func Serve(urlPrefix string, fs ServeFileSystem) gin.HandlerFunc {
|
||||
fileserver := http.FileServer(fs)
|
||||
if urlPrefix != "" {
|
||||
fileserver = http.StripPrefix(urlPrefix, fileserver)
|
||||
}
|
||||
return func(c *gin.Context) {
|
||||
if fs.Exists(urlPrefix, c.Request.URL.Path) {
|
||||
fileserver.ServeHTTP(c.Writer, c.Request)
|
||||
c.Abort()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
type ServeFileSystem interface {
|
||||
http.FileSystem
|
||||
Exists(prefix string, path string) bool
|
||||
}
|
||||
|
||||
type LocalFileSystem struct {
|
||||
http.FileSystem
|
||||
root string
|
||||
indexes bool
|
||||
}
|
||||
|
||||
func (l *LocalFileSystem) Exists(prefix string, filepath string) bool {
|
||||
p := strings.TrimPrefix(filepath, prefix)
|
||||
if len(p) < len(filepath) {
|
||||
name := path.Join(l.root, p)
|
||||
stats, err := os.Stat(name)
|
||||
if err != nil {
|
||||
return false
|
||||
}
|
||||
if !l.indexes && stats.IsDir() {
|
||||
return false
|
||||
}
|
||||
return true
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
func LocalFile(root string, indexes bool) *LocalFileSystem {
|
||||
return &LocalFileSystem{
|
||||
FileSystem: gin.Dir(root, indexes),
|
||||
root: root,
|
||||
indexes: indexes,
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user