2021-01-06 01:00:49 +08:00
|
|
|
// Copyright GoFrame Author(https://goframe.org). All Rights Reserved.
|
2017-12-29 16:03:30 +08:00
|
|
|
//
|
|
|
|
// This Source Code Form is subject to the terms of the MIT License.
|
|
|
|
// If a copy of the MIT was not distributed with this file,
|
2019-02-02 16:18:25 +08:00
|
|
|
// You can obtain one at https://github.com/gogf/gf.
|
2017-12-29 16:03:30 +08:00
|
|
|
|
2017-11-23 10:21:28 +08:00
|
|
|
package ghttp
|
|
|
|
|
|
|
|
import (
|
2019-06-19 09:06:52 +08:00
|
|
|
"bytes"
|
2021-06-26 16:23:54 +08:00
|
|
|
"context"
|
2021-10-03 00:22:06 +08:00
|
|
|
"fmt"
|
2019-06-22 11:03:50 +08:00
|
|
|
"net/http"
|
|
|
|
"os"
|
|
|
|
"runtime"
|
|
|
|
"strings"
|
|
|
|
"time"
|
|
|
|
|
2022-03-01 11:43:42 +08:00
|
|
|
"github.com/gogf/gf/v2/net/ghttp/internal/swaggerui"
|
2021-11-16 19:43:02 +08:00
|
|
|
"github.com/olekukonko/tablewriter"
|
|
|
|
|
2021-10-11 21:41:56 +08:00
|
|
|
"github.com/gogf/gf/v2/container/garray"
|
|
|
|
"github.com/gogf/gf/v2/container/gtype"
|
2021-11-13 23:23:55 +08:00
|
|
|
"github.com/gogf/gf/v2/debug/gdebug"
|
|
|
|
"github.com/gogf/gf/v2/errors/gcode"
|
|
|
|
"github.com/gogf/gf/v2/errors/gerror"
|
|
|
|
"github.com/gogf/gf/v2/internal/intlog"
|
2021-10-11 21:41:56 +08:00
|
|
|
"github.com/gogf/gf/v2/os/gcache"
|
|
|
|
"github.com/gogf/gf/v2/os/genv"
|
|
|
|
"github.com/gogf/gf/v2/os/gfile"
|
|
|
|
"github.com/gogf/gf/v2/os/glog"
|
|
|
|
"github.com/gogf/gf/v2/os/gproc"
|
2021-11-13 23:23:55 +08:00
|
|
|
"github.com/gogf/gf/v2/os/gsession"
|
2021-10-11 21:41:56 +08:00
|
|
|
"github.com/gogf/gf/v2/os/gtimer"
|
2021-11-13 23:23:55 +08:00
|
|
|
"github.com/gogf/gf/v2/protocol/goai"
|
2021-10-11 21:41:56 +08:00
|
|
|
"github.com/gogf/gf/v2/text/gregex"
|
2021-11-13 23:23:55 +08:00
|
|
|
"github.com/gogf/gf/v2/text/gstr"
|
2021-10-11 21:41:56 +08:00
|
|
|
"github.com/gogf/gf/v2/util/gconv"
|
2017-11-23 10:21:28 +08:00
|
|
|
)
|
|
|
|
|
2019-03-01 23:45:55 +08:00
|
|
|
func init() {
|
2020-01-21 17:18:03 +08:00
|
|
|
// Initialize the methods map.
|
2021-01-19 19:33:21 +08:00
|
|
|
for _, v := range strings.Split(supportedHttpMethods, ",") {
|
2019-06-19 09:06:52 +08:00
|
|
|
methodsMap[v] = struct{}{}
|
|
|
|
}
|
2019-03-01 23:45:55 +08:00
|
|
|
}
|
|
|
|
|
2020-04-29 00:14:29 +08:00
|
|
|
// serverProcessInit initializes some process configurations, which can only be done once.
|
2019-02-20 16:07:11 +08:00
|
|
|
func serverProcessInit() {
|
2022-01-27 16:50:31 +08:00
|
|
|
var ctx = context.TODO()
|
2020-11-08 15:44:04 +08:00
|
|
|
if !serverProcessInitialized.Cas(false, true) {
|
2019-06-19 09:06:52 +08:00
|
|
|
return
|
|
|
|
}
|
2020-04-29 00:14:29 +08:00
|
|
|
// This means it is a restart server, it should kill its parent before starting its listening,
|
|
|
|
// to avoid duplicated port listening in two processes.
|
2021-10-21 18:22:47 +08:00
|
|
|
if !genv.Get(adminActionRestartEnvKey).IsEmpty() {
|
2021-10-03 00:22:06 +08:00
|
|
|
if p, err := os.FindProcess(gproc.PPid()); err == nil {
|
|
|
|
if err = p.Kill(); err != nil {
|
2022-01-28 14:51:49 +08:00
|
|
|
intlog.Errorf(ctx, `%+v`, err)
|
2021-10-03 00:22:06 +08:00
|
|
|
}
|
|
|
|
if _, err = p.Wait(); err != nil {
|
2022-01-28 14:51:49 +08:00
|
|
|
intlog.Errorf(ctx, `%+v`, err)
|
2021-10-03 00:22:06 +08:00
|
|
|
}
|
2019-06-19 09:06:52 +08:00
|
|
|
} else {
|
2021-10-03 00:22:06 +08:00
|
|
|
glog.Error(ctx, err)
|
2019-06-19 09:06:52 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-01-22 01:06:44 +08:00
|
|
|
// Signal handler.
|
|
|
|
go handleProcessSignal()
|
2020-04-29 00:14:29 +08:00
|
|
|
|
|
|
|
// Process message handler.
|
|
|
|
// It's enabled only graceful feature is enabled.
|
2019-06-19 09:06:52 +08:00
|
|
|
if gracefulEnabled {
|
2021-09-27 21:27:24 +08:00
|
|
|
intlog.Printf(ctx, "%d: graceful reload feature is enabled", gproc.Pid())
|
2019-06-19 09:06:52 +08:00
|
|
|
go handleProcessMessage()
|
2020-07-25 13:50:04 +08:00
|
|
|
} else {
|
2021-09-27 21:27:24 +08:00
|
|
|
intlog.Printf(ctx, "%d: graceful reload feature is disabled", gproc.Pid())
|
2019-06-19 09:06:52 +08:00
|
|
|
}
|
|
|
|
|
2020-04-29 00:14:29 +08:00
|
|
|
// It's an ugly calling for better initializing the main package path
|
|
|
|
// in source development environment. It is useful only be used in main goroutine.
|
2021-05-15 18:13:51 +08:00
|
|
|
// It fails retrieving the main package path in asynchronous goroutines.
|
2019-06-19 09:06:52 +08:00
|
|
|
gfile.MainPkgPath()
|
2018-05-10 23:52:09 +08:00
|
|
|
}
|
|
|
|
|
2020-04-29 00:14:29 +08:00
|
|
|
// GetServer creates and returns a server instance using given name and default configurations.
|
2021-10-21 18:22:47 +08:00
|
|
|
// Note that the parameter `name` should be unique for different servers. It returns an existing
|
|
|
|
// server instance if given `name` is already existing in the server mapping.
|
2019-06-19 09:06:52 +08:00
|
|
|
func GetServer(name ...interface{}) *Server {
|
2021-09-19 10:01:09 +08:00
|
|
|
serverName := DefaultServerName
|
2019-07-28 17:37:13 +08:00
|
|
|
if len(name) > 0 && name[0] != "" {
|
2019-09-04 19:23:19 +08:00
|
|
|
serverName = gconv.String(name[0])
|
2019-06-19 09:06:52 +08:00
|
|
|
}
|
2019-09-04 19:23:19 +08:00
|
|
|
if s := serverMapping.Get(serverName); s != nil {
|
2019-06-19 09:06:52 +08:00
|
|
|
return s.(*Server)
|
|
|
|
}
|
|
|
|
s := &Server{
|
2022-01-27 16:50:31 +08:00
|
|
|
instance: serverName,
|
2020-01-21 17:18:03 +08:00
|
|
|
plugins: make([]Plugin, 0),
|
2019-06-19 09:06:52 +08:00
|
|
|
servers: make([]*gracefulServer, 0),
|
2019-11-28 23:19:37 +08:00
|
|
|
closeChan: make(chan struct{}, 10000),
|
2019-06-19 09:06:52 +08:00
|
|
|
serverCount: gtype.NewInt(),
|
2020-11-25 16:37:41 +08:00
|
|
|
statusHandlerMap: make(map[string][]HandlerFunc),
|
2019-06-19 09:06:52 +08:00
|
|
|
serveTree: make(map[string]interface{}),
|
|
|
|
serveCache: gcache.New(),
|
|
|
|
routesMap: make(map[string][]registeredRouteItem),
|
2021-10-02 22:34:39 +08:00
|
|
|
openapi: goai.New(),
|
2019-06-19 09:06:52 +08:00
|
|
|
}
|
2020-04-29 00:14:29 +08:00
|
|
|
// Initialize the server using default configurations.
|
2020-11-25 16:37:41 +08:00
|
|
|
if err := s.SetConfig(NewConfig()); err != nil {
|
2021-08-24 21:18:59 +08:00
|
|
|
panic(gerror.WrapCode(gcode.CodeInvalidConfiguration, err, ""))
|
2019-11-07 11:32:25 +08:00
|
|
|
}
|
2020-04-29 00:14:29 +08:00
|
|
|
// Record the server to internal server mapping by name.
|
2019-09-04 19:23:19 +08:00
|
|
|
serverMapping.Set(serverName, s)
|
2021-12-16 23:09:37 +08:00
|
|
|
// It enables OpenTelemetry for server in default.
|
|
|
|
s.Use(internalMiddlewareServerTracing)
|
2019-06-19 09:06:52 +08:00
|
|
|
return s
|
2017-12-07 14:57:16 +08:00
|
|
|
}
|
|
|
|
|
2020-04-29 00:14:29 +08:00
|
|
|
// Start starts listening on configured port.
|
|
|
|
// This function does not block the process, you can use function Wait blocking the process.
|
2018-05-13 14:04:37 +08:00
|
|
|
func (s *Server) Start() error {
|
2022-01-27 16:50:31 +08:00
|
|
|
var ctx = context.TODO()
|
2021-09-27 21:27:24 +08:00
|
|
|
|
2021-10-03 00:22:06 +08:00
|
|
|
// Swagger UI.
|
|
|
|
if s.config.SwaggerPath != "" {
|
2021-10-13 22:28:49 +08:00
|
|
|
swaggerui.Init()
|
2021-10-03 00:22:06 +08:00
|
|
|
s.AddStaticPath(s.config.SwaggerPath, swaggerUIPackedPath)
|
|
|
|
s.BindHookHandler(s.config.SwaggerPath+"/*", HookBeforeServe, s.swaggerUI)
|
|
|
|
s.Logger().Debugf(
|
|
|
|
ctx,
|
|
|
|
`swagger ui is serving at address: %s%s/`,
|
|
|
|
s.getListenAddress(),
|
|
|
|
s.config.SwaggerPath,
|
|
|
|
)
|
|
|
|
}
|
|
|
|
|
2021-10-02 22:34:39 +08:00
|
|
|
// OpenApi specification json producing handler.
|
|
|
|
if s.config.OpenApiPath != "" {
|
2021-10-03 00:22:06 +08:00
|
|
|
s.BindHandler(s.config.OpenApiPath, s.openapiSpec)
|
2022-02-17 17:15:09 +08:00
|
|
|
s.Logger().Infof(
|
2021-10-03 00:22:06 +08:00
|
|
|
ctx,
|
|
|
|
`openapi specification is serving at address: %s%s`,
|
|
|
|
s.getListenAddress(),
|
|
|
|
s.config.OpenApiPath,
|
|
|
|
)
|
|
|
|
} else {
|
|
|
|
if s.config.SwaggerPath != "" {
|
2022-02-17 17:15:09 +08:00
|
|
|
s.Logger().Warning(
|
2021-10-03 00:22:06 +08:00
|
|
|
ctx,
|
|
|
|
`openapi specification is disabled but swagger ui is serving, which might make no sense`,
|
|
|
|
)
|
|
|
|
} else {
|
2022-02-17 17:15:09 +08:00
|
|
|
s.Logger().Info(
|
2021-10-03 00:22:06 +08:00
|
|
|
ctx,
|
|
|
|
`openapi specification is disabled`,
|
|
|
|
)
|
|
|
|
}
|
2021-10-02 22:34:39 +08:00
|
|
|
}
|
2019-12-04 13:55:08 +08:00
|
|
|
// Register group routes.
|
2021-09-27 21:27:24 +08:00
|
|
|
s.handlePreBindItems(ctx)
|
2019-08-06 20:40:04 +08:00
|
|
|
|
2019-12-04 13:55:08 +08:00
|
|
|
// Server process initialization, which can only be initialized once.
|
2019-06-19 09:06:52 +08:00
|
|
|
serverProcessInit()
|
|
|
|
|
2019-12-04 13:55:08 +08:00
|
|
|
// Server can only be run once.
|
2020-12-14 13:26:48 +08:00
|
|
|
if s.Status() == ServerStatusRunning {
|
2021-08-24 21:18:59 +08:00
|
|
|
return gerror.NewCode(gcode.CodeInvalidOperation, "server is already running")
|
2019-06-19 09:06:52 +08:00
|
|
|
}
|
|
|
|
|
2019-12-04 13:55:08 +08:00
|
|
|
// Logging path setting check.
|
2021-01-06 01:00:49 +08:00
|
|
|
if s.config.LogPath != "" && s.config.LogPath != s.config.Logger.GetPath() {
|
2019-11-08 19:52:49 +08:00
|
|
|
if err := s.config.Logger.SetPath(s.config.LogPath); err != nil {
|
2021-01-06 01:00:49 +08:00
|
|
|
return err
|
2019-11-08 19:52:49 +08:00
|
|
|
}
|
2019-06-19 09:06:52 +08:00
|
|
|
}
|
2019-10-29 16:45:42 +08:00
|
|
|
// Default session storage.
|
|
|
|
if s.config.SessionStorage == nil {
|
2019-11-07 20:42:13 +08:00
|
|
|
path := ""
|
|
|
|
if s.config.SessionPath != "" {
|
2022-01-27 16:50:31 +08:00
|
|
|
path = gfile.Join(s.config.SessionPath, s.config.Name)
|
2019-11-07 20:42:13 +08:00
|
|
|
if !gfile.Exists(path) {
|
|
|
|
if err := gfile.Mkdir(path); err != nil {
|
2021-12-21 22:59:14 +08:00
|
|
|
return gerror.Wrapf(err, `mkdir failed for "%s"`, path)
|
2019-11-07 20:42:13 +08:00
|
|
|
}
|
2019-11-07 20:36:33 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
s.config.SessionStorage = gsession.NewStorageFile(path)
|
2019-10-29 16:45:42 +08:00
|
|
|
}
|
|
|
|
// Initialize session manager when start running.
|
2019-11-07 20:36:33 +08:00
|
|
|
s.sessionManager = gsession.New(
|
|
|
|
s.config.SessionMaxAge,
|
|
|
|
s.config.SessionStorage,
|
|
|
|
)
|
2019-10-29 16:45:42 +08:00
|
|
|
|
2019-11-07 16:40:34 +08:00
|
|
|
// PProf feature.
|
|
|
|
if s.config.PProfEnabled {
|
|
|
|
s.EnablePProf(s.config.PProfPattern)
|
|
|
|
}
|
|
|
|
|
|
|
|
// Default HTTP handler.
|
2019-06-19 09:06:52 +08:00
|
|
|
if s.config.Handler == nil {
|
2022-02-22 14:12:09 +08:00
|
|
|
s.config.Handler = s.ServeHTTP
|
2019-06-19 09:06:52 +08:00
|
|
|
}
|
|
|
|
|
2020-01-21 17:18:03 +08:00
|
|
|
// Install external plugins.
|
|
|
|
for _, p := range s.plugins {
|
|
|
|
if err := p.Install(s); err != nil {
|
2021-10-06 12:12:59 +08:00
|
|
|
s.Logger().Fatalf(ctx, `%+v`, err)
|
2020-01-21 17:18:03 +08:00
|
|
|
}
|
|
|
|
}
|
2020-01-21 22:18:49 +08:00
|
|
|
// Check the group routes again.
|
2021-09-27 21:27:24 +08:00
|
|
|
s.handlePreBindItems(ctx)
|
2020-01-21 17:18:03 +08:00
|
|
|
|
2020-09-17 23:27:10 +08:00
|
|
|
// If there's no route registered and no static service enabled,
|
|
|
|
// it then returns an error of invalid usage of server.
|
|
|
|
if len(s.routesMap) == 0 && !s.config.FileServerEnabled {
|
2021-07-20 23:02:02 +08:00
|
|
|
return gerror.NewCode(
|
2021-08-24 21:18:59 +08:00
|
|
|
gcode.CodeInvalidOperation,
|
2021-07-20 23:02:02 +08:00
|
|
|
`there's no route set or static feature enabled, did you forget import the router?`,
|
|
|
|
)
|
2020-09-17 23:27:10 +08:00
|
|
|
}
|
|
|
|
|
2019-11-07 16:40:34 +08:00
|
|
|
// Start the HTTP server.
|
2019-06-19 09:06:52 +08:00
|
|
|
reloaded := false
|
2021-10-21 18:22:47 +08:00
|
|
|
fdMapStr := genv.Get(adminActionReloadEnvKey).String()
|
2019-06-19 09:06:52 +08:00
|
|
|
if len(fdMapStr) > 0 {
|
|
|
|
sfm := bufferToServerFdMap([]byte(fdMapStr))
|
2022-01-27 16:50:31 +08:00
|
|
|
if v, ok := sfm[s.config.Name]; ok {
|
2019-06-19 09:06:52 +08:00
|
|
|
s.startServer(v)
|
|
|
|
reloaded = true
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if !reloaded {
|
|
|
|
s.startServer(nil)
|
|
|
|
}
|
|
|
|
|
2019-12-04 13:55:08 +08:00
|
|
|
// If this is a child process, it then notifies its parent exit.
|
2019-06-19 09:06:52 +08:00
|
|
|
if gproc.IsChild() {
|
2021-10-30 15:36:10 +08:00
|
|
|
gtimer.SetTimeout(ctx, time.Duration(s.config.GracefulTimeout)*time.Second, func(ctx context.Context) {
|
2020-12-15 20:16:17 +08:00
|
|
|
if err := gproc.Send(gproc.PPid(), []byte("exit"), adminGProcCommGroup); err != nil {
|
2022-01-28 14:51:49 +08:00
|
|
|
intlog.Errorf(ctx, `server error in process communication: %+v`, err)
|
2019-06-19 09:06:52 +08:00
|
|
|
}
|
|
|
|
})
|
|
|
|
}
|
2021-10-02 22:34:39 +08:00
|
|
|
s.initOpenApi()
|
2022-01-27 16:50:31 +08:00
|
|
|
s.doServiceRegister()
|
2019-12-10 12:28:55 +08:00
|
|
|
s.dumpRouterMap()
|
2019-06-19 09:06:52 +08:00
|
|
|
return nil
|
2018-05-13 14:04:37 +08:00
|
|
|
}
|
2018-04-27 22:12:11 +08:00
|
|
|
|
2021-10-03 00:22:06 +08:00
|
|
|
func (s *Server) getListenAddress() string {
|
|
|
|
var (
|
|
|
|
array = gstr.SplitAndTrim(s.config.Address, ":")
|
|
|
|
host = `127.0.0.1`
|
|
|
|
port = 0
|
|
|
|
)
|
|
|
|
if len(array) > 1 {
|
|
|
|
host = array[0]
|
|
|
|
port = gconv.Int(array[1])
|
|
|
|
} else {
|
|
|
|
port = gconv.Int(array[0])
|
|
|
|
}
|
|
|
|
return fmt.Sprintf(`http://%s:%d`, host, port)
|
|
|
|
}
|
|
|
|
|
2019-12-04 13:55:08 +08:00
|
|
|
// DumpRouterMap dumps the router map to the log.
|
2019-12-10 12:28:55 +08:00
|
|
|
func (s *Server) dumpRouterMap() {
|
2021-09-27 21:27:24 +08:00
|
|
|
var (
|
2021-12-18 12:36:34 +08:00
|
|
|
ctx = context.TODO()
|
2021-12-18 18:25:04 +08:00
|
|
|
routes = s.GetRoutes()
|
2021-12-18 12:36:34 +08:00
|
|
|
headers = []string{"SERVER", "DOMAIN", "ADDRESS", "METHOD", "ROUTE", "HANDLER", "MIDDLEWARE"}
|
|
|
|
isJustDefaultServerAndDomain = true
|
2021-09-27 21:27:24 +08:00
|
|
|
)
|
2021-12-18 18:25:04 +08:00
|
|
|
for _, item := range routes {
|
2021-12-18 12:36:34 +08:00
|
|
|
if item.Server != DefaultServerName || item.Domain != DefaultDomainName {
|
|
|
|
isJustDefaultServerAndDomain = false
|
|
|
|
break
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if isJustDefaultServerAndDomain {
|
|
|
|
headers = []string{"ADDRESS", "METHOD", "ROUTE", "HANDLER", "MIDDLEWARE"}
|
|
|
|
}
|
2021-12-18 18:25:04 +08:00
|
|
|
if s.config.DumpRouterMap && len(routes) > 0 {
|
2019-12-04 13:55:08 +08:00
|
|
|
buffer := bytes.NewBuffer(nil)
|
|
|
|
table := tablewriter.NewWriter(buffer)
|
2021-12-18 12:36:34 +08:00
|
|
|
table.SetHeader(headers)
|
2019-12-04 13:55:08 +08:00
|
|
|
table.SetRowLine(true)
|
|
|
|
table.SetBorder(false)
|
|
|
|
table.SetCenterSeparator("|")
|
2018-10-17 16:56:50 +08:00
|
|
|
|
2021-12-18 18:25:04 +08:00
|
|
|
for _, item := range routes {
|
2021-12-18 12:54:09 +08:00
|
|
|
var (
|
|
|
|
data = make([]string, 0)
|
|
|
|
handlerName = gstr.TrimRightStr(item.Handler.Name, "-fm")
|
|
|
|
middlewares = gstr.SplitAndTrim(item.Middleware, ",")
|
|
|
|
)
|
|
|
|
for k, v := range middlewares {
|
|
|
|
middlewares[k] = gstr.TrimRightStr(v, "-fm")
|
|
|
|
}
|
|
|
|
item.Middleware = gstr.Join(middlewares, "\n")
|
2021-12-18 12:36:34 +08:00
|
|
|
if isJustDefaultServerAndDomain {
|
|
|
|
data = append(
|
|
|
|
data,
|
|
|
|
item.Address,
|
|
|
|
item.Method,
|
|
|
|
item.Route,
|
2021-12-18 12:54:09 +08:00
|
|
|
handlerName,
|
2021-12-18 12:36:34 +08:00
|
|
|
item.Middleware,
|
|
|
|
)
|
|
|
|
} else {
|
|
|
|
data = append(
|
|
|
|
data,
|
|
|
|
item.Server,
|
|
|
|
item.Domain,
|
|
|
|
item.Address,
|
|
|
|
item.Method,
|
|
|
|
item.Route,
|
2021-12-18 12:54:09 +08:00
|
|
|
handlerName,
|
2021-12-18 12:36:34 +08:00
|
|
|
item.Middleware,
|
|
|
|
)
|
|
|
|
}
|
2019-12-10 12:28:55 +08:00
|
|
|
table.Append(data)
|
2019-12-04 13:55:08 +08:00
|
|
|
}
|
|
|
|
table.Render()
|
2021-09-27 21:27:24 +08:00
|
|
|
s.config.Logger.Header(false).Printf(ctx, "\n%s", buffer.String())
|
2019-06-19 09:06:52 +08:00
|
|
|
}
|
2019-12-04 13:55:08 +08:00
|
|
|
}
|
2019-06-19 09:06:52 +08:00
|
|
|
|
2021-10-02 22:34:39 +08:00
|
|
|
// GetOpenApi returns the OpenApi specification management object of current server.
|
|
|
|
func (s *Server) GetOpenApi() *goai.OpenApiV3 {
|
|
|
|
return s.openapi
|
|
|
|
}
|
|
|
|
|
|
|
|
// GetRoutes retrieves and returns the router array.
|
|
|
|
func (s *Server) GetRoutes() []RouterItem {
|
2021-12-18 18:25:04 +08:00
|
|
|
var (
|
|
|
|
m = make(map[string]*garray.SortedArray)
|
|
|
|
address = s.config.Address
|
|
|
|
)
|
2019-12-09 21:53:44 +08:00
|
|
|
if s.config.HTTPSAddr != "" {
|
|
|
|
if len(address) > 0 {
|
|
|
|
address += ","
|
|
|
|
}
|
|
|
|
address += "tls" + s.config.HTTPSAddr
|
|
|
|
}
|
2019-06-19 09:06:52 +08:00
|
|
|
for k, registeredItems := range s.routesMap {
|
|
|
|
array, _ := gregex.MatchString(`(.*?)%([A-Z]+):(.+)@(.+)`, k)
|
|
|
|
for index, registeredItem := range registeredItems {
|
2019-12-04 13:55:08 +08:00
|
|
|
item := RouterItem{
|
2022-01-27 16:50:31 +08:00
|
|
|
Server: s.config.Name,
|
2019-12-09 21:53:44 +08:00
|
|
|
Address: address,
|
|
|
|
Domain: array[4],
|
2021-07-19 20:06:44 +08:00
|
|
|
Type: registeredItem.Handler.Type,
|
2019-12-04 13:55:08 +08:00
|
|
|
Middleware: array[1],
|
|
|
|
Method: array[2],
|
|
|
|
Route: array[3],
|
|
|
|
Priority: len(registeredItems) - index - 1,
|
2021-10-02 22:34:39 +08:00
|
|
|
Handler: registeredItem.Handler,
|
2019-08-03 23:57:20 +08:00
|
|
|
}
|
2021-10-02 22:34:39 +08:00
|
|
|
switch item.Handler.Type {
|
2021-10-06 14:22:58 +08:00
|
|
|
case HandlerTypeObject, HandlerTypeHandler:
|
2019-12-09 23:19:39 +08:00
|
|
|
item.IsServiceHandler = true
|
2021-10-02 22:34:39 +08:00
|
|
|
|
2021-10-06 14:22:58 +08:00
|
|
|
case HandlerTypeMiddleware:
|
2019-12-04 13:55:08 +08:00
|
|
|
item.Middleware = "GLOBAL MIDDLEWARE"
|
2019-12-04 10:03:03 +08:00
|
|
|
}
|
2021-10-02 22:34:39 +08:00
|
|
|
if len(item.Handler.Middleware) > 0 {
|
|
|
|
for _, v := range item.Handler.Middleware {
|
2019-12-04 13:55:08 +08:00
|
|
|
if item.Middleware != "" {
|
2021-05-02 08:10:35 +08:00
|
|
|
item.Middleware += ","
|
2019-12-04 10:03:03 +08:00
|
|
|
}
|
2019-12-04 13:55:08 +08:00
|
|
|
item.Middleware += gdebug.FuncName(v)
|
2019-12-04 10:03:03 +08:00
|
|
|
}
|
2019-06-19 09:06:52 +08:00
|
|
|
}
|
2021-05-01 09:04:16 +08:00
|
|
|
// If the domain does not exist in the dump map, it creates the map.
|
2019-12-04 10:03:03 +08:00
|
|
|
// The value of the map is a custom sorted array.
|
2019-12-04 13:55:08 +08:00
|
|
|
if _, ok := m[item.Domain]; !ok {
|
2019-12-04 10:03:03 +08:00
|
|
|
// Sort in ASC order.
|
2019-12-10 12:28:55 +08:00
|
|
|
m[item.Domain] = garray.NewSortedArray(func(v1, v2 interface{}) int {
|
2019-12-04 13:55:08 +08:00
|
|
|
item1 := v1.(RouterItem)
|
|
|
|
item2 := v2.(RouterItem)
|
2019-06-19 09:06:52 +08:00
|
|
|
r := 0
|
2019-12-04 13:55:08 +08:00
|
|
|
if r = strings.Compare(item1.Domain, item2.Domain); r == 0 {
|
|
|
|
if r = strings.Compare(item1.Route, item2.Route); r == 0 {
|
|
|
|
if r = strings.Compare(item1.Method, item2.Method); r == 0 {
|
2021-10-06 14:22:58 +08:00
|
|
|
if item1.Handler.Type == HandlerTypeMiddleware && item2.Handler.Type != HandlerTypeMiddleware {
|
2019-08-03 23:57:20 +08:00
|
|
|
return -1
|
2021-10-06 14:22:58 +08:00
|
|
|
} else if item1.Handler.Type == HandlerTypeMiddleware && item2.Handler.Type == HandlerTypeMiddleware {
|
2019-08-03 23:57:20 +08:00
|
|
|
return 1
|
2019-12-04 13:55:08 +08:00
|
|
|
} else if r = strings.Compare(item1.Middleware, item2.Middleware); r == 0 {
|
|
|
|
r = item2.Priority - item1.Priority
|
2019-06-19 09:06:52 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return r
|
2019-07-23 23:20:27 +08:00
|
|
|
})
|
2019-06-19 09:06:52 +08:00
|
|
|
}
|
2019-12-04 13:55:08 +08:00
|
|
|
m[item.Domain].Add(item)
|
2019-06-19 09:06:52 +08:00
|
|
|
}
|
|
|
|
}
|
2021-12-18 18:25:04 +08:00
|
|
|
|
2019-12-10 12:28:55 +08:00
|
|
|
routerArray := make([]RouterItem, 0, 128)
|
|
|
|
for _, array := range m {
|
|
|
|
for _, v := range array.Slice() {
|
|
|
|
routerArray = append(routerArray, v.(RouterItem))
|
2019-06-19 09:06:52 +08:00
|
|
|
}
|
|
|
|
}
|
2019-12-10 12:28:55 +08:00
|
|
|
return routerArray
|
2018-10-17 10:09:42 +08:00
|
|
|
}
|
|
|
|
|
2019-12-04 13:55:08 +08:00
|
|
|
// Run starts server listening in blocking way.
|
2020-03-04 17:29:23 +08:00
|
|
|
// It's commonly used for single server situation.
|
2019-06-22 11:03:50 +08:00
|
|
|
func (s *Server) Run() {
|
2022-01-27 16:50:31 +08:00
|
|
|
var ctx = context.TODO()
|
|
|
|
|
2019-06-19 09:06:52 +08:00
|
|
|
if err := s.Start(); err != nil {
|
2021-10-06 12:12:59 +08:00
|
|
|
s.Logger().Fatalf(ctx, `%+v`, err)
|
2019-06-19 09:06:52 +08:00
|
|
|
}
|
2019-12-04 13:55:08 +08:00
|
|
|
// Blocking using channel.
|
2019-06-19 09:06:52 +08:00
|
|
|
<-s.closeChan
|
2020-03-04 17:29:23 +08:00
|
|
|
// Remove plugins.
|
|
|
|
if len(s.plugins) > 0 {
|
|
|
|
for _, p := range s.plugins {
|
2021-10-06 14:22:58 +08:00
|
|
|
intlog.Printf(ctx, `remove plugin: %s`, p.Name())
|
2021-01-22 00:36:28 +08:00
|
|
|
if err := p.Remove(); err != nil {
|
2021-10-06 14:22:58 +08:00
|
|
|
intlog.Errorf(ctx, "%+v", err)
|
2021-01-22 00:36:28 +08:00
|
|
|
}
|
2020-03-04 17:29:23 +08:00
|
|
|
}
|
|
|
|
}
|
2022-01-27 16:50:31 +08:00
|
|
|
s.doServiceDeregister()
|
2022-01-28 16:00:16 +08:00
|
|
|
s.Logger().Infof(ctx, "pid[%d]: all servers shutdown", gproc.Pid())
|
2018-05-10 19:16:41 +08:00
|
|
|
}
|
2018-05-10 17:48:47 +08:00
|
|
|
|
2019-12-04 13:55:08 +08:00
|
|
|
// Wait blocks to wait for all servers done.
|
2022-01-27 16:50:31 +08:00
|
|
|
// It's commonly used in multiple server situation.
|
2018-05-13 14:04:37 +08:00
|
|
|
func Wait() {
|
2022-01-27 16:50:31 +08:00
|
|
|
var ctx = context.TODO()
|
|
|
|
|
2019-06-19 09:06:52 +08:00
|
|
|
<-allDoneChan
|
2020-03-04 17:29:23 +08:00
|
|
|
// Remove plugins.
|
|
|
|
serverMapping.Iterator(func(k string, v interface{}) bool {
|
|
|
|
s := v.(*Server)
|
|
|
|
if len(s.plugins) > 0 {
|
|
|
|
for _, p := range s.plugins {
|
2021-09-27 21:27:24 +08:00
|
|
|
intlog.Printf(ctx, `remove plugin: %s`, p.Name())
|
|
|
|
if err := p.Remove(); err != nil {
|
2022-01-28 14:51:49 +08:00
|
|
|
intlog.Errorf(ctx, `%+v`, err)
|
2021-09-27 21:27:24 +08:00
|
|
|
}
|
2020-03-04 17:29:23 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
return true
|
|
|
|
})
|
2022-01-28 16:00:16 +08:00
|
|
|
glog.Infof(ctx, "pid[%d]: all servers shutdown", gproc.Pid())
|
2018-05-13 14:04:37 +08:00
|
|
|
}
|
|
|
|
|
2020-04-29 00:14:29 +08:00
|
|
|
// startServer starts the underlying server listening.
|
2018-05-10 23:52:09 +08:00
|
|
|
func (s *Server) startServer(fdMap listenerFdMap) {
|
2021-09-27 21:27:24 +08:00
|
|
|
var (
|
|
|
|
ctx = context.TODO()
|
|
|
|
httpsEnabled bool
|
|
|
|
)
|
2020-04-29 00:14:29 +08:00
|
|
|
// HTTPS
|
2019-11-07 16:40:34 +08:00
|
|
|
if s.config.TLSConfig != nil || (s.config.HTTPSCertPath != "" && s.config.HTTPSKeyPath != "") {
|
2019-06-19 09:06:52 +08:00
|
|
|
if len(s.config.HTTPSAddr) == 0 {
|
2019-11-07 11:32:25 +08:00
|
|
|
if len(s.config.Address) > 0 {
|
|
|
|
s.config.HTTPSAddr = s.config.Address
|
|
|
|
s.config.Address = ""
|
2019-06-19 09:06:52 +08:00
|
|
|
} else {
|
2021-01-12 00:42:33 +08:00
|
|
|
s.config.HTTPSAddr = defaultHttpsAddr
|
2019-06-19 09:06:52 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
httpsEnabled = len(s.config.HTTPSAddr) > 0
|
|
|
|
var array []string
|
|
|
|
if v, ok := fdMap["https"]; ok && len(v) > 0 {
|
|
|
|
array = strings.Split(v, ",")
|
|
|
|
} else {
|
|
|
|
array = strings.Split(s.config.HTTPSAddr, ",")
|
|
|
|
}
|
|
|
|
for _, v := range array {
|
|
|
|
if len(v) == 0 {
|
|
|
|
continue
|
|
|
|
}
|
2022-01-13 20:57:13 +08:00
|
|
|
var (
|
|
|
|
fd = 0
|
|
|
|
itemFunc = v
|
|
|
|
addrAndFd = strings.Split(v, "#")
|
|
|
|
)
|
|
|
|
if len(addrAndFd) > 1 {
|
|
|
|
itemFunc = addrAndFd[0]
|
2021-09-27 21:27:24 +08:00
|
|
|
// The Windows OS does not support socket file descriptor passing
|
2020-04-29 00:14:29 +08:00
|
|
|
// from parent process.
|
2019-06-19 09:06:52 +08:00
|
|
|
if runtime.GOOS != "windows" {
|
2022-01-13 20:57:13 +08:00
|
|
|
fd = gconv.Int(addrAndFd[1])
|
2019-06-19 09:06:52 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
if fd > 0 {
|
2019-08-03 15:54:12 +08:00
|
|
|
s.servers = append(s.servers, s.newGracefulServer(itemFunc, fd))
|
2019-06-19 09:06:52 +08:00
|
|
|
} else {
|
2019-08-03 15:54:12 +08:00
|
|
|
s.servers = append(s.servers, s.newGracefulServer(itemFunc))
|
2019-06-19 09:06:52 +08:00
|
|
|
}
|
|
|
|
s.servers[len(s.servers)-1].isHttps = true
|
|
|
|
}
|
|
|
|
}
|
|
|
|
// HTTP
|
2019-11-07 11:32:25 +08:00
|
|
|
if !httpsEnabled && len(s.config.Address) == 0 {
|
2021-01-12 00:42:33 +08:00
|
|
|
s.config.Address = defaultHttpAddr
|
2019-06-19 09:06:52 +08:00
|
|
|
}
|
|
|
|
var array []string
|
|
|
|
if v, ok := fdMap["http"]; ok && len(v) > 0 {
|
|
|
|
array = strings.Split(v, ",")
|
|
|
|
} else {
|
2019-11-07 11:32:25 +08:00
|
|
|
array = strings.Split(s.config.Address, ",")
|
2019-06-19 09:06:52 +08:00
|
|
|
}
|
|
|
|
for _, v := range array {
|
|
|
|
if len(v) == 0 {
|
|
|
|
continue
|
|
|
|
}
|
2022-01-13 20:57:13 +08:00
|
|
|
var (
|
|
|
|
fd = 0
|
|
|
|
itemFunc = v
|
|
|
|
addrAndFd = strings.Split(v, "#")
|
|
|
|
)
|
|
|
|
if len(addrAndFd) > 1 {
|
|
|
|
itemFunc = addrAndFd[0]
|
2021-09-27 21:27:24 +08:00
|
|
|
// The Windows OS does not support socket file descriptor passing
|
2020-04-29 00:14:29 +08:00
|
|
|
// from parent process.
|
2019-06-19 09:06:52 +08:00
|
|
|
if runtime.GOOS != "windows" {
|
2022-01-13 20:57:13 +08:00
|
|
|
fd = gconv.Int(addrAndFd[1])
|
2019-06-19 09:06:52 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
if fd > 0 {
|
2019-08-03 15:54:12 +08:00
|
|
|
s.servers = append(s.servers, s.newGracefulServer(itemFunc, fd))
|
2019-06-19 09:06:52 +08:00
|
|
|
} else {
|
2019-08-03 15:54:12 +08:00
|
|
|
s.servers = append(s.servers, s.newGracefulServer(itemFunc))
|
2019-06-19 09:06:52 +08:00
|
|
|
}
|
|
|
|
}
|
2021-05-15 18:13:51 +08:00
|
|
|
// Start listening asynchronously.
|
2019-06-19 09:06:52 +08:00
|
|
|
serverRunning.Add(1)
|
|
|
|
for _, v := range s.servers {
|
|
|
|
go func(server *gracefulServer) {
|
|
|
|
s.serverCount.Add(1)
|
2022-01-13 20:57:13 +08:00
|
|
|
var err error
|
2019-06-19 09:06:52 +08:00
|
|
|
if server.isHttps {
|
2019-11-07 16:40:34 +08:00
|
|
|
err = server.ListenAndServeTLS(s.config.HTTPSCertPath, s.config.HTTPSKeyPath, s.config.TLSConfig)
|
2019-06-19 09:06:52 +08:00
|
|
|
} else {
|
|
|
|
err = server.ListenAndServe()
|
|
|
|
}
|
2020-04-29 00:14:29 +08:00
|
|
|
// The process exits if the server is closed with none closing error.
|
2019-06-19 09:06:52 +08:00
|
|
|
if err != nil && !strings.EqualFold(http.ErrServerClosed.Error(), err.Error()) {
|
2021-10-06 12:12:59 +08:00
|
|
|
s.Logger().Fatalf(ctx, `%+v`, err)
|
2019-06-19 09:06:52 +08:00
|
|
|
}
|
2022-01-13 20:57:13 +08:00
|
|
|
// If all the underlying servers' shutdown, the process exits.
|
2019-06-19 09:06:52 +08:00
|
|
|
if s.serverCount.Add(-1) < 1 {
|
|
|
|
s.closeChan <- struct{}{}
|
|
|
|
if serverRunning.Add(-1) < 1 {
|
2022-01-27 16:50:31 +08:00
|
|
|
serverMapping.Remove(s.instance)
|
2019-06-19 09:06:52 +08:00
|
|
|
allDoneChan <- struct{}{}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}(v)
|
|
|
|
}
|
2018-08-01 13:04:15 +08:00
|
|
|
}
|
2018-04-23 19:22:59 +08:00
|
|
|
|
2020-04-29 00:14:29 +08:00
|
|
|
// Status retrieves and returns the server status.
|
2018-08-01 13:04:15 +08:00
|
|
|
func (s *Server) Status() int {
|
2019-06-19 09:06:52 +08:00
|
|
|
if serverRunning.Val() == 0 {
|
2020-12-14 13:26:48 +08:00
|
|
|
return ServerStatusStopped
|
2019-06-19 09:06:52 +08:00
|
|
|
}
|
2020-04-29 00:14:29 +08:00
|
|
|
// If any underlying server is running, the server status is running.
|
2019-06-19 09:06:52 +08:00
|
|
|
for _, v := range s.servers {
|
2020-12-14 13:26:48 +08:00
|
|
|
if v.status == ServerStatusRunning {
|
|
|
|
return ServerStatusRunning
|
2019-06-19 09:06:52 +08:00
|
|
|
}
|
|
|
|
}
|
2020-12-14 13:26:48 +08:00
|
|
|
return ServerStatusStopped
|
2018-05-08 23:38:09 +08:00
|
|
|
}
|
|
|
|
|
2020-04-29 00:14:29 +08:00
|
|
|
// getListenerFdMap retrieves and returns the socket file descriptors.
|
|
|
|
// The key of the returned map is "http" and "https".
|
2018-05-10 23:52:09 +08:00
|
|
|
func (s *Server) getListenerFdMap() map[string]string {
|
2019-06-19 09:06:52 +08:00
|
|
|
m := map[string]string{
|
|
|
|
"https": "",
|
|
|
|
"http": "",
|
|
|
|
}
|
|
|
|
for _, v := range s.servers {
|
2020-04-30 20:37:09 +08:00
|
|
|
str := v.address + "#" + gconv.String(v.Fd()) + ","
|
2019-06-19 09:06:52 +08:00
|
|
|
if v.isHttps {
|
2020-04-29 00:14:29 +08:00
|
|
|
if len(m["https"]) > 0 {
|
|
|
|
m["https"] += ","
|
|
|
|
}
|
2019-06-19 09:06:52 +08:00
|
|
|
m["https"] += str
|
|
|
|
} else {
|
2020-04-29 00:14:29 +08:00
|
|
|
if len(m["http"]) > 0 {
|
|
|
|
m["http"] += ","
|
|
|
|
}
|
2019-06-19 09:06:52 +08:00
|
|
|
m["http"] += str
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return m
|
2018-05-10 19:16:41 +08:00
|
|
|
}
|
2022-02-22 14:12:09 +08:00
|
|
|
|
|
|
|
// GetListenedPort retrieves and returns one port which is listened by current server.
|
|
|
|
func (s *Server) GetListenedPort() int {
|
|
|
|
ports := s.GetListenedPorts()
|
|
|
|
if len(ports) > 0 {
|
|
|
|
return ports[0]
|
|
|
|
}
|
|
|
|
return 0
|
|
|
|
}
|
|
|
|
|
|
|
|
// GetListenedPorts retrieves and returns the ports which are listened by current server.
|
|
|
|
func (s *Server) GetListenedPorts() []int {
|
|
|
|
ports := make([]int, 0)
|
|
|
|
for _, server := range s.servers {
|
2022-02-22 20:49:09 +08:00
|
|
|
ports = append(ports, server.GetListenedPort())
|
2022-02-22 14:12:09 +08:00
|
|
|
}
|
|
|
|
return ports
|
|
|
|
}
|