reprogl

1
package main
2

3
import (
4
	"context"
5
	"errors"
6
	"fmt"
7
	"log"
8
	"net/http"
9
	"os"
10
	"os/signal"
11
	"runtime"
12
	"runtime/debug"
13
	"syscall"
14
	"time"
15

16
	"github.com/xelbot/reverse"
17
	"xelbot.com/reprogl/container"
18
	"xelbot.com/reprogl/middlewares"
19
	"xelbot.com/reprogl/services/oauth"
20
	"xelbot.com/reprogl/views"
21
)
22

23
func main() {
24
	var err error
25
	infoLog := log.New(os.Stdout, "INFO\t", log.Ldate|log.Ltime|log.Lmicroseconds)
26
	errorLog := log.New(os.Stderr, "ERROR\t", log.Ldate|log.Ltime|log.Lshortfile)
27

28
	infoLog.Printf("Version: %s (tag: %s)", container.Version, container.GetBuildTag())
29
	infoLog.Printf("Build time: %s", container.BuildTimeRFC1123())
30
	infoLog.Printf("Go version: %s", runtime.Version())
31

32
	handleError(container.Load("app.ini"), errorLog)
33

34
	app := &container.Application{
35
		ErrorLog: errorLog,
36
		InfoLog:  infoLog,
37
	}
38

39
	handleError(app.SetupDatabase(), errorLog)
40

41
	router := getRoutes(app)
42
	handler := middlewares.Session(router, infoLog)
43
	handler = middlewares.Clacks().Middleware(handler)
44
	handler = middlewares.CDN(handler)
45
	handler = middlewares.Recover(handler, app)
46
	handler = middlewares.Track(handler, app)
47
	handler = middlewares.AccessLog(handler, app)
48
	handler = middlewares.ResponseWrapper(handler)
49

50
	cfg := container.GetConfig()
51

52
	urlGenerator := func(routeName string, absoluteURL bool, pairs ...string) string {
53
		var url string
54
		url, err = reverse.Get(routeName, pairs...)
55
		if err != nil {
56
			errorLog.Printf("[urlGenerator] URL generation error for: %s", routeName)
57
			url = "/error"
58
		}
59

60
		var prefix string
61
		if absoluteURL {
62
			prefix = "https://" + cfg.Host
63
		}
64

65
		return prefix + url
66
	}
67

68
	container.SetURLGenerator(urlGenerator)
69
	handleError(views.LoadViewSet(), errorLog)
70

71
	oauth.SetLogger(infoLog)
72

73
	server := &http.Server{
74
		Handler:      handler,
75
		Addr:         ":" + cfg.Port,
76
		WriteTimeout: 10 * time.Second,
77
		ReadTimeout:  10 * time.Second,
78
	}
79

80
	go func() {
81
		infoLog.Printf("Starting server on %s port", cfg.Port)
82
		err = server.ListenAndServe()
83
		if !errors.Is(err, http.ErrServerClosed) {
84
			handleError(err, errorLog)
85
		}
86
	}()
87

88
	exit := make(chan os.Signal, 1)
89
	signal.Notify(exit, os.Interrupt, syscall.SIGTERM)
90

91
	<-exit
92

93
	infoLog.Print("Shutting down...")
94
	err = server.Shutdown(context.Background())
95
	if err != nil {
96
		errorLog.Fatal(err)
97
	}
98
	infoLog.Print("Server stopped")
99

100
	err = app.Stop()
101
	if err != nil {
102
		errorLog.Fatal(err)
103
	}
104
	infoLog.Print("Application stopped")
105
}
106

107
func handleError(err error, logger *log.Logger) {
108
	if err != nil {
109
		logger.Println(fmt.Sprintf("%s", debug.Stack()))
110
		logger.Fatal(err)
111
	}
112
}
113