reprogl

1
package container
2

3
import (
4
	"database/sql"
5
	"fmt"
6
	"log"
7
	"net/http"
8
	"regexp"
9
	"runtime"
10
	"runtime/debug"
11
	"time"
12

13
	"github.com/xelbot/yetacache"
14
)
15

16
var Version string
17
var GitRevision string
18
var BuildTime string
19
var GoVersionNumbers string
20

21
type URLGenerator func(string, bool, ...string) string
22

23
type Application struct {
24
	ErrorLog *log.Logger
25
	InfoLog  *log.Logger
26
	DB       *sql.DB
27

28
	intCache *yetacache.Cache[string, int]
29
	strCache *yetacache.Cache[string, string]
30
}
31

32
var urlGen URLGenerator
33

34
func init() {
35
	re := regexp.MustCompile(`^\D*(\d+\.\d+(?:\.\d+)?)`)
36
	GoVersionNumbers = re.FindStringSubmatch(runtime.Version())[1]
37

38
	checkBuildFlags()
39
}
40

41
func checkBuildFlags() {
42
	if len(Version) == 0 {
43
		panic("ldflags: xelbot.com/reprogl/container.Version is empty")
44
	}
45
	if len(GitRevision) == 0 {
46
		panic("ldflags: xelbot.com/reprogl/container.GitRevision is empty")
47
	}
48

49
	_, err := time.Parse(time.RFC3339, BuildTime)
50
	if err != nil {
51
		panic("ldflags: xelbot.com/reprogl/container.BuildTime wrong format")
52
	}
53
}
54

55
func BuildTimeRFC1123() string {
56
	t, _ := time.Parse(time.RFC3339, BuildTime)
57

58
	return t.Format(time.RFC1123)
59
}
60

61
func SetURLGenerator(u URLGenerator) {
62
	urlGen = u
63
}
64

65
func GenerateURL(routeName string, pairs ...string) string {
66
	return urlGen(routeName, false, pairs...)
67
}
68

69
func GenerateAbsoluteURL(routeName string, pairs ...string) string {
70
	return urlGen(routeName, true, pairs...)
71
}
72

73
func (app *Application) NotFound(w http.ResponseWriter) {
74
	app.ClientError(w, http.StatusNotFound)
75
}
76

77
func (app *Application) ServerError(w http.ResponseWriter, err error) {
78
	trace := fmt.Sprintf("%s\n%s", err.Error(), debug.Stack())
79
	app.ErrorLog.Println(trace)
80

81
	http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
82
}
83

84
func (app *Application) ClientError(w http.ResponseWriter, status int) {
85
	http.Error(w, http.StatusText(status), status)
86
}
87

88
func (app *Application) LogError(err error) {
89
	trace := fmt.Sprintf("%s\n%s", err.Error(), debug.Stack())
90
	app.ErrorLog.Println(trace)
91
}
92

93
func (app *Application) GetIntCache() *yetacache.Cache[string, int] {
94
	if app.intCache == nil {
95
		app.InfoLog.Println("[CACHE] create integer instance")
96
		app.intCache = yetacache.New[string, int](time.Hour, 8*time.Hour)
97
	}
98

99
	return app.intCache
100
}
101

102
func (app *Application) GetStringCache() *yetacache.Cache[string, string] {
103
	if app.strCache == nil {
104
		app.InfoLog.Println("[CACHE] create string instance")
105
		app.strCache = yetacache.New[string, string](time.Hour, 8*time.Hour)
106
	}
107

108
	return app.strCache
109
}
110

111
func (app *Application) Stop() error {
112
	err := app.DB.Close()
113
	if err != nil {
114
		return err
115
	}
116
	app.InfoLog.Print("The database connection is closed")
117

118
	return nil
119
}
120