110 lines
2.7 KiB
Go
110 lines
2.7 KiB
Go
package main
|
|
|
|
import (
|
|
"encoding/json"
|
|
"net/http"
|
|
"os"
|
|
|
|
"git.pyer.club/kingecg/gohttpd/admin"
|
|
handler "git.pyer.club/kingecg/gohttpd/hander"
|
|
"git.pyer.club/kingecg/gohttpd/model"
|
|
"git.pyer.club/kingecg/gohttpd/server"
|
|
"git.pyer.club/kingecg/gohttpd/utils"
|
|
"git.pyer.club/kingecg/gologger"
|
|
)
|
|
|
|
type GoHttp struct {
|
|
logger gologger.Logger
|
|
}
|
|
|
|
func (g *GoHttp) Start() {
|
|
conf := model.GetConfig()
|
|
g.logger = gologger.GetLogger("Server")
|
|
g.logger.Info("start gohttpd")
|
|
// if g.conf != nil {
|
|
adminHandler := g.assembleServerMux(conf.Admin.Paths)
|
|
adminHandler.(*http.ServeMux).Handle("/api/", http.StripPrefix("/api", admin.AdminServerMux))
|
|
g.makeServer(conf.Admin, adminHandler)
|
|
|
|
for _, server := range conf.Servers {
|
|
sHandler := g.assembleServerMux(server.Paths)
|
|
g.makeServer(server, sHandler)
|
|
}
|
|
|
|
for _, listener := range server.ServerManager {
|
|
listener.Start()
|
|
listener.Serve()
|
|
|
|
}
|
|
g.logger.Info("gohttpd start success")
|
|
}
|
|
|
|
func (g *GoHttp) makeServer(conf *model.HttpServerConfig, mux http.Handler) {
|
|
s := &http.Server{
|
|
Handler: mux,
|
|
}
|
|
name := conf.Name
|
|
port := conf.Port
|
|
ss := &server.Server{
|
|
Server: s,
|
|
Conf: conf,
|
|
}
|
|
server.AddServer(name, ss, port)
|
|
}
|
|
|
|
func (g *GoHttp) assembleServerMux(p []model.HttpPath) http.Handler {
|
|
s := http.NewServeMux()
|
|
for _, httpPath := range p {
|
|
if httpPath.Root != "" {
|
|
fileHandler := handler.NewFileHandler(handler.FileHandler{
|
|
Root: httpPath.Root,
|
|
Default: httpPath.Default,
|
|
})
|
|
s.Handle(httpPath.Path, fileHandler)
|
|
} else if len(httpPath.Upstreams) != 0 {
|
|
proxyHandler := handler.NewProxyHandler(&httpPath)
|
|
s.Handle(httpPath.Path, proxyHandler)
|
|
} else {
|
|
g.logger.Error("Not supportted server path type :", httpPath.Path)
|
|
}
|
|
}
|
|
return s
|
|
}
|
|
|
|
func (g *GoHttp) Stop() {}
|
|
|
|
func LoadConfig() {
|
|
cpath := utils.NormalizePath("./config.json")
|
|
|
|
// read content from cpath
|
|
content, _ := os.ReadFile(cpath)
|
|
json.Unmarshal(content, &model.Config)
|
|
//normalize path in config
|
|
for _, appender := range model.Config.Logging.Appenders {
|
|
if appender.Type == "file" {
|
|
appender.Options["file"] = utils.NormalizePath(appender.Options["file"].(string))
|
|
}
|
|
}
|
|
normalizeServer(model.Config.Admin)
|
|
for _, server := range model.Config.Servers {
|
|
normalizeServer(server)
|
|
}
|
|
gologger.Configure(model.Config.Logging)
|
|
logger := gologger.GetLogger("Server")
|
|
logger.Info("Load config success")
|
|
}
|
|
|
|
func normalizeServer(server *model.HttpServerConfig) {
|
|
for index, path := range server.Paths {
|
|
if path.Root != "" {
|
|
server.Paths[index].Root = utils.NormalizePath(path.Root)
|
|
}
|
|
}
|
|
if server.CertFile != "" {
|
|
server.CertFile = utils.NormalizePath(server.CertFile)
|
|
}
|
|
if server.KeyFile != "" {
|
|
server.KeyFile = utils.NormalizePath(server.KeyFile)
|
|
}
|
|
}
|