2022-07-14 17:18:08 +01:00
|
|
|
package main
|
|
|
|
|
|
|
|
import (
|
|
|
|
"fmt"
|
|
|
|
"github.com/joho/godotenv"
|
|
|
|
"golang.captainalm.com/cityuni-webserver/conf"
|
2022-07-14 18:07:07 +01:00
|
|
|
"golang.captainalm.com/cityuni-webserver/pageHandler"
|
2022-07-14 17:18:08 +01:00
|
|
|
"gopkg.in/yaml.v3"
|
|
|
|
"log"
|
|
|
|
"net"
|
|
|
|
"net/http"
|
2022-07-14 18:07:07 +01:00
|
|
|
"net/http/fcgi"
|
2022-07-14 17:18:08 +01:00
|
|
|
"os"
|
|
|
|
"os/signal"
|
|
|
|
"path"
|
|
|
|
"path/filepath"
|
|
|
|
"strings"
|
|
|
|
"sync"
|
|
|
|
"syscall"
|
|
|
|
"time"
|
|
|
|
)
|
|
|
|
|
|
|
|
var (
|
|
|
|
buildVersion = "develop"
|
|
|
|
buildDate = ""
|
|
|
|
)
|
|
|
|
|
|
|
|
func main() {
|
|
|
|
log.Printf("[Main] Starting up GO Package Header Server #%s (%s)\n", buildVersion, buildDate)
|
|
|
|
y := time.Now()
|
|
|
|
|
|
|
|
//Hold main thread till safe shutdown exit:
|
|
|
|
wg := &sync.WaitGroup{}
|
|
|
|
wg.Add(1)
|
|
|
|
|
|
|
|
//Get working directory:
|
|
|
|
cwdDir, err := os.Getwd()
|
|
|
|
if err != nil {
|
|
|
|
log.Println(err)
|
|
|
|
}
|
|
|
|
|
|
|
|
//Load environment file:
|
|
|
|
err = godotenv.Load()
|
|
|
|
if err != nil {
|
|
|
|
log.Fatalln("Error loading .env file")
|
|
|
|
}
|
|
|
|
|
|
|
|
//Data directory processing:
|
|
|
|
dataDir := os.Getenv("DIR_DATA")
|
|
|
|
if dataDir == "" {
|
|
|
|
dataDir = path.Join(cwdDir, ".data")
|
|
|
|
}
|
|
|
|
|
|
|
|
check(os.MkdirAll(dataDir, 0777))
|
|
|
|
|
|
|
|
//Config file processing:
|
|
|
|
configLocation := os.Getenv("CONFIG_FILE")
|
|
|
|
if configLocation == "" {
|
|
|
|
configLocation = path.Join(dataDir, "config.yml")
|
|
|
|
} else {
|
|
|
|
if !filepath.IsAbs(configLocation) {
|
|
|
|
configLocation = path.Join(dataDir, configLocation)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
//Config loading:
|
|
|
|
configFile, err := os.Open(configLocation)
|
|
|
|
if err != nil {
|
|
|
|
log.Fatalln("Failed to open config.yml")
|
|
|
|
}
|
|
|
|
|
|
|
|
var configYml conf.ConfigYaml
|
|
|
|
groupsDecoder := yaml.NewDecoder(configFile)
|
|
|
|
err = groupsDecoder.Decode(&configYml)
|
|
|
|
if err != nil {
|
|
|
|
log.Fatalln("Failed to parse config.yml:", err)
|
|
|
|
}
|
|
|
|
|
|
|
|
//Server definitions:
|
|
|
|
var webServer *http.Server
|
|
|
|
var fcgiListen net.Listener
|
|
|
|
switch strings.ToLower(configYml.Listen.WebMethod) {
|
|
|
|
case "http":
|
2022-07-14 18:07:07 +01:00
|
|
|
webServer = &http.Server{
|
|
|
|
Handler: pageHandler.GetRouter(configYml),
|
|
|
|
ReadTimeout: configYml.Listen.ReadTimeout,
|
|
|
|
ReadHeaderTimeout: configYml.Listen.WriteTimeout,
|
|
|
|
}
|
|
|
|
go runBackgroundHttp(webServer, getListener(configYml, cwdDir), false)
|
2022-07-14 17:18:08 +01:00
|
|
|
case "fcgi":
|
|
|
|
fcgiListen = getListener(configYml, cwdDir)
|
|
|
|
if fcgiListen == nil {
|
|
|
|
log.Fatalln("Listener Nil")
|
|
|
|
} else {
|
2022-07-14 18:07:07 +01:00
|
|
|
go runBackgroundFCgi(pageHandler.GetRouter(configYml), fcgiListen)
|
2022-07-14 17:18:08 +01:00
|
|
|
}
|
|
|
|
default:
|
|
|
|
log.Fatalln("Unknown Web Method.")
|
|
|
|
}
|
|
|
|
|
|
|
|
//=====================
|
|
|
|
// Safe shutdown
|
|
|
|
sigs := make(chan os.Signal, 1)
|
|
|
|
signal.Notify(sigs, syscall.SIGINT, syscall.SIGTERM)
|
|
|
|
|
|
|
|
//Startup complete:
|
|
|
|
z := time.Now().Sub(y)
|
|
|
|
log.Printf("[Main] Took '%s' to fully initialize modules\n", z.String())
|
|
|
|
|
|
|
|
go func() {
|
|
|
|
<-sigs
|
|
|
|
fmt.Printf("\n")
|
|
|
|
|
|
|
|
log.Printf("[Main] Attempting safe shutdown\n")
|
|
|
|
a := time.Now()
|
|
|
|
|
|
|
|
if webServer != nil {
|
|
|
|
log.Printf("[Main] Shutting down HTTP server...\n")
|
|
|
|
err := webServer.Close()
|
|
|
|
if err != nil {
|
|
|
|
log.Println(err)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if fcgiListen != nil {
|
|
|
|
log.Printf("[Main] Shutting down FCGI server...\n")
|
|
|
|
err := fcgiListen.Close()
|
|
|
|
if err != nil {
|
|
|
|
log.Println(err)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
log.Printf("[Main] Signalling program exit...\n")
|
|
|
|
b := time.Now().Sub(a)
|
|
|
|
log.Printf("[Main] Took '%s' to fully shutdown modules\n", b.String())
|
|
|
|
wg.Done()
|
|
|
|
}()
|
|
|
|
//
|
|
|
|
//=====================
|
|
|
|
wg.Wait()
|
|
|
|
log.Println("[Main] Goodbye")
|
|
|
|
//os.Exit(0)
|
|
|
|
}
|
|
|
|
|
|
|
|
func check(err error) {
|
|
|
|
if err != nil {
|
|
|
|
panic(err)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func getListener(config conf.ConfigYaml, cwd string) net.Listener {
|
|
|
|
split := strings.Split(strings.ToLower(config.Listen.WebNetwork), ":")
|
|
|
|
if len(split) == 0 {
|
|
|
|
log.Fatalln("Invalid Web Network")
|
|
|
|
return nil
|
|
|
|
} else {
|
|
|
|
var theListener net.Listener
|
|
|
|
var theError error
|
|
|
|
log.Println("[Main] Socket Network Type:" + split[0])
|
|
|
|
log.Printf("[Main] Starting up %s server on %s...\n", config.Listen.WebMethod, config.Listen.Web)
|
|
|
|
switch split[0] {
|
|
|
|
case "tcp", "tcp4", "tcp6", "udp", "udp4", "udp6", "ip", "ip4", "ip6":
|
|
|
|
theListener, theError = net.Listen(strings.ToLower(config.Listen.WebNetwork), config.Listen.Web)
|
|
|
|
case "unix", "unixgram", "unixpacket":
|
|
|
|
socketPath := config.Listen.Web
|
|
|
|
if !filepath.IsAbs(socketPath) {
|
|
|
|
if !filepath.IsAbs(cwd) {
|
|
|
|
log.Fatalln("Web Path Not Absolute And No Working Directory.")
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
socketPath = path.Join(cwd, socketPath)
|
|
|
|
}
|
|
|
|
log.Println("[Main] Removing old socket.")
|
|
|
|
if err := os.RemoveAll(socketPath); err != nil {
|
|
|
|
log.Fatalln("Could Not Remove Old Socket.")
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
theListener, theError = net.Listen(strings.ToLower(config.Listen.WebNetwork), config.Listen.Web)
|
|
|
|
default:
|
|
|
|
log.Fatalln("Unknown Web Network.")
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
if theError != nil {
|
|
|
|
log.Fatalln("Failed to listen due to:", theError)
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
return theListener
|
|
|
|
}
|
|
|
|
}
|
2022-07-14 18:07:07 +01:00
|
|
|
|
|
|
|
func runBackgroundHttp(s *http.Server, l net.Listener, tlsEnabled bool) {
|
|
|
|
var err error
|
|
|
|
if tlsEnabled {
|
|
|
|
err = s.ServeTLS(l, "", "")
|
|
|
|
} else {
|
|
|
|
err = s.Serve(l)
|
|
|
|
}
|
|
|
|
if err != nil {
|
|
|
|
if err == http.ErrServerClosed {
|
|
|
|
log.Println("The http server shutdown successfully")
|
|
|
|
} else {
|
|
|
|
log.Fatalf("[Http] Error trying to host the http server: %s\n", err.Error())
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func runBackgroundFCgi(h http.Handler, l net.Listener) {
|
|
|
|
err := fcgi.Serve(l, h)
|
|
|
|
if err != nil {
|
|
|
|
if err == net.ErrClosed {
|
|
|
|
log.Println("The fcgi server shutdown successfully")
|
|
|
|
} else {
|
|
|
|
log.Fatalf("[Http] Error trying to host the fcgi server: %s\n", err.Error())
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|